Respect animations preference when paging up/down

Cargo.toml

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

src/app.rs

@@ -1,16 +1,23 @@
 use std::{
     fs,
+    io::Read,
     path::PathBuf,
     sync::{Arc, mpsc},
     thread::JoinHandle,
     time::{Duration, Instant},
 };
 
-use crate::{file_editor::FileEditor, folder::Folder, preferences::Preferences, util::GuiSender};
-use egui::{
-    Align, Button, Context, FontData, FontDefinitions, Image, Key, Modifiers, PointerButton,
-    RichText, ScrollArea, Widget, include_image,
+use crate::{
+    file_editor::{FileEditor, SaveStatus},
+    folder::Folder,
+    preferences::Preferences,
+    util::{GuiSender, file_mtime, log_error},
 };
+use egui::{
+    Align, Button, Context, FontData, FontDefinitions, FontId, Image, Key, Modifiers,
+    PointerButton, RichText, ScrollArea, Theme, Widget, include_image,
+};
+use eyre::eyre;
 
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)]
@@ -40,7 +47,7 @@ pub struct Jobs {
 }
 
 impl Jobs {
-    fn start(&mut self, ctx: &Context, job: impl FnOnce() -> Option<Action> + Send + 'static) {
+    pub fn start(&mut self, ctx: &Context, job: impl FnOnce() -> Option<Action> + Send + 'static) {
         let ctx = ctx.clone();
         let actions_tx = self.actions_tx.clone();
         self.handles.push(std::thread::spawn(move || {
@@ -73,9 +80,21 @@ impl Tab {
         }
     }
 
-    pub fn is_dirty(&self) -> bool {
+    pub fn notice_symbol(&self) -> Option<&'static str> {
         match self {
-            Tab::File(file_editor) => file_editor.is_dirty,
+            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),
         }
     }
 }
@@ -182,6 +201,28 @@ impl App {
 
         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) in [
+                    ("H1", 28.0),
+                    ("H2", 26.0),
+                    ("H3", 24.0),
+                    ("H4", 22.0),
+                    ("H5", 20.0),
+                    ("H6", 18.0),
+                ] {
+                    style.text_styles.insert(
+                        egui::TextStyle::Name(name.into()),
+                        FontId {
+                            size,
+                            family: egui::FontFamily::Proportional,
+                        },
+                    );
+                }
+            });
+        }
+
         // enable features on egui_extras to add more image types
         egui_extras::install_image_loaders(&cc.egui_ctx);
 
@@ -253,7 +294,7 @@ impl eframe::App for App {
         });
 
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
-            egui::containers::menu::Bar::new().ui(ui, |ui| {
+            egui::MenuBar::new().ui(ui, |ui| {
                 // NOTE: no File->Quit on web pages!
                 ui.menu_button("Menu ⚙", |ui| {
                     ui.label(RichText::new("Action").weak());
@@ -268,11 +309,18 @@ impl eframe::App for App {
                         self.jobs.start(ui.ctx(), move || {
                             let file_path = rfd::FileDialog::new().pick_file()?;
 
-                            let text = fs::read_to_string(&file_path)
+                            let mut file = fs::File::open(&file_path)
+                                .inspect_err(|e| log::error!("Failed to open {file_path:?}: {e}"))
+                                .ok()?;
+
+                            let mtime = log_error(eyre!("file_path:?"), || file_mtime(&file))?;
+
+                            let mut text = String::new();
+                            file.read_to_string(&mut text)
                                 .inspect_err(|e| log::error!("Failed to read {file_path:?}: {e}"))
                                 .ok()?;
 
-                            let editor = FileEditor::from_file(file_path, &text);
+                            let editor = FileEditor::from_file(file_path, &text, mtime);
                             Some(Action::OpenFile(editor))
                         });
                     }
@@ -364,8 +412,8 @@ impl eframe::App for App {
                         let selected = self.open_tab_index == Some(i);
                         let mut button = Button::new(tab.title()).selected(selected);
 
-                        if tab.is_dirty() {
-                            button = button.right_text(RichText::new("*").strong())
+                        if let Some(symbol) = tab.notice_symbol() {
+                            button = button.right_text(RichText::new(symbol).strong())
                         }
 
                         let response = ui.add(button);
@@ -396,13 +444,22 @@ 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 text = fs::read_to_string(&file_path)
+                                let mut file = fs::File::open(&file_path)
+                                    .inspect_err(|e| {
+                                        log::error!("Failed to open {file_path:?}: {e}")
+                                    })
+                                    .ok()?;
+
+                                let mtime = log_error(eyre!("file_path:?"), || file_mtime(&file))?;
+
+                                let mut text = String::new();
+                                file.read_to_string(&mut text)
                                     .inspect_err(|e| {
                                         log::error!("Failed to read {file_path:?}: {e}")
                                     })
                                     .ok()?;
 
-                                let editor = FileEditor::from_file(file_path, &text);
+                                let editor = FileEditor::from_file(file_path, &text, mtime);
                                 Some(Action::OpenFile(editor))
                             });
                         }
@@ -448,29 +505,13 @@ impl App {
     }
 
     fn save_active_tab(&mut self, ctx: &Context) {
-        let open_file = self
+        let open_tab = self
             .open_tab_index
             .and_then(|i| self.tabs.get_mut(i))
-            .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))
-            });
+            .map(|(_id, tab)| tab);
 
-        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
-            });
+        if let Some(open_tab) = open_tab {
+            open_tab.save(ctx, &mut self.jobs);
         }
     }
 }

