Add egui-kittest

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,15 @@ 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" }
+egui_kittest = { git = "https://github.com/emilk/egui", rev = "f2ce6424f3a32f47308fb9871d540c01377b2cd9" }
 
 [dev-dependencies]
 insta = { version = "1.43.1", features = ["yaml"] }
-
-[lints.clippy]
-unnecessary_lazy_evaluations = "allow"
+egui_kittest = { version = "0.31", features = ["wgpu", "snapshot"] }
+# 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, Image, Key, Modifiers,
-    PointerButton, RichText, ScrollArea, Theme, Widget, include_image,
+    Align, Button, Context, FontData, FontDefinitions, Image, Key, Modifiers, PointerButton,
+    RichText, ScrollArea, 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,39 +171,17 @@ 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 });
-                }
-            });
-        }
-
         // enable features on egui_extras to add more image types
         egui_extras::install_image_loaders(&cc.egui_ctx);
 
@@ -295,7 +253,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 +268,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 +364,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 +396,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))
                             });
                         }
@@ -506,13 +448,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/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,63 +64,12 @@ 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() {
@@ -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);
 
@@ -278,17 +161,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(
                     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 +180,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 +243,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 +280,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 +314,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/handwriting/canvas_rasterizer.rs

@@ -42,7 +42,7 @@ impl Tile {
 
         Self {
             bounding_box,
-            image: ColorImage::filled([CHUNK_SIZE, CHUNK_SIZE], Color32::TRANSPARENT),
+            image: ColorImage::new([CHUNK_SIZE, CHUNK_SIZE], Color32::TRANSPARENT),
             texture: None,
             texture_is_dirty: false,
         }

src/handwriting/mod.rs

@@ -8,7 +8,6 @@ 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};
@@ -78,15 +77,10 @@ struct Ephemeral {
 
     canvas_rasterizer: CanvasRasterizer,
 
-    /// Whether the handwriting element is being interacted with.
-    is_focused: bool,
-
     /// The stroke that is currently being drawed.
     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>,
@@ -131,7 +125,6 @@ impl Default for Ephemeral {
         Self {
             id: random_id(),
             canvas_rasterizer: Default::default(),
-            is_focused: false,
             current_stroke: Default::default(),
             tessellator: None,
             mesh: Default::default(),
@@ -170,12 +163,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 vertex_count: usize = self.e.mesh.indices.len() / 3;
             ui.label(format!("vertices: {vertex_count}"));
         })
@@ -218,16 +205,9 @@ impl Handwriting {
         // Was the user in the process of drawing a stroke last frame?
         let was_drawing = !self.e.current_stroke.is_empty();
 
-        // Is the user in the process of drawing a stroke now?;
+        // Is the user in the process of drawing a stroke now?
         let is_drawing = response.interact_pointer_pos().is_some();
 
-        if is_drawing {
-            self.e.is_focused = true;
-        } else if ui.ctx().input(|i| i.pointer.any_down()) {
-            // if the user starts interactive with something else, unfocus the handwriting area.
-            self.e.is_focused = false;
-        }
-
         if !is_drawing {
             if was_drawing {
                 // commit current line
@@ -235,18 +215,12 @@ impl Handwriting {
                 response.mark_changed();
             }
 
-            let padding = if self.e.is_focused {
-                HANDWRITING_BOTTOM_PADDING
-            } else {
-                0.0
-            };
-
             // recalculate how tall the widget should be
             let lines_max_y = self
                 .strokes
                 .iter()
                 .flatten()
-                .map(|p| p.y + padding)
+                .map(|p| p.y + HANDWRITING_BOTTOM_PADDING)
                 .fold(HANDWRITING_MIN_HEIGHT, |max, y| max.max(y));
 
             // Change the height of the handwriting item.
@@ -444,7 +418,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);
 
@@ -463,7 +437,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);
             });
@@ -496,6 +473,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)))

src/lib.rs

@@ -1,3 +1,5 @@
+#![warn(clippy::all, rust_2018_idioms)]
+
 pub mod app;
 pub mod constants;
 pub mod custom_code_block;
