Shrink handwriting when not focused [wip]

Cargo.toml

@@ -12,25 +12,22 @@ targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
 pinenote = []
 
 [dependencies]
-egui = "0.32"
-egui_extras = { version = "0.32", features = ["svg"] }
-egui_glow = "0.32"
-eframe = { version = "0.32", default-features = false, features = [
+egui = "0.31"
+egui_extras = { version = "0.31", features = ["svg"] }
+eframe = { version = "0.31", 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"
@@ -42,14 +39,13 @@ wasm-bindgen-futures = "0.4.50"
 web-sys = "0.3.77"
 
 [patch.crates-io]
-# egui = { path = "../egui/crates/egui" }
-# eframe = { path = "../egui/crates/eframe" }
+egui =   { git = "https://github.com/emilk/egui", rev = "f2ce6424f3a32f47308fb9871d540c01377b2cd9" }
+eframe = { git = "https://github.com/emilk/egui", rev = "f2ce6424f3a32f47308fb9871d540c01377b2cd9" }
 
 [dev-dependencies]
 insta = { version = "1.43.1", features = ["yaml"] }
-
-[lints.clippy]
-unnecessary_lazy_evaluations = "allow"
+# egui = { path = "../egui/crates/egui" }
+# eframe = { path = "../egui/crates/eframe" }
 
 [profile.release]
 opt-level = 2 # fast and small wasm

src/app.rs

@@ -1,24 +1,16 @@
 use std::{
     fs,
-    io::Read,
     path::PathBuf,
     sync::{Arc, mpsc},
     thread::JoinHandle,
     time::{Duration, Instant},
 };
 
-use crate::{
-    file_editor::{FileEditor, SaveStatus},
-    folder::Folder,
-    preferences::Preferences,
-    text_styles::{H1, H1_MONO, H2, H2_MONO, H3, H3_MONO, H4, H4_MONO, H5, H5_MONO, H6, H6_MONO},
-    util::{GuiSender, file_mtime, log_error},
-};
+use crate::{file_editor::FileEditor, folder::Folder, preferences::Preferences, util::GuiSender};
 use egui::{
-    Align, Button, Context, FontData, FontDefinitions, FontFamily, FontId, Frame, Image, Key,
-    Modifiers, PointerButton, RichText, ScrollArea, Theme, Widget, include_image,
+    Align, Button, Color32, Context, FontData, FontDefinitions, Image, Key, Modifiers,
+    PointerButton, RichText, ScrollArea, Stroke, Widget, include_image,
 };
-use eyre::eyre;
 
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)]
@@ -48,7 +40,7 @@ pub struct Jobs {
 }
 
 impl Jobs {
-    pub fn start(&mut self, ctx: &Context, job: impl FnOnce() -> Option<Action> + Send + 'static) {
+    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 || {
@@ -81,21 +73,9 @@ impl Tab {
         }
     }
 
-    pub fn notice_symbol(&self) -> Option<&'static str> {
+    pub fn is_dirty(&self) -> bool {
         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),
+            Tab::File(file_editor) => file_editor.is_dirty,
         }
     }
 }
@@ -191,38 +171,22 @@ impl App {
         .map(|(name, data)| (name.to_string(), Arc::new(FontData::from_static(data))))
         .collect();
 
-        fonts
-            .families
-            .insert(FontFamily::Proportional, vec!["IosevkaAile-Regular".into()]);
+        fonts.families.insert(
+            egui::FontFamily::Proportional,
+            vec!["IosevkaAile-Regular".into()],
+        );
 
         fonts
             .families
-            .insert(FontFamily::Monospace, vec!["Iosevka-Thin".into()]);
+            .insert(egui::FontFamily::Monospace, vec!["Iosevka-Thin".into()]);
 
         cc.egui_ctx.set_fonts(fonts);
 
-        // markdown font styles
-        for theme in [Theme::Dark, Theme::Light] {
-            cc.egui_ctx.style_mut_of(theme, |style| {
-                for (name, size, family) in [
-                    (H1, 28.0, FontFamily::Proportional),
-                    (H2, 26.0, FontFamily::Proportional),
-                    (H3, 24.0, FontFamily::Proportional),
-                    (H4, 22.0, FontFamily::Proportional),
-                    (H5, 20.0, FontFamily::Proportional),
-                    (H6, 18.0, FontFamily::Proportional),
-                    (H1_MONO, 28.0, FontFamily::Monospace),
-                    (H2_MONO, 26.0, FontFamily::Monospace),
-                    (H3_MONO, 24.0, FontFamily::Monospace),
-                    (H4_MONO, 22.0, FontFamily::Monospace),
-                    (H5_MONO, 20.0, FontFamily::Monospace),
-                    (H6_MONO, 18.0, FontFamily::Monospace),
-                ] {
-                    let name = egui::TextStyle::Name(name.into());
-                    style.text_styles.insert(name, FontId { size, family });
-                }
-            });
-        }
+        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));
+        });
 
         // enable features on egui_extras to add more image types
         egui_extras::install_image_loaders(&cc.egui_ctx);
@@ -295,7 +259,7 @@ impl eframe::App for App {
         });
 
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
-            egui::MenuBar::new().ui(ui, |ui| {
+            egui::containers::menu::Bar::new().ui(ui, |ui| {
                 // NOTE: no File->Quit on web pages!
                 ui.menu_button("Menu ⚙", |ui| {
                     ui.label(RichText::new("Action").weak());
@@ -310,18 +274,11 @@ impl eframe::App for App {
                         self.jobs.start(ui.ctx(), move || {
                             let file_path = rfd::FileDialog::new().pick_file()?;
 
-                            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)
+                            let text = fs::read_to_string(&file_path)
                                 .inspect_err(|e| log::error!("Failed to read {file_path:?}: {e}"))
                                 .ok()?;
 
-                            let editor = FileEditor::from_file(file_path, &text, mtime);
+                            let editor = FileEditor::from_file(file_path, &text);
                             Some(Action::OpenFile(editor))
                         });
                     }
@@ -413,8 +370,8 @@ impl eframe::App for App {
                         let selected = self.open_tab_index == Some(i);
                         let mut button = Button::new(tab.title()).selected(selected);
 
-                        if let Some(symbol) = tab.notice_symbol() {
-                            button = button.right_text(RichText::new(symbol).strong())
+                        if tab.is_dirty() {
+                            button = button.right_text(RichText::new("*").strong())
                         }
 
                         let response = ui.add(button);
@@ -445,22 +402,13 @@ impl eframe::App for App {
                         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)
+                                let text = fs::read_to_string(&file_path)
                                     .inspect_err(|e| {
                                         log::error!("Failed to read {file_path:?}: {e}")
                                     })
                                     .ok()?;
 
-                                let editor = FileEditor::from_file(file_path, &text, mtime);
+                                let editor = FileEditor::from_file(file_path, &text);
                                 Some(Action::OpenFile(editor))
                             });
                         }
@@ -471,24 +419,19 @@ impl eframe::App for App {
                 });
             });
 
-        egui::CentralPanel::default()
-            .frame(Frame {
-                fill: ctx.style().visuals.window_fill(),
-                ..Frame::central_panel(&ctx.style())
-            })
-            .show(ctx, |ui| {
-                if let Some(Tab::File(file_editor)) = self
-                    .open_tab_index
-                    .and_then(|i| self.tabs.get_mut(i))
-                    .map(|(_tab_id, tab)| tab)
-                {
-                    file_editor.show(ui, &self.preferences);
-                }
+        egui::CentralPanel::default().show(ctx, |ui| {
+            if let Some(Tab::File(file_editor)) = self
+                .open_tab_index
+                .and_then(|i| self.tabs.get_mut(i))
+                .map(|(_tab_id, tab)| tab)
+            {
+                file_editor.show(ui, &self.preferences);
+            }
 
-                ui.with_layout(egui::Layout::bottom_up(Align::LEFT), |ui| {
-                    egui::warn_if_debug_build(ui);
-                });
+            ui.with_layout(egui::Layout::bottom_up(Align::LEFT), |ui| {
+                egui::warn_if_debug_build(ui);
             });
+        });
     }
 }
 
@@ -511,13 +454,29 @@ impl App {
     }
 
     fn save_active_tab(&mut self, ctx: &Context) {
-        let open_tab = self
+        let open_file = self
             .open_tab_index
             .and_then(|i| self.tabs.get_mut(i))
-            .map(|(_id, tab)| tab);
+            .map(|(id, tab)| match tab {
+                Tab::File(file_editor) => (*id, file_editor),
+            })
+            .and_then(|(_, file_editor)| {
+                file_editor
+                    .path()
+                    .map(ToOwned::to_owned)
+                    .zip(Some(file_editor))
+            });
 
-        if let Some(open_tab) = open_tab {
-            open_tab.save(ctx, &mut self.jobs);
+        if let Some((file_path, file_editor)) = open_file {
+            file_editor.is_dirty = false;
+            let text = file_editor.to_string();
+            let file_path = file_path.to_owned();
+            self.jobs.start(ctx, move || {
+                if let Err(e) = fs::write(file_path, text.as_bytes()) {
+                    log::error!("{e}");
+                };
+                None
+            });
         }
     }
 }

src/easy_mark/easy_mark_highlighter.rs

@@ -0,0 +1,243 @@
+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

@@ -0,0 +1,346 @@
+//! 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

@@ -0,0 +1,7 @@
+//! 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,116 +1,57 @@
 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, Context, DragAndDrop, Frame, Layout, ScrollArea, Ui, UiBuilder, Vec2, vec2,
+    Align, Button, 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},
     handwriting::{self, Handwriting, HandwritingStyle},
     preferences::Preferences,
     text_editor::MdTextEdit,