src/file_editor.rs

@@ -1,57 +1,117 @@
 use std::{
     cmp::Ordering,
     fmt::{self, Display},
+    fs::{self, File},
+    io::Write,
     ops::{Div as _, Sub as _},
     path::{Path, PathBuf},
     str::FromStr,
+    sync::mpsc,
 };
 
+use chrono::{DateTime, Local};
 use egui::{
-    Align, Button, DragAndDrop, Frame, Layout, ScrollArea, Ui, UiBuilder, Vec2, Widget as _, vec2,
+    Align, Button, Context, DragAndDrop, Frame, Layout, ScrollArea, Ui, UiBuilder, Vec2,
+    Widget as _, vec2,
 };
+use eyre::eyre;
+use notify::{EventKind, Watcher};
 
 use crate::{
+    app::Jobs,
     custom_code_block::{MdItem, iter_lines_and_code_blocks},
     handwriting::{self, Handwriting, HandwritingStyle},
     preferences::Preferences,
     text_editor::MdTextEdit,
+    util::{file_mtime, log_error},
 };
 
 #[derive(serde::Deserialize, serde::Serialize)]
 pub struct FileEditor {
     title: String,
-    pub path: Option<PathBuf>,
+
+    path: Option<PathBuf>,
     pub buffer: Vec<BufferItem>,
 
-    /// Whether the file has been edited since it was laste saved to disk.
-    pub is_dirty: bool,
+    pub file_mtime: Option<DateTime<Local>>,
+    pub buffer_mtime: DateTime<Local>,
+
+    // TODO: instantiate these on load
+    #[serde(skip)]
+    inner: Option<Inner>,
+
+    /// The distance to scroll when paging up or down.
+    ///
+    /// This is calculated when the view is rendered.
+    #[serde(skip)]
+    scroll_delta: f32,
+
+    /// Whether the file has been edited since it was last saved to disk.
+    is_dirty: bool,
+}
+
+struct Inner {
+    file_events: mpsc::Receiver<FileEvent>,
+    file_events_tx: mpsc::Sender<FileEvent>,
+    _file_watcher: notify::RecommendedWatcher,
+}
+
+#[derive(Debug)]
+pub enum SaveStatus {
+    /// The contents of the buffer is the same as on disk.
+    Synced,
+
+    /// The contents exits only in memory and has never been saved to disk.
+    NoFile,
+
+    /// The buffer has been edited but not saved to disk.
+    FileOutdated,
+
+    /// The contents on disk has changes that are newer than the buffer.
+    BufferOutdated,
+
+    /// The contents on disk and in the buffer has diverged.
+    Desynced,
+}
+
+#[derive(Debug)]
+enum FileEvent {
+    NewFileMTime(DateTime<Local>),
+    NewBufferMTime(DateTime<Local>),
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
 pub enum BufferItem {
-    Text(MdTextEdit),
+    Text(Box<MdTextEdit>),
     Handwriting(Box<Handwriting>),
 }
 
 impl FileEditor {
     pub fn new(title: impl Into<String>) -> Self {
-        let buffer = vec![BufferItem::Text(MdTextEdit::new())];
+        let buffer = vec![BufferItem::Text(Box::new(MdTextEdit::new()))];
         Self {
             title: title.into(),
             path: None,
             buffer,
+            file_mtime: None,
+            buffer_mtime: Local::now(),
+            scroll_delta: 0.0,
             is_dirty: false,
+            inner: None,
         }
     }
 
-    pub fn from_file(file_path: PathBuf, contents: &str) -> Self {
+    pub fn from_file(file_path: PathBuf, contents: &str, mtime: DateTime<Local>) -> Self {
         let file_title = file_path
             .file_name()
             .map(|name| name.to_string_lossy().to_string())
             .unwrap_or_else(|| String::from("untitled.md"));
+
         Self {
             title: file_title,
             path: Some(file_path),
+            file_mtime: Some(mtime),
+            buffer_mtime: mtime,
             ..FileEditor::from(contents)
         }
     }
@@ -64,15 +124,66 @@ 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()));
                 }
@@ -81,9 +192,23 @@ 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;
+                }
             });
 
-            ScrollArea::vertical().show(ui, |ui| {
+            let scroll_area = ScrollArea::vertical().show(ui, |ui| {
+                if scroll_delta != 0.0 {
+                    ui.scroll_with_delta(Vec2::new(0.0, scroll_delta));
+                }
+
                 ui.horizontal(|ui| {
                     let side_padding = ui.available_width().sub(MAX_NOTE_WIDTH).max(0.0).div(2.0);
                     ui.add_space(side_padding);
@@ -94,6 +219,8 @@ impl FileEditor {
                     ui.add_space(side_padding);
                 });
             });
+
+            self.scroll_delta = scroll_area.inner_rect.height() * 0.9;
         });
     }
 
@@ -243,6 +370,38 @@ impl FileEditor {
         self.title = title.to_string_lossy().to_string();
         self.path = Some(new_path);
     }
+
+    pub fn set_dirty(&mut self, value: bool) {
+        self.is_dirty = value;
+    }
+
+    pub fn save(&mut self, ctx: &Context, jobs: &mut Jobs) {
+        let Some(file_path) = self.path.clone() else {
+            log::info!("Can't save {}, no path set.", self.title);
+            return;
+        };
+
+        self.is_dirty = false;
+        let text = self.to_string();
+        let inner = self
+            .inner
+            .get_or_insert_with(|| spawn_file_watcher(&file_path));
+        let file_event_tx = inner.file_events_tx.clone();
+
+        jobs.start(ctx, move || {
+            log_error(eyre!("Failed to save file {file_path:?}"), || {
+                let mut file = fs::File::create(file_path)?;
+                file.write_all(text.as_bytes())?;
+                let mtime = file_mtime(&file)?;
+
+                let _ = file_event_tx.send(FileEvent::NewBufferMTime(mtime));
+
+                Ok(())
+            });
+
+            None
+        });
+    }
 }
 
 impl Display for BufferItem {
@@ -280,7 +439,7 @@ impl From<&str> for FileEditor {
             _ => {
                 let mut text_edit = MdTextEdit::new();
                 text_edit.text.push_str(text);
-                buffer.push(BufferItem::Text(text_edit));
+                buffer.push(BufferItem::Text(Box::new(text_edit)));
             }
         };
 
@@ -314,6 +473,40 @@ impl From<&str> for FileEditor {
     }
 }
 
+fn spawn_file_watcher(p: &Path) -> Inner {
+    let (tx, rx) = mpsc::channel();
+
+    let path = p.to_owned();
+    let events_tx = tx.clone();
+    let mut watcher = notify::recommended_watcher(move |event: notify::Result<notify::Event>| {
+        log_error(eyre!("watch {path:?} error"), || {
+            match event?.kind {
+                EventKind::Create(..) | EventKind::Modify(..) | EventKind::Remove(..) => {}
+
+                EventKind::Access(..) | EventKind::Any | EventKind::Other => return Ok(()),
+            }
+
+            let file = File::open(&path)?;
+            let mtime = file_mtime(&file)?;
+
+            let _ = events_tx.send(FileEvent::NewFileMTime(mtime));
+
+            Ok(())
+        });
+    })
+    .unwrap();
+
+    if let Err(e) = watcher.watch(p, notify::RecursiveMode::NonRecursive) {
+        log::error!("Failed to watch {p:?}: {e}");
+    };
+
+    Inner {
+        file_events: rx,
+        file_events_tx: tx,
+        _file_watcher: watcher,
+    }
+}
+
 #[cfg(test)]
 mod test {
 

src/handwriting/canvas_rasterizer.rs

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

src/handwriting/mod.rs

@@ -8,6 +8,7 @@ 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};
@@ -163,6 +164,12 @@ 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}"));
         })

src/lib.rs

@@ -1,5 +1,3 @@
-#![warn(clippy::all, rust_2018_idioms)]
-
 pub mod app;
 pub mod constants;
 pub mod custom_code_block;

src/markdown/highlighter.rs

@@ -1,5 +1,7 @@
 use egui::text::{CCursorRange, LayoutJob};
 
+use crate::markdown::Heading;
+
 use super::{Item, Style, parse};
 
 /// Highlight markdown, caching previous output to save CPU.
@@ -71,8 +73,15 @@ fn format_from_style(egui_style: &egui::Style, style: &Style) -> egui::text::Tex
         egui_style.visuals.text_color()
     };
 
-    let text_style = if style.heading.is_some() {
-        TextStyle::Heading
+    let text_style = if let Some(heading) = style.heading {
+        match heading {
+            Heading::H1 => TextStyle::Name("H1".into()),
+            Heading::H2 => TextStyle::Name("H2".into()),
+            Heading::H3 => TextStyle::Name("H3".into()),
+            Heading::H4 => TextStyle::Name("H4".into()),
+            Heading::H5 => TextStyle::Name("H5".into()),
+            Heading::H6 => TextStyle::Name("H6".into()),
+        }
     } else if style.code {
         TextStyle::Monospace
     } else if style.small | style.raised {

src/markdown/tokenizer.rs

@@ -31,7 +31,7 @@ pub enum TokenKind {
     Text,
 }
 
-const TOKENS: &[(&'static str, TokenKind)] = &[
+const TOKENS: &[(&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};
+use egui::{Color32, Context, RichText, Theme, Ui, Visuals, style::ScrollAnimation};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
@@ -14,7 +14,7 @@ pub struct Preferences {
     pub hide_handwriting_cursor: bool,
 
     #[serde(skip)]
-    has_applied_theme: bool,
+    has_applied_prefs: bool,
 }
 
 impl Default for Preferences {
@@ -22,7 +22,7 @@ impl Default for Preferences {
         Self {
             animations: true,
             high_contrast: false,
-            has_applied_theme: false,
+            has_applied_prefs: false,
             hide_handwriting_cursor: false,
         }
     }
@@ -31,8 +31,20 @@ impl Default for Preferences {
 impl Preferences {
     /// Apply preferences, if they haven't already been applied.
     pub fn apply(&mut self, ctx: &Context) {
-        if !self.has_applied_theme {
-            self.has_applied_theme = true;
+        if !self.has_applied_prefs {
+            self.has_applied_prefs = true;
+
+            let scroll_animation = if self.animations {
+                ScrollAnimation::default()
+            } else {
+                ScrollAnimation::none()
+            };
+
+            for theme in [Theme::Dark, Theme::Light] {
+                ctx.style_mut_of(theme, |style| {
+                    style.scroll_animation = scroll_animation;
+                });
+            }
 
             let mut dark_visuals = Visuals::dark();
             let mut light_visuals = Visuals::light();
@@ -71,11 +83,15 @@ impl Preferences {
     pub fn show(&mut self, ui: &mut Ui) {
         ui.label(RichText::new("Prefs").weak());
 
-        ui.toggle_value(&mut self.animations, "Animations");
+        let animations_toggle = ui.toggle_value(&mut self.animations, "Animations");
+        if animations_toggle.clicked() {
+            self.has_applied_prefs = false;
+            self.apply(ui.ctx());
+        }
 
         let high_contrast_toggle = ui.toggle_value(&mut self.high_contrast, "High Contrast");
         if high_contrast_toggle.clicked() {
-            self.has_applied_theme = false;
+            self.has_applied_prefs = false;
             self.apply(ui.ctx());
         }
 

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

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