Respect animations preference when paging up/down

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "inkr"
-version = "0.1.0"
+version = "1.0.0"
 authors = []
 edition = "2024"
 
@@ -12,21 +12,25 @@ targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
 pinenote = []
 
 [dependencies]
-egui = "0.31"
-eframe = { version = "0.31", default-features = false, features = [
+egui = "0.32"
+egui_extras = { version = "0.32", features = ["svg"] }
+egui_glow = "0.32"
+eframe = { version = "0.32", default-features = false, features = [
     "glow",           # alt: "wgpu".
     "persistence",
     "wayland",
 ] }
 log = "0.4.27"
 serde = { version = "1.0.219", features = ["derive"] }
-egui_glow = "0.31.1"
 rfd = { version = "0.15.3", default-features = false, features = ["gtk3"] }
 rand = "0.9.1"
 eyre = "0.6.12"
 half = "2.6.0"
 zerocopy = { version = "0.8.25", features = ["derive", "std"] }
 base64 = "0.22.1"
+chrono = { version = "0.4.41", features = ["serde"] }
+notify = "8.1.0"
+arboard = "3.6.0"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 env_logger = "0.11.8"
@@ -38,13 +42,14 @@ wasm-bindgen-futures = "0.4.50"
 web-sys = "0.3.77"
 
 [patch.crates-io]
-egui =   { git = "https://github.com/emilk/egui", rev = "f2ce6424f3a32f47308fb9871d540c01377b2cd9" }
-eframe = { git = "https://github.com/emilk/egui", rev = "f2ce6424f3a32f47308fb9871d540c01377b2cd9" }
+# egui = { path = "../egui/crates/egui" }
+# eframe = { path = "../egui/crates/eframe" }
 
 [dev-dependencies]
 insta = { version = "1.43.1", features = ["yaml"] }
-# egui = { path = "../egui/crates/egui" }
-# eframe = { path = "../egui/crates/eframe" }
+
+[lints.clippy]
+unnecessary_lazy_evaluations = "allow"
 
 [profile.release]
 opt-level = 2 # fast and small wasm

PKGBUILD

@@ -0,0 +1,27 @@
+pkgname=inkr
+pkgver=1.0.0
+pkgrel=1
+pkgdesc="A note-taking and handwriting tool"
+arch=('x86_64' 'aarch64')
+url="https://git.nubo.sh/hulthe/inkr"
+#license=('GPL')
+groups=('base-devel')
+depends=('glibc')
+makedepends=('cargo')
+#optdepends=('ed: for "patch -e" functionality')
+#source=(" ftp://ftp.gnu.org/gnu/$pkgname/$pkgname-$pkgver.tar.xz"{,.sig})
+#sha256sums=('SKIP')
+prepare() {
+	export RUSTUP_TOOLCHAIN=stable
+	cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')"
+}
+build() {
+	export RUSTUP_TOOLCHAIN=stable
+	cargo build --frozen --release
+}
+package() {
+	cd ..
+	install -Dm0755 -t "$pkgdir/usr/bin/" "${CARGO_TARGET_DIR:-target}/release/$pkgname"
+	install -Dm0755 -t "$pkgdir/usr/share/applications/" "assets/$pkgname.desktop"
+	install -Dm0755 "assets/icon.svg" "$pkgdir/usr/share/pixmaps/$pkgname.svg"
+}

assets/collapse-icon.svg

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="256"
+   height="256"
+   viewBox="0 0 67.733332 67.733332"
+   version="1.1"
+   id="svg1"
+   inkscape:version="1.4.2 (ebf0e940, 2025-05-08)"
+   sodipodi:docname="collapse-icon.svg"
+   inkscape:export-filename="collapse-icon.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#505050"
+     bordercolor="#eeeeee"
+     borderopacity="1"
+     inkscape:showpageshadow="0"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#505050"
+     inkscape:document-units="mm"
+     inkscape:zoom="2.0010679"
+     inkscape:cx="97.198102"
+     inkscape:cy="140.42502"
+     inkscape:window-width="1472"
+     inkscape:window-height="815"
+     inkscape:window-x="0"
+     inkscape:window-y="38"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" />
+  <defs
+     id="defs1" />
+  <g
+     inkscape:label="Lager 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <rect
+       style="fill:#000000;fill-opacity:0;stroke:#ffffff;stroke-width:4.92907;stroke-linejoin:miter;stroke-dasharray:none;stroke-opacity:1"
+       id="rect1"
+       width="62.804268"
+       height="52.220932"
+       x="2.4645352"
+       y="7.7562032"
+       ry="6.9627905" />
+    <path
+       style="fill:#000000;fill-opacity:0;stroke:#ffffff;stroke-width:4.92628;stroke-linejoin:miter;stroke-dasharray:none;stroke-opacity:1"
+       d="M 28.921473,6.35 V 61.383333"
+       id="path1" />
+    <path
+       style="fill:#000000;fill-opacity:0;stroke:#ffffff;stroke-width:3.12398;stroke-linecap:round;stroke-linejoin:miter;stroke-dasharray:none;stroke-opacity:1"
+       d="M 22.250504,15.411171 9.4994923,15.320325"
+       id="path1-7" />
+    <path
+       style="fill:#000000;fill-opacity:0;stroke:#ffffff;stroke-width:3.12398;stroke-linecap:round;stroke-linejoin:miter;stroke-dasharray:none;stroke-opacity:1"
+       d="M 22.250506,21.743139 9.4994938,21.652293"
+       id="path1-7-4" />
+    <path
+       style="fill:#000000;fill-opacity:0;stroke:#ffffff;stroke-width:3.12398;stroke-linecap:round;stroke-linejoin:miter;stroke-dasharray:none;stroke-opacity:1"
+       d="M 22.250506,28.075107 9.4994938,27.984261"
+       id="path1-7-5" />
+    <path
+       style="fill:#000000;fill-opacity:0;stroke:#ffffff;stroke-width:3.12398;stroke-linecap:round;stroke-linejoin:miter;stroke-dasharray:none;stroke-opacity:1"
+       d="M 22.250508,34.407075 9.4994958,34.316229"
+       id="path1-7-4-4" />
+  </g>
+</svg>

assets/inkr.desktop

@@ -0,0 +1,9 @@
+[Desktop Entry]
+Name=inkr
+Exec=inkr
+Terminal=false
+Type=Application
+Icon=inkr
+StartupWMClass=inkr
+MimeType=x-scheme-handler/inkr;
+Categories=Office;

src/app.rs

@@ -1,13 +1,23 @@
 use std::{
     fs,
+    io::Read,
     path::PathBuf,
     sync::{Arc, mpsc},
+    thread::JoinHandle,
+    time::{Duration, Instant},
 };
 
-use crate::{file_editor::FileEditor, preferences::Preferences, util::GuiSender};
-use egui::{
-    Align, Button, Color32, FontData, FontDefinitions, PointerButton, RichText, ScrollArea, Stroke,
+use crate::{
+    file_editor::{FileEditor, SaveStatus},
+    folder::Folder,
+    preferences::Preferences,
+    util::{GuiSender, file_mtime, log_error},
 };
+use egui::{
+    Align, Button, Context, FontData, FontDefinitions, FontId, Image, Key, Modifiers,
+    PointerButton, RichText, ScrollArea, Theme, Widget, include_image,
+};
+use eyre::eyre;
 
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)]
@@ -18,13 +28,46 @@ pub struct App {
     actions_tx: mpsc::Sender<Action>,
     #[serde(skip)]
     actions_rx: mpsc::Receiver<Action>,
+    #[serde(skip)]
+    jobs: Jobs,
 
     tabs: Vec<(TabId, Tab)>,
+
+    show_folders: bool,
+    folders: Vec<Folder>,
+
     open_tab_index: Option<usize>,
 
     next_tab_id: TabId,
 }
 
+pub struct Jobs {
+    handles: Vec<JoinHandle<()>>,
+    actions_tx: mpsc::Sender<Action>,
+}
+
+impl Jobs {
+    pub fn start(&mut self, ctx: &Context, job: impl FnOnce() -> Option<Action> + Send + 'static) {
+        let ctx = ctx.clone();
+        let actions_tx = self.actions_tx.clone();
+        self.handles.push(std::thread::spawn(move || {
+            // start rendering the spinner thingy
+            ctx.request_repaint();
+
+            let start = Instant::now();
+
+            if let Some(action) = job() {
+                let _ = actions_tx.send(action);
+                ctx.request_repaint();
+            };
+
+            // Make sure that task takes at least 250ms to run, so that the spinner won't blink
+            let sleep_for = Duration::from_millis(250).saturating_sub(start.elapsed());
+            std::thread::sleep(sleep_for);
+        }));
+    }
+}
+
 #[derive(serde::Deserialize, serde::Serialize)]
 enum Tab {
     File(FileEditor),
@@ -36,12 +79,31 @@ impl Tab {
             Tab::File(file_editor) => file_editor.title(),
         }
     }
+
+    pub fn notice_symbol(&self) -> Option<&'static str> {
+        match self {
+            Tab::File(file_editor) => match file_editor.save_status() {
+                SaveStatus::Synced => None,
+                SaveStatus::NoFile => Some("?"),
+                SaveStatus::FileOutdated => Some("*"),
+                SaveStatus::BufferOutdated => Some("!"),
+                SaveStatus::Desynced => Some("!!"),
+            },
+        }
+    }
+
+    pub fn save(&mut self, ctx: &Context, jobs: &mut Jobs) {
+        match self {
+            Tab::File(file_editor) => file_editor.save(ctx, jobs),
+        }
+    }
 }
 
 pub type TabId = usize;
 
 pub enum Action {
     OpenFile(FileEditor),
+    OpenFolder(Folder),
     MoveFile(TabId, PathBuf),
     CloseTab(TabId),
     // TODO
@@ -55,11 +117,17 @@ impl Default for App {
         let (actions_tx, actions_rx) = mpsc::channel();
         Self {
             preferences: Preferences::default(),
-            actions_tx,
+            actions_tx: actions_tx.clone(/* this is silly, i know */),
             actions_rx,
+            jobs: Jobs {
+                handles: Default::default(),
+                actions_tx,
+            },
             tabs: vec![(1, Tab::File(FileEditor::new("note.md")))],
             open_tab_index: None,
             next_tab_id: 2,
+            show_folders: false,
+            folders: vec![],
         }
     }
 }