-    util::{file_mtime, log_error},
 };
 
 #[derive(serde::Deserialize, serde::Serialize)]
 pub struct FileEditor {
     title: String,
-
-    path: Option<PathBuf>,
+    pub 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>),
+    /// Whether the file has been edited since it was laste saved to disk.
+    pub is_dirty: bool,
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
 pub enum BufferItem {
-    Text(Box<MdTextEdit>),
+    Text(MdTextEdit),
     Handwriting(Box<Handwriting>),
 }
 
 impl FileEditor {
     pub fn new(title: impl Into<String>) -> Self {
-        let buffer = vec![BufferItem::Text(Box::new(MdTextEdit::new()))];
+        let buffer = vec![BufferItem::Text(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, mtime: DateTime<Local>) -> Self {
+    pub fn from_file(file_path: PathBuf, contents: &str) -> 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)
         }
     }
@@ -123,66 +64,15 @@ 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;
 
-            // 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 input.consume_key(egui::Modifiers::NONE, egui::Key::PageDown) {
-                    scroll_delta -= self.scroll_delta;
-                }
-            });
-
             ui.horizontal(|ui| {
                 ui.label("new");
-                if ui.button(" text ").clicked() {
+                if ui.button("text").clicked() {
                     self.is_dirty = true;
                     self.buffer.push(BufferItem::Text(Default::default()));
                 }
@@ -191,23 +81,9 @@ impl FileEditor {
                     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));
-                }
-
+            ScrollArea::vertical().show(ui, |ui| {
                 ui.horizontal(|ui| {
                     let side_padding = ui.available_width().sub(MAX_NOTE_WIDTH).max(0.0).div(2.0);
                     ui.add_space(side_padding);
@@ -218,8 +94,6 @@ impl FileEditor {
                     ui.add_space(side_padding);
                 });
             });
-
-            self.scroll_delta = scroll_area.inner_rect.height() * 0.5;
         });
     }
 
