Merge branch 'master' into remove-vertex-indexing

11 files changed, 1198 insertions, 179 deletions

diff --git a/graphics/src/backend.rs b/graphics/src/backend.rs
index c2ac82ba..10eb337f 100644
--- a/graphics/src/backend.rs
+++ b/graphics/src/backend.rs
@@ -2,7 +2,6 @@
 use crate::core::image;
 use crate::core::svg;
 use crate::core::Size;
-use crate::text;
 
 use std::borrow::Cow;
 
@@ -18,9 +17,6 @@ pub trait Backend {
 pub trait Text {
     /// Loads a font from its bytes.
     fn load_font(&mut self, font: Cow<'static, [u8]>);
-
-    /// Returns the [`cosmic_text::FontSystem`] of the [`Backend`].
-    fn font_system(&self) -> &text::FontSystem;
 }
 
 /// A graphics backend that supports image rendering.
diff --git a/graphics/src/compositor.rs b/graphics/src/compositor.rs
index 0222a80f..0188f4d8 100644
--- a/graphics/src/compositor.rs
+++ b/graphics/src/compositor.rs
@@ -2,9 +2,10 @@
 //! surfaces.
 use crate::{Error, Viewport};
 
-use iced_core::Color;
+use crate::core::Color;
+use crate::futures::{MaybeSend, MaybeSync};
 
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use thiserror::Error;
 
 /// A graphics compositor that can draw to windows.
@@ -19,17 +20,20 @@ pub trait Compositor: Sized {
     type Surface;
 
     /// Creates a new [`Compositor`].
-    fn new<W: HasRawWindowHandle + HasRawDisplayHandle>(
+    fn new<W: Window + Clone>(
         settings: Self::Settings,
-        compatible_window: Option<&W>,
-    ) -> Result<(Self, Self::Renderer), Error>;
+        compatible_window: W,
+    ) -> Result<Self, Error>;
+
+    /// Creates a [`Self::Renderer`] for the [`Compositor`].
+    fn create_renderer(&self) -> Self::Renderer;
 
     /// Crates a new [`Surface`] for the given window.
     ///
     /// [`Surface`]: Self::Surface
-    fn create_surface<W: HasRawWindowHandle + HasRawDisplayHandle>(
+    fn create_surface<W: Window + Clone>(
         &mut self,
-        window: &W,
+        window: W,
         width: u32,
         height: u32,
     ) -> Self::Surface;
@@ -74,6 +78,20 @@ pub trait Compositor: Sized {
     ) -> Vec<u8>;
 }
 
+/// A window that can be used in a [`Compositor`].
+///
+/// This is just a convenient super trait of the `raw-window-handle`
+/// traits.
+pub trait Window:
+    HasWindowHandle + HasDisplayHandle + MaybeSend + MaybeSync + 'static
+{
+}
+
+impl<T> Window for T where
+    T: HasWindowHandle + HasDisplayHandle + MaybeSend + MaybeSync + 'static
+{
+}
+
 /// Result of an unsuccessful call to [`Compositor::present`].
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
 pub enum SurfaceError {
diff --git a/graphics/src/damage.rs b/graphics/src/damage.rs
index 3276c2d4..59e9f5b4 100644
--- a/graphics/src/damage.rs
+++ b/graphics/src/damage.rs
@@ -66,6 +66,18 @@ impl<T: Damage> Damage for Primitive<T> {
 
                 bounds.expand(1.5)
             }
+            Self::Editor {
+                editor, position, ..
+            } => {
+                let bounds = Rectangle::new(*position, editor.bounds);
+
+                bounds.expand(1.5)
+            }
+            Self::RawText(raw) => {
+                // TODO: Add `size` field to `raw` to compute more accurate
+                // damage bounds (?)
+                raw.clip_bounds.expand(1.5)
+            }
             Self::Quad { bounds, .. }
             | Self::Image { bounds, .. }
             | Self::Svg { bounds, .. } => bounds.expand(1.0),
diff --git a/graphics/src/geometry/text.rs b/graphics/src/geometry/text.rs
index 0bf7ec97..d314e85e 100644
--- a/graphics/src/geometry/text.rs
+++ b/graphics/src/geometry/text.rs
@@ -1,6 +1,8 @@
 use crate::core::alignment;
 use crate::core::text::{LineHeight, Shaping};
-use crate::core::{Color, Font, Pixels, Point};
+use crate::core::{Color, Font, Pixels, Point, Size, Vector};
+use crate::geometry::Path;
+use crate::text;
 
 /// A bunch of text that can be drawn to a canvas
 #[derive(Debug, Clone)]
@@ -32,6 +34,137 @@ pub struct Text {
     pub shaping: Shaping,
 }
 
+impl Text {
+    /// Computes the [`Path`]s of the [`Text`] and draws them using
+    /// the given closure.
+    pub fn draw_with(&self, mut f: impl FnMut(Path, Color)) {
+        let mut font_system =
+            text::font_system().write().expect("Write font system");
+
+        let mut buffer = cosmic_text::BufferLine::new(
+            &self.content,
+            cosmic_text::AttrsList::new(text::to_attributes(self.font)),
+            text::to_shaping(self.shaping),
+        );
+
+        let layout = buffer.layout(
+            font_system.raw(),
+            self.size.0,
+            f32::MAX,
+            cosmic_text::Wrap::None,
+        );
+
+        let translation_x = match self.horizontal_alignment {
+            alignment::Horizontal::Left => self.position.x,
+            alignment::Horizontal::Center | alignment::Horizontal::Right => {
+                let mut line_width = 0.0f32;
+
+                for line in layout.iter() {
+                    line_width = line_width.max(line.w);
+                }
+
+                if self.horizontal_alignment == alignment::Horizontal::Center {
+                    self.position.x - line_width / 2.0
+                } else {
+                    self.position.x - line_width
+                }
+            }
+        };
+
+        let translation_y = {
+            let line_height = self.line_height.to_absolute(self.size);
+
+            match self.vertical_alignment {
+                alignment::Vertical::Top => self.position.y,
+                alignment::Vertical::Center => {
+                    self.position.y - line_height.0 / 2.0
+                }
+                alignment::Vertical::Bottom => self.position.y - line_height.0,
+            }
+        };
+
+        let mut swash_cache = cosmic_text::SwashCache::new();
+
+        for run in layout.iter() {
+            for glyph in run.glyphs.iter() {
+                let physical_glyph = glyph.physical((0.0, 0.0), 1.0);
+
+                let start_x = translation_x + glyph.x + glyph.x_offset;
+                let start_y = translation_y + glyph.y_offset + self.size.0;
+                let offset = Vector::new(start_x, start_y);
+
+                if let Some(commands) = swash_cache.get_outline_commands(
+                    font_system.raw(),
+                    physical_glyph.cache_key,
+                ) {
+                    let glyph = Path::new(|path| {
+                        use cosmic_text::Command;
+
+                        for command in commands {
+                            match command {
+                                Command::MoveTo(p) => {
+                                    path.move_to(
+                                        Point::new(p.x, -p.y) + offset,
+                                    );
+                                }
+                                Command::LineTo(p) => {
+                                    path.line_to(
+                                        Point::new(p.x, -p.y) + offset,
+                                    );
+                                }
+                                Command::CurveTo(control_a, control_b, to) => {
+                                    path.bezier_curve_to(
+                                        Point::new(control_a.x, -control_a.y)
+                                            + offset,
+                                        Point::new(control_b.x, -control_b.y)
+                                            + offset,
+                                        Point::new(to.x, -to.y) + offset,
+                                    );
+                                }
+                                Command::QuadTo(control, to) => {
+                                    path.quadratic_curve_to(
+                                        Point::new(control.x, -control.y)
+                                            + offset,
+                                        Point::new(to.x, -to.y) + offset,
+                                    );
+                                }
+                                Command::Close => {
+                                    path.close();
+                                }
+                            }
+                        }
+                    });
+
+                    f(glyph, self.color);
+                } else {
+                    // TODO: Raster image support for `Canvas`
+                    let [r, g, b, a] = self.color.into_rgba8();
+
+                    swash_cache.with_pixels(
+                        font_system.raw(),
+                        physical_glyph.cache_key,
+                        cosmic_text::Color::rgba(r, g, b, a),
+                        |x, y, color| {
+                            f(
+                                Path::rectangle(
+                                    Point::new(x as f32, y as f32) + offset,
+                                    Size::new(1.0, 1.0),
+                                ),
+                                Color::from_rgba8(
+                                    color.r(),
+                                    color.g(),
+                                    color.b(),
+                                    color.a() as f32 / 255.0,
+                                ),
+                            );
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
 impl Default for Text {
     fn default() -> Text {
         Text {
diff --git a/graphics/src/lib.rs b/graphics/src/lib.rs
index a0729058..76de56bf 100644
--- a/graphics/src/lib.rs
+++ b/graphics/src/lib.rs
@@ -10,7 +10,7 @@
 #![forbid(rust_2018_idioms)]
 #![deny(
     missing_debug_implementations,
-    //missing_docs,
+    missing_docs,
     unsafe_code,
     unused_results,
     rustdoc::broken_intra_doc_links
@@ -50,3 +50,4 @@ pub use transformation::Transformation;
 pub use viewport::Viewport;
 
 pub use iced_core as core;
+pub use iced_futures as futures;
diff --git a/graphics/src/primitive.rs b/graphics/src/primitive.rs
index 8a97e6e7..20affaaf 100644
--- a/graphics/src/primitive.rs
+++ b/graphics/src/primitive.rs
@@ -4,6 +4,7 @@ use crate::core::image;
 use crate::core::svg;
 use crate::core::text;
 use crate::core::{Background, Color, Font, Pixels, Point, Rectangle, Vector};
+use crate::text::editor;
 use crate::text::paragraph;
 
 use std::sync::Arc;
@@ -13,24 +14,26 @@ use std::sync::Arc;
 pub enum Primitive<T> {
     /// A text primitive
     Text {
-        /// The contents of the text
+        /// The contents of the text.
         content: String,
-        /// The bounds of the text
+        /// The bounds of the text.
         bounds: Rectangle,
-        /// The color of the text
+        /// The color of the text.
         color: Color,
-        /// The size of the text in logical pixels
+        /// The size of the text in logical pixels.
         size: Pixels,
-        /// The line height of the text
+        /// The line height of the text.
         line_height: text::LineHeight,
-        /// The font of the text
+        /// The font of the text.
         font: Font,
-        /// The horizontal alignment of the text
+        /// The horizontal alignment of the text.
         horizontal_alignment: alignment::Horizontal,
-        /// The vertical alignment of the text
+        /// The vertical alignment of the text.
         vertical_alignment: alignment::Vertical,
         /// The shaping strategy of the text.
         shaping: text::Shaping,
+        /// The clip bounds of the text.
+        clip_bounds: Rectangle,
     },
     /// A paragraph primitive
     Paragraph {
@@ -40,7 +43,22 @@ pub enum Primitive<T> {
         position: Point,
         /// The color of the paragraph.
         color: Color,
+        /// The clip bounds of the paragraph.
+        clip_bounds: Rectangle,
     },
+    /// An editor primitive
+    Editor {
+        /// The [`editor::Weak`] reference.
+        editor: editor::Weak,
+        /// The position of the editor.
+        position: Point,
+        /// The color of the editor.
+        color: Color,
+        /// The clip bounds of the editor.
+        clip_bounds: Rectangle,
+    },
+    /// A raw `cosmic-text` primitive
+    RawText(crate::text::Raw),
     /// A quad primitive
     Quad {
         /// The bounds of the quad
@@ -58,6 +76,8 @@ pub enum Primitive<T> {
     Image {
         /// The handle of the image
         handle: image::Handle,
+        /// The filter method of the image
+        filter_method: image::FilterMethod,
         /// The bounds of the image
         bounds: Rectangle,
     },
diff --git a/graphics/src/renderer.rs b/graphics/src/renderer.rs
index a9d7895e..1b0f5c5b 100644
--- a/graphics/src/renderer.rs
+++ b/graphics/src/renderer.rs
@@ -141,6 +141,7 @@ where
 {
     type Font = Font;
     type Paragraph = text::Paragraph;
+    type Editor = text::Editor;
 
     const ICON_FONT: Font = Font::with_name("Iced-Icons");
     const CHECKMARK_ICON: char = '\u{f00c}';
@@ -158,51 +159,33 @@ where
         self.backend.load_font(bytes);
     }
 
-    fn create_paragraph(&self, text: Text<'_, Self::Font>) -> text::Paragraph {
-        text::Paragraph::with_text(text, self.backend.font_system())
-    }
-
-    fn update_paragraph(
-        &self,
-        paragraph: &mut Self::Paragraph,
-        text: Text<'_, Self::Font>,
-    ) {
-        let font_system = self.backend.font_system();
-
-        if paragraph.version() != font_system.version() {
-            // The font system has changed, paragraph fonts may be outdated
-            *paragraph = self.create_paragraph(text);
-        } else {
-            match core::text::compare(paragraph, text) {
-                core::text::Difference::None => {}
-                core::text::Difference::Bounds => {
-                    self.resize_paragraph(paragraph, text.bounds);
-                }
-                core::text::Difference::Shape => {
-                    *paragraph = self.create_paragraph(text);
-                }
-            }
-        }
-    }
-
-    fn resize_paragraph(
-        &self,
-        paragraph: &mut Self::Paragraph,
-        new_bounds: Size,
-    ) {
-        paragraph.resize(new_bounds, self.backend.font_system());
-    }
-
     fn fill_paragraph(
         &mut self,
         paragraph: &Self::Paragraph,
         position: Point,
         color: Color,
+        clip_bounds: Rectangle,
     ) {
         self.primitives.push(Primitive::Paragraph {
             paragraph: paragraph.downgrade(),
             position,
             color,
+            clip_bounds,
+        });
+    }
+
+    fn fill_editor(
+        &mut self,
+        editor: &Self::Editor,
+        position: Point,
+        color: Color,
+        clip_bounds: Rectangle,
+    ) {
+        self.primitives.push(Primitive::Editor {
+            editor: editor.downgrade(),
+            position,
+            color,
+            clip_bounds,
         });
     }
 
@@ -211,6 +194,7 @@ where
         text: Text<'_, Self::Font>,
         position: Point,
         color: Color,
+        clip_bounds: Rectangle,
     ) {
         self.primitives.push(Primitive::Text {
             content: text.content.to_string(),
@@ -222,6 +206,7 @@ where
             horizontal_alignment: text.horizontal_alignment,
             vertical_alignment: text.vertical_alignment,
             shaping: text.shaping,
+            clip_bounds,
         });
     }
 }
@@ -236,8 +221,17 @@ where
         self.backend().dimensions(handle)
     }
 
-    fn draw(&mut self, handle: image::Handle, bounds: Rectangle) {
-        self.primitives.push(Primitive::Image { handle, bounds });
+    fn draw(
+        &mut self,
+        handle: image::Handle,
+        filter_method: image::FilterMethod,
+        bounds: Rectangle,
+    ) {
+        self.primitives.push(Primitive::Image {
+            handle,
+            filter_method,
+            bounds,
+        });
     }
 }
 
diff --git a/graphics/src/text.rs b/graphics/src/text.rs
index bc06aa3c..7c4b5e31 100644
--- a/graphics/src/text.rs
+++ b/graphics/src/text.rs
@@ -1,69 +1,96 @@
+//! Draw text.
 pub mod cache;
+pub mod editor;
 pub mod paragraph;
 
 pub use cache::Cache;
+pub use editor::Editor;
 pub use paragraph::Paragraph;
 
 pub use cosmic_text;
 
 use crate::core::font::{self, Font};
 use crate::core::text::Shaping;
-use crate::core::Size;
+use crate::core::{Color, Point, Rectangle, Size};
 
+use once_cell::sync::OnceCell;
 use std::borrow::Cow;
-use std::sync::{self, Arc, RwLock};
+use std::sync::{Arc, RwLock, Weak};
 
+/// Returns the global [`FontSystem`].
+pub fn font_system() -> &'static RwLock<FontSystem> {
+    static FONT_SYSTEM: OnceCell<RwLock<FontSystem>> = OnceCell::new();
+
+    FONT_SYSTEM.get_or_init(|| {
+        RwLock::new(FontSystem {
+            raw: cosmic_text::FontSystem::new_with_fonts([
+                cosmic_text::fontdb::Source::Binary(Arc::new(
+                    include_bytes!("../fonts/Iced-Icons.ttf").as_slice(),
+                )),
+            ]),
+            version: Version::default(),
+        })
+    })
+}
+
+/// A set of system fonts.
 #[allow(missing_debug_implementations)]
 pub struct FontSystem {
-    raw: RwLock<cosmic_text::FontSystem>,
+    raw: cosmic_text::FontSystem,
     version: Version,
 }
 
 impl FontSystem {
-    pub fn new() -> Self {
-        FontSystem {
-            raw: RwLock::new(cosmic_text::FontSystem::new_with_fonts(
-                [cosmic_text::fontdb::Source::Binary(Arc::new(
-                    include_bytes!("../fonts/Iced-Icons.ttf").as_slice(),
-                ))]
-                .into_iter(),
-            )),
-            version: Version::default(),
-        }
-    }
-
-    pub fn get_mut(&mut self) -> &mut cosmic_text::FontSystem {
-        self.raw.get_mut().expect("Lock font system")
-    }
-
-    pub fn write(
-        &self,
-    ) -> (sync::RwLockWriteGuard<'_, cosmic_text::FontSystem>, Version) {
-        (self.raw.write().expect("Write font system"), self.version)
+    /// Returns the raw [`cosmic_text::FontSystem`].
+    pub fn raw(&mut self) -> &mut cosmic_text::FontSystem {
+        &mut self.raw
     }
 
+    /// Loads a font from its bytes.
     pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) {
-        let _ = self.get_mut().db_mut().load_font_source(
+        let _ = self.raw.db_mut().load_font_source(
             cosmic_text::fontdb::Source::Binary(Arc::new(bytes.into_owned())),
         );
 
         self.version = Version(self.version.0 + 1);
     }
 
+    /// Returns the current [`Version`] of the [`FontSystem`].
+    ///
+    /// Loading a font will increase the version of a [`FontSystem`].
     pub fn version(&self) -> Version {
         self.version
     }
 }
 
+/// A version number.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct Version(u32);
 
-impl Default for FontSystem {
-    fn default() -> Self {
-        Self::new()
+/// A weak reference to a [`cosmic-text::Buffer`] that can be drawn.
+#[derive(Debug, Clone)]
+pub struct Raw {
+    /// A weak reference to a [`cosmic_text::Buffer`].
+    pub buffer: Weak<cosmic_text::Buffer>,
+    /// The position of the text.
+    pub position: Point,
+    /// The color of the text.
+    pub color: Color,
+    /// The clip bounds of the text.
+    pub clip_bounds: Rectangle,
+}
+
+impl PartialEq for Raw {
+    fn eq(&self, _other: &Self) -> bool {
+        // TODO: There is no proper way to compare raw buffers
+        // For now, no two instances of `Raw` text will be equal.
+        // This should be fine, but could trigger unnecessary redraws
+        // in the future.
+        false
     }
 }
 
+/// Measures the dimensions of the given [`cosmic_text::Buffer`].
 pub fn measure(buffer: &cosmic_text::Buffer) -> Size {
     let (width, total_lines) = buffer
         .layout_runs()
@@ -71,9 +98,15 @@ pub fn measure(buffer: &cosmic_text::Buffer) -> Size {
             (run.line_w.max(width), total_lines + 1)
         });
 
-    Size::new(width, total_lines as f32 * buffer.metrics().line_height)
+    let (max_width, max_height) = buffer.size();
+
+    Size::new(
+        width.min(max_width),
+        (total_lines as f32 * buffer.metrics().line_height).min(max_height),
+    )
 }
 
+/// Returns the attributes of the given [`Font`].
 pub fn to_attributes(font: Font) -> cosmic_text::Attrs<'static> {
     cosmic_text::Attrs::new()
         .family(to_family(font.family))
@@ -129,9 +162,17 @@ fn to_style(style: font::Style) -> cosmic_text::Style {
     }
 }
 
+/// Converts some [`Shaping`] strategy to a [`cosmic_text::Shaping`] strategy.
 pub fn to_shaping(shaping: Shaping) -> cosmic_text::Shaping {
     match shaping {
         Shaping::Basic => cosmic_text::Shaping::Basic,
         Shaping::Advanced => cosmic_text::Shaping::Advanced,
     }
 }
+
+/// Converts some [`Color`] to a [`cosmic_text::Color`].
+pub fn to_color(color: Color) -> cosmic_text::Color {
+    let [r, g, b, a] = color.into_rgba8();
+
+    cosmic_text::Color::rgba(r, g, b, a)
+}
diff --git a/graphics/src/text/cache.rs b/graphics/src/text/cache.rs
index 577c4687..7fb33567 100644
--- a/graphics/src/text/cache.rs
+++ b/graphics/src/text/cache.rs
@@ -1,3 +1,4 @@
+//! Cache text.
 use crate::core::{Font, Size};
 use crate::text;
 
@@ -5,6 +6,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use std::collections::hash_map;
 use std::hash::{BuildHasher, Hash, Hasher};
 
+/// A store of recently used sections of text.
 #[allow(missing_debug_implementations)]
 #[derive(Default)]
 pub struct Cache {
@@ -14,21 +16,20 @@ pub struct Cache {
     hasher: HashBuilder,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-type HashBuilder = twox_hash::RandomXxHashBuilder64;
-
-#[cfg(target_arch = "wasm32")]
-type HashBuilder = std::hash::BuildHasherDefault<twox_hash::XxHash64>;
+type HashBuilder = xxhash_rust::xxh3::Xxh3Builder;
 
 impl Cache {
+    /// Creates a new empty [`Cache`].
     pub fn new() -> Self {
         Self::default()
     }
 
+    /// Gets the text [`Entry`] with the given [`KeyHash`].
     pub fn get(&self, key: &KeyHash) -> Option<&Entry> {
         self.entries.get(key)
     }
 
+    /// Allocates a text [`Entry`] if it is not already present in the [`Cache`].
     pub fn allocate(
         &mut self,
         font_system: &mut cosmic_text::FontSystem,
@@ -88,6 +89,9 @@ impl Cache {
         (hash, self.entries.get_mut(&hash).unwrap())
     }
 
+    /// Trims the [`Cache`].
+    ///
+    /// This will clear the sections of text that have not been used since the last `trim`.
     pub fn trim(&mut self) {
         self.entries
             .retain(|key, _| self.recently_used.contains(key));
@@ -99,13 +103,20 @@ impl Cache {
     }
 }
 
+/// A cache key representing a section of text.
 #[derive(Debug, Clone, Copy)]
 pub struct Key<'a> {
+    /// The content of the text.
     pub content: &'a str,
+    /// The size of the text.
     pub size: f32,
+    /// The line height of the text.
     pub line_height: f32,
+    /// The [`Font`] of the text.
     pub font: Font,
+    /// The bounds of the text.
     pub bounds: Size,
+    /// The shaping strategy of the text.
     pub shaping: text::Shaping,
 }
 
@@ -123,10 +134,14 @@ impl Key<'_> {
     }
 }
 
+/// The hash of a [`Key`].
 pub type KeyHash = u64;
 
+/// A cache entry.
 #[allow(missing_debug_implementations)]
 pub struct Entry {
+    /// The buffer of text, ready for drawing.
     pub buffer: cosmic_text::Buffer,
+    /// The minimum bounds of the text.
     pub min_bounds: Size,
 }
diff --git a/graphics/src/text/editor.rs b/graphics/src/text/editor.rs
new file mode 100644
index 00000000..d5262ae8
--- /dev/null
+++ b/graphics/src/text/editor.rs
@@ -0,0 +1,779 @@
+//! Draw and edit text.
+use crate::core::text::editor::{
+    self, Action, Cursor, Direction, Edit, Motion,
+};
+use crate::core::text::highlighter::{self, Highlighter};
+use crate::core::text::LineHeight;
+use crate::core::{Font, Pixels, Point, Rectangle, Size};
+use crate::text;
+
+use cosmic_text::Edit as _;
+
+use std::fmt;
+use std::sync::{self, Arc};
+
+/// A multi-line text editor.
+#[derive(Debug, PartialEq)]
+pub struct Editor(Option<Arc<Internal>>);
+
+struct Internal {
+    editor: cosmic_text::Editor,
+    font: Font,
+    bounds: Size,
+    topmost_line_changed: Option<usize>,
+    version: text::Version,
+}
+
+impl Editor {
+    /// Creates a new empty [`Editor`].
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Returns the buffer of the [`Editor`].
+    pub fn buffer(&self) -> &cosmic_text::Buffer {
+        self.internal().editor.buffer()
+    }
+
+    /// Creates a [`Weak`] reference to the [`Editor`].
+    ///
+    /// This is useful to avoid cloning the [`Editor`] when
+    /// referential guarantees are unnecessary. For instance,
+    /// when creating a rendering tree.
+    pub fn downgrade(&self) -> Weak {
+        let editor = self.internal();
+
+        Weak {
+            raw: Arc::downgrade(editor),
+            bounds: editor.bounds,
+        }
+    }
+
+    fn internal(&self) -> &Arc<Internal> {
+        self.0
+            .as_ref()
+            .expect("Editor should always be initialized")
+    }
+}
+
+impl editor::Editor for Editor {
+    type Font = Font;
+
+    fn with_text(text: &str) -> Self {
+        let mut buffer = cosmic_text::Buffer::new_empty(cosmic_text::Metrics {
+            font_size: 1.0,
+            line_height: 1.0,
+        });
+
+        let mut font_system =
+            text::font_system().write().expect("Write font system");
+
+        buffer.set_text(
+            font_system.raw(),
+            text,
+            cosmic_text::Attrs::new(),
+            cosmic_text::Shaping::Advanced,
+        );
+
+        Editor(Some(Arc::new(Internal {
+            editor: cosmic_text::Editor::new(buffer),
+            version: font_system.version(),
+            ..Default::default()
+        })))
+    }
+
+    fn line(&self, index: usize) -> Option<&str> {
+        self.buffer()
+            .lines
+            .get(index)
+            .map(cosmic_text::BufferLine::text)
+    }
+
+    fn line_count(&self) -> usize {
+        self.buffer().lines.len()
+    }
+
+    fn selection(&self) -> Option<String> {
+        self.internal().editor.copy_selection()
+    }
+
+    fn cursor(&self) -> editor::Cursor {
+        let internal = self.internal();
+
+        let cursor = internal.editor.cursor();
+        let buffer = internal.editor.buffer();
+
+        match internal.editor.select_opt() {
+            Some(selection) => {
+                let (start, end) = if cursor < selection {
+                    (cursor, selection)
+                } else {
+                    (selection, cursor)
+                };
+
+                let line_height = buffer.metrics().line_height;
+                let selected_lines = end.line - start.line + 1;
+
+                let visual_lines_offset =
+                    visual_lines_offset(start.line, buffer);
+
+                let regions = buffer
+                    .lines
+                    .iter()
+                    .skip(start.line)
+                    .take(selected_lines)
+                    .enumerate()
+                    .flat_map(|(i, line)| {
+                        highlight_line(
+                            line,
+                            if i == 0 { start.index } else { 0 },
+                            if i == selected_lines - 1 {
+                                end.index
+                            } else {
+                                line.text().len()
+                            },
+                        )
+                    })
+                    .enumerate()
+                    .filter_map(|(visual_line, (x, width))| {
+                        if width > 0.0 {
+                            Some(Rectangle {
+                                x,
+                                width,
+                                y: (visual_line as i32 + visual_lines_offset)
+                                    as f32
+                                    * line_height,
+                                height: line_height,
+                            })
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                Cursor::Selection(regions)
+            }
+            _ => {
+                let line_height = buffer.metrics().line_height;
+
+                let visual_lines_offset =
+                    visual_lines_offset(cursor.line, buffer);
+
+                let line = buffer
+                    .lines
+                    .get(cursor.line)
+                    .expect("Cursor line should be present");
+
+                let layout = line
+                    .layout_opt()
+                    .as_ref()
+                    .expect("Line layout should be cached");
+
+                let mut lines = layout.iter().enumerate();
+
+                let (visual_line, offset) = lines
+                    .find_map(|(i, line)| {
+                        let start = line
+                            .glyphs
+                            .first()
+                            .map(|glyph| glyph.start)
+                            .unwrap_or(0);
+                        let end = line
+                            .glyphs
+                            .last()
+                            .map(|glyph| glyph.end)
+                            .unwrap_or(0);
+
+                        let is_cursor_before_start = start > cursor.index;
+
+                        let is_cursor_before_end = match cursor.affinity {
+                            cosmic_text::Affinity::Before => {
+                                cursor.index <= end
+                            }
+                            cosmic_text::Affinity::After => cursor.index < end,
+                        };
+
+                        if is_cursor_before_start {
+                            // Sometimes, the glyph we are looking for is right
+                            // between lines. This can happen when a line wraps
+                            // on a space.
+                            // In that case, we can assume the cursor is at the
+                            // end of the previous line.
+                            // i is guaranteed to be > 0 because `start` is always
+                            // 0 for the first line, so there is no way for the
+                            // cursor to be before it.
+                            Some((i - 1, layout[i - 1].w))
+                        } else if is_cursor_before_end {
+                            let offset = line
+                                .glyphs
+                                .iter()
+                                .take_while(|glyph| cursor.index > glyph.start)
+                                .map(|glyph| glyph.w)
+                                .sum();
+
+                            Some((i, offset))
+                        } else {
+                            None
+                        }
+                    })
+                    .unwrap_or((
+                        layout.len().saturating_sub(1),
+                        layout.last().map(|line| line.w).unwrap_or(0.0),
+                    ));
+
+                Cursor::Caret(Point::new(
+                    offset,
+                    (visual_lines_offset + visual_line as i32) as f32
+                        * line_height,
+                ))
+            }
+        }
+    }
+
+    fn cursor_position(&self) -> (usize, usize) {
+        let cursor = self.internal().editor.cursor();
+
+        (cursor.line, cursor.index)
+    }
+
+    fn perform(&mut self, action: Action) {
+        let mut font_system =
+            text::font_system().write().expect("Write font system");
+
+        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");
+
+        let editor = &mut internal.editor;
+
+        match action {
+            // Motion events
+            Action::Move(motion) => {
+                if let Some(selection) = editor.select_opt() {
+                    let cursor = editor.cursor();
+
+                    let (left, right) = if cursor < selection {
+                        (cursor, selection)
+                    } else {
+                        (selection, cursor)
+                    };
+
+                    editor.set_select_opt(None);
+
+                    match motion {
+                        // These motions are performed as-is even when a selection
+                        // is present
+                        Motion::Home
+                        | Motion::End
+                        | Motion::DocumentStart
+                        | Motion::DocumentEnd => {
+                            editor.action(
+                                font_system.raw(),
+                                motion_to_action(motion),
+                            );
+                        }
+                        // Other motions simply move the cursor to one end of the selection
+                        _ => editor.set_cursor(match motion.direction() {
+                            Direction::Left => left,
+                            Direction::Right => right,
+                        }),
+                    }
+                } else {
+                    editor.action(font_system.raw(), motion_to_action(motion));
+                }
+            }
+
+            // Selection events
+            Action::Select(motion) => {
+                let cursor = editor.cursor();
+
+                if editor.select_opt().is_none() {
+                    editor.set_select_opt(Some(cursor));
+                }
+
+                editor.action(font_system.raw(), motion_to_action(motion));
+
+                // Deselect if selection matches cursor position
+                if let Some(selection) = editor.select_opt() {
+                    let cursor = editor.cursor();
+
+                    if cursor.line == selection.line
+                        && cursor.index == selection.index
+                    {
+                        editor.set_select_opt(None);
+                    }
+                }
+            }
+            Action::SelectWord => {
+                use unicode_segmentation::UnicodeSegmentation;
+
+                let cursor = editor.cursor();
+
+                if let Some(line) = editor.buffer().lines.get(cursor.line) {
+                    let (start, end) =
+                        UnicodeSegmentation::unicode_word_indices(line.text())
+                            // Split words with dots
+                            .flat_map(|(i, word)| {
+                                word.split('.').scan(i, |current, word| {
+                                    let start = *current;
+                                    *current += word.len() + 1;
+
+                                    Some((start, word))
+                                })
+                            })
+                            // Turn words into ranges
+                            .map(|(i, word)| (i, i + word.len()))
+                            // Find the word at cursor
+                            .find(|&(start, end)| {
+                                start <= cursor.index && cursor.index < end
+                            })
+                            // Cursor is not in a word. Let's select its punctuation cluster.
+                            .unwrap_or_else(|| {
+                                let start = line.text()[..cursor.index]
+                                    .char_indices()
+                                    .rev()
+                                    .take_while(|(_, c)| {
+                                        c.is_ascii_punctuation()
+                                    })
+                                    .map(|(i, _)| i)
+                                    .last()
+                                    .unwrap_or(cursor.index);
+
+                                let end = line.text()[cursor.index..]
+                                    .char_indices()
+                                    .skip_while(|(_, c)| {
+                                        c.is_ascii_punctuation()
+                                    })
+                                    .map(|(i, _)| i + cursor.index)
+                                    .next()
+                                    .unwrap_or(cursor.index);
+
+                                (start, end)
+                            });
+
+                    if start != end {
+                        editor.set_cursor(cosmic_text::Cursor {
+                            index: start,
+                            ..cursor
+                        });
+
+                        editor.set_select_opt(Some(cosmic_text::Cursor {
+                            index: end,
+                            ..cursor
+                        }));
+                    }
+                }
+            }
+            Action::SelectLine => {
+                let cursor = editor.cursor();
+
+                if let Some(line_length) = editor
+                    .buffer()
+                    .lines
+                    .get(cursor.line)
+                    .map(|line| line.text().len())
+                {
+                    editor
+                        .set_cursor(cosmic_text::Cursor { index: 0, ..cursor });
+
+                    editor.set_select_opt(Some(cosmic_text::Cursor {
+                        index: line_length,
+                        ..cursor
+                    }));
+                }
+            }
+
+            // Editing events
+            Action::Edit(edit) => {
+                match edit {
+                    Edit::Insert(c) => {
+                        editor.action(
+                            font_system.raw(),
+                            cosmic_text::Action::Insert(c),
+                        );
+                    }
+                    Edit::Paste(text) => {
+                        editor.insert_string(&text, None);
+                    }
+                    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 = editor.select_opt().unwrap_or(cursor);
+
+                internal.topmost_line_changed =
+                    Some(cursor.min(selection).line);
+            }
+
+            // 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(selection) = editor.select_opt() {
+                    let cursor = editor.cursor();
+
+                    if cursor.line == selection.line
+                        && cursor.index == selection.index
+                    {
+                        editor.set_select_opt(None);
+                    }
+                }
+            }
+            Action::Scroll { lines } => {
+                editor.action(
+                    font_system.raw(),
+                    cosmic_text::Action::Scroll { lines },
+                );
+            }
+        }
+
+        self.0 = Some(Arc::new(internal));
+    }
+
+    fn bounds(&self) -> Size {
+        self.internal().bounds
+    }
+
+    fn update(
+        &mut self,
+        new_bounds: Size,
+        new_font: Font,
+        new_size: Pixels,
+        new_line_height: LineHeight,
+        new_highlighter: &mut impl Highlighter,
+    ) {
+        let editor =
+            self.0.take().expect("Editor should always be initialized");
+
+        let mut internal = Arc::try_unwrap(editor)
+            .expect("Editor cannot have multiple strong references");
+
+        let mut font_system =
+            text::font_system().write().expect("Write font system");
+
+        if font_system.version() != internal.version {
+            log::trace!("Updating `FontSystem` of `Editor`...");
+
+            for line in internal.editor.buffer_mut().lines.iter_mut() {
+                line.reset();
+            }
+
+            internal.version = font_system.version();
+            internal.topmost_line_changed = Some(0);
+        }
+
+        if new_font != internal.font {
+            log::trace!("Updating font of `Editor`...");
+
+            for line in internal.editor.buffer_mut().lines.iter_mut() {
+                let _ = line.set_attrs_list(cosmic_text::AttrsList::new(
+                    text::to_attributes(new_font),
+                ));
+            }
+
+            internal.font = new_font;
+            internal.topmost_line_changed = Some(0);
+        }
+
+        let metrics = internal.editor.buffer().metrics();
+        let new_line_height = new_line_height.to_absolute(new_size);
+
+        if new_size.0 != metrics.font_size
+            || new_line_height.0 != metrics.line_height
+        {
+            log::trace!("Updating `Metrics` of `Editor`...");
+
+            internal.editor.buffer_mut().set_metrics(
+                font_system.raw(),
+                cosmic_text::Metrics::new(new_size.0, new_line_height.0),
+            );
+        }
+
+        if new_bounds != internal.bounds {
+            log::trace!("Updating size of `Editor`...");
+
+            internal.editor.buffer_mut().set_size(
+                font_system.raw(),
+                new_bounds.width,
+                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}"
+            );
+
+            new_highlighter.change_line(topmost_line_changed);
+        }
+
+        internal.editor.shape_as_needed(font_system.raw());
+
+        self.0 = Some(Arc::new(internal));
+    }
+
+    fn highlight<H: Highlighter>(
+        &mut self,
+        font: Self::Font,
+        highlighter: &mut H,
+        format_highlight: impl Fn(&H::Highlight) -> highlighter::Format<Self::Font>,
+    ) {
+        let internal = self.internal();
+        let buffer = internal.editor.buffer();
+
+        let mut window = buffer.scroll() + buffer.visible_lines();
+
+        let last_visible_line = buffer
+            .lines
+            .iter()
+            .enumerate()
+            .find_map(|(i, line)| {
+                let visible_lines = line
+                    .layout_opt()
+                    .as_ref()
+                    .expect("Line layout should be cached")
+                    .len() as i32;
+
+                if window > visible_lines {
+                    window -= visible_lines;
+                    None
+                } else {
+                    Some(i)
+                }
+            })
+            .unwrap_or(buffer.lines.len().saturating_sub(1));
+
+        let current_line = highlighter.current_line();
+
+        if current_line > last_visible_line {
+            return;
+        }
+
+        let editor =
+            self.0.take().expect("Editor should always be initialized");
+
+        let mut internal = Arc::try_unwrap(editor)
+            .expect("Editor cannot have multiple strong references");
+
+        let mut font_system =
+            text::font_system().write().expect("Write font system");
+
+        let attributes = text::to_attributes(font);
+
+        for line in &mut internal.editor.buffer_mut().lines
+            [current_line..=last_visible_line]
+        {
+            let mut list = cosmic_text::AttrsList::new(attributes);
+
+            for (range, highlight) in highlighter.highlight_line(line.text()) {
+                let format = format_highlight(&highlight);
+
+                if format.color.is_some() || format.font.is_some() {
+                    list.add_span(
+                        range,
+                        cosmic_text::Attrs {
+                            color_opt: format.color.map(text::to_color),
+                            ..if let Some(font) = format.font {
+                                text::to_attributes(font)
+                            } else {
+                                attributes
+                            }
+                        },
+                    );
+                }
+            }
+
+            let _ = line.set_attrs_list(list);
+        }
+
+        internal.editor.shape_as_needed(font_system.raw());
+
+        self.0 = Some(Arc::new(internal));
+    }
+}
+
+impl Default for Editor {
+    fn default() -> Self {
+        Self(Some(Arc::new(Internal::default())))
+    }
+}
+
+impl PartialEq for Internal {
+    fn eq(&self, other: &Self) -> bool {
+        self.font == other.font
+            && self.bounds == other.bounds
+            && self.editor.buffer().metrics() == other.editor.buffer().metrics()
+    }
+}
+
+impl Default for Internal {
+    fn default() -> Self {
+        Self {
+            editor: cosmic_text::Editor::new(cosmic_text::Buffer::new_empty(
+                cosmic_text::Metrics {
+                    font_size: 1.0,
+                    line_height: 1.0,
+                },
+            )),
+            font: Font::default(),
+            bounds: Size::ZERO,
+            topmost_line_changed: None,
+            version: text::Version::default(),
+        }
+    }
+}
+
+impl fmt::Debug for Internal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Internal")
+            .field("font", &self.font)
+            .field("bounds", &self.bounds)
+            .finish()
+    }
+}
+
+/// A weak reference to an [`Editor`].
+#[derive(Debug, Clone)]
+pub struct Weak {
+    raw: sync::Weak<Internal>,
+    /// The bounds of the [`Editor`].
+    pub bounds: Size,
+}
+
+impl Weak {
+    /// Tries to update the reference into an [`Editor`].
+    pub fn upgrade(&self) -> Option<Editor> {
+        self.raw.upgrade().map(Some).map(Editor)
+    }
+}
+
+impl PartialEq for Weak {
+    fn eq(&self, other: &Self) -> bool {
+        match (self.raw.upgrade(), other.raw.upgrade()) {
+            (Some(p1), Some(p2)) => p1 == p2,
+            _ => false,
+        }
+    }
+}
+
+fn highlight_line(
+    line: &cosmic_text::BufferLine,
+    from: usize,
+    to: usize,
+) -> impl Iterator<Item = (f32, f32)> + '_ {
+    let layout = line
+        .layout_opt()
+        .as_ref()
+        .expect("Line layout should be cached");
+
+    layout.iter().map(move |visual_line| {
+        let start = visual_line
+            .glyphs
+            .first()
+            .map(|glyph| glyph.start)
+            .unwrap_or(0);
+        let end = visual_line
+            .glyphs
+            .last()
+            .map(|glyph| glyph.end)
+            .unwrap_or(0);
+
+        let range = start.max(from)..end.min(to);
+
+        if range.is_empty() {
+            (0.0, 0.0)
+        } else if range.start == start && range.end == end {
+            (0.0, visual_line.w)
+        } else {
+            let first_glyph = visual_line
+                .glyphs
+                .iter()
+                .position(|glyph| range.start <= glyph.start)
+                .unwrap_or(0);
+
+            let mut glyphs = visual_line.glyphs.iter();
+
+            let x =
+                glyphs.by_ref().take(first_glyph).map(|glyph| glyph.w).sum();
+
+            let width: f32 = glyphs
+                .take_while(|glyph| range.end > glyph.start)
+                .map(|glyph| glyph.w)
+                .sum();
+
+            (x, width)
+        }
+    })
+}
+
+fn visual_lines_offset(line: usize, buffer: &cosmic_text::Buffer) -> i32 {
+    let visual_lines_before_start: usize = buffer
+        .lines
+        .iter()
+        .take(line)
+        .map(|line| {
+            line.layout_opt()
+                .as_ref()
+                .expect("Line layout should be cached")
+                .len()
+        })
+        .sum();
+
+    visual_lines_before_start as i32 - buffer.scroll()
+}
+
+fn motion_to_action(motion: Motion) -> cosmic_text::Action {
+    match motion {
+        Motion::Left => cosmic_text::Action::Left,
+        Motion::Right => cosmic_text::Action::Right,
+        Motion::Up => cosmic_text::Action::Up,
+        Motion::Down => cosmic_text::Action::Down,
+        Motion::WordLeft => cosmic_text::Action::LeftWord,
+        Motion::WordRight => cosmic_text::Action::RightWord,
+        Motion::Home => cosmic_text::Action::Home,
+        Motion::End => cosmic_text::Action::End,
+        Motion::PageUp => cosmic_text::Action::PageUp,
+        Motion::PageDown => cosmic_text::Action::PageDown,
+        Motion::DocumentStart => cosmic_text::Action::BufferStart,
+        Motion::DocumentEnd => cosmic_text::Action::BufferEnd,
+    }
+}
diff --git a/graphics/src/text/paragraph.rs b/graphics/src/text/paragraph.rs
index e4350cff..5d027542 100644
--- a/graphics/src/text/paragraph.rs
+++ b/graphics/src/text/paragraph.rs
@@ -1,12 +1,14 @@
+//! Draw paragraphs.
 use crate::core;
 use crate::core::alignment;
 use crate::core::text::{Hit, LineHeight, Shaping, Text};
 use crate::core::{Font, Pixels, Point, Size};
-use crate::text::{self, FontSystem};
+use crate::text;
 
 use std::fmt;
 use std::sync::{self, Arc};
 
+/// A bunch of text.
 #[derive(Clone, PartialEq)]
 pub struct Paragraph(Option<Arc<Internal>>);
 
@@ -23,17 +25,50 @@ struct Internal {
 }
 
 impl Paragraph {
+    /// Creates a new empty [`Paragraph`].
     pub fn new() -> Self {
         Self::default()
     }
 
-    pub fn with_text(text: Text<'_, Font>, font_system: &FontSystem) -> Self {
+    /// Returns the buffer of the [`Paragraph`].
+    pub fn buffer(&self) -> &cosmic_text::Buffer {
+        &self.internal().buffer
+    }
+
+    /// Creates a [`Weak`] reference to the [`Paragraph`].
+    ///
+    /// This is useful to avoid cloning the [`Paragraph`] when
+    /// referential guarantees are unnecessary. For instance,
+    /// when creating a rendering tree.
+    pub fn downgrade(&self) -> Weak {
+        let paragraph = self.internal();
+
+        Weak {
+            raw: Arc::downgrade(paragraph),
+            min_bounds: paragraph.min_bounds,
+            horizontal_alignment: paragraph.horizontal_alignment,
+            vertical_alignment: paragraph.vertical_alignment,
+        }
+    }
+
+    fn internal(&self) -> &Arc<Internal> {
+        self.0
+            .as_ref()
+            .expect("paragraph should always be initialized")
+    }
+}
+
+impl core::text::Paragraph for Paragraph {
+    type Font = Font;
+
+    fn with_text(text: Text<'_, Font>) -> Self {
         log::trace!("Allocating paragraph: {}", text.content);
 
-        let (mut font_system, version) = font_system.write();
+        let mut font_system =
+            text::font_system().write().expect("Write font system");
 
         let mut buffer = cosmic_text::Buffer::new(
-            &mut font_system,
+            font_system.raw(),
             cosmic_text::Metrics::new(
                 text.size.into(),
                 text.line_height.to_absolute(text.size).into(),
@@ -41,13 +76,13 @@ impl Paragraph {
         );
 
         buffer.set_size(
-            &mut font_system,
+            font_system.raw(),
             text.bounds.width,
             text.bounds.height,
         );
 
         buffer.set_text(
-            &mut font_system,
+            font_system.raw(),
             text.content,
             text::to_attributes(text.font),
             text::to_shaping(text.shaping),
@@ -64,30 +99,11 @@ impl Paragraph {
             shaping: text.shaping,
             bounds: text.bounds,
             min_bounds,
-            version,
+            version: font_system.version(),
         })))
     }
 
-    pub fn buffer(&self) -> &cosmic_text::Buffer {
-        &self.internal().buffer
-    }
-
-    pub fn version(&self) -> text::Version {
-        self.internal().version
-    }
-
-    pub fn downgrade(&self) -> Weak {
-        let paragraph = self.internal();
-
-        Weak {
-            raw: Arc::downgrade(paragraph),
-            min_bounds: paragraph.min_bounds,
-            horizontal_alignment: paragraph.horizontal_alignment,
-            vertical_alignment: paragraph.vertical_alignment,
-        }
-    }
-
-    pub fn resize(&mut self, new_bounds: Size, font_system: &FontSystem) {
+    fn resize(&mut self, new_bounds: Size) {
         let paragraph = self
             .0
             .take()
@@ -95,10 +111,11 @@ impl Paragraph {
 
         match Arc::try_unwrap(paragraph) {
             Ok(mut internal) => {
-                let (mut font_system, _) = font_system.write();
+                let mut font_system =
+                    text::font_system().write().expect("Write font system");
 
                 internal.buffer.set_size(
-                    &mut font_system,
+                    font_system.raw(),
                     new_bounds.width,
                     new_bounds.height,
                 );
@@ -113,55 +130,42 @@ impl Paragraph {
 
                 // If there is a strong reference somewhere, we recompute the
                 // buffer from scratch
-                *self = Self::with_text(
-                    Text {
-                        content: &internal.content,
-                        bounds: internal.bounds,
-                        size: Pixels(metrics.font_size),
-                        line_height: LineHeight::Absolute(Pixels(
-                            metrics.line_height,
-                        )),
-                        font: internal.font,
-                        horizontal_alignment: internal.horizontal_alignment,
-                        vertical_alignment: internal.vertical_alignment,
-                        shaping: internal.shaping,
-                    },
-                    font_system,
-                );
+                *self = Self::with_text(Text {
+                    content: &internal.content,
+                    bounds: internal.bounds,
+                    size: Pixels(metrics.font_size),
+                    line_height: LineHeight::Absolute(Pixels(
+                        metrics.line_height,
+                    )),
+                    font: internal.font,
+                    horizontal_alignment: internal.horizontal_alignment,
+                    vertical_alignment: internal.vertical_alignment,
+                    shaping: internal.shaping,
+                });
             }
         }
     }
 
-    fn internal(&self) -> &Arc<Internal> {
-        self.0
-            .as_ref()
-            .expect("paragraph should always be initialized")
-    }
-}
-
-impl core::text::Paragraph for Paragraph {
-    type Font = Font;
-
-    fn content(&self) -> &str {
-        &self.internal().content
-    }
-
-    fn text_size(&self) -> Pixels {
-        Pixels(self.internal().buffer.metrics().font_size)
-    }
-
-    fn line_height(&self) -> LineHeight {
-        LineHeight::Absolute(Pixels(
-            self.internal().buffer.metrics().line_height,
-        ))
-    }
-
-    fn font(&self) -> Font {
-        self.internal().font
-    }
-
-    fn shaping(&self) -> Shaping {
-        self.internal().shaping
+    fn compare(&self, text: Text<'_, Font>) -> core::text::Difference {
+        let font_system = text::font_system().read().expect("Read font system");
+        let paragraph = self.internal();
+        let metrics = paragraph.buffer.metrics();
+
+        if paragraph.version != font_system.version
+            || paragraph.content != text.content
+            || metrics.font_size != text.size.0
+            || metrics.line_height != text.line_height.to_absolute(text.size).0
+            || paragraph.font != text.font
+            || paragraph.shaping != text.shaping
+            || paragraph.horizontal_alignment != text.horizontal_alignment
+            || paragraph.vertical_alignment != text.vertical_alignment
+        {
+            core::text::Difference::Shape
+        } else if paragraph.bounds != text.bounds {
+            core::text::Difference::Bounds
+        } else {
+            core::text::Difference::None
+        }
     }
 
     fn horizontal_alignment(&self) -> alignment::Horizontal {
@@ -172,10 +176,6 @@ impl core::text::Paragraph for Paragraph {
         self.internal().vertical_alignment
     }
 
-    fn bounds(&self) -> Size {
-        self.internal().bounds
-    }
-
     fn min_bounds(&self) -> Size {
         self.internal().min_bounds
     }
@@ -187,38 +187,43 @@ impl core::text::Paragraph for Paragraph {
     }
 
     fn grapheme_position(&self, line: usize, index: usize) -> Option<Point> {
+        use unicode_segmentation::UnicodeSegmentation;
+
         let run = self.internal().buffer.layout_runs().nth(line)?;
 
         // index represents a grapheme, not a glyph
         // Let's find the first glyph for the given grapheme cluster
         let mut last_start = None;
+        let mut last_grapheme_count = 0;
         let mut graphemes_seen = 0;
 
         let glyph = run
             .glyphs
             .iter()
             .find(|glyph| {
-                if graphemes_seen == index {
-                    return true;
-                }
-
                 if Some(glyph.start) != last_start {
+                    last_grapheme_count = run.text[glyph.start..glyph.end]
+                        .graphemes(false)
+                        .count();
                     last_start = Some(glyph.start);
-                    graphemes_seen += 1;
+                    graphemes_seen += last_grapheme_count;
                 }
 
-                false
+                graphemes_seen >= index
             })
             .or_else(|| run.glyphs.last())?;
 
-        let advance_last = if index == run.glyphs.len() {
-            glyph.w
-        } else {
+        let advance = if index == 0 {
             0.0
+        } else {
+            glyph.w
+                * (1.0
+                    - graphemes_seen.saturating_sub(index) as f32
+                        / last_grapheme_count.max(1) as f32)
         };
 
         Some(Point::new(
-            glyph.x + glyph.x_offset * glyph.font_size + advance_last,
+            glyph.x + glyph.x_offset * glyph.font_size + advance,
             glyph.y - glyph.y_offset * glyph.font_size,
         ))
     }
@@ -278,15 +283,20 @@ impl Default for Internal {
     }
 }
 
+/// A weak reference to a [`Paragraph`].
 #[derive(Debug, Clone)]
 pub struct Weak {
     raw: sync::Weak<Internal>,
+    /// The minimum bounds of the [`Paragraph`].
     pub min_bounds: Size,
+    /// The horizontal alignment of the [`Paragraph`].
     pub horizontal_alignment: alignment::Horizontal,
+    /// The vertical alignment of the [`Paragraph`].
     pub vertical_alignment: alignment::Vertical,
 }
 
 impl Weak {
+    /// Tries to update the reference into a [`Paragraph`].
     pub fn upgrade(&self) -> Option<Paragraph> {
         self.raw.upgrade().map(Some).map(Paragraph)
     }