@@ -133,11 +201,30 @@ impl App {
 
         cc.egui_ctx.set_fonts(fonts);
 
-        cc.egui_ctx.style_mut(|style| {
-            // TODO: change color of text in TextEdit
-            style.visuals.widgets.noninteractive.fg_stroke =
-                Stroke::new(1.0, Color32::from_rgb(200, 200, 200));
-        });
+        // markdown font styles
+        for theme in [Theme::Dark, Theme::Light] {
+            cc.egui_ctx.style_mut_of(theme, |style| {
+                for (name, size) in [
+                    ("H1", 28.0),
+                    ("H2", 26.0),
+                    ("H3", 24.0),
+                    ("H4", 22.0),
+                    ("H5", 20.0),
+                    ("H6", 18.0),
+                ] {
+                    style.text_styles.insert(
+                        egui::TextStyle::Name(name.into()),
+                        FontId {
+                            size,
+                            family: egui::FontFamily::Proportional,
+                        },
+                    );
+                }
+            });
+        }
+
+        // enable features on egui_extras to add more image types
+        egui_extras::install_image_loaders(&cc.egui_ctx);
 
         if let Some(storage) = cc.storage {
             return eframe::get_value(storage, eframe::APP_KEY).unwrap_or_default();
@@ -146,12 +233,24 @@ impl App {
         Default::default()
     }
 
-    fn actions_tx(&self, ctx: &egui::Context) -> GuiSender<Action> {
+    fn actions_tx(&self, ctx: &Context) -> GuiSender<Action> {
         GuiSender::new(self.actions_tx.clone(), ctx)
     }
 
     fn handle_action(&mut self, action: Action) {
         match action {
+            Action::OpenFolder(new_folder) => {
+                if let Some(folder) = self
+                    .folders
+                    .iter_mut()
+                    .find(|folder| folder.path() == new_folder.path())
+                {
+                    *folder = new_folder;
+                } else {
+                    self.folders.push(new_folder);
+                    self.folders.sort_by(|a, b| a.name().cmp(b.name()));
+                }
+            }
             Action::OpenFile(file_editor) => {
                 self.open_tab(Tab::File(file_editor));
             }
@@ -175,9 +274,11 @@ impl eframe::App for App {
         eframe::set_value(storage, eframe::APP_KEY, self);
     }
 
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+    fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
         self.preferences.apply(ctx);
 
+        self.jobs.handles.retain(|job| !job.is_finished());
+
         while let Ok(action) = self.actions_rx.try_recv() {
             self.handle_action(action);
         }
@@ -186,14 +287,14 @@ impl eframe::App for App {
             self.open_tab_index = Some(self.tabs.len().saturating_sub(1));
         }
 
-        //ctx.input_mut(|input| {
-        //    if input.consume_key(Modifiers::CTRL, Key::H) {
-        //        self.buffer.push(BufferItem::Painting(Default::default()));
-        //    }
-        //});
+        ctx.input_mut(|input| {
+            if input.consume_key(Modifiers::CTRL, Key::S) {
+                self.save_active_tab(ctx);
+            }
+        });
 
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
-            egui::containers::menu::Bar::new().ui(ui, |ui| {
+            egui::MenuBar::new().ui(ui, |ui| {
                 // NOTE: no File->Quit on web pages!
                 ui.menu_button("Menu ⚙", |ui| {
                     ui.label(RichText::new("Action").weak());
@@ -205,27 +306,32 @@ impl eframe::App for App {
 
                     #[cfg(not(target_arch = "wasm32"))]
                     if ui.button("Open File").clicked() {
-                        let actions_tx = self.actions_tx(ui.ctx());
-                        std::thread::spawn(move || {
-                            let file = rfd::FileDialog::new().pick_file();
+                        self.jobs.start(ui.ctx(), move || {
+                            let file_path = rfd::FileDialog::new().pick_file()?;
 
-                            let Some(file_path) = file else { return };
+                            let mut file = fs::File::open(&file_path)
+                                .inspect_err(|e| log::error!("Failed to open {file_path:?}: {e}"))
+                                .ok()?;
 
-                            let text = match fs::read_to_string(&file_path) {
-                                Ok(text) => text,
-                                Err(e) => {
-                                    log::error!("Failed to read {file_path:?}: {e}");
-                                    return;
-                                }
-                            };
+                            let mtime = log_error(eyre!("file_path:?"), || file_mtime(&file))?;
 
-                            let editor = FileEditor::from_file(file_path, &text);
-                            let _ = actions_tx.send(Action::OpenFile(editor));
+                            let mut text = String::new();
+                            file.read_to_string(&mut text)
+                                .inspect_err(|e| log::error!("Failed to read {file_path:?}: {e}"))
+                                .ok()?;
+
+                            let editor = FileEditor::from_file(file_path, &text, mtime);
+                            Some(Action::OpenFile(editor))
                         });
                     }
 
                     if ui.button("Open Folder").clicked() {
-                        log::error!("Open Folder not implemented");
+                        self.jobs.start(ui.ctx(), move || {
+                            let path = rfd::FileDialog::new().pick_folder()?;
+                            let name = path.file_name()?.to_string_lossy().to_string();
+                            let folder = Folder::NotLoaded { name, path };
+                            Some(Action::OpenFolder(folder))
+                        });
                     }
 
                     if ui
@@ -237,52 +343,41 @@ impl eframe::App for App {
                         }
                     }
 
-                    let open_file =
-                        self.open_tab_index
-                            .and_then(|i| self.tabs.get(i))
-                            .and_then(|(id, tab)| match tab {
-                                Tab::File(file_editor) => Some((*id, file_editor)),
-                            });
+                    let can_save_file = self
+                        .open_tab_index
+                        .and_then(|i| self.tabs.get(i))
+                        .map(|(id, tab)| match tab {
+                            Tab::File(file_editor) => (*id, file_editor),
+                        })
+                        .and_then(|(_, file_editor)| file_editor.path().zip(Some(file_editor)))
+                        .is_some();
 
-                    let open_file_with_path = open_file
-                        .clone()
-                        .and_then(|(_, file_editor)| file_editor.path().zip(Some(file_editor)));
-
-                    if ui
-                        .add_enabled(open_file_with_path.is_some(), Button::new("Save"))
-                        .clicked()
-                    {
-                        if let Some((file_path, file_editor)) = open_file_with_path {
-                            let text = file_editor.to_string();
-                            let file_path = file_path.to_owned();
-                            std::thread::spawn(move || {
-                                if let Err(e) = fs::write(file_path, text.as_bytes()) {
-                                    log::error!("{e}");
-                                };
-                            });
-                        }
+                    if ui.add_enabled(can_save_file, Button::new("Save")).clicked() {
+                        self.save_active_tab(ui.ctx());
                     }
 
+                    let open_file = self.open_tab_index.and_then(|i| self.tabs.get(i)).map(
+                        |(id, tab)| match tab {
+                            Tab::File(file_editor) => (*id, file_editor),
+                        },
+                    );
+
                     #[cfg(not(target_arch = "wasm32"))]
                     if ui
                         .add_enabled(open_file.is_some(), Button::new("Save As"))
                         .clicked()
                     {
-                        let actions_tx = self.actions_tx(ui.ctx());
                         let (tab_id, editor) =
                             open_file.expect("We checked that open_file is_some");
                         let text = editor.to_string();
-                        std::thread::spawn(move || {
-                            let Some(file_path) = rfd::FileDialog::new().save_file() else {
-                                return;
-                            };
+                        self.jobs.start(ui.ctx(), move || {
+                            let file_path = rfd::FileDialog::new().save_file()?;
 
-                            if let Err(e) = fs::write(&file_path, text.as_bytes()) {
-                                log::error!("{e}");
-                                return;
-                            };
+                            fs::write(&file_path, text.as_bytes())
+                                .inspect_err(|e| log::error!("{e}"))
+                                .ok()?;
 
-                            let _ = actions_tx.send(Action::MoveFile(tab_id, file_path));
+                            Some(Action::MoveFile(tab_id, file_path))
                         });
                     }
 
@@ -297,7 +392,18 @@ impl eframe::App for App {
                     }
                 });
 
-                ui.add_space(16.0);
+                ui.add_space(8.0);
+
+                let image = Image::new(include_image!("../assets/collapse-icon.svg"));
+                let image = image.tint(ui.style().visuals.text_color());
+                if Button::image(image).ui(ui).clicked() {
+                    self.show_folders = !self.show_folders;
+                }
+
+                if !self.jobs.handles.is_empty() {
+                    ui.add_space(8.0);
+                    ui.spinner();
+                }
 
                 ui.add_space(16.0);
 
@@ -306,9 +412,8 @@ impl eframe::App for App {
                         let selected = self.open_tab_index == Some(i);
                         let mut button = Button::new(tab.title()).selected(selected);
 
-                        let dirty = i == 0; // TODO: mark as dirty when contents hasn't been saved
-                        if dirty {
-                            button = button.right_text(RichText::new("*").strong())
+                        if let Some(symbol) = tab.notice_symbol() {
+                            button = button.right_text(RichText::new(symbol).strong())
                         }
 
                         let response = ui.add(button);
@@ -323,6 +428,48 @@ impl eframe::App for App {
             });
         });
 
+        egui::SidePanel::left("file browser")
+            .resizable(true)
+            .show_animated(ctx, self.show_folders, |ui| {
+                if ui.button("refresh").clicked() {
+                    for folder in &mut self.folders {
+                        folder.unload();
+                    }
+                }
+
+                ScrollArea::both().auto_shrink(false).show(ui, |ui| {
+                    self.folders.retain_mut(|folder| {
+                        let response = folder.show(ui);
+
+                        if let Some(file_path) = response.open_file {
+                            let file_path = file_path.to_owned();
+                            self.jobs.start(ui.ctx(), move || {
+                                let mut file = fs::File::open(&file_path)
+                                    .inspect_err(|e| {
+                                        log::error!("Failed to open {file_path:?}: {e}")
+                                    })
+                                    .ok()?;
+
+                                let mtime = log_error(eyre!("file_path:?"), || file_mtime(&file))?;
+
+                                let mut text = String::new();
+                                file.read_to_string(&mut text)
+                                    .inspect_err(|e| {
+                                        log::error!("Failed to read {file_path:?}: {e}")
+                                    })
+                                    .ok()?;
+
+                                let editor = FileEditor::from_file(file_path, &text, mtime);
+                                Some(Action::OpenFile(editor))
+                            });
+                        }
+
+                        // delete on right-click
+                        !response.clicked_by(PointerButton::Secondary)
+                    });
+                });
+            });
+
         egui::CentralPanel::default().show(ctx, |ui| {
             if let Some(Tab::File(file_editor)) = self
                 .open_tab_index
@@ -354,5 +501,17 @@ impl App {
         let id = self.next_tab_id;
         self.next_tab_id += 1;
         self.tabs.insert(i, (id, tab));
+        self.open_tab_index = Some(i);
+    }
+
+    fn save_active_tab(&mut self, ctx: &Context) {
+        let open_tab = self
+            .open_tab_index
+            .and_then(|i| self.tabs.get_mut(i))
+            .map(|(_id, tab)| tab);
+
+        if let Some(open_tab) = open_tab {
+            open_tab.save(ctx, &mut self.jobs);
+        }
     }
 }

src/easy_mark/easy_mark_highlighter.rs

@@ -1,243 +0,0 @@
-use egui::text::{CCursorRange, LayoutJob};
-
-use crate::easy_mark::easy_mark_parser;
-
-/// Highlight easymark, memoizing previous output to save CPU.
-///
-/// In practice, the highlighter is fast enough not to need any caching.
-#[derive(Default)]
-pub struct MemoizedHighlighter {
-    style: egui::Style,
-    code: String,
-    output: LayoutJob,
-}
-
-impl MemoizedHighlighter {
-    pub fn highlight(
-        &mut self,
-        egui_style: &egui::Style,
-        code: &str,
-        cursor: Option<CCursorRange>,
-    ) -> LayoutJob {
-        if (&self.style, self.code.as_str()) != (egui_style, code) {
-            self.style = egui_style.clone();
-            code.clone_into(&mut self.code);
-            self.output = highlight_easymark(egui_style, code, cursor);
-        }
-        self.output.clone()
-    }
-}
-
-pub fn highlight_easymark(
-    egui_style: &egui::Style,
-    mut text: &str,
-
-    // TODO: hide special characters where cursor isn't
-    _cursor: Option<CCursorRange>,
-) -> LayoutJob {
-    let mut job = LayoutJob::default();
-    let mut style = easy_mark_parser::Style::default();
-    let mut start_of_line = true;
-
-    const CODE_INDENT: f32 = 10.0;
-
-    while !text.is_empty() {
-        if start_of_line && text.starts_with("```") {
-            let astyle = format_from_style(
-                egui_style,
-                &easy_mark_parser::Style {
-                    code: true,
-                    ..Default::default()
-                },
-            );
-
-            // Render the initial backticks as spaces
-            text = &text[3..];
-            job.append("   ", CODE_INDENT, astyle.clone());
-
-            match text.find("\n```") {
-                Some(n) => {
-                    for line in text[..n + 1].lines() {
-                        job.append(line, CODE_INDENT, astyle.clone());
-                        job.append("\n", 0.0, astyle.clone());
-                    }
-                    // Render the final backticks as spaces
-                    job.append("   ", CODE_INDENT, astyle);
-                    text = &text[n + 4..];
-                }
-                None => {
-                    job.append(text, 0.0, astyle.clone());
-                    text = "";
-                }
-            };
-            style = Default::default();
-            continue;
-        }
-
-        if text.starts_with('`') {
-            style.code = true;
-            let end = text[1..]
-                .find(&['`', '\n'][..])
-                .map_or_else(|| text.len(), |i| i + 2);
-            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
-            text = &text[end..];
-            style.code = false;
-            continue;
-        }
-
-        let skip;
-
-        // zero-width space
-        let _zws = "\u{200b}";
-
-        let mut apply_basic_style =
-            |text: &mut &str,
-             style: &mut easy_mark_parser::Style,
-             access: fn(&mut easy_mark_parser::Style) -> &mut bool| {
-                let skip = if *access(style) {
-                    // Include the character that is ending this style:
-                    job.append(&text[..1], 0.0, format_from_style(egui_style, style));
-                    *text = &text[1..];
-                    0
-                } else {
-                    1
-                };
-                *access(style) ^= true;
-                skip
-            };
-
-        if text.starts_with('*') {
-            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.strong);
-        } else if text.starts_with('/') {
-            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.italics);
-        } else if text.starts_with('_') {
-            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.underline);
-        } else if text.starts_with('$') {
-            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.small);
-        } else if text.starts_with('~') {
-            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.strikethrough);
-        } else if text.starts_with('^') {
-            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.raised);
-        } else if text.starts_with('\\') && text.len() >= 2 {
-            skip = 2;
-        } else if start_of_line && text.starts_with(' ') {
-            // we don't preview indentation, because it is confusing
-            skip = 1;
-        } else if start_of_line && text.starts_with("###### ") {
-            style.heading = true;
-            skip = 7;
-        } else if start_of_line && text.starts_with("##### ") {
-            style.heading = true;
-            skip = 6;
-        } else if start_of_line && text.starts_with("#### ") {
-            style.heading = true;
-            skip = 5;
-        } else if start_of_line && text.starts_with("### ") {
-            style.heading = true;
-            skip = 4;
-        } else if start_of_line && text.starts_with("## ") {
-            style.heading = true;
-            skip = 3;
-        } else if start_of_line && text.starts_with("# ") {
-            style.heading = true;
-            skip = 2;
-        } else if start_of_line && text.starts_with("> ") {
-            style.quoted = true;
-            skip = 2;
-            // we don't preview indentation, because it is confusing
-        } else if start_of_line && text.trim_start().starts_with("- ") {
-            job.append("• ", 0.0, format_from_style(egui_style, &style));
-            text = &text[2..];
-            skip = 0;
-            // we don't preview indentation, because it is confusing
-        } else {
-            skip = 0;
-        }
-        // Note: we don't preview underline, strikethrough and italics because it confuses things.
-
-        // Swallow everything up to the next special character:
-        let line_end = text[skip..]
-            .find('\n')
-            .map_or_else(|| text.len(), |i| (skip + i + 1));
-        let end = text[skip..]
-            .find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '['][..])
-            .map_or_else(|| text.len(), |i| (skip + i).max(1));
-
-        if line_end <= end {
-            job.append(
-                &text[..line_end],
-                0.0,
-                format_from_style(egui_style, &style),
-            );
-            text = &text[line_end..];
-            start_of_line = true;
-            style = Default::default();
-        } else {
-            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
-            text = &text[end..];
-            start_of_line = false;
-        }
-    }
-
-    job
-}
-
-fn format_from_style(
-    egui_style: &egui::Style,
-    emark_style: &easy_mark_parser::Style,
-) -> egui::text::TextFormat {
-    use egui::{Align, Color32, Stroke, TextStyle};
-
-    let color = if emark_style.strong || emark_style.heading {
-        egui_style.visuals.strong_text_color()
-    } else if emark_style.quoted {
-        egui_style.visuals.weak_text_color()
-    } else {
-        egui_style.visuals.text_color()
-    };
-
-    let text_style = if emark_style.heading {
-        TextStyle::Heading
-    } else if emark_style.code {
-        TextStyle::Monospace
-    } else if emark_style.small | emark_style.raised {
-        TextStyle::Small
-    } else {
-        TextStyle::Body
-    };
-
-    let background = if emark_style.code {
-        egui_style.visuals.code_bg_color
-    } else {
-        Color32::TRANSPARENT
-    };
-
-    let underline = if emark_style.underline {
-        Stroke::new(1.0, color)
-    } else {
-        Stroke::NONE
-    };
-
-    let strikethrough = if emark_style.strikethrough {
-        Stroke::new(1.0, color)
-    } else {
-        Stroke::NONE
-    };
-
-    let valign = if emark_style.raised {
-        Align::TOP
-    } else {
-        Align::BOTTOM
-    };
-
-    egui::text::TextFormat {
-        font_id: text_style.resolve(egui_style),
-        color,
-        background,
-        italics: emark_style.italics,
-        underline,
-        strikethrough,
-        valign,
-        ..Default::default()
-    }
-}

src/easy_mark/easy_mark_parser.rs

@@ -1,346 +0,0 @@
-//! A parser for `EasyMark`: a very simple markup language.
-//!
-//! WARNING: `EasyMark` is subject to change.
-//
-//! # `EasyMark` design goals:
-//! 1. easy to parse
-//! 2. easy to learn
-//! 3. similar to markdown
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Item<'a> {
-    /// `\n`
-    // TODO(emilk): add Style here so empty heading still uses up the right amount of space.
-    Newline,
-
-    /// Text
-    Text(Style, &'a str),
-
-    /// title, url
-    Hyperlink(Style, &'a str, &'a str),
-
-    /// leading space before e.g. a [`Self::BulletPoint`].
-    Indentation(usize),
-
-    /// >
-    QuoteIndent,
-
-    /// - a point well made.
-    BulletPoint,
-
-    /// 1. numbered list. The string is the number(s).
-    NumberedPoint(&'a str),
-
-    /// ---
-    Separator,
-
-    /// language, code
-    CodeBlock(&'a str, &'a str),
-}
-
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-pub struct Style {
-    /// # heading (large text)
-    pub heading: bool,
-
-    /// > quoted (slightly dimmer color or other font style)
-    pub quoted: bool,
-
-    /// `code` (monospace, some other color)
-    pub code: bool,
-
-    /// self.strong* (emphasized, e.g. bold)
-    pub strong: bool,
-
-    /// _underline_
-    pub underline: bool,
-
-    /// ~strikethrough~
-    pub strikethrough: bool,
-
-    /// /italics/
-    pub italics: bool,
-
-    /// $small$
-    pub small: bool,
-
-    /// ^raised^
-    pub raised: bool,
-}
-
-/// Parser for the `EasyMark` markup language.
-pub struct Parser<'a> {
-    /// The remainder of the input text
-    s: &'a str,
-
-    /// Are we at the start of a line?
-    start_of_line: bool,
-
-    /// Current self.style. Reset after a newline.
-    style: Style,
-}
-
-impl<'a> Parser<'a> {
-    pub fn new(s: &'a str) -> Self {
-        Self {
-            s,
-            start_of_line: true,
-            style: Style::default(),
-        }
-    }
-
-    /// `1. `, `42. ` etc.
-    fn numbered_list(&mut self) -> Option<Item<'a>> {
-        let n_digits = self.s.chars().take_while(|c| c.is_ascii_digit()).count();
-        if n_digits > 0 && self.s.chars().skip(n_digits).take(2).eq(". ".chars()) {
-            let number = &self.s[..n_digits];
-            self.s = &self.s[(n_digits + 2)..];
-            self.start_of_line = false;
-            return Some(Item::NumberedPoint(number));
-        }
-        None
-    }
-
-    // ```{language}\n{code}```
-    fn code_block(&mut self) -> Option<Item<'a>> {
-        if let Some(language_start) = self.s.strip_prefix("```") {
-            if let Some(newline) = language_start.find('\n') {
-                let language = &language_start[..newline];
-                let code_start = &language_start[newline + 1..];
-                if let Some(end) = code_start.find("\n```") {
-                    let code = &code_start[..end].trim();
-                    self.s = &code_start[end + 4..];
-                    self.start_of_line = false;
-                    return Some(Item::CodeBlock(language, code));
-                } else {
-                    self.s = "";
-                    return Some(Item::CodeBlock(language, code_start));
-                }
-            }
-        }
-        None
-    }
-
-    // `code`
-    fn inline_code(&mut self) -> Option<Item<'a>> {
-        if let Some(rest) = self.s.strip_prefix('`') {
-            self.s = rest;
-            self.start_of_line = false;
-            self.style.code = true;
-            let rest_of_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
-            if let Some(end) = rest_of_line.find('`') {
-                let item = Item::Text(self.style, &self.s[..end]);
-                self.s = &self.s[end + 1..];
-                self.style.code = false;
-                return Some(item);
-            } else {
-                let end = rest_of_line.len();
-                let item = Item::Text(self.style, rest_of_line);
-                self.s = &self.s[end..];
-                self.style.code = false;
-                return Some(item);
-            }
-        }
-        None
-    }
-
-    /// `<url>` or `[link](url)`
-    fn url(&mut self) -> Option<Item<'a>> {
-        if self.s.starts_with('<') {
-            let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
-            if let Some(url_end) = this_line.find('>') {
-                let url = &self.s[1..url_end];
-                self.s = &self.s[url_end + 1..];
-                self.start_of_line = false;
-                return Some(Item::Hyperlink(self.style, url, url));
-            }
-        }
-
-        // [text](url)
-        if self.s.starts_with('[') {
-            let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
-            if let Some(bracket_end) = this_line.find(']') {
-                let text = &this_line[1..bracket_end];
-                if this_line[bracket_end + 1..].starts_with('(') {
-                    if let Some(parens_end) = this_line[bracket_end + 2..].find(')') {
-                        let parens_end = bracket_end + 2 + parens_end;
-                        let url = &self.s[bracket_end + 2..parens_end];
-                        self.s = &self.s[parens_end + 1..];
-                        self.start_of_line = false;
-                        return Some(Item::Hyperlink(self.style, text, url));
-                    }
-                }
-            }
-        }
-        None
-    }
-}
-
-impl<'a> Iterator for Parser<'a> {
-    type Item = Item<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            if self.s.is_empty() {
-                return None;
-            }
-
-            // \n
-            if self.s.starts_with('\n') {
-                self.s = &self.s[1..];
-                self.start_of_line = true;
-                self.style = Style::default();
-                return Some(Item::Newline);
-            }
-
-            // Ignore line break (continue on the same line)
-            if self.s.starts_with("\\\n") && self.s.len() >= 2 {
-                self.s = &self.s[2..];
-                self.start_of_line = false;
-                continue;
-            }
-
-            // \ escape (to show e.g. a backtick)
-            if self.s.starts_with('\\') && self.s.len() >= 2 {
-                let text = &self.s[1..2];
-                self.s = &self.s[2..];
-                self.start_of_line = false;
-                return Some(Item::Text(self.style, text));
-            }
-
-            if self.start_of_line {
-                // leading space (indentation)
-                if self.s.starts_with(' ') {
-                    let length = self.s.find(|c| c != ' ').unwrap_or(self.s.len());
-                    self.s = &self.s[length..];
-                    self.start_of_line = true; // indentation doesn't count
-                    return Some(Item::Indentation(length));
-                }
-
-                // # Heading
-                if let Some(after) = self.s.strip_prefix("# ") {
-                    self.s = after;
-                    self.start_of_line = false;
-                    self.style.heading = true;
-                    continue;
-                }
-
-                // > quote
-                if let Some(after) = self.s.strip_prefix("> ") {
-                    self.s = after;
-                    self.start_of_line = true; // quote indentation doesn't count
-                    self.style.quoted = true;
-                    return Some(Item::QuoteIndent);
-                }
-
-                // - bullet point
-                if self.s.starts_with("- ") {
-                    self.s = &self.s[2..];
-                    self.start_of_line = false;
-                    return Some(Item::BulletPoint);
-                }
-
-                // `1. `, `42. ` etc.
-                if let Some(item) = self.numbered_list() {
-                    return Some(item);
-                }
-
-                // --- separator
-                if let Some(after) = self.s.strip_prefix("---") {
-                    self.s = after.trim_start_matches('-'); // remove extra dashes
-                    self.s = self.s.strip_prefix('\n').unwrap_or(self.s); // remove trailing newline
-                    self.start_of_line = false;
-                    return Some(Item::Separator);
-                }
-
-                // ```{language}\n{code}```
-                if let Some(item) = self.code_block() {
-                    return Some(item);
-                }
-            }
-
-            // `code`
-            if let Some(item) = self.inline_code() {
-                return Some(item);
-            }
-
-            if let Some(rest) = self.s.strip_prefix('*') {
-                self.s = rest;
-                self.start_of_line = false;
-                self.style.strong = !self.style.strong;
-                continue;
-            }
-            if let Some(rest) = self.s.strip_prefix('_') {
-                self.s = rest;
-                self.start_of_line = false;
-                self.style.underline = !self.style.underline;
-                continue;
-            }
-            if let Some(rest) = self.s.strip_prefix('~') {
-                self.s = rest;
-                self.start_of_line = false;
-                self.style.strikethrough = !self.style.strikethrough;
-                continue;
-            }
-            if let Some(rest) = self.s.strip_prefix('/') {
-                self.s = rest;
-                self.start_of_line = false;
-                self.style.italics = !self.style.italics;
-                continue;
-            }
-            if let Some(rest) = self.s.strip_prefix('$') {
-                self.s = rest;
-                self.start_of_line = false;
-                self.style.small = !self.style.small;
-                continue;
-            }
-            if let Some(rest) = self.s.strip_prefix('^') {
-                self.s = rest;
-                self.start_of_line = false;
-                self.style.raised = !self.style.raised;
-                continue;
-            }
-
-            // `<url>` or `[link](url)`
-            if let Some(item) = self.url() {
-                return Some(item);
-            }
-
-            // Swallow everything up to the next special character:
-            let end = self
-                .s
-                .find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '[', '\n'][..])
-                .map_or_else(|| self.s.len(), |special| special.max(1));
-
-            let item = Item::Text(self.style, &self.s[..end]);
-            self.s = &self.s[end..];
-            self.start_of_line = false;
-            return Some(item);
-        }
-    }
-}
-
-#[test]
-fn test_easy_mark_parser() {
-    let items: Vec<_> = Parser::new("~strikethrough `code`~").collect();
-    assert_eq!(
-        items,
-        vec![
-            Item::Text(
-                Style {
-                    strikethrough: true,
-                    ..Default::default()
-                },
-                "strikethrough "
-            ),
-            Item::Text(
-                Style {
-                    code: true,
-                    strikethrough: true,
-                    ..Default::default()
-                },
-                "code"
-            ),
-        ]
-    );
-}

