Merge pull request #3125 from nrjais/editor-api

Improve `cursor` API in `Editor` and add `move_to` method

core/src/renderer/null.rs

@@ -166,14 +166,17 @@ impl text::Editor for () {
     }
 
     fn cursor(&self) -> text::editor::Cursor {
-        text::editor::Cursor::Caret(Point::ORIGIN)
+        text::editor::Cursor {
+            position: text::editor::Position { line: 0, column: 0 },
+            selection: None,
+        }
     }
 
-    fn cursor_position(&self) -> (usize, usize) {
+    fn selection(&self) -> text::editor::Selection {
-        (0, 0)
+        text::editor::Selection::Caret(Point::ORIGIN)
     }
 
-    fn selection(&self) -> Option<String> {
+    fn copy(&self) -> Option<String> {
         None
     }
 
@@ -187,6 +190,8 @@ impl text::Editor for () {
 
     fn perform(&mut self, _action: text::editor::Action) {}
 
+    fn move_to(&mut self, _cursor: text::editor::Cursor) {}
+
     fn bounds(&self) -> Size {
         Size::ZERO
     }

core/src/text/editor.rs

@@ -20,13 +20,11 @@ pub trait Editor: Sized + Default {
     /// Returns the current [`Cursor`] of the [`Editor`].
     fn cursor(&self) -> Cursor;
 
-    /// Returns the current cursor position of the [`Editor`].
+    /// Returns the current [`Selection`] of the [`Editor`].
-    ///
+    fn selection(&self) -> Selection;
-    /// Line and column, respectively.
-    fn cursor_position(&self) -> (usize, usize);
 
     /// Returns the current selected text of the [`Editor`].
-    fn selection(&self) -> Option<String>;
+    fn copy(&self) -> Option<String>;
 
     /// Returns the text of the given line in the [`Editor`], if it exists.
     fn line(&self, index: usize) -> Option<Line<'_>>;
@@ -37,6 +35,9 @@ pub trait Editor: Sized + Default {
     /// Performs an [`Action`] on the [`Editor`].
     fn perform(&mut self, action: Action);
 
+    /// Moves the cursor to the given position.
+    fn move_to(&mut self, cursor: Cursor);
+
     /// Returns the current boundaries of the [`Editor`].
     fn bounds(&self) -> Size;
 
@@ -187,12 +188,31 @@ pub enum Direction {
 
 /// The cursor of an [`Editor`].
 #[derive(Debug, Clone)]
-pub enum Cursor {
+pub enum Selection {
     /// Cursor without a selection
     Caret(Point),
 
     /// Cursor selecting a range of text
-    Selection(Vec<Rectangle>),
+    Range(Vec<Rectangle>),
+}
+
+/// The range of an [`Editor`].
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Cursor {
+    /// The cursor position.
+    pub position: Position,
+
+    /// The selection position, if any.
+    pub selection: Option<Position>,
+}
+
+/// A cursor position in an [`Editor`].
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Position {
+    /// The line of text.
+    pub line: usize,
+    /// The column in the line.
+    pub column: usize,
 }
 
 /// A line of an [`Editor`].

examples/editor/src/main.rs

@@ -190,9 +190,13 @@ impl Editor {
             }),
             space::horizontal(),
             text({
-                let (line, column) = self.content.cursor_position();
+                let cursor = self.content.cursor();
 
-                format!("{}:{}", line + 1, column + 1)
+                format!(
+                    "{}:{}",
+                    cursor.position.line + 1,
+                    cursor.position.column + 1
+                )
             })
         ]
         .spacing(10);

graphics/src/text/editor.rs

@@ -1,6 +1,6 @@
 //! Draw and edit text.
 use crate::core::text::editor::{
-    self, Action, Cursor, Direction, Edit, Motion,
+    self, Action, Cursor, Direction, Edit, Motion, Position, Selection,
 };
 use crate::core::text::highlighter::{self, Highlighter};
 use crate::core::text::{LineHeight, Wrapping};
@@ -19,7 +19,7 @@ pub struct Editor(Option<Arc<Internal>>);
 
 struct Internal {
     editor: cosmic_text::Editor<'static>,
-    cursor: RwLock<Option<Cursor>>,
+    selection: RwLock<Option<Selection>>,
     font: Font,
     bounds: Size,
     topmost_line_changed: Option<usize>,
@@ -56,6 +56,31 @@ impl Editor {
             .as_ref()
             .expect("Editor should always be initialized")
     }
+
+    fn with_internal_mut<T>(
+        &mut self,
+        f: impl FnOnce(&mut Internal) -> T,
+    ) -> T {
+        let editor =
+            self.0.take().expect("Editor should always be initialized");
+
+        // TODO: Handle multiple strong references somehow
+        let mut internal = Arc::try_unwrap(editor)
+            .expect("Editor cannot have multiple strong references");
+
+        // Clear cursor cache
+        let _ = internal
+            .selection
+            .write()
+            .expect("Write to cursor cache")
+            .take();
+
+        let result = f(&mut internal);
+
+        self.0 = Some(Arc::new(internal));
+
+        result
+    }
 }
 
 impl editor::Editor for Editor {
@@ -109,14 +134,14 @@ impl editor::Editor for Editor {
         self.buffer().lines.len()
     }
 
-    fn selection(&self) -> Option<String> {
+    fn copy(&self) -> Option<String> {
         self.internal().editor.copy_selection()
     }
 
-    fn cursor(&self) -> editor::Cursor {
+    fn selection(&self) -> editor::Selection {
         let internal = self.internal();
 
-        if let Ok(Some(cursor)) = internal.cursor.read().as_deref() {
+        if let Ok(Some(cursor)) = internal.selection.read().as_deref() {
             return cursor.clone();
         }
 
@@ -166,7 +191,7 @@ impl editor::Editor for Editor {
                     })
                     .collect();
 
-                Cursor::Selection(regions)
+                Selection::Range(regions)
             }
             _ => {
                 let line_height = buffer.metrics().line_height;
@@ -234,7 +259,7 @@ impl editor::Editor for Editor {
                         layout.last().map(|line| line.w).unwrap_or(0.0),
                     ));
 
-                Cursor::Caret(Point::new(
+                Selection::Caret(Point::new(
                     offset,
                     (visual_lines_offset + visual_line as i32) as f32
                         * line_height
@@ -243,229 +268,266 @@ impl editor::Editor for Editor {
             }
         };
 
-        *internal.cursor.write().expect("Write to cursor cache") =
+        *internal.selection.write().expect("Write to cursor cache") =
             Some(cursor.clone());
 
         cursor
     }
 
-    fn cursor_position(&self) -> (usize, usize) {
+    fn cursor(&self) -> Cursor {
-        let cursor = self.internal().editor.cursor();
+        let editor = &self.internal().editor;
 
-        (cursor.line, cursor.index)
+        let position = {
+            let cursor = editor.cursor();
+
+            Position {
+                line: cursor.line,
+                column: cursor.index,
+            }
+        };
+
+        let selection = match editor.selection() {
+            cosmic_text::Selection::None => None,
+            cosmic_text::Selection::Normal(cursor)
+            | cosmic_text::Selection::Line(cursor)
+            | cosmic_text::Selection::Word(cursor) => Some(Position {
+                line: cursor.line,
+                column: cursor.index,
+            }),
+        };
+
+        Cursor {
+            position,
+            selection,
+        }
     }
 
     fn perform(&mut self, action: Action) {
         let mut font_system =
             text::font_system().write().expect("Write font system");
 
-        let editor =
+        self.with_internal_mut(|internal| {
-            self.0.take().expect("Editor should always be initialized");
+            let editor = &mut internal.editor;
 
-        // TODO: Handle multiple strong references somehow
+            match action {
-        let mut internal = Arc::try_unwrap(editor)
+                // Motion events
-            .expect("Editor cannot have multiple strong references");
+                Action::Move(motion) => {
+                    if let Some((start, end)) = editor.selection_bounds() {
+                        editor.set_selection(cosmic_text::Selection::None);
 
-        let editor = &mut internal.editor;
+                        match motion {
-
+                            // These motions are performed as-is even when a selection
-        // Clear cursor cache
+                            // is present
-        let _ = internal
+                            Motion::Home
-            .cursor
+                            | Motion::End
-            .write()
+                            | Motion::DocumentStart
-            .expect("Write to cursor cache")
+                            | Motion::DocumentEnd => {
-            .take();
+                                editor.action(
-
+                                    font_system.raw(),
-        match action {
+                                    cosmic_text::Action::Motion(to_motion(
-            // Motion events
+                                        motion,
-            Action::Move(motion) => {
+                                    )),
-                if let Some((start, end)) = editor.selection_bounds() {
+                                );
-                    editor.set_selection(cosmic_text::Selection::None);
+                            }
-
+                            // Other motions simply move the cursor to one end of the selection
-                    match motion {
+                            _ => editor.set_cursor(match motion.direction() {
-                        // These motions are performed as-is even when a selection
+                                Direction::Left => start,
-                        // is present
+                                Direction::Right => end,
-                        Motion::Home
+                            }),
-                        | Motion::End
-                        | Motion::DocumentStart
-                        | Motion::DocumentEnd => {
-                            editor.action(
-                                font_system.raw(),
-                                cosmic_text::Action::Motion(to_motion(motion)),
-                            );
                         }
-                        // Other motions simply move the cursor to one end of the selection
+                    } else {
-                        _ => editor.set_cursor(match motion.direction() {
+                        editor.action(
-                            Direction::Left => start,
+                            font_system.raw(),
-                            Direction::Right => end,
+                            cosmic_text::Action::Motion(to_motion(motion)),
-                        }),
+                        );
                     }
-                } else {
+                }
+
+                // Selection events
+                Action::Select(motion) => {
+                    let cursor = editor.cursor();
+
+                    if editor.selection_bounds().is_none() {
+                        editor.set_selection(cosmic_text::Selection::Normal(
+                            cursor,
+                        ));
+                    }
+
                     editor.action(
                         font_system.raw(),
                         cosmic_text::Action::Motion(to_motion(motion)),
                     );
+
+                    // Deselect if selection matches cursor position
+                    if let Some((start, end)) = editor.selection_bounds()
+                        && start.line == end.line
+                        && start.index == end.index
+                    {
+                        editor.set_selection(cosmic_text::Selection::None);
+                    }
                 }
-            }
+                Action::SelectWord => {
-
-            // Selection events
-            Action::Select(motion) => {
-                let cursor = editor.cursor();
-
-                if editor.selection_bounds().is_none() {
-                    editor
-                        .set_selection(cosmic_text::Selection::Normal(cursor));
-                }
-
-                editor.action(
-                    font_system.raw(),
-                    cosmic_text::Action::Motion(to_motion(motion)),
-                );
-
-                // Deselect if selection matches cursor position
-                if let Some((start, end)) = editor.selection_bounds()
-                    && start.line == end.line
-                    && start.index == end.index
-                {
-                    editor.set_selection(cosmic_text::Selection::None);
-                }
-            }
-            Action::SelectWord => {
-                let cursor = editor.cursor();
-
-                editor.set_selection(cosmic_text::Selection::Word(cursor));
-            }
-            Action::SelectLine => {
-                let cursor = editor.cursor();
-
-                editor.set_selection(cosmic_text::Selection::Line(cursor));
-            }
-            Action::SelectAll => {
-                let buffer = buffer_from_editor(editor);
-
-                if buffer.lines.len() > 1
-                    || buffer
-                        .lines
-                        .first()
-                        .is_some_and(|line| !line.text().is_empty())
-                {
                     let cursor = editor.cursor();
 
-                    editor.set_selection(cosmic_text::Selection::Normal(
+                    editor.set_selection(cosmic_text::Selection::Word(cursor));
-                        cosmic_text::Cursor {
+                }
-                            line: 0,
+                Action::SelectLine => {
-                            index: 0,
+                    let cursor = editor.cursor();
-                            ..cursor
-                        },
-                    ));
 
+                    editor.set_selection(cosmic_text::Selection::Line(cursor));
+                }
+                Action::SelectAll => {
+                    let buffer = buffer_from_editor(editor);
+
+                    if buffer.lines.len() > 1
+                        || buffer
+                            .lines
+                            .first()
+                            .is_some_and(|line| !line.text().is_empty())
+                    {
+                        let cursor = editor.cursor();
+
+                        editor.set_selection(cosmic_text::Selection::Normal(
+                            cosmic_text::Cursor {
+                                line: 0,
+                                index: 0,
+                                ..cursor
+                            },
+                        ));
+
+                        editor.action(
+                            font_system.raw(),
+                            cosmic_text::Action::Motion(
+                                cosmic_text::Motion::BufferEnd,
+                            ),
+                        );
+                    }
+                }
+
+                // Editing events
+                Action::Edit(edit) => {
+                    let topmost_line_before_edit = editor
+                        .selection_bounds()
+                        .map(|(start, _)| start)
+                        .unwrap_or_else(|| editor.cursor())
+                        .line;
+
+                    match edit {
+                        Edit::Insert(c) => {
+                            editor.action(
+                                font_system.raw(),
+                                cosmic_text::Action::Insert(c),
+                            );
+                        }
+                        Edit::Paste(text) => {
+                            editor.insert_string(&text, None);
+                        }
+                        Edit::Indent => {
+                            editor.action(
+                                font_system.raw(),
+                                cosmic_text::Action::Indent,
+                            );
+                        }
+                        Edit::Unindent => {
+                            editor.action(
+                                font_system.raw(),
+                                cosmic_text::Action::Unindent,
+                            );
+                        }
+                        Edit::Enter => {
+                            editor.action(
+                                font_system.raw(),
+                                cosmic_text::Action::Enter,
+                            );
+                        }
+                        Edit::Backspace => {
+                            editor.action(
+                                font_system.raw(),
+                                cosmic_text::Action::Backspace,
+                            );
+                        }
+                        Edit::Delete => {
+                            editor.action(
+                                font_system.raw(),
+                                cosmic_text::Action::Delete,
+                            );
+                        }
+                    }
+
+                    let cursor = editor.cursor();
+                    let selection_start = editor
+                        .selection_bounds()
+                        .map(|(start, _)| start)
+                        .unwrap_or(cursor);
+
+                    internal.topmost_line_changed = Some(
+                        selection_start.line.min(topmost_line_before_edit),
+                    );
+                }
+
+                // Mouse events
+                Action::Click(position) => {
                     editor.action(
                         font_system.raw(),
-                        cosmic_text::Action::Motion(
+                        cosmic_text::Action::Click {
-                            cosmic_text::Motion::BufferEnd,
+                            x: position.x as i32,
-                        ),
+                            y: position.y as i32,
+                        },
+                    );
+                }
+                Action::Drag(position) => {
+                    editor.action(
+                        font_system.raw(),
+                        cosmic_text::Action::Drag {
+                            x: position.x as i32,
+                            y: position.y as i32,
+                        },
+                    );
+
+                    // Deselect if selection matches cursor position
+                    if let Some((start, end)) = editor.selection_bounds()
+                        && start.line == end.line
+                        && start.index == end.index
+                    {
+                        editor.set_selection(cosmic_text::Selection::None);
+                    }
+                }
+                Action::Scroll { lines } => {
+                    editor.action(
+                        font_system.raw(),
+                        cosmic_text::Action::Scroll {
+                            pixels: lines as f32
+                                * buffer_from_editor(editor)
+                                    .metrics()
+                                    .line_height,
+                        },
                     );
                 }
             }
+        });
+    }
 
-            // Editing events
+    fn move_to(&mut self, cursor: Cursor) {
-            Action::Edit(edit) => {
+        self.with_internal_mut(|internal| {
-                let topmost_line_before_edit = editor
+            // TODO: Expose `Affinity`
-                    .selection_bounds()
+            internal.editor.set_cursor(cosmic_text::Cursor {
-                    .map(|(start, _)| start)
+                line: cursor.position.line,
-                    .unwrap_or_else(|| editor.cursor())
+                index: cursor.position.column,
-                    .line;
+                affinity: cosmic_text::Affinity::Before,
+            });
 
-                match edit {
+            if let Some(selection) = cursor.selection {
-                    Edit::Insert(c) => {
+                internal
-                        editor.action(
+                    .editor
-                            font_system.raw(),
+                    .set_selection(cosmic_text::Selection::Normal(
-                            cosmic_text::Action::Insert(c),
+                        cosmic_text::Cursor {
-                        );
+                            line: selection.line,
-                    }
+                            index: selection.column,
-                    Edit::Paste(text) => {
+                            affinity: cosmic_text::Affinity::Before,
-                        editor.insert_string(&text, None);
+                        },
-                    }
+                    ));
-                    Edit::Indent => {
-                        editor.action(
-                            font_system.raw(),
-                            cosmic_text::Action::Indent,
-                        );
-                    }
-                    Edit::Unindent => {
-                        editor.action(
-                            font_system.raw(),
-                            cosmic_text::Action::Unindent,
-                        );
-                    }
-                    Edit::Enter => {
-                        editor.action(
-                            font_system.raw(),
-                            cosmic_text::Action::Enter,
-                        );
-                    }
-                    Edit::Backspace => {
-                        editor.action(
-                            font_system.raw(),
-                            cosmic_text::Action::Backspace,
-                        );
-                    }
-                    Edit::Delete => {
-                        editor.action(
-                            font_system.raw(),
-                            cosmic_text::Action::Delete,
-                        );
-                    }
-                }
-
-                let cursor = editor.cursor();
-                let selection_start = editor
-                    .selection_bounds()
-                    .map(|(start, _)| start)
-                    .unwrap_or(cursor);
-
-                internal.topmost_line_changed =
-                    Some(selection_start.line.min(topmost_line_before_edit));
             }
-
+        });
-            // Mouse events
-            Action::Click(position) => {
-                editor.action(
-                    font_system.raw(),
-                    cosmic_text::Action::Click {
-                        x: position.x as i32,
-                        y: position.y as i32,
-                    },
-                );
-            }
-            Action::Drag(position) => {
-                editor.action(
-                    font_system.raw(),
-                    cosmic_text::Action::Drag {
-                        x: position.x as i32,
-                        y: position.y as i32,
-                    },
-                );
-
-                // Deselect if selection matches cursor position
-                if let Some((start, end)) = editor.selection_bounds()
-                    && start.line == end.line
-                    && start.index == end.index
-                {
-                    editor.set_selection(cosmic_text::Selection::None);
-                }
-            }
-            Action::Scroll { lines } => {
-                editor.action(
-                    font_system.raw(),
-                    cosmic_text::Action::Scroll {
-                        pixels: lines as f32
-                            * buffer_from_editor(editor).metrics().line_height,
-                    },
-                );
-            }
-        }
-
-        self.0 = Some(Arc::new(internal));
     }
 
     fn bounds(&self) -> Size {
@@ -490,94 +552,83 @@ impl editor::Editor for Editor {
         new_wrapping: Wrapping,
         new_highlighter: &mut impl Highlighter,
     ) {
-        let editor =
+        self.with_internal_mut(|internal| {
-            self.0.take().expect("Editor should always be initialized");
+            let mut font_system =
+                text::font_system().write().expect("Write font system");
 
-        let mut internal = Arc::try_unwrap(editor)
+            let buffer = buffer_mut_from_editor(&mut internal.editor);
-            .expect("Editor cannot have multiple strong references");
 
-        let mut font_system =
+            if font_system.version() != internal.version {
-            text::font_system().write().expect("Write font system");
+                log::trace!("Updating `FontSystem` of `Editor`...");
 
-        let buffer = buffer_mut_from_editor(&mut internal.editor);
+                for line in buffer.lines.iter_mut() {
+                    line.reset();
+                }
 
-        if font_system.version() != internal.version {
+                internal.version = font_system.version();
-            log::trace!("Updating `FontSystem` of `Editor`...");
+                internal.topmost_line_changed = Some(0);
-
-            for line in buffer.lines.iter_mut() {
-                line.reset();
             }
 
-            internal.version = font_system.version();
+            if new_font != internal.font {
-            internal.topmost_line_changed = Some(0);
+                log::trace!("Updating font of `Editor`...");
-        }
 
-        if new_font != internal.font {
+                for line in buffer.lines.iter_mut() {
-            log::trace!("Updating font of `Editor`...");
+                    let _ = line.set_attrs_list(cosmic_text::AttrsList::new(
+                        &text::to_attributes(new_font),
+                    ));
+                }
 
-            for line in buffer.lines.iter_mut() {
+                internal.font = new_font;
-                let _ = line.set_attrs_list(cosmic_text::AttrsList::new(
+                internal.topmost_line_changed = Some(0);
-                    &text::to_attributes(new_font),
-                ));
             }
 
-            internal.font = new_font;
+            let metrics = buffer.metrics();
-            internal.topmost_line_changed = Some(0);
+            let new_line_height = new_line_height.to_absolute(new_size);
-        }
 
-        let metrics = buffer.metrics();
+            if new_size.0 != metrics.font_size
-        let new_line_height = new_line_height.to_absolute(new_size);
+                || new_line_height.0 != metrics.line_height
+            {
+                log::trace!("Updating `Metrics` of `Editor`...");
 
-        if new_size.0 != metrics.font_size
+                buffer.set_metrics(
-            || new_line_height.0 != metrics.line_height
+                    font_system.raw(),
-        {
+                    cosmic_text::Metrics::new(new_size.0, new_line_height.0),
-            log::trace!("Updating `Metrics` of `Editor`...");
+                );
+            }
 
-            buffer.set_metrics(
+            let new_wrap = text::to_wrap(new_wrapping);
-                font_system.raw(),
-                cosmic_text::Metrics::new(new_size.0, new_line_height.0),
-            );
-        }
 
-        let new_wrap = text::to_wrap(new_wrapping);
+            if new_wrap != buffer.wrap() {
+                log::trace!("Updating `Wrap` strategy of `Editor`...");
 
-        if new_wrap != buffer.wrap() {
+                buffer.set_wrap(font_system.raw(), new_wrap);
-            log::trace!("Updating `Wrap` strategy of `Editor`...");
+            }
 
-            buffer.set_wrap(font_system.raw(), new_wrap);
+            if new_bounds != internal.bounds {
-        }
+                log::trace!("Updating size of `Editor`...");
 
-        if new_bounds != internal.bounds {
+                buffer.set_size(
-            log::trace!("Updating size of `Editor`...");
+                    font_system.raw(),
+                    Some(new_bounds.width),
+                    Some(new_bounds.height),
+                );
 
-            buffer.set_size(
+                internal.bounds = new_bounds;
-                font_system.raw(),
+            }
-                Some(new_bounds.width),
-                Some(new_bounds.height),
-            );
 
-            internal.bounds = new_bounds;
+            if let Some(topmost_line_changed) =
-        }
+                internal.topmost_line_changed.take()
+            {
+                log::trace!(
+                    "Notifying highlighter of line \
+                    change: {topmost_line_changed}"
+                );
 
-        if let Some(topmost_line_changed) = internal.topmost_line_changed.take()
+                new_highlighter.change_line(topmost_line_changed);
-        {
+            }
-            log::trace!(
-                "Notifying highlighter of line change: {topmost_line_changed}"
-            );
 
-            new_highlighter.change_line(topmost_line_changed);
+            internal.editor.shape_as_needed(font_system.raw(), false);
-        }
+        });
-
-        internal.editor.shape_as_needed(font_system.raw(), false);
-
-        // Clear cursor cache
-        let _ = internal
-            .cursor
-            .write()
-            .expect("Write to cursor cache")
-            .take();
-
-        self.0 = Some(Arc::new(internal));
     }
 
     fn highlight<H: Highlighter>(
@@ -685,7 +736,7 @@ impl Default for Internal {
                     line_height: 1.0,
                 },
             )),
-            cursor: RwLock::new(None),
+            selection: RwLock::new(None),
             font: Font::default(),
             bounds: Size::ZERO,
             topmost_line_changed: None,

widget/src/text_editor.rs

@@ -39,7 +39,7 @@ use crate::core::keyboard::key;
 use crate::core::layout::{self, Layout};
 use crate::core::mouse;
 use crate::core::renderer;
-use crate::core::text::editor::{Cursor, Editor as _};
+use crate::core::text::editor::Editor as _;
 use crate::core::text::highlighter::{self, Highlighter};
 use crate::core::text::{self, LineHeight, Text, Wrapping};
 use crate::core::theme;
@@ -55,11 +55,13 @@ use crate::core::{
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::fmt;
+use std::ops;
 use std::ops::DerefMut;
-use std::ops::Range;
 use std::sync::Arc;
 
-pub use text::editor::{Action, Edit, Line, LineEnding, Motion};
+pub use text::editor::{
+    Action, Cursor, Edit, Line, LineEnding, Motion, Position, Selection,
+};
 
 /// A multi-line text input.
 ///
@@ -354,9 +356,9 @@ where
         let text_bounds = bounds.shrink(self.padding);
         let translation = text_bounds.position() - Point::ORIGIN;
 
-        let cursor = match internal.editor.cursor() {
+        let cursor = match internal.editor.selection() {
-            Cursor::Caret(position) => position,
+            Selection::Caret(position) => position,
-            Cursor::Selection(ranges) => {
+            Selection::Range(ranges) => {
                 ranges.first().cloned().unwrap_or_default().position()
             }
         };
@@ -388,7 +390,6 @@ where
     R: text::Renderer,
 {
     editor: R::Editor,
-    is_dirty: bool,
 }
 
 impl<R> Content<R>
@@ -404,7 +405,6 @@ where
     pub fn with_text(text: &str) -> Self {
         Self(RefCell::new(Internal {
             editor: R::Editor::with_text(text),
-            is_dirty: true,
         }))
     }
 
@@ -413,7 +413,18 @@ where
         let internal = self.0.get_mut();
 
         internal.editor.perform(action);
-        internal.is_dirty = true;
+    }
+
+    /// Moves the current cursor to reflect the given one.
+    pub fn move_to(&mut self, cursor: Cursor) {
+        let internal = self.0.get_mut();
+
+        internal.editor.move_to(cursor);
+    }
+
+    /// Returns the current cursor position of the [`Content`].
+    pub fn cursor(&self) -> Cursor {
+        self.0.borrow().editor.cursor()
     }
 
     /// Returns the amount of lines of the [`Content`].
@@ -460,21 +471,16 @@ where
         contents
     }
 
+    /// Returns the selected text of the [`Content`].
+    pub fn selection(&self) -> Option<String> {
+        self.0.borrow().editor.copy()
+    }
+
     /// Returns the kind of [`LineEnding`] used for separating lines in the [`Content`].
     pub fn line_ending(&self) -> Option<LineEnding> {
         Some(self.line(0)?.ending)
     }
 
-    /// Returns the selected text of the [`Content`].
-    pub fn selection(&self) -> Option<String> {
-        self.0.borrow().editor.selection()
-    }
-
-    /// Returns the current cursor position of the [`Content`].
-    pub fn cursor_position(&self) -> (usize, usize) {
-        self.0.borrow().editor.cursor_position()
-    }
-
     /// Returns whether or not the the [`Content`] is empty.
     pub fn is_empty(&self) -> bool {
         self.0.borrow().editor.is_empty()
@@ -509,7 +515,6 @@ where
 
         f.debug_struct("Content")
             .field("editor", &internal.editor)
-            .field("is_dirty", &internal.is_dirty)
             .finish()
     }
 }
@@ -1014,8 +1019,8 @@ where
         let translation = text_bounds.position() - Point::ORIGIN;
 
         if let Some(focus) = state.focus.as_ref() {
-            match internal.editor.cursor() {
+            match internal.editor.selection() {
-                Cursor::Caret(position) if focus.is_cursor_visible() => {
+                Selection::Caret(position) if focus.is_cursor_visible() => {
                     let cursor =
                         Rectangle::new(
                             position + translation,
@@ -1041,7 +1046,7 @@ where
                         );
                     }
                 }
-                Cursor::Selection(ranges) => {
+                Selection::Range(ranges) => {
                     for range in ranges.into_iter().filter_map(|range| {
                         text_bounds.intersection(&(range + translation))
                     }) {
@@ -1054,7 +1059,7 @@ where
                         );
                     }
                 }
-                Cursor::Caret(_) => {}
+                Selection::Caret(_) => {}
             }
         }
     }
@@ -1265,7 +1270,7 @@ enum Ime {
     Toggle(bool),
     Preedit {
         content: String,
-        selection: Option<Range<usize>>,
+        selection: Option<ops::Range<usize>>,
     },
     Commit(String),
 }