@@ -8,7 +10,6 @@ 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/highlighter.rs

@@ -1,10 +1,5 @@
 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.
@@ -39,6 +34,7 @@ pub fn highlight_markdown(
     _cursor: Option<CCursorRange>,
 ) -> LayoutJob {
     let mut job = LayoutJob::default();
+
     let code_style = Style {
         code: true,
         ..Default::default()
@@ -75,24 +71,8 @@ fn format_from_style(egui_style: &egui::Style, style: &Style) -> egui::text::Tex
         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())
+    let text_style = if style.heading.is_some() {
+        TextStyle::Heading
     } else if style.code {
         TextStyle::Monospace
     } else if style.small | style.raised {

src/markdown/parser.rs

@@ -16,6 +16,11 @@ pub fn parse_tokens<'a>(mut tokens: &[Token<'a>]) -> Vec<Item<'a>> {
 
     let mut style = Style::default();
 
+    let mono_style = Style {
+        code: true,
+        ..Default::default()
+    };
+
     iter::from_fn(move || {
         if tokens.is_empty() {
             return None;
@@ -68,10 +73,7 @@ pub fn parse_tokens<'a>(mut tokens: &[Token<'a>]) -> Vec<Item<'a>> {
                     any_of([TokenKind::Mono, TokenKind::CodeBlock, TokenKind::Newline]),
                 );
 
-                let mut style = style;
-                style.code = true;
-
-                return Some(Item::Text { span, style });
+                return Some(Item::Text { span, style: mono_style});
             }
 
             // TODO: different heading strengths

src/markdown/tokenizer.rs

@@ -31,7 +31,7 @@ pub enum TokenKind {
     Text,
 }
 
-const TOKENS: &[(&str, TokenKind)] = &[
+const TOKENS: &[(&'static str, TokenKind)] = &[
     ("\n", TokenKind::Newline),
     ("######", TokenKind::Heading(Heading::H6)),
     ("#####", TokenKind::Heading(Heading::H5)),

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)]
@@ -14,7 +14,7 @@ pub struct Preferences {
     pub hide_handwriting_cursor: bool,
 
     #[serde(skip)]
-    has_applied_prefs: bool,
+    has_applied_theme: bool,
 }
 
 impl Default for Preferences {
@@ -22,7 +22,7 @@ impl Default for Preferences {
         Self {
             animations: true,
             high_contrast: false,
-            has_applied_prefs: false,
+            has_applied_theme: false,
             hide_handwriting_cursor: false,
         }
     }
@@ -31,20 +31,8 @@ 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;
-                });
-            }
+        if !self.has_applied_theme {
+            self.has_applied_theme = true;
 
             let mut dark_visuals = Visuals::dark();
             let mut light_visuals = Visuals::light();
@@ -83,15 +71,11 @@ 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());
         }
 

src/rasterizer.rs

@@ -22,7 +22,7 @@ pub fn rasterize<'a, Blend: BlendFn>(
     point_to_pixel: TSTransform,
     triangles: impl Iterator<Item = [&'a Vertex; 3]>,
 ) -> ColorImage {
-    let mut image = ColorImage::filled([width, height], Color32::TRANSPARENT);
+    let mut image = ColorImage::new([width, height], Color32::TRANSPARENT);
     rasterize_onto::<Blend>(&mut image, point_to_pixel, triangles);
     image
 }
@@ -90,10 +90,10 @@ 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>(
+pub fn rasterize_triangle_onto<'a, Blend: BlendFn>(
     image: &mut ColorImage,
     point_to_pixel: TSTransform,
-    triangle: [&Vertex; 3],
+    triangle: [&'a Vertex; 3],
 ) {
     rasterize_onto::<Blend>(image, point_to_pixel, [triangle].into_iter());
 }
@@ -140,7 +140,8 @@ impl PxBoundingBox {
     }
 
     pub fn is_disjoint_from(&self, other: &PxBoundingBox) -> bool {
-        self.x_from > other.x_to
+        false
+            || self.x_from > other.x_to
             || self.y_from > other.y_to
             || other.x_from > self.x_to
             || other.y_from > self.y_to

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")
-}