Compare commits
4 Commits
a91cafa74a
...
markdown-p
| Author | SHA1 | Date | |
|---|---|---|---|
7f93084e64
|
|||
|
83ad2068e0
|
|||
|
3908e6d913
|
|||
|
27728fc431
|
2
.cargo/config.toml
Normal file
2
.cargo/config.toml
Normal file
@ -0,0 +1,2 @@
|
||||
[target.wasm32-unknown-unknown]
|
||||
rustflags = ['--cfg', 'getrandom_backend="wasm_js"']
|
||||
2
.gitignore
vendored
Normal file
2
.gitignore
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
dist
|
||||
target
|
||||
3633
Cargo.lock
generated
Normal file
3633
Cargo.lock
generated
Normal file
File diff suppressed because it is too large
Load Diff
53
Cargo.toml
Normal file
53
Cargo.toml
Normal file
@ -0,0 +1,53 @@
|
||||
[package]
|
||||
name = "inkr"
|
||||
version = "0.1.0"
|
||||
authors = []
|
||||
edition = "2024"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
all-features = true
|
||||
targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
|
||||
|
||||
[features]
|
||||
pinenote = []
|
||||
|
||||
[dependencies]
|
||||
egui = "0.31"
|
||||
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"
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
||||
env_logger = "0.11.8"
|
||||
rand = "0.9.1"
|
||||
|
||||
[target.'cfg(target_arch = "wasm32")'.dependencies]
|
||||
getrandom = { version = "0.3", features = ["wasm_js"] }
|
||||
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" }
|
||||
|
||||
[dev-dependencies]
|
||||
insta = { version = "1.43.1", features = ["yaml"] }
|
||||
# egui = { path = "../egui/crates/egui" }
|
||||
# eframe = { path = "../egui/crates/eframe" }
|
||||
|
||||
[profile.release]
|
||||
opt-level = 2 # fast and small wasm
|
||||
|
||||
[profile.dev.package."*"]
|
||||
opt-level = 2 # optimize dependencies in debug-builds
|
||||
2
Trunk.toml
Normal file
2
Trunk.toml
Normal file
@ -0,0 +1,2 @@
|
||||
[build]
|
||||
filehash = false
|
||||
BIN
assets/icon-1024.png
Normal file
BIN
assets/icon-1024.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 85 KiB |
BIN
assets/icon-256.png
Normal file
BIN
assets/icon-256.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 19 KiB |
62
assets/icon.svg
Normal file
62
assets/icon.svg
Normal file
@ -0,0 +1,62 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Created with Inkscape (http://www.inkscape.org/) -->
|
||||
|
||||
<svg
|
||||
width="256"
|
||||
height="256"
|
||||
viewBox="0 0 67.733332 67.733333"
|
||||
version="1.1"
|
||||
id="svg1"
|
||||
xml:space="preserve"
|
||||
inkscape:version="1.4.2 (ebf0e940d0, 2025-05-08)"
|
||||
sodipodi:docname="icon.svg"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"><sodipodi:namedview
|
||||
id="namedview1"
|
||||
pagecolor="#505050"
|
||||
bordercolor="#eeeeee"
|
||||
borderopacity="1"
|
||||
inkscape:showpageshadow="0"
|
||||
inkscape:pageopacity="0"
|
||||
inkscape:pagecheckerboard="0"
|
||||
inkscape:deskcolor="#505050"
|
||||
inkscape:document-units="mm"
|
||||
showguides="false"
|
||||
inkscape:zoom="1.6249158"
|
||||
inkscape:cx="147.69996"
|
||||
inkscape:cy="131.69913"
|
||||
inkscape:window-width="1664"
|
||||
inkscape:window-height="1123"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-maximized="0"
|
||||
inkscape:current-layer="layer1" /><defs
|
||||
id="defs1"><rect
|
||||
x="-8.0004144"
|
||||
y="1.8462495"
|
||||
width="264.01368"
|
||||
height="253.5516"
|
||||
id="rect3" /><rect
|
||||
x="-1.8462495"
|
||||
y="-3.0770825"
|
||||
width="256.01326"
|
||||
height="257.85951"
|
||||
id="rect2" /></defs><g
|
||||
inkscape:label="Layer 1"
|
||||
inkscape:groupmode="layer"
|
||||
id="layer1"><circle
|
||||
style="fill:#110320;stroke-width:1.5875;fill-opacity:1;stroke:#ffffff;stroke-opacity:1;stroke-dasharray:none"
|
||||
id="path1"
|
||||
cx="-33.866669"
|
||||
cy="33.866669"
|
||||
transform="scale(-1,1)"
|
||||
r="29.633333" /><path
|
||||
style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.726546;stroke-dasharray:none"
|
||||
d="m 24.357358,51.75417 c 1.677138,0.1954 3.012712,-1.943399 0.697783,-2.233805 -0.43693,-0.05481 -1.094737,-0.196393 -1.469913,0.112888 -0.725035,0.597691 -0.05602,2.024431 0.77213,2.120918 M 44.55508,47.458562 c -2.036319,-1.300371 -6.036944,-3.772356 -2.853754,-6.546895 2.728243,-2.377997 6.477766,1.248147 8.186012,3.109607 0.979637,1.0675 2.466472,1.861233 3.67434,0.654289 0.51717,-0.516775 0.968121,-1.312455 1.189759,-2.005947 1.591482,-4.979623 -4.179579,-4.744659 -7.417698,-4.633956 -0.951483,0.03253 -2.61236,0.303404 -3.212234,-0.656953 -0.427092,-0.683746 -0.135095,-1.484022 0.474312,-1.93208 1.360421,-1.000262 3.587682,-0.457196 4.652612,-1.849352 0.828528,-1.083114 0.951,-4.818847 -1.22072,-3.350234 -1.443858,0.976401 -2.006307,1.916665 -3.873526,2.324531 0.222633,-0.929454 1.778989,-2.100224 1.499021,-3.032882 -0.386705,-1.28822 -2.097275,-0.0512 -2.89635,-0.174431 -1.301969,-0.200779 -1.776328,-2.582496 -1.679169,-3.637966 0.211543,-2.29809 1.939272,-4.771313 3.673637,-6.185849 1.3339,-1.087912 3.458366,-2.233404 3.97281,-3.99081 0.963508,-3.291457 -2.687111,-5.514838 -5.437351,-4.032242 -3.193287,1.721432 -2.389588,8.096059 -3.623982,11.147297 -0.364454,0.900877 -0.970432,2.880491 -2.042274,3.173114 -0.649242,0.177246 -0.922121,-0.598875 -0.994604,-1.093721 -0.156259,-1.066832 0.596766,-3.104217 -0.406279,-3.871285 -1.925963,-1.472853 -2.118198,3.230061 -3.387645,2.716025 -0.51512,-0.208588 -0.592573,-0.957611 -0.557124,-1.427206 0.09125,-1.208752 1.39216,-7.538591 -2.172458,-5.21215 -2.924945,1.90896 1.702668,6.085542 -0.527528,7.633266 -1.553108,1.077833 -2.569377,-0.643592 -3.218833,-1.834516 -0.888912,-1.630017 -1.577648,-3.577817 -1.50393,-5.458634 0.05507,-1.40513 0.84855,-3.098296 0.08945,-4.419774 -1.28002,-2.228324 -5.084134,-1.932106 -6.097163,0.32796 -1.494817,3.334892 1.146497,4.662242 3.098072,6.621665 1.013668,1.01774 1.832017,2.31355 2.489201,3.583834 0.365325,0.706145 1.458044,2.439306 1.13037,3.248518 -0.272203,0.672224 -1.201216,-0.06939 -1.483304,-0.328274 -0.923006,-0.847094 -2.934861,-3.048331 -3.902644,-0.972527 -1.582374,3.394047 7.74979,3.046066 4.025122,6.811266 -1.165609,1.178293 -2.619518,0.377498 -3.890096,-0.119487 -1.802787,-0.705155 -3.350441,-0.965609 -4.797851,0.545082 -0.403375,0.42101 -0.774148,0.921607 -0.840012,1.518039 -0.175061,1.585323 2.03783,3.007543 3.477426,2.714219 1.11212,-0.2266 2.010389,-1.009378 3.175375,-1.139827 1.241591,-0.139028 2.045938,0.790409 1.832938,2.042238 -0.224989,1.322281 -2.006141,1.492584 -3.065696,1.516282 -2.728138,0.06102 -8.365686,0.740019 -7.421897,5.0174 0.427713,1.938463 3.289772,2.755106 4.919438,1.986954 2.399018,-1.130846 2.82494,-4.428861 5.323211,-5.680952 0.728974,-0.365349 2.079221,-1.095803 2.829431,-0.432104 2.412658,2.134442 -2.819355,5.586848 0.0509,8.076797 0.940133,0.815568 1.796677,-0.187134 2.072547,-1.076718 0.424858,-1.370002 -0.241091,-5.437488 2.687209,-4.531871 0.942342,0.29143 1.676656,1.468989 2.20772,2.230322 1.180467,1.692317 1.943623,3.555791 2.23459,5.603278 0.241802,1.701573 0.05628,3.87755 1.015729,5.366084 1.767129,2.741609 5.0248,0.99903 5.770174,-1.581327 0.278479,-0.964043 0.244035,-1.97941 -0.06571,-2.93006 -0.203472,-0.624482 -0.837385,-1.594523 -0.485287,-2.259042 0.560913,-1.058617 2.500975,-0.205104 3.323697,-1.568951 M 11.282216,39.999731 c -1.089731,-0.383555 -3.0034339,-0.530935 -3.8017272,0.534465 -0.5463955,0.729209 0.1590305,1.777793 1.0382558,1.536416 0.8474681,-0.232658 1.9728694,-1.554161 2.7634714,-2.070881 m 5.328926,-2.404732 c -0.753761,-0.138097 -1.837599,-0.08651 -2.477713,-0.539231 -0.767733,-0.542982 -0.921334,-1.592688 -1.957202,-1.817154 -1.363887,-0.295546 -2.8379814,1.425438 -2.086435,2.701244 1.0566,1.793659 5.358164,0.731178 6.52135,-0.344859 m 28.117712,10.970905 -0.144296,0.356349 c 0.64822,0.812599 4.681381,4.096531 5.227817,1.72372 0.359489,-1.561022 -4.071741,-2.094883 -5.083523,-2.080066 M 18.806334,25.003554 c 0.15582,-1.480274 -1.948974,-3.996407 -3.550889,-3.979179 -1.724018,0.01854 -0.620047,1.668489 0.138592,2.162822 0.434608,0.283193 0.887821,0.53677 1.33694,0.795641 0.67922,0.391499 1.348677,0.725904 2.075355,1.020716 m 33.510001,10.458337 c 1.688214,0.682313 4.022777,1.141407 5.653158,-4.78e-4 1.057186,-0.740431 1.253424,-3.177239 -0.284082,-3.519836 -1.561492,-0.347939 -1.996578,1.718043 -2.991458,2.390466 -0.75837,0.512568 -1.672781,0.516416 -2.377622,1.129849 m -0.653258,-3.515868 c 1.605596,0.313842 2.298441,-2.135314 0.575747,-2.430759 -1.593158,-0.273232 -2.264698,2.100623 -0.575747,2.430759 m -5.829793,-4.023772 c 2.878313,1.130708 7.741256,-4.494597 4.037077,-5.882019 -2.692662,-1.008547 -2.519327,1.463896 -3.454303,2.94427 -0.457826,0.724892 -2.297067,2.264312 -0.582774,2.937749 M 32.659319,15.259489 c 1.43128,-0.213437 1.900284,-3.437075 0.09929,-3.084237 -1.390128,0.272344 -1.94476,3.359442 -0.09929,3.084237 z"
|
||||
id="path2" /><text
|
||||
xml:space="preserve"
|
||||
transform="scale(0.26458333)"
|
||||
id="text2"
|
||||
style="fill:#1e0026;text-orientation:auto;text-align:start;writing-mode:lr-tb;direction:ltr;fill-opacity:1;stroke:#200029;stroke-opacity:1;stroke-width:2.746;stroke-dasharray:none;white-space:pre;shape-inside:url(#rect2)" /></g></svg>
|
||||
|
After Width: | Height: | Size: 6.9 KiB |
22
assets/manifest.json
Normal file
22
assets/manifest.json
Normal file
@ -0,0 +1,22 @@
|
||||
{
|
||||
"name": "Inkr",
|
||||
"short_name": "inkr",
|
||||
"icons": [
|
||||
{
|
||||
"src": "./assets/icon-256.png",
|
||||
"sizes": "256x256",
|
||||
"type": "image/png"
|
||||
},
|
||||
{
|
||||
"src": "./assets/icon-1024.png",
|
||||
"sizes": "1024x1024",
|
||||
"type": "image/png"
|
||||
}
|
||||
],
|
||||
"lang": "en-US",
|
||||
"id": "/index.html",
|
||||
"start_url": "./index.html",
|
||||
"display": "standalone",
|
||||
"background_color": "black",
|
||||
"theme_color": "black"
|
||||
}
|
||||
25
assets/sw.js
Normal file
25
assets/sw.js
Normal file
@ -0,0 +1,25 @@
|
||||
var cacheName = 'inkr';
|
||||
var filesToCache = [
|
||||
'./',
|
||||
'./index.html',
|
||||
'./inkr.js',
|
||||
'./inkr.wasm',
|
||||
];
|
||||
|
||||
/* Start the service worker and cache all of the app's content */
|
||||
self.addEventListener('install', function(e) {
|
||||
e.waitUntil(
|
||||
caches.open(cacheName).then(function(cache) {
|
||||
return cache.addAll(filesToCache);
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
/* Serve cached content when offline */
|
||||
self.addEventListener('fetch', function(e) {
|
||||
e.respondWith(
|
||||
caches.match(e.request).then(function(response) {
|
||||
return response || fetch(e.request);
|
||||
})
|
||||
);
|
||||
});
|
||||
BIN
fonts/Iosevka-Thin.ttc
Normal file
BIN
fonts/Iosevka-Thin.ttc
Normal file
Binary file not shown.
BIN
fonts/IosevkaAile-Regular.ttc
Normal file
BIN
fonts/IosevkaAile-Regular.ttc
Normal file
Binary file not shown.
135
index.html
Normal file
135
index.html
Normal file
@ -0,0 +1,135 @@
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||||
|
||||
<!-- Disable zooming: -->
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
|
||||
|
||||
<head>
|
||||
<title>Inkr</title>
|
||||
|
||||
<link data-trunk rel="rust" data-wasm-opt="2" />
|
||||
<base data-trunk-public-url />
|
||||
|
||||
<link data-trunk rel="icon" href="assets/icon.svg">
|
||||
|
||||
|
||||
<link data-trunk rel="copy-file" href="assets/sw.js"/>
|
||||
<link data-trunk rel="copy-file" href="assets/manifest.json"/>
|
||||
<link data-trunk rel="copy-file" href="assets/icon-256.png" data-target-path="assets"/>
|
||||
<link data-trunk rel="copy-file" href="assets/icon-1024.png" data-target-path="assets"/>
|
||||
|
||||
|
||||
<link rel="manifest" href="manifest.json">
|
||||
<meta name="theme-color" media="(prefers-color-scheme: dark)" content="#404040">
|
||||
<meta name="theme-color" media="(prefers-color-scheme: light)" content="white">
|
||||
|
||||
<style>
|
||||
html {
|
||||
touch-action: manipulation; /* Remove touch delay: */
|
||||
}
|
||||
|
||||
body {
|
||||
background: #909090;
|
||||
}
|
||||
|
||||
@media (prefers-color-scheme: dark) {
|
||||
body {
|
||||
background: #404040;
|
||||
}
|
||||
}
|
||||
|
||||
/* Allow canvas to fill entire web page: */
|
||||
html,
|
||||
body {
|
||||
overflow: hidden;
|
||||
margin: 0 !important;
|
||||
padding: 0 !important;
|
||||
height: 100%;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
/* Make canvas fill entire document: */
|
||||
canvas {
|
||||
margin-right: auto;
|
||||
margin-left: auto;
|
||||
display: block;
|
||||
position: absolute;
|
||||
top: 0;
|
||||
left: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
}
|
||||
|
||||
.centered {
|
||||
margin-right: auto;
|
||||
margin-left: auto;
|
||||
display: block;
|
||||
position: absolute;
|
||||
top: 50%;
|
||||
left: 50%;
|
||||
transform: translate(-50%, -50%);
|
||||
color: #f0f0f0;
|
||||
font-size: 24px;
|
||||
font-family: Ubuntu-Light, Helvetica, sans-serif;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------- */
|
||||
/* Loading animation from https://loading.io/css/ */
|
||||
.lds-dual-ring {
|
||||
display: inline-block;
|
||||
width: 24px;
|
||||
height: 24px;
|
||||
}
|
||||
|
||||
.lds-dual-ring:after {
|
||||
content: " ";
|
||||
display: block;
|
||||
width: 24px;
|
||||
height: 24px;
|
||||
margin: 0px;
|
||||
border-radius: 50%;
|
||||
border: 3px solid #fff;
|
||||
border-color: #fff transparent #fff transparent;
|
||||
animation: lds-dual-ring 1.2s linear infinite;
|
||||
}
|
||||
|
||||
@keyframes lds-dual-ring {
|
||||
0% {
|
||||
transform: rotate(0deg);
|
||||
}
|
||||
|
||||
100% {
|
||||
transform: rotate(360deg);
|
||||
}
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<!-- The WASM code will resize the canvas dynamically -->
|
||||
<!-- the id is hardcoded in main.rs . so, make sure both match. -->
|
||||
<canvas id="the_canvas_id"></canvas>
|
||||
|
||||
<!-- the loading spinner will be removed in main.rs -->
|
||||
<div class="centered" id="loading_text">
|
||||
<p style="font-size:16px">
|
||||
Loading…
|
||||
</p>
|
||||
<div class="lds-dual-ring"></div>
|
||||
</div>
|
||||
|
||||
<!--Register Service Worker. this will cache the wasm / js scripts for offline use (for PWA functionality). -->
|
||||
<!-- Force refresh (Ctrl + F5) to load the latest files instead of cached files -->
|
||||
<script>
|
||||
// We disable caching during development so that we always view the latest version.
|
||||
if ('serviceWorker' in navigator && window.location.hash !== "#dev") {
|
||||
window.addEventListener('load', function () {
|
||||
navigator.serviceWorker.register('sw.js');
|
||||
});
|
||||
}
|
||||
</script>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
358
src/app.rs
Normal file
358
src/app.rs
Normal file
@ -0,0 +1,358 @@
|
||||
use std::{
|
||||
fs,
|
||||
path::PathBuf,
|
||||
sync::{Arc, mpsc},
|
||||
};
|
||||
|
||||
use crate::{file_editor::FileEditor, preferences::Preferences, util::GuiSender};
|
||||
use egui::{
|
||||
Align, Button, Color32, FontData, FontDefinitions, PointerButton, RichText, ScrollArea, Stroke,
|
||||
};
|
||||
|
||||
#[derive(serde::Deserialize, serde::Serialize)]
|
||||
#[serde(default)]
|
||||
pub struct App {
|
||||
preferences: Preferences,
|
||||
|
||||
#[serde(skip)]
|
||||
actions_tx: mpsc::Sender<Action>,
|
||||
#[serde(skip)]
|
||||
actions_rx: mpsc::Receiver<Action>,
|
||||
|
||||
tabs: Vec<(TabId, Tab)>,
|
||||
open_tab_index: Option<usize>,
|
||||
|
||||
next_tab_id: TabId,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, serde::Serialize)]
|
||||
enum Tab {
|
||||
File(FileEditor),
|
||||
}
|
||||
|
||||
impl Tab {
|
||||
pub fn title(&self) -> &str {
|
||||
match self {
|
||||
Tab::File(file_editor) => file_editor.title(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub type TabId = usize;
|
||||
|
||||
pub enum Action {
|
||||
OpenFile(FileEditor),
|
||||
MoveFile(TabId, PathBuf),
|
||||
CloseTab(TabId),
|
||||
// TODO
|
||||
//ShowError {
|
||||
// error: RichText
|
||||
//},
|
||||
}
|
||||
|
||||
impl Default for App {
|
||||
fn default() -> Self {
|
||||
let (actions_tx, actions_rx) = mpsc::channel();
|
||||
Self {
|
||||
preferences: Preferences::default(),
|
||||
actions_tx,
|
||||
actions_rx,
|
||||
tabs: vec![(1, Tab::File(FileEditor::new("note.md")))],
|
||||
open_tab_index: None,
|
||||
next_tab_id: 2,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl App {
|
||||
/// Called once before the first frame.
|
||||
pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
|
||||
let mut fonts = FontDefinitions::empty();
|
||||
fonts.font_data = [
|
||||
//(
|
||||
// "IosevkaAile-Thin",
|
||||
// include_bytes!("../fonts/IosevkaAile-Thin.ttc").as_slice(),
|
||||
//),
|
||||
//(
|
||||
// "IosevkaAile-ExtraLight",
|
||||
// include_bytes!("../fonts/IosevkaAile-ExtraLight.ttc").as_slice(),
|
||||
//),
|
||||
//(
|
||||
// "IosevkaAile-Light",
|
||||
// include_bytes!("../fonts/IosevkaAile-Light.ttc").as_slice(),
|
||||
//),
|
||||
(
|
||||
"IosevkaAile-Regular",
|
||||
include_bytes!("../fonts/IosevkaAile-Regular.ttc").as_slice(),
|
||||
),
|
||||
//(
|
||||
// "IosevkaAile-Medium",
|
||||
// include_bytes!("../fonts/IosevkaAile-Medium.ttc").as_slice(),
|
||||
//),
|
||||
//(
|
||||
// "IosevkaAile-Bold",
|
||||
// include_bytes!("../fonts/IosevkaAile-Bold.ttc").as_slice(),
|
||||
//),
|
||||
(
|
||||
"Iosevka-Thin",
|
||||
include_bytes!("../fonts/Iosevka-Thin.ttc").as_slice(),
|
||||
),
|
||||
//(
|
||||
// "Iosevka-ExtraLight",
|
||||
// include_bytes!("../fonts/Iosevka-ExtraLight.ttc").as_slice(),
|
||||
//),
|
||||
//(
|
||||
// "Iosevka-Light",
|
||||
// include_bytes!("../fonts/Iosevka-Light.ttc").as_slice(),
|
||||
//),
|
||||
//(
|
||||
// "Iosevka-Medium",
|
||||
// include_bytes!("../fonts/Iosevka-Medium.ttc").as_slice(),
|
||||
//),
|
||||
//(
|
||||
// "Iosevka-Regular",
|
||||
// include_bytes!("../fonts/Iosevka-Regular.ttc").as_slice(),
|
||||
//),
|
||||
//(
|
||||
// "Iosevka-Heavy",
|
||||
// include_bytes!("../fonts/Iosevka-Heavy.ttc").as_slice(),
|
||||
//),
|
||||
]
|
||||
.into_iter()
|
||||
.map(|(name, data)| (name.to_string(), Arc::new(FontData::from_static(data))))
|
||||
.collect();
|
||||
|
||||
fonts.families.insert(
|
||||
egui::FontFamily::Proportional,
|
||||
vec!["IosevkaAile-Regular".into()],
|
||||
);
|
||||
|
||||
fonts
|
||||
.families
|
||||
.insert(egui::FontFamily::Monospace, vec!["Iosevka-Thin".into()]);
|
||||
|
||||
cc.egui_ctx.set_fonts(fonts);
|
||||
|
||||
cc.egui_ctx.style_mut(|style| {
|
||||
// TODO: change color of text in TextEdit
|
||||
style.visuals.widgets.noninteractive.fg_stroke =
|
||||
Stroke::new(1.0, Color32::from_rgb(200, 200, 200));
|
||||
});
|
||||
|
||||
if let Some(storage) = cc.storage {
|
||||
return eframe::get_value(storage, eframe::APP_KEY).unwrap_or_default();
|
||||
}
|
||||
|
||||
Default::default()
|
||||
}
|
||||
|
||||
fn actions_tx(&self, ctx: &egui::Context) -> GuiSender<Action> {
|
||||
GuiSender::new(self.actions_tx.clone(), ctx)
|
||||
}
|
||||
|
||||
fn handle_action(&mut self, action: Action) {
|
||||
match action {
|
||||
Action::OpenFile(file_editor) => {
|
||||
self.open_tab(Tab::File(file_editor));
|
||||
}
|
||||
Action::MoveFile(tab_id, new_path) => {
|
||||
let tab = self.tabs.iter_mut().find(|(id, _)| &tab_id == id);
|
||||
let Some((_, tab)) = tab else { return };
|
||||
let Tab::File(editor) = tab; // else { return };
|
||||
|
||||
editor.set_path(new_path);
|
||||
}
|
||||
Action::CloseTab(id) => {
|
||||
// TODO: check if the file is dirty and ask to save it first?
|
||||
self.tabs.retain(|(tab_id, _)| &id != tab_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl eframe::App for App {
|
||||
fn save(&mut self, storage: &mut dyn eframe::Storage) {
|
||||
eframe::set_value(storage, eframe::APP_KEY, self);
|
||||
}
|
||||
|
||||
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
|
||||
self.preferences.apply(ctx);
|
||||
|
||||
while let Ok(action) = self.actions_rx.try_recv() {
|
||||
self.handle_action(action);
|
||||
}
|
||||
|
||||
if self.open_tab_index >= Some(self.tabs.len()) {
|
||||
self.open_tab_index = Some(self.tabs.len().saturating_sub(1));
|
||||
}
|
||||
|
||||
//ctx.input_mut(|input| {
|
||||
// if input.consume_key(Modifiers::CTRL, Key::H) {
|
||||
// self.buffer.push(BufferItem::Painting(Default::default()));
|
||||
// }
|
||||
//});
|
||||
|
||||
egui::TopBottomPanel::top("top_panel").show(ctx, |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());
|
||||
|
||||
if ui.button("New File").clicked() {
|
||||
let file = FileEditor::new("note.md");
|
||||
self.open_tab(Tab::File(file));
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if ui.button("Open File").clicked() {
|
||||
let actions_tx = self.actions_tx(ui.ctx());
|
||||
std::thread::spawn(move || {
|
||||
let file = rfd::FileDialog::new().pick_file();
|
||||
|
||||
let Some(file_path) = file else { return };
|
||||
|
||||
let text = match fs::read_to_string(&file_path) {
|
||||
Ok(text) => text,
|
||||
Err(e) => {
|
||||
log::error!("Failed to read {file_path:?}: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
let editor = FileEditor::from_file(file_path, &text);
|
||||
let _ = actions_tx.send(Action::OpenFile(editor));
|
||||
});
|
||||
}
|
||||
|
||||
if ui.button("Open Folder").clicked() {
|
||||
log::error!("Open Folder not implemented");
|
||||
}
|
||||
|
||||
if ui
|
||||
.add_enabled(self.open_tab_index.is_some(), Button::new("Close File"))
|
||||
.clicked()
|
||||
{
|
||||
if let Some(i) = self.open_tab_index.take() {
|
||||
self.tabs.remove(i);
|
||||
}
|
||||
}
|
||||
|
||||
let open_file =
|
||||
self.open_tab_index
|
||||
.and_then(|i| self.tabs.get(i))
|
||||
.and_then(|(id, tab)| match tab {
|
||||
Tab::File(file_editor) => Some((*id, file_editor)),
|
||||
});
|
||||
|
||||
let open_file_with_path = open_file
|
||||
.clone()
|
||||
.and_then(|(_, file_editor)| file_editor.path().zip(Some(file_editor)));
|
||||
|
||||
if ui
|
||||
.add_enabled(open_file_with_path.is_some(), Button::new("Save"))
|
||||
.clicked()
|
||||
{
|
||||
if let Some((file_path, file_editor)) = open_file_with_path {
|
||||
let text = file_editor.to_string();
|
||||
let file_path = file_path.to_owned();
|
||||
std::thread::spawn(move || {
|
||||
if let Err(e) = fs::write(file_path, text.as_bytes()) {
|
||||
log::error!("{e}");
|
||||
};
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if ui
|
||||
.add_enabled(open_file.is_some(), Button::new("Save As"))
|
||||
.clicked()
|
||||
{
|
||||
let actions_tx = self.actions_tx(ui.ctx());
|
||||
let (tab_id, editor) =
|
||||
open_file.expect("We checked that open_file is_some");
|
||||
let text = editor.to_string();
|
||||
std::thread::spawn(move || {
|
||||
let Some(file_path) = rfd::FileDialog::new().save_file() else {
|
||||
return;
|
||||
};
|
||||
|
||||
if let Err(e) = fs::write(&file_path, text.as_bytes()) {
|
||||
log::error!("{e}");
|
||||
return;
|
||||
};
|
||||
|
||||
let _ = actions_tx.send(Action::MoveFile(tab_id, file_path));
|
||||
});
|
||||
}
|
||||
|
||||
ui.add_space(8.0);
|
||||
|
||||
self.preferences.show(ui);
|
||||
|
||||
ui.add_space(8.0);
|
||||
|
||||
if cfg!(not(target_arch = "wasm32")) && ui.button("Quit").clicked() {
|
||||
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
|
||||
}
|
||||
});
|
||||
|
||||
ui.add_space(16.0);
|
||||
|
||||
ui.add_space(16.0);
|
||||
|
||||
ScrollArea::horizontal().show(ui, |ui| {
|
||||
for (i, (tab_id, tab)) in self.tabs.iter().enumerate() {
|
||||
let selected = self.open_tab_index == Some(i);
|
||||
let mut button = Button::new(tab.title()).selected(selected);
|
||||
|
||||
let dirty = i == 0; // TODO: mark as dirty when contents hasn't been saved
|
||||
if dirty {
|
||||
button = button.right_text(RichText::new("*").strong())
|
||||
}
|
||||
|
||||
let response = ui.add(button);
|
||||
|
||||
if response.clicked() {
|
||||
self.open_tab_index = Some(i);
|
||||
} else if response.clicked_by(PointerButton::Secondary) {
|
||||
let _ = self.actions_tx(ui.ctx()).send(Action::CloseTab(*tab_id));
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
egui::CentralPanel::default().show(ctx, |ui| {
|
||||
if let Some(Tab::File(file_editor)) = self
|
||||
.open_tab_index
|
||||
.and_then(|i| self.tabs.get_mut(i))
|
||||
.map(|(_tab_id, tab)| tab)
|
||||
{
|
||||
file_editor.show(ui, &self.preferences);
|
||||
}
|
||||
|
||||
ui.with_layout(egui::Layout::bottom_up(Align::LEFT), |ui| {
|
||||
egui::warn_if_debug_build(ui);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
impl App {
|
||||
/// Figure out where we should insert the next tab.
|
||||
fn insert_tab_at(&self) -> usize {
|
||||
match self.open_tab_index {
|
||||
None => 0,
|
||||
Some(i) => (i + 1).min(self.tabs.len()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Open a [Tab].
|
||||
fn open_tab(&mut self, tab: Tab) {
|
||||
let i = self.insert_tab_at();
|
||||
let id = self.next_tab_id;
|
||||
self.next_tab_id += 1;
|
||||
self.tabs.insert(i, (id, tab));
|
||||
}
|
||||
}
|
||||
1
src/constants.rs
Normal file
1
src/constants.rs
Normal file
@ -0,0 +1 @@
|
||||
pub const MAX_NOTE_WIDTH: f32 = 600.0;
|
||||
135
src/custom_code_block.rs
Normal file
135
src/custom_code_block.rs
Normal file
@ -0,0 +1,135 @@
|
||||
use std::{
|
||||
fmt::{self, Display, Write},
|
||||
iter,
|
||||
};
|
||||
|
||||
const TICKS: &str = "```";
|
||||
const NL_TICKS: &str = "\n```";
|
||||
|
||||
/// Wrap a [Display] in markdown code-block ticks ([TICKS])
|
||||
pub fn to_custom_code_block(key: &str, content: impl Display) -> String {
|
||||
let mut out = String::new();
|
||||
write_custom_code_block(&mut out, key, content).unwrap();
|
||||
out
|
||||
}
|
||||
|
||||
/// Wrap a [Display] in markdown code-block ticks ([TICKS])
|
||||
pub fn write_custom_code_block(mut w: impl Write, key: &str, content: impl Display) -> fmt::Result {
|
||||
write!(w, "{TICKS}{key}\n{content}\n{TICKS}")
|
||||
}
|
||||
|
||||
/// Try to unwrap a string from within markdown code-block ticks ([TICKS])
|
||||
pub fn try_from_custom_code_block<'a>(key: &str, code_block: &'a str) -> Option<&'a str> {
|
||||
code_block
|
||||
.trim()
|
||||
.strip_prefix(TICKS)?
|
||||
.strip_prefix(key)?
|
||||
.strip_prefix("\n")?
|
||||
.strip_suffix(TICKS)?
|
||||
.strip_suffix("\n")
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum MdItem<'a> {
|
||||
/// A line of regular markdown, but not a code block.
|
||||
Line(&'a str),
|
||||
|
||||
/// A markdown code block
|
||||
CodeBlock {
|
||||
/// The key or language of the code block.
|
||||
key: &'a str,
|
||||
|
||||
/// Everything in-between the ticks.
|
||||
content: &'a str,
|
||||
|
||||
/// The entire code-block, including ticks.
|
||||
span: &'a str,
|
||||
},
|
||||
}
|
||||
|
||||
/// Iterate over code-blocks in a markdown string
|
||||
pub fn iter_lines_and_code_blocks(mut md: &str) -> impl Iterator<Item = MdItem<'_>> {
|
||||
iter::from_fn(move || {
|
||||
if md.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
if !md.starts_with(TICKS) {
|
||||
// line does not start with ticks, return a normal line.
|
||||
let line;
|
||||
if let Some(i) = md.find('\n') {
|
||||
let i = i + 1;
|
||||
line = &md[..i];
|
||||
md = &md[i..];
|
||||
} else {
|
||||
line = md;
|
||||
md = "";
|
||||
}
|
||||
return Some(MdItem::Line(line));
|
||||
}
|
||||
|
||||
let mut i = TICKS.len();
|
||||
let from_key = &md[i..];
|
||||
|
||||
let Some((key, from_content)) = from_key.split_once('\n') else {
|
||||
// no more newlines, return the remaining string as the final line.
|
||||
let rest = md;
|
||||
md = "";
|
||||
return Some(MdItem::Line(rest));
|
||||
};
|
||||
i += key.len() + "\n".len();
|
||||
|
||||
let Some(end) = from_content.find(NL_TICKS) else {
|
||||
// no closing ticks, return a line instead.
|
||||
let line;
|
||||
if let Some(i) = md.find('\n') {
|
||||
let i = i + 1;
|
||||
line = &md[..i];
|
||||
md = &md[i..];
|
||||
} else {
|
||||
line = md;
|
||||
md = "";
|
||||
}
|
||||
return Some(MdItem::Line(line));
|
||||
};
|
||||
let content = &from_content[..end];
|
||||
i += end + NL_TICKS.len();
|
||||
|
||||
if md[i..].starts_with("\n") {
|
||||
i += 1;
|
||||
};
|
||||
let span = &md[..i];
|
||||
md = &md[i..];
|
||||
|
||||
Some(MdItem::CodeBlock { key, content, span })
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::iter_lines_and_code_blocks;
|
||||
|
||||
#[test]
|
||||
fn iter_markdown() {
|
||||
let markdown = r#"
|
||||
# Hello world
|
||||
## Subheader
|
||||
- 1
|
||||
```foo
|
||||
whatever
|
||||
some code
|
||||
Hi mom!
|
||||
```
|
||||
|
||||
```` # wrong number of ticks, but that's ok
|
||||
``` # indented ticks
|
||||
```
|
||||
|
||||
``` # no closing ticks
|
||||
"#;
|
||||
|
||||
let list: Vec<_> = iter_lines_and_code_blocks(markdown).collect();
|
||||
insta::assert_snapshot!(markdown);
|
||||
insta::assert_debug_snapshot!(list);
|
||||
}
|
||||
}
|
||||
356
src/file_editor.rs
Normal file
356
src/file_editor.rs
Normal file
@ -0,0 +1,356 @@
|
||||
use std::{
|
||||
cmp::Ordering,
|
||||
fmt::{self, Display},
|
||||
ops::{Div as _, Sub as _},
|
||||
path::{Path, PathBuf},
|
||||
str::FromStr,
|
||||
};
|
||||
|
||||
use egui::{
|
||||
Align, Button, DragAndDrop, Frame, Layout, ScrollArea, Ui, UiBuilder, Vec2, Widget as _, vec2,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
custom_code_block::{MdItem, iter_lines_and_code_blocks},
|
||||
painting::{self, Handwriting, HandwritingStyle},
|
||||
preferences::Preferences,
|
||||
text_editor::MdTextEdit,
|
||||
};
|
||||
|
||||
#[derive(serde::Deserialize, serde::Serialize)]
|
||||
pub struct FileEditor {
|
||||
title: String,
|
||||
pub path: Option<PathBuf>,
|
||||
pub buffer: Vec<BufferItem>,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, serde::Serialize)]
|
||||
pub enum BufferItem {
|
||||
Text(MdTextEdit),
|
||||
Handwriting(Handwriting),
|
||||
}
|
||||
|
||||
impl FileEditor {
|
||||
pub fn new(title: impl Into<String>) -> Self {
|
||||
let buffer = vec![BufferItem::Text(MdTextEdit::new())];
|
||||
Self {
|
||||
title: title.into(),
|
||||
path: None,
|
||||
buffer,
|
||||
}
|
||||
}
|
||||
|
||||
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),
|
||||
..FileEditor::from(contents)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn title(&self) -> &str {
|
||||
&self.title
|
||||
}
|
||||
|
||||
pub fn path(&self) -> Option<&Path> {
|
||||
self.path.as_deref()
|
||||
}
|
||||
|
||||
pub fn show(&mut self, ui: &mut Ui, preferences: &Preferences) {
|
||||
ui.vertical_centered_justified(|ui| {
|
||||
ui.heading(&self.title);
|
||||
|
||||
const MAX_NOTE_WIDTH: f32 = 600.0;
|
||||
|
||||
ui.horizontal(|ui| {
|
||||
ui.label("new");
|
||||
if ui.button("text").clicked() {
|
||||
self.buffer.push(BufferItem::Text(Default::default()));
|
||||
}
|
||||
if ui.button("writing").clicked() {
|
||||
self.buffer
|
||||
.push(BufferItem::Handwriting(Default::default()));
|
||||
}
|
||||
});
|
||||
|
||||
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);
|
||||
ui.vertical(|ui| {
|
||||
ui.set_max_width(MAX_NOTE_WIDTH);
|
||||
self.show_contents(ui, preferences);
|
||||
});
|
||||
ui.add_space(side_padding);
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
fn show_contents(&mut self, ui: &mut Ui, preferences: &Preferences) {
|
||||
if self.buffer.is_empty() {
|
||||
self.buffer.push(BufferItem::Text(Default::default()));
|
||||
}
|
||||
|
||||
struct DraggingItem {
|
||||
index: usize,
|
||||
}
|
||||
|
||||
let mut drop_from_to: Option<(usize, usize)> = None;
|
||||
let is_dragging = DragAndDrop::has_payload_of_type::<DraggingItem>(ui.ctx());
|
||||
let drag_zone_height = 10.0;
|
||||
|
||||
// Iterate over buffer items using `retain` so that we can handle deletions
|
||||
let mut i = 0usize..;
|
||||
let len = self.buffer.len();
|
||||
self.buffer.retain_mut(|item| {
|
||||
let i = i.next().unwrap();
|
||||
let is_first = i == 0;
|
||||
let is_last = i == len - 1;
|
||||
|
||||
let mut retain = true;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
let item_response = ui.allocate_ui(item_size, |ui| match item {
|
||||
BufferItem::Text(text_edit) => {
|
||||
text_edit.ui(ui);
|
||||
}
|
||||
BufferItem::Handwriting(painting) => {
|
||||
let style = HandwritingStyle {
|
||||
animate: preferences.animations,
|
||||
..HandwritingStyle::from_theme(ui.ctx().theme())
|
||||
};
|
||||
painting.ui(&style, ui);
|
||||
}
|
||||
});
|
||||
|
||||
// Delete-button
|
||||
if ui.button("x").clicked() {
|
||||
retain = false;
|
||||
ui.ctx().request_repaint();
|
||||
}
|
||||
|
||||
// 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.allocate_new_ui(
|
||||
UiBuilder::new()
|
||||
.max_rect(dragger_rect)
|
||||
.layout(Layout::top_down(Align::Center)),
|
||||
|ui| {
|
||||
let up_button_response = ui.add_enabled(!is_first, Button::new("⇡"));
|
||||
if up_button_response.clicked() {
|
||||
drop_from_to = Some((i, i - 1));
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
retain
|
||||
});
|
||||
|
||||
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, self.buffer.len()));
|
||||
}
|
||||
} else {
|
||||
// the dnd_drop_zone adds 3.0pts work of extra space
|
||||
ui.add_space(drag_zone_height + 3.0);
|
||||
}
|
||||
|
||||
// Handle drag-and-dropping buffer items
|
||||
// TODO: make sure nothing was removed from self.buffer this frame
|
||||
if let Some((from, to)) = drop_from_to {
|
||||
if from < self.buffer.len() {
|
||||
match from.cmp(&to) {
|
||||
Ordering::Greater => {
|
||||
let item = self.buffer.remove(from);
|
||||
self.buffer.insert(to, item);
|
||||
}
|
||||
Ordering::Less => {
|
||||
let item = self.buffer.remove(from);
|
||||
self.buffer.insert(to - 1, item);
|
||||
}
|
||||
Ordering::Equal => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_path(&mut self, new_path: PathBuf) {
|
||||
let Some(title) = new_path.file_name() else {
|
||||
log::error!("No filename in path {new_path:?}");
|
||||
return;
|
||||
};
|
||||
self.title = title.to_string_lossy().to_string();
|
||||
self.path = Some(new_path);
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for BufferItem {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
BufferItem::Text(md_text_edit) => Display::fmt(md_text_edit, f),
|
||||
BufferItem::Handwriting(handwriting) => Display::fmt(handwriting, f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for FileEditor {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let mut first = true;
|
||||
for item in &self.buffer {
|
||||
if !first {
|
||||
writeln!(f)?;
|
||||
}
|
||||
|
||||
first = false;
|
||||
|
||||
write!(f, "{item}")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&str> for FileEditor {
|
||||
fn from(s: &str) -> Self {
|
||||
let mut editor = FileEditor::new("note.md");
|
||||
let buffer = &mut editor.buffer;
|
||||
|
||||
let push_text = |buffer: &mut Vec<BufferItem>, text| match buffer.last_mut() {
|
||||
Some(BufferItem::Text(text_edit)) => text_edit.text.push_str(text),
|
||||
_ => {
|
||||
let mut text_edit = MdTextEdit::new();
|
||||
text_edit.text.push_str(text);
|
||||
buffer.push(BufferItem::Text(text_edit));
|
||||
}
|
||||
};
|
||||
|
||||
for item in iter_lines_and_code_blocks(s) {
|
||||
match item {
|
||||
MdItem::Line(line) => push_text(buffer, line),
|
||||
MdItem::CodeBlock { key, content, span } => match key {
|
||||
painting::CODE_BLOCK_KEY => match Handwriting::from_str(span) {
|
||||
Ok(handwriting) => {
|
||||
if let Some(BufferItem::Text(text_edit)) = buffer.last_mut() {
|
||||
if text_edit.text.ends_with('\n') {
|
||||
text_edit.text.pop();
|
||||
if text_edit.text.is_empty() {
|
||||
buffer.pop();
|
||||
}
|
||||
}
|
||||
};
|
||||
buffer.push(BufferItem::Handwriting(handwriting))
|
||||
}
|
||||
Err(e) => {
|
||||
log::error!("Failed to decode handwriting {content:?}: {e}");
|
||||
push_text(buffer, span);
|
||||
}
|
||||
},
|
||||
_ => push_text(buffer, span),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
editor
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
|
||||
use crate::file_editor::BufferItem;
|
||||
|
||||
use super::FileEditor;
|
||||
|
||||
#[test]
|
||||
fn from_str_and_back_1() {
|
||||
let markdown = r#"
|
||||
# Hello world!
|
||||
|
||||
This is some text.
|
||||
Here's some handwriting:
|
||||
```handwriting
|
||||
DgB0UUlNeFFJTX9RUE2pUYZNDlIATotSjk4AUwxPaFODT89T608UVBtQL1QqUDtULlBDVDFQSVQuUA==
|
||||
```
|
||||
|
||||
And here's some more text :D
|
||||
```
|
||||
with a regular code-block!
|
||||
```"#;
|
||||
|
||||
println!("{markdown}");
|
||||
println!();
|
||||
println!();
|
||||
println!("{markdown:?}");
|
||||
println!();
|
||||
println!();
|
||||
|
||||
let file_editor = FileEditor::from(markdown);
|
||||
|
||||
for item in &file_editor.buffer {
|
||||
match item {
|
||||
BufferItem::Text(md_text_edit) => {
|
||||
println!("{:?}", md_text_edit.text);
|
||||
}
|
||||
BufferItem::Handwriting(_) => {
|
||||
println!("<handwriting>");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
println!();
|
||||
println!();
|
||||
|
||||
let serialized = file_editor.to_string();
|
||||
assert_eq!(
|
||||
markdown, serialized,
|
||||
"FileEditor should preserve formatting"
|
||||
);
|
||||
}
|
||||
}
|
||||
3
src/handwriting/advanced-example.md
Normal file
3
src/handwriting/advanced-example.md
Normal file
File diff suppressed because one or more lines are too long
14
src/lib.rs
Normal file
14
src/lib.rs
Normal file
@ -0,0 +1,14 @@
|
||||
#![warn(clippy::all, rust_2018_idioms)]
|
||||
|
||||
pub mod app;
|
||||
pub mod constants;
|
||||
pub mod custom_code_block;
|
||||
pub mod file_editor;
|
||||
pub mod markdown;
|
||||
pub mod painting;
|
||||
pub mod preferences;
|
||||
pub mod rasterizer;
|
||||
pub mod text_editor;
|
||||
pub mod util;
|
||||
|
||||
pub use app::App;
|
||||
71
src/main.rs
Normal file
71
src/main.rs
Normal file
@ -0,0 +1,71 @@
|
||||
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
|
||||
|
||||
// When compiling natively:
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn main() -> eframe::Result {
|
||||
env_logger::init();
|
||||
|
||||
let native_options = eframe::NativeOptions {
|
||||
viewport: egui::ViewportBuilder::default()
|
||||
.with_inner_size([400.0, 300.0])
|
||||
.with_min_inner_size([300.0, 220.0])
|
||||
.with_icon(
|
||||
// NOTE: Adding an icon is optional
|
||||
eframe::icon_data::from_png_bytes(&include_bytes!("../assets/icon-256.png")[..])
|
||||
.expect("Failed to load icon"),
|
||||
),
|
||||
..Default::default()
|
||||
};
|
||||
eframe::run_native(
|
||||
"Inkr",
|
||||
native_options,
|
||||
Box::new(|cc| Ok(Box::new(inkr::App::new(cc)))),
|
||||
)
|
||||
}
|
||||
|
||||
// When compiling to web using trunk:
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn main() {
|
||||
use eframe::wasm_bindgen::JsCast as _;
|
||||
|
||||
// Redirect `log` message to `console.log` and friends:
|
||||
eframe::WebLogger::init(log::LevelFilter::Debug).ok();
|
||||
|
||||
let web_options = eframe::WebOptions::default();
|
||||
|
||||
wasm_bindgen_futures::spawn_local(async {
|
||||
let document = web_sys::window()
|
||||
.expect("No window")
|
||||
.document()
|
||||
.expect("No document");
|
||||
|
||||
let canvas = document
|
||||
.get_element_by_id("the_canvas_id")
|
||||
.expect("Failed to find the_canvas_id")
|
||||
.dyn_into::<web_sys::HtmlCanvasElement>()
|
||||
.expect("the_canvas_id was not a HtmlCanvasElement");
|
||||
|
||||
let start_result = eframe::WebRunner::new()
|
||||
.start(
|
||||
canvas,
|
||||
web_options,
|
||||
Box::new(|cc| Ok(Box::new(inkr::App::new(cc)))),
|
||||
)
|
||||
.await;
|
||||
|
||||
// Remove the loading text and spinner:
|
||||
if let Some(loading_text) = document.get_element_by_id("loading_text") {
|
||||
match start_result {
|
||||
Ok(_) => {
|
||||
loading_text.remove();
|
||||
}
|
||||
Err(e) => {
|
||||
loading_text.set_inner_html(
|
||||
"<p> The app has crashed. See the developer console for details. </p>",
|
||||
);
|
||||
panic!("Failed to start eframe: {e:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
54
src/markdown/ast.rs
Normal file
54
src/markdown/ast.rs
Normal file
@ -0,0 +1,54 @@
|
||||
use super::span::Span;
|
||||
|
||||
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
|
||||
pub enum Heading {
|
||||
H1,
|
||||
H2,
|
||||
H3,
|
||||
H4,
|
||||
H5,
|
||||
H6,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
|
||||
pub struct Style {
|
||||
/// # heading (large text)
|
||||
pub heading: Option<Heading>,
|
||||
|
||||
/// > quoted (slightly dimmer color or other font style)
|
||||
pub quoted: bool,
|
||||
|
||||
/// `code` (monospace, some other color)
|
||||
pub code: bool,
|
||||
|
||||
/// self.strong* (emphasized, e.g. bold)
|
||||
pub strong: bool,
|
||||
|
||||
/// _underline_
|
||||
pub underline: bool,
|
||||
|
||||
/// ~strikethrough~
|
||||
pub strikethrough: bool,
|
||||
|
||||
/// /italics/
|
||||
pub italics: bool,
|
||||
|
||||
/// $small$
|
||||
pub small: bool,
|
||||
|
||||
/// ^raised^
|
||||
pub raised: bool,
|
||||
}
|
||||
|
||||
pub enum MarkdownItem<'a> {
|
||||
Text {
|
||||
span: Span<'a>,
|
||||
style: Style,
|
||||
},
|
||||
|
||||
CodeBlock {
|
||||
all: Span<'a>,
|
||||
language: Span<'a>,
|
||||
code: Span<'a>,
|
||||
},
|
||||
}
|
||||
10
src/markdown/grammar.lalrpop
Normal file
10
src/markdown/grammar.lalrpop
Normal file
@ -0,0 +1,10 @@
|
||||
use std::str::FromStr;
|
||||
|
||||
grammar;
|
||||
|
||||
pub Term: i32 = {
|
||||
<n:Num> => n,
|
||||
"(" <t:Term> ")" => t,
|
||||
};
|
||||
|
||||
Num: i32 = <s:r"[0-9]+"> => i32::from_str(s).unwrap();
|
||||
268
src/markdown/highlighter.rs
Normal file
268
src/markdown/highlighter.rs
Normal file
@ -0,0 +1,268 @@
|
||||
use egui::text::{CCursorRange, LayoutJob};
|
||||
|
||||
use crate::markdown::{
|
||||
span::Span,
|
||||
tokenizer::{Heading, Token, TokenKind, tokenize},
|
||||
};
|
||||
|
||||
/// Highlight markdown, caching previous output to save CPU.
|
||||
#[derive(Default)]
|
||||
pub struct MemoizedHighlighter {
|
||||
style: egui::Style,
|
||||
code: String,
|
||||
output: LayoutJob,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
|
||||
pub struct Style {
|
||||
/// # heading (large text)
|
||||
pub heading: Option<Heading>,
|
||||
|
||||
/// > quoted (slightly dimmer color or other font style)
|
||||
pub quoted: bool,
|
||||
|
||||
/// `code` (monospace, some other color)
|
||||
pub code: bool,
|
||||
|
||||
/// self.strong* (emphasized, e.g. bold)
|
||||
pub strong: bool,
|
||||
|
||||
/// _underline_
|
||||
pub underline: bool,
|
||||
|
||||
/// ~strikethrough~
|
||||
pub strikethrough: bool,
|
||||
|
||||
/// /italics/
|
||||
pub italics: bool,
|
||||
|
||||
/// $small$
|
||||
pub small: bool,
|
||||
|
||||
/// ^raised^
|
||||
pub raised: bool,
|
||||
}
|
||||
|
||||
impl MemoizedHighlighter {
|
||||
pub fn highlight(
|
||||
&mut self,
|
||||
egui_style: &egui::Style,
|
||||
code: &str,
|
||||
cursor: Option<CCursorRange>,
|
||||
) -> LayoutJob {
|
||||
if (&self.style, self.code.as_str()) != (egui_style, code) {
|
||||
self.style = egui_style.clone();
|
||||
code.clone_into(&mut self.code);
|
||||
self.output = highlight_markdown(egui_style, code, cursor);
|
||||
}
|
||||
self.output.clone()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn highlight_markdown(
|
||||
egui_style: &egui::Style,
|
||||
text: &str,
|
||||
|
||||
// TODO: hide special characters where cursor isn't
|
||||
_cursor: Option<CCursorRange>,
|
||||
) -> LayoutJob {
|
||||
let mut job = LayoutJob::default();
|
||||
let mut style = Style::default();
|
||||
|
||||
let mut prev = TokenKind::Newline;
|
||||
|
||||
let tokens: Vec<_> = tokenize(text).collect();
|
||||
let mut tokens = &tokens[..];
|
||||
|
||||
const CODE_INDENT: f32 = 10.0;
|
||||
|
||||
while !tokens.is_empty() {
|
||||
let token = tokens.first().unwrap();
|
||||
tokens = &tokens[1..];
|
||||
|
||||
let start_of_line = prev == TokenKind::Newline;
|
||||
prev = token.kind;
|
||||
|
||||
let mut basic_style: Option<fn(&mut Style) -> &mut bool> = None;
|
||||
|
||||
match token.kind {
|
||||
TokenKind::CodeBlock if start_of_line => {
|
||||
let span = collect_until(
|
||||
token,
|
||||
&mut tokens,
|
||||
series([TokenKind::Newline, TokenKind::CodeBlock]),
|
||||
);
|
||||
|
||||
let code_style = format_from_style(
|
||||
egui_style,
|
||||
&Style {
|
||||
code: true,
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
|
||||
job.append(&*span, CODE_INDENT, code_style.clone());
|
||||
style = Default::default();
|
||||
continue;
|
||||
}
|
||||
|
||||
TokenKind::Newline => style = Style::default(),
|
||||
|
||||
TokenKind::Strong => basic_style = Some(|s| &mut s.strong),
|
||||
TokenKind::Italic => basic_style = Some(|s| &mut s.italics),
|
||||
TokenKind::Strikethrough => basic_style = Some(|s| &mut s.strikethrough),
|
||||
|
||||
TokenKind::CodeBlock | TokenKind::Mono => {
|
||||
style.code = true;
|
||||
let span = collect_until(
|
||||
token,
|
||||
&mut tokens,
|
||||
any_of([TokenKind::Mono, TokenKind::CodeBlock, TokenKind::Newline]),
|
||||
);
|
||||
job.append(&*span, 0.0, format_from_style(egui_style, &style));
|
||||
style.code = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
// TODO: different heading strengths
|
||||
TokenKind::Heading(h) if start_of_line => style.heading = Some(h),
|
||||
TokenKind::Quote if start_of_line => style.quoted = true,
|
||||
|
||||
// TODO: indented list entries
|
||||
TokenKind::ListEntry if start_of_line => {
|
||||
job.append("• ", 0.0, format_from_style(egui_style, &style));
|
||||
continue;
|
||||
}
|
||||
|
||||
TokenKind::Text
|
||||
// the following tokens are only richly rendered if encountered e.g. at start_of_line.
|
||||
| TokenKind::Indentation
|
||||
| TokenKind::ListEntry
|
||||
| TokenKind::Heading(..)
|
||||
| TokenKind::Quote => {}
|
||||
}
|
||||
|
||||
// if we encountered a marker for Bold, Italic, or Strikethrough, toggle that style and
|
||||
// render the token with the style enabled.
|
||||
if let Some(basic_style) = basic_style {
|
||||
let mut tmp_style = style;
|
||||
*basic_style(&mut tmp_style) = true;
|
||||
*basic_style(&mut style) ^= true; // toggle
|
||||
job.append(&token.span, 0.0, format_from_style(egui_style, &tmp_style));
|
||||
continue;
|
||||
}
|
||||
|
||||
job.append(&token.span, 0.0, format_from_style(egui_style, &style));
|
||||
}
|
||||
|
||||
job
|
||||
}
|
||||
|
||||
fn series<'a, const N: usize>(of: [TokenKind; N]) -> impl FnMut(&[Token<'a>; N]) -> bool {
|
||||
move |token| {
|
||||
of.iter()
|
||||
.zip(token)
|
||||
.all(|(kind, token)| kind == &token.kind)
|
||||
}
|
||||
}
|
||||
|
||||
fn any_of<'a, const N: usize>(these: [TokenKind; N]) -> impl FnMut(&[Token<'a>; 1]) -> bool {
|
||||
move |[token]| these.contains(&token.kind)
|
||||
}
|
||||
|
||||
/// Collect all tokens up to and including `pattern`, and merge them into a signle span.
|
||||
///
|
||||
/// `N` determines how many specific and consecutive tokens we are looking for.
|
||||
/// i.e. if we were looking for a [TokenKind::Newline] followed by a [TokenKind::Quote], `N`
|
||||
/// would equal `2`.
|
||||
///
|
||||
/// `pattern` is a function that accepts an array of `N` tokens and returns `true` if they match,
|
||||
/// i.e. if we should stop collecting. [any_of] and [series] can help to construct this function.
|
||||
///
|
||||
/// The collected tokens will be split off the head of the slice referred to by `tokens`.
|
||||
///
|
||||
/// # Panic
|
||||
/// Panics if `tokens` does not contain only consecutive adjacent spans.
|
||||
fn collect_until<'a, const N: usize>(
|
||||
token: &Token<'a>,
|
||||
tokens: &mut &[Token<'a>],
|
||||
pattern: impl FnMut(&[Token<'a>; N]) -> bool,
|
||||
) -> Span<'a>
|
||||
where
|
||||
for<'b> &'b [Token<'a>; N]: TryFrom<&'b [Token<'a>]>,
|
||||
{
|
||||
let mut windows = tokens
|
||||
.windows(N)
|
||||
.map(|slice| <&[Token<'a>; N]>::try_from(slice).ok().unwrap());
|
||||
|
||||
let split_at = match windows.position(pattern) {
|
||||
Some(i) => i + N,
|
||||
None => tokens.len(), // consume everything
|
||||
};
|
||||
|
||||
let (consume, keep) = tokens.split_at(split_at);
|
||||
*tokens = keep;
|
||||
|
||||
consume
|
||||
.iter()
|
||||
.fold(token.span.clone(), |span: Span<'_>, token| {
|
||||
span.try_merge(&token.span).unwrap()
|
||||
})
|
||||
}
|
||||
|
||||
fn format_from_style(egui_style: &egui::Style, emark_style: &Style) -> egui::text::TextFormat {
|
||||
use egui::{Align, Color32, Stroke, TextStyle};
|
||||
|
||||
let color = if emark_style.strong || emark_style.heading.is_some() {
|
||||
egui_style.visuals.strong_text_color()
|
||||
} else if emark_style.quoted {
|
||||
egui_style.visuals.weak_text_color()
|
||||
} else {
|
||||
egui_style.visuals.text_color()
|
||||
};
|
||||
|
||||
let text_style = if emark_style.heading.is_some() {
|
||||
TextStyle::Heading
|
||||
} else if emark_style.code {
|
||||
TextStyle::Monospace
|
||||
} else if emark_style.small | emark_style.raised {
|
||||
TextStyle::Small
|
||||
} else {
|
||||
TextStyle::Body
|
||||
};
|
||||
|
||||
let background = if emark_style.code {
|
||||
egui_style.visuals.code_bg_color
|
||||
} else {
|
||||
Color32::TRANSPARENT
|
||||
};
|
||||
|
||||
let underline = if emark_style.underline {
|
||||
Stroke::new(1.0, color)
|
||||
} else {
|
||||
Stroke::NONE
|
||||
};
|
||||
|
||||
let strikethrough = if emark_style.strikethrough {
|
||||
Stroke::new(1.0, color)
|
||||
} else {
|
||||
Stroke::NONE
|
||||
};
|
||||
|
||||
let valign = if emark_style.raised {
|
||||
Align::TOP
|
||||
} else {
|
||||
Align::BOTTOM
|
||||
};
|
||||
|
||||
egui::text::TextFormat {
|
||||
font_id: text_style.resolve(egui_style),
|
||||
color,
|
||||
background,
|
||||
italics: emark_style.italics,
|
||||
underline,
|
||||
strikethrough,
|
||||
valign,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
7
src/markdown/mod.rs
Normal file
7
src/markdown/mod.rs
Normal file
@ -0,0 +1,7 @@
|
||||
mod highlighter;
|
||||
mod span;
|
||||
mod tokenizer;
|
||||
|
||||
pub use highlighter::*;
|
||||
pub use span::*;
|
||||
pub use tokenizer::*;
|
||||
@ -0,0 +1,46 @@
|
||||
---
|
||||
source: src/markdown/tokenizer.rs
|
||||
expression: examples
|
||||
---
|
||||
- string: "just some normal text :D"
|
||||
tokens:
|
||||
- "Token { span: Span(0..24, \"just some normal text :D\"), kind: Text }"
|
||||
- string: normal *bold* normal
|
||||
tokens:
|
||||
- "Token { span: Span(0..7, \"normal \"), kind: Text }"
|
||||
- "Token { span: Span(7..8, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(8..12, \"bold\"), kind: Text }"
|
||||
- "Token { span: Span(12..13, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(13..20, \" normal\"), kind: Text }"
|
||||
- string: normal * maybe bold? * normal
|
||||
tokens:
|
||||
- "Token { span: Span(0..7, \"normal \"), kind: Text }"
|
||||
- "Token { span: Span(7..8, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(8..21, \" maybe bold? \"), kind: Text }"
|
||||
- "Token { span: Span(21..22, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(22..29, \" normal\"), kind: Text }"
|
||||
- string: "```lang\ncode code code\n```"
|
||||
tokens:
|
||||
- "Token { span: Span(0..3, \"```\"), kind: CodeBlock }"
|
||||
- "Token { span: Span(3..7, \"lang\"), kind: Text }"
|
||||
- "Token { span: Span(7..8, \"\\n\"), kind: Newline }"
|
||||
- "Token { span: Span(8..22, \"code code code\"), kind: Text }"
|
||||
- "Token { span: Span(22..23, \"\\n\"), kind: Newline }"
|
||||
- "Token { span: Span(23..26, \"```\"), kind: CodeBlock }"
|
||||
- string: "*/``/*"
|
||||
tokens:
|
||||
- "Token { span: Span(0..1, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(1..2, \"/\"), kind: Italic }"
|
||||
- "Token { span: Span(2..3, \"`\"), kind: Mono }"
|
||||
- "Token { span: Span(3..4, \"`\"), kind: Mono }"
|
||||
- "Token { span: Span(4..5, \"/\"), kind: Italic }"
|
||||
- "Token { span: Span(5..6, \"*\"), kind: Strong }"
|
||||
- string: "*/`*/*/"
|
||||
tokens:
|
||||
- "Token { span: Span(0..1, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(1..2, \"/\"), kind: Italic }"
|
||||
- "Token { span: Span(2..3, \"`\"), kind: Mono }"
|
||||
- "Token { span: Span(3..4, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(4..5, \"/\"), kind: Italic }"
|
||||
- "Token { span: Span(5..6, \"*\"), kind: Strong }"
|
||||
- "Token { span: Span(6..7, \"/\"), kind: Italic }"
|
||||
83
src/markdown/span.rs
Normal file
83
src/markdown/span.rs
Normal file
@ -0,0 +1,83 @@
|
||||
use std::{
|
||||
fmt,
|
||||
ops::{Deref, Range},
|
||||
};
|
||||
|
||||
#[derive(Clone, Eq, PartialEq)]
|
||||
pub struct Span<'a> {
|
||||
complete_str: &'a str,
|
||||
range: Range<usize>,
|
||||
}
|
||||
|
||||
impl<'a> Span<'a> {
|
||||
pub fn new(complete_str: &'a str) -> Self {
|
||||
Self {
|
||||
complete_str,
|
||||
range: 0..complete_str.len(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get(&self, slice: Range<usize>) -> Option<Self> {
|
||||
let start = self.range.start.checked_add(slice.start)?;
|
||||
let end = self.range.start.checked_add(slice.end)?;
|
||||
|
||||
if end > self.range.end || end < start {
|
||||
return None;
|
||||
}
|
||||
|
||||
Some(Self {
|
||||
complete_str: self.complete_str,
|
||||
range: Range { start, end },
|
||||
})
|
||||
}
|
||||
|
||||
pub fn complete_str(&self) -> Self {
|
||||
Self::new(self.complete_str)
|
||||
}
|
||||
|
||||
pub fn split_at(&self, i: usize) -> Option<(Self, Self)> {
|
||||
let head = self.get(0..i)?;
|
||||
let tail = self.get(i..self.range.len())?;
|
||||
Some((head, tail))
|
||||
}
|
||||
|
||||
/// Try to merge the spans.
|
||||
///
|
||||
/// This only works if spans are pointing into the same backing buffer, and are adjacent.
|
||||
pub fn try_merge(&self, other: &Self) -> Option<Self> {
|
||||
if self.complete_str.as_ptr() != other.complete_str.as_ptr() {
|
||||
return None;
|
||||
}
|
||||
|
||||
if self.range.end == other.range.start {
|
||||
Some(Self {
|
||||
range: self.range.start..other.range.end,
|
||||
..*self
|
||||
})
|
||||
} else if self.range.start == other.range.end {
|
||||
Some(Self {
|
||||
range: other.range.start..self.range.end,
|
||||
..*self
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Deref for Span<'_> {
|
||||
type Target = str;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.complete_str[self.range.clone()]
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> fmt::Debug for Span<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_tuple("Span")
|
||||
.field(&self.range)
|
||||
.field(&self.deref())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
156
src/markdown/tokenizer.rs
Normal file
156
src/markdown/tokenizer.rs
Normal file
@ -0,0 +1,156 @@
|
||||
use std::iter;
|
||||
|
||||
use super::span::Span;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Heading {
|
||||
H6,
|
||||
H5,
|
||||
H4,
|
||||
H3,
|
||||
H2,
|
||||
H1,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum TokenKind {
|
||||
/// A newline that isn't a codeblock
|
||||
Newline,
|
||||
|
||||
/// "#" to "######"
|
||||
Heading(Heading),
|
||||
|
||||
/// A newline followed by three `
|
||||
CodeBlock,
|
||||
|
||||
Mono,
|
||||
Strong,
|
||||
Italic,
|
||||
Strikethrough,
|
||||
|
||||
/// ">"
|
||||
Quote,
|
||||
|
||||
/// Two spaces
|
||||
Indentation,
|
||||
|
||||
/// "- "
|
||||
ListEntry,
|
||||
|
||||
/// Normal text
|
||||
Text,
|
||||
}
|
||||
|
||||
const TOKENS: &[(&'static str, TokenKind)] = &[
|
||||
("\n", TokenKind::Newline),
|
||||
("######", TokenKind::Heading(Heading::H6)),
|
||||
("#####", TokenKind::Heading(Heading::H5)),
|
||||
("####", TokenKind::Heading(Heading::H4)),
|
||||
("###", TokenKind::Heading(Heading::H3)),
|
||||
("##", TokenKind::Heading(Heading::H2)),
|
||||
("#", TokenKind::Heading(Heading::H1)),
|
||||
("```", TokenKind::CodeBlock),
|
||||
("`", TokenKind::Mono),
|
||||
("*", TokenKind::Strong),
|
||||
("_", TokenKind::Italic),
|
||||
("~", TokenKind::Strikethrough),
|
||||
(">", TokenKind::Quote),
|
||||
(" ", TokenKind::Indentation),
|
||||
("- ", TokenKind::ListEntry),
|
||||
];
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Token<'a> {
|
||||
pub span: Span<'a>,
|
||||
pub kind: TokenKind,
|
||||
}
|
||||
|
||||
pub fn tokenize<'a>(s: &'a str) -> impl Iterator<Item = Token<'a>> {
|
||||
let mut s = Span::new(s);
|
||||
let mut yield_n: usize = 0;
|
||||
|
||||
iter::from_fn(move || {
|
||||
loop {
|
||||
if s.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
if yield_n == s.len() {
|
||||
let (token, rest) = s.split_at(s.len()).unwrap();
|
||||
let token = Token {
|
||||
span: token,
|
||||
kind: TokenKind::Text,
|
||||
};
|
||||
s = rest;
|
||||
return Some(token);
|
||||
}
|
||||
|
||||
let token = TOKENS.iter().find_map(|(token_str, token_kind)| {
|
||||
s[yield_n..]
|
||||
.starts_with(token_str)
|
||||
.then(|| (*token_kind, token_str.len()))
|
||||
});
|
||||
|
||||
let Some((kind, len)) = token else {
|
||||
yield_n += s[yield_n..].chars().next().unwrap_or('\0').len_utf8();
|
||||
continue;
|
||||
};
|
||||
|
||||
if yield_n > 0 {
|
||||
let (token, rest) = s.split_at(yield_n).unwrap();
|
||||
let token = Token {
|
||||
span: token,
|
||||
kind: TokenKind::Text,
|
||||
};
|
||||
s = rest;
|
||||
yield_n = 0;
|
||||
return Some(token);
|
||||
}
|
||||
|
||||
let (token, rest) = s.split_at(len).unwrap();
|
||||
let token = Token { span: token, kind };
|
||||
s = rest;
|
||||
return Some(token);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use serde::Serialize;
|
||||
|
||||
use super::tokenize;
|
||||
|
||||
#[test]
|
||||
fn test_tokenize() {
|
||||
let examples = [
|
||||
"just some normal text :D",
|
||||
"normal *bold* normal",
|
||||
"normal * maybe bold? * normal",
|
||||
"```lang\ncode code code\n```",
|
||||
"*/``/*",
|
||||
"*/`*/*/",
|
||||
];
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct Result {
|
||||
pub string: &'static str,
|
||||
|
||||
/// Debug-printed tokens
|
||||
pub tokens: Vec<String>,
|
||||
}
|
||||
|
||||
let examples = examples
|
||||
.into_iter()
|
||||
.map(|string| {
|
||||
let tokens = tokenize(string)
|
||||
.map(|tokens| format!("{tokens:?}"))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
Result { string, tokens }
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
insta::assert_yaml_snapshot!(examples);
|
||||
}
|
||||
}
|
||||
701
src/painting.rs
Normal file
701
src/painting.rs
Normal file
@ -0,0 +1,701 @@
|
||||
use std::{
|
||||
fmt::{self, Display},
|
||||
iter, mem,
|
||||
str::FromStr,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use base64::{Engine, prelude::BASE64_STANDARD};
|
||||
use egui::{
|
||||
Color32, ColorImage, CornerRadius, Event, Frame, Id, Mesh, PointerButton, Pos2, Rect, Sense,
|
||||
Shape, Stroke, TextureHandle, Theme, Ui, Vec2,
|
||||
emath::{self, TSTransform},
|
||||
epaint::{Brush, RectShape, TessellationOptions, Tessellator, Vertex},
|
||||
load::SizedTexture,
|
||||
};
|
||||
use eyre::{Context, bail};
|
||||
use eyre::{OptionExt, eyre};
|
||||
use half::f16;
|
||||
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
|
||||
|
||||
use crate::{
|
||||
custom_code_block::try_from_custom_code_block,
|
||||
rasterizer::{self, rasterize, rasterize_onto},
|
||||
};
|
||||
use crate::{custom_code_block::write_custom_code_block, util::random_id};
|
||||
|
||||
const HANDWRITING_MIN_HEIGHT: f32 = 100.0;
|
||||
const HANDWRITING_BOTTOM_PADDING: f32 = 80.0;
|
||||
const HANDWRITING_MARGIN: f32 = 0.05;
|
||||
const HANDWRITING_LINE_SPACING: f32 = 36.0;
|
||||
|
||||
pub const CODE_BLOCK_KEY: &str = "handwriting";
|
||||
|
||||
type StrokeBlendMode = rasterizer::blend::Normal;
|
||||
|
||||
const TESSELATION_OPTIONS: TessellationOptions = TessellationOptions {
|
||||
feathering: true,
|
||||
feathering_size_in_pixels: 1.0,
|
||||
coarse_tessellation_culling: true,
|
||||
prerasterized_discs: true,
|
||||
round_text_to_pixels: true,
|
||||
round_line_segments_to_pixels: true,
|
||||
round_rects_to_pixels: true,
|
||||
debug_paint_text_rects: false,
|
||||
debug_paint_clip_rects: false,
|
||||
debug_ignore_clip_rects: false,
|
||||
bezier_tolerance: 0.1,
|
||||
epsilon: 1.0e-5,
|
||||
parallel_tessellation: true,
|
||||
validate_meshes: false,
|
||||
};
|
||||
|
||||
pub struct HandwritingStyle {
|
||||
pub stroke: Stroke,
|
||||
pub bg_line_stroke: Stroke,
|
||||
pub bg_color: Color32,
|
||||
pub animate: bool,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, serde::Serialize)]
|
||||
#[serde(default)]
|
||||
pub struct Handwriting {
|
||||
#[serde(skip, default = "random_id")]
|
||||
id: Id,
|
||||
|
||||
strokes: Vec<Vec<Pos2>>,
|
||||
|
||||
/// The stroke that is currently being drawed.
|
||||
#[serde(skip)]
|
||||
current_stroke: Vec<Pos2>,
|
||||
|
||||
/// The lines that have not been blitted to `texture` yet.
|
||||
#[serde(skip)]
|
||||
unblitted_lines: Vec<[Pos2; 2]>,
|
||||
|
||||
height: f32,
|
||||
desired_height: f32,
|
||||
|
||||
/// Tesselated mesh of all strokes
|
||||
#[serde(skip)]
|
||||
mesh: Arc<Mesh>,
|
||||
|
||||
#[serde(skip)]
|
||||
texture: Option<TextureHandle>,
|
||||
|
||||
#[serde(skip)]
|
||||
image: ColorImage,
|
||||
|
||||
#[serde(skip)]
|
||||
refresh_texture: bool,
|
||||
|
||||
/// Context of the last mesh render.
|
||||
#[serde(skip)]
|
||||
last_mesh_ctx: Option<MeshContext>,
|
||||
}
|
||||
|
||||
/// Context of a mesh render.
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
struct MeshContext {
|
||||
/// Need to update the mesh when the stroke color changes.
|
||||
pub ui_theme: Theme,
|
||||
|
||||
pub pixels_per_point: f32,
|
||||
|
||||
/// Canvas size in points
|
||||
pub size: Vec2,
|
||||
|
||||
pub stroke: Stroke,
|
||||
}
|
||||
|
||||
/// Get [Painting::texture], initializing it if necessary.
|
||||
macro_rules! texture {
|
||||
($self_:expr, $ui:expr, $mesh_context:expr) => {{
|
||||
let ui: &Ui = $ui;
|
||||
let mesh_context: &MeshContext = $mesh_context;
|
||||
let image_size = mesh_context.pixel_size();
|
||||
|
||||
let new_image = || {
|
||||
let image = ColorImage::new(image_size, Color32::TRANSPARENT);
|
||||
ui.ctx()
|
||||
.load_texture("handwriting", image, Default::default())
|
||||
};
|
||||
|
||||
let texture = $self_.texture.get_or_insert_with(new_image);
|
||||
|
||||
if texture.size() != image_size {
|
||||
$self_.refresh_texture = true;
|
||||
// TODO: don't redraw the entire mesh, just blit the old texture onto the new one
|
||||
*texture = new_image()
|
||||
};
|
||||
|
||||
texture
|
||||
}};
|
||||
}
|
||||
|
||||
impl MeshContext {
|
||||
/// Calculate canvas size in pixels
|
||||
pub fn pixel_size(&self) -> [usize; 2] {
|
||||
let Vec2 { x, y } = self.size * self.pixels_per_point;
|
||||
[x, y].map(|f| f.ceil() as usize)
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Handwriting {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
id: random_id(),
|
||||
strokes: Default::default(),
|
||||
current_stroke: Default::default(),
|
||||
height: HANDWRITING_MIN_HEIGHT,
|
||||
desired_height: HANDWRITING_MIN_HEIGHT,
|
||||
mesh: Default::default(),
|
||||
texture: None,
|
||||
image: ColorImage::new([0, 0], Color32::WHITE),
|
||||
refresh_texture: true,
|
||||
last_mesh_ctx: None,
|
||||
unblitted_lines: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Handwriting {
|
||||
pub fn ui_control(
|
||||
&mut self,
|
||||
style: Option<&mut HandwritingStyle>,
|
||||
ui: &mut egui::Ui,
|
||||
) -> egui::Response {
|
||||
ui.horizontal(|ui| {
|
||||
if let Some(style) = style {
|
||||
ui.label("Stroke:");
|
||||
ui.add(&mut style.stroke);
|
||||
ui.separator();
|
||||
}
|
||||
|
||||
if ui.button("Clear Painting").clicked() {
|
||||
self.strokes.clear();
|
||||
self.refresh_texture = true;
|
||||
}
|
||||
|
||||
ui.add_enabled_ui(!self.strokes.is_empty(), |ui| {
|
||||
if ui.button("Undo").clicked() {
|
||||
self.strokes.pop();
|
||||
self.refresh_texture = true;
|
||||
}
|
||||
});
|
||||
|
||||
let vertex_count: usize = self.mesh.indices.len() / 3;
|
||||
ui.label(format!("vertices: {vertex_count}"));
|
||||
})
|
||||
.response
|
||||
}
|
||||
|
||||
fn commit_current_line(&mut self) {
|
||||
debug_assert!(!self.current_stroke.is_empty());
|
||||
self.strokes.push(mem::take(&mut self.current_stroke));
|
||||
}
|
||||
|
||||
pub fn ui_content(&mut self, style: &HandwritingStyle, ui: &mut Ui) -> egui::Response {
|
||||
if style.animate {
|
||||
self.height = ui.ctx().animate_value_with_time(
|
||||
self.id.with("height animation"),
|
||||
self.desired_height,
|
||||
0.4,
|
||||
);
|
||||
} else {
|
||||
self.height = self.desired_height;
|
||||
}
|
||||
|
||||
let size = Vec2::new(ui.available_width(), self.height);
|
||||
let (response, painter) = ui.allocate_painter(size, Sense::drag());
|
||||
|
||||
let mut response = response
|
||||
//.on_hover_cursor(CursorIcon::Crosshair)
|
||||
//.on_hover_and_drag_cursor(CursorIcon::None)
|
||||
;
|
||||
|
||||
let size = response.rect.size();
|
||||
|
||||
let to_screen = emath::RectTransform::from_to(
|
||||
//Rect::from_min_size(Pos2::ZERO, response.rect.square_proportions()),
|
||||
Rect::from_min_size(Pos2::ZERO, size),
|
||||
response.rect,
|
||||
);
|
||||
let from_screen = to_screen.inverse();
|
||||
|
||||
let is_drawing = response.interact_pointer_pos().is_some();
|
||||
let was_drawing = !self.current_stroke.is_empty();
|
||||
|
||||
if !is_drawing {
|
||||
// commit current line
|
||||
if was_drawing {
|
||||
self.commit_current_line();
|
||||
response.mark_changed();
|
||||
}
|
||||
|
||||
// recalculate how tall the widget should be
|
||||
let lines_max_y = self
|
||||
.strokes
|
||||
.iter()
|
||||
.flatten()
|
||||
.map(|p| p.y + HANDWRITING_BOTTOM_PADDING)
|
||||
.fold(HANDWRITING_MIN_HEIGHT, |max, y| max.max(y));
|
||||
|
||||
if self.desired_height != lines_max_y {
|
||||
self.desired_height = lines_max_y;
|
||||
response.mark_changed();
|
||||
}
|
||||
} else {
|
||||
let events = ui.ctx().input(|input| {
|
||||
// If we are getting both MouseMoved and PointerMoved events, ignore the first.
|
||||
let mut events = input.raw.events.iter().peekable();
|
||||
iter::from_fn(move || {
|
||||
let next = events.next()?;
|
||||
let Some(peek) = events.peek() else {
|
||||
return Some(next);
|
||||
};
|
||||
|
||||
match next {
|
||||
Event::PointerMoved(..) if matches!(peek, Event::MouseMoved(..)) => {
|
||||
let _ = events.next(); // drop the MouseMoved event
|
||||
Some(next)
|
||||
}
|
||||
Event::MouseMoved(..) if matches!(peek, Event::PointerMoved(..)) => {
|
||||
// return the peeked PointerMoved instead
|
||||
Some(events.next().expect("next is some"))
|
||||
}
|
||||
_ => Some(next),
|
||||
}
|
||||
})
|
||||
.cloned()
|
||||
.filter(|event| {
|
||||
// FIXME: pinenote: PointerMoved are duplicated after the MouseMoved events
|
||||
cfg!(not(feature = "pinenote")) || !matches!(event, Event::PointerMoved(..))
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
});
|
||||
|
||||
for event in events {
|
||||
let last_canvas_pos = self.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.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();
|
||||
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.current_stroke.is_empty() {
|
||||
self.commit_current_line();
|
||||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
(1..)
|
||||
.map(|n| n as f32 * HANDWRITING_LINE_SPACING)
|
||||
.take_while(|&y| y < size.y)
|
||||
.map(|y| {
|
||||
let l = to_screen * Pos2::new(HANDWRITING_MARGIN * size.x, y);
|
||||
let r = to_screen * Pos2::new((1.0 - HANDWRITING_MARGIN) * size.x, y);
|
||||
Shape::hline(l.x..=r.x, l.y, style.bg_line_stroke)
|
||||
})
|
||||
.for_each(|shape| {
|
||||
painter.add(shape);
|
||||
});
|
||||
|
||||
let mesh_rect = response
|
||||
.rect
|
||||
.with_max_y(response.rect.min.y + self.desired_height);
|
||||
let new_context = MeshContext {
|
||||
ui_theme: ui.ctx().theme(),
|
||||
pixels_per_point: ui.pixels_per_point(),
|
||||
size: mesh_rect.size(),
|
||||
stroke: style.stroke,
|
||||
};
|
||||
|
||||
if Some(&new_context) != self.last_mesh_ctx.as_ref() {
|
||||
self.refresh_texture = true;
|
||||
}
|
||||
|
||||
if self.refresh_texture {
|
||||
// rasterize the entire texture from scratch
|
||||
self.refresh_texture(style, new_context, ui);
|
||||
self.unblitted_lines.clear();
|
||||
} else if !self.unblitted_lines.is_empty() {
|
||||
// only rasterize the new lines onto the existing texture
|
||||
for [from, to] in std::mem::take(&mut self.unblitted_lines) {
|
||||
self.draw_line_to_texture(from, to, &new_context, ui);
|
||||
}
|
||||
self.unblitted_lines.clear();
|
||||
}
|
||||
|
||||
//painter.add(self.mesh.clone());
|
||||
|
||||
if let Some(texture) = &self.texture {
|
||||
let texture = SizedTexture::new(texture.id(), texture.size_vec2());
|
||||
let shape = RectShape {
|
||||
rect: mesh_rect,
|
||||
corner_radius: CornerRadius::ZERO,
|
||||
fill: Color32::WHITE,
|
||||
stroke: Stroke::NONE,
|
||||
stroke_kind: egui::StrokeKind::Inside,
|
||||
round_to_pixels: None,
|
||||
blur_width: 0.0,
|
||||
brush: Some(Arc::new(Brush {
|
||||
fill_texture_id: texture.id,
|
||||
uv: Rect {
|
||||
min: Pos2::ZERO,
|
||||
max: Pos2::new(1.0, 1.0),
|
||||
},
|
||||
})),
|
||||
};
|
||||
painter.add(shape);
|
||||
}
|
||||
|
||||
response
|
||||
}
|
||||
|
||||
fn refresh_texture(
|
||||
&mut self,
|
||||
style: &HandwritingStyle,
|
||||
mesh_context: MeshContext,
|
||||
ui: &mut Ui,
|
||||
) {
|
||||
self.last_mesh_ctx = Some(mesh_context);
|
||||
|
||||
self.refresh_texture = false;
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
let start_time = std::time::Instant::now();
|
||||
|
||||
let mut tesselator = Tessellator::new(
|
||||
mesh_context.pixels_per_point,
|
||||
TESSELATION_OPTIONS,
|
||||
Default::default(), // we don't tesselate fonts
|
||||
vec![],
|
||||
);
|
||||
|
||||
let mesh = Arc::make_mut(&mut self.mesh);
|
||||
mesh.clear();
|
||||
|
||||
self.strokes
|
||||
.iter()
|
||||
.chain([&self.current_stroke])
|
||||
.filter(|stroke| stroke.len() >= 2)
|
||||
.map(|stroke| {
|
||||
//let points: Vec<Pos2> = stroke.iter().map(|&p| to_screen * p).collect();
|
||||
egui::Shape::line(stroke.clone(), style.stroke)
|
||||
})
|
||||
.for_each(|shape| {
|
||||
tesselator.tessellate_shape(shape, mesh);
|
||||
});
|
||||
|
||||
let texture = texture!(self, ui, &mesh_context);
|
||||
let triangles = mesh_triangles(&self.mesh);
|
||||
|
||||
let [px_x, px_y] = mesh_context.pixel_size();
|
||||
let point_to_pixel = TSTransform::from_scaling(mesh_context.pixels_per_point);
|
||||
self.image = rasterize::<StrokeBlendMode>(px_x, px_y, point_to_pixel, triangles);
|
||||
texture.set(self.image.clone(), Default::default());
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
let elapsed = start_time.elapsed();
|
||||
println!("refreshed mesh in {:.3}s", elapsed.as_secs_f32());
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ui(&mut self, style: &HandwritingStyle, ui: &mut Ui) {
|
||||
ui.vertical_centered_justified(|ui| {
|
||||
self.ui_control(None, ui);
|
||||
|
||||
//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)))
|
||||
.fill(style.bg_color)
|
||||
.show(ui, |ui| {
|
||||
self.ui_content(style, ui);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
fn push_to_stroke(&mut self, new_canvas_pos: Pos2) {
|
||||
if let Some(&last_canvas_pos) = self.current_stroke.last() {
|
||||
if last_canvas_pos == new_canvas_pos {
|
||||
return;
|
||||
}
|
||||
|
||||
self.unblitted_lines.push([last_canvas_pos, new_canvas_pos]);
|
||||
}
|
||||
|
||||
self.current_stroke.push(new_canvas_pos);
|
||||
}
|
||||
|
||||
/// Draw a single line onto the existing texture.
|
||||
fn draw_line_to_texture(
|
||||
&mut self,
|
||||
from: Pos2,
|
||||
to: Pos2,
|
||||
mesh_context: &MeshContext,
|
||||
ui: &mut Ui,
|
||||
) {
|
||||
let mut tesselator = Tessellator::new(
|
||||
mesh_context.pixels_per_point,
|
||||
TESSELATION_OPTIONS,
|
||||
Default::default(), // we don't tesselate fonts
|
||||
vec![],
|
||||
);
|
||||
|
||||
let mut mesh = Mesh::default();
|
||||
let line = egui::Shape::line_segment([from, to], mesh_context.stroke);
|
||||
tesselator.tessellate_shape(line, &mut mesh);
|
||||
|
||||
self.draw_mesh_to_texture(&mesh, mesh_context, ui);
|
||||
}
|
||||
|
||||
/// Draw a single mesh onto the existing texture.
|
||||
fn draw_mesh_to_texture(&mut self, mesh: &Mesh, mesh_context: &MeshContext, ui: &mut Ui) {
|
||||
let triangles = mesh_triangles(mesh);
|
||||
let point_to_pixel = TSTransform::from_scaling(mesh_context.pixels_per_point);
|
||||
rasterize_onto::<StrokeBlendMode>(&mut self.image, point_to_pixel, triangles);
|
||||
texture!(self, ui, mesh_context).set(self.image.clone(), Default::default());
|
||||
}
|
||||
|
||||
pub fn strokes(&self) -> &[Vec<Pos2>] {
|
||||
&self.strokes
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub fn example() -> Self {
|
||||
Handwriting {
|
||||
strokes: vec![
|
||||
vec![
|
||||
Pos2::new(-1.0, 1.0),
|
||||
Pos2::new(3.0, 1.0),
|
||||
Pos2::new(3.0, 3.0),
|
||||
Pos2::new(1.5, 2.0),
|
||||
Pos2::new(0.0, 0.0),
|
||||
],
|
||||
vec![
|
||||
Pos2::new(3.0, 3.0),
|
||||
Pos2::new(-1.0, 1.0),
|
||||
Pos2::new(0.0, 0.0),
|
||||
Pos2::new(3.0, 1.0),
|
||||
],
|
||||
],
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for Handwriting {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let mut raw = vec![];
|
||||
|
||||
for stroke in &self.strokes {
|
||||
raw.push((stroke.len() as u16).to_le_bytes());
|
||||
for position in stroke {
|
||||
let x = half::f16::from_f32(position.x);
|
||||
let y = half::f16::from_f32(position.y);
|
||||
raw.push(x.to_bits().to_le_bytes());
|
||||
raw.push(y.to_bits().to_le_bytes());
|
||||
}
|
||||
}
|
||||
|
||||
let raw = raw.as_slice().as_bytes();
|
||||
|
||||
write_custom_code_block(f, CODE_BLOCK_KEY, BASE64_STANDARD.encode(raw))
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for Handwriting {
|
||||
type Err = eyre::Report;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
let s = try_from_custom_code_block(CODE_BLOCK_KEY, s)
|
||||
.ok_or_eyre("Not a valid ```handwriting-block")?;
|
||||
|
||||
let bytes = BASE64_STANDARD
|
||||
.decode(s)
|
||||
.wrap_err("Failed to decode painting data from base64")?;
|
||||
|
||||
#[allow(non_camel_case_types)]
|
||||
type u16_le = [u8; 2];
|
||||
|
||||
#[allow(non_camel_case_types)]
|
||||
type f16_le = [u8; 2];
|
||||
|
||||
#[derive(FromBytes, KnownLayout, Immutable)]
|
||||
#[repr(C, packed)]
|
||||
struct Stroke {
|
||||
pub len: u16_le,
|
||||
pub positions: [f16_le],
|
||||
}
|
||||
|
||||
let mut bytes = &bytes[..];
|
||||
let mut strokes = vec![];
|
||||
|
||||
while !bytes.is_empty() {
|
||||
let header_len = size_of::<u16_le>();
|
||||
if bytes.len() < header_len {
|
||||
bail!("Invalid remaining length: {}", bytes.len());
|
||||
}
|
||||
|
||||
let stroke = Stroke::ref_from_bytes(&bytes[..header_len]).expect("length is correct");
|
||||
let len = usize::from(u16::from_le_bytes(stroke.len));
|
||||
let len = len * size_of::<f16_le>() * 2;
|
||||
|
||||
if bytes.len() < len {
|
||||
bail!("Invalid remaining length: {}", bytes.len());
|
||||
}
|
||||
|
||||
let (stroke, rest) = bytes.split_at(header_len + len);
|
||||
bytes = rest;
|
||||
let stroke = Stroke::ref_from_bytes(stroke)
|
||||
.map_err(|e| eyre!("Failed to decode stroke bytes: {e}"))?;
|
||||
|
||||
let mut positions = stroke
|
||||
.positions
|
||||
.iter()
|
||||
.map(|&position| f16::from_bits(u16::from_le_bytes(position)));
|
||||
|
||||
let mut stroke = vec![];
|
||||
while let Some(x) = positions.next() {
|
||||
let Some(y) = positions.next() else {
|
||||
unreachable!("len is a multiple of two");
|
||||
};
|
||||
stroke.push(Pos2::new(x.into(), y.into()));
|
||||
}
|
||||
strokes.push(stroke);
|
||||
}
|
||||
|
||||
Ok(Handwriting {
|
||||
strokes,
|
||||
..Default::default()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl HandwritingStyle {
|
||||
pub fn from_theme(theme: Theme) -> Self {
|
||||
let stroke_color;
|
||||
let bg_color;
|
||||
let line_color;
|
||||
|
||||
match theme {
|
||||
Theme::Dark => {
|
||||
stroke_color = Color32::WHITE;
|
||||
bg_color = Color32::from_gray(30);
|
||||
line_color = Color32::from_rgb(100, 100, 100);
|
||||
}
|
||||
Theme::Light => {
|
||||
stroke_color = Color32::BLACK;
|
||||
bg_color = Color32::WHITE;
|
||||
line_color = Color32::from_rgb(130, 130, 130); // TODO
|
||||
}
|
||||
}
|
||||
|
||||
HandwritingStyle {
|
||||
stroke: Stroke::new(1.6, stroke_color),
|
||||
bg_color,
|
||||
bg_line_stroke: Stroke::new(0.5, line_color),
|
||||
animate: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn mesh_triangles(mesh: &Mesh) -> impl Iterator<Item = [&Vertex; 3]> {
|
||||
mesh.triangles()
|
||||
.map(|indices| indices.map(|i| &mesh.vertices[i as usize]))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use std::str::FromStr;
|
||||
|
||||
use super::Handwriting;
|
||||
|
||||
#[test]
|
||||
fn serialize_handwriting() {
|
||||
let handwriting = Handwriting::example();
|
||||
insta::assert_debug_snapshot!("handwriting example", handwriting.strokes);
|
||||
|
||||
let serialized = handwriting.to_string();
|
||||
insta::assert_snapshot!("serialized handwriting", serialized);
|
||||
|
||||
let deserialized =
|
||||
Handwriting::from_str(&serialized).expect("Handwriting must de/serialize correctly");
|
||||
insta::assert_debug_snapshot!("deserialized handwriting", deserialized.strokes);
|
||||
}
|
||||
}
|
||||
72
src/preferences.rs
Normal file
72
src/preferences.rs
Normal file
@ -0,0 +1,72 @@
|
||||
use egui::{Color32, Context, RichText, Theme, Ui, Visuals};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
#[serde(default)]
|
||||
pub struct Preferences {
|
||||
/// Enable animations
|
||||
pub animations: bool,
|
||||
|
||||
/// Enable high-contrast theme
|
||||
pub high_contrast: bool,
|
||||
|
||||
#[serde(skip)]
|
||||
has_applied_theme: bool,
|
||||
}
|
||||
|
||||
impl Default for Preferences {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
animations: true,
|
||||
high_contrast: false,
|
||||
has_applied_theme: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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.high_contrast {
|
||||
// widgets.active: color of headers in textedit
|
||||
// widgets.inactive: color of button labels
|
||||
// widgets.hovered: color of hovered button labels
|
||||
// widgets.noninteractive: color of labels and normal textedit text
|
||||
let mut dark_visuals = Visuals::dark();
|
||||
let mut light_visuals = Visuals::light();
|
||||
|
||||
dark_visuals.widgets.noninteractive.fg_stroke.color = Color32::WHITE;
|
||||
dark_visuals.widgets.inactive.fg_stroke.color = Color32::WHITE;
|
||||
dark_visuals.widgets.hovered.fg_stroke.color = Color32::WHITE;
|
||||
|
||||
light_visuals.widgets.noninteractive.fg_stroke.color = Color32::BLACK;
|
||||
light_visuals.widgets.inactive.fg_stroke.color = Color32::BLACK;
|
||||
light_visuals.widgets.hovered.fg_stroke.color = Color32::BLACK;
|
||||
|
||||
ctx.set_visuals_of(Theme::Dark, dark_visuals);
|
||||
ctx.set_visuals_of(Theme::Light, light_visuals);
|
||||
} else {
|
||||
ctx.set_visuals_of(Theme::Dark, Visuals::dark());
|
||||
ctx.set_visuals_of(Theme::Light, Visuals::light());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Show preference switches
|
||||
pub fn show(&mut self, ui: &mut Ui) {
|
||||
ui.label(RichText::new("Prefs").weak());
|
||||
|
||||
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_theme = false;
|
||||
self.apply(ui.ctx());
|
||||
}
|
||||
|
||||
egui::widgets::global_theme_preference_buttons(ui);
|
||||
}
|
||||
}
|
||||
277
src/rasterizer.rs
Normal file
277
src/rasterizer.rs
Normal file
@ -0,0 +1,277 @@
|
||||
use core::f32;
|
||||
use egui::{Color32, ColorImage, Pos2, Rect, Vec2, emath::TSTransform, epaint::Vertex};
|
||||
|
||||
pub trait BlendFn {
|
||||
fn blend(a: Color32, b: Color32) -> Color32;
|
||||
}
|
||||
|
||||
pub mod blend {
|
||||
pub struct Normal;
|
||||
pub struct Add;
|
||||
pub struct Multiply;
|
||||
}
|
||||
|
||||
/// Rasterize some triangles onto a new image,
|
||||
///
|
||||
/// Triangle positions must be in image-local point-coords.
|
||||
/// `width` and `height` are in pixel coords.
|
||||
pub fn rasterize<'a, Blend: BlendFn>(
|
||||
width: usize,
|
||||
height: usize,
|
||||
point_to_pixel: TSTransform,
|
||||
triangles: impl Iterator<Item = [&'a Vertex; 3]>,
|
||||
) -> ColorImage {
|
||||
let mut image = ColorImage::new([width, height], Color32::TRANSPARENT);
|
||||
rasterize_onto::<Blend>(&mut image, point_to_pixel, triangles);
|
||||
image
|
||||
}
|
||||
|
||||
/// Rasterize some triangles onto an image,
|
||||
///
|
||||
/// Triangle positions must be in image-local point-coords.
|
||||
pub fn rasterize_onto<'a, Blend: BlendFn>(
|
||||
image: &mut ColorImage,
|
||||
point_to_pixel: TSTransform,
|
||||
triangles: impl Iterator<Item = [&'a Vertex; 3]>,
|
||||
) {
|
||||
let width = image.width();
|
||||
let height = image.height();
|
||||
|
||||
let mut set_pixel = |x: usize, y: usize, color| {
|
||||
let pixel = &mut image.pixels[y * width + x];
|
||||
*pixel = Blend::blend(*pixel, color);
|
||||
};
|
||||
|
||||
let image_box = PxBoundingBox {
|
||||
x_from: 0,
|
||||
y_from: 0,
|
||||
x_to: width,
|
||||
y_to: height,
|
||||
};
|
||||
|
||||
let pixel_to_point = point_to_pixel.inverse();
|
||||
|
||||
for triangle in triangles {
|
||||
let [a, b, c] = triangle;
|
||||
if triangle_area(a.pos, b.pos, c.pos) == 0.0 {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check all pixels within the triangle's bounding box.
|
||||
let bounding_box =
|
||||
triangle_bounding_box(&triangle, point_to_pixel).intersection(&image_box);
|
||||
|
||||
// TODO: consider subdividing the triangle if it's very large.
|
||||
let pixels = pixels_in_box(bounding_box);
|
||||
|
||||
for [x, y] in pixels {
|
||||
// Calculate point-coordinate of the pixel
|
||||
let pt_pos = pixel_to_point * Pos2::new(x as f32, y as f32);
|
||||
|
||||
let point_in_triangle = point_in_triangle(pt_pos, triangle);
|
||||
|
||||
// If the pixel is within the triangle, fill it in.
|
||||
if point_in_triangle.inside {
|
||||
let c0 = triangle[0]
|
||||
.color
|
||||
.linear_multiply(point_in_triangle.weights[0]);
|
||||
let c1 = triangle[1]
|
||||
.color
|
||||
.linear_multiply(point_in_triangle.weights[1]);
|
||||
let c2 = triangle[2]
|
||||
.color
|
||||
.linear_multiply(point_in_triangle.weights[2]);
|
||||
|
||||
let color = c0 + c1 + c2;
|
||||
|
||||
set_pixel(x, y, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A bounding box, measured in pixels.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
struct PxBoundingBox {
|
||||
pub x_from: usize,
|
||||
pub y_from: usize,
|
||||
pub x_to: usize,
|
||||
pub y_to: usize,
|
||||
}
|
||||
|
||||
impl PxBoundingBox {
|
||||
pub fn intersection(&self, other: &PxBoundingBox) -> PxBoundingBox {
|
||||
PxBoundingBox {
|
||||
x_from: self.x_from.max(other.x_from),
|
||||
y_from: self.y_from.max(other.y_from),
|
||||
x_to: self.x_to.min(other.x_to),
|
||||
y_to: self.y_to.min(other.y_to),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn triangle_bounding_box(triangle: &[&Vertex; 3], point_to_pixel: TSTransform) -> PxBoundingBox {
|
||||
// calculate bounding box in point coords
|
||||
let mut rect = Rect::NOTHING;
|
||||
for vertex in triangle {
|
||||
rect.min = rect.min.min(vertex.pos);
|
||||
rect.max = rect.max.max(vertex.pos);
|
||||
}
|
||||
|
||||
// convert bounding box to pixel coords
|
||||
let rect = point_to_pixel.mul_rect(rect);
|
||||
PxBoundingBox {
|
||||
x_from: rect.min.x.floor() as usize,
|
||||
y_from: rect.min.y.floor() as usize,
|
||||
x_to: rect.max.x.ceil() as usize,
|
||||
y_to: rect.max.y.ceil() as usize,
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculate the perpendicular vector (90 degrees from the given vector)
|
||||
fn perpendicular(v: Vec2) -> Vec2 {
|
||||
Vec2::new(v.y, -v.x)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct PointInTriangle {
|
||||
/// Is the point inside the triangle?
|
||||
inside: bool,
|
||||
|
||||
/// Normalized weights describing the vicinity between the point and the three verticies of
|
||||
/// thre triangle.
|
||||
weights: [f32; 3],
|
||||
}
|
||||
|
||||
/// Calculate whether a point is within a triangle, and the relative vicinities between the point
|
||||
/// and each triangle vertex. The triangle must have a non-zero area.
|
||||
fn point_in_triangle(point: Pos2, triangle: [&Vertex; 3]) -> PointInTriangle {
|
||||
let [a, b, c] = triangle;
|
||||
|
||||
let sides = [[b, c], [c, a], [a, b]];
|
||||
|
||||
// For each side of the triangle, imagine a new triangle consisting of the side and `point`.
|
||||
// Calculate the areas of those triangles.
|
||||
let areas = sides.map(|[start, end]| signed_triangle_area(start.pos, end.pos, point));
|
||||
|
||||
// Use the areas to determine the side of the line at which the point exists.
|
||||
// If the area is positive, the point is on the right side of the triangle line.
|
||||
let [side_ab, side_bc, side_ca] = areas.map(|area| area >= 0.0);
|
||||
|
||||
// Total area of the traingle.
|
||||
let triangle_area: f32 = areas.iter().sum();
|
||||
|
||||
// egui does not wind the triangles in a consistent order, otherwise we might check if the
|
||||
// point is on a *specific* side of each line. As it is, we just check if the point is on the
|
||||
// same side of each line.
|
||||
let inside = side_ab == side_bc && side_bc == side_ca;
|
||||
|
||||
// Normalize the weights.
|
||||
let weights = areas.map(|area| area / triangle_area);
|
||||
|
||||
PointInTriangle { inside, weights }
|
||||
}
|
||||
|
||||
/// Calculate the area of a triangle.
|
||||
fn triangle_area(a: Pos2, b: Pos2, c: Pos2) -> f32 {
|
||||
signed_triangle_area(a, b, c).abs()
|
||||
}
|
||||
|
||||
/// Calculate the area of a triangle.
|
||||
///
|
||||
/// The area will be positive if the triangle is wound clockwise, and negative otherwise.
|
||||
fn signed_triangle_area(a: Pos2, b: Pos2, c: Pos2) -> f32 {
|
||||
// Vector of an arbitrary "base" side of the triangle.
|
||||
let base = c - a;
|
||||
let base_perp = perpendicular(base);
|
||||
let diagonal = c - b;
|
||||
base_perp.dot(diagonal) / 2.0
|
||||
}
|
||||
|
||||
/// Iterate over every pixel coordinate in a box.
|
||||
#[inline(always)]
|
||||
fn pixels_in_box(
|
||||
PxBoundingBox {
|
||||
x_from,
|
||||
y_from,
|
||||
x_to,
|
||||
y_to,
|
||||
}: PxBoundingBox,
|
||||
) -> impl ExactSizeIterator<Item = [usize; 2]> {
|
||||
struct IterWithLen<I>(I, usize);
|
||||
impl<I: Iterator> ExactSizeIterator for IterWithLen<I> {}
|
||||
impl<I: Iterator> Iterator for IterWithLen<I> {
|
||||
type Item = I::Item;
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(self.1, Some(self.1))
|
||||
}
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.0.next()
|
||||
}
|
||||
}
|
||||
|
||||
let len = (x_from..x_to).len() * (y_from..y_to).len();
|
||||
let iter = (x_from..x_to).flat_map(move |x| (y_from..y_to).map(move |y| [x, y]));
|
||||
|
||||
debug_assert_eq!(len, iter.clone().count());
|
||||
|
||||
IterWithLen(iter, len)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use egui::{Color32, Pos2, Vec2, emath::TSTransform, epaint::Vertex};
|
||||
|
||||
use super::triangle_bounding_box;
|
||||
|
||||
#[test]
|
||||
fn px_bounding_box() {
|
||||
let triangle = [
|
||||
Vertex {
|
||||
pos: Pos2::new(56.3, 18.9),
|
||||
uv: Default::default(),
|
||||
color: Color32::WHITE,
|
||||
},
|
||||
Vertex {
|
||||
pos: Pos2::new(56.4, 19.6),
|
||||
uv: Default::default(),
|
||||
color: Color32::WHITE,
|
||||
},
|
||||
Vertex {
|
||||
pos: Pos2::new(55.8, 20.5),
|
||||
uv: Default::default(),
|
||||
color: Color32::WHITE,
|
||||
},
|
||||
];
|
||||
|
||||
let pixels_per_point = 2.0;
|
||||
let point_to_pixel = TSTransform {
|
||||
scaling: pixels_per_point,
|
||||
translation: Vec2::new(-55.8, -18.9) * pixels_per_point,
|
||||
};
|
||||
|
||||
let bounding_box = triangle_bounding_box(&triangle.each_ref(), point_to_pixel);
|
||||
|
||||
insta::assert_debug_snapshot!((triangle, point_to_pixel, bounding_box));
|
||||
}
|
||||
}
|
||||
|
||||
impl BlendFn for blend::Normal {
|
||||
fn blend(a: Color32, b: Color32) -> Color32 {
|
||||
a.blend(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl BlendFn for blend::Add {
|
||||
fn blend(a: Color32, b: Color32) -> Color32 {
|
||||
a + b
|
||||
}
|
||||
}
|
||||
|
||||
impl BlendFn for blend::Multiply {
|
||||
fn blend(a: Color32, b: Color32) -> Color32 {
|
||||
a * b
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,44 @@
|
||||
---
|
||||
source: src/custom_code_block.rs
|
||||
assertion_line: 133
|
||||
expression: list
|
||||
---
|
||||
[
|
||||
Line(
|
||||
"\n",
|
||||
),
|
||||
Line(
|
||||
"# Hello world\n",
|
||||
),
|
||||
Line(
|
||||
"## Subheader\n",
|
||||
),
|
||||
Line(
|
||||
"- 1\n",
|
||||
),
|
||||
CodeBlock {
|
||||
key: "foo",
|
||||
content: " whatever\n some code\n Hi mom!",
|
||||
span: "```foo\n whatever\n some code\n Hi mom!\n```",
|
||||
},
|
||||
Line(
|
||||
" \n",
|
||||
),
|
||||
Line(
|
||||
"\n",
|
||||
),
|
||||
CodeBlock {
|
||||
key: "` # wrong number of ticks, but that's ok",
|
||||
content: " ``` # indented ticks",
|
||||
span: "```` # wrong number of ticks, but that's ok\n ``` # indented ticks\n```\n",
|
||||
},
|
||||
Line(
|
||||
"\n",
|
||||
),
|
||||
Line(
|
||||
"``` # no closing ticks\n",
|
||||
),
|
||||
Line(
|
||||
" ",
|
||||
),
|
||||
]
|
||||
@ -0,0 +1,18 @@
|
||||
---
|
||||
source: src/custom_code_block.rs
|
||||
expression: markdown
|
||||
---
|
||||
# Hello world
|
||||
## Subheader
|
||||
- 1
|
||||
```foo
|
||||
whatever
|
||||
some code
|
||||
Hi mom!
|
||||
```
|
||||
|
||||
```` # wrong number of ticks, but that's ok
|
||||
``` # indented ticks
|
||||
```
|
||||
|
||||
``` # no closing ticks
|
||||
19
src/snapshots/inkr__painting__test__handwriting example.snap
Normal file
19
src/snapshots/inkr__painting__test__handwriting example.snap
Normal file
@ -0,0 +1,19 @@
|
||||
---
|
||||
source: src/painting.rs
|
||||
expression: handwriting.strokes
|
||||
---
|
||||
[
|
||||
[
|
||||
[-1.0 1.0],
|
||||
[3.0 1.0],
|
||||
[3.0 3.0],
|
||||
[1.5 2.0],
|
||||
[0.0 0.0],
|
||||
],
|
||||
[
|
||||
[3.0 3.0],
|
||||
[-1.0 1.0],
|
||||
[0.0 0.0],
|
||||
[3.0 1.0],
|
||||
],
|
||||
]
|
||||
@ -0,0 +1,8 @@
|
||||
---
|
||||
source: src/painting.rs
|
||||
assertion_line: 695
|
||||
expression: serialized
|
||||
---
|
||||
```handwriting
|
||||
BQAAvAA8AEIAPABCAEIAPgBAAAAAAAQAAEIAQgC8ADwAAAAAAEIAPA==
|
||||
```
|
||||
33
src/snapshots/inkr__rasterizer__test__px_bounding_box.snap
Normal file
33
src/snapshots/inkr__rasterizer__test__px_bounding_box.snap
Normal file
@ -0,0 +1,33 @@
|
||||
---
|
||||
source: src/rasterizer.rs
|
||||
expression: "(triangle, point_to_pixel, bounding_box)"
|
||||
---
|
||||
(
|
||||
[
|
||||
Vertex {
|
||||
pos: [56.3 18.9],
|
||||
uv: [0.0 0.0],
|
||||
color: #FF_FF_FF_FF,
|
||||
},
|
||||
Vertex {
|
||||
pos: [56.4 19.6],
|
||||
uv: [0.0 0.0],
|
||||
color: #FF_FF_FF_FF,
|
||||
},
|
||||
Vertex {
|
||||
pos: [55.8 20.5],
|
||||
uv: [0.0 0.0],
|
||||
color: #FF_FF_FF_FF,
|
||||
},
|
||||
],
|
||||
TSTransform {
|
||||
scaling: 2.0,
|
||||
translation: [-111.6 -37.8],
|
||||
},
|
||||
PxBoundingBox {
|
||||
x_from: 0,
|
||||
y_from: 0,
|
||||
x_to: 2,
|
||||
y_to: 4,
|
||||
},
|
||||
)
|
||||
125
src/text_editor.rs
Normal file
125
src/text_editor.rs
Normal file
@ -0,0 +1,125 @@
|
||||
use std::{
|
||||
convert::Infallible,
|
||||
fmt::{self, Display},
|
||||
iter::repeat_n,
|
||||
};
|
||||
|
||||
use egui::{
|
||||
Color32, InputState, Key, Modifiers, TextBuffer, TextEdit, Ui, Vec2, text::CCursorRange,
|
||||
};
|
||||
|
||||
use crate::markdown::MemoizedHighlighter;
|
||||
|
||||
#[derive(Default, serde::Deserialize, serde::Serialize)]
|
||||
pub struct MdTextEdit {
|
||||
pub text: String,
|
||||
|
||||
#[serde(skip)]
|
||||
highlighter: MemoizedHighlighter,
|
||||
|
||||
#[serde(skip)]
|
||||
focused: bool,
|
||||
|
||||
#[serde(skip)]
|
||||
cursor: Option<CCursorRange>,
|
||||
}
|
||||
|
||||
impl MdTextEdit {
|
||||
pub fn new() -> Self {
|
||||
MdTextEdit::default()
|
||||
}
|
||||
|
||||
pub fn from_text(text: String) -> Self {
|
||||
MdTextEdit {
|
||||
text,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ui(&mut self, ui: &mut Ui) {
|
||||
let Self {
|
||||
text,
|
||||
highlighter,
|
||||
focused,
|
||||
cursor,
|
||||
} = self;
|
||||
|
||||
let w = ui.available_width();
|
||||
|
||||
let mut layouter = |ui: &egui::Ui, markdown: &dyn TextBuffer, _wrap_width: f32| {
|
||||
let mut layout_job = highlighter.highlight(ui.style(), markdown.as_str(), *cursor);
|
||||
layout_job.wrap.max_width = w - 10.0;
|
||||
ui.fonts(|f| f.layout_job(layout_job))
|
||||
};
|
||||
|
||||
if *focused {
|
||||
ui.input_mut(|input| {
|
||||
handle_tab_input(text, input, *cursor);
|
||||
});
|
||||
}
|
||||
|
||||
let text_edit = TextEdit::multiline(text)
|
||||
.layouter(&mut layouter)
|
||||
.background_color(Color32::TRANSPARENT)
|
||||
.desired_rows(1)
|
||||
.min_size(Vec2::new(w, 0.0))
|
||||
.lock_focus(true)
|
||||
.show(ui);
|
||||
|
||||
*focused = text_edit.response.has_focus();
|
||||
|
||||
if *cursor != text_edit.cursor_range {
|
||||
*cursor = text_edit.cursor_range;
|
||||
//ui.ctx().request_repaint();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_tab_input(
|
||||
text: &mut String,
|
||||
input: &mut InputState,
|
||||
cursor: Option<CCursorRange>,
|
||||
) -> Option<Infallible> {
|
||||
let break_if_not = || ();
|
||||
let cursor = cursor.and_then(|c| c.single())?;
|
||||
|
||||
let do_unindent = input.consume_key(Modifiers::SHIFT, Key::Tab);
|
||||
let do_indent = input.consume_key(Modifiers::NONE, Key::Tab);
|
||||
|
||||
(do_unindent || do_indent).then(break_if_not)?;
|
||||
|
||||
let row_n = text
|
||||
.chars()
|
||||
.take(cursor.index)
|
||||
.filter(|&c| c == '\n')
|
||||
.count();
|
||||
|
||||
let row = text.lines().nth(row_n)?;
|
||||
let (indent, content) = row.split_once("- ")?;
|
||||
indent.trim().is_empty().then(break_if_not)?;
|
||||
|
||||
let indents = indent.chars().count() / 2;
|
||||
let indents = if do_indent {
|
||||
indents + 1
|
||||
} else if indents == 0 {
|
||||
return None;
|
||||
} else {
|
||||
indents.saturating_sub(1)
|
||||
};
|
||||
*text = text
|
||||
.lines()
|
||||
.take(row_n)
|
||||
.flat_map(|line| [line, "\n"])
|
||||
.chain(repeat_n(" ", indents))
|
||||
.chain([format!("- {content}\n").as_str()])
|
||||
.chain(text.lines().skip(row_n + 1).flat_map(|line| [line, "\n"]))
|
||||
.collect();
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
impl Display for MdTextEdit {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}", self.text)
|
||||
}
|
||||
}
|
||||
30
src/util.rs
Normal file
30
src/util.rs
Normal file
@ -0,0 +1,30 @@
|
||||
use std::sync::mpsc;
|
||||
|
||||
use egui::Id;
|
||||
use rand::{Rng, rng};
|
||||
|
||||
pub fn random_id() -> Id {
|
||||
Id::new(rng().random::<u64>())
|
||||
}
|
||||
|
||||
/// An [mpsc::Sender] where the receiver is the GUI.
|
||||
#[derive(Clone)]
|
||||
pub struct GuiSender<T> {
|
||||
tx: mpsc::Sender<T>,
|
||||
ctx: egui::Context,
|
||||
}
|
||||
|
||||
impl<T> GuiSender<T> {
|
||||
pub fn new(tx: mpsc::Sender<T>, ctx: &egui::Context) -> Self {
|
||||
Self {
|
||||
tx,
|
||||
ctx: ctx.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn send(&self, t: T) -> Result<(), mpsc::SendError<T>> {
|
||||
self.tx.send(t)?;
|
||||
self.ctx.request_repaint();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user