mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-21 20:40:02 +00:00
Compare commits
12
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
29e17181bf | ||
|
|
b3d11070e4 | ||
|
|
155fd45d61 | ||
|
|
0bc69feed0 | ||
|
|
7b525189c0 | ||
|
|
13de76e5b2 | ||
|
|
a009f7d022 | ||
|
|
ca6c100342 | ||
|
|
072ec4500a | ||
|
|
58a13b5a64 | ||
|
|
281f86d602 | ||
|
|
caaa0e37f7 |
Generated
+33
@@ -746,6 +746,7 @@ version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-geom",
|
||||
"craft-dxf",
|
||||
"craft-font-catalog",
|
||||
"craft-shx",
|
||||
"encoding_rs",
|
||||
"harfrust 0.14.0",
|
||||
@@ -829,6 +830,7 @@ dependencies = [
|
||||
"cadcraft-io",
|
||||
"cadcraft-render",
|
||||
"chrono",
|
||||
"craft-image-codecs",
|
||||
"craft-ui",
|
||||
"craft-update",
|
||||
"craft-window",
|
||||
@@ -1205,6 +1207,16 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-font-catalog"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c07e38090879ffa994f893df9956c6d5b96c049c#c07e38090879ffa994f893df9956c6d5b96c049c"
|
||||
dependencies = [
|
||||
"skrifa 0.47.0",
|
||||
"thiserror 2.0.21",
|
||||
"windows-registry",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-fonts-build"
|
||||
version = "0.1.0"
|
||||
@@ -4172,6 +4184,17 @@ dependencies = [
|
||||
"once_cell",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "read-fonts"
|
||||
version = "0.44.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d5a0cf4bb6cbce4c29756270d189a5e400ac05e91192161d83a0bcb6e68492e8"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"font-types 0.12.7",
|
||||
"once_cell",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "read-fonts"
|
||||
version = "0.45.1"
|
||||
@@ -4636,6 +4659,16 @@ dependencies = [
|
||||
"read-fonts 0.41.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "skrifa"
|
||||
version = "0.47.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "526e654b303ff4ad73a5a40b25de2b3ce3d039c5e3b6da5f89ae6e57004cb40f"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"read-fonts 0.44.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "skrifa"
|
||||
version = "0.48.0"
|
||||
|
||||
@@ -35,6 +35,8 @@ craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-l
|
||||
# PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin
|
||||
# craft-pdf's patched backends to the same revision (Cargo ignores dependency-local patches).
|
||||
craft-pdf = { version = "=0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", default-features = false }
|
||||
# TrueType embedding-permission classification for plotted fonts (craft-libs#778).
|
||||
craft-font-catalog = { git = "https://github.com/storytold/craft-libs", rev = "c07e38090879ffa994f893df9956c6d5b96c049c", default-features = false }
|
||||
clap = { version = "4", features = ["derive", "env"] }
|
||||
clap_complete = "4.6.11"
|
||||
clap_mangen = { version = "0.3.3", features = ["env"] }
|
||||
|
||||
@@ -363,7 +363,7 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let (a, b) = (screen(Vec2::new(min.x, max.y)), screen(Vec2::new(max.x, min.y)));
|
||||
cadcraft_render::raster::blank_outside_pixels(&mut pm, a, b);
|
||||
}
|
||||
let png = pm.encode_png().map_err(|_| bad("preview", "rendering the preview failed"))?;
|
||||
let png = cadcraft_render::raster::encode_png(&pm).ok_or_else(|| bad("preview", "rendering the preview failed"))?;
|
||||
let layout = space.tab_name();
|
||||
Ok(json!({ "data": base64_encode(&png), "width": w, "height": h, "layout": layout, "paper": page.paper, "landscape": page.landscape }))
|
||||
}
|
||||
|
||||
@@ -11,6 +11,7 @@ workspace = true
|
||||
[dependencies]
|
||||
cadcraft-geom = { workspace = true }
|
||||
craft-dxf = { workspace = true }
|
||||
craft-font-catalog = { workspace = true }
|
||||
craft-shx = { workspace = true }
|
||||
skrifa = { workspace = true }
|
||||
harfrust = { workspace = true }
|
||||
|
||||
@@ -3,50 +3,14 @@
|
||||
//! never embedded; callers draw their text as outlines instead. Fonts without TrueType outlines
|
||||
//! (CFF-flavoured OpenType) aren't embedded either.
|
||||
|
||||
use skrifa::FontRef;
|
||||
use skrifa::raw::types::Tag;
|
||||
|
||||
use crate::ttf::Face;
|
||||
|
||||
/// Whether a face may be embedded as a subset.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Embedding {
|
||||
/// Installable, editable or preview & print embedding (or no OS/2 table).
|
||||
Allowed,
|
||||
/// `fsType` restricted licence: no embedding.
|
||||
Restricted,
|
||||
/// `fsType` bit 8: the font may only be embedded whole.
|
||||
NoSubsetting,
|
||||
/// `fsType` bit 9: only bitmaps may be embedded.
|
||||
BitmapOnly,
|
||||
/// No TrueType outlines (`glyf` / `loca`), or the font doesn't parse.
|
||||
NotTrueType,
|
||||
}
|
||||
|
||||
fn table<'a>(f: &FontRef<'a>, t: [u8; 4]) -> Option<&'a [u8]> {
|
||||
f.table_data(Tag::new(&t)).map(|d| d.as_bytes())
|
||||
}
|
||||
|
||||
fn u16_at(b: &[u8], i: usize) -> Option<u16> {
|
||||
Some(u16::from_be_bytes([*b.get(i)?, *b.get(i + 1)?]))
|
||||
}
|
||||
pub use craft_font_catalog::SubsetEmbedding as Embedding;
|
||||
|
||||
/// The embedding permission of a face.
|
||||
pub fn embedding(face: &Face) -> Embedding {
|
||||
let Ok(f) = FontRef::from_index(&face.bytes, face.index) else { return Embedding::NotTrueType };
|
||||
if table(&f, *b"glyf").is_none() || table(&f, *b"loca").is_none() || table(&f, *b"head").is_none() {
|
||||
return Embedding::NotTrueType;
|
||||
}
|
||||
let Some(fs_type) = table(&f, *b"OS/2").and_then(|o| u16_at(o, 8)) else { return Embedding::Allowed };
|
||||
if fs_type & 0x0200 != 0 {
|
||||
Embedding::BitmapOnly
|
||||
} else if fs_type & 0x000F == 0x0002 {
|
||||
Embedding::Restricted
|
||||
} else if fs_type & 0x0100 != 0 {
|
||||
Embedding::NoSubsetting
|
||||
} else {
|
||||
Embedding::Allowed
|
||||
}
|
||||
craft_font_catalog::subset_embedding(&face.bytes, face.index)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
+2
-12
@@ -4,7 +4,7 @@
|
||||
|
||||
use crate::{IoError, Result};
|
||||
use cadcraft_doc::Raster;
|
||||
use craft_image_codecs::{ChannelLayout, DecodeOptions, DecodeWarning, EncodeOptions, Format, Image, Limits, PngRows, SampleType};
|
||||
use craft_image_codecs::{ChannelLayout, DecodeOptions, DecodeWarning, Format, Limits, SampleType};
|
||||
|
||||
/// Largest image file read (bytes).
|
||||
pub const MAX_IMAGE_BYTES: usize = 256 << 20;
|
||||
@@ -61,17 +61,7 @@ pub fn decode(bytes: &[u8]) -> Result<Raster> {
|
||||
|
||||
/// `raster` as a PNG file, encoded in rows to avoid a full extra image copy.
|
||||
pub fn encode_png(raster: &Raster) -> Result<Vec<u8>> {
|
||||
let stride = usize::try_from(raster.width()).ok().and_then(|w| w.checked_mul(4)).filter(|s| *s > 0).ok_or_else(|| bad("invalid image width"))?;
|
||||
let mut chunks = raster.rgba().chunks_exact(stride);
|
||||
let first = chunks.next().ok_or_else(|| bad("the image is empty"))?;
|
||||
let row = |data: &[u8]| Image::from_u8(raster.width(), 1, ChannelLayout::Rgba, data.to_vec()).map_err(bad);
|
||||
let first = row(first)?;
|
||||
let mut out = Vec::new();
|
||||
let mut writer = PngRows::new(&mut out, &first, raster.height(), &EncodeOptions::default()).map_err(bad)?;
|
||||
writer.push(&first).map_err(bad)?;
|
||||
for chunk in chunks {
|
||||
writer.push(&row(chunk)?).map_err(bad)?;
|
||||
}
|
||||
writer.finish().map_err(bad)?;
|
||||
cadcraft_render::raster::write_rgba_png(&mut out, raster.width(), raster.height(), raster.rgba()).ok_or_else(|| bad("PNG encoding failed"))?;
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
@@ -354,6 +354,25 @@ fn premultiplied(r: &cadcraft_doc::Raster) -> Option<Pixmap> {
|
||||
Pixmap::from_vec(data, tiny_skia::IntSize::from_wh(r.width(), r.height())?)
|
||||
}
|
||||
|
||||
/// Write straight-alpha RGBA8 pixels as PNG a row at a time.
|
||||
pub fn write_rgba_png(mut output: impl std::io::Write, width: u32, height: u32, pixels: &[u8]) -> Option<()> {
|
||||
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
|
||||
let stride = usize::try_from(width).ok()?.checked_mul(4).filter(|n| *n > 0)?;
|
||||
let expected = stride.checked_mul(usize::try_from(height).ok()?)?;
|
||||
if height == 0 || pixels.len() != expected {
|
||||
return None;
|
||||
}
|
||||
let mut rows = pixels.chunks_exact(stride);
|
||||
let row = |data: &[u8]| Image::from_u8(width, 1, ChannelLayout::Rgba, data.to_vec()).ok();
|
||||
let first = row(rows.next()?)?;
|
||||
let mut encoder = PngRows::new(&mut output, &first, height, &EncodeOptions::default()).ok()?;
|
||||
encoder.push(&first).ok()?;
|
||||
for data in rows {
|
||||
encoder.push(&row(data)?).ok()?;
|
||||
}
|
||||
encoder.finish().ok()
|
||||
}
|
||||
|
||||
/// Encode a premultiplied pixmap as PNG without a second full-frame copy.
|
||||
pub fn encode_png(pixmap: &Pixmap) -> Option<Vec<u8>> {
|
||||
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
|
||||
|
||||
@@ -16,6 +16,8 @@ cadcraft-color = { workspace = true }
|
||||
cadcraft-doc = { workspace = true }
|
||||
cadcraft-render = { workspace = true }
|
||||
cadcraft-engine = { workspace = true }
|
||||
cadcraft-io = { workspace = true }
|
||||
craft-image-codecs = { workspace = true }
|
||||
cadcraft-fonts = { workspace = true }
|
||||
craft-window = { workspace = true }
|
||||
egui = { workspace = true }
|
||||
@@ -40,8 +42,6 @@ craft-ui = { workspace = true, features = ["native-windows"] }
|
||||
egui_kittest = { workspace = true, features = ["wgpu", "snapshot"] }
|
||||
# Validates the canvas WGSL and its GLSL ES 3.0 (WebGL2) translation in tests (same naga wgpu uses).
|
||||
naga = { version = "30", features = ["wgsl-in", "glsl-out"] }
|
||||
# Reads the synthetic dynamic-block fixture of the io tests for the dynamic grips tests.
|
||||
cadcraft-io = { workspace = true }
|
||||
|
||||
[build-dependencies]
|
||||
serde_json = { workspace = true }
|
||||
|
||||
@@ -691,6 +691,29 @@ impl Drop for PathlessShots {
|
||||
}
|
||||
}
|
||||
|
||||
fn write_screenshot_png(img: &image::RgbaImage, output: impl std::io::Write) -> std::io::Result<()> {
|
||||
cadcraft_render::raster::write_rgba_png(output, img.width(), img.height(), img.as_raw())
|
||||
.ok_or_else(|| std::io::Error::other("PNG encoding failed"))
|
||||
}
|
||||
|
||||
fn save_explicit_screenshot(img: &image::RgbaImage, path: &str) -> std::io::Result<()> {
|
||||
use craft_image_codecs::{ChannelLayout, EncodeOptions, Format, Image};
|
||||
let format = match image::ImageFormat::from_path(path).map_err(std::io::Error::other)? {
|
||||
image::ImageFormat::Png => Format::Png,
|
||||
image::ImageFormat::Jpeg => Format::Jpeg,
|
||||
image::ImageFormat::Bmp => Format::Bmp,
|
||||
image::ImageFormat::Tiff => Format::Tiff,
|
||||
_ => return Err(std::io::Error::other("unsupported screenshot format")),
|
||||
};
|
||||
if format == Format::Png {
|
||||
return write_screenshot_png(img, std::fs::File::create(path)?);
|
||||
}
|
||||
let pixels = Image::from_u8(img.width(), img.height(), ChannelLayout::Rgba, img.as_raw().clone()).map_err(std::io::Error::other)?;
|
||||
let opts = EncodeOptions { jpeg_quality: 75, jpeg_chroma_subsampling: false, ..EncodeOptions::default() };
|
||||
let bytes = craft_image_codecs::encode(&pixels, format, &opts).map_err(std::io::Error::other)?;
|
||||
std::fs::write(path, bytes)
|
||||
}
|
||||
|
||||
/// Save a pathless screenshot into the private per-process directory: re-validate or recreate it as an owner-only real directory (0700 on Unix; plain create elsewhere), then create up to 64 exclusive files (0600 on Unix) and write a PNG.
|
||||
fn save_pathless_screenshot(img: &image::RgbaImage, token: u64) -> std::io::Result<std::path::PathBuf> {
|
||||
use std::io::Write as _;
|
||||
@@ -713,7 +736,7 @@ fn save_pathless_screenshot(img: &image::RgbaImage, token: u64) -> std::io::Resu
|
||||
let path = dir.join(format!("cadcraft-shot-{token}-{}.png", next_pathless_nonce()));
|
||||
match create_private_file(&path) {
|
||||
Ok(mut file) => {
|
||||
let written = img.write_to(&mut file, image::ImageFormat::Png).map_err(std::io::Error::other).and_then(|()| file.flush());
|
||||
let written = write_screenshot_png(img, &mut file).and_then(|()| file.flush());
|
||||
if let Err(e) = written {
|
||||
// The reply carries no path on failure, so nobody else could remove the partial file.
|
||||
drop(file);
|
||||
@@ -752,7 +775,7 @@ pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>, token: u64)
|
||||
return inline_screenshot(&img, token);
|
||||
}
|
||||
let saved = match path {
|
||||
Some(path) => img.save(path).map(|()| path.to_string()).map_err(std::io::Error::other),
|
||||
Some(path) => save_explicit_screenshot(&img, path).map(|()| path.to_string()),
|
||||
None => save_pathless_screenshot(&img, token).map(|path| path.to_string_lossy().into_owned()),
|
||||
};
|
||||
match saved {
|
||||
@@ -766,7 +789,7 @@ pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>, token: u64)
|
||||
fn inline_screenshot(img: &image::RgbaImage, token: u64) -> Value {
|
||||
let (w, h) = img.dimensions();
|
||||
let mut png = Vec::new();
|
||||
if let Err(e) = img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png) {
|
||||
if let Err(e) = write_screenshot_png(img, &mut png) {
|
||||
return json!({"ok": false, "error": e.to_string(), "request": token});
|
||||
}
|
||||
json!({"ok": true, "request": token, "result": {"pngBase64": cadcraft_engine::cmd::file::base64_encode(&png), "width": w, "height": h, "bytes": png.len()}})
|
||||
@@ -776,6 +799,25 @@ fn inline_screenshot(img: &image::RgbaImage, token: u64) -> Value {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn explicit_screenshot_retains_supported_file_formats() {
|
||||
let img = image::RgbaImage::from_pixel(3, 2, image::Rgba([10, 20, 30, 128]));
|
||||
for ext in ["png", "bmp", "tiff", "jpg"] {
|
||||
let path = std::env::temp_dir().join(format!("cadcraft-format-{}-{}.{}", std::process::id(), next_pathless_nonce(), ext));
|
||||
let name = path.to_string_lossy().to_string();
|
||||
save_explicit_screenshot(&img, &name).unwrap();
|
||||
let decoded = image::open(&path).unwrap().to_rgba8();
|
||||
assert_eq!(decoded.dimensions(), img.dimensions(), "{ext}");
|
||||
if ext != "jpg" {
|
||||
let mut original = std::io::Cursor::new(Vec::new());
|
||||
img.write_to(&mut original, image::ImageFormat::from_path(&path).unwrap()).unwrap();
|
||||
let original = image::load_from_memory(&original.into_inner()).unwrap().to_rgba8();
|
||||
assert_eq!(decoded.as_raw(), original.as_raw(), "{ext}");
|
||||
}
|
||||
std::fs::remove_file(path).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_inline_screenshot_carries_the_png_and_its_size() {
|
||||
let img = image::RgbaImage::from_pixel(3, 2, image::Rgba([10, 20, 30, 255]));
|
||||
|
||||
@@ -70,16 +70,12 @@ fn render(app: &mut CadApp, ctx: &egui::Context) -> Result<(TextureHandle, Strin
|
||||
if let Some(f) = ctx.data(|d| d.get_temp::<FromPlot>(egui::Id::unique(FROM_PLOT))) {
|
||||
let r = app.session.execute("plot", &f.params).map_err(|e| e.to_string())?;
|
||||
let png = r["data"].as_str().and_then(cadcraft_engine::cmd::file::base64_decode).ok_or("the preview has no image")?;
|
||||
let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).map_err(|e| e.to_string())?.to_rgba8();
|
||||
let size = [img.width() as usize, img.height() as usize];
|
||||
let tex = ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.as_raw()), egui::TextureOptions::LINEAR);
|
||||
let tex = preview_texture(ctx, &png)?;
|
||||
return Ok((tex, f.info));
|
||||
}
|
||||
let r = app.session.execute("preview", &json!({ "width": 1600 })).map_err(|e| e.to_string())?;
|
||||
let png = r["data"].as_str().and_then(cadcraft_engine::cmd::file::base64_decode).ok_or("the preview has no image")?;
|
||||
let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).map_err(|e| e.to_string())?.to_rgba8();
|
||||
let size = [img.width() as usize, img.height() as usize];
|
||||
let tex = ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.as_raw()), egui::TextureOptions::LINEAR);
|
||||
let tex = preview_texture(ctx, &png)?;
|
||||
let mut info = format!("{} · {}", r["layout"].as_str().unwrap_or(""), r["paper"].as_str().unwrap_or(""));
|
||||
if r["landscape"].as_bool() == Some(true) {
|
||||
info.push_str(" · landscape");
|
||||
@@ -87,6 +83,15 @@ fn render(app: &mut CadApp, ctx: &egui::Context) -> Result<(TextureHandle, Strin
|
||||
Ok((tex, info))
|
||||
}
|
||||
|
||||
fn preview_texture(ctx: &egui::Context, png: &[u8]) -> Result<TextureHandle, String> {
|
||||
if !png.starts_with(b"\x89PNG\r\n\x1a\n") {
|
||||
return Err("the preview is not a PNG".into());
|
||||
}
|
||||
let img = cadcraft_io::raster::decode(png).map_err(|e| e.to_string())?;
|
||||
let size = [img.width() as usize, img.height() as usize];
|
||||
Ok(ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.rgba()), egui::TextureOptions::LINEAR))
|
||||
}
|
||||
|
||||
/// The Plot Preview window: the sheet as it plots, with Print and Close.
|
||||
pub fn dialog(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
|
||||
let id = egui::Id::unique("cc_plot_preview");
|
||||
@@ -169,6 +174,16 @@ mod tests {
|
||||
(CadApp::new(Session::new(), services), asked)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plot_preview_reads_shared_png_and_rejects_other_bytes() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut png = Vec::new();
|
||||
cadcraft_render::raster::write_rgba_png(&mut png, 1, 1, &[10, 20, 30, 255]).unwrap();
|
||||
let texture = super::preview_texture(&ctx, &png).unwrap();
|
||||
assert_eq!(texture.size(), [1, 1]);
|
||||
assert!(super::preview_texture(&ctx, b"not a PNG").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_and_menu_commands_ask_json_calls_never_do() {
|
||||
let (mut app, asked) = app();
|
||||
|
||||
Reference in New Issue
Block a user