hulthe/inkr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: hulthe:master
Branches Tags
hulthe:master hulthe:shrink-handwriting hulthe:gui-testing hulthe:markdown-parser hulthe:all-fonts
..
compare: hulthe:gui-testing
Branches Tags
hulthe:master hulthe:shrink-handwriting hulthe:gui-testing hulthe:markdown-parser hulthe:all-fonts

1 Commits
master ... gui-testin

Author SHA1 Message Date
Joakim Hulthe
fa03714826 Add egui-kittest 2025-07-08 12:33:49 +02:00
20 changed files with 1237 additions and 2280 deletions
Expand all files Collapse all files

1933
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

22
Cargo.toml
View File

@ -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

125
src/app.rs
View File

@ -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, 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))
});
}
@ -471,12 +413,7 @@ impl eframe::App for App {
});
});
egui::CentralPanel::default()
.frame(Frame {
fill: ctx.style().visuals.window_fill(),
..Frame::central_panel(&ctx.style())
})
.show(ctx, |ui| {
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))
@ -511,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
});
}
}
}

261
src/file_editor.rs
View File

@ -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 {

58
src/folder.rs
View File

@ -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,18 +94,11 @@ 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 });
}
} else if file_type.is_dir() {
if filter_folder(&name) {
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,
@ -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"
}

2
src/handwriting/canvas_rasterizer.rs
View File

@ -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,
}

417
src/handwriting/mod.rs
View File

@ -1,6 +1,5 @@
mod canvas_rasterizer;
mod disk_format;
mod tool;
use std::{
fmt::{self, Display},
@ -9,14 +8,13 @@ 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},
emath::{self, TSTransform},
epaint::{TessellationOptions, Tessellator, Vertex},
};
use eyre::{Context, bail};
@ -27,8 +25,6 @@ use zerocopy::{FromBytes, IntoBytes};
use crate::{custom_code_block::try_from_custom_code_block, rasterizer};
use crate::{custom_code_block::write_custom_code_block, util::random_id};
use self::tool::{Tool, ToolEvent};
const HANDWRITING_MIN_HEIGHT: f32 = 100.0;
const HANDWRITING_BOTTOM_PADDING: f32 = 80.0;
const HANDWRITING_MARGIN: f32 = 0.05;
@ -81,20 +77,10 @@ struct Ephemeral {
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>,
/// 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>,
@ -139,9 +125,6 @@ impl Default for Ephemeral {
Self {
id: random_id(),
canvas_rasterizer: Default::default(),
tool: Tool::Pencil,
tool_position: None,
last_tool_position: None,
current_stroke: Default::default(),
tessellator: None,
mesh: Default::default(),
@ -180,20 +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 (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}"));
})
@ -233,8 +202,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();
@ -294,21 +261,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,
}
}
}
@ -365,14 +399,6 @@ impl Handwriting {
// 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);
painter.add(shape);
}
response
}
@ -392,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);
@ -411,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);
});
@ -444,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)))
@ -554,87 +584,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,
@ -778,9 +727,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() {
@ -794,194 +741,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);
}
}

455
src/handwriting/snapshots/inkr__handwriting__test__handle_input.snap
View File

@ -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

7
src/handwriting/snapshots/inkr__handwriting__test__input events to handwriting.snap
View File

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

32
src/handwriting/tool/eraser.rs
View File

@ -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
}

28
src/handwriting/tool/mod.rs
View File

@ -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,
}
}
}

22
src/handwriting/tool/pencil.rs
View File

@ -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
}
}
}

3
src/lib.rs
View File

@ -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;

26
src/markdown/highlighter.rs
View File

@ -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 {

10
src/markdown/parser.rs
View File

@ -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

2
src/markdown/tokenizer.rs
View File

@ -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)),

37
src/preferences.rs
View File

@ -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,30 +31,13 @@ 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();
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;
dark_visuals.code_bg_color = Color32::BLACK;
light_visuals.code_bg_color = Color32::WHITE;
@ -88,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());
}

9
src/rasterizer.rs
View File

@ -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

14
src/text_styles.rs
View File

@ -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";

28
src/util.rs
View File

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