src/easy_mark/mod.rs

@@ -1,7 +0,0 @@
-//! Experimental markup language
-
-mod easy_mark_highlighter;
-pub mod easy_mark_parser;
-
-pub use easy_mark_highlighter::{MemoizedHighlighter, highlight_easymark};
-pub use easy_mark_parser as parser;

src/file_editor.rs

@@ -1,53 +1,117 @@
 use std::{
     cmp::Ordering,
     fmt::{self, Display},
+    fs::{self, File},
+    io::Write,
     ops::{Div as _, Sub as _},
     path::{Path, PathBuf},
     str::FromStr,
+    sync::mpsc,
 };
 
+use chrono::{DateTime, Local};
 use egui::{
-    Align, Button, DragAndDrop, Frame, Layout, ScrollArea, Ui, UiBuilder, Vec2, Widget as _, vec2,
+    Align, Button, Context, DragAndDrop, Frame, Layout, ScrollArea, Ui, UiBuilder, Vec2,
+    Widget as _, vec2,
 };
+use eyre::eyre;
+use notify::{EventKind, Watcher};
 
 use crate::{
+    app::Jobs,
     custom_code_block::{MdItem, iter_lines_and_code_blocks},
-    painting::{self, Handwriting, HandwritingStyle},
+    handwriting::{self, Handwriting, HandwritingStyle},
     preferences::Preferences,
     text_editor::MdTextEdit,
+    util::{file_mtime, log_error},
 };
 
 #[derive(serde::Deserialize, serde::Serialize)]
 pub struct FileEditor {
     title: String,
-    pub path: Option<PathBuf>,
+
+    path: Option<PathBuf>,
     pub buffer: Vec<BufferItem>,
+
+    pub file_mtime: Option<DateTime<Local>>,
+    pub buffer_mtime: DateTime<Local>,
+
+    // TODO: instantiate these on load
+    #[serde(skip)]
+    inner: Option<Inner>,
+
+    /// The distance to scroll when paging up or down.
+    ///
+    /// This is calculated when the view is rendered.
+    #[serde(skip)]
+    scroll_delta: f32,
+
+    /// Whether the file has been edited since it was last saved to disk.
+    is_dirty: bool,
+}
+
+struct Inner {
+    file_events: mpsc::Receiver<FileEvent>,
+    file_events_tx: mpsc::Sender<FileEvent>,
+    _file_watcher: notify::RecommendedWatcher,
+}
+
+#[derive(Debug)]
+pub enum SaveStatus {
+    /// The contents of the buffer is the same as on disk.
+    Synced,
+
+    /// The contents exits only in memory and has never been saved to disk.
+    NoFile,
+
+    /// The buffer has been edited but not saved to disk.
+    FileOutdated,
+
+    /// The contents on disk has changes that are newer than the buffer.
+    BufferOutdated,
+
+    /// The contents on disk and in the buffer has diverged.
+    Desynced,
+}
+
+#[derive(Debug)]
+enum FileEvent {
+    NewFileMTime(DateTime<Local>),
+    NewBufferMTime(DateTime<Local>),
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
 pub enum BufferItem {
-    Text(MdTextEdit),
-    Handwriting(Handwriting),
+    Text(Box<MdTextEdit>),
+    Handwriting(Box<Handwriting>),
 }
 
 impl FileEditor {
     pub fn new(title: impl Into<String>) -> Self {
-        let buffer = vec![BufferItem::Text(MdTextEdit::new())];
+        let buffer = vec![BufferItem::Text(Box::new(MdTextEdit::new()))];
         Self {
             title: title.into(),
             path: None,
             buffer,
+            file_mtime: None,
+            buffer_mtime: Local::now(),
+            scroll_delta: 0.0,
+            is_dirty: false,
+            inner: None,
         }
     }
 
-    pub fn from_file(file_path: PathBuf, contents: &str) -> Self {
+    pub fn from_file(file_path: PathBuf, contents: &str, mtime: DateTime<Local>) -> Self {
         let file_title = file_path
             .file_name()
             .map(|name| name.to_string_lossy().to_string())
             .unwrap_or_else(|| String::from("untitled.md"));
+
         Self {
             title: file_title,
             path: Some(file_path),
+            file_mtime: Some(mtime),
+            buffer_mtime: mtime,
             ..FileEditor::from(contents)
         }
     }
@@ -60,24 +124,91 @@ impl FileEditor {
         self.path.as_deref()
     }
 
+    pub fn save_status(&self) -> SaveStatus {
+        let Some(file_mtime) = self.file_mtime else {
+            return SaveStatus::NoFile;
+        };
+
+        let buffer_is_newer = self.buffer_mtime > file_mtime;
+        let file_is_newer = self.buffer_mtime < file_mtime;
+
+        if buffer_is_newer || (file_is_newer && self.is_dirty) {
+            SaveStatus::Desynced
+        } else if file_is_newer {
+            SaveStatus::BufferOutdated
+        } else if self.is_dirty {
+            SaveStatus::FileOutdated
+        } else {
+            SaveStatus::Synced
+        }
+    }
+
     pub fn show(&mut self, ui: &mut Ui, preferences: &Preferences) {
+        if let Some(path) = &self.path
+            && self.inner.is_none()
+        {
+            self.inner = Some(spawn_file_watcher(path));
+        }
+
+        if let Some(inner) = &mut self.inner {
+            while let Ok(event) = inner.file_events.try_recv() {
+                match event {
+                    FileEvent::NewFileMTime(mtime) => {
+                        self.file_mtime = Some(mtime);
+                    }
+                    FileEvent::NewBufferMTime(mtime) => {
+                        self.buffer_mtime = mtime;
+                        self.file_mtime = Some(mtime);
+                    }
+                }
+            }
+        }
+
         ui.vertical_centered_justified(|ui| {
             ui.heading(&self.title);
 
             const MAX_NOTE_WIDTH: f32 = 600.0;
 
-            ui.horizontal(|ui| {
-                ui.label("new");
-                if ui.button("text").clicked() {
-                    self.buffer.push(BufferItem::Text(Default::default()));
+            // distance to scroll when paging up or down.
+            let mut scroll_delta = 0.0;
+
+            ui.input_mut(|input| {
+                if input.consume_key(egui::Modifiers::NONE, egui::Key::PageUp) {
+                    scroll_delta += self.scroll_delta;
                 }
-                if ui.button("writing").clicked() {
-                    self.buffer
-                        .push(BufferItem::Handwriting(Default::default()));
+                if input.consume_key(egui::Modifiers::NONE, egui::Key::PageDown) {
+                    scroll_delta -= self.scroll_delta;
                 }
             });
 
-            ScrollArea::vertical().show(ui, |ui| {
+            ui.horizontal(|ui| {
+                ui.label("new");
+                if ui.button(" text ").clicked() {
+                    self.is_dirty = true;
+                    self.buffer.push(BufferItem::Text(Default::default()));
+                }
+                if ui.button("writing").clicked() {
+                    self.is_dirty = true;
+                    self.buffer
+                        .push(BufferItem::Handwriting(Default::default()));
+                }
+
+                ui.add_space(16.0);
+
+                ui.label("scroll");
+                if ui.button("  up  ").clicked() {
+                    scroll_delta += self.scroll_delta;
+                }
+                if ui.button("down").clicked() {
+                    scroll_delta -= self.scroll_delta;
+                }
+            });
+
+            let scroll_area = ScrollArea::vertical().show(ui, |ui| {
+                if scroll_delta != 0.0 {
+                    ui.scroll_with_delta(Vec2::new(0.0, scroll_delta));
+                }
+
                 ui.horizontal(|ui| {
                     let side_padding = ui.available_width().sub(MAX_NOTE_WIDTH).max(0.0).div(2.0);
                     ui.add_space(side_padding);
@@ -88,6 +219,8 @@ impl FileEditor {
                     ui.add_space(side_padding);
                 });
             });
+
+            self.scroll_delta = scroll_area.inner_rect.height() * 0.9;
         });
     }
 
@@ -138,14 +271,19 @@ impl FileEditor {
 
                 let item_response = ui.allocate_ui(item_size, |ui| match item {
                     BufferItem::Text(text_edit) => {
-                        text_edit.ui(ui);
+                        if text_edit.ui(ui).changed {
+                            self.is_dirty = true;
+                        }
                     }
-                    BufferItem::Handwriting(painting) => {
+                    BufferItem::Handwriting(handwriting) => {
                         let style = HandwritingStyle {
                             animate: preferences.animations,
+                            hide_cursor: preferences.hide_handwriting_cursor,
                             ..HandwritingStyle::from_theme(ui.ctx().theme())
                         };
-                        painting.ui(&style, ui);
+                        if handwriting.ui(&style, ui).changed {
+                            self.is_dirty = true;
+                        }
                     }
                 });
 
@@ -159,7 +297,7 @@ impl FileEditor {
                 dragger_rect.set_height(item_response.response.rect.height());
 
                 // Controls for moving the buffer item
-                ui.allocate_new_ui(
+                ui.scope_builder(
                     UiBuilder::new()
                         .max_rect(dragger_rect)
                         .layout(Layout::top_down(Align::Center)),
@@ -211,10 +349,12 @@ impl FileEditor {
                     Ordering::Greater => {
                         let item = self.buffer.remove(from);
                         self.buffer.insert(to, item);
+                        self.is_dirty = true;
                     }
                     Ordering::Less => {
                         let item = self.buffer.remove(from);
                         self.buffer.insert(to - 1, item);
+                        self.is_dirty = true;
                     }
                     Ordering::Equal => {}
                 }
@@ -230,6 +370,38 @@ impl FileEditor {
         self.title = title.to_string_lossy().to_string();
         self.path = Some(new_path);
     }
+
+    pub fn set_dirty(&mut self, value: bool) {
+        self.is_dirty = value;
+    }
+
+    pub fn save(&mut self, ctx: &Context, jobs: &mut Jobs) {
+        let Some(file_path) = self.path.clone() else {
+            log::info!("Can't save {}, no path set.", self.title);
+            return;
+        };
+
+        self.is_dirty = false;
+        let text = self.to_string();
+        let inner = self
+            .inner
+            .get_or_insert_with(|| spawn_file_watcher(&file_path));
+        let file_event_tx = inner.file_events_tx.clone();
+
+        jobs.start(ctx, move || {
+            log_error(eyre!("Failed to save file {file_path:?}"), || {
+                let mut file = fs::File::create(file_path)?;
+                file.write_all(text.as_bytes())?;
+                let mtime = file_mtime(&file)?;
+
+                let _ = file_event_tx.send(FileEvent::NewBufferMTime(mtime));
+
+                Ok(())
+            });
+
+            None
+        });
+    }
 }
 
 impl Display for BufferItem {
@@ -267,7 +439,7 @@ impl From<&str> for FileEditor {
             _ => {
                 let mut text_edit = MdTextEdit::new();
                 text_edit.text.push_str(text);
-                buffer.push(BufferItem::Text(text_edit));
+                buffer.push(BufferItem::Text(Box::new(text_edit)));
             }
         };
 
@@ -275,7 +447,7 @@ impl From<&str> for FileEditor {
             match item {
                 MdItem::Line(line) => push_text(buffer, line),
                 MdItem::CodeBlock { key, content, span } => match key {
-                    painting::CODE_BLOCK_KEY => match Handwriting::from_str(span) {
+                    handwriting::CODE_BLOCK_KEY => match Handwriting::from_str(span) {
                         Ok(handwriting) => {
                             if let Some(BufferItem::Text(text_edit)) = buffer.last_mut() {
                                 if text_edit.text.ends_with('\n') {
@@ -285,7 +457,7 @@ impl From<&str> for FileEditor {
                                     }
                                 }
                             };
-                            buffer.push(BufferItem::Handwriting(handwriting))
+                            buffer.push(BufferItem::Handwriting(Box::new(handwriting)))
                         }
                         Err(e) => {
                             log::error!("Failed to decode handwriting {content:?}: {e}");
@@ -301,6 +473,40 @@ impl From<&str> for FileEditor {
     }
 }
 
+fn spawn_file_watcher(p: &Path) -> Inner {
+    let (tx, rx) = mpsc::channel();
+
+    let path = p.to_owned();
+    let events_tx = tx.clone();
+    let mut watcher = notify::recommended_watcher(move |event: notify::Result<notify::Event>| {
+        log_error(eyre!("watch {path:?} error"), || {
+            match event?.kind {
+                EventKind::Create(..) | EventKind::Modify(..) | EventKind::Remove(..) => {}
+
+                EventKind::Access(..) | EventKind::Any | EventKind::Other => return Ok(()),
+            }
+
+            let file = File::open(&path)?;
+            let mtime = file_mtime(&file)?;
+
+            let _ = events_tx.send(FileEvent::NewFileMTime(mtime));
+
+            Ok(())
+        });
+    })
+    .unwrap();
+
+    if let Err(e) = watcher.watch(p, notify::RecursiveMode::NonRecursive) {
+        log::error!("Failed to watch {p:?}: {e}");
+    };
+
+    Inner {
+        file_events: rx,
+        file_events_tx: tx,
+        _file_watcher: watcher,
+    }
+}
+
 #[cfg(test)]
 mod test {
 

src/folder.rs

@@ -0,0 +1,218 @@
+use std::{
+    fs::read_dir,
+    mem,
+    ops::Deref,
+    path::{Path, PathBuf},
+    sync::mpsc,
+    thread,
+};
+
+use egui::{Response, Ui};
+use eyre::{Context, OptionExt, eyre};
+use serde::{Deserialize, Serialize};
+
+pub enum Folder {
+    NotLoaded {
+        name: String,
+        path: PathBuf,
+    },
+    Loading {
+        name: String,
+        path: PathBuf,
+        recv: mpsc::Receiver<LoadedFolder>,
+    },
+    Loaded(LoadedFolder),
+}
+
+pub struct LoadedFolder {
+    pub name: String,
+    pub path: PathBuf,
+    pub child_folders: Vec<Folder>,
+    pub child_files: Vec<File>,
+}
+
+pub struct File {
+    pub name: String,
+    pub path: PathBuf,
+}
+
+pub struct FolderResponse<'a> {
+    inner: Response,
+    pub open_file: Option<&'a Path>,
+}
+
+impl Deref for FolderResponse<'_> {
+    type Target = Response;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl LoadedFolder {
+    pub fn show<'a>(&'a mut self, ui: &mut Ui) -> FolderResponse<'a> {
+        let mut open_file = None;
+        let inner = ui
+            .collapsing(&self.name, |ui| {
+                for folder in &mut self.child_folders {
+                    open_file = open_file.or(folder.show(ui).open_file);
+                }
+
+                for file in &mut self.child_files {
+                    if ui.button(&file.name).clicked() {
+                        open_file = Some(file.path.as_path())
+                    };
+                }
+            })
+            .header_response;
+
+        FolderResponse { inner, open_file }
+    }
+
+    fn load(path: PathBuf) -> eyre::Result<Self> {
+        let name = path
+            .file_name()
+            .ok_or_eyre("Path is missing a file-name")?
+            .to_string_lossy()
+            .to_string();
+
+        let mut child_folders = vec![];
+        let mut child_files = vec![];
+
+        for entry in read_dir(&path).with_context(|| eyre!("Couldn't read dir {path:?}"))? {
+            let entry = entry.with_context(|| eyre!("Couldn't read dir {path:?}"))?;
+            let path = entry.path();
+            let name = path
+                .file_name()
+                .ok_or_eyre("Path is missing a file-name")?
+                .to_string_lossy()
+                .to_string();
+
+            let file_type = entry.file_type()?;
+
+            if file_type.is_symlink() {
+                log::error!("Symlinks not yet supported, skipping {path:?}");
+                continue;
+            } else if file_type.is_file() {
+                child_files.push(File { name, path });
+            } else if file_type.is_dir() {
+                child_folders.push(Folder::NotLoaded { name, path });
+            }
+        }
+
+        let folder = LoadedFolder {
+            name,
+            path,
+            child_folders,
+            child_files,
+        };
+
+        Ok(folder)
+    }
+}
+
+impl Folder {
+    fn load(&mut self, ui: &mut Ui) -> Option<&mut LoadedFolder> {
+        if let Folder::NotLoaded { name, path } = self {
+            let (tx, rx) = mpsc::channel();
+
+            {
+                let path = path.clone();
+                let ctx = ui.ctx().clone();
+                thread::spawn(move || match LoadedFolder::load(path) {
+                    Err(e) => log::error!("Failed to load folder: {e}"),
+                    Ok(folder) => {
+                        let _ = tx.send(folder);
+                        ctx.request_repaint();
+                    }
+                });
+            }
+
+            *self = Folder::Loading {
+                name: mem::take(name),
+                path: mem::take(path),
+                recv: rx,
+            };
+        }
+
+        if let Folder::Loading { recv, .. } = self {
+            match recv.try_recv() {
+                Ok(folder) => *self = Folder::Loaded(folder),
+                Err(_) => return None,
+            }
+        }
+
+        let Folder::Loaded(folder) = self else {
+            unreachable!()
+        };
+
+        Some(folder)
+    }
+
+    pub fn show<'a>(&'a mut self, ui: &mut Ui) -> FolderResponse<'a> {
+        self.load(ui);
+
+        if let Folder::Loaded(folder) = self {
+            return folder.show(ui);
+        }
+
+        FolderResponse {
+            inner: ui.label(self.name()),
+            open_file: None,
+        }
+    }
+
+    pub fn path(&self) -> &Path {
+        match self {
+            Folder::NotLoaded { path, .. } => path,
+            Folder::Loading { path, .. } => path,
+            Folder::Loaded(folder) => &folder.path,
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        match self {
+            Folder::NotLoaded { name, .. } => name,
+            Folder::Loading { name, .. } => name,
+            Folder::Loaded(folder) => &folder.name,
+        }
+    }
+
+    pub fn unload(&mut self) {
+        let (name, path) = match self {
+            Folder::NotLoaded { .. } => return,
+            Folder::Loading { name, path, .. } => (name, path),
+            Folder::Loaded(folder) => (&mut folder.name, &mut folder.path),
+        };
+
+        *self = Folder::NotLoaded {
+            name: mem::take(name),
+            path: mem::take(path),
+        }
+    }
+}
+
+impl Serialize for Folder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.path().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for Folder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use serde::de::Error;
+        let path = PathBuf::deserialize(deserializer)?;
+        let name = path
+            .file_name()
+            .ok_or(D::Error::custom("Path is missing a file-name"))?
+            .to_string_lossy()
+            .to_string();
+        Ok(Folder::NotLoaded { name, path })
+    }
+}

src/handwriting/canvas_rasterizer.rs

@@ -0,0 +1,176 @@
+use std::sync::Arc;
+
+use egui::{
+    Color32, ColorImage, CornerRadius, Painter, Pos2, Rect, Stroke, StrokeKind, TextureHandle,
+    Vec2,
+    ahash::HashMap,
+    emath::TSTransform,
+    epaint::{Brush, RectShape, Vertex},
+    load::SizedTexture,
+};
+
+use crate::rasterizer::{PxBoundingBox, rasterize_triangle_onto, triangle_bounding_box};
+
+use super::StrokeBlendMode;
+
+const CHUNK_SIZE: usize = 64;
+
+/// Rasterize onto a resizeable canvas.
+#[derive(Default)]
+pub struct CanvasRasterizer {
+    image_size: [usize; 2],
+    tiles: HashMap<[usize; 2], Tile>,
+}
+
+struct Tile {
+    bounding_box: PxBoundingBox,
+    image: ColorImage,
+    texture: Option<TextureHandle>,
+    texture_is_dirty: bool,
+}
+
+impl Tile {
+    fn new(xi: usize, yi: usize) -> Self {
+        let x_from = xi * CHUNK_SIZE;
+        let y_from = yi * CHUNK_SIZE;
+        let bounding_box = PxBoundingBox {
+            x_from,
+            y_from,
+            x_to: x_from + CHUNK_SIZE,
+            y_to: y_from + CHUNK_SIZE,
+        };
+
+        Self {
+            bounding_box,
+            image: ColorImage::filled([CHUNK_SIZE, CHUNK_SIZE], Color32::TRANSPARENT),
+            texture: None,
+            texture_is_dirty: false,
+        }
+    }
+}
+
+impl CanvasRasterizer {
+    pub fn set_size(&mut self, width: usize, height: usize) {
+        self.image_size = [width, height];
+        self.populate_tiles();
+    }
+
+    pub fn clear(&mut self) {
+        log::debug!("clearing all tiles");
+        self.tiles.clear();
+        self.populate_tiles();
+    }
+
+    fn populate_tiles(&mut self) {
+        let [width, height] = self.image_size;
+
+        // discard tiles that are out of bounds
+        self.tiles.retain(|_, tile| {
+            tile.bounding_box.x_from <= width && tile.bounding_box.y_from <= height
+        });
+
+        let chunk = |max: usize| {
+            (0..)
+                .step_by(CHUNK_SIZE)
+                .take_while(move |n| n <= &max)
+                .enumerate()
+        };
+
+        // create new tiles where we need them
+        for (xi, _x) in chunk(width) {
+            for (yi, _y) in chunk(height) {
+                self.tiles
+                    .entry([xi, yi])
+                    .or_insert_with(|| Tile::new(xi, yi));
+            }
+        }
+    }
+
+    pub fn rasterize<'a>(
+        &mut self,
+        point_to_pixel: TSTransform,
+        triangles: impl Iterator<Item = [&'a Vertex; 3]> + Clone,
+    ) {
+        for triangle in triangles {
+            let triangle_bounding_box = triangle_bounding_box(&triangle, point_to_pixel);
+            for chunk in chunks_from_bounding_box(triangle_bounding_box) {
+                let Some(tile) = self.tiles.get_mut(&chunk) else {
+                    continue;
+                };
+
+                let mut point_to_tile_pixel = point_to_pixel;
+                point_to_tile_pixel.translation -= Vec2::new(
+                    tile.bounding_box.x_from as f32,
+                    tile.bounding_box.y_from as f32,
+                );
+
+                tile.texture_is_dirty = true;
+                rasterize_triangle_onto::<StrokeBlendMode>(
+                    &mut tile.image,
+                    point_to_tile_pixel,
+                    triangle,
+                );
+            }
+        }
+    }
+
+    /// `at` defines the location in screen-coordinates where the canvas should be drawn.
+    pub fn show(&mut self, ctx: &egui::Context, painter: &Painter, at: Rect) {
+        let pixels_per_point = ctx.pixels_per_point();
+        let chunk_vec = Vec2::splat(CHUNK_SIZE as f32) / pixels_per_point;
+
+        for ([xi, yi], tile) in &mut self.tiles {
+            if tile.texture_is_dirty {
+                tile.texture_is_dirty = false;
+                if let Some(texture) = &mut tile.texture {
+                    texture.set(tile.image.clone(), Default::default());
+                } else {
+                    tile.texture = Some(ctx.load_texture(
+                        "handwriting",
+                        tile.image.clone(),
+                        Default::default(),
+                    ));
+                }
+            }
+
+            if let Some(texture) = &mut tile.texture {
+                let texture = SizedTexture::new(texture.id(), texture.size_vec2());
+                let shape = RectShape {
+                    rect: Rect::from_min_size(
+                        at.min + Vec2::new(*xi as f32, *yi as f32) * chunk_vec,
+                        chunk_vec,
+                    ),
+                    corner_radius: CornerRadius::ZERO,
+                    fill: Color32::WHITE,
+                    stroke: Stroke::NONE,
+                    stroke_kind: StrokeKind::Inside,
+                    round_to_pixels: None,
+                    blur_width: 0.0,
+                    brush: Some(Arc::new(Brush {
+                        fill_texture_id: texture.id,
+                        uv: Rect {
+                            min: Pos2::ZERO,
+                            max: Pos2::new(1.0, 1.0),
+                        },
+                    })),
+                };
+                painter.add(shape);
+            }
+        }
+    }
+}
+
+/// Get all chunk indices that overlaps with a PxBoundingBox.
+fn chunks_from_bounding_box(
+    triangle_bounding_box: PxBoundingBox,
+) -> impl Iterator<Item = [usize; 2]> {
+    let x_from_chunk = triangle_bounding_box.x_from / CHUNK_SIZE;
+    let y_from_chunk = triangle_bounding_box.y_from / CHUNK_SIZE;
+    let x_to_chunk = triangle_bounding_box.x_to.saturating_sub(1) / CHUNK_SIZE;
+    let y_to_chunk = triangle_bounding_box.y_to.saturating_sub(1) / CHUNK_SIZE;
+
+    let xs = x_from_chunk..=x_to_chunk;
+    let ys = y_from_chunk..=y_to_chunk;
+
+    ys.flat_map(move |yi| xs.clone().map(move |xi| [xi, yi]))
+}

src/handwriting/disk_format.rs

@@ -0,0 +1,97 @@
+//! see [Packet]
+
+use std::fmt::Display;
+
+use half::f16;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+/// A `u16` encoded in little-endian.
+#[allow(non_camel_case_types)]
+#[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, PartialEq, Eq)]
+#[repr(C, packed)]
+pub struct u16_le([u8; 2]);
+
+/// An `f16` encoded in little-endian.
+#[allow(non_camel_case_types)]
+#[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable)]
+#[repr(C, packed)]
+pub struct f16_le(u16_le);
+
+/// Top-level type describing the handwriting disk-format.
+#[derive(FromBytes, KnownLayout, Immutable)]
+#[repr(C, packed)]
+pub struct DiskFormat {
+    pub header: Header,
+
+    /// A packed array of [Stroke]s.
+    pub strokes: [u8],
+}
+
+pub const V1: u16_le = u16_le::new(1);
+
+#[derive(FromBytes, IntoBytes, KnownLayout, Immutable)]
+#[repr(C, packed)]
+pub struct Header {
+    /// Version of the disk format
+    pub version: u16_le,
+}
+
+#[derive(FromBytes, IntoBytes, KnownLayout, Immutable)]
+#[repr(C, packed)]
+pub struct RawStrokeHeader {
+    /// Number of points in the stroke.
+    pub len: u16_le,
+}
+
+#[derive(FromBytes, KnownLayout, Immutable)]
+#[repr(C, packed)]
+pub struct RawStroke {
+    pub header: RawStrokeHeader,
+    pub positions: [f16_le],
+}
+
+impl RawStroke {
+    pub const MIN_LEN: usize = size_of::<RawStrokeHeader>();
+}
+
+impl u16_le {
+    pub const fn new(init: u16) -> Self {
+        u16_le(init.to_le_bytes())
+    }
+}
+
+impl f16_le {
+    pub const fn new(init: f16) -> Self {
+        f16_le(u16_le::new(init.to_bits()))
+    }
+}
+
+impl Display for u16_le {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        u16::from(*self).fmt(f)
+    }
+}
+
+impl From<u16_le> for u16 {
+    fn from(value: u16_le) -> Self {
+        u16::from_le_bytes(value.0)
+    }
+}
+
+impl From<f16_le> for f16 {
+    fn from(value: f16_le) -> Self {
+        f16::from_bits(u16::from(value.0))
+    }
+}
+
+impl From<u16> for u16_le {
+    fn from(value: u16) -> Self {
+        u16_le::new(value)
+    }
+}
+
+impl From<f16> for f16_le {
+    fn from(value: f16) -> Self {
+        f16_le::new(value)
+    }
+}

src/handwriting/mod.rs

@@ -1,3 +1,6 @@
+mod canvas_rasterizer;
+mod disk_format;
+
 use std::{
     fmt::{self, Display},
     iter, mem,
@@ -5,23 +8,22 @@ use std::{
     sync::Arc,
 };
 
+use arboard::Clipboard;
 use base64::{Engine, prelude::BASE64_STANDARD};
+use canvas_rasterizer::CanvasRasterizer;
+use disk_format::{DiskFormat, RawStroke, RawStrokeHeader, f16_le};
 use egui::{
-    Color32, ColorImage, CornerRadius, Event, Frame, Id, Mesh, PointerButton, Pos2, Rect, Sense,
-    Shape, Stroke, TextureHandle, Theme, Ui, Vec2,
+    Color32, Event, Frame, Id, Mesh, PointerButton, Pos2, Rect, Sense, Shape, Stroke, Theme, Ui,
+    Vec2,
     emath::{self, TSTransform},
-    epaint::{Brush, RectShape, TessellationOptions, Tessellator, Vertex},
-    load::SizedTexture,
+    epaint::{TessellationOptions, Tessellator, Vertex},
 };
 use eyre::{Context, bail};
 use eyre::{OptionExt, eyre};
 use half::f16;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, IntoBytes};
 
-use crate::{
-    custom_code_block::try_from_custom_code_block,
-    rasterizer::{self, rasterize, rasterize_onto},
-};
+use crate::{custom_code_block::try_from_custom_code_block, rasterizer};
 use crate::{custom_code_block::write_custom_code_block, util::random_id};
 
 const HANDWRITING_MIN_HEIGHT: f32 = 100.0;
@@ -33,7 +35,7 @@ pub const CODE_BLOCK_KEY: &str = "handwriting";
 
 type StrokeBlendMode = rasterizer::blend::Normal;
 
-const TESSELATION_OPTIONS: TessellationOptions = TessellationOptions {
+const TESSELLATION_OPTIONS: TessellationOptions = TessellationOptions {
     feathering: true,
     feathering_size_in_pixels: 1.0,
     coarse_tessellation_culling: true,
@@ -55,45 +57,48 @@ pub struct HandwritingStyle {
     pub bg_line_stroke: Stroke,
     pub bg_color: Color32,
     pub animate: bool,
+    pub hide_cursor: bool,
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)]
 pub struct Handwriting {
-    #[serde(skip, default = "random_id")]
-    id: Id,
-
     strokes: Vec<Vec<Pos2>>,
 
-    /// The stroke that is currently being drawed.
-    #[serde(skip)]
-    current_stroke: Vec<Pos2>,
-
-    /// The lines that have not been blitted to `texture` yet.
-    #[serde(skip)]
-    unblitted_lines: Vec<[Pos2; 2]>,
-
     height: f32,
     desired_height: f32,
 
-    /// Tesselated mesh of all strokes
     #[serde(skip)]
+    e: Ephemeral,
+}
+
+/// Handwriting data that isn't persisted across restarts.
+struct Ephemeral {
+    id: Id,
+
+    canvas_rasterizer: CanvasRasterizer,
+
+    /// The stroke that is currently being drawed.
+    current_stroke: Vec<Pos2>,
+
+    /// The lines that have not been blitted to `texture` yet.
+    unblitted_lines: Vec<[Pos2; 2]>,
+
+    tessellator: Option<Tessellator>,
+
+    /// Tessellated mesh of all strokes
     mesh: Arc<Mesh>,
 
-    #[serde(skip)]
-    texture: Option<TextureHandle>,
-
-    #[serde(skip)]
-    image: ColorImage,
-
-    #[serde(skip)]
     refresh_texture: bool,
 
     /// Context of the last mesh render.
-    #[serde(skip)]
     last_mesh_ctx: Option<MeshContext>,
 }
 
+pub struct HandwritingResponse {
+    pub changed: bool,
+}
+
 /// Context of a mesh render.
 #[derive(Clone, Copy, PartialEq)]
 struct MeshContext {
@@ -102,56 +107,28 @@ struct MeshContext {
 
     pub pixels_per_point: f32,
 
-    /// Canvas size in points
-    pub size: Vec2,
-
     pub stroke: Stroke,
 }
 
-/// Get [Painting::texture], initializing it if necessary.
-macro_rules! texture {
-    ($self_:expr, $ui:expr, $mesh_context:expr) => {{
-        let ui: &Ui = $ui;
-        let mesh_context: &MeshContext = $mesh_context;
-        let image_size = mesh_context.pixel_size();
-
-        let new_image = || {
-            let image = ColorImage::new(image_size, Color32::TRANSPARENT);
-            ui.ctx()
-                .load_texture("handwriting", image, Default::default())
-        };
-
-        let texture = $self_.texture.get_or_insert_with(new_image);
-
-        if texture.size() != image_size {
-            $self_.refresh_texture = true;
-            // TODO: don't redraw the entire mesh, just blit the old texture onto the new one
-            *texture = new_image()
-        };
-
-        texture
-    }};
-}
-
-impl MeshContext {
-    /// Calculate canvas size in pixels
-    pub fn pixel_size(&self) -> [usize; 2] {
-        let Vec2 { x, y } = self.size * self.pixels_per_point;
-        [x, y].map(|f| f.ceil() as usize)
-    }
-}
-
 impl Default for Handwriting {
     fn default() -> Self {
         Self {
-            id: random_id(),
             strokes: Default::default(),
-            current_stroke: Default::default(),
             height: HANDWRITING_MIN_HEIGHT,
             desired_height: HANDWRITING_MIN_HEIGHT,
+            e: Default::default(),
+        }
+    }
+}
+
+impl Default for Ephemeral {
+    fn default() -> Self {
+        Self {
+            id: random_id(),
+            canvas_rasterizer: Default::default(),
+            current_stroke: Default::default(),
+            tessellator: None,
             mesh: Default::default(),
-            texture: None,
-            image: ColorImage::new([0, 0], Color32::WHITE),
             refresh_texture: true,
             last_mesh_ctx: None,
             unblitted_lines: Default::default(),
@@ -164,6 +141,7 @@ impl Handwriting {
         &mut self,
         style: Option<&mut HandwritingStyle>,
         ui: &mut egui::Ui,
+        response: &mut HandwritingResponse,
     ) -> egui::Response {
         ui.horizontal(|ui| {
             if let Some(style) = style {
@@ -172,33 +150,41 @@ impl Handwriting {
                 ui.separator();
             }
 
-            if ui.button("Clear Painting").clicked() {
+            if ui.button("clear").clicked() {
                 self.strokes.clear();
-                self.refresh_texture = true;
+                self.e.refresh_texture = true;
+                response.changed = true;
             }
 
             ui.add_enabled_ui(!self.strokes.is_empty(), |ui| {
-                if ui.button("Undo").clicked() {
+                if ui.button("undo").clicked() {
                     self.strokes.pop();
-                    self.refresh_texture = true;
+                    self.e.refresh_texture = true;
+                    response.changed = true;
                 }
             });
 
-            let vertex_count: usize = self.mesh.indices.len() / 3;
+            if ui.button("copy").clicked() {
+                let text = self.to_string();
+                // TODO: move to a job
+                let _ = Clipboard::new().unwrap().set_text(text);
+            }
+
+            let vertex_count: usize = self.e.mesh.indices.len() / 3;
             ui.label(format!("vertices: {vertex_count}"));
         })
         .response
     }
 
-    fn commit_current_line(&mut self) {
-        debug_assert!(!self.current_stroke.is_empty());
-        self.strokes.push(mem::take(&mut self.current_stroke));
-    }
-
-    pub fn ui_content(&mut self, style: &HandwritingStyle, ui: &mut Ui) -> egui::Response {
+    pub fn ui_content(
+        &mut self,
+        style: &HandwritingStyle,
+        ui: &mut Ui,
+        hw_response: &mut HandwritingResponse,
+    ) -> egui::Response {
         if style.animate {
             self.height = ui.ctx().animate_value_with_time(
-                self.id.with("height animation"),
+                self.e.id.with("height animation"),
                 self.desired_height,
                 0.4,
             );
@@ -206,30 +192,33 @@ impl Handwriting {
             self.height = self.desired_height;
         }
 
-        let size = Vec2::new(ui.available_width(), self.height);
-        let (response, painter) = ui.allocate_painter(size, Sense::drag());
+        let desired_size = Vec2::new(ui.available_width(), self.height);
+        let (mut response, painter) = ui.allocate_painter(desired_size, Sense::drag());
 
-        let mut response = response
-            //.on_hover_cursor(CursorIcon::Crosshair)
-            //.on_hover_and_drag_cursor(CursorIcon::None)
-            ;
+        if style.hide_cursor {
+            response = response.on_hover_and_drag_cursor(egui::CursorIcon::None);
+        }
 
         let size = response.rect.size();
 
-        let to_screen = emath::RectTransform::from_to(
-            //Rect::from_min_size(Pos2::ZERO, response.rect.square_proportions()),
-            Rect::from_min_size(Pos2::ZERO, size),
-            response.rect,
-        );
+        // Calculate matrices that convert between screen-space and image-space.
+        // - image-space: 0,0 is the top-left of the texture.
+        // - screen-space: 0,0 is the top-left of the window.
+        // Both spaces use the same logical points, not pixels.
+        let to_screen =
+            emath::RectTransform::from_to(Rect::from_min_size(Pos2::ZERO, size), response.rect);
         let from_screen = to_screen.inverse();
 
+        // Was the user in the process of drawing a stroke last frame?
+        let was_drawing = !self.e.current_stroke.is_empty();
+
+        // Is the user in the process of drawing a stroke now?
         let is_drawing = response.interact_pointer_pos().is_some();
-        let was_drawing = !self.current_stroke.is_empty();
 
         if !is_drawing {
-            // commit current line
             if was_drawing {
-                self.commit_current_line();
+                // commit current line
+                self.commit_current_line(hw_response);
                 response.mark_changed();
             }
 
@@ -241,6 +230,8 @@ impl Handwriting {
                 .map(|p| p.y + HANDWRITING_BOTTOM_PADDING)
                 .fold(HANDWRITING_MIN_HEIGHT, |max, y| max.max(y));
 
+            // Change the height of the handwriting item.
+            // We don't do this mid-stroke, only when the user e.g. lifts the pen.
             if self.desired_height != lines_max_y {
                 self.desired_height = lines_max_y;
                 response.mark_changed();
@@ -267,16 +258,17 @@ impl Handwriting {
                         _ => Some(next),
                     }
                 })
-                .cloned()
                 .filter(|event| {
                     // FIXME: pinenote: PointerMoved are duplicated after the MouseMoved events
                     cfg!(not(feature = "pinenote")) || !matches!(event, Event::PointerMoved(..))
                 })
+                .cloned()
                 .collect::<Vec<_>>()
             });
 
+            // Process input events and turn them into strokes
             for event in events {
-                let last_canvas_pos = self.current_stroke.last();
+                let last_canvas_pos = self.e.current_stroke.last();
 
                 match event {
                     Event::PointerMoved(new_position) => {
@@ -318,13 +310,13 @@ impl Handwriting {
                     } => match (button, pressed) {
                         (PointerButton::Primary, true) => {
                             if last_canvas_pos.is_none() {
-                                self.current_stroke.push(from_screen * pos);
+                                self.e.current_stroke.push(from_screen * pos);
                             }
                         }
                         (PointerButton::Primary, false) => {
                             if last_canvas_pos.is_some() {
                                 self.push_to_stroke(from_screen * pos);
-                                self.commit_current_line();
+                                self.commit_current_line(hw_response);
                                 response.mark_changed();
                             }
 
@@ -340,8 +332,8 @@ impl Handwriting {
                     // TODO: In theory, we can get multiple press->draw->release series
                     // in the same frame. Should handle this.
                     Event::PointerGone | Event::WindowFocused(false) => {
-                        if !self.current_stroke.is_empty() {
-                            self.commit_current_line();
+                        if !self.e.current_stroke.is_empty() {
+                            self.commit_current_line(hw_response);
                             break;
                         }
                     }
@@ -361,6 +353,7 @@ impl Handwriting {
             }
         }
 
+        // Draw the horizontal ruled lines
         (1..)
             .map(|n| n as f32 * HANDWRITING_LINE_SPACING)
             .take_while(|&y| y < size.y)
@@ -373,111 +366,119 @@ impl Handwriting {
                 painter.add(shape);
             });
 
+        // Get the position and dimensions of the image
         let mesh_rect = response
             .rect
             .with_max_y(response.rect.min.y + self.desired_height);
+
+        // These are the values that, if changed, would require the mesh to be re-rendered.
         let new_context = MeshContext {
             ui_theme: ui.ctx().theme(),
             pixels_per_point: ui.pixels_per_point(),
-            size: mesh_rect.size(),
             stroke: style.stroke,
         };
 
-        if Some(&new_context) != self.last_mesh_ctx.as_ref() {
-            self.refresh_texture = true;
+        // Figure out if we need to re-rasterize the mesh.
+        if Some(&new_context) != self.e.last_mesh_ctx.as_ref() {
+            self.e.refresh_texture = true;
         }
 
-        if self.refresh_texture {
-            // rasterize the entire texture from scratch
-            self.refresh_texture(style, new_context, ui);
-            self.unblitted_lines.clear();
-        } else if !self.unblitted_lines.is_empty() {
-            // only rasterize the new lines onto the existing texture
-            for [from, to] in std::mem::take(&mut self.unblitted_lines) {
-                self.draw_line_to_texture(from, to, &new_context, ui);
+        let [px_width, px_height] = {
+            let Vec2 { x, y } = mesh_rect.size() * new_context.pixels_per_point;
+            [x, y].map(|f| f.ceil() as usize)
+        };
+
+        self.e.canvas_rasterizer.set_size(px_width, px_height);
+
+        if self.e.refresh_texture {
+            // ...if we do, rasterize the entire texture from scratch
+            self.refresh_texture(style, new_context);
+            self.e.unblitted_lines.clear();
+        } else if !self.e.unblitted_lines.is_empty() {
+            // ...if we don't, we can get away with  only rasterizing the *new* lines onto the
+            // existing texture.
+            for [from, to] in std::mem::take(&mut self.e.unblitted_lines) {
+                self.draw_line_to_texture(from, to, &new_context);
             }
-            self.unblitted_lines.clear();
+            self.e.unblitted_lines.clear();
         }
 
-        //painter.add(self.mesh.clone());
-
-        if let Some(texture) = &self.texture {
-            let texture = SizedTexture::new(texture.id(), texture.size_vec2());
-            let shape = RectShape {
-                rect: mesh_rect,
-                corner_radius: CornerRadius::ZERO,
-                fill: Color32::WHITE,
-                stroke: Stroke::NONE,
-                stroke_kind: egui::StrokeKind::Inside,
-                round_to_pixels: None,
-                blur_width: 0.0,
-                brush: Some(Arc::new(Brush {
-                    fill_texture_id: texture.id,
-                    uv: Rect {
-                        min: Pos2::ZERO,
-                        max: Pos2::new(1.0, 1.0),
-                    },
-                })),
-            };
-            painter.add(shape);
-        }
+        // Draw the texture
+        self.e.canvas_rasterizer.show(ui.ctx(), &painter, mesh_rect);
 
         response
     }
 
-    fn refresh_texture(
-        &mut self,
-        style: &HandwritingStyle,
-        mesh_context: MeshContext,
-        ui: &mut Ui,
-    ) {
-        self.last_mesh_ctx = Some(mesh_context);
+    fn commit_current_line(&mut self, response: &mut HandwritingResponse) {
+        debug_assert!(!self.e.current_stroke.is_empty());
+        self.strokes.push(mem::take(&mut self.e.current_stroke));
+        response.changed = true;
+    }
 
-        self.refresh_texture = false;
+    /// Tessellate and rasterize the strokes into a new texture.
+    fn refresh_texture(&mut self, style: &HandwritingStyle, mesh_context: MeshContext) {
+        let Ephemeral {
+            current_stroke,
+            tessellator,
+            mesh,
+            refresh_texture,
+            last_mesh_ctx,
+            ..
+        } = &mut self.e;
+        // TODO: don't tessellate and rasterize on the GUI thread
+
+        *last_mesh_ctx = Some(mesh_context);
+
+        *refresh_texture = false;
 
         #[cfg(not(target_arch = "wasm32"))]
         let start_time = std::time::Instant::now();
 
-        let mut tesselator = Tessellator::new(
-            mesh_context.pixels_per_point,
-            TESSELATION_OPTIONS,
-            Default::default(), // we don't tesselate fonts
-            vec![],
-        );
-
-        let mesh = Arc::make_mut(&mut self.mesh);
+        let mesh = Arc::make_mut(mesh);
         mesh.clear();
 
+        // TODO: re-use tessellator if pixels_per_point hasn't changed
+        let tessellator = tessellator.insert(new_tessellator(mesh_context.pixels_per_point));
+
         self.strokes
             .iter()
-            .chain([&self.current_stroke])
+            .chain([&*current_stroke])
             .filter(|stroke| stroke.len() >= 2)
             .map(|stroke| {
                 //let points: Vec<Pos2> = stroke.iter().map(|&p| to_screen * p).collect();
                 egui::Shape::line(stroke.clone(), style.stroke)
             })
             .for_each(|shape| {
-                tesselator.tessellate_shape(shape, mesh);
+                tessellator.tessellate_shape(shape, mesh);
             });
 
-        let texture = texture!(self, ui, &mesh_context);
-        let triangles = mesh_triangles(&self.mesh);
+        // sanity-check that tessellation did not produce any NaNs.
+        // this can happen if the line contains duplicated consecutive positions
+        //for vertex in &mesh.vertices {
+        //    debug_assert!(vertex.pos.x.is_finite(), "{} must be finite", vertex.pos.x);
+        //    debug_assert!(vertex.pos.y.is_finite(), "{} must be finite", vertex.pos.y);
+        //}
 
-        let [px_x, px_y] = mesh_context.pixel_size();
         let point_to_pixel = TSTransform::from_scaling(mesh_context.pixels_per_point);
-        self.image = rasterize::<StrokeBlendMode>(px_x, px_y, point_to_pixel, triangles);
-        texture.set(self.image.clone(), Default::default());
+        let triangles = mesh_triangles(&self.e.mesh);
+
+        self.e.canvas_rasterizer.clear();
+        self.e
+            .canvas_rasterizer
+            .rasterize(point_to_pixel, triangles);
 
         #[cfg(not(target_arch = "wasm32"))]
         {
             let elapsed = start_time.elapsed();
-            println!("refreshed mesh in {:.3}s", elapsed.as_secs_f32());
+            log::debug!("refreshed mesh in {:.3}s", elapsed.as_secs_f32());
         }
     }
 
-    pub fn ui(&mut self, style: &HandwritingStyle, ui: &mut Ui) {
+    pub fn ui(&mut self, style: &HandwritingStyle, ui: &mut Ui) -> HandwritingResponse {
+        let mut response = HandwritingResponse { changed: false };
+
         ui.vertical_centered_justified(|ui| {
-            self.ui_control(None, ui);
+            self.ui_control(None, ui, &mut response);
 
             //ui.label("Paint with your mouse/touch!");
             Frame::canvas(ui.style())
@@ -485,51 +486,53 @@ impl Handwriting {
                 .stroke(Stroke::new(5.0, Color32::from_black_alpha(40)))
                 .fill(style.bg_color)
                 .show(ui, |ui| {
-                    self.ui_content(style, ui);
+                    self.ui_content(style, ui, &mut response);
                 });
         });
+
+        response
     }
 
+    /// Append a new [Pos2] to [Self::current_stroke].
+    ///
+    /// Queue a new line to be drawn onto [Self::texture].
     fn push_to_stroke(&mut self, new_canvas_pos: Pos2) {
-        if let Some(&last_canvas_pos) = self.current_stroke.last() {
+        if let Some(&last_canvas_pos) = self.e.current_stroke.last() {
             if last_canvas_pos == new_canvas_pos {
                 return;
             }
 
-            self.unblitted_lines.push([last_canvas_pos, new_canvas_pos]);
+            self.e
+                .unblitted_lines
+                .push([last_canvas_pos, new_canvas_pos]);
         }
 
-        self.current_stroke.push(new_canvas_pos);
+        self.e.current_stroke.push(new_canvas_pos);
     }
 
     /// Draw a single line onto the existing texture.
-    fn draw_line_to_texture(
-        &mut self,
-        from: Pos2,
-        to: Pos2,
-        mesh_context: &MeshContext,
-        ui: &mut Ui,
-    ) {
-        let mut tesselator = Tessellator::new(
-            mesh_context.pixels_per_point,
-            TESSELATION_OPTIONS,
-            Default::default(), // we don't tesselate fonts
-            vec![],
-        );
+    fn draw_line_to_texture(&mut self, from: Pos2, to: Pos2, mesh_context: &MeshContext) {
+        // INVARIANT: if this function was called, then pixels_per_point is the same as last frame,
+        // so there's no need to create a new tessellator.
+        let tessellator = self
+            .e
+            .tessellator
+            .get_or_insert_with(|| new_tessellator(mesh_context.pixels_per_point));
 
         let mut mesh = Mesh::default();
         let line = egui::Shape::line_segment([from, to], mesh_context.stroke);
-        tesselator.tessellate_shape(line, &mut mesh);
+        tessellator.tessellate_shape(line, &mut mesh);
 
-        self.draw_mesh_to_texture(&mesh, mesh_context, ui);
+        self.draw_mesh_to_texture(&mesh, mesh_context);
     }
 
     /// Draw a single mesh onto the existing texture.
-    fn draw_mesh_to_texture(&mut self, mesh: &Mesh, mesh_context: &MeshContext, ui: &mut Ui) {
+    fn draw_mesh_to_texture(&mut self, mesh: &Mesh, mesh_context: &MeshContext) {
         let triangles = mesh_triangles(mesh);
         let point_to_pixel = TSTransform::from_scaling(mesh_context.pixels_per_point);
-        rasterize_onto::<StrokeBlendMode>(&mut self.image, point_to_pixel, triangles);
-        texture!(self, ui, mesh_context).set(self.image.clone(), Default::default());
+        self.e
+            .canvas_rasterizer
+            .rasterize(point_to_pixel, triangles);
     }
 
     pub fn strokes(&self) -> &[Vec<Pos2>] {
@@ -557,24 +560,49 @@ impl Handwriting {
             ..Default::default()
         }
     }
+
+    pub fn encode_as_disk_format(&self) -> Box<[u8]> {
+        let mut bytes = vec![];
+        let header = disk_format::Header {
+            version: disk_format::V1,
+        };
+
+        bytes.extend_from_slice(header.as_bytes());
+
+        for stroke in &self.strokes {
+            let Ok(len) = u16::try_from(stroke.len()) else {
+                log::error!("More than u16::MAX points in a stroke!");
+                continue;
+            };
+
+            let header = RawStrokeHeader { len: len.into() };
+            bytes.extend_from_slice(header.as_bytes());
+
+            for position in stroke {
+                for v in [position.x, position.y] {
+                    let v = f16::from_f32(v);
+                    let v = f16_le::from(v);
+                    bytes.extend_from_slice(v.as_bytes());
+                }
+            }
+        }
+
+        bytes.into_boxed_slice()
+    }
+}
+
+fn new_tessellator(pixels_per_point: f32) -> Tessellator {
+    Tessellator::new(
+        pixels_per_point,
+        TESSELLATION_OPTIONS,
+        Default::default(), // we don't tessellate fonts
+        vec![],
+    )
 }
 
 impl Display for Handwriting {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut raw = vec![];
-
-        for stroke in &self.strokes {
-            raw.push((stroke.len() as u16).to_le_bytes());
-            for position in stroke {
-                let x = half::f16::from_f32(position.x);
-                let y = half::f16::from_f32(position.y);
-                raw.push(x.to_bits().to_le_bytes());
-                raw.push(y.to_bits().to_le_bytes());
-            }
-        }
-
-        let raw = raw.as_slice().as_bytes();
-
+        let raw = self.encode_as_disk_format();
         write_custom_code_block(f, CODE_BLOCK_KEY, BASE64_STANDARD.encode(raw))
     }
 }
@@ -590,53 +618,72 @@ impl FromStr for Handwriting {
             .decode(s)
             .wrap_err("Failed to decode painting data from base64")?;
 
-        #[allow(non_camel_case_types)]
-        type u16_le = [u8; 2];
+        // HACK: first iteration of disk format did not have version header
+        //let mut bytes = bytes;
+        //bytes.insert(0, 0);
+        //bytes.insert(0, 1);
 
-        #[allow(non_camel_case_types)]
-        type f16_le = [u8; 2];
+        let disk_format = DiskFormat::ref_from_bytes(&bytes[..]).map_err(|_| eyre!("Too short"))?;
 
-        #[derive(FromBytes, KnownLayout, Immutable)]
-        #[repr(C, packed)]
-        struct Stroke {
-            pub len: u16_le,
-            pub positions: [f16_le],
+        if disk_format.header.version != disk_format::V1 {
+            bail!(
+                "Unknown disk_format version: {}",
+                disk_format.header.version
+            );
         }
 
-        let mut bytes = &bytes[..];
+        let mut raw_strokes = &disk_format.strokes[..];
         let mut strokes = vec![];
 
-        while !bytes.is_empty() {
-            let header_len = size_of::<u16_le>();
-            if bytes.len() < header_len {
-                bail!("Invalid remaining length: {}", bytes.len());
+        while !raw_strokes.is_empty() {
+            if raw_strokes.len() < RawStroke::MIN_LEN {
+                bail!("Invalid remaining length: {}", raw_strokes.len());
             }
 
-            let stroke = Stroke::ref_from_bytes(&bytes[..header_len]).expect("length is correct");
-            let len = usize::from(u16::from_le_bytes(stroke.len));
-            let len = len * size_of::<f16_le>() * 2;
+            let stroke = RawStroke::ref_from_bytes(&raw_strokes[..RawStroke::MIN_LEN])
+                .expect("length is correct");
 
-            if bytes.len() < len {
-                bail!("Invalid remaining length: {}", bytes.len());
+            // get length as number of points
+            let len = usize::from(u16::from(stroke.header.len));
+
+            // convert to length in bytes
+            let byte_len = 2 * size_of::<f16_le>() * len;
+
+            if raw_strokes.len() < byte_len {
+                bail!("Invalid remaining length: {}", raw_strokes.len());
             }
 
-            let (stroke, rest) = bytes.split_at(header_len + len);
-            bytes = rest;
-            let stroke = Stroke::ref_from_bytes(stroke)
-                .map_err(|e| eyre!("Failed to decode stroke bytes: {e}"))?;
+            let (stroke, rest) = raw_strokes.split_at(RawStroke::MIN_LEN + byte_len);
+            raw_strokes = rest;
 
-            let mut positions = stroke
+            let stroke = RawStroke::ref_from_bytes(stroke).expect("length is correct");
+
+            debug_assert_eq!(
+                stroke.positions.len().rem_euclid(2),
+                0,
+                "{} must be divisible by 2",
+                stroke.positions.len()
+            );
+            debug_assert_eq!(stroke.positions.len(), len * 2);
+
+            let mut last_pos = Pos2::new(f32::NEG_INFINITY, f32::INFINITY);
+
+            // positions are encoded as an array of f16s [x, y, x, y, x, y, ..]
+            let stroke: Vec<Pos2> = stroke
                 .positions
-                .iter()
-                .map(|&position| f16::from_bits(u16::from_le_bytes(position)));
+                .chunks_exact(2)
+                .map(|chunk| [chunk[0], chunk[1]])
+                .map(|pos| pos.map(f16::from)) // interpret bytes as f16
+                .map(|pos| pos.map(f32::from)) // widen to f32
+                .filter(|pos| pos.iter().all(|f| f.is_finite())) // filter out NaNs and Infs
+                .map(|[x, y]| Pos2::new(x, y))
+                .filter(|pos| {
+                    let is_duplicate = pos == &last_pos;
+                    last_pos = *pos;
+                    !is_duplicate // skip duplicates
+                })
+                .collect();
 
-            let mut stroke = vec![];
-            while let Some(x) = positions.next() {
-                let Some(y) = positions.next() else {
-                    unreachable!("len is a multiple of two");
-                };
-                stroke.push(Pos2::new(x.into(), y.into()));
-            }
             strokes.push(stroke);
         }
 
@@ -667,16 +714,19 @@ impl HandwritingStyle {
         }
 
         HandwritingStyle {
-            stroke: Stroke::new(1.6, stroke_color),
+            stroke: Stroke::new(1.0, stroke_color),
             bg_color,
             bg_line_stroke: Stroke::new(0.5, line_color),
             animate: true,
+            hide_cursor: false,
         }
     }
 }
 
-fn mesh_triangles(mesh: &Mesh) -> impl Iterator<Item = [&Vertex; 3]> {
-    mesh.triangles()
+fn mesh_triangles(mesh: &Mesh) -> impl Iterator<Item = [&Vertex; 3]> + Clone {
+    mesh.indices
+        .chunks_exact(3)
+        .map(|chunk| [chunk[0], chunk[1], chunk[2]])
         .map(|indices| indices.map(|i| &mesh.vertices[i as usize]))
 }
 

src/handwriting/snapshots/inkr__handwriting__test__deserialized handwriting.snap

@@ -0,0 +1,19 @@
+---
+source: src/handwriting/mod.rs
+expression: deserialized.strokes
+---
+[
+    [
+        [-1.0 1.0],
+        [3.0 1.0],
+        [3.0 3.0],
+        [1.5 2.0],
+        [0.0 0.0],
+    ],
+    [
+        [3.0 3.0],
+        [-1.0 1.0],
+        [0.0 0.0],
+        [3.0 1.0],
+    ],
+]

src/handwriting/snapshots/inkr__handwriting__test__handwriting example.snap

@@ -0,0 +1,19 @@
+---
+source: src/handwriting/mod.rs
+expression: handwriting.strokes
+---
+[
+    [
+        [-1.0 1.0],
+        [3.0 1.0],
+        [3.0 3.0],
+        [1.5 2.0],
+        [0.0 0.0],
+    ],
+    [
+        [3.0 3.0],
+        [-1.0 1.0],
+        [0.0 0.0],
+        [3.0 1.0],
+    ],
+]

src/handwriting/snapshots/inkr__handwriting__test__serialized handwriting.snap

@@ -0,0 +1,7 @@
+---
+source: src/handwriting/mod.rs
+expression: serialized
+---
+```handwriting
+AQAFAAC8ADwAQgA8AEIAQgA+AEAAAAAABAAAQgBCALwAPAAAAAAAQgA8
+```

src/lib.rs

@@ -1,11 +1,10 @@
-#![warn(clippy::all, rust_2018_idioms)]
-
 pub mod app;
 pub mod constants;
 pub mod custom_code_block;
-pub mod easy_mark;
 pub mod file_editor;
-pub mod painting;
+pub mod folder;
+pub mod handwriting;
+pub mod markdown;
 pub mod preferences;
 pub mod rasterizer;
 pub mod text_editor;

src/markdown/ast.rs

@@ -0,0 +1,54 @@
+use super::span::Span;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Heading {
+    H1,
+    H2,
+    H3,
+    H4,
+    H5,
+    H6,
+}
+
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+pub struct Style {
+    /// # heading (large text)
+    pub heading: Option<Heading>,
+
+    /// > quoted (slightly dimmer color or other font style)
+    pub quoted: bool,
+
+    /// `code` (monospace, some other color)
+    pub code: bool,
+
+    /// self.strong* (emphasized, e.g. bold)
+    pub strong: bool,
+
+    /// _underline_
+    pub underline: bool,
+
+    /// ~strikethrough~
+    pub strikethrough: bool,
+
+    /// /italics/
+    pub italics: bool,
+
+    /// $small$
+    pub small: bool,
+
+    /// ^raised^
+    pub raised: bool,
+}
+
+pub enum Item<'a> {
+    Text {
+        span: Span<'a>,
+        style: Style,
+    },
+
+    CodeBlock {
+        all: Span<'a>,
+        language: Span<'a>,
+        code: Span<'a>,
+    },
+}

src/markdown/grammar.lalrpop

@@ -0,0 +1,10 @@
+use std::str::FromStr;
+
+grammar;
+
+pub Term: i32 = {
+    <n:Num> => n,
+    "(" <t:Term> ")" => t,
+};
+
+Num: i32 = <s:r"[0-9]+"> => i32::from_str(s).unwrap();

src/markdown/highlighter.rs

@@ -0,0 +1,127 @@
+use egui::text::{CCursorRange, LayoutJob};
+
+use crate::markdown::Heading;
+
+use super::{Item, Style, parse};
+
+/// Highlight markdown, caching previous output to save CPU.
+#[derive(Default)]
+pub struct MemoizedHighlighter {
+    style: egui::Style,
+    code: String,
+    output: LayoutJob,
+}
+
+impl MemoizedHighlighter {
+    pub fn highlight(
+        &mut self,
+        egui_style: &egui::Style,
+        code: &str,
+        cursor: Option<CCursorRange>,
+    ) -> LayoutJob {
+        if (&self.style, self.code.as_str()) != (egui_style, code) {
+            self.style = egui_style.clone();
+            code.clone_into(&mut self.code);
+            self.output = highlight_markdown(egui_style, code, cursor);
+        }
+        self.output.clone()
+    }
+}
+
+pub fn highlight_markdown(
+    egui_style: &egui::Style,
+    text: &str,
+
+    // TODO: hide special characters where cursor isn't
+    _cursor: Option<CCursorRange>,
+) -> LayoutJob {
+    let mut job = LayoutJob::default();
+
+    let code_style = Style {
+        code: true,
+        ..Default::default()
+    };
+
+    for item in parse(text) {
+        match item {
+            Item::Text { span, style } => {
+                job.append(&span, 0.0, format_from_style(egui_style, &style));
+            }
+            Item::CodeBlock {
+                all,
+                language: _, // TODO
+                code: _,     // TODO
+            } => {
+                job.append(&all, 100.0, format_from_style(egui_style, &code_style));
+            }
+        }
+    }
+
+    job
+}
+
+fn format_from_style(egui_style: &egui::Style, style: &Style) -> egui::text::TextFormat {
+    use egui::{Align, Color32, Stroke, TextStyle};
+
+    let color = if style.code {
+        egui_style.visuals.strong_text_color() * Color32::GREEN
+    } else if style.strong || style.heading.is_some() {
+        egui_style.visuals.strong_text_color()
+    } else if style.quoted {
+        egui_style.visuals.weak_text_color()
+    } else {
+        egui_style.visuals.text_color()
+    };
+
+    let text_style = if let Some(heading) = style.heading {
+        match heading {
+            Heading::H1 => TextStyle::Name("H1".into()),
+            Heading::H2 => TextStyle::Name("H2".into()),
+            Heading::H3 => TextStyle::Name("H3".into()),
+            Heading::H4 => TextStyle::Name("H4".into()),
+            Heading::H5 => TextStyle::Name("H5".into()),
+            Heading::H6 => TextStyle::Name("H6".into()),
+        }
+    } else if style.code {
+        TextStyle::Monospace
+    } else if style.small | style.raised {
+        TextStyle::Small
+    } else {
+        TextStyle::Body
+    };
+
+    let background = if style.code {
+        egui_style.visuals.code_bg_color
+    } else {
+        Color32::TRANSPARENT
+    };
+
+    let underline = if style.underline {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let strikethrough = if style.strikethrough {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let valign = if style.raised {
+        Align::TOP
+    } else {
+        Align::BOTTOM
+    };
+
+    egui::text::TextFormat {
+        font_id: text_style.resolve(egui_style),
+        color,
+        background,
+        italics: style.italics,
+        underline,
+        strikethrough,
+        valign,
+        ..Default::default()
+    }
+}

src/markdown/mod.rs

@@ -0,0 +1,11 @@
+mod ast;
+mod highlighter;
+mod parser;
+mod span;
+mod tokenizer;
+
+pub use ast::*;
+pub use highlighter::*;
+pub use parser::*;
+pub use span::*;
+pub use tokenizer::*;

src/markdown/parser.rs

@@ -0,0 +1,172 @@
+use std::iter::{self, once};
+
+use crate::markdown::Style;
+
+use super::{Item, Span, Token, TokenKind, tokenize};
+
+pub fn parse(text: &str) -> Vec<Item<'_>> {
+    let tokens: Vec<_> = tokenize(text).collect();
+    parse_tokens(&tokens)
+}
+
+pub fn parse_tokens<'a>(mut tokens: &[Token<'a>]) -> Vec<Item<'a>> {
+    // pretend that the first token was preceeded by a newline.
+    // means we don't have to handle the first token as a special case.
+    let mut prev = TokenKind::Newline;
+
+    let mut style = Style::default();
+
+    let mono_style = Style {
+        code: true,
+        ..Default::default()
+    };
+
+    iter::from_fn(move || {
+        if tokens.is_empty() {
+            return None;
+        }
+
+        let token = tokens.first().unwrap();
+        tokens = &tokens[1..];
+
+        let start_of_line = prev == TokenKind::Newline;
+        prev = token.kind;
+
+        let mut basic_style: Option<fn(&mut Style) -> &mut bool> = None;
+
+        match token.kind {
+            TokenKind::CodeBlock if start_of_line => {
+                let language = collect_until(
+                    None,
+                    &mut tokens,
+                    any_of([TokenKind::Newline]),
+                );
+
+                let code = collect_until(
+                    None,
+                    &mut tokens,
+                    series([TokenKind::Newline, TokenKind::CodeBlock]),
+                );
+
+                let all = [
+                    &token.span,
+                    &language,
+                    &code,
+                ].into_iter().fold(Span::empty(), |a, b| a.try_merge(b).unwrap());
+
+                let language = language.trim_end_matches("\n");
+                let code = code.trim_end_matches("\n```");
+
+                return Some(Item::CodeBlock { all, language, code });
+            }
+
+            TokenKind::Newline => style = Style::default(),
+
+            TokenKind::Strong => basic_style = Some(|s| &mut s.strong),
+            TokenKind::Italic => basic_style = Some(|s| &mut s.italics),
+            TokenKind::Strikethrough => basic_style = Some(|s| &mut s.strikethrough),
+
+            TokenKind::CodeBlock | TokenKind::Mono => {
+                let span = collect_until(
+                    Some(token),
+                    &mut tokens,
+                    any_of([TokenKind::Mono, TokenKind::CodeBlock, TokenKind::Newline]),
+                );
+
+                return Some(Item::Text { span, style: mono_style});
+            }
+
+            // TODO: different heading strengths
+            TokenKind::Heading(h) if start_of_line => style.heading = Some(h),
+            TokenKind::Quote if start_of_line => style.quoted = true,
+
+            // TODO: replace dashes with dots
+            //// TODO: indented list entries
+            //TokenKind::ListEntry if start_of_line => {
+            //    job.append("• ", 0.0, format_from_style(egui_style, &style));
+            //    continue;
+            //}
+
+            TokenKind::Text
+            // the following tokens are only richly rendered if encountered e.g. at start_of_line.
+            | TokenKind::Indentation
+            | TokenKind::ListEntry
+            | TokenKind::Heading(..)
+            | TokenKind::Quote => {}
+        }
+
+        // if we encountered a marker for Bold, Italic, or Strikethrough, toggle that style and
+        // render the token with the style enabled.
+        if let Some(basic_style) = basic_style {
+            let mut tmp_style = style;
+            *basic_style(&mut tmp_style) = true;
+            *basic_style(&mut style) ^= true; // toggle
+            return Some(Item::Text {
+                span: token.span.clone(),
+                style: tmp_style,
+            });
+        }
+
+        Some(Item::Text {
+            span: token.span.clone(),
+            style,
+        })
+    })
+    .collect()
+}
+
+fn series<'a, const N: usize>(of: [TokenKind; N]) -> impl FnMut(&[Token<'a>; N]) -> bool {
+    move |token| {
+        of.iter()
+            .zip(token)
+            .all(|(kind, token)| kind == &token.kind)
+    }
+}
+
+fn any_of<'a, const N: usize>(these: [TokenKind; N]) -> impl FnMut(&[Token<'a>; 1]) -> bool {
+    move |[token]| these.contains(&token.kind)
+}
+
+/// Collect all tokens up to and including `pattern`, and merge them into a signle span.
+///
+/// `N` determines how many specific and consecutive tokens we are looking for.
+/// i.e. if we were looking for a [TokenKind::Newline] followed by a [TokenKind::Quote], `N`
+/// would equal `2`.
+///
+/// `pattern` is a function that accepts an array of `N` tokens and returns `true` if they match,
+/// i.e. if we should stop collecting. [any_of] and [series] can help to construct this function.
+///
+/// The collected tokens will be split off the head of the slice referred to by `tokens`.
+///
+/// # Panic
+/// Panics if `tokens` does not contain only consecutive adjacent spans.
+fn collect_until<'a, const N: usize>(
+    first_token: Option<&Token<'a>>,
+    tokens: &mut &[Token<'a>],
+    pattern: impl FnMut(&[Token<'a>; N]) -> bool,
+) -> Span<'a>
+where
+    // &[T; N]: TryFrom<&[T]>
+    for<'b> &'b [Token<'a>; N]: TryFrom<&'b [Token<'a>]>,
+{
+    let mut windows = tokens.windows(N).map(|slice| {
+        <&[Token<'a>; N]>::try_from(slice)
+            .ok()
+            .expect("`windows` promises to return slices of length N")
+    });
+
+    let split_at = match windows.position(pattern) {
+        Some(i) => i + N,
+        None => tokens.len(), // consume everything
+    };
+
+    let (consume, keep) = tokens.split_at(split_at);
+    *tokens = keep;
+
+    once(first_token)
+        .flatten()
+        .chain(consume)
+        .fold(Span::empty(), |span: Span<'_>, token| {
+            span.try_merge(&token.span).unwrap()
+        })
+}

src/markdown/snapshots/inkr__markdown__tokenizer__tests__tokenize.snap

@@ -0,0 +1,46 @@
+---
+source: src/markdown/tokenizer.rs
+expression: examples
+---
+- string: "just some normal text :D"
+  tokens:
+    - "Token { span: Span(0..24, \"just some normal text :D\"), kind: Text }"
+- string: normal *bold* normal
+  tokens:
+    - "Token { span: Span(0..7, \"normal \"), kind: Text }"
+    - "Token { span: Span(7..8, \"*\"), kind: Strong }"
+    - "Token { span: Span(8..12, \"bold\"), kind: Text }"
+    - "Token { span: Span(12..13, \"*\"), kind: Strong }"
+    - "Token { span: Span(13..20, \" normal\"), kind: Text }"
+- string: normal * maybe bold? * normal
+  tokens:
+    - "Token { span: Span(0..7, \"normal \"), kind: Text }"
+    - "Token { span: Span(7..8, \"*\"), kind: Strong }"
+    - "Token { span: Span(8..21, \" maybe bold? \"), kind: Text }"
+    - "Token { span: Span(21..22, \"*\"), kind: Strong }"
+    - "Token { span: Span(22..29, \" normal\"), kind: Text }"
+- string: "```lang\ncode code code\n```"
+  tokens:
+    - "Token { span: Span(0..3, \"```\"), kind: CodeBlock }"
+    - "Token { span: Span(3..7, \"lang\"), kind: Text }"
+    - "Token { span: Span(7..8, \"\\n\"), kind: Newline }"
+    - "Token { span: Span(8..22, \"code code code\"), kind: Text }"
+    - "Token { span: Span(22..23, \"\\n\"), kind: Newline }"
+    - "Token { span: Span(23..26, \"```\"), kind: CodeBlock }"
+- string: "*_``_*"
+  tokens:
+    - "Token { span: Span(0..1, \"*\"), kind: Strong }"
+    - "Token { span: Span(1..2, \"_\"), kind: Italic }"
+    - "Token { span: Span(2..3, \"`\"), kind: Mono }"
+    - "Token { span: Span(3..4, \"`\"), kind: Mono }"
+    - "Token { span: Span(4..5, \"_\"), kind: Italic }"
+    - "Token { span: Span(5..6, \"*\"), kind: Strong }"
+- string: "*_`*_*_"
+  tokens:
+    - "Token { span: Span(0..1, \"*\"), kind: Strong }"
+    - "Token { span: Span(1..2, \"_\"), kind: Italic }"
+    - "Token { span: Span(2..3, \"`\"), kind: Mono }"
+    - "Token { span: Span(3..4, \"*\"), kind: Strong }"
+    - "Token { span: Span(4..5, \"_\"), kind: Italic }"
+    - "Token { span: Span(5..6, \"*\"), kind: Strong }"
+    - "Token { span: Span(6..7, \"_\"), kind: Italic }"

src/markdown/span.rs

@@ -0,0 +1,115 @@
+use std::{
+    fmt,
+    ops::{Deref, Range},
+};
+
+use eyre::{bail, eyre};
+
+#[derive(Clone, Eq, PartialEq)]
+pub struct Span<'a> {
+    complete_str: &'a str,
+    range: Range<usize>,
+}
+
+impl<'a> Span<'a> {
+    pub fn new(complete_str: &'a str) -> Self {
+        Self {
+            complete_str,
+            range: 0..complete_str.len(),
+        }
+    }
+
+    pub const fn empty() -> Self {
+        Span {
+            complete_str: "",
+            range: 0..0,
+        }
+    }
+
+    pub fn get(&self, slice: Range<usize>) -> Option<Self> {
+        let start = self.range.start.checked_add(slice.start)?;
+        let end = self.range.start.checked_add(slice.end)?;
+
+        if end > self.range.end || end < start {
+            return None;
+        }
+
+        Some(Self {
+            complete_str: self.complete_str,
+            range: Range { start, end },
+        })
+    }
+
+    pub fn complete_str(&self) -> Self {
+        Self::new(self.complete_str)
+    }
+
+    pub fn split_at(&self, i: usize) -> Option<(Self, Self)> {
+        let head = self.get(0..i)?;
+        let tail = self.get(i..self.range.len())?;
+        Some((head, tail))
+    }
+
+    pub fn trim_end_matches(&self, p: &str) -> Self {
+        if !self.ends_with(p) {
+            return self.clone();
+        }
+
+        Self {
+            range: self.range.start..self.range.end - p.len(),
+            complete_str: self.complete_str,
+        }
+    }
+
+    /// Try to merge the spans.
+    ///
+    /// If either spans is empty, this just returns the other one.
+    /// This only works if spans are pointing into the same backing buffer, and are adjacent.
+    pub fn try_merge(&self, other: &Self) -> eyre::Result<Self> {
+        if self.is_empty() {
+            return Ok(other.clone());
+        }
+
+        if other.is_empty() {
+            return Ok(self.clone());
+        }
+
+        if self.complete_str.as_ptr() != other.complete_str.as_ptr() {
+            bail!("Can't merge different strings");
+        }
+
+        if self.range.end == other.range.start {
+            Ok(Self {
+                range: self.range.start..other.range.end,
+                ..*self
+            })
+        } else if self.range.start == other.range.end {
+            Ok(Self {
+                range: other.range.start..self.range.end,
+                ..*self
+            })
+        } else {
+            Err(eyre!("String: {:?}", self.complete_str)
+                .wrap_err(eyre!("Span 2: {:?}", other.deref()))
+                .wrap_err(eyre!("Span 1: {:?}", self.deref()))
+                .wrap_err("Can't merge disjoint string spans"))
+        }
+    }
+}
+
+impl Deref for Span<'_> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.complete_str[self.range.clone()]
+    }
+}
+
+impl<'a> fmt::Debug for Span<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Span")
+            .field(&self.range)
+            .field(&self.deref())
+            .finish()
+    }
+}

src/markdown/tokenizer.rs

@@ -0,0 +1,146 @@
+use std::iter;
+
+use super::{Heading, span::Span};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TokenKind {
+    /// A newline that isn't a codeblock
+    Newline,
+
+    /// "#" to "######"
+    Heading(Heading),
+
+    /// A newline followed by three `
+    CodeBlock,
+
+    Mono,
+    Strong,
+    Italic,
+    Strikethrough,
+
+    /// ">"
+    Quote,
+
+    /// Two spaces
+    Indentation,
+
+    /// "- "
+    ListEntry,
+
+    /// Normal text
+    Text,
+}
+
+const TOKENS: &[(&str, TokenKind)] = &[
+    ("\n", TokenKind::Newline),
+    ("######", TokenKind::Heading(Heading::H6)),
+    ("#####", TokenKind::Heading(Heading::H5)),
+    ("####", TokenKind::Heading(Heading::H4)),
+    ("###", TokenKind::Heading(Heading::H3)),
+    ("##", TokenKind::Heading(Heading::H2)),
+    ("#", TokenKind::Heading(Heading::H1)),
+    ("```", TokenKind::CodeBlock),
+    ("`", TokenKind::Mono),
+    ("*", TokenKind::Strong),
+    ("_", TokenKind::Italic),
+    ("~", TokenKind::Strikethrough),
+    (">", TokenKind::Quote),
+    ("  ", TokenKind::Indentation),
+    ("- ", TokenKind::ListEntry),
+];
+
+#[derive(Debug)]
+pub struct Token<'a> {
+    pub span: Span<'a>,
+    pub kind: TokenKind,
+}
+
+pub fn tokenize<'a>(s: &'a str) -> impl Iterator<Item = Token<'a>> {
+    let mut s = Span::new(s);
+    let mut yield_n: usize = 0;
+
+    iter::from_fn(move || {
+        loop {
+            if s.is_empty() {
+                return None;
+            }
+
+            if yield_n == s.len() {
+                let (token, rest) = s.split_at(s.len()).unwrap();
+                let token = Token {
+                    span: token,
+                    kind: TokenKind::Text,
+                };
+                s = rest;
+                return Some(token);
+            }
+
+            let token = TOKENS.iter().find_map(|(token_str, token_kind)| {
+                s[yield_n..]
+                    .starts_with(token_str)
+                    .then(|| (*token_kind, token_str.len()))
+            });
+
+            let Some((kind, len)) = token else {
+                yield_n += s[yield_n..].chars().next().unwrap_or('\0').len_utf8();
+                continue;
+            };
+
+            if yield_n > 0 {
+                let (token, rest) = s.split_at(yield_n).unwrap();
+                let token = Token {
+                    span: token,
+                    kind: TokenKind::Text,
+                };
+                s = rest;
+                yield_n = 0;
+                return Some(token);
+            }
+
+            let (token, rest) = s.split_at(len).unwrap();
+            let token = Token { span: token, kind };
+            s = rest;
+            return Some(token);
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use serde::Serialize;
+
+    use super::tokenize;
+
+    #[test]
+    fn test_tokenize() {
+        let examples = [
+            "just some normal text :D",
+            "normal *bold* normal",
+            "normal * maybe bold? * normal",
+            "```lang\ncode code code\n```",
+            "*_``_*",
+            "*_`*_*_",
+        ];
+
+        #[derive(Serialize)]
+        struct Result {
+            pub string: &'static str,
+
+            /// Debug-printed tokens
+            pub tokens: Vec<String>,
+        }
+
+        let examples = examples
+            .into_iter()
+            .map(|string| {
+                let tokens = tokenize(string)
+                    .map(|tokens| format!("{tokens:?}"))
+                    .collect::<Vec<_>>();
+
+                Result { string, tokens }
+            })
+            .collect::<Vec<_>>();
+
+        insta::assert_yaml_snapshot!(examples);
+    }
+}

src/preferences.rs

@@ -1,4 +1,4 @@
-use egui::{Color32, Context, RichText, Theme, Ui, Visuals};
+use egui::{Color32, Context, RichText, Theme, Ui, Visuals, style::ScrollAnimation};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
@@ -10,8 +10,11 @@ pub struct Preferences {
     /// Enable high-contrast theme
     pub high_contrast: bool,
 
+    /// Hide the cursor when handwriting
+    pub hide_handwriting_cursor: bool,
+
     #[serde(skip)]
-    has_applied_theme: bool,
+    has_applied_prefs: bool,
 }
 
 impl Default for Preferences {
@@ -19,7 +22,8 @@ impl Default for Preferences {
         Self {
             animations: true,
             high_contrast: false,
-            has_applied_theme: false,
+            has_applied_prefs: false,
+            hide_handwriting_cursor: false,
         }
     }
 }
@@ -27,16 +31,33 @@ impl Default for Preferences {
 impl Preferences {
     /// Apply preferences, if they haven't already been applied.
     pub fn apply(&mut self, ctx: &Context) {
-        if !self.has_applied_theme {
-            self.has_applied_theme = true;
+        if !self.has_applied_prefs {
+            self.has_applied_prefs = true;
+
+            let scroll_animation = if self.animations {
+                ScrollAnimation::default()
+            } else {
+                ScrollAnimation::none()
+            };
+
+            for theme in [Theme::Dark, Theme::Light] {
+                ctx.style_mut_of(theme, |style| {
+                    style.scroll_animation = scroll_animation;
+                });
+            }
+
+            let mut dark_visuals = Visuals::dark();
+            let mut light_visuals = Visuals::light();
+
+            dark_visuals.code_bg_color = Color32::BLACK;
+            dark_visuals.code_bg_color = Color32::BLACK;
+            light_visuals.code_bg_color = Color32::WHITE;
 
             if self.high_contrast {
                 // widgets.active:         color of headers in textedit
                 // widgets.inactive:       color of button labels
                 // widgets.hovered:        color of hovered button labels
                 // widgets.noninteractive: color of labels and normal textedit text
-                let mut dark_visuals = Visuals::dark();
-                let mut light_visuals = Visuals::light();
 
                 dark_visuals.widgets.noninteractive.fg_stroke.color = Color32::WHITE;
                 dark_visuals.widgets.inactive.fg_stroke.color = Color32::WHITE;
@@ -45,13 +66,16 @@ impl Preferences {
                 light_visuals.widgets.noninteractive.fg_stroke.color = Color32::BLACK;
                 light_visuals.widgets.inactive.fg_stroke.color = Color32::BLACK;
                 light_visuals.widgets.hovered.fg_stroke.color = Color32::BLACK;
-
-                ctx.set_visuals_of(Theme::Dark, dark_visuals);
-                ctx.set_visuals_of(Theme::Light, light_visuals);
             } else {
-                ctx.set_visuals_of(Theme::Dark, Visuals::dark());
-                ctx.set_visuals_of(Theme::Light, Visuals::light());
+                dark_visuals.widgets.noninteractive.fg_stroke.color =
+                    Color32::from_rgb(0xaa, 0xaa, 0xaa);
+
+                light_visuals.widgets.noninteractive.fg_stroke.color =
+                    Color32::from_rgb(0x11, 0x11, 0x11);
             }
+
+            ctx.set_visuals_of(Theme::Dark, dark_visuals);
+            ctx.set_visuals_of(Theme::Light, light_visuals);
         }
     }
 
@@ -59,14 +83,20 @@ impl Preferences {
     pub fn show(&mut self, ui: &mut Ui) {
         ui.label(RichText::new("Prefs").weak());
 
-        ui.toggle_value(&mut self.animations, "Animations");
+        let animations_toggle = ui.toggle_value(&mut self.animations, "Animations");
+        if animations_toggle.clicked() {
+            self.has_applied_prefs = false;
+            self.apply(ui.ctx());
+        }
 
         let high_contrast_toggle = ui.toggle_value(&mut self.high_contrast, "High Contrast");
         if high_contrast_toggle.clicked() {
-            self.has_applied_theme = false;
+            self.has_applied_prefs = false;
             self.apply(ui.ctx());
         }
 
+        ui.toggle_value(&mut self.hide_handwriting_cursor, "Hide Handwriting Cursor");
+
         egui::widgets::global_theme_preference_buttons(ui);
     }
 }

src/rasterizer.rs

@@ -1,5 +1,6 @@
 use core::f32;
 use egui::{Color32, ColorImage, Pos2, Rect, Vec2, emath::TSTransform, epaint::Vertex};
+use std::ops::Range;
 
 pub trait BlendFn {
     fn blend(a: Color32, b: Color32) -> Color32;
@@ -21,7 +22,7 @@ pub fn rasterize<'a, Blend: BlendFn>(
     point_to_pixel: TSTransform,
     triangles: impl Iterator<Item = [&'a Vertex; 3]>,
 ) -> ColorImage {
-    let mut image = ColorImage::new([width, height], Color32::TRANSPARENT);
+    let mut image = ColorImage::filled([width, height], Color32::TRANSPARENT);
     rasterize_onto::<Blend>(&mut image, point_to_pixel, triangles);
     image
 }
@@ -72,15 +73,11 @@ pub fn rasterize_onto<'a, Blend: BlendFn>(
 
             // If the pixel is within the triangle, fill it in.
             if point_in_triangle.inside {
-                let c0 = triangle[0]
-                    .color
-                    .linear_multiply(point_in_triangle.weights[0]);
-                let c1 = triangle[1]
-                    .color
-                    .linear_multiply(point_in_triangle.weights[1]);
-                let c2 = triangle[2]
-                    .color
-                    .linear_multiply(point_in_triangle.weights[2]);
+                let [c0, c1, c2] = [0, 1, 2].map(|i| {
+                    triangle[i]
+                        .color
+                        .linear_multiply(point_in_triangle.weights[i])
+                });
 
                 let color = c0 + c1 + c2;
 
@@ -90,9 +87,20 @@ pub fn rasterize_onto<'a, Blend: BlendFn>(
     }
 }
 
+/// Rasterize a single triangles onto an image,
+///
+/// Triangle positions must be in image-local point-coords.
+pub fn rasterize_triangle_onto<Blend: BlendFn>(
+    image: &mut ColorImage,
+    point_to_pixel: TSTransform,
+    triangle: [&Vertex; 3],
+) {
+    rasterize_onto::<Blend>(image, point_to_pixel, [triangle].into_iter());
+}
+
 /// A bounding box, measured in pixels.
 #[derive(Debug, PartialEq, Eq)]
-struct PxBoundingBox {
+pub struct PxBoundingBox {
     pub x_from: usize,
     pub y_from: usize,
     pub x_to: usize,
@@ -108,9 +116,41 @@ impl PxBoundingBox {
             y_to: self.y_to.min(other.y_to),
         }
     }
+
+    pub fn union(&self, other: &PxBoundingBox) -> PxBoundingBox {
+        PxBoundingBox {
+            x_from: self.x_from.min(other.x_from),
+            y_from: self.y_from.min(other.y_from),
+            x_to: self.x_to.max(other.x_to),
+            y_to: self.y_to.max(other.y_to),
+        }
+    }
+
+    pub fn x_range(&self) -> Range<usize> {
+        self.x_from..self.x_to
+    }
+
+    pub fn y_range(&self) -> Range<usize> {
+        self.y_from..self.y_to
+    }
+
+    /// Test whether two boxes do NOT overlap
+    pub fn overlaps_with(&self, other: &PxBoundingBox) -> bool {
+        !self.is_disjoint_from(other)
+    }
+
+    pub fn is_disjoint_from(&self, other: &PxBoundingBox) -> bool {
+        self.x_from > other.x_to
+            || self.y_from > other.y_to
+            || other.x_from > self.x_to
+            || other.y_from > self.y_to
+    }
 }
 
-fn triangle_bounding_box(triangle: &[&Vertex; 3], point_to_pixel: TSTransform) -> PxBoundingBox {
+pub fn triangle_bounding_box(
+    triangle: &[&Vertex; 3],
+    point_to_pixel: TSTransform,
+) -> PxBoundingBox {
     // calculate bounding box in point coords
     let mut rect = Rect::NOTHING;
     for vertex in triangle {
@@ -169,6 +209,10 @@ fn point_in_triangle(point: Pos2, triangle: [&Vertex; 3]) -> PointInTriangle {
     // Normalize the weights.
     let weights = areas.map(|area| area / triangle_area);
 
+    if cfg!(debug_assertions) && weights.into_iter().any(f32::is_nan) {
+        panic!("weights must not be NaN! {weights:?} {triangle_area:?} {areas:?} {sides:?}");
+    }
+
     PointInTriangle { inside, weights }
 }
 

src/snapshots/inkr__custom_code_block__test__iter_markdown-2.snap

@@ -0,0 +1,43 @@
+---
+source: src/custom_code_block.rs
+expression: list
+---
+[
+    Line(
+        "\n",
+    ),
+    Line(
+        "# Hello world\n",
+    ),
+    Line(
+        "## Subheader\n",
+    ),
+    Line(
+        "- 1\n",
+    ),
+    CodeBlock {
+        key: "foo",
+        content: "  whatever\n     some code\n Hi mom!",
+        span: "```foo\n  whatever\n     some code\n Hi mom!\n```",
+    },
+    Line(
+        " \n",
+    ),
+    Line(
+        "\n",
+    ),
+    CodeBlock {
+        key: "` # wrong number of ticks, but that's ok",
+        content: " ``` # indented ticks",
+        span: "```` # wrong number of ticks, but that's ok\n ``` # indented ticks\n```\n",
+    },
+    Line(
+        "\n",
+    ),
+    Line(
+        "``` # no closing ticks\n",
+    ),
+    Line(
+        "            ",
+    ),
+]

src/snapshots/inkr__painting__test__serialized handwriting.snap

@@ -0,0 +1,7 @@
+---
+source: src/painting.rs
+expression: serialized
+---
+```handwriting
+BQAAvAA8AEIAPABCAEIAPgBAAAAAAAQAAEIAQgC8ADwAAAAAAEIAPA==
+```

src/text_editor.rs

@@ -8,7 +8,7 @@ use egui::{
     Color32, InputState, Key, Modifiers, TextBuffer, TextEdit, Ui, Vec2, text::CCursorRange,
 };
 
-use crate::easy_mark::MemoizedHighlighter;
+use crate::markdown::MemoizedHighlighter;
 
 #[derive(Default, serde::Deserialize, serde::Serialize)]
 pub struct MdTextEdit {
@@ -24,6 +24,10 @@ pub struct MdTextEdit {
     cursor: Option<CCursorRange>,
 }
 
+pub struct MdTextEditOutput {
+    pub changed: bool,
+}
+
 impl MdTextEdit {
     pub fn new() -> Self {
         MdTextEdit::default()
@@ -36,7 +40,7 @@ impl MdTextEdit {
         }
     }
 
-    pub fn ui(&mut self, ui: &mut Ui) {
+    pub fn ui(&mut self, ui: &mut Ui) -> MdTextEditOutput {
         let Self {
             text,
             highlighter,
@@ -46,8 +50,8 @@ impl MdTextEdit {
 
         let w = ui.available_width();
 
-        let mut layouter = |ui: &egui::Ui, easymark: &dyn TextBuffer, _wrap_width: f32| {
-            let mut layout_job = highlighter.highlight(ui.style(), easymark.as_str(), *cursor);
+        let mut layouter = |ui: &egui::Ui, markdown: &dyn TextBuffer, _wrap_width: f32| {
+            let mut layout_job = highlighter.highlight(ui.style(), markdown.as_str(), *cursor);
             layout_job.wrap.max_width = w - 10.0;
             ui.fonts(|f| f.layout_job(layout_job))
         };
@@ -72,6 +76,10 @@ impl MdTextEdit {
             *cursor = text_edit.cursor_range;
             //ui.ctx().request_repaint();
         }
+
+        MdTextEditOutput {
+            changed: text_edit.response.changed(),
+        }
     }
 }
 

src/util.rs

@@ -1,6 +1,8 @@
-use std::sync::mpsc;
+use std::{fs::File, os::unix::fs::MetadataExt as _, sync::mpsc};
 
+use chrono::{DateTime, Local};
 use egui::Id;
+use eyre::{Context, ContextCompat};
 use rand::{Rng, rng};
 
 pub fn random_id() -> Id {
@@ -28,3 +30,27 @@ impl<T> GuiSender<T> {
         Ok(())
     }
 }
+
+#[track_caller]
+pub fn log_error<T>(chain: eyre::Report, f: impl FnOnce() -> eyre::Result<T>) -> Option<T> {
+    f().map_err(|e| e.wrap_err(chain))
+        .inspect_err(|e| log::error!("{e}"))
+        .ok()
+}
+
+pub fn file_mtime(file: &File) -> eyre::Result<DateTime<Local>> {
+    (move || {
+        let meta = file.metadata().wrap_err("Failed to stat file")?;
+
+        let sec = meta.mtime();
+        let nsec = meta
+            .mtime_nsec()
+            .try_into()
+            .wrap_err("Nanoseconds overflowed")?;
+
+        DateTime::from_timestamp(sec, nsec)
+            .wrap_err("Bad timestamp")
+            .map(Into::into)
+    })()
+    .wrap_err("Failed to get file mtime")
+}