@@ -246,16 +120,25 @@ impl FileEditor {
 
             let mut retain = true;
 
-            // Createa horizontal area to draw the buffer item. The three things drawn here are:
-            // - The controls that exist at the left-size of the buffer item, i.e. "up"/"down".
-            // - The buffer item.
-            // - The controls that exist at the right-size of the buffer item, i.e. "delete".
-            ui.horizontal(|ui| {
-                // At this point, we don't know how tall the buffer item will be, so we'll reserve
-                // some horizontal space here and come back to drawing the controls later.
-                let (_id, mut left_controls_rect) = ui.allocate_space(Vec2::new(20.0, 1.0));
+            if is_dragging {
+                let (_, drop) = ui.dnd_drop_zone::<DraggingItem, _>(Frame::NONE, |ui| {
+                    ui.set_min_size(vec2(ui.available_width(), drag_zone_height));
+                });
+                if let Some(drop) = drop {
+                    drop_from_to = Some((drop.index, i));
+                }
+            } else {
+                // the dnd_drop_zone adds 3pts work of extra space
+                ui.add_space(drag_zone_height + 3.0);
+            }
 
-                // Leave some space at the end for the delete button.
+            ui.horizontal(|ui| {
+                // We don't know how tall the buffer item will be, so we'll reserve
+                // some horizontal space here and come back to drawing the dragger
+                // later.
+                let (dragger_id, mut dragger_rect) = ui.allocate_space(Vec2::new(20.0, 1.0));
+
+                // Leave some space at the end for the delete button..
                 let w = ui.available_width();
                 let item_size = Vec2::new(w - 20.0, 0.0);
 
@@ -268,7 +151,6 @@ impl FileEditor {
                     BufferItem::Handwriting(handwriting) => {
                         let style = HandwritingStyle {
                             animate: preferences.animations,
-                            hide_cursor: preferences.hide_handwriting_cursor,
                             ..HandwritingStyle::from_theme(ui.ctx().theme())
                         };
                         if handwriting.ui(&style, ui).changed {
@@ -278,17 +160,18 @@ impl FileEditor {
                 });
 
                 // Delete-button
-                if ui.button("⌫").clicked() {
+                if ui.button("x").clicked() {
                     retain = false;
                     ui.ctx().request_repaint();
                 }
 
-                left_controls_rect.set_height(item_response.response.rect.height());
+                // Draw the dragger using the height from the buffer item
+                dragger_rect.set_height(item_response.response.rect.height());
 
                 // Controls for moving the buffer item
-                ui.scope_builder(
+                ui.allocate_new_ui(
                     UiBuilder::new()
-                        .max_rect(left_controls_rect)
+                        .max_rect(dragger_rect)
                         .layout(Layout::top_down(Align::Center)),
                     |ui| {
                         let up_button_response = ui.add_enabled(!is_first, Button::new("⇡"));
@@ -296,12 +179,17 @@ impl FileEditor {
                             drop_from_to = Some((i, i - 1));
                         }
 
-                        // Add some space so that the next button is drawn
-                        // at the bottom of the buffer item.
-                        ui.add_space(
-                            left_controls_rect.height()
-                                - (up_button_response.rect.height() * 2.0 + 4.0),
-                        );
+                        ui.dnd_drag_source(dragger_id, DraggingItem { index: i }, |ui| {
+                            Button::new("≡")
+                                .min_size(
+                                    // Use all available height, save for the height taken up by
+                                    // the up/down buttons + padding. Assume down-button is the
+                                    // equally tall as the up-button.
+                                    dragger_rect.size()
+                                        - Vec2::Y * (up_button_response.rect.height() * 2.0 + 4.0),
+                                )
+                                .ui(ui);
+                        });
 
                         if ui.add_enabled(!is_last, Button::new("⇣")).clicked() {
                             drop_from_to = Some((i, i + 2));
@@ -354,38 +242,6 @@ 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 {
@@ -423,7 +279,7 @@ impl From<&str> for FileEditor {
             _ => {
                 let mut text_edit = MdTextEdit::new();
                 text_edit.text.push_str(text);
-                buffer.push(BufferItem::Text(Box::new(text_edit)));
+                buffer.push(BufferItem::Text(text_edit));
             }
         };
 
@@ -457,40 +313,6 @@ 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

@@ -7,7 +7,7 @@ use std::{
     thread,
 };
 
-use egui::{Button, Color32, Response, Stroke, TextWrapMode, Ui, Vec2, Widget};
+use egui::{Response, Ui};
 use eyre::{Context, OptionExt, eyre};
 use serde::{Deserialize, Serialize};
 
@@ -52,59 +52,20 @@ impl Deref for FolderResponse<'_> {
 impl LoadedFolder {
     pub fn show<'a>(&'a mut self, ui: &mut Ui) -> FolderResponse<'a> {
         let mut open_file = None;
-
-        let draw_highlight = |ui: &mut Ui, rect| {
-            ui.painter().rect(
-                rect,
-                2.0,
-                if ui.visuals().dark_mode {
-                    Color32::from_white_alpha(16)
-                } else {
-                    Color32::from_black_alpha(16)
-                },
-                Stroke::NONE,
-                egui::StrokeKind::Outside,
-            );
-        };
-
         let inner = ui
             .collapsing(&self.name, |ui| {
                 for folder in &mut self.child_folders {
                     open_file = open_file.or(folder.show(ui).open_file);
                 }
 
-                let w = ui.available_width();
-
-                let mut first = true;
-
                 for file in &mut self.child_files {
-                    if !first {
-                        ui.add_space(2.0);
-                    }
-                    first = false;
-
-                    let button = Button::new(&file.name)
-                        .min_size(Vec2::new(w, 0.0))
-                        .wrap_mode(TextWrapMode::Truncate)
-                        .frame(false)
-                        .corner_radius(0.0)
-                        .ui(ui);
-
-                    if button.hovered() {
-                        draw_highlight(ui, button.rect);
-                    }
-
-                    if button.clicked() {
+                    if ui.button(&file.name).clicked() {
                         open_file = Some(file.path.as_path())
                     };
                 }
             })
             .header_response;
 
-        if inner.hovered() {
-            draw_highlight(ui, inner.rect);
-        }
-
         FolderResponse { inner, open_file }
     }
 
@@ -133,19 +94,12 @@ impl LoadedFolder {
                 log::error!("Symlinks not yet supported, skipping {path:?}");
                 continue;
             } else if file_type.is_file() {
-                if filter_file(&name) {
-                    child_files.push(File { name, path });
-                }
+                child_files.push(File { name, path });
             } else if file_type.is_dir() {
-                if filter_folder(&name) {
-                    child_folders.push(Folder::NotLoaded { name, path });
-                }
+                child_folders.push(Folder::NotLoaded { name, path });
             }
         }
 
-        child_folders.sort_by_key(|folder| folder.name().to_owned());
-        child_files.sort_by_key(|file| (!file.name.ends_with(".md"), file.name.clone()));
-
         let folder = LoadedFolder {
             name,
             path,
@@ -262,11 +216,3 @@ impl<'de> Deserialize<'de> for Folder {
         Ok(Folder::NotLoaded { name, path })
     }
 }
-
-fn filter_folder(_folder_name: &str) -> bool {
-    true
-}
-
-fn filter_file(file_name: &str) -> bool {
-    file_name != ".DS_Store"
-}

src/handwriting/canvas_rasterizer.rs

@@ -1,176 +0,0 @@
-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/mod.rs

@@ -1,7 +1,3 @@
-mod canvas_rasterizer;
-mod disk_format;
-mod tool;
-
 use std::{
     fmt::{self, Display},
     iter, mem,
@@ -9,25 +5,27 @@ 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, Event, Frame, Id, Mesh, PointerButton, Pos2, Rect, Sense, Shape, Stroke, Theme, Ui,
-    Vec2,
-    emath::{self, RectTransform, TSTransform},
-    epaint::{TessellationOptions, Tessellator, Vertex},
+    Color32, ColorImage, CornerRadius, Event, Frame, Id, Mesh, PointerButton, Pos2, Rect, Sense,
+    Shape, Stroke, TextureHandle, Theme, Ui, Vec2,
+    emath::{self, TSTransform},
+    epaint::{Brush, RectShape, TessellationOptions, Tessellator, Vertex},
+    load::SizedTexture,
 };
 use eyre::{Context, bail};
 use eyre::{OptionExt, eyre};
 use half::f16;
 use zerocopy::{FromBytes, IntoBytes};
 
-use crate::{custom_code_block::try_from_custom_code_block, rasterizer};
+use crate::{
+    custom_code_block::try_from_custom_code_block,
+    rasterizer::{self, rasterize, rasterize_onto},
+};
 use crate::{custom_code_block::write_custom_code_block, util::random_id};
 
-use self::tool::{ToolEvent, Tool};
+mod disk_format;
 
 const HANDWRITING_MIN_HEIGHT: f32 = 100.0;
 const HANDWRITING_BOTTOM_PADDING: f32 = 80.0;
@@ -60,7 +58,6 @@ pub struct HandwritingStyle {
     pub bg_line_stroke: Stroke,
     pub bg_color: Color32,
     pub animate: bool,
-    pub hide_cursor: bool,
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
@@ -79,16 +76,6 @@ pub struct Handwriting {
 struct Ephemeral {
     id: Id,
 
-    canvas_rasterizer: CanvasRasterizer,
-
-    tool: Tool,
-
-    /// Tool position in canvas space.
-    tool_position: Option<Pos2>,
-
-    /// Tool position last frame, in canvas space.
-    last_tool_position: Option<Pos2>,
-
     /// Whether the handwriting element is being interacted with.
     is_focused: bool,
 
@@ -96,8 +83,6 @@ struct Ephemeral {
     current_stroke: Vec<Pos2>,
 
     /// The lines that have not been blitted to `texture` yet.
-    ///
-    /// Each pair of [Pos2]s is the start and end of one line.
     unblitted_lines: Vec<[Pos2; 2]>,
 
     tessellator: Option<Tessellator>,
@@ -105,6 +90,10 @@ struct Ephemeral {
     /// Tessellated mesh of all strokes
     mesh: Arc<Mesh>,
 
+    texture: Option<TextureHandle>,
+
+    image: ColorImage,
+
     refresh_texture: bool,
 
     /// Context of the last mesh render.
@@ -123,9 +112,45 @@ 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 {
@@ -141,14 +166,12 @@ impl Default for Ephemeral {
     fn default() -> Self {
         Self {
             id: random_id(),
-            canvas_rasterizer: Default::default(),
-            tool: Tool::Eraser,
-            tool_position: None,
-            last_tool_position: None,
             is_focused: false,
             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(),
@@ -184,20 +207,6 @@ impl Handwriting {
                 }
             });
 
-            if ui.button("copy").clicked() {
-                let text = self.to_string();
-                // TODO: move to a job
-                let _ = Clipboard::new().unwrap().set_text(text);
-            }
-
-            let (label, switch_to_tool) = match self.e.tool {
-                Tool::Pencil => ("eraser", Tool::Eraser),
-                Tool::Eraser => ("pencil", Tool::Pencil),
-            };
-            if ui.button(label).clicked() {
-                self.e.tool = switch_to_tool;
-            }
-
             let vertex_count: usize = self.e.mesh.indices.len() / 3;
             ui.label(format!("vertices: {vertex_count}"));
         })
@@ -221,11 +230,12 @@ impl Handwriting {
         }
 
         let desired_size = Vec2::new(ui.available_width(), self.height);
-        let (mut response, painter) = ui.allocate_painter(desired_size, Sense::drag());
+        let (response, painter) = ui.allocate_painter(desired_size, Sense::drag());
 
-        if style.hide_cursor {
-            response = response.on_hover_and_drag_cursor(egui::CursorIcon::None);
-        }
+        let mut response = response
+            //.on_hover_cursor(CursorIcon::Crosshair)
+            //.on_hover_and_drag_cursor(CursorIcon::None)
+            ;
 
         let size = response.rect.size();
 
@@ -237,8 +247,6 @@ impl Handwriting {
             emath::RectTransform::from_to(Rect::from_min_size(Pos2::ZERO, size), response.rect);
         let from_screen = to_screen.inverse();
 
-        self.e.last_tool_position = self.e.tool_position;
-
         // Was the user in the process of drawing a stroke last frame?
         let was_drawing = !self.e.current_stroke.is_empty();
 
@@ -311,23 +319,88 @@ impl Handwriting {
 
             // Process input events and turn them into strokes
             for event in events {
-                let mut last_tool_position = self.e.last_tool_position;
-                process_event(&mut last_tool_position, from_screen, &event, |tool_event| {
-                    self.e.tool_position = tool_event.position();
-                    match self.e.tool {
-                        Tool::Pencil => {
-                            hw_response.changed |=
-                            tool::pencil::on_tool_event(self, tool_event);
-                            
-                        }
-                        Tool::Eraser => {
-                            if tool::eraser::on_tool_event(self, tool_event) {
-                                self.e.refresh_texture = true;
-                                hw_response.changed = true;
+                let last_canvas_pos = self.e.current_stroke.last();
+
+                match event {
+                    Event::PointerMoved(new_position) => {
+                        let new_canvas_pos = from_screen * new_position;
+                        if let Some(&last_canvas_pos) = last_canvas_pos {
+                            if last_canvas_pos != new_canvas_pos {
+                                self.push_to_stroke(new_canvas_pos);
+                                response.mark_changed();
                             }
                         }
                     }
-                });
+
+                    Event::MouseMoved(mut delta) => {
+                        if delta.length() == 0.0 {
+                            continue;
+                        }
+
+                        // FIXME: pinenote: MouseMovement delta does *not* take into account screen
+                        // scaling and rotation, so unless you've scaling=1 and no rotation, the
+                        // MouseMoved values will be all wrong.
+                        if cfg!(feature = "pinenote") {
+                            delta /= 1.8;
+                            delta = -delta.rot90();
+                        }
+
+                        if let Some(&last_canvas_pos) = last_canvas_pos {
+                            self.push_to_stroke(last_canvas_pos + delta);
+                            response.mark_changed();
+                        } else {
+                            println!("Got `MouseMoved`, but have no previous pos");
+                        }
+                    }
+
+                    Event::PointerButton {
+                        pos,
+                        button,
+                        pressed,
+                        modifiers: _,
+                    } => match (button, pressed) {
+                        (PointerButton::Primary, true) => {
+                            if last_canvas_pos.is_none() {
+                                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(hw_response);
+                                response.mark_changed();
+                            }
+
+                            // Stop reading events.
+                            // TODO: In theory, we can get multiple press->draw->release series
+                            // in the same frame. Should handle this.
+                            break;
+                        }
+                        (_, _) => continue,
+                    },
+
+                    // Stop drawing after pointer disappears or the window is unfocused
+                    // 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.e.current_stroke.is_empty() {
+                            self.commit_current_line(hw_response);
+                            break;
+                        }
+                    }
+
+                    Event::WindowFocused(true)
+                    | Event::Copy
+                    | Event::Cut
+                    | Event::Paste(..)
+                    | Event::Text(..)
+                    | Event::Key { .. }
+                    | Event::Zoom(..)
+                    | Event::Ime(..)
+                    | Event::Touch { .. }
+                    | Event::MouseWheel { .. }
+                    | Event::Screenshot { .. } => continue,
+                }
             }
         }
 
@@ -344,7 +417,7 @@ impl Handwriting {
                 painter.add(shape);
             });
 
-        // Get the position and dimensions of the image
+        // Get the dimensions of the image
         let mesh_rect = response
             .rect
             .with_max_y(response.rect.min.y + self.desired_height);
@@ -353,6 +426,7 @@ impl Handwriting {
         let new_context = MeshContext {
             ui_theme: ui.ctx().theme(),
             pixels_per_point: ui.pixels_per_point(),
+            size: mesh_rect.size(),
             stroke: style.stroke,
         };
 
@@ -361,32 +435,38 @@ impl Handwriting {
             self.e.refresh_texture = true;
         }
 
-        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.refresh_texture(style, new_context, ui);
             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.draw_line_to_texture(from, to, &new_context, ui);
             }
             self.e.unblitted_lines.clear();
         }
 
         // Draw the texture
-        self.e.canvas_rasterizer.show(ui.ctx(), &painter, mesh_rect);
-
-        if let Some(tool_position) = self.e.tool_position && let Tool::Eraser = self.e.tool {
-            let pos = to_screen * tool_position;
-            let shape = Shape::circle_stroke(pos, tool::eraser::RADIUS, style.stroke);
+        if let Some(texture) = &self.e.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);
         }
 
@@ -400,7 +480,12 @@ impl Handwriting {
     }
 
     /// Tessellate and rasterize the strokes into a new texture.
-    fn refresh_texture(&mut self, style: &HandwritingStyle, mesh_context: MeshContext) {
+    fn refresh_texture(
+        &mut self,
+        style: &HandwritingStyle,
+        mesh_context: MeshContext,
+        ui: &mut Ui,
+    ) {
         let Ephemeral {
             current_stroke,
             tessellator,
@@ -409,7 +494,7 @@ impl Handwriting {
             last_mesh_ctx,
             ..
         } = &mut self.e;
-        // TODO: avoid tessellating and rasterizing on the GUI thread
+        // TODO: don't tessellate and rasterize on the GUI thread
 
         *last_mesh_ctx = Some(mesh_context);
 
@@ -428,7 +513,10 @@ impl Handwriting {
             .iter()
             .chain([&*current_stroke])
             .filter(|stroke| stroke.len() >= 2)
-            .map(|stroke| egui::Shape::line(stroke.clone(), style.stroke))
+            .map(|stroke| {
+                //let points: Vec<Pos2> = stroke.iter().map(|&p| to_screen * p).collect();
+                egui::Shape::line(stroke.clone(), style.stroke)
+            })
             .for_each(|shape| {
                 tessellator.tessellate_shape(shape, mesh);
             });
@@ -440,13 +528,13 @@ impl Handwriting {
         //    debug_assert!(vertex.pos.y.is_finite(), "{} must be finite", vertex.pos.y);
         //}
 
-        let point_to_pixel = TSTransform::from_scaling(mesh_context.pixels_per_point);
+        let texture = texture!(self.e, ui, &mesh_context);
         let triangles = mesh_triangles(&self.e.mesh);
 
-        self.e.canvas_rasterizer.clear();
-        self.e
-            .canvas_rasterizer
-            .rasterize(point_to_pixel, triangles);
+        let [px_x, px_y] = mesh_context.pixel_size();
+        let point_to_pixel = TSTransform::from_scaling(mesh_context.pixels_per_point);
+        self.e.image = rasterize::<StrokeBlendMode>(px_x, px_y, point_to_pixel, triangles);
+        texture.set(self.e.image.clone(), Default::default());
 
         #[cfg(not(target_arch = "wasm32"))]
         {
@@ -461,6 +549,7 @@ impl Handwriting {
         ui.vertical_centered_justified(|ui| {
             self.ui_control(None, ui, &mut response);
 
+            //ui.label("Paint with your mouse/touch!");
             Frame::canvas(ui.style())
                 .corner_radius(20.0)
                 .stroke(Stroke::new(5.0, Color32::from_black_alpha(40)))
@@ -491,7 +580,13 @@ impl Handwriting {
     }
 
     /// Draw a single line onto the existing texture.
-    fn draw_line_to_texture(&mut self, from: Pos2, to: Pos2, mesh_context: &MeshContext) {
+    fn draw_line_to_texture(
+        &mut self,
+        from: Pos2,
+        to: Pos2,
+        mesh_context: &MeshContext,
+        ui: &mut Ui,
+    ) {
         // 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
@@ -503,16 +598,15 @@ impl Handwriting {
         let line = egui::Shape::line_segment([from, to], mesh_context.stroke);
         tessellator.tessellate_shape(line, &mut mesh);
 
-        self.draw_mesh_to_texture(&mesh, mesh_context);
+        self.draw_mesh_to_texture(&mesh, mesh_context, ui);
     }
 
     /// Draw a single mesh onto the existing texture.
-    fn draw_mesh_to_texture(&mut self, mesh: &Mesh, mesh_context: &MeshContext) {
+    fn draw_mesh_to_texture(&mut self, mesh: &Mesh, mesh_context: &MeshContext, ui: &mut Ui) {
         let triangles = mesh_triangles(mesh);
         let point_to_pixel = TSTransform::from_scaling(mesh_context.pixels_per_point);
-        self.e
-            .canvas_rasterizer
-            .rasterize(point_to_pixel, triangles);
+        rasterize_onto::<StrokeBlendMode>(&mut self.e.image, point_to_pixel, triangles);
+        texture!(self.e, ui, mesh_context).set(self.e.image.clone(), Default::default());
     }
 
     pub fn strokes(&self) -> &[Vec<Pos2>] {
@@ -571,87 +665,6 @@ impl Handwriting {
     }
 }
 
-/// Convert [egui::Event]s to [ToolEvent]s.
-fn process_event(
-    last_canvas_pos: &mut Option<Pos2>,
-    from_screen: RectTransform,
-    event: &Event,
-    mut on_tool_event: impl FnMut(ToolEvent),
-) {
-    match event {
-        &Event::PointerMoved(new_position) => {
-            let new_canvas_pos = from_screen * new_position;
-            if last_canvas_pos.is_some() && *last_canvas_pos != Some(new_canvas_pos) {
-                *last_canvas_pos = Some(new_canvas_pos);
-                on_tool_event(ToolEvent::Move { to: new_canvas_pos });
-            }
-        }
-
-        &Event::MouseMoved(mut delta) => {
-            if delta.length() == 0.0 {
-                return;
-            }
-
-            // FIXME: pinenote: MouseMovement delta does *not* take into account screen
-            // scaling and rotation, so unless you've scaling=1 and no rotation, the
-            // MouseMoved values will be all wrong.
-            if cfg!(feature = "pinenote") {
-                delta /= 1.8;
-                delta = -delta.rot90();
-            }
-
-            if let Some(pos) = last_canvas_pos {
-                *pos += delta;
-                on_tool_event(ToolEvent::Move { to: *pos });
-            } else {
-                println!("Got `MouseMoved`, but have no previous pos");
-            }
-        }
-
-        &Event::PointerButton {
-            pos,
-            button,
-            pressed,
-            modifiers: _,
-        } => match (button, pressed) {
-            (PointerButton::Primary, true) => {
-                if last_canvas_pos.is_none() {
-                    let pos = from_screen * pos;
-                    *last_canvas_pos = Some(pos);
-                    on_tool_event(ToolEvent::Press { at: pos });
-                }
-            }
-            (PointerButton::Primary, false) => {
-                if last_canvas_pos.take().is_some() {
-                    let pos = from_screen * pos;
-                    on_tool_event(ToolEvent::Move { to: pos });
-                    on_tool_event(ToolEvent::Release {});
-                }
-            }
-            (_, _) => {}
-        },
-
-        // Stop drawing after pointer disappears or the window is unfocused
-        Event::PointerGone | Event::WindowFocused(false) => {
-            if last_canvas_pos.take().is_some() {
-                on_tool_event(ToolEvent::Release {});
-            }
-        }
-
-        Event::WindowFocused(true)
-        | Event::Copy
-        | Event::Cut
-        | Event::Paste(..)
-        | Event::Text(..)
-        | Event::Key { .. }
-        | Event::Zoom(..)
-        | Event::Ime(..)
-        | Event::Touch { .. }
-        | Event::MouseWheel { .. }
-        | Event::Screenshot { .. } => {}
-    }
-}
-
 fn new_tessellator(pixels_per_point: f32) -> Tessellator {
     Tessellator::new(
         pixels_per_point,
@@ -775,19 +788,16 @@ impl HandwritingStyle {
         }
 
         HandwritingStyle {
-            stroke: Stroke::new(1.0, stroke_color),
+            stroke: Stroke::new(1.6, 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]> + Clone {
-    mesh.indices
-        .chunks_exact(3)
-        .map(|chunk| [chunk[0], chunk[1], chunk[2]])
+fn mesh_triangles(mesh: &Mesh) -> impl Iterator<Item = [&Vertex; 3]> {
+    mesh.triangles()
         .map(|indices| indices.map(|i| &mesh.vertices[i as usize]))
 }
 
@@ -795,9 +805,7 @@ fn mesh_triangles(mesh: &Mesh) -> impl Iterator<Item = [&Vertex; 3]> + Clone {
 mod test {
     use std::str::FromStr;
 
-    use egui::{Event, Modifiers, PointerButton, Pos2, Rect, emath::RectTransform};
-
-    use super::{Handwriting, process_event};
+    use super::Handwriting;
 
     #[test]
     fn serialize_handwriting() {
@@ -811,194 +819,4 @@ mod test {
             Handwriting::from_str(&serialized).expect("Handwriting must de/serialize correctly");
         insta::assert_debug_snapshot!("deserialized handwriting", deserialized.strokes);
     }
-
-    const TEST_EVENTS: &[Event] = &[
-        Event::PointerMoved(Pos2::new(749.9, 225.6)),
-        Event::PointerButton {
-            pos: Pos2::new(749.9, 225.6),
-            button: PointerButton::Primary,
-            pressed: true,
-            modifiers: Modifiers::NONE,
-        },
-        Event::PointerMoved(Pos2::new(749.9, 225.7)),
-        Event::PointerMoved(Pos2::new(749.9, 226.4)),
-        Event::PointerMoved(Pos2::new(750.2, 228.4)),
-        Event::PointerMoved(Pos2::new(751.0, 231.3)),
-        Event::PointerMoved(Pos2::new(752.6, 234.4)),
-        Event::PointerMoved(Pos2::new(754.1, 237.7)),
-        Event::PointerMoved(Pos2::new(755.8, 241.1)),
-        Event::PointerMoved(Pos2::new(757.7, 244.4)),
-        Event::PointerMoved(Pos2::new(759.3, 247.4)),
-        Event::PointerMoved(Pos2::new(760.8, 250.2)),
-        Event::PointerMoved(Pos2::new(762.8, 253.4)),
-        Event::PointerMoved(Pos2::new(765.1, 256.8)),
-        Event::PointerMoved(Pos2::new(767.7, 260.2)),
-        Event::PointerMoved(Pos2::new(771.2, 264.3)),
-        Event::PointerMoved(Pos2::new(774.6, 267.9)),
-        Event::PointerMoved(Pos2::new(778.2, 271.2)),
-        Event::PointerMoved(Pos2::new(782.7, 275.2)),
-        Event::PointerMoved(Pos2::new(786.7, 278.5)),
-        Event::PointerMoved(Pos2::new(790.4, 280.8)),
-        Event::PointerMoved(Pos2::new(794.1, 282.6)),
-        Event::PointerMoved(Pos2::new(797.9, 283.9)),
-        Event::PointerMoved(Pos2::new(801.9, 284.8)),
-        Event::PointerMoved(Pos2::new(805.9, 285.5)),
-        Event::PointerMoved(Pos2::new(810.2, 285.8)),
-        Event::PointerMoved(Pos2::new(814.5, 285.8)),
-        Event::PointerMoved(Pos2::new(818.2, 285.6)),
-        Event::PointerMoved(Pos2::new(821.6, 284.5)),
-        Event::PointerMoved(Pos2::new(824.7, 283.0)),
-        Event::PointerMoved(Pos2::new(827.5, 281.4)),
-        Event::PointerMoved(Pos2::new(830.4, 279.6)),
-        Event::PointerMoved(Pos2::new(833.4, 277.7)),
-        Event::PointerMoved(Pos2::new(836.1, 275.7)),
-        Event::PointerMoved(Pos2::new(838.6, 273.6)),
-        Event::PointerMoved(Pos2::new(840.9, 271.7)),
-        Event::PointerMoved(Pos2::new(843.0, 269.6)),
-        Event::PointerMoved(Pos2::new(845.4, 267.2)),
-        Event::PointerMoved(Pos2::new(847.7, 265.1)),
-        Event::PointerMoved(Pos2::new(849.8, 262.7)),
-        Event::PointerMoved(Pos2::new(852.0, 260.0)),
-        Event::PointerMoved(Pos2::new(854.3, 256.8)),
-        Event::PointerMoved(Pos2::new(856.3, 253.4)),
-        Event::PointerMoved(Pos2::new(858.2, 250.1)),
-        Event::PointerMoved(Pos2::new(860.0, 247.1)),
-        Event::PointerMoved(Pos2::new(861.5, 244.3)),
-        Event::PointerMoved(Pos2::new(862.8, 242.0)),
-        Event::PointerMoved(Pos2::new(864.1, 240.1)),
-        Event::PointerMoved(Pos2::new(865.0, 238.2)),
-        Event::PointerMoved(Pos2::new(865.8, 236.6)),
-        Event::PointerMoved(Pos2::new(866.5, 234.9)),
-        Event::PointerMoved(Pos2::new(867.1, 233.1)),
-        Event::PointerMoved(Pos2::new(867.8, 231.4)),
-        Event::PointerMoved(Pos2::new(868.4, 229.8)),
-        Event::PointerMoved(Pos2::new(868.7, 228.4)),
-        Event::PointerMoved(Pos2::new(868.9, 227.2)),
-        Event::PointerMoved(Pos2::new(869.1, 226.2)),
-        Event::PointerMoved(Pos2::new(869.1, 225.1)),
-        Event::PointerMoved(Pos2::new(869.1, 224.1)),
-        Event::PointerMoved(Pos2::new(869.1, 223.4)),
-        Event::PointerMoved(Pos2::new(869.1, 222.8)),
-        Event::PointerMoved(Pos2::new(869.1, 222.4)),
-        Event::PointerMoved(Pos2::new(869.1, 222.4)),
-        // Event::PointerButton {
-        //     pos: Pos2::new(869.1, 222.4),
-        //     button: PointerButton::Primary,
-        //     pressed: false,
-        //     modifiers: Modifiers::NONE,
-        // },
-        Event::PointerGone,
-        Event::PointerMoved(Pos2::new(779.3, 158.6)),
-        // --
-        // FIXME: This line looks weird. Probably because of a bug in the rasterizer when the X-coord is all the same.
-        Event::PointerButton {
-            pos: Pos2::new(779.3, 158.6),
-            button: PointerButton::Primary,
-            pressed: true,
-            modifiers: Modifiers::NONE,
-        },
-        Event::PointerMoved(Pos2::new(779.3, 159.0)),
-        Event::PointerMoved(Pos2::new(779.3, 160.9)),
-        Event::PointerMoved(Pos2::new(779.3, 164.6)),
-        Event::PointerMoved(Pos2::new(779.3, 169.6)),
-        Event::PointerMoved(Pos2::new(779.3, 175.2)),
-        Event::PointerMoved(Pos2::new(779.3, 180.3)),
-        Event::PointerMoved(Pos2::new(779.3, 185.0)),
-        Event::PointerMoved(Pos2::new(779.3, 189.4)),
-        Event::PointerMoved(Pos2::new(779.3, 192.8)),
-        Event::PointerMoved(Pos2::new(779.3, 194.9)),
-        Event::PointerMoved(Pos2::new(779.3, 196.1)),
-        Event::PointerMoved(Pos2::new(779.3, 197.0)),
-        Event::PointerMoved(Pos2::new(779.3, 197.6)),
-        Event::PointerMoved(Pos2::new(779.3, 198.1)),
-        Event::PointerMoved(Pos2::new(779.3, 198.5)),
-        Event::PointerMoved(Pos2::new(779.3, 198.8)),
-        Event::PointerMoved(Pos2::new(779.3, 199.0)),
-        Event::PointerMoved(Pos2::new(779.3, 199.2)),
-        Event::PointerMoved(Pos2::new(779.3, 199.2)),
-        Event::PointerButton {
-            pos: Pos2::new(779.3, 199.2),
-            button: PointerButton::Primary,
-            pressed: false,
-            modifiers: Modifiers::NONE,
-        },
-        // --
-        Event::PointerMoved(Pos2::new(841.5, 159.2)),
-        Event::PointerButton {
-            pos: Pos2::new(841.5, 159.2),
-            button: PointerButton::Primary,
-            pressed: true,
-            modifiers: Modifiers::NONE,
-        },
-        Event::PointerMoved(Pos2::new(841.5, 159.3)),
-        Event::PointerMoved(Pos2::new(841.5, 159.7)),
-        Event::PointerMoved(Pos2::new(841.5, 160.5)),
-        Event::PointerMoved(Pos2::new(841.5, 162.4)),
-        Event::PointerMoved(Pos2::new(841.5, 165.1)),
-        Event::PointerMoved(Pos2::new(841.5, 168.4)),
-        Event::PointerMoved(Pos2::new(841.5, 171.6)),
-        Event::PointerMoved(Pos2::new(841.5, 174.4)),
-        Event::PointerMoved(Pos2::new(841.5, 177.1)),
-        Event::PointerMoved(Pos2::new(841.5, 179.3)),
-        Event::PointerMoved(Pos2::new(841.5, 180.9)),
-        Event::PointerMoved(Pos2::new(841.5, 182.4)),
-        Event::PointerMoved(Pos2::new(841.5, 183.5)),
-        Event::PointerMoved(Pos2::new(841.5, 184.5)),
-        Event::PointerMoved(Pos2::new(841.5, 185.6)),
-        Event::PointerMoved(Pos2::new(841.5, 187.0)),
-        Event::PointerMoved(Pos2::new(841.5, 188.6)),
-        Event::PointerMoved(Pos2::new(841.5, 190.3)),
-        Event::PointerMoved(Pos2::new(841.5, 191.8)),
-        Event::PointerMoved(Pos2::new(841.3, 192.7)),
-        Event::PointerMoved(Pos2::new(841.0, 193.3)),
-        Event::PointerMoved(Pos2::new(841.0, 193.7)),
-        Event::PointerMoved(Pos2::new(841.1, 193.9)),
-        Event::PointerMoved(Pos2::new(841.3, 193.9)),
-        Event::PointerMoved(Pos2::new(841.4, 194.0)),
-        Event::PointerMoved(Pos2::new(841.4, 194.2)),
-        Event::PointerMoved(Pos2::new(841.4, 194.6)),
-        Event::PointerMoved(Pos2::new(841.4, 194.9)),
-        Event::PointerMoved(Pos2::new(841.4, 195.1)),
-        Event::PointerMoved(Pos2::new(841.4, 195.1)),
-        Event::PointerButton {
-            pos: Pos2::new(841.4, 195.1),
-            button: PointerButton::Primary,
-            pressed: false,
-            modifiers: Modifiers::NONE,
-        },
-    ];
-
-    fn from_screen() -> RectTransform {
-        RectTransform::from_to(
-            Rect::from_two_pos(Pos2::new(570.0, 145.1), Pos2::new(1116.4, 245.1)),
-            Rect::from_two_pos(Pos2::new(0.0, 0.0), Pos2::new(546.4, 100.0)),
-        )
-    }
-
-    #[test]
-    fn handle_input() {
-        let mut tool_events = vec![];
-        let mut last_pos = None;
-        let from_screen = from_screen();
-        for event in TEST_EVENTS {
-            process_event(&mut last_pos, from_screen, event, |tool_event| {
-                tool_events.push(tool_event)
-            });
-        }
-        insta::assert_yaml_snapshot!(tool_events);
-    }
-
-    #[test]
-    fn input_to_handwriting() {
-        let mut handwriting = Handwriting::default();
-        let mut last_pos = None;
-        let from_screen = from_screen();
-        for event in TEST_EVENTS {
-            process_event(&mut last_pos, from_screen, event, |tool_event| {
-                handwriting.on_tool_event(tool_event);
-            });
-        }
-        let serialized = handwriting.to_string();
-        insta::assert_snapshot!("input events to handwriting", serialized);
-    }
 }

src/handwriting/snapshots/inkr__handwriting__test__handle_input.snap

@@ -1,455 +0,0 @@
----
-source: src/handwriting/mod.rs
-expression: tool_events
----
-- Press:
-    at:
-      x: 179.90002
-      y: 80.5
-- Move:
-    to:
-      x: 179.90002
-      y: 80.59999
-- Move:
-    to:
-      x: 179.90002
-      y: 81.29999
-- Move:
-    to:
-      x: 180.20001
-      y: 83.29999
-- Move:
-    to:
-      x: 181
-      y: 86.2
-- Move:
-    to:
-      x: 182.59998
-      y: 89.29999
-- Move:
-    to:
-      x: 184.09998
-      y: 92.59999
-- Move:
-    to:
-      x: 185.79999
-      y: 96
-- Move:
-    to:
-      x: 187.70001
-      y: 99.29999
-- Move:
-    to:
-      x: 189.3
-      y: 102.29999
-- Move:
-    to:
-      x: 190.8
-      y: 105.09999
-- Move:
-    to:
-      x: 192.79999
-      y: 108.29998
-- Move:
-    to:
-      x: 195.09998
-      y: 111.69999
-- Move:
-    to:
-      x: 197.70001
-      y: 115.100006
-- Move:
-    to:
-      x: 201.20001
-      y: 119.19998
-- Move:
-    to:
-      x: 204.59998
-      y: 122.799995
-- Move:
-    to:
-      x: 208.20001
-      y: 126.100006
-- Move:
-    to:
-      x: 212.70001
-      y: 130.1
-- Move:
-    to:
-      x: 216.70001
-      y: 133.4
-- Move:
-    to:
-      x: 220.40002
-      y: 135.69998
-- Move:
-    to:
-      x: 224.09998
-      y: 137.5
-- Move:
-    to:
-      x: 227.90002
-      y: 138.79999
-- Move:
-    to:
-      x: 231.90002
-      y: 139.69998
-- Move:
-    to:
-      x: 235.90002
-      y: 140.4
-- Move:
-    to:
-      x: 240.20001
-      y: 140.69998
-- Move:
-    to:
-      x: 244.5
-      y: 140.69998
-- Move:
-    to:
-      x: 248.20001
-      y: 140.5
-- Move:
-    to:
-      x: 251.59996
-      y: 139.4
-- Move:
-    to:
-      x: 254.70001
-      y: 137.9
-- Move:
-    to:
-      x: 257.5
-      y: 136.29999
-- Move:
-    to:
-      x: 260.40002
-      y: 134.5
-- Move:
-    to:
-      x: 263.40002
-      y: 132.6
-- Move:
-    to:
-      x: 266.09998
-      y: 130.6
-- Move:
-    to:
-      x: 268.59998
-      y: 128.5
-- Move:
-    to:
-      x: 270.90002
-      y: 126.600006
-- Move:
-    to:
-      x: 273
-      y: 124.5
-- Move:
-    to:
-      x: 275.40002
-      y: 122.100006
-- Move:
-    to:
-      x: 277.70004
-      y: 120.00001
-- Move:
-    to:
-      x: 279.8
-      y: 117.60001
-- Move:
-    to:
-      x: 282
-      y: 114.899994
-- Move:
-    to:
-      x: 284.3
-      y: 111.69999
-- Move:
-    to:
-      x: 286.3
-      y: 108.29998
-- Move:
-    to:
-      x: 288.2
-      y: 104.99999
-- Move:
-    to:
-      x: 290
-      y: 102
-- Move:
-    to:
-      x: 291.5
-      y: 99.2
-- Move:
-    to:
-      x: 292.8
-      y: 96.899994
-- Move:
-    to:
-      x: 294.09995
-      y: 95
-- Move:
-    to:
-      x: 295
-      y: 93.09999
-- Move:
-    to:
-      x: 295.8
-      y: 91.5
-- Move:
-    to:
-      x: 296.5
-      y: 89.79999
-- Move:
-    to:
-      x: 297.1
-      y: 88
-- Move:
-    to:
-      x: 297.8
-      y: 86.29999
-- Move:
-    to:
-      x: 298.40005
-      y: 84.7
-- Move:
-    to:
-      x: 298.7
-      y: 83.29999
-- Move:
-    to:
-      x: 298.90002
-      y: 82.09999
-- Move:
-    to:
-      x: 299.1
-      y: 81.09999
-- Move:
-    to:
-      x: 299.1
-      y: 80
-- Move:
-    to:
-      x: 299.1
-      y: 79
-- Move:
-    to:
-      x: 299.1
-      y: 78.29999
-- Move:
-    to:
-      x: 299.1
-      y: 77.7
-- Move:
-    to:
-      x: 299.1
-      y: 77.29999
-- Release
-- Press:
-    at:
-      x: 209.29999
-      y: 13.500001
-- Move:
-    to:
-      x: 209.29999
-      y: 13.899994
-- Move:
-    to:
-      x: 209.29999
-      y: 15.799988
-- Move:
-    to:
-      x: 209.29999
-      y: 19.5
-- Move:
-    to:
-      x: 209.29999
-      y: 24.5
-- Move:
-    to:
-      x: 209.29999
-      y: 30.09999
-- Move:
-    to:
-      x: 209.29999
-      y: 35.199997
-- Move:
-    to:
-      x: 209.29999
-      y: 39.899994
-- Move:
-    to:
-      x: 209.29999
-      y: 44.299988
-- Move:
-    to:
-      x: 209.29999
-      y: 47.699997
-- Move:
-    to:
-      x: 209.29999
-      y: 49.799988
-- Move:
-    to:
-      x: 209.29999
-      y: 51
-- Move:
-    to:
-      x: 209.29999
-      y: 51.899994
-- Move:
-    to:
-      x: 209.29999
-      y: 52.499996
-- Move:
-    to:
-      x: 209.29999
-      y: 52.999996
-- Move:
-    to:
-      x: 209.29999
-      y: 53.399994
-- Move:
-    to:
-      x: 209.29999
-      y: 53.699993
-- Move:
-    to:
-      x: 209.29999
-      y: 53.89999
-- Move:
-    to:
-      x: 209.29999
-      y: 54.09999
-- Move:
-    to:
-      x: 209.29999
-      y: 54.09999
-- Release
-- Press:
-    at:
-      x: 271.5
-      y: 14.099991
-- Move:
-    to:
-      x: 271.5
-      y: 14.199998
-- Move:
-    to:
-      x: 271.5
-      y: 14.599991
-- Move:
-    to:
-      x: 271.5
-      y: 15.399994
-- Move:
-    to:
-      x: 271.5
-      y: 17.299988
-- Move:
-    to:
-      x: 271.5
-      y: 20
-- Move:
-    to:
-      x: 271.5
-      y: 23.299988
-- Move:
-    to:
-      x: 271.5
-      y: 26.499998
-- Move:
-    to:
-      x: 271.5
-      y: 29.299986
-- Move:
-    to:
-      x: 271.5
-      y: 32
-- Move:
-    to:
-      x: 271.5
-      y: 34.199997
-- Move:
-    to:
-      x: 271.5
-      y: 35.799988
-- Move:
-    to:
-      x: 271.5
-      y: 37.299988
-- Move:
-    to:
-      x: 271.5
-      y: 38.399994
-- Move:
-    to:
-      x: 271.5
-      y: 39.399994
-- Move:
-    to:
-      x: 271.5
-      y: 40.5
-- Move:
-    to:
-      x: 271.5
-      y: 41.899994
-- Move:
-    to:
-      x: 271.5
-      y: 43.5
-- Move:
-    to:
-      x: 271.5
-      y: 45.199997
-- Move:
-    to:
-      x: 271.5
-      y: 46.699997
-- Move:
-    to:
-      x: 271.3
-      y: 47.59999
-- Move:
-    to:
-      x: 271
-      y: 48.199997
-- Move:
-    to:
-      x: 271
-      y: 48.59999
-- Move:
-    to:
-      x: 271.09998
-      y: 48.799988
-- Move:
-    to:
-      x: 271.3
-      y: 48.799988
-- Move:
-    to:
-      x: 271.40002
-      y: 48.899994
-- Move:
-    to:
-      x: 271.40002
-      y: 49.09999
-- Move:
-    to:
-      x: 271.40002
-      y: 49.5
-- Move:
-    to:
-      x: 271.40002
-      y: 49.799988
-- Move:
-    to:
-      x: 271.40002
-      y: 50
-- Move:
-    to:
-      x: 271.40002
-      y: 50
-- Release

src/handwriting/snapshots/inkr__handwriting__test__input events to handwriting.snap

@@ -1,7 +0,0 @@
----
-source: src/handwriting/mod.rs
-expression: serialized
----
-```handwriting
-AQA9AJ9ZCFWfWQpVn1kVVaJZNVWoWWNVtVmVVcFZylXOWQBW3lk1VupZZVb2WZJWBlrFVhla+1YuWjJXSlpzV2VarVeCWuJXploRWMZaK1jjWj5YAVtMWB9bVlg/W15YX1tjWIJbZlikW2ZYwltkWN1bW1j2W09YBlxCWBJcNFgeXCVYKFwVWDJcBFg8XOpXRFzIV05coldXXIBXX1xaV2hcLldxXPtWeVzFVoFckFaIXGBWjlwzVpNcDlaYXPBVnFzSVZ9cuFWiXJ1VpFyAVadcZVWqXEtVq1w1VaxcIlWsXBJVrFwAVaxc8FSsXOVUrFzbVKxc1VQTAIpawEqKWvNKilrmS4pa4EyKWiBOilqGT4paZlCKWv1QilqKUYpa9lGKWjpSilpgUopafVKKWpBSilqgUoparVKKWrZSilq9Uopaw1IeAD5cDUs+XBpLPlxNSz5cs0s+XFNMPlwATT5c000+XKBOPlxTTz5cAFA+XEZQPlx6UD5cqlA+XM1QPlztUD5cEFE+XD1RPlxwUT5cplE+XNZRPVzzUTxcBlI8XBNSPFwaUj1cGlI+XB1SPlwjUj5cMFI+XDpSPlxAUg==
-```

src/handwriting/tool/eraser.rs

@@ -1,32 +0,0 @@
-use crate::handwriting::{Handwriting, ToolEvent};
-use egui::Pos2;
-
-pub const RADIUS: f32 = 12.0;
-
-/// Handle a [ToolEvent]. Returns true if a stroke was completed.
-pub fn on_tool_event(handwriting: &mut Handwriting, tool_event: ToolEvent) -> bool {
-    match tool_event {
-        ToolEvent::Press { at } => {
-            erase(handwriting, at, RADIUS)
-        }
-        ToolEvent::Move { to } => {
-            erase(handwriting, to, RADIUS)
-        }
-        ToolEvent::Release => {
-            false            
-        }
-    }
-
-}
-
-fn erase(handwriting: &mut Handwriting, at: Pos2, radius: f32) -> bool {
-    let strokes = handwriting.strokes.len();
-
-    handwriting.strokes.retain(|stroke| {
-        stroke.iter().all(|&point| {
-            (point - at).length() > radius
-        })
-    });
-
-    handwriting.strokes.len() < strokes
-}

src/handwriting/tool/mod.rs

@@ -1,28 +0,0 @@
-pub mod pencil;
-pub mod eraser;
-
-use egui::Pos2;
-use serde::Serialize;
-
-pub enum Tool {
-    Pencil,
-    Eraser,
-}
-
-/// A simple event that can defines how a tool (e.g. the pen) is used on a [Handwriting].
-#[derive(Debug, Serialize, Copy, Clone)]
-pub enum ToolEvent {
-    Press { at: Pos2 },
-    Move { to: Pos2 },
-    Release,
-}
-
-impl ToolEvent {
-    pub const fn position(&self) -> Option<Pos2> {
-        match self {
-            &ToolEvent::Press { at } => Some(at),
-            &ToolEvent::Move { to } => Some(to),
-            ToolEvent::Release => None,
-        }
-    }
-}

src/handwriting/tool/pencil.rs

@@ -1,22 +0,0 @@
-use crate::handwriting::{Handwriting, ToolEvent};
-use std::mem;
-
-/// Handle a [ToolEvent]. Returns true if a stroke was completed.
-pub fn on_tool_event(handwriting: &mut Handwriting, tool_event: ToolEvent) -> bool {
-    match tool_event {
-        ToolEvent::Press { at } => {
-            debug_assert!(handwriting.e.current_stroke.is_empty());
-            handwriting.push_to_stroke(at);
-            false
-        }
-        ToolEvent::Move { to } => {
-            handwriting.push_to_stroke(to);
-            false
-        }
-        ToolEvent::Release => {
-            debug_assert!(!handwriting.e.current_stroke.is_empty());
-            handwriting.strokes.push(mem::take(&mut handwriting.e.current_stroke));
-            true
-        }
-    }
-}

src/lib.rs

@@ -1,14 +1,15 @@
+#![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 folder;
 pub mod handwriting;
-pub mod markdown;
 pub mod preferences;
 pub mod rasterizer;
 pub mod text_editor;
-pub mod text_styles;
 pub mod util;
 
 pub use app::App;

src/markdown/ast.rs

@@ -1,54 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,138 +0,0 @@
-use egui::text::{CCursorRange, LayoutJob};
-
-use crate::{
-    markdown::Heading,
-    text_styles::{H1, H1_MONO, H2, H2_MONO, H3, H3_MONO, H4, H4_MONO, H5, H5_MONO, H6, H6_MONO},
-};
-
-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 {
-        let text_style = match (heading, style.code) {
-            (Heading::H1, false) => H1,
-            (Heading::H2, false) => H2,
-            (Heading::H3, false) => H3,
-            (Heading::H4, false) => H4,
-            (Heading::H5, false) => H5,
-            (Heading::H6, false) => H6,
-
-            (Heading::H1, true) => H1_MONO,
-            (Heading::H2, true) => H2_MONO,
-            (Heading::H3, true) => H3_MONO,
-            (Heading::H4, true) => H4_MONO,
-            (Heading::H5, true) => H5_MONO,
-            (Heading::H6, true) => H6_MONO,
-        };
-
-        TextStyle::Name(text_style.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

@@ -1,11 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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();
-
-    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]),
-                );
-
-                let mut style = style;
-                style.code = true;
-
-                return Some(Item::Text { span, 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

@@ -1,46 +0,0 @@
----
-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

@@ -1,115 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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, style::ScrollAnimation};
+use egui::{Color32, Context, RichText, Theme, Ui, Visuals};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
@@ -10,11 +10,8 @@ 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_prefs: bool,
+    has_applied_theme: bool,
 }
 
 impl Default for Preferences {
@@ -22,8 +19,7 @@ impl Default for Preferences {
         Self {
             animations: true,
             high_contrast: false,
-            has_applied_prefs: false,
-            hide_handwriting_cursor: false,
+            has_applied_theme: false,
         }
     }
 }
@@ -31,38 +27,16 @@ 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_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.window_fill = Color32::from_rgb(0x1e, 0x1e, 0x1e);
-            dark_visuals.panel_fill = Color32::from_rgb(0x26, 0x26, 0x26);
-
-            light_visuals.window_fill = Color32::WHITE;
-            light_visuals.panel_fill = Color32::from_rgb(0xf6, 0xf6, 0xf6);
-
-            dark_visuals.code_bg_color = Color32::BLACK;
-            light_visuals.code_bg_color = Color32::WHITE;
+        if !self.has_applied_theme {
+            self.has_applied_theme = true;
 
             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;
@@ -71,16 +45,13 @@ 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 {
-                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, Visuals::dark());
+                ctx.set_visuals_of(Theme::Light, Visuals::light());
             }
-
-            ctx.set_visuals_of(Theme::Dark, dark_visuals);
-            ctx.set_visuals_of(Theme::Light, light_visuals);
         }
     }
 
@@ -88,20 +59,14 @@ impl Preferences {
     pub fn show(&mut self, ui: &mut Ui) {
         ui.label(RichText::new("Prefs").weak());
 
-        let animations_toggle = ui.toggle_value(&mut self.animations, "Animations");
-        if animations_toggle.clicked() {
-            self.has_applied_prefs = false;
-            self.apply(ui.ctx());
-        }
+        ui.toggle_value(&mut self.animations, "Animations");
 
         let high_contrast_toggle = ui.toggle_value(&mut self.high_contrast, "High Contrast");
         if high_contrast_toggle.clicked() {
-            self.has_applied_prefs = false;
+            self.has_applied_theme = 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,6 +1,5 @@
 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;
@@ -22,7 +21,7 @@ pub fn rasterize<'a, Blend: BlendFn>(
     point_to_pixel: TSTransform,
     triangles: impl Iterator<Item = [&'a Vertex; 3]>,
 ) -> ColorImage {
-    let mut image = ColorImage::filled([width, height], Color32::TRANSPARENT);
+    let mut image = ColorImage::new([width, height], Color32::TRANSPARENT);
     rasterize_onto::<Blend>(&mut image, point_to_pixel, triangles);
     image
 }
@@ -87,20 +86,9 @@ 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)]
-pub struct PxBoundingBox {
+struct PxBoundingBox {
     pub x_from: usize,
     pub y_from: usize,
     pub x_to: usize,
@@ -116,41 +104,9 @@ 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
-    }
 }
 
-pub fn triangle_bounding_box(
-    triangle: &[&Vertex; 3],
-    point_to_pixel: TSTransform,
-) -> PxBoundingBox {
+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 {

src/snapshots/inkr__painting__test__serialized handwriting.snap

@@ -1,7 +0,0 @@
----
-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::markdown::MemoizedHighlighter;
+use crate::easy_mark::MemoizedHighlighter;
 
 #[derive(Default, serde::Deserialize, serde::Serialize)]
 pub struct MdTextEdit {
@@ -50,8 +50,8 @@ impl MdTextEdit {
 
         let w = ui.available_width();
 
-        let mut layouter = |ui: &egui::Ui, markdown: &dyn TextBuffer, _wrap_width: f32| {
-            let mut layout_job = highlighter.highlight(ui.style(), markdown.as_str(), *cursor);
+        let mut layouter = |ui: &egui::Ui, easymark: &dyn TextBuffer, _wrap_width: f32| {
+            let mut layout_job = highlighter.highlight(ui.style(), easymark.as_str(), *cursor);
             layout_job.wrap.max_width = w - 10.0;
             ui.fonts(|f| f.layout_job(layout_job))
         };

src/text_styles.rs

@@ -1,14 +0,0 @@
-//! Name of custom [egui::TextStyle]s
-
-pub const H1: &str = "H1";
-pub const H2: &str = "H2";
-pub const H3: &str = "H3";
-pub const H4: &str = "H4";
-pub const H5: &str = "H5";
-pub const H6: &str = "H6";
-pub const H1_MONO: &str = "H1-mono";
-pub const H2_MONO: &str = "H2-mono";
-pub const H3_MONO: &str = "H3-mono";
-pub const H4_MONO: &str = "H4-mono";
-pub const H5_MONO: &str = "H5-mono";
-pub const H6_MONO: &str = "H6-mono";

src/util.rs

@@ -1,8 +1,6 @@
-use std::{fs::File, os::unix::fs::MetadataExt as _, sync::mpsc};
+use std::sync::mpsc;
 
-use chrono::{DateTime, Local};
 use egui::Id;
-use eyre::{Context, ContextCompat};
 use rand::{Rng, rng};
 
 pub fn random_id() -> Id {
@@ -30,27 +28,3 @@ 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")
-}