mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-22 10:23:16 +01:00
Merge main into fix/transform-copies-raster-effects-each
This commit is contained in:
commit
e5eaf31b4d
52 files changed
+1358
-189
No files matched your search
+2
-2
@@ -102,14 +102,14 @@ Weights, evidence and the missing items per area: [target-app-parity.md](docs/ta
|
||||
| Arabic | `ar` | none (no right-to-left interface) | 0% |
|
||||
| French | `fr` | full | 100% |
|
||||
| Portuguese (Brazil) | `pt-br` | full | 100% |
|
||||
| Indonesian | `id` | none | 0% |
|
||||
| Indonesian | `id` | 6,947 catalog rows; status and error messages partial | most dialogs and tooltips |
|
||||
| Japanese | `ja` | full | 100% |
|
||||
| German | `de` | full | 98% |
|
||||
| Korean | `ko` | full | 100% |
|
||||
| Bosnian | `bs` | full (AI-assisted, native review pending) | 100% |
|
||||
| Vietnamese | `vi` | full | 100% |
|
||||
|
||||
Also shipped: Traditional Chinese (partial, 80%), Bulgarian, Finnish, Greek, Hungarian, Italian, Polish, Russian, Swedish, Ukrainian and Georgian (full), Catalan (full; AI-drafted, native review welcome), Czech (catalog complete; render-site gaps reduced; native review pending).
|
||||
Also shipped: Traditional Chinese (partial, 80%), Bulgarian, Finnish, Greek, Hungarian, Italian, Polish, Russian, Swedish, Ukrainian, Georgian, Dutch, Danish and Turkish (full), Catalan (full; AI-drafted, native review welcome), Czech (catalog complete; render-site gaps reduced; native review pending).
|
||||
The Georgian catalog has had a native speaker's review; no other catalog has. Details: [localization-parity.md](docs/localization-parity.md).
|
||||
|
||||
## Upcoming
|
||||
|
||||
@@ -155,6 +155,12 @@ fn copied_file(paths: Vec<PathBuf>, mimes: &[&'static str]) -> Option<Flavour> {
|
||||
copied_file_within(paths, mimes, MAX_BYTES)
|
||||
}
|
||||
|
||||
/// Whether a paste of one of `mimes` can take a copied file: one of them is not text.
|
||||
#[cfg_attr(windows, allow(dead_code))]
|
||||
fn takes_files(mimes: &[&'static str]) -> bool {
|
||||
mimes.iter().any(|&m| m != TEXT)
|
||||
}
|
||||
|
||||
/// [`copied_file`] with a file of more than `limit` bytes skipped.
|
||||
fn copied_file_within(paths: Vec<PathBuf>, mimes: &[&'static str], limit: usize) -> Option<Flavour> {
|
||||
paths.into_iter().find_map(|path| {
|
||||
@@ -727,7 +733,7 @@ mod portable {
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use super::{BITMAP, ClipboardRead, Flavour, PNG, SystemClipboard, TEXT, copied_file, decode_png, png_flavour, text_of};
|
||||
use super::{BITMAP, ClipboardRead, Flavour, PNG, SystemClipboard, TEXT, copied_file, decode_png, png_flavour, takes_files, text_of};
|
||||
|
||||
/// What our last write put on the clipboard.
|
||||
#[derive(Clone)]
|
||||
@@ -741,7 +747,7 @@ mod portable {
|
||||
}
|
||||
|
||||
/// A read of arboard's clipboard.
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
enum Request {
|
||||
Text,
|
||||
Image,
|
||||
@@ -813,6 +819,19 @@ mod portable {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a paste of one of `mimes` can take what `cb` holds: text that is not empty when one
|
||||
/// of `mimes` is text (`text` reads it), else files copied in a file manager when one of `mimes`
|
||||
/// is not text (`files` reads the list). The list is read only when the text doesn't do, and no
|
||||
/// copied file is opened: Paste checks the files themselves.
|
||||
fn arboard_has<B>(
|
||||
mimes: &[&'static str],
|
||||
cb: &mut B,
|
||||
text: impl FnOnce(&mut B) -> Result<String, String>,
|
||||
files: impl FnOnce(&mut B) -> Vec<PathBuf>,
|
||||
) -> bool {
|
||||
(mimes.contains(&TEXT) && text(cb).is_ok_and(|t| !t.is_empty())) || (takes_files(mimes) && !files(cb).is_empty())
|
||||
}
|
||||
|
||||
/// `request` read on `reads`' worker, waiting `wait` at most.
|
||||
#[cfg(test)]
|
||||
fn read_within(reads: &mut super::loads::Loads<Request, Answer>, request: Request, wait: Duration) -> Answer {
|
||||
@@ -1441,10 +1460,11 @@ mod portable {
|
||||
read
|
||||
}
|
||||
|
||||
/// Text, on macOS vector art or a bitmap (by the pasteboard's types), and on the Wayland
|
||||
/// core protocol copied files, SVG, text or PNG (by the types offered, nothing read).
|
||||
/// Text or files copied in a file manager (their list read, no file opened:
|
||||
/// [`arboard_has`]), on macOS vector art or a bitmap (by the pasteboard's types), and on the
|
||||
/// Wayland core protocol copied files, SVG, text or PNG (by the types offered, nothing read).
|
||||
/// arboard has no cheap way to ask for a bitmap (reading one costs as much as pasting it):
|
||||
/// the paste keys take it, the menu item waits for text.
|
||||
/// the paste keys take it, the menu item waits for text or copied files.
|
||||
fn has(&mut self, mimes: &[&'static str]) -> bool {
|
||||
#[cfg(target_os = "macos")]
|
||||
if super::mac::has(mimes) {
|
||||
@@ -1455,7 +1475,7 @@ mod portable {
|
||||
if let Backend::Wayland(wl) = cb {
|
||||
return wl.has(mimes);
|
||||
}
|
||||
mimes.contains(&TEXT) && cb.get_text().is_ok_and(|t| !t.is_empty())
|
||||
arboard_has(mimes, cb, Backend::get_text, Backend::file_list)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1619,6 +1639,40 @@ mod portable {
|
||||
assert!(Answer::Text(Ok("art.svg".into())).files().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paste_is_available_for_files_copied_in_a_file_manager() {
|
||||
use vectorcraft_engine::cmd::clipboard::{PASTE_ORDER, SVG};
|
||||
/// What the clipboard holds, and which reads [`arboard_has`] made.
|
||||
struct Held {
|
||||
text: Option<String>,
|
||||
files: Vec<PathBuf>,
|
||||
reads: Vec<Request>,
|
||||
}
|
||||
fn has(mimes: &[&'static str], text: Option<&str>, files: &[&str]) -> (bool, Vec<Request>) {
|
||||
let mut held = Held { text: text.map(String::from), files: files.iter().map(PathBuf::from).collect(), reads: vec![] };
|
||||
let text = |h: &mut Held| {
|
||||
h.reads.push(Request::Text);
|
||||
h.text.clone().ok_or_else(|| "no text".to_string())
|
||||
};
|
||||
let files = |h: &mut Held| {
|
||||
h.reads.push(Request::Files);
|
||||
h.files.clone()
|
||||
};
|
||||
let has = arboard_has(mimes, &mut held, text, files);
|
||||
(has, held.reads)
|
||||
}
|
||||
// Files a file manager copied, with no text: the Paste menu item is available.
|
||||
assert_eq!(has(&PASTE_ORDER, None, &["/tmp/art.svg"]), (true, vec![Request::Text, Request::Files]));
|
||||
assert_eq!(has(&PASTE_ORDER, Some(""), &["/tmp/art.svg"]), (true, vec![Request::Text, Request::Files]));
|
||||
assert_eq!(has(&[SVG], None, &["/tmp/art.svg"]), (true, vec![Request::Files]));
|
||||
// Text does, and the list is not read.
|
||||
assert_eq!(has(&PASTE_ORDER, Some("hello"), &[]), (true, vec![Request::Text]));
|
||||
// An empty list and no text: nothing to paste.
|
||||
assert_eq!(has(&PASTE_ORDER, None, &[]), (false, vec![Request::Text, Request::Files]));
|
||||
// A paste of text alone can't take copied files, and their list is not read.
|
||||
assert_eq!(has(&[TEXT], None, &["/tmp/art.svg"]), (false, vec![Request::Text]));
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))]
|
||||
#[test]
|
||||
fn arboards_reads_run_on_its_reader_and_wait_by_kind() {
|
||||
@@ -1925,7 +1979,7 @@ mod wayland {
|
||||
use wayland_client::{Connection, Dispatch, Proxy, QueueHandle, WEnum};
|
||||
|
||||
use super::loads::{Asker, GONE, LOAD_WAIT, Loads, wait_for_answer};
|
||||
use super::{BITMAP, Flavour, MAX_BYTES, PNG, PathBuf, SVG, TEXT, copied_file, gnome_copied_paths, uri_list_paths};
|
||||
use super::{BITMAP, Flavour, MAX_BYTES, PNG, PathBuf, SVG, TEXT, copied_file, gnome_copied_paths, takes_files, uri_list_paths};
|
||||
|
||||
/// The types text is offered under and read from, best first: `text/plain;charset=utf-8` (GTK
|
||||
/// and Qt apps), `UTF8_STRING` (X11 apps through XWayland) and `text/plain`.
|
||||
@@ -2016,11 +2070,6 @@ mod wayland {
|
||||
Some(first)
|
||||
}
|
||||
|
||||
/// Whether a paste of one of `mimes` can take a copied file: one of them is not text.
|
||||
fn takes_files(mimes: &[&'static str]) -> bool {
|
||||
mimes.iter().any(|&m| m != TEXT)
|
||||
}
|
||||
|
||||
/// The first type among `offered` that lists copied files ([`FILE_LISTS`]), in any letter case.
|
||||
fn file_list_type(offered: &[String]) -> Option<&str> {
|
||||
FILE_LISTS.iter().find_map(|(list, _)| offered.iter().find(|o| o.eq_ignore_ascii_case(list))).map(String::as_str)
|
||||
|
||||
@@ -87,8 +87,9 @@ fn version_6(r: &mut Reader<'_>, budget: &mut usize) -> Result<Vec<PsdSlice>, St
|
||||
if count > MAX_SLICES {
|
||||
return Err(format!("the file has {count} slices, more than the {MAX_SLICES} read"));
|
||||
}
|
||||
let one_after_another = records_one_after_another(Reader::new(r.rest()), count, *budget);
|
||||
let mut out = vec![];
|
||||
for _ in 0..count {
|
||||
for i in 0..count {
|
||||
// The ID and group ID.
|
||||
r.take(8)?;
|
||||
let origin = r.u32()?;
|
||||
@@ -116,9 +117,10 @@ fn version_6(r: &mut Reader<'_>, budget: &mut usize) -> Result<Vec<PsdSlice>, St
|
||||
format!("#{red:02x}{green:02x}{blue:02x}")
|
||||
};
|
||||
// Photoshop 7 and later may follow a record with a descriptor (version 16); a record that
|
||||
// doesn't start one is the next slice. A descriptor read that uses up the budget is an
|
||||
// error.
|
||||
if r.rest().starts_with(&16u32.to_be_bytes()) {
|
||||
// doesn't start one is the next slice. When the records follow one another, only the
|
||||
// last one may be followed by a descriptor. A descriptor read that uses up the budget is
|
||||
// an error.
|
||||
if (!one_after_another || i + 1 == count) && r.rest().starts_with(&16u32.to_be_bytes()) {
|
||||
let mut ahead = Reader::new(r.rest());
|
||||
ahead.u32()?;
|
||||
match descriptor(&mut ahead, 0, budget) {
|
||||
@@ -139,6 +141,37 @@ fn version_6(r: &mut Reader<'_>, budget: &mut usize) -> Result<Vec<PsdSlice>, St
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Whether `r` holds `count` version 6 records one after another, followed by nothing or by one
|
||||
/// descriptor (version 16) that reads within `budget`, as ag-psd writes them. A record whose ID is
|
||||
/// 16 then isn't taken for a descriptor. Otherwise each record may be followed by a descriptor.
|
||||
fn records_one_after_another(mut r: Reader<'_>, count: usize, mut budget: usize) -> bool {
|
||||
if !(0..count).all(|_| skip_record(&mut r).is_ok()) {
|
||||
return false;
|
||||
}
|
||||
r.rest().is_empty() || (r.rest().starts_with(&16u32.to_be_bytes()) && r.u32().is_ok() && descriptor(&mut r, 0, &mut budget).is_ok())
|
||||
}
|
||||
|
||||
/// Reads past the version 6 record `r` starts with, in the layout [`version_6`] reads. Its strings
|
||||
/// are checked and read past without being decoded.
|
||||
fn skip_record(r: &mut Reader<'_>) -> Result<(), String> {
|
||||
// The ID and group ID.
|
||||
r.take(8)?;
|
||||
if r.u32()? == 1 {
|
||||
r.take(4)?;
|
||||
}
|
||||
units(r)?;
|
||||
// The type and the rectangle.
|
||||
r.take(20)?;
|
||||
for _ in 0..4 {
|
||||
units(r)?;
|
||||
}
|
||||
r.take(1)?;
|
||||
units(r)?;
|
||||
// The alignments and the background color.
|
||||
r.take(12)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Versions 7 and 8: the descriptor's `slices` list, each slice an object.
|
||||
fn from_descriptor(d: &[(String, Value)]) -> Result<Vec<PsdSlice>, String> {
|
||||
let Some(Value::List(list)) = field(d, "slices") else { return Err("the slices' descriptor has no list of slices".into()) };
|
||||
@@ -221,12 +254,17 @@ fn text_len(n: usize) -> Result<usize, String> {
|
||||
|
||||
/// A Unicode string: a count of UTF-16 units, then the units; trailing NULs dropped.
|
||||
fn unicode(r: &mut Reader<'_>) -> Result<String, String> {
|
||||
let n = text_len(r.u32()? as usize)?;
|
||||
let bytes = r.take(n.checked_mul(2).ok_or(TRUNCATED)?)?;
|
||||
let bytes = units(r)?;
|
||||
let units: Vec<u16> = bytes.as_chunks::<2>().0.iter().map(|u| u16::from_be_bytes(*u)).collect();
|
||||
Ok(String::from_utf16_lossy(&units).trim_end_matches('\0').to_string())
|
||||
}
|
||||
|
||||
/// A Unicode string's units, as bytes: a count of UTF-16 units, then the units.
|
||||
fn units<'a>(r: &mut Reader<'a>) -> Result<&'a [u8], String> {
|
||||
let n = text_len(r.u32()? as usize)?;
|
||||
r.take(n.checked_mul(2).ok_or(TRUNCATED)?)
|
||||
}
|
||||
|
||||
/// A descriptor's value, as far as the slices need it.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
enum Value {
|
||||
|
||||
@@ -262,6 +262,32 @@ fn photoshop_7_descriptors_after_version_6_records_are_read_past() {
|
||||
assert_eq!(names, ["a", "b"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_version_6_record_whose_id_is_16_is_a_slice_not_a_descriptor() {
|
||||
// The 16th record has ID 16, group ID 0, origin 2, no name and the Image type: its first 18
|
||||
// bytes also read as a descriptor of version 16 with no items.
|
||||
let records: Vec<S> = (1..=17).map(|id| if id == 16 { user("", [1, 1, 4, 4]) } else { user("a", [0, 0, 5, 5]) }).collect();
|
||||
let descriptor_after = [16u32.to_be_bytes().to_vec(), descriptor(&[("topOutset", D::Long(0))])].concat();
|
||||
for trailing in [vec![], descriptor_after] {
|
||||
let (s, r) = open(&with_resource(&psd(false), 1050, &v6(&records, &trailing)), json!({}));
|
||||
assert!(warnings(&r).is_empty(), "{r}");
|
||||
let got = slices(&s);
|
||||
assert_eq!(got.len(), 17, "{got:?}");
|
||||
assert_eq!((got[15].0, got[15].1.name.as_str()), (Rect::new(1.0, 1.0, 4.0, 4.0), ""));
|
||||
assert_eq!(got[16].1.name, "a");
|
||||
}
|
||||
// A descriptor after each record whose class ID is four zero bytes, with no items, followed by
|
||||
// records with no strings: the records don't also read one after another.
|
||||
let empty = [ustr(""), 0u32.to_be_bytes().to_vec(), vec![0; 4], 0u32.to_be_bytes().to_vec()].concat();
|
||||
let trailing = [16u32.to_be_bytes().to_vec(), empty].concat();
|
||||
for rect in [[0, 0, 0, 0], [0, 0, 5, 5]] {
|
||||
let (s, r) = open(&with_resource(&psd(false), 1050, &v6(&[user("", rect), user("", rect), user("", rect)], &trailing)), json!({}));
|
||||
let w = warnings(&r);
|
||||
assert!(!w.iter().any(|w| w.starts_with("the slices can't be read")), "{w:?}");
|
||||
assert_eq!(slices(&s).len(), if rect[2] > 0 { 3 } else { 0 }, "{w:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn version_6_descriptors_share_one_budget_of_values() {
|
||||
// Each record's descriptor holds 2,501 values, well under the 200,000 one descriptor may hold;
|
||||
|
||||
@@ -185,9 +185,12 @@ impl Sets {
|
||||
/// horizontal extent, would otherwise compare every pair). An open box inside a later box of
|
||||
/// its group, ending no further right, is closed early, and a box inside an open box of its group,
|
||||
/// ending no further right, isn't opened: whatever overlaps it overlaps that box. An open box that
|
||||
/// a later box of its group overlaps, starting lower and ending no further right or lower, keeps
|
||||
/// only its part above the later box's top, so boxes staggered right and down each meet only the
|
||||
/// one before. Fails only when cancelled ([`vectorcraft_doc::cancel`]).
|
||||
/// a later box of its group overlaps and ends no further right than keeps only the part the later
|
||||
/// box doesn't cover: its part above the later box's top when the later box starts lower and ends
|
||||
/// no higher than it, and its part below the later box's bottom when the later box starts no lower
|
||||
/// and ends higher than it. The open box's top then moves down in the tree, so boxes staggered right
|
||||
/// and down, or right and up, each meet only the one before. Fails only when cancelled
|
||||
/// ([`vectorcraft_doc::cancel`]).
|
||||
pub(super) fn overlapping(bounds: &[Option<Rect>]) -> Result<Vec<Vec<usize>>, Cancelled> {
|
||||
Ok(sweep(bounds, None)?.groups())
|
||||
}
|
||||
@@ -206,27 +209,25 @@ fn sweep(bounds: &[Option<Rect>], see_through: Option<&[bool]>) -> Result<Sets,
|
||||
};
|
||||
let boxes: Vec<(usize, Rect)> = bounds.iter().enumerate().filter_map(|(i, b)| b.filter(finite).map(|b| (i, b))).collect();
|
||||
let n = boxes.len();
|
||||
// Each box's place in the tree: by top (then index).
|
||||
let mut by_top: Vec<usize> = (0..n).collect();
|
||||
by_top.sort_by(|&a, &b| boxes[a].1.y0.total_cmp(&boxes[b].1.y0).then(a.cmp(&b)));
|
||||
let tops: Vec<f64> = by_top.iter().map(|&k| boxes[k].1.y0).collect();
|
||||
let mut leaf = vec![0usize; n];
|
||||
for (pos, &k) in by_top.iter().enumerate() {
|
||||
leaf[k] = pos;
|
||||
}
|
||||
// The lowest bottom of the open boxes below each node (−∞: none open), in the tree of the
|
||||
// boxes without transparency (every box without `see_through`) and the see-through boxes'.
|
||||
let size = n.next_power_of_two().max(1);
|
||||
let mut low = [vec![f64::NEG_INFINITY; 2 * size], if see_through.is_some() { vec![f64::NEG_INFINITY; 2 * size] } else { vec![] }];
|
||||
let tree = |k: usize| usize::from(see_through.is_some_and(|s| s[boxes[k].0]));
|
||||
let set = |low: &mut [f64], pos: usize, v: f64| {
|
||||
let mut i = pos + size;
|
||||
low[i] = v;
|
||||
while i > 1 {
|
||||
i /= 2;
|
||||
low[i] = low[2 * i].max(low[2 * i + 1]);
|
||||
}
|
||||
// The places an open box's top can be at in the tree: a box's top, or just below a box's
|
||||
// bottom, where a later box cuts it short (`-0.0` as `0.0`).
|
||||
let mut places: Vec<f64> = boxes.iter().flat_map(|(_, b)| [b.y0 + 0.0, b.y1.next_up() + 0.0]).collect();
|
||||
places.sort_by(f64::total_cmp);
|
||||
places.dedup_by(|a, b| a.total_cmp(b).is_eq());
|
||||
let place = |y: f64| {
|
||||
let y = y + 0.0;
|
||||
let p = places.partition_point(|t| t.total_cmp(&y).is_lt());
|
||||
places.get(p).is_some_and(|t| t.total_cmp(&y).is_eq()).then_some(p)
|
||||
};
|
||||
// Each box's part still open, from its top to its bottom, and the place of its top while it
|
||||
// is open.
|
||||
let mut top: Vec<f64> = boxes.iter().map(|(_, b)| b.y0).collect();
|
||||
let mut bottom: Vec<f64> = boxes.iter().map(|(_, b)| b.y1).collect();
|
||||
let mut open: Vec<Option<usize>> = vec![None; n];
|
||||
// The tree of the open boxes without transparency (every box without `see_through`) and the
|
||||
// see-through boxes'.
|
||||
let mut trees = [Open::new(places.len()), Open::new(if see_through.is_some() { places.len() } else { 0 })];
|
||||
let tree = |k: usize| usize::from(see_through.is_some_and(|s| s[boxes[k].0]));
|
||||
let mut by_left: Vec<usize> = (0..n).collect();
|
||||
by_left.sort_by(|&a, &b| boxes[a].1.x0.total_cmp(&boxes[b].1.x0));
|
||||
let mut by_right: Vec<usize> = (0..n).collect();
|
||||
@@ -241,7 +242,9 @@ fn sweep(bounds: &[Option<Rect>], see_through: Option<&[bool]>) -> Result<Sets,
|
||||
while let Some(&c) = by_right.get(closing)
|
||||
&& boxes[c].1.x1 < b.x0
|
||||
{
|
||||
set(&mut low[tree(c)], leaf[c], f64::NEG_INFINITY);
|
||||
if let Some(p) = open[c].take() {
|
||||
trees[tree(c)].take(p, c, &bottom);
|
||||
}
|
||||
closing += 1;
|
||||
}
|
||||
// The open boxes it joins with their top at most this bottom and their bottom at least
|
||||
@@ -253,21 +256,32 @@ fn sweep(bounds: &[Option<Rect>], see_through: Option<&[bool]>) -> Result<Sets,
|
||||
Some(_) if shadows => &[0, 1],
|
||||
Some(_) => &[1],
|
||||
};
|
||||
let below = tops.partition_point(|t| *t <= b.y1);
|
||||
let below = places.partition_point(|t| *t <= b.y1);
|
||||
met.clear();
|
||||
for &t in looks {
|
||||
let tr = &trees[t];
|
||||
stack.clear();
|
||||
stack.push((1, 0, size));
|
||||
stack.push((1, 0, tr.size));
|
||||
while let Some((node, lo, hi)) = stack.pop() {
|
||||
work += 1;
|
||||
if work.is_multiple_of(4096) {
|
||||
vectorcraft_doc::cancel::check()?;
|
||||
}
|
||||
if lo >= below || low[t][node] < b.y0 {
|
||||
if lo >= below || tr.low[node] < b.y0 {
|
||||
continue;
|
||||
}
|
||||
if hi - lo == 1 {
|
||||
met.push(by_top[lo]);
|
||||
// The boxes with their top here, lowest bottom first.
|
||||
for &(_, o) in tr.at[lo].iter().rev() {
|
||||
if bottom[o] < b.y0 {
|
||||
break;
|
||||
}
|
||||
work += 1;
|
||||
if work.is_multiple_of(4096) {
|
||||
vectorcraft_doc::cancel::check()?;
|
||||
}
|
||||
met.push(o);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let mid = (lo + hi) / 2;
|
||||
@@ -286,30 +300,91 @@ fn sweep(bounds: &[Option<Rect>], see_through: Option<&[bool]>) -> Result<Sets,
|
||||
let ob = boxes[o].1;
|
||||
see_through.is_none_or(|s| s[boxes[o].0]) && b.x1 <= ob.x1 && ob.y0 <= b.y0 && b.y1 <= ob.y1
|
||||
});
|
||||
// Whatever overlaps a box inside this one overlaps this one, and joins it when this one is
|
||||
// see-through. Likewise, whatever later overlaps the part of an open box at or below this
|
||||
// one's top, when that box ends no further right or lower than this one, overlaps this
|
||||
// one: the open box then keeps only the part above this one's top.
|
||||
let cut = b.y0.next_down();
|
||||
// Whatever overlaps the open part of a box inside this one overlaps this one, and joins it
|
||||
// when this one is see-through. Likewise, whatever later overlaps the part of an open box
|
||||
// this one covers, when that box ends no further right than this one, overlaps this one:
|
||||
// the open box then keeps only the part above this one's top, when this one reaches its
|
||||
// bottom, or only the part below this one's bottom, when this one reaches its top.
|
||||
for &o in &met {
|
||||
sets.join(boxes[k].0, boxes[o].0);
|
||||
let ob = boxes[o].1;
|
||||
if !shadows || Some(o) == holder || b.x1 < ob.x1 || b.y1 < ob.y1 {
|
||||
let Some(p) = open[o] else { continue };
|
||||
if !shadows || Some(o) == holder || b.x1 < boxes[o].1.x1 {
|
||||
continue;
|
||||
}
|
||||
if b.y0 <= ob.y0 {
|
||||
set(&mut low[tree(o)], leaf[o], f64::NEG_INFINITY);
|
||||
} else if holder.is_none() && cut < low[tree(o)][leaf[o] + size] {
|
||||
set(&mut low[tree(o)], leaf[o], cut);
|
||||
let (t, u) = (top[o], bottom[o]);
|
||||
let tr = &mut trees[tree(o)];
|
||||
if b.y0 <= t && u <= b.y1 {
|
||||
tr.take(p, o, &bottom);
|
||||
open[o] = None;
|
||||
continue;
|
||||
}
|
||||
if holder.is_some() || (b.y1 < u && t < b.y0) {
|
||||
continue;
|
||||
}
|
||||
let (t, u) = if u <= b.y1 { (t, b.y0.next_down()) } else { (b.y1.next_up(), u) };
|
||||
// Every top it can get has a place; one without stays as it is.
|
||||
let Some(q) = place(t) else { continue };
|
||||
tr.take(p, o, &bottom);
|
||||
(top[o], bottom[o]) = (t, u);
|
||||
open[o] = (t <= u).then_some(q);
|
||||
if t <= u {
|
||||
tr.put(q, o, &bottom);
|
||||
}
|
||||
}
|
||||
if holder.is_none() {
|
||||
set(&mut low[tree(k)], leaf[k], b.y1);
|
||||
if holder.is_none()
|
||||
&& let Some(p) = place(b.y0)
|
||||
{
|
||||
open[k] = Some(p);
|
||||
trees[tree(k)].put(p, k, &bottom);
|
||||
}
|
||||
}
|
||||
Ok(sets)
|
||||
}
|
||||
|
||||
/// The open boxes of [`sweep`] by the place of their tops, in a tree that knows the lowest bottom
|
||||
/// below each of its branches.
|
||||
struct Open {
|
||||
size: usize,
|
||||
/// The lowest bottom of the open boxes below each node (−∞: none open).
|
||||
low: Vec<f64>,
|
||||
/// The open boxes at each place, by bottom ([`order`]) and then index.
|
||||
at: Vec<BTreeSet<(i64, usize)>>,
|
||||
}
|
||||
|
||||
impl Open {
|
||||
fn new(places: usize) -> Self {
|
||||
let size = places.next_power_of_two().max(1);
|
||||
Self { size, low: vec![f64::NEG_INFINITY; 2 * size], at: vec![BTreeSet::new(); places] }
|
||||
}
|
||||
|
||||
/// Opens box `k` at place `p`, with its bottom `bottom[k]`.
|
||||
fn put(&mut self, p: usize, k: usize, bottom: &[f64]) {
|
||||
self.at[p].insert((order(bottom[k]), k));
|
||||
self.fix(p, bottom);
|
||||
}
|
||||
|
||||
/// Closes box `k` at place `p`, while its bottom is still `bottom[k]`.
|
||||
fn take(&mut self, p: usize, k: usize, bottom: &[f64]) {
|
||||
self.at[p].remove(&(order(bottom[k]), k));
|
||||
self.fix(p, bottom);
|
||||
}
|
||||
|
||||
fn fix(&mut self, p: usize, bottom: &[f64]) {
|
||||
let mut i = p + self.size;
|
||||
self.low[i] = self.at[p].last().map_or(f64::NEG_INFINITY, |&(_, k)| bottom[k]);
|
||||
while i > 1 {
|
||||
i /= 2;
|
||||
self.low[i] = self.low[2 * i].max(self.low[2 * i + 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `v` as an integer in the same order as [`f64::total_cmp`].
|
||||
fn order(v: f64) -> i64 {
|
||||
let b = v.to_bits() as i64;
|
||||
b ^ (((b >> 63) as u64) >> 1) as i64
|
||||
}
|
||||
|
||||
/// Boxes in blocks of nearby ones, each block with the box around it, to find the boxes a box
|
||||
/// touches.
|
||||
struct Blocks {
|
||||
@@ -775,6 +850,136 @@ mod tests {
|
||||
assert_eq!(sets.groups(), vec![(0..n).collect::<Vec<_>>()]);
|
||||
}
|
||||
|
||||
/// `n` boxes of one size, each a little right of and above the one before, all overlapping and
|
||||
/// none inside another.
|
||||
fn staggered_up(n: usize) -> Vec<Option<Rect>> {
|
||||
let w = 2.0 * n as f64;
|
||||
(0..n).map(|i| Some(Rect::new(i as f64, -(i as f64), w + i as f64, w - i as f64))).collect()
|
||||
}
|
||||
|
||||
/// Each box of a stagger right and up meets only the box before it, which keeps only its part
|
||||
/// below the new box's bottom, not every box still open; so does each box of a stagger left and
|
||||
/// down, which the sweep meets right and up.
|
||||
#[test]
|
||||
fn boxes_staggered_up_meet_only_the_box_before() {
|
||||
let n = 512;
|
||||
let bounds = staggered_up(n);
|
||||
let all = vec![(0..n).collect::<Vec<_>>()];
|
||||
let mut sets = sweep(&bounds, None).unwrap();
|
||||
assert_eq!(sets.meets, n - 1);
|
||||
assert_eq!(sets.groups(), every_pair(&bounds));
|
||||
assert_eq!(sets.groups(), all);
|
||||
let mut sets = sweep(&bounds, Some(&vec![true; n])).unwrap();
|
||||
assert_eq!(sets.meets, n - 1);
|
||||
assert_eq!(sets.groups(), all);
|
||||
let mut reversed = bounds.clone();
|
||||
reversed.reverse();
|
||||
let mut sets = sweep(&reversed, None).unwrap();
|
||||
assert_eq!(sets.meets, n - 1);
|
||||
assert_eq!(sets.groups(), all);
|
||||
let mut sets = sweep(&reversed, Some(&vec![true; n])).unwrap();
|
||||
assert_eq!(sets.meets, n - 1);
|
||||
assert_eq!(sets.groups(), all);
|
||||
}
|
||||
|
||||
/// An open box cut short from above keeps the part a later box would meet without meeting the
|
||||
/// box that cut it: a part below that box, a part further right, or any part when that box is
|
||||
/// opaque or held; a box cut from above and from below keeps its middle.
|
||||
#[test]
|
||||
fn a_box_is_cut_short_from_above_only_where_the_later_box_covers_it() {
|
||||
let k = Rect::new(5.0, -5.0, 15.0, 10.0);
|
||||
let cases = [
|
||||
// Below `k`: the last box overlaps only the bottom of the first.
|
||||
("below", vec![Some(Rect::new(0.0, 0.0, 10.0, 20.0)), Some(k), Some(Rect::new(8.0, 15.0, 9.0, 25.0))], vec![true, true, false]),
|
||||
// Further right than `k`: `k` cuts nothing and the last box overlaps the first.
|
||||
("right", vec![Some(Rect::new(0.0, 0.0, 20.0, 20.0)), Some(k), Some(Rect::new(17.0, 2.0, 25.0, 4.0))], vec![true, true, false]),
|
||||
// Just below `k`'s bottom, and touching it.
|
||||
(
|
||||
"edge",
|
||||
vec![Some(Rect::new(0.0, 0.0, 10.0, 20.0)), Some(k), Some(Rect::new(8.0, 10.0, 9.0, 12.0)), Some(Rect::new(8.0, 10.5, 9.0, 12.0))],
|
||||
vec![false, true, false, false],
|
||||
),
|
||||
// An opaque `k` doesn't join the opaque last box, which joins the see-through first one.
|
||||
("opaque", vec![Some(Rect::new(0.0, 0.0, 10.0, 10.0)), Some(k), Some(Rect::new(6.0, -10.0, 7.0, 2.0))], vec![true, false, false]),
|
||||
// A see-through `k` held by a see-through box around it isn't opened and cuts nothing short.
|
||||
(
|
||||
"held",
|
||||
vec![
|
||||
Some(Rect::new(0.0, -6.0, 30.0, 28.0)),
|
||||
Some(Rect::new(1.0, 0.0, 10.0, 20.0)),
|
||||
Some(k),
|
||||
Some(Rect::new(6.0, 11.0, 7.0, 13.0)),
|
||||
Some(Rect::new(6.0, 4.0, 7.0, 6.0)),
|
||||
],
|
||||
vec![true, false, true, false, false],
|
||||
),
|
||||
// Cut from above, then from below: a later box inside what is left joins the first.
|
||||
(
|
||||
"middle",
|
||||
vec![
|
||||
Some(Rect::new(0.0, 0.0, 10.0, 30.0)),
|
||||
Some(Rect::new(2.0, -5.0, 12.0, 10.0)),
|
||||
Some(Rect::new(3.0, 20.0, 13.0, 40.0)),
|
||||
Some(Rect::new(5.0, 15.0, 6.0, 16.0)),
|
||||
Some(Rect::new(5.0, 9.0, 6.0, 10.0)),
|
||||
Some(Rect::new(5.0, 20.0, 6.0, 20.0)),
|
||||
],
|
||||
vec![false, true, true, false, false, false],
|
||||
),
|
||||
// Signed zeros, a point and a box that isn't finite.
|
||||
(
|
||||
"zeros",
|
||||
vec![
|
||||
Some(Rect::new(-0.0, -0.0, 4.0, 8.0)),
|
||||
Some(Rect::new(0.0, -2.0, 6.0, -0.0)),
|
||||
Some(Rect::new(1.0, 0.0, 1.0, 0.0)),
|
||||
Some(Rect::new(2.0, f64::NEG_INFINITY, 3.0, 1.0)),
|
||||
Some(Rect::new(3.0, f64::MAX, 3.0, f64::MAX)),
|
||||
Some(Rect::new(3.5, 0.0, 3.5, 0.0)),
|
||||
],
|
||||
vec![false, true, false, true, true, false],
|
||||
),
|
||||
];
|
||||
for (what, bounds, see) in cases {
|
||||
assert_eq!(overlapping(&bounds).unwrap(), every_pair(&bounds), "{what}");
|
||||
let mut sets = sweep(&bounds, Some(&see)).unwrap();
|
||||
assert_eq!(sets.groups(), every_pair_joining(&bounds, |i, j| see[i] || see[j]), "{what}, with transparency");
|
||||
let mut sets = sweep(&bounds, Some(&vec![true; bounds.len()])).unwrap();
|
||||
assert_eq!(sets.groups(), every_pair(&bounds), "{what}, all see-through");
|
||||
}
|
||||
}
|
||||
|
||||
/// Boxes stepping right and alternately up and down, so that open boxes are cut short from
|
||||
/// above and from below, of mixed sizes, some see-through, group as comparing every pair groups
|
||||
/// them.
|
||||
#[test]
|
||||
fn boxes_stepping_up_and_down_group_as_comparing_every_pair() {
|
||||
let mut seed = 0x6a09_e667_f3bc_c908u64;
|
||||
let mut next = |m: f64| {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 7;
|
||||
seed ^= seed << 17;
|
||||
(seed % 1000) as f64 / 1000.0 * m
|
||||
};
|
||||
for round in 0..40 {
|
||||
let n = 10 + round * 3;
|
||||
let mut y = 0.0;
|
||||
let bounds: Vec<Option<Rect>> = (0..n)
|
||||
.map(|i| {
|
||||
let up = if (i / (1 + round % 3)) % 2 == 0 { -1.0 } else { 1.0 };
|
||||
y += up * (next(4.0).floor() + 1.0);
|
||||
let x = i as f64 + next(2.0).floor();
|
||||
let (w, h) = (next(12.0).floor() + 4.0, next(16.0).floor() + 2.0);
|
||||
Some(Rect::new(x, y, x + w, y + h))
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(overlapping(&bounds).unwrap(), every_pair(&bounds), "round {round}");
|
||||
let see: Vec<bool> = (0..n).map(|_| next(1.0) < if round % 2 == 0 { 0.5 } else { 0.9 }).collect();
|
||||
let mut sets = sweep(&bounds, Some(&see)).unwrap();
|
||||
assert_eq!(sets.groups(), every_pair_joining(&bounds, |i, j| see[i] || see[j]), "round {round}, with transparency");
|
||||
}
|
||||
}
|
||||
|
||||
/// An open box keeps the part a later box would meet without meeting the box that cut it short:
|
||||
/// a part lower than that box, a part further right, or any part when that box is opaque.
|
||||
#[test]
|
||||
|
||||
@@ -377,14 +377,15 @@ fn annotator_gestures_edit_the_gradient_as_single_undo_steps() {
|
||||
assert_eq!(stops.len(), 3);
|
||||
assert!((stops[1].offset - 0.3).abs() < 1e-6);
|
||||
assert_eq!(s.selected_stop(), Some(1));
|
||||
// Dragging the end handle changes only the end, as one undo step.
|
||||
// Dragging the end handle changes only the length (the end stays on the bar's line), as one
|
||||
// undo step.
|
||||
let undo = s.doc().unwrap().history.undo.len();
|
||||
gesture(
|
||||
&mut s,
|
||||
&[(PointerKind::Down, 200.0, 150.0), (PointerKind::Drag, 210.0, 160.0), (PointerKind::Drag, 220.0, 170.0), (PointerKind::Up, 220.0, 170.0)],
|
||||
);
|
||||
let g = fill_geom(&s, id);
|
||||
assert_eq!((g.start, g.end), (Point::new(100.0, 150.0), Point::new(220.0, 170.0)));
|
||||
assert_eq!((g.start, g.end), (Point::new(100.0, 150.0), Point::new(220.0, 150.0)));
|
||||
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
// The selected stop takes Delete ahead of edit.clear; the object stays.
|
||||
|
||||
@@ -44,10 +44,15 @@ fn gradient_annotator_end_to_end() {
|
||||
let r = ok(&mut h, "press_key", json!({"key": "Delete"}));
|
||||
assert_eq!(r["handledBy"], "tool", "{r}");
|
||||
assert_eq!(offsets(&gradient(&h)), vec![0.0, 100.0]);
|
||||
// The end handle changes only the end.
|
||||
// The end handle changes only the length: the end stays on the bar's line.
|
||||
let end = json!({"events": [{"kind": "down", "x": 200, "y": 150}, {"kind": "drag", "x": 230, "y": 120}, {"kind": "up", "x": 230, "y": 120}]});
|
||||
ok(&mut h, "pointer_gesture", end);
|
||||
let g = gradient(&h).geom.unwrap();
|
||||
assert_eq!((g.start, g.end), (Point::new(100.0, 150.0), Point::new(230.0, 150.0)));
|
||||
// Alt-dragged, it changes the length and the angle together.
|
||||
let end = json!({"mods": {"alt": true}, "events": [{"kind": "down", "x": 230, "y": 150}, {"kind": "drag", "x": 230, "y": 120}, {"kind": "up", "x": 230, "y": 120}]});
|
||||
ok(&mut h, "pointer_gesture", end);
|
||||
let g = gradient(&h).geom.unwrap();
|
||||
assert_eq!((g.start, g.end), (Point::new(100.0, 150.0), Point::new(230.0, 120.0)));
|
||||
// Double-clicking a stop asks for its popover.
|
||||
let dbl = ok(&mut h, "pointer_gesture", json!({"events": [{"kind": "doubleclick", "x": 100, "y": 160}]}));
|
||||
|
||||
@@ -37,9 +37,25 @@ pub(super) enum StrokePlan {
|
||||
Written(Written),
|
||||
}
|
||||
|
||||
/// Visit `n` and the descendants the writer draws ([`Writer::node_body`]): a hidden layer or object
|
||||
/// and what it holds only with `hidden` (SVG Options › hidden layers kept), and a template layer's
|
||||
/// art never.
|
||||
fn walk_drawn<'a>(n: &'a Node, hidden: bool, f: &mut impl FnMut(&'a Node)) {
|
||||
if !(n.visible || hidden) {
|
||||
return;
|
||||
}
|
||||
f(n);
|
||||
if matches!(n.kind, NodeKind::Layer { template: true, .. }) {
|
||||
return;
|
||||
}
|
||||
for c in n.children().into_iter().flatten() {
|
||||
walk_drawn(c, hidden, f);
|
||||
}
|
||||
}
|
||||
|
||||
impl Writer<'_> {
|
||||
pub(super) fn count_colorized_images(&mut self, art: &Node) {
|
||||
art.walk(&mut |n| {
|
||||
walk_drawn(art, self.opts.hidden_layers, &mut |n| {
|
||||
let NodeKind::Image(im) = &n.kind else { return };
|
||||
let Some(Paint::Solid { color, .. }) = n.extras().colorize.as_deref() else { return };
|
||||
let shown = self.doc.shown_image(n, im);
|
||||
@@ -176,7 +192,7 @@ impl Writer<'_> {
|
||||
self.count_colorized_images(art);
|
||||
// Each image's count and its first piece, which shows what they all show.
|
||||
let mut seen: HashMap<(String, u32, u32), (usize, vectorcraft_doc::ImageObject)> = HashMap::new();
|
||||
art.walk(&mut |c| {
|
||||
walk_drawn(art, self.opts.hidden_layers, &mut |c| {
|
||||
if let NodeKind::Image(im) = &c.kind {
|
||||
let shown = self.doc.shown_image(c, im);
|
||||
let im = &*shown;
|
||||
|
||||
@@ -875,7 +875,8 @@ fn raster(format: image::ImageFormat) -> Option<RasterKind> {
|
||||
/// TIFF) leaves the pixels as stored. Otherwise the pixels are read ([`decoded`],
|
||||
/// [`tiff_pixels`]), turned or flipped as the orientation says, and written as PNG, so usvg sizes
|
||||
/// and fits the image as it is shown, with the resolution the file declares
|
||||
/// ([`vectorcraft_doc::ppi::resolution`]), its axes swapped by a quarter turn. A CMYK TIFF also
|
||||
/// ([`vectorcraft_doc::ppi::resolution`]), its axes swapped by a quarter turn, and the ICC profile
|
||||
/// the file carries when its color space is the written samples' (gray or RGB). A CMYK TIFF also
|
||||
/// keeps its inks as a CMYK TIFF ([`vectorcraft_doc::cmyk::stored_cmyk_tiff`]), and a CMYK JPEG
|
||||
/// or TIFF that is turned keeps them turned ([`vectorcraft_doc::cmyk::turned_cmyk`]). `None` when
|
||||
/// the pixels can't be read, and for a TIFF with more strips or tiles than the decoder can count
|
||||
@@ -893,7 +894,7 @@ fn shown(bytes: Arc<Vec<u8>>, format: image::ImageFormat) -> Option<Shown> {
|
||||
return Some(Shown { kind, bytes, cmyk: None });
|
||||
}
|
||||
let tiff = image::guess_format(&bytes).ok() == Some(F::Tiff);
|
||||
let mut img = if tiff { tiff_pixels(&bytes)? } else { decoded(&bytes, format)? };
|
||||
let (mut img, icc) = if tiff { tiff_pixels(&bytes)? } else { decoded(&bytes, format)? };
|
||||
let ppi = vectorcraft_doc::ppi::resolution(&bytes);
|
||||
// The resolution describes the stored pixels; a quarter turn swaps its axes.
|
||||
let quarter = orientation.is_some_and(|o| o.to_exif() >= 5);
|
||||
@@ -906,18 +907,38 @@ fn shown(bytes: Arc<Vec<u8>>, format: image::ImageFormat) -> Option<Shown> {
|
||||
if let Some(orientation) = orientation {
|
||||
img.apply_orientation(orientation);
|
||||
}
|
||||
use image::DynamicImage as D;
|
||||
let img = match img {
|
||||
D::ImageLuma8(_) | D::ImageLumaA8(_) | D::ImageRgb8(_) | D::ImageRgba8(_) => img,
|
||||
D::ImageLuma16(_) | D::ImageLumaA16(_) | D::ImageRgb16(_) | D::ImageRgba16(_) => img,
|
||||
other => D::ImageRgba8(other.into_rgba8()),
|
||||
};
|
||||
let mut png = Vec::new();
|
||||
img.write_to(&mut std::io::Cursor::new(&mut png), F::Png).ok()?;
|
||||
let mut encoder = image::codecs::png::PngEncoder::new(&mut png);
|
||||
if let Some(icc) = icc.filter(|icc| png_takes_icc(&img, icc)) {
|
||||
// A profile the encoder doesn't take leaves the image without one.
|
||||
let _ = image::ImageEncoder::set_icc_profile(&mut encoder, icc);
|
||||
}
|
||||
img.write_with_encoder(encoder).ok()?;
|
||||
if let Some(ppi) = shown_ppi {
|
||||
png = vectorcraft_doc::ppi::with_png_resolution(&png, ppi);
|
||||
}
|
||||
Some(Shown { kind: ImageKind::PNG, bytes: Arc::new(png), cmyk })
|
||||
}
|
||||
|
||||
/// Can a PNG of `img`'s samples carry ICC profile `icc`? Its color space must be the samples':
|
||||
/// `GRAY` for gray samples, `RGB ` for RGB ones.
|
||||
fn png_takes_icc(img: &image::DynamicImage, icc: &[u8]) -> bool {
|
||||
let want = if img.color().has_color() { *b"RGB " } else { *b"GRAY" };
|
||||
vectorcraft_doc::cmyk::icc_color_space(icc) == Some(want)
|
||||
}
|
||||
|
||||
/// The pixels of encoded image `bytes` (`format` when their bytes don't say), as stored, decoded
|
||||
/// within [`vectorcraft_doc::MAX_RASTER_ALLOC`], counted as decoded and as RGBA, as Open and Place
|
||||
/// decode them; `None` when they can't be.
|
||||
fn decoded(bytes: &[u8], format: image::ImageFormat) -> Option<image::DynamicImage> {
|
||||
/// decode them, with the ICC profile their samples are in when the file carries one the decoder
|
||||
/// can read (a TIFF's read by [`vectorcraft_doc::cmyk::tiff_icc_profile`]); `None` when they
|
||||
/// can't be.
|
||||
fn decoded(bytes: &[u8], format: image::ImageFormat) -> Option<(image::DynamicImage, Option<Vec<u8>>)> {
|
||||
use image::ImageDecoder as _;
|
||||
let max = vectorcraft_doc::MAX_RASTER_ALLOC;
|
||||
let mut reader = image::ImageReader::new(std::io::Cursor::new(bytes)).with_guessed_format().ok()?;
|
||||
@@ -927,12 +948,16 @@ fn decoded(bytes: &[u8], format: image::ImageFormat) -> Option<image::DynamicIma
|
||||
let mut limits = image::Limits::default();
|
||||
limits.max_alloc = Some(max);
|
||||
reader.limits(limits);
|
||||
let decoder = reader.into_decoder().ok()?;
|
||||
let tiff = reader.format() == Some(image::ImageFormat::Tiff);
|
||||
let mut decoder = reader.into_decoder().ok()?;
|
||||
let (w, h) = decoder.dimensions();
|
||||
if decoder.total_bytes() > max || u64::from(w) * u64::from(h) * 4 > max {
|
||||
return None;
|
||||
}
|
||||
image::DynamicImage::from_decoder(decoder).ok()
|
||||
// The image decoder reads a TIFF's tags within the size of its pixels, so a small TIFF's
|
||||
// profile is read by the TIFF decoder itself.
|
||||
let icc = if tiff { vectorcraft_doc::cmyk::tiff_icc_profile(bytes) } else { decoder.icc_profile().ok().flatten() };
|
||||
Some((image::DynamicImage::from_decoder(decoder).ok()?, icc))
|
||||
}
|
||||
|
||||
/// The pixels of TIFF `bytes`, as stored, read as Open and Place read them: a TIFF with extra
|
||||
@@ -940,15 +965,17 @@ fn decoded(bytes: &[u8], format: image::ImageFormat) -> Option<image::DynamicIma
|
||||
/// ([`vectorcraft_doc::cmyk::extra_samples_tiff_rgba`]); a 1-bit TIFF compressed with CCITT Group
|
||||
/// 3 as RGBA ([`vectorcraft_doc::cmyk::group3_tiff_rgba`]); others by [`decoded`], a CMYK TIFF
|
||||
/// that stores one plane per ink with its inks written together first
|
||||
/// ([`vectorcraft_doc::cmyk::stored_cmyk_tiff`]). `None` when they can't be read.
|
||||
fn tiff_pixels(bytes: &[u8]) -> Option<image::DynamicImage> {
|
||||
/// ([`vectorcraft_doc::cmyk::stored_cmyk_tiff`]). Pixels the image decoder reads come with the
|
||||
/// TIFF's ICC profile; the other readers give sRGB pixels, without one. `None` when they can't be
|
||||
/// read.
|
||||
fn tiff_pixels(bytes: &[u8]) -> Option<(image::DynamicImage, Option<Vec<u8>>)> {
|
||||
use image::DynamicImage::ImageRgba8;
|
||||
let cms = vectorcraft_color::cms::active();
|
||||
if let Some(img) = vectorcraft_doc::cmyk::extra_samples_tiff_rgba(bytes, |c| cms.cmyk_to_srgb(c, false)) {
|
||||
return Some(ImageRgba8(img));
|
||||
return Some((ImageRgba8(img), None));
|
||||
}
|
||||
if let Some(read) = vectorcraft_doc::cmyk::group3_tiff_rgba(bytes) {
|
||||
return read.ok().map(ImageRgba8);
|
||||
return read.ok().map(|img| (ImageRgba8(img), None));
|
||||
}
|
||||
decoded(bytes, image::ImageFormat::Tiff).or_else(|| decoded(&vectorcraft_doc::cmyk::stored_cmyk_tiff(bytes, None)?, image::ImageFormat::Tiff))
|
||||
}
|
||||
|
||||
@@ -243,48 +243,59 @@ impl Importer {
|
||||
if !matches!(kids.get(main), Some(usvg::Node::Path(p)) if p.is_visible()) {
|
||||
return Some(vec![]);
|
||||
}
|
||||
let text::PendingText { name, mut obj, servers, paints, non_scaling, under, .. } = self.slots.texts.get(i)?.clone();
|
||||
// The scale the type draws at becomes its size (last, below): text space grows by `grow`.
|
||||
let xf = ts * obj.xf;
|
||||
let grow = text::size_scale(&obj, xf);
|
||||
// usvg resolved the `url(#…)` paints (the paths after the main one) in the element's user
|
||||
// space; runs paint in text space.
|
||||
let to_text = Affine::scale(grow) * obj.xf.inverse();
|
||||
let text::PendingText { name, obj, servers, rest, paints, non_scaling, under, .. } = self.slots.texts.get(i)?.clone();
|
||||
let slot_paint = |im: &mut Self, k: usize, m: Affine| match kids.get(main + 1 + k) {
|
||||
Some(usvg::Node::Path(p)) => p.fill().map_or(Paint::None, |f| im.paint(f.paint(), m)),
|
||||
_ => Paint::None,
|
||||
};
|
||||
let resolved: Vec<Paint> = (0..paints).map(|k| slot_paint(self, k, to_text)).collect();
|
||||
let server = |k: usize| resolved.get(k).cloned().unwrap_or(Paint::None);
|
||||
for (run, (fill, stroke)) in obj.runs.iter_mut().zip(servers) {
|
||||
if let Some(k) = fill {
|
||||
run.style.fill = server(k);
|
||||
// A text split into several objects becomes a group of them, named after the element.
|
||||
let whole = rest.is_empty();
|
||||
let mut skewed = false;
|
||||
let mut nodes = Vec::with_capacity(rest.len() + 1);
|
||||
for (mut obj, servers) in std::iter::once((obj, servers)).chain(rest) {
|
||||
// The scale the type draws at becomes its size (last, below): text space grows by `grow`.
|
||||
let xf = ts * obj.xf;
|
||||
let grow = text::size_scale(&obj, xf);
|
||||
// usvg resolved the `url(#…)` paints (the paths after the main one) in the element's user
|
||||
// space; runs paint in text space.
|
||||
let to_text = Affine::scale(grow) * obj.xf.inverse();
|
||||
let resolved: Vec<Paint> = (0..paints).map(|k| slot_paint(self, k, to_text)).collect();
|
||||
let server = |k: usize| resolved.get(k).cloned().unwrap_or(Paint::None);
|
||||
for (run, (fill, stroke)) in obj.runs.iter_mut().zip(servers) {
|
||||
if let Some(k) = fill {
|
||||
run.style.fill = server(k);
|
||||
}
|
||||
if let Some(k) = stroke {
|
||||
run.style.stroke = server(k);
|
||||
}
|
||||
}
|
||||
if let Some(k) = stroke {
|
||||
run.style.stroke = server(k);
|
||||
obj.xf = xf;
|
||||
skewed |= non_scaling && !vector_effect::unscale_text(&mut obj, self.screen);
|
||||
// A stroke under the characters is the object's own: it paints in the document.
|
||||
let under = under.clone().map(|(mut sl, k)| {
|
||||
if let Some(k) = k {
|
||||
sl.paint = slot_paint(self, k, ts);
|
||||
}
|
||||
let mut ap = Appearance { items: vec![AppearanceItem::Stroke(sl)], ..Default::default() };
|
||||
ap.scale_strokes(if non_scaling { self.screen } else { obj.xf.determinant().abs().sqrt() });
|
||||
ap.set_contents_at(1);
|
||||
ap
|
||||
});
|
||||
text::fold_scale(&mut obj, grow);
|
||||
let mut n = self.named(if whole { &name } else { "" }, NodeKind::Text(Box::new(obj)))?;
|
||||
if let Some(ap) = under {
|
||||
n.appearance = ap.into();
|
||||
}
|
||||
nodes.push(Arc::new(n));
|
||||
}
|
||||
obj.xf = xf;
|
||||
if non_scaling && !vector_effect::unscale_text(&mut obj, self.screen) {
|
||||
if skewed {
|
||||
let label = if name.is_empty() || made_up(&name) { "a text".to_string() } else { format!("text '{name}'") };
|
||||
self.warn(format!("non-scaling stroke on {label} approximated: the text is stretched or skewed"));
|
||||
}
|
||||
// A stroke under the characters is the object's own: it paints in the document.
|
||||
let under = under.map(|(mut sl, k)| {
|
||||
if let Some(k) = k {
|
||||
sl.paint = slot_paint(self, k, ts);
|
||||
}
|
||||
let mut ap = Appearance { items: vec![AppearanceItem::Stroke(sl)], ..Default::default() };
|
||||
ap.scale_strokes(if non_scaling { self.screen } else { obj.xf.determinant().abs().sqrt() });
|
||||
ap.set_contents_at(1);
|
||||
ap
|
||||
});
|
||||
text::fold_scale(&mut obj, grow);
|
||||
let mut n = self.named(&name, NodeKind::Text(Box::new(obj)))?;
|
||||
if let Some(ap) = under {
|
||||
n.appearance = ap.into();
|
||||
if whole {
|
||||
return Some(nodes);
|
||||
}
|
||||
Some(vec![Arc::new(n)])
|
||||
Some(vec![Arc::new(self.named(&name, NodeKind::Group { children: nodes, clip: false })?)])
|
||||
}
|
||||
|
||||
fn group_node(&mut self, g: &usvg::Group, acc: Affine) -> Option<Node> {
|
||||
@@ -584,7 +595,8 @@ impl Importer {
|
||||
if p.id().is_empty() || !p.is_visible() || p.fill().is_some_and(|f| f.rule() == usvg::FillRule::EvenOdd) {
|
||||
return None;
|
||||
}
|
||||
let mut obj = self.slots.texts.get(self.slots.find(p)?)?.obj.clone();
|
||||
// A text split into several objects clips by its outlines.
|
||||
let mut obj = self.slots.texts.get(self.slots.find(p)?).filter(|t| t.rest.is_empty())?.obj.clone();
|
||||
obj.xf = m * self.slots.inner(p) * obj.xf;
|
||||
let grow = text::size_scale(&obj, obj.xf);
|
||||
for run in &mut obj.runs {
|
||||
|
||||
+192
-48
@@ -130,6 +130,7 @@ const BIDI_NESTED: &str = "a unicode-bidi embedding inside another imported one
|
||||
const BIDI_TEXT_OVERRIDE: &str = "unicode-bidi override on the text imported as its paragraph direction; directional override is not supported";
|
||||
|
||||
/// One character of a text and the adjustments its position needs.
|
||||
#[derive(Clone)]
|
||||
struct Cell {
|
||||
ch: char,
|
||||
style: CharStyle,
|
||||
@@ -178,6 +179,9 @@ pub(super) struct PendingText {
|
||||
pub obj: TextObject,
|
||||
/// For each run, the index of its fill's and stroke's `url(#…)` paint, if any.
|
||||
pub servers: Vec<(Option<usize>, Option<usize>)>,
|
||||
/// The other point type objects of a text whose absolutely placed characters one object cannot
|
||||
/// put on their x ([`split`]), after `obj` in text order, each with its runs' paint indices.
|
||||
pub rest: Vec<(TextObject, Vec<Key>)>,
|
||||
/// Number of `url(#…)` paints (the placeholder paths after the main one, in order).
|
||||
pub paints: usize,
|
||||
/// `vector-effect="non-scaling-stroke"`: the character strokes keep their width on screen.
|
||||
@@ -233,7 +237,14 @@ impl TextSlots {
|
||||
return Some(bp.clone());
|
||||
}
|
||||
let t = self.texts.get(i)?;
|
||||
let bp = Rc::new(vectorcraft_text::layout(FontDb::global(), &t.obj).to_bezpath());
|
||||
let mut bp = vectorcraft_text::layout(FontDb::global(), &t.obj).to_bezpath();
|
||||
// The other objects of a split text, in the first one's text space.
|
||||
for (o, _) in &t.rest {
|
||||
let mut more = vectorcraft_text::layout(FontDb::global(), o).to_bezpath();
|
||||
more.apply_affine(t.obj.xf.inverse() * o.xf);
|
||||
bp.extend(more.elements().iter().copied());
|
||||
}
|
||||
let bp = Rc::new(bp);
|
||||
self.outlines.borrow_mut().insert(i, bp.clone());
|
||||
Some(bp)
|
||||
}
|
||||
@@ -534,7 +545,10 @@ fn use_slot(
|
||||
shown.build(style_xml, style_t, &label, &mut found)
|
||||
};
|
||||
let differs = |(text, paints): &(PendingText, Vec<String>)| {
|
||||
slots.texts.get(shared).is_none_or(|old| old.obj != text.obj || old.servers != text.servers || old.under != text.under)
|
||||
slots
|
||||
.texts
|
||||
.get(shared)
|
||||
.is_none_or(|old| old.obj != text.obj || old.servers != text.servers || old.rest != text.rest || old.under != text.under)
|
||||
|| inst.paints.get(shared) != Some(paints)
|
||||
};
|
||||
let slot = built.filter(differs).map(|(text, paints)| {
|
||||
@@ -1337,7 +1351,7 @@ impl Ctx {
|
||||
}
|
||||
let marker = Rect::new(b.x0, b.y0, b.x1.max(b.x0 + 1.0), b.y1.max(b.y0 + 1.0));
|
||||
let name = t.attribute("id").unwrap_or("").to_string();
|
||||
Some((PendingText { name, obj, servers, paints: 0, non_scaling: false, under: None, marker }, Vec::new()))
|
||||
Some((PendingText { name, obj, servers, rest: vec![], paints: 0, non_scaling: false, under: None, marker }, Vec::new()))
|
||||
}
|
||||
|
||||
/// Read one `<text>`: the pending text and its `url(#…)` paints.
|
||||
@@ -1469,6 +1483,7 @@ impl Ctx {
|
||||
let mut obj = TextObject::point(Point::ZERO, "", CharStyle::default());
|
||||
let mut breaks: Vec<Break> = vec![];
|
||||
let mut para_styles: Vec<ParaStyle> = vec![];
|
||||
let mut rest = vec![];
|
||||
if let Some((tp, followed)) = path {
|
||||
let bp = &followed.path;
|
||||
// Along the path: dx is extra advance, dy shifts off the path.
|
||||
@@ -1549,46 +1564,37 @@ impl Ctx {
|
||||
obj.kind = TextKind::OnPath { path: PathData::from_bezpath(&bp), start: 0.0, end: None };
|
||||
obj.xf = Affine::IDENTITY;
|
||||
} else {
|
||||
let origin = Point::new(x[0].unwrap_or(0.0) + dx[0], y[0].unwrap_or(0.0) + dy[0]);
|
||||
let (justify, left, starts, unplaced) = lines(&mut cells, &x, &y, &dx, &dy, &anchor_of, &pin, origin.x, &mut breaks);
|
||||
if unplaced > 0 {
|
||||
let whole = cells.clone();
|
||||
let mut ys = vec![];
|
||||
let (b, p, unplaced) = place(&mut cells, &x, &y, &dx, &dy, &anchor_of, &pin, &mut obj, &mut ys);
|
||||
(breaks, para_styles) = (b, p);
|
||||
if !unplaced.is_empty() {
|
||||
// One object cannot put every absolutely placed character on its x: the text becomes
|
||||
// several, the first of them `obj`.
|
||||
let mut pieces = split(&whole, &x, &y, &dx, &dy, &ys, &anchor_of, &pin, unplaced).into_iter();
|
||||
if let Some(first) = pieces.next() {
|
||||
(obj, cells, breaks, para_styles) = (first.obj, first.cells, first.breaks, first.paras);
|
||||
}
|
||||
rest = pieces
|
||||
.map(|mut p| {
|
||||
let servers = finish(&mut p.obj, &p.cells, &p.breaks, p.paras, &pin);
|
||||
(p.obj, servers)
|
||||
})
|
||||
.collect();
|
||||
warnings.push(format!(
|
||||
"{label}: {unplaced} absolutely placed character(s) between characters of the other direction keep their place in the line"
|
||||
"{label}: imported as {} point type objects in a group, since one object cannot put every character on its own x",
|
||||
rest.len() + 1
|
||||
));
|
||||
}
|
||||
obj.para.justify = justify;
|
||||
obj.xf = Affine::translate((finite(left), finite(origin.y)));
|
||||
// Lines anchored differently or at different x (paragraphs aligned or indented
|
||||
// differently): each line's paragraph takes its alignment, and indents that put it
|
||||
// where it was.
|
||||
if starts.iter().any(|&(_, a, ax)| a != starts[0].1 || ax != starts[0].2) {
|
||||
for (k, &(_, a, ax)) in starts.iter().enumerate() {
|
||||
let d = finite(ax - left);
|
||||
let mut pa = ParaStyle { justify: justify_of(a), ..ParaStyle::default() };
|
||||
match pa.justify {
|
||||
Justify::Center if d >= 0.0 => pa.left_indent = 2.0 * d,
|
||||
Justify::Center => pa.right_indent = -2.0 * d,
|
||||
Justify::Right => pa.right_indent = -d,
|
||||
_ => pa.left_indent = d,
|
||||
}
|
||||
let count = if k == 0 { 1 } else { breaks.get(k - 1).map_or(1, |b| b.count) };
|
||||
para_styles.extend(std::iter::repeat_n(pa, count));
|
||||
}
|
||||
}
|
||||
}
|
||||
let (runs, servers) = assemble(&cells, &breaks).0;
|
||||
obj.runs = runs;
|
||||
if !para_styles.is_empty() {
|
||||
obj.set_paragraph_styles(para_styles);
|
||||
}
|
||||
pin(&mut obj);
|
||||
keep_reader_anchors(&mut obj);
|
||||
let servers = finish(&mut obj, &cells, &breaks, para_styles, &pin);
|
||||
// The placeholder covers the text (laid out when a paint server needs its bounding box).
|
||||
let b = if paints.is_empty() { obj.bounds() } else { Some(obj.xf.transform_rect_bbox(measure(&obj).bounds)) }.unwrap_or_default();
|
||||
let bounds = |o: &TextObject| if paints.is_empty() { o.bounds() } else { Some(o.xf.transform_rect_bbox(measure(o).bounds)) };
|
||||
let b = rest.iter().filter_map(|(o, _)| bounds(o)).fold(bounds(&obj), |all, b| Some(all.map_or(b, |a| a.union(b)))).unwrap_or_default();
|
||||
let marker = Rect::new(b.x0, b.y0, b.x1.max(b.x0 + 1.0), b.y1.max(b.y0 + 1.0));
|
||||
let name = t.attribute("id").unwrap_or("").to_string();
|
||||
let non_scaling = vector_effect::is_non_scaling(&self.css, t);
|
||||
Some((PendingText { name, obj, servers, paints: paints.len(), non_scaling, under, marker }, paints))
|
||||
Some((PendingText { name, obj, servers, rest, paints: paints.len(), non_scaling, under, marker }, paints))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1683,13 +1689,145 @@ fn leading_tolerance(spacing: f64) -> f64 {
|
||||
0.01_f64.min(spacing.abs() * 1e-3)
|
||||
}
|
||||
|
||||
/// Point type `obj` of `cells` placed by the positioning lists ([`lines`]): sets its justification
|
||||
/// and transform, and returns its line breaks, its paragraph styles and the absolutely placed
|
||||
/// characters kerning cannot put on their x. `ys` takes each character's line baseline and y.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn place(
|
||||
cells: &mut [Cell],
|
||||
x: &[Option<f64>],
|
||||
y: &[Option<f64>],
|
||||
dx: &[f64],
|
||||
dy: &[f64],
|
||||
anchor_of: &dyn Fn(usize) -> f64,
|
||||
pin: &dyn Fn(&mut TextObject),
|
||||
obj: &mut TextObject,
|
||||
ys: &mut Vec<(f64, f64)>,
|
||||
) -> (Vec<Break>, Vec<ParaStyle>, Vec<usize>) {
|
||||
let mut breaks = vec![];
|
||||
let mut para_styles = vec![];
|
||||
let origin = Point::new(x[0].unwrap_or(0.0) + dx[0], y[0].unwrap_or(0.0) + dy[0]);
|
||||
let (justify, left, starts, unplaced) = lines(cells, x, y, dx, dy, anchor_of, pin, origin.x, &mut breaks, ys);
|
||||
obj.para.justify = justify;
|
||||
obj.xf = Affine::translate((finite(left), finite(origin.y)));
|
||||
// Lines anchored differently or at different x (paragraphs aligned or indented
|
||||
// differently): each line's paragraph takes its alignment, and indents that put it
|
||||
// where it was.
|
||||
if starts.iter().any(|&(_, a, ax)| a != starts[0].1 || ax != starts[0].2) {
|
||||
for (k, &(_, a, ax)) in starts.iter().enumerate() {
|
||||
let d = finite(ax - left);
|
||||
let mut pa = ParaStyle { justify: justify_of(a), ..ParaStyle::default() };
|
||||
match pa.justify {
|
||||
Justify::Center if d >= 0.0 => pa.left_indent = 2.0 * d,
|
||||
Justify::Center => pa.right_indent = -2.0 * d,
|
||||
Justify::Right => pa.right_indent = -d,
|
||||
_ => pa.left_indent = d,
|
||||
}
|
||||
let count = if k == 0 { 1 } else { breaks.get(k - 1).map_or(1, |b| b.count) };
|
||||
para_styles.extend(std::iter::repeat_n(pa, count));
|
||||
}
|
||||
}
|
||||
(breaks, para_styles, unplaced)
|
||||
}
|
||||
|
||||
/// Gives `obj` the runs of `cells` with `breaks`, its paragraph styles and its paragraph
|
||||
/// directions; returns the paint indices of its runs.
|
||||
fn finish(obj: &mut TextObject, cells: &[Cell], breaks: &[Break], para_styles: Vec<ParaStyle>, pin: &dyn Fn(&mut TextObject)) -> Vec<Key> {
|
||||
let (runs, servers) = assemble(cells, breaks).0;
|
||||
obj.runs = runs;
|
||||
if !para_styles.is_empty() {
|
||||
obj.set_paragraph_styles(para_styles);
|
||||
}
|
||||
pin(obj);
|
||||
keep_reader_anchors(obj);
|
||||
servers
|
||||
}
|
||||
|
||||
/// One point type object of a text [`split`] into several, before [`finish`].
|
||||
struct Piece {
|
||||
obj: TextObject,
|
||||
cells: Vec<Cell>,
|
||||
breaks: Vec<Break>,
|
||||
paras: Vec<ParaStyle>,
|
||||
}
|
||||
|
||||
/// How many times [`split`] cuts a piece before the characters kerning cannot place; a piece that
|
||||
/// still has such characters is then cut before each of its chunks.
|
||||
const MAX_SPLITS: usize = 3;
|
||||
|
||||
/// Point type objects, in text order, that together put every absolutely placed character of
|
||||
/// `cells` (before [`place`] kerned them) on its x. SVG anchors each chunk on its own and reorders
|
||||
/// right-to-left characters only within a chunk (SVG 2 › Text, https://www.w3.org/TR/SVG2/text.html),
|
||||
/// while one object reorders the whole
|
||||
/// line: a left-to-right character drawn right before a right-to-left one has no kerning between
|
||||
/// them. The text is cut before each character `unplaced` lists, and each piece placed again. `ys`
|
||||
/// holds each character's line baseline and y, so that a piece keeps its characters' baselines.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn split(
|
||||
cells: &[Cell],
|
||||
x: &[Option<f64>],
|
||||
y: &[Option<f64>],
|
||||
dx: &[f64],
|
||||
dy: &[f64],
|
||||
ys: &[(f64, f64)],
|
||||
anchor_of: &dyn Fn(usize) -> f64,
|
||||
pin: &dyn Fn(&mut TextObject),
|
||||
unplaced: Vec<usize>,
|
||||
) -> Vec<Piece> {
|
||||
let piece = |r: Range<usize>| {
|
||||
let s = r.start;
|
||||
let mut cells = cells[r.clone()].to_vec();
|
||||
let (base, cur) = ys.get(s).copied().unwrap_or((0.0, 0.0));
|
||||
// The piece starts on its line's baseline, and its first character keeps its own y.
|
||||
cells[0].style.baseline_shift += base - cur;
|
||||
let py: Vec<Option<f64>> = r
|
||||
.clone()
|
||||
.map(|i| match i - s {
|
||||
0 => Some(base),
|
||||
1 => y[i].or(Some(cur)),
|
||||
_ => y[i],
|
||||
})
|
||||
.collect();
|
||||
let mut pdy = dy[r.clone()].to_vec();
|
||||
pdy[0] = 0.0;
|
||||
let mut obj = TextObject::point(Point::ZERO, "", CharStyle::default());
|
||||
let (breaks, paras, unplaced) = place(&mut cells, &x[r.clone()], &py, &dx[r], &pdy, &|j| anchor_of(s + j), pin, &mut obj, &mut vec![]);
|
||||
(Piece { obj, cells, breaks, paras }, unplaced.into_iter().map(|j| s + j).collect::<Vec<_>>())
|
||||
};
|
||||
let mut done = vec![];
|
||||
let mut todo = vec![(0..cells.len(), unplaced, 0)];
|
||||
while let Some((range, failed, round)) = todo.pop() {
|
||||
// Past the last round every chunk of the piece is a piece of its own, and so has no
|
||||
// characters to place.
|
||||
let mut cuts: Vec<usize> = if round < MAX_SPLITS { failed } else { (range.start + 1..range.end).filter(|&i| x[i].is_some()).collect() };
|
||||
cuts.sort_unstable();
|
||||
cuts.dedup();
|
||||
let mut from = range.start;
|
||||
for to in cuts.into_iter().chain([range.end]) {
|
||||
if to <= from || to > range.end {
|
||||
continue;
|
||||
}
|
||||
match piece(from..to) {
|
||||
(p, failed) if failed.is_empty() => done.push((from, p)),
|
||||
(_, failed) => todo.push((from..to, failed, round + 1)),
|
||||
}
|
||||
from = to;
|
||||
}
|
||||
}
|
||||
done.sort_by_key(|p| p.0);
|
||||
done.into_iter().map(|p| p.1).collect()
|
||||
}
|
||||
|
||||
/// A line's first character, alignment (as for [`justify_of`]) and anchor x.
|
||||
type LineStart = (usize, f64, f64);
|
||||
|
||||
/// Point type: line breaks, baseline shifts and kerning from the positioning lists. Returns the
|
||||
/// justification, the x of the first line's left (or anchor) edge and each line's first
|
||||
/// character, alignment (as for [`justify_of`]) and anchor x. `anchor_of` gives where the chunk
|
||||
/// starting at a character sits on its anchor, and `pin` sets the paragraph directions of the
|
||||
/// text ([`pin_direction`]). When characters are placed on their own, every line is left-aligned
|
||||
/// and its anchor x is its left edge. Also returns how many absolutely placed characters kerning
|
||||
/// cannot put on their x.
|
||||
/// and its anchor x is its left edge. Also returns the absolutely placed characters kerning cannot
|
||||
/// put on their x. `ys` takes each character's line baseline and y.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn lines(
|
||||
cells: &mut [Cell],
|
||||
@@ -1701,10 +1839,13 @@ fn lines(
|
||||
pin: &dyn Fn(&mut TextObject),
|
||||
x0: f64,
|
||||
breaks: &mut Vec<Break>,
|
||||
) -> (Justify, f64, Vec<(usize, f64, f64)>, usize) {
|
||||
ys: &mut Vec<(f64, f64)>,
|
||||
) -> (Justify, f64, Vec<LineStart>, Vec<usize>) {
|
||||
let n = cells.len();
|
||||
let y0 = y[0].unwrap_or(0.0) + dy[0];
|
||||
let (mut base, mut cur) = (y0, y0);
|
||||
ys.clear();
|
||||
ys.push((y0, y0));
|
||||
// Line starts (first character, anchor x) and absolutely placed characters (index, x).
|
||||
let mut lines = vec![(0, x0)];
|
||||
let mut targets: Vec<(usize, f64)> = vec![];
|
||||
@@ -1723,9 +1864,11 @@ fn lines(
|
||||
breaks.push(Break { at: i, count: count as usize, leading: gap / count });
|
||||
lines.push((i, ax + dx[i]));
|
||||
(base, cur) = (ny, ny);
|
||||
ys.push((base, cur));
|
||||
continue;
|
||||
}
|
||||
cur = ny;
|
||||
ys.push((base, cur));
|
||||
match x[i] {
|
||||
Some(ax) => targets.push((i, ax + dx[i])),
|
||||
None => cells[i - 1].kern += dx[i],
|
||||
@@ -1744,7 +1887,7 @@ fn lines(
|
||||
}
|
||||
if targets.is_empty() {
|
||||
let starts = lines.iter().map(|&(s, lx)| (s, anchor_of(s), lx)).collect();
|
||||
return (justify_of(anchor_of(0)), x0, starts, 0);
|
||||
return (justify_of(anchor_of(0)), x0, starts, vec![]);
|
||||
}
|
||||
// Absolutely placed characters: lay the text out left-aligned and kern each one onto its x.
|
||||
// SVG anchors every absolutely placed chunk on its own, so a chunk not anchored at its left
|
||||
@@ -1774,7 +1917,7 @@ fn lines(
|
||||
let mut wants: Vec<(usize, f64)> = vec![];
|
||||
// Absolutely placed characters drawn right next to a placed neighbor with no kerning between
|
||||
// them (a left-to-right character between right-to-left ones): they stay where the layout puts them.
|
||||
let mut unplaced = 0;
|
||||
let mut unplaced = vec![];
|
||||
// Kerning changes shaping (pair kerning is off for manually kerned characters): repeat until
|
||||
// every character sits on its x.
|
||||
for round in 0..4 {
|
||||
@@ -1811,7 +1954,7 @@ fn lines(
|
||||
// character's horizontal scale, so each correction is divided by it.
|
||||
let mut worst = 0.0f64;
|
||||
let mut from = 0;
|
||||
unplaced = 0;
|
||||
unplaced.clear();
|
||||
while from < wants.len() {
|
||||
let l = line_of(wants[from].0);
|
||||
let to = from + wants[from..].partition_point(|&(i, _)| line_of(i) == l);
|
||||
@@ -1831,35 +1974,35 @@ fn lines(
|
||||
.filter_map(|&(i, _)| (lines[l].0..i).rev().find_map(|j| pens[j]).map(|k| (2 * k.rank + if k.rtl { 1 } else { 3 }, i - 1)))
|
||||
.collect();
|
||||
cuts.sort_unstable();
|
||||
let mut points: Vec<(usize, f64, f64)> =
|
||||
on_line.iter().filter_map(|&(i, want)| pens[i].map(|p| (2 * p.rank + 2, p.start, want))).collect();
|
||||
let mut points: Vec<(usize, f64, f64, usize)> =
|
||||
on_line.iter().filter_map(|&(i, want)| pens[i].map(|p| (2 * p.rank + 2, p.start, want, i))).collect();
|
||||
points.sort_by_key(|p| p.0);
|
||||
// The character kerned at the first cut between places `a` and `b`.
|
||||
let cut = |a: usize, b: usize| cuts.get(cuts.partition_point(|c| c.0 <= a)).filter(|c| c.0 < b).map(|c| c.1);
|
||||
let split = points.partition_point(|p| p.0 < home);
|
||||
// Drawn right of the line's first chunk: kerning moves the character away from it.
|
||||
let (mut prev, mut moved) = (home, 0.0);
|
||||
for &(place, start, want) in &points[split..] {
|
||||
for &(place, start, want, i) in &points[split..] {
|
||||
if let Some(k) = cut(prev, place) {
|
||||
let d = want - (start - p0 + moved);
|
||||
cells[k].kern += d / spacing_scale(&cells[k].style, false);
|
||||
moved += d;
|
||||
worst = worst.max(d.abs());
|
||||
} else {
|
||||
unplaced += 1;
|
||||
unplaced.push(i);
|
||||
}
|
||||
prev = place;
|
||||
}
|
||||
// Drawn left of it: kerning moves the chunk (and what lies between) away from the character.
|
||||
(prev, moved) = (home, 0.0);
|
||||
for &(place, start, want) in points[..split].iter().rev() {
|
||||
for &(place, start, want, i) in points[..split].iter().rev() {
|
||||
if let Some(k) = cut(place, prev) {
|
||||
let d = start - p0 - moved - want;
|
||||
cells[k].kern += d / spacing_scale(&cells[k].style, false);
|
||||
moved += d;
|
||||
worst = worst.max(d.abs());
|
||||
} else {
|
||||
unplaced += 1;
|
||||
unplaced.push(i);
|
||||
}
|
||||
prev = place;
|
||||
}
|
||||
@@ -2064,7 +2207,8 @@ fn pens(lay: &TextLayout, bytes: &[usize], cells: &[Cell]) -> Vec<Option<Pen>> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
type Key = (Option<usize>, Option<usize>);
|
||||
/// The indices of a run's fill and stroke `url(#…)` paints.
|
||||
pub(super) type Key = (Option<usize>, Option<usize>);
|
||||
type Runs = (Vec<TextRun>, Vec<Key>);
|
||||
|
||||
/// Runs (and their paint indices) from the characters, with `breaks` inserted; also the byte offset
|
||||
|
||||
@@ -125,6 +125,20 @@ fn a_text_clip_path_with_a_clip_rule_or_a_clip_of_its_own_clips_by_its_outlines(
|
||||
assert_eq!(shapes[0].1, vectorcraft_geom::FillRule::EvenOdd);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_text_imported_as_several_objects_clips_by_all_their_outlines() {
|
||||
// One object cannot put ג on its x, so the text is several objects; the clip outlines all of them.
|
||||
let d = open(
|
||||
r##"<clipPath id="c"><text x="100 160 220" y="80" direction="rtl" font-size="20">אbג</text></clipPath>
|
||||
<rect width="400" height="300" clip-path="url(#c)"/>"##,
|
||||
);
|
||||
let (clip, _) = clip_group(&top(&d)[0]);
|
||||
assert!(!matches!(clip.kind, NodeKind::Text(_)), "{:?}", clip.kind);
|
||||
let b = clip_bounds(clip);
|
||||
// ג ends at 220, the first object at 160.
|
||||
assert!(b.x1 > 200.0 && b.x1 <= 220.0 + 1e-6 && b.x0 < 100.0, "{b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tspans_and_type_on_a_path_clip_too() {
|
||||
let d = open(
|
||||
|
||||
@@ -362,6 +362,133 @@ fn a_cmyk_tiff_keeps_its_resolution_turned_or_not() {
|
||||
}
|
||||
}
|
||||
|
||||
/// A made-up ICC profile of `len` bytes (at least a header's 128) whose header names the color
|
||||
/// space `space`; the bytes after the header differ from place to place.
|
||||
fn icc_profile(space: &[u8; 4], len: usize) -> Vec<u8> {
|
||||
let mut icc: Vec<u8> = (0..len).map(|i| (i % 251) as u8).collect();
|
||||
icc[..4].copy_from_slice(&u32::try_from(len).unwrap().to_be_bytes());
|
||||
icc[12..16].copy_from_slice(b"mntr");
|
||||
icc[16..20].copy_from_slice(space);
|
||||
icc[36..40].copy_from_slice(b"acsp");
|
||||
icc
|
||||
}
|
||||
|
||||
/// `tiff` (little-endian) with an ICCProfile tag (34675, of type UNDEFINED) holding `icc`: its first
|
||||
/// directory copied to the end of the file with the tag added in order.
|
||||
fn tiff_with_icc(tiff: &[u8], icc: &[u8]) -> Vec<u8> {
|
||||
let at = usize::try_from(u32::from_le_bytes(tiff[4..8].try_into().unwrap())).unwrap();
|
||||
let n = usize::from(u16::from_le_bytes([tiff[at], tiff[at + 1]]));
|
||||
let mut entries: Vec<Vec<u8>> = tiff[at + 2..at + 2 + 12 * n].chunks(12).map(<[u8]>::to_vec).collect();
|
||||
let mut out = tiff.to_vec();
|
||||
if out.len() % 2 == 1 {
|
||||
out.push(0);
|
||||
}
|
||||
let data = u32::try_from(out.len()).unwrap();
|
||||
out.extend(icc);
|
||||
if out.len() % 2 == 1 {
|
||||
out.push(0);
|
||||
}
|
||||
let i = entries.iter().position(|e| u16::from_le_bytes([e[0], e[1]]) > 34675).unwrap_or(n);
|
||||
let count = u32::try_from(icc.len()).unwrap();
|
||||
entries.insert(i, [&34675u16.to_le_bytes()[..], &7u16.to_le_bytes(), &count.to_le_bytes(), &data.to_le_bytes()].concat());
|
||||
let ifd = u32::try_from(out.len()).unwrap();
|
||||
out[4..8].copy_from_slice(&ifd.to_le_bytes());
|
||||
out.extend(u16::try_from(n + 1).unwrap().to_le_bytes());
|
||||
out.extend(entries.concat());
|
||||
out.extend([0; 4]);
|
||||
out
|
||||
}
|
||||
|
||||
/// A little-endian EXIF block (a TIFF header and one directory) giving Orientation `orientation`.
|
||||
fn exif_block(orientation: u16) -> Vec<u8> {
|
||||
let o = orientation.to_le_bytes();
|
||||
[b"II".as_slice(), &[0x2a, 0, 8, 0, 0, 0], &[1, 0], &[0x12, 0x01, 3, 0, 1, 0, 0, 0, o[0], o[1], 0, 0], &[0, 0, 0, 0]].concat()
|
||||
}
|
||||
|
||||
/// The ICC profile and the bits per sample of the PNG `im` is stored as.
|
||||
fn stored_icc(d: &Document, im: &ImageObject) -> (Option<Vec<u8>>, u16) {
|
||||
use image::ImageDecoder as _;
|
||||
let blob = &d.images[&im.key];
|
||||
assert_eq!(blob.mime, "image/png");
|
||||
let mut dec = image::codecs::png::PngDecoder::new(std::io::Cursor::new(blob.bytes.as_slice())).unwrap();
|
||||
let color = dec.original_color_type();
|
||||
(dec.icc_profile().unwrap(), color.bits_per_pixel() / u16::from(color.channel_count()))
|
||||
}
|
||||
|
||||
/// A raster that import writes again as PNG keeps the gray or RGB ICC profile its file carries,
|
||||
/// byte for byte, linked and as a data URL: a TIFF, turned or not, and a turned PNG and JPEG, with
|
||||
/// 16-bit samples kept at 16 bits and the resolution kept beside the profile. A profile of another
|
||||
/// color space than the written samples', one too short to be a profile, and one on a TIFF whose
|
||||
/// pixels are read as RGBA by its own reader are left out, and the image still imports.
|
||||
#[test]
|
||||
fn a_raster_written_again_as_png_keeps_its_icc_profile() {
|
||||
use image::{DynamicImage, ImageEncoder as _};
|
||||
let (rgb_icc, gray_icc, cmyk_icc) = (icc_profile(b"RGB ", 600), icc_profile(b"GRAY", 300), icc_profile(b"CMYK", 400));
|
||||
let rgb8 = DynamicImage::ImageRgb8(image::RgbImage::from_fn(3, 2, |x, y| image::Rgb([u8::try_from(x * 70 + y * 9).unwrap(), 200, 13])));
|
||||
let gray8 = DynamicImage::ImageLuma8(image::GrayImage::from_fn(3, 2, |x, y| image::Luma([u8::try_from(x * 80 + y * 7).unwrap()])));
|
||||
let rgb16 = DynamicImage::ImageRgb16(image::ImageBuffer::from_fn(3, 2, |x, y| {
|
||||
let v = u16::try_from(x * 0x1111 + y * 0x2345).unwrap();
|
||||
image::Rgb([0x1000 + v, 0x8001 + v, 0xF0F3 - v])
|
||||
}));
|
||||
let tiff_of = |img: &DynamicImage, icc: &[u8]| {
|
||||
let mut out = Vec::new();
|
||||
let mut enc = image::codecs::tiff::TiffEncoder::new(std::io::Cursor::new(&mut out));
|
||||
enc.set_icc_profile(icc.to_vec()).unwrap();
|
||||
img.write_with_encoder(enc).unwrap();
|
||||
out
|
||||
};
|
||||
let png = {
|
||||
let mut out = Vec::new();
|
||||
let mut enc = image::codecs::png::PngEncoder::new(&mut out);
|
||||
enc.set_icc_profile(rgb_icc.clone()).unwrap();
|
||||
enc.set_exif_metadata(exif_block(6)).unwrap();
|
||||
rgb16.write_with_encoder(enc).unwrap();
|
||||
out
|
||||
};
|
||||
let jpg = {
|
||||
let mut out = Vec::new();
|
||||
let mut enc = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut out, 95);
|
||||
enc.set_icc_profile(rgb_icc.clone()).unwrap();
|
||||
rgb8.write_with_encoder(enc).unwrap();
|
||||
let exif = [b"Exif\0\0".as_slice(), &exif_block(6)].concat();
|
||||
let mut turned = out[..2].to_vec();
|
||||
turned.extend([0xff, 0xe1]);
|
||||
turned.extend(u16::try_from(exif.len() + 2).unwrap().to_be_bytes());
|
||||
turned.extend(&exif);
|
||||
turned.extend(&out[2..]);
|
||||
turned
|
||||
};
|
||||
let gray = [0, 0, 255, 255, 0, 0, 255, 255];
|
||||
let turned_gray = tiff_with_icc(&tiff_at(4, 2, 1, &gray, 6, Some((300, 150))), &gray_icc);
|
||||
let gray_alpha = [0, 255, 0, 255, 255, 255, 255, 255, 0, 255, 0, 255, 255, 255, 255, 255];
|
||||
// (what, file, the ICC profile to keep, bits per sample, resolution)
|
||||
type Case<'a> = (&'a str, Vec<u8>, Option<&'a [u8]>, u16, Option<(f64, f64)>);
|
||||
let cases: Vec<Case> = vec![
|
||||
("RGB TIFF", tiff_of(&rgb8, &rgb_icc), Some(&rgb_icc), 8, None),
|
||||
("gray TIFF", tiff_of(&gray8, &gray_icc), Some(&gray_icc), 8, None),
|
||||
("16-bit RGB TIFF", tiff_of(&rgb16, &rgb_icc), Some(&rgb_icc), 16, None),
|
||||
("gray TIFF, orientation 6, with a resolution", turned_gray, Some(&gray_icc), 8, Some((150.0, 300.0))),
|
||||
("16-bit RGB PNG, orientation 6", png, Some(&rgb_icc), 16, None),
|
||||
("JPEG, orientation 6", jpg, Some(&rgb_icc), 8, None),
|
||||
("RGB TIFF with a gray profile", tiff_of(&rgb8, &gray_icc), None, 8, None),
|
||||
("gray TIFF with an RGB profile", tiff_of(&gray8, &rgb_icc), None, 8, None),
|
||||
("RGB TIFF with a CMYK profile", tiff_of(&rgb8, &cmyk_icc), None, 8, None),
|
||||
("RGB TIFF with a profile too short to be one", tiff_of(&rgb8, &rgb_icc[..40]), None, 8, None),
|
||||
("gray TIFF with alpha, read as RGBA", tiff_with_icc(&tiff(4, 2, 2, &gray_alpha, 1), &rgb_icc), None, 8, None),
|
||||
];
|
||||
let dir = folder("icc");
|
||||
for (what, file, icc, bits, ppi) in cases {
|
||||
std::fs::write(dir.join("photo.img"), &file).unwrap();
|
||||
let data = format!("data:;base64,{}", base64_encode(&file));
|
||||
for href in ["photo.img", data.as_str()] {
|
||||
let what = format!("{what}, {}", &href[..href.len().min(12)]);
|
||||
let (d, im) = import_one(&format!(r#"<image href="{href}" width="20" height="40"/>"#), Some(&dir));
|
||||
assert_eq!(stored_icc(&d, &im), (icc.map(<[u8]>::to_vec), bits), "{what}");
|
||||
assert_eq!(stored_ppi(&d, &im), ppi, "{what}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A turned JPEG that a linked SVG file links to is turned too.
|
||||
#[test]
|
||||
fn a_turned_jpeg_linked_from_a_linked_svg_file_imports_upright() {
|
||||
|
||||
@@ -974,7 +974,7 @@ fn absolutely_placed_right_to_left_characters_sit_on_their_own_x() {
|
||||
vec![(0..2, 20.0), (3..4, 100.0), (4..5, 160.0)],
|
||||
),
|
||||
];
|
||||
let unplaced = |w: &[String]| w.iter().any(|w| w.contains("absolutely placed"));
|
||||
let unplaced = |w: &[String]| w.iter().any(|w| w.contains("point type objects"));
|
||||
for (body, share, chunks) in cases {
|
||||
let (d, w) = import_with_report(&svg(&body)).unwrap();
|
||||
assert!(!unplaced(&w), "{body}: {w:?}");
|
||||
@@ -988,12 +988,82 @@ fn absolutely_placed_right_to_left_characters_sit_on_their_own_x() {
|
||||
assert!(close(left, want, 0.05), "{body}: the chunk {bytes:?} spans {left}..{right}, so it does not start at {want}");
|
||||
}
|
||||
}
|
||||
// A left-to-right character between right-to-left ones is drawn right next to the one after
|
||||
// it, with no kerning between them: that one keeps its place in the line, and a warning says so.
|
||||
let (d, w) = import_with_report(&svg(r#"<text x="100 160 220" y="80" direction="rtl" font-size="20">אbג</text>"#)).unwrap();
|
||||
assert!(unplaced(&w), "{w:?}");
|
||||
let (left, right) = chunk_edges(only_text(&d), 2..3);
|
||||
assert!(close(right, 160.0, 0.05), "b spans {left}..{right}");
|
||||
}
|
||||
|
||||
/// The document-space edges of character `ch`, in whichever text of `d` holds it (as
|
||||
/// [`chunk_edges`] measures them), and the y it is drawn at (its baseline moved by its baseline
|
||||
/// shift).
|
||||
fn char_edges(d: &Document, ch: char) -> (f64, f64, f64) {
|
||||
let t = texts(d).into_iter().find(|t| t.plain_text().contains(ch)).unwrap_or_else(|| panic!("no text holds {ch}"));
|
||||
let at = t.plain_text().find(ch).unwrap();
|
||||
let (left, right) = chunk_edges(t, at..at + ch.len_utf8());
|
||||
let shift = t.runs.iter().find(|r| r.text.contains(ch)).unwrap().style.baseline_shift;
|
||||
let y = layout(FontDb::global(), t).glyphs.iter().find(|g| g.byte == at).map(|g| (t.xf * g.origin).y).unwrap() - shift;
|
||||
(left, right, y)
|
||||
}
|
||||
|
||||
/// SVG 2 › Text (https://www.w3.org/TR/SVG2/text.html): each absolute position starts a chunk,
|
||||
/// and bidi reordering happens only within a chunk. A left-to-right character drawn right before a
|
||||
/// right-to-left one has no kerning between them in one text object, so such a text imports as a
|
||||
/// group of point type objects, each character on its own x.
|
||||
#[test]
|
||||
fn absolutely_placed_characters_one_object_cannot_place_import_as_a_group() {
|
||||
// (markup, the characters of its objects in order, each character with the x its right edge
|
||||
// sits on and its baseline)
|
||||
type Case = (&'static str, &'static str, Vec<(char, f64, f64)>);
|
||||
let cases: Vec<Case> = vec![
|
||||
(
|
||||
r#"<text id="t" x="100 160 220" y="80" direction="rtl" font-size="20">אbג</text>"#,
|
||||
"אbג",
|
||||
vec![('א', 100.0, 80.0), ('b', 160.0, 80.0), ('ג', 220.0, 80.0)],
|
||||
),
|
||||
(
|
||||
r#"<text id="t" x="100 160 220 280" y="80" direction="rtl" font-size="20">אbגd</text>"#,
|
||||
"אbגd",
|
||||
vec![('א', 100.0, 80.0), ('b', 160.0, 80.0), ('ג', 220.0, 80.0), ('d', 280.0, 80.0)],
|
||||
),
|
||||
// x values that decrease.
|
||||
(
|
||||
r#"<text id="t" x="220 160 100" y="80" direction="rtl" font-size="20">אbג</text>"#,
|
||||
"אbג",
|
||||
vec![('א', 220.0, 80.0), ('b', 160.0, 80.0), ('ג', 100.0, 80.0)],
|
||||
),
|
||||
// On a second line, and with a baseline of its own.
|
||||
(
|
||||
r#"<text id="t" direction="rtl" font-size="20"><tspan x="40" y="40">אב</tspan><tspan x="100 160 220" y="80 80 90">גbד</tspan></text>"#,
|
||||
"אבגbד",
|
||||
vec![('א', 40.0, 40.0), ('ג', 100.0, 80.0), ('b', 160.0, 80.0), ('ד', 220.0, 90.0)],
|
||||
),
|
||||
];
|
||||
for (body, text, chars) in cases {
|
||||
let (d, w) = import_with_report(&svg(body)).unwrap();
|
||||
assert!(w.iter().any(|w| w.contains("point type objects in a group")), "{body}: {w:?}");
|
||||
let top = d.layers[0].children().unwrap();
|
||||
assert_eq!(top.len(), 1, "{body}: {top:?}");
|
||||
assert_eq!(top[0].name.as_deref(), Some("t"), "{body}: the group takes the element's id");
|
||||
let NodeKind::Group { children, clip: false } = &top[0].kind else { panic!("{body}: {:?}", top[0].kind) };
|
||||
assert!(children.len() > 1 && children.iter().all(|c| matches!(c.kind, NodeKind::Text(_))), "{body}: {children:?}");
|
||||
let all: String = texts(&d).iter().map(|t| t.plain_text().replace('\n', "")).collect();
|
||||
assert_eq!(all, text, "{body}: every character once, in order");
|
||||
for (ch, x, y) in chars {
|
||||
let (left, right, base) = char_edges(&d, ch);
|
||||
assert!(close(right, x, 0.05), "{body}: {ch} spans {left}..{right}, not ending at {x}");
|
||||
assert!(close(base, y, 1e-6), "{body}: {ch} sits on {base}, not {y}");
|
||||
}
|
||||
}
|
||||
// Placed characters one object can place stay one object, also when their x values decrease.
|
||||
for (body, chars) in [
|
||||
(r#"<text x="100 160 220" y="80" direction="rtl" font-size="20">אbc</text>"#, [('א', 100.0), ('b', 160.0), ('c', 220.0)]),
|
||||
(r#"<text x="220 160 100" y="80" direction="rtl" font-size="20">אבג</text>"#, [('א', 220.0), ('ב', 160.0), ('ג', 100.0)]),
|
||||
] {
|
||||
let (d, w) = import_with_report(&svg(body)).unwrap();
|
||||
assert!(!w.iter().any(|w| w.contains("point type objects")), "{body}: {w:?}");
|
||||
only_text(&d);
|
||||
for (ch, x) in chars {
|
||||
let (left, right, _) = char_edges(&d, ch);
|
||||
assert!(close(right, x, 0.05), "{body}: {ch} spans {left}..{right}, not ending at {x}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -118,6 +118,49 @@ fn opaque_pixels_stay_opaque_where_warp_pieces_overlap() {
|
||||
}
|
||||
}
|
||||
|
||||
/// Pieces the file leaves out share no image: with Images set to Link, the warp pieces of a linked
|
||||
/// image that are hidden, or sit in hidden clip groups, put no `<image>` naming its file in the
|
||||
/// defs unless hidden layers are kept. Visible pieces share one.
|
||||
#[test]
|
||||
fn hidden_warp_pieces_share_no_image() {
|
||||
let path = "/away/photo.png";
|
||||
let svg = |d: &Document, hidden_layers: bool| {
|
||||
let opts = ExportOptions { images: vectorcraft_svg::ImageMode::Link, hidden_layers, ..ExportOptions::default() };
|
||||
export_full(d, &opts, None).svg
|
||||
};
|
||||
// Every image in `n` linked to `path`.
|
||||
fn link(n: &mut Node, path: &str) {
|
||||
if let NodeKind::Image(im) = &mut n.kind {
|
||||
im.link = Some(vectorcraft_doc::LinkInfo::new(path));
|
||||
}
|
||||
for c in n.children_mut().into_iter().flatten() {
|
||||
link(std::sync::Arc::make_mut(c), path);
|
||||
}
|
||||
}
|
||||
for masked in [false, true] {
|
||||
// Hide every image (`ancestor` false), or every clip group holding one (`ancestor` true).
|
||||
for ancestor in [false, true] {
|
||||
let mut d = warped_pixels(&|p| p, masked, [255, 0, 0, 255], |_| {});
|
||||
let layer = std::sync::Arc::make_mut(&mut d.layers[0]);
|
||||
let g = std::sync::Arc::make_mut(&mut layer.children_mut().unwrap()[0]);
|
||||
link(g, path);
|
||||
let visible = d.clone();
|
||||
assert_eq!(svg(&visible, false).matches(path).count(), 1, "masked {masked}: the pieces share one image");
|
||||
let layer = std::sync::Arc::make_mut(&mut d.layers[0]);
|
||||
let g = std::sync::Arc::make_mut(&mut layer.children_mut().unwrap()[0]);
|
||||
for piece in g.children_mut().unwrap() {
|
||||
let piece = std::sync::Arc::make_mut(piece);
|
||||
match piece.children_mut() {
|
||||
Some(kids) if !ancestor => std::sync::Arc::make_mut(&mut kids[1]).visible = false,
|
||||
_ => piece.visible = false,
|
||||
}
|
||||
}
|
||||
assert!(!svg(&d, false).contains(path), "masked {masked}, ancestor {ancestor}: {}", svg(&d, false));
|
||||
assert_eq!(svg(&d, true).matches(path).count(), 1, "masked {masked}, ancestor {ancestor}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Pieces of an opaque image are drawn one over another without knockout masks; a colorize paint
|
||||
/// draws a gray image's light pixels partly transparent, so its pieces take them.
|
||||
#[test]
|
||||
|
||||
@@ -1120,14 +1120,15 @@ fn gradient_vector_ends_land_on_a_glyph_anchor() {
|
||||
let acts = tool.pointer(&c, &ev(PointerKind::Drag, near + Vec2::new(1.5, -1.0)));
|
||||
assert!(acts.is_empty(), "drag start, Snap to Glyph {glyphs}: {acts:?}");
|
||||
tool.pointer(&c, &ev(PointerKind::Up, near + Vec2::new(1.5, -1.0)));
|
||||
// The end handle of the rectangle's gradient dragged to the click lands on the anchor.
|
||||
// The end handle of the rectangle's gradient Alt-dragged to the click lands on the anchor.
|
||||
let c = ToolContext { snap_to_glyph: glyphs, ..cx(&d, &on_rect, &p) };
|
||||
let mut tool = GradientTool::default();
|
||||
// Hovering over the handle (on the rectangle's edge) shows no guides.
|
||||
tool.pointer(&c, &ev(PointerKind::Move, Point::new(400.0, 100.0)));
|
||||
assert!(!tool.overlays(&c).iter().any(|o| matches!(o, Overlay::Label { .. })), "hover over the handle");
|
||||
tool.pointer(&c, &ev(PointerKind::Down, Point::new(400.0, 100.0)));
|
||||
let v = preview(&tool.pointer(&c, &ev(PointerKind::Drag, click)));
|
||||
let alt = |kind, q: Point| PointerEvent { mods: crate::Mods { alt: true, ..Default::default() }, ..ev(kind, q) };
|
||||
tool.pointer(&c, &alt(PointerKind::Down, Point::new(400.0, 100.0)));
|
||||
let v = preview(&tool.pointer(&c, &alt(PointerKind::Drag, click)));
|
||||
assert_eq!(lands(at(&v["end"])), glyphs, "end handle, Snap to Glyph {glyphs}: {v}");
|
||||
tool.pointer(&c, &ev(PointerKind::Up, click));
|
||||
// The start handle dragged to the click lands on the anchor.
|
||||
|
||||
@@ -6,11 +6,14 @@
|
||||
//! pointer; a click inside selected art applies the gradient from that point.
|
||||
//!
|
||||
//! The annotator is a bar from a round start handle to a square end handle. Drag the start handle
|
||||
//! (or the bar) to move the gradient, the end handle to change its length and angle, and just past
|
||||
//! the end to rotate it. A vector drawn on the art, a click that applies one, and the dragged
|
||||
//! handles snap as drawn points do (the anchors and paths of the art, and with Snap to Glyph the
|
||||
//! guides of live type); Shift keeps the dragged end or handle at 45° steps from the Constrain Angle
|
||||
//! preference, snapping along that step. Colour stops sit under the bar: click the bar to add
|
||||
//! (or the bar) to move the gradient, the end handle to change its length, and just past the end
|
||||
//! to rotate it. The dragged end stays on the bar's line, never nearer the start than
|
||||
//! `MIN_LENGTH`; Alt-drag the end handle to change the length and angle together. A vector drawn
|
||||
//! on the art, a click that applies one, and the dragged handles snap as drawn points do (the
|
||||
//! anchors and paths of the art, and with Snap to Glyph the guides of live type; the end handle
|
||||
//! without Alt only onto points on the bar's line); Shift keeps the end of a drawn vector, the
|
||||
//! Alt-dragged end handle or the start handle at 45° steps from the Constrain Angle preference,
|
||||
//! snapping along that step. Colour stops sit under the bar: click the bar to add
|
||||
//! one, drag one to move it (Alt drags a copy), drag it off the bar to delete it, and drag a
|
||||
//! diamond above the bar to move a midpoint. Double-clicking a stop opens its popover. The
|
||||
//! selected stop (`gradient.selectStop`) is shared with the Gradient and Color panels: Delete or
|
||||
@@ -54,6 +57,9 @@ const LIGHT: [u8; 3] = [0xf0, 0xf0, 0xf0];
|
||||
// Annotator layout and hit radii, in screen pixels.
|
||||
/// Start and end handles.
|
||||
const HANDLE: f64 = 5.0;
|
||||
/// The end handle dragged without Alt stays at least this far from the start (or at the vector's
|
||||
/// own length when that is shorter).
|
||||
const MIN_LENGTH: f64 = 2.0 * HANDLE;
|
||||
/// The rotate zone reaches this far past the end handle.
|
||||
const ROTATE: f64 = 14.0;
|
||||
/// Stop chips sit this far below the bar.
|
||||
@@ -335,6 +341,19 @@ fn run_ticks(cx: &ToolContext, a: &Annotator) -> Vec<Overlay> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Where the end handle dragged to `p` lands when only the length changes: `p` projected onto the
|
||||
/// line of `geom`'s vector, on the side of its end and no nearer the start than `min` (or the
|
||||
/// vector's own length when that is shorter). None for a vector of no length.
|
||||
fn along_bar(geom: &GradientGeom, p: Point, min: f64) -> Option<Point> {
|
||||
let v = geom.end - geom.start;
|
||||
let len = v.hypot();
|
||||
if len < 1e-12 {
|
||||
return None;
|
||||
}
|
||||
let u = v / len;
|
||||
Some(geom.start + u * (p - geom.start).dot(u).max(min.min(len)))
|
||||
}
|
||||
|
||||
/// The vector a click applies to `id`: its current gradient's, else the default fit on its box.
|
||||
fn click_vector(cx: &ToolContext, id: NodeId) -> Option<Vec2> {
|
||||
let stroke = !cx.fill_active;
|
||||
@@ -444,7 +463,24 @@ impl GradientTool {
|
||||
let start = place(geom.start, geom.start + (p - g.at));
|
||||
("paint.setGradientGeom", Self::geom_params(cx, start, start + (geom.end - geom.start)))
|
||||
}
|
||||
Grab::End(geom) => ("paint.setGradientGeom", Self::geom_params(cx, geom.start, place(geom.start, p))),
|
||||
// Alt (or a vector of no length, which has no direction to keep) moves the end freely.
|
||||
Grab::End(geom) if mods.alt || geom.length() < 1e-12 => {
|
||||
("paint.setGradientGeom", Self::geom_params(cx, geom.start, place(geom.start, p)))
|
||||
}
|
||||
Grab::End(geom) => {
|
||||
// Only the length changes: the end slides along the bar's line. It snaps only to a
|
||||
// target on that line; elsewhere it follows the pointer, with no guides.
|
||||
let min = cx.tol(MIN_LENGTH);
|
||||
let q = snap.drag(cx, p, Some(&Leave::segment(cx, geom.start, false)));
|
||||
let end = match along_bar(geom, q, min) {
|
||||
Some(e) if e.distance(q) <= cx.tol(0.5) => e,
|
||||
_ => {
|
||||
snap.clear();
|
||||
along_bar(geom, p, min).unwrap_or(geom.end)
|
||||
}
|
||||
};
|
||||
("paint.setGradientGeom", Self::geom_params(cx, geom.start, end))
|
||||
}
|
||||
Grab::Rotate { geom, from } => {
|
||||
let dir = (Affine::rotate(-from) * (p - geom.start).to_point()).to_vec2();
|
||||
let dir = if mods.shift { constrain(dir) } else { dir };
|
||||
|
||||
@@ -111,8 +111,9 @@ fn the_end_handle_changes_only_the_end_and_the_start_moves_both() {
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
let mut t = GradientTool::default();
|
||||
t.pointer(&cx, &ev(PointerKind::Down, Point::new(200.0, 150.0)));
|
||||
let v = preview(&t.pointer(&cx, &ev(PointerKind::Drag, Point::new(220.0, 170.0)))).clone();
|
||||
// Alt-drag moves the end freely: the length and the angle change together.
|
||||
t.pointer(&cx, &with(ALT, ev(PointerKind::Down, Point::new(200.0, 150.0))));
|
||||
let v = preview(&t.pointer(&cx, &with(ALT, ev(PointerKind::Drag, Point::new(220.0, 170.0))))).clone();
|
||||
assert_eq!((point(&v["start"]), point(&v["end"])), (Point::new(100.0, 150.0), Point::new(220.0, 170.0)));
|
||||
assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, Point::new(220.0, 170.0))), vec![Action::Commit]);
|
||||
// The start handle moves the whole vector.
|
||||
@@ -121,6 +122,32 @@ fn the_end_handle_changes_only_the_end_and_the_start_moves_both() {
|
||||
assert_eq!((point(&v["start"]), point(&v["end"])), (Point::new(110.0, 140.0), Point::new(210.0, 140.0)));
|
||||
}
|
||||
|
||||
/// A plain drag of the end handle changes only the length: the end stays on the bar's line, with
|
||||
/// Shift too, never nearer the start than `MIN_LENGTH`, and it does not snap to a target off
|
||||
/// that line.
|
||||
#[test]
|
||||
fn a_plain_drag_of_the_end_handle_changes_only_the_length() {
|
||||
let (d, s) = graded(two());
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
let mut t = GradientTool::default();
|
||||
let drag = |t: &mut GradientTool, m: Mods, to: Point| {
|
||||
t.pointer(&cx, &with(m, ev(PointerKind::Down, Point::new(200.0, 150.0))));
|
||||
let v = preview(&t.pointer(&cx, &with(m, ev(PointerKind::Drag, to)))).clone();
|
||||
let guides = t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Label { .. }));
|
||||
t.pointer(&cx, &with(m, ev(PointerKind::Up, to)));
|
||||
(point(&v["start"]), point(&v["end"]), guides)
|
||||
};
|
||||
let start = Point::new(100.0, 150.0);
|
||||
assert_eq!(drag(&mut t, Mods::default(), Point::new(220.0, 170.0)), (start, Point::new(220.0, 150.0), false));
|
||||
assert_eq!(drag(&mut t, SHIFT, Point::new(230.0, 100.0)), (start, Point::new(230.0, 150.0), false));
|
||||
// Near the rectangle's corner, off the line: no snap.
|
||||
assert_eq!(drag(&mut t, Mods::default(), Point::new(202.0, 197.0)), (start, Point::new(202.0, 150.0), false));
|
||||
// Dragged back past the start, the end stops short of it.
|
||||
let (_, end, _) = drag(&mut t, Mods::default(), Point::new(60.0, 160.0));
|
||||
assert!(end.distance(Point::new(100.0 + cx.tol(MIN_LENGTH), 150.0)) < 1e-9, "{end:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn past_the_end_rotates_and_shift_snaps() {
|
||||
let (d, s) = graded(two());
|
||||
@@ -140,9 +167,9 @@ fn handles_snap_to_anchors_and_shift_uses_the_constrain_angle() {
|
||||
let p = paint();
|
||||
let mut cx = cx(&d, &s, &p);
|
||||
let mut t = GradientTool::default();
|
||||
// The end handle dragged near the rectangle's corner lands on it, with a guide label.
|
||||
t.pointer(&cx, &ev(PointerKind::Down, Point::new(200.0, 150.0)));
|
||||
let v = preview(&t.pointer(&cx, &ev(PointerKind::Drag, Point::new(202.0, 197.0)))).clone();
|
||||
// The end handle Alt-dragged near the rectangle's corner lands on it, with a guide label.
|
||||
t.pointer(&cx, &with(ALT, ev(PointerKind::Down, Point::new(200.0, 150.0))));
|
||||
let v = preview(&t.pointer(&cx, &with(ALT, ev(PointerKind::Drag, Point::new(202.0, 197.0))))).clone();
|
||||
assert_eq!(point(&v["end"]), Point::new(200.0, 200.0));
|
||||
assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "anchor")));
|
||||
t.pointer(&cx, &ev(PointerKind::Up, Point::new(202.0, 197.0)));
|
||||
@@ -156,12 +183,13 @@ fn handles_snap_to_anchors_and_shift_uses_the_constrain_angle() {
|
||||
let v = preview(&t.pointer(&cx2, &ev(PointerKind::Drag, Point::new(150.0, 130.0)))).clone();
|
||||
assert_eq!(point(&v["start"]), Point::new(100.0, 100.0));
|
||||
t.pointer(&cx2, &ev(PointerKind::Up, Point::new(150.0, 130.0)));
|
||||
// Constrain Angle 30: Shift gives 30 and 75 degrees (and no snapping).
|
||||
// Constrain Angle 30: Shift with Alt gives 30 and 75 degrees (and no snapping).
|
||||
cx.constrain_angle = 30.0;
|
||||
let angle = |v: &Value| GradientGeom { start: point(&v["start"]), end: point(&v["end"]), aspect: 1.0, focal: None }.angle_deg();
|
||||
let shift_alt = Mods { alt: true, ..SHIFT };
|
||||
for (to, want) in [(Point::new(190.0, 100.0), 30.0), (Point::new(125.0, 60.0), 75.0)] {
|
||||
t.pointer(&cx, &ev(PointerKind::Down, Point::new(200.0, 150.0)));
|
||||
let v = preview(&t.pointer(&cx, &with(SHIFT, ev(PointerKind::Drag, to)))).clone();
|
||||
t.pointer(&cx, &with(shift_alt, ev(PointerKind::Down, Point::new(200.0, 150.0))));
|
||||
let v = preview(&t.pointer(&cx, &with(shift_alt, ev(PointerKind::Drag, to)))).clone();
|
||||
assert!((angle(&v) - want).abs() < 1e-9, "{want}: {v}");
|
||||
t.pointer(&cx, &ev(PointerKind::Up, to));
|
||||
}
|
||||
|
||||
@@ -1378,6 +1378,8 @@ font-technology Variable Променливи
|
||||
Graph Диаграма
|
||||
Graph Data Данни за диаграма
|
||||
Graph Type Тип диаграма
|
||||
Graph Type… Тип диаграма…
|
||||
Graph Data… Данни за диаграма…
|
||||
Graph Options Опции на диаграмата
|
||||
Left Axis Лява ос
|
||||
Right Axis Дясна ос
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -3599,6 +3599,8 @@ theme Appearance Izgled
|
||||
Create Graph Kreiraj grafikon
|
||||
Graph Data Podaci grafikona
|
||||
Graph Type Vrsta grafikona
|
||||
Graph Type… Vrsta grafikona…
|
||||
Graph Data… Podaci grafikona…
|
||||
Graph Options Opcije grafikona
|
||||
Left Axis Lijeva osa
|
||||
Right Axis Desna osa
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -1910,6 +1910,8 @@ digits Malayalam Malaiàlam
|
||||
Graph Design Disseny del gràfic
|
||||
Graph Marker Marcador del gràfic
|
||||
Graph Type Tipus de gràfic
|
||||
Graph Type… Tipus de gràfic…
|
||||
Graph Data… Dades del gràfic…
|
||||
Graph Options Opcions del gràfic
|
||||
Left Axis Eix esquerre
|
||||
Right Axis Eix dret
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -3695,6 +3695,8 @@ theme Appearance Motiv
|
||||
Create Graph Vytvořit graf
|
||||
Graph Data Data grafu
|
||||
Graph Type Typ grafu
|
||||
Graph Type… Typ grafu…
|
||||
Graph Data… Data grafu…
|
||||
Graph Options Možnosti grafu
|
||||
Left Axis Levá osa
|
||||
Right Axis Pravá osa
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -4042,6 +4042,8 @@ theme Appearance Udseende
|
||||
Create Graph Opret graf
|
||||
Graph Data Grafdata
|
||||
Graph Type Graftype
|
||||
Graph Type… Graftype…
|
||||
Graph Data… Grafdata…
|
||||
Graph Options Grafindstillinger
|
||||
Left Axis Venstre akse
|
||||
Right Axis Højre akse
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -1421,6 +1421,8 @@ file-filter Templates Vorlagen
|
||||
Graph Diagramm
|
||||
Graph Data Diagrammdaten
|
||||
Graph Type Diagrammtyp
|
||||
Graph Type… Diagrammtyp…
|
||||
Graph Data… Diagrammdaten…
|
||||
Graph Options Diagrammoptionen
|
||||
Left Axis Linke Achse
|
||||
Right Axis Rechte Achse
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1353,6 +1353,8 @@ font-technology Variable Μεταβλητές
|
||||
Graph Γράφημα
|
||||
Graph Data Δεδομένα γραφήματος
|
||||
Graph Type Τύπος γραφήματος
|
||||
Graph Type… Τύπος γραφήματος…
|
||||
Graph Data… Δεδομένα γραφήματος…
|
||||
Graph Options Επιλογές γραφήματος
|
||||
Left Axis Αριστερός άξονας
|
||||
Right Axis Δεξιός άξονας
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1432,6 +1432,8 @@ font-technology Variable Variables
|
||||
Graph Gráfico
|
||||
Graph Data Datos del gráfico
|
||||
Graph Type Tipo de gráfico
|
||||
Graph Type… Tipo de gráfico…
|
||||
Graph Data… Datos del gráfico…
|
||||
Graph Options Opciones de gráfico
|
||||
Left Axis Eje izquierdo
|
||||
Right Axis Eje derecho
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -3633,6 +3633,8 @@ theme Appearance Ulkoasu
|
||||
Create Graph Luo kaavio
|
||||
Graph Data Kaavion tiedot
|
||||
Graph Type Kaavion tyyppi
|
||||
Graph Type… Kaavion tyyppi…
|
||||
Graph Data… Kaavion tiedot…
|
||||
Graph Options Kaavion asetukset
|
||||
Left Axis Vasen akseli
|
||||
Right Axis Oikea akseli
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -1426,6 +1426,8 @@ font-technology Variable Variables
|
||||
Graph Graphe
|
||||
Graph Data Données du graphe
|
||||
Graph Type Type de graphe
|
||||
Graph Type… Type de graphe…
|
||||
Graph Data… Données du graphe…
|
||||
Graph Options Options du graphe
|
||||
Left Axis Axe gauche
|
||||
Right Axis Axe droit
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1548,6 +1548,8 @@
|
||||
Graph Design ગ્રાફ ડિઝાઇન
|
||||
Graph Marker ગ્રાફ માર્કર
|
||||
Graph Type ગ્રાફ પ્રકાર
|
||||
Graph Type… ગ્રાફ પ્રકાર…
|
||||
Graph Data… ગ્રાફ ડેટા…
|
||||
Graph Options ગ્રાફ વિકલ્પો
|
||||
Left Axis ડાબી અક્ષ
|
||||
Right Axis જમણી અક્ષ
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 72 and column 5.
|
@@ -2125,6 +2125,8 @@ antiAlias Sharp शार्प
|
||||
Graph Design ग्राफ़ डिजाइन
|
||||
Graph Marker ग्राफ़ मार्कर
|
||||
Graph Type ग्राफ़ टाइप
|
||||
Graph Type… ग्राफ़ टाइप…
|
||||
Graph Data… ग्राफ़ डेटा…
|
||||
Graph Options ग्राफ़ विकल्प
|
||||
Left Axis बायाँ एक्सिस
|
||||
Right Axis दायाँ एक्सिस
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1784,6 +1784,8 @@ file-filter Templates Sablonok
|
||||
Graph Diagram
|
||||
Graph Data Diagramadatok
|
||||
Graph Type Diagramtípus
|
||||
Graph Type… Diagramtípus…
|
||||
Graph Data… Diagramadatok…
|
||||
Graph Options Diagrambeállítások
|
||||
Left Axis Bal tengely
|
||||
Right Axis Jobb tengely
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -3376,6 +3376,8 @@ theme Appearance Tampilan
|
||||
Create Graph Buat grafik
|
||||
Graph Data Data grafik
|
||||
Graph Type Jenis grafik
|
||||
Graph Type… Jenis grafik…
|
||||
Graph Data… Data grafik…
|
||||
Graph Options Opsi grafik
|
||||
Left Axis Sumbu kiri
|
||||
Right Axis Sumbu kanan
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2473 and column 5.
|
@@ -1451,6 +1451,8 @@ file-filter Templates Modelli
|
||||
Graph Grafico
|
||||
Graph Data Dati grafico
|
||||
Graph Type Tipo di grafico
|
||||
Graph Type… Tipo di grafico…
|
||||
Graph Data… Dati grafico…
|
||||
Graph Options Opzioni grafico
|
||||
Left Axis Asse sinistro
|
||||
Right Axis Asse destro
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -3874,6 +3874,8 @@ file-filter Templates テンプレート
|
||||
Gradient (. or Shift+.) グラデーション (. または Shift+.)
|
||||
Graph Data グラフデータ
|
||||
Graph Type グラフの種類
|
||||
Graph Type… グラフの種類…
|
||||
Graph Data… グラフデータ…
|
||||
Graph Options グラフオプション
|
||||
Left Axis 左軸
|
||||
Right Axis 右軸
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5349,6 +5349,8 @@ theme Appearance იერსახე
|
||||
Create Graph დიაგრამის შექმნა
|
||||
Graph Data დიაგრამის მონაცემები
|
||||
Graph Type დიაგრამის ტიპი
|
||||
Graph Type… გრაფიკის ტიპი…
|
||||
Graph Data… გრაფიკის მონაცემები…
|
||||
Graph Options გრაფიკის პარამეტრები
|
||||
Left Axis მარცხენა ღერძი
|
||||
Right Axis მარჯვენა ღერძი
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -3862,6 +3862,8 @@ file-filter Templates 템플릿
|
||||
Gradient (. or Shift+.) 그레이디언트 (. 또는 Shift+.)
|
||||
Graph Data 그래프 데이터
|
||||
Graph Type 그래프 유형
|
||||
Graph Type… 그래프 유형…
|
||||
Graph Data… 그래프 데이터…
|
||||
Graph Options 그래프 옵션
|
||||
Left Axis 왼쪽 축
|
||||
Right Axis 오른쪽 축
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -3938,6 +3938,8 @@ theme Appearance Vormgeving
|
||||
Create Graph Diagram maken
|
||||
Graph Data Diagramgegevens
|
||||
Graph Type Diagramtype
|
||||
Graph Type… Diagramtype…
|
||||
Graph Data… Diagramgegevens…
|
||||
Graph Options Diagramopties
|
||||
Left Axis Linkeras
|
||||
Right Axis Rechteras
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -3574,6 +3574,8 @@ theme Appearance Wygląd
|
||||
Create Graph Utwórz wykres
|
||||
Graph Data Dane wykresu
|
||||
Graph Type Typ wykresu
|
||||
Graph Type… Typ wykresu…
|
||||
Graph Data… Dane wykresu…
|
||||
Graph Options Opcje wykresu
|
||||
Left Axis Lewa oś
|
||||
Right Axis Prawa oś
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -4993,6 +4993,8 @@ axis Both Ambos
|
||||
Gradient (. or Shift+.) Gradiente (. ou Shift+.)
|
||||
Graph Data Dados do Gráfico
|
||||
Graph Type Tipo de Gráfico
|
||||
Graph Type… Tipo de Gráfico…
|
||||
Graph Data… Dados do Gráfico…
|
||||
Graph Options Opções do Gráfico
|
||||
Left Axis Eixo Esquerdo
|
||||
Right Axis Eixo Direito
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1442,6 +1442,8 @@ file-filter Templates Шаблоны
|
||||
Graph Диаграмма
|
||||
Graph Data Данные диаграммы
|
||||
Graph Type Тип диаграммы
|
||||
Graph Type… Тип диаграммы…
|
||||
Graph Data… Данные диаграммы…
|
||||
Graph Options Параметры диаграммы
|
||||
Left Axis Левая ось
|
||||
Right Axis Правая ось
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1389,6 +1389,8 @@ font-technology Variable Variabla
|
||||
Graph Diagram
|
||||
Graph Data Diagramdata
|
||||
Graph Type Diagramtyp
|
||||
Graph Type… Diagramtyp…
|
||||
Graph Data… Diagramdata…
|
||||
Graph Options Diagramalternativ
|
||||
Left Axis Vänster axel
|
||||
Right Axis Höger axel
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1357,6 +1357,8 @@ font-technology Variable Değişken
|
||||
Graph Grafik
|
||||
Graph Data Grafik Verileri
|
||||
Graph Type Grafik Türü
|
||||
Graph Type… Grafik Türü…
|
||||
Graph Data… Grafik Verileri…
|
||||
Graph Options Grafik Seçenekleri
|
||||
Left Axis Sol Eksen
|
||||
Right Axis Sağ Eksen
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1445,6 +1445,8 @@ file-filter Templates Шаблони
|
||||
Graph Діаграма
|
||||
Graph Data Дані діаграми
|
||||
Graph Type Тип діаграми
|
||||
Graph Type… Тип діаграми…
|
||||
Graph Data… Дані діаграми…
|
||||
Graph Options Параметри діаграми
|
||||
Left Axis Ліва вісь
|
||||
Right Axis Права вісь
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1704,6 +1704,8 @@ file-filter Templates Mẫu
|
||||
Chop Design Cắt thiết kế
|
||||
Scale Design Co giãn thiết kế
|
||||
Graph Type Loại biểu đồ
|
||||
Graph Type… Loại biểu đồ…
|
||||
Graph Data… Dữ liệu biểu đồ…
|
||||
Graph Options Tùy chọn biểu đồ
|
||||
Left Axis Trục trái
|
||||
Right Axis Trục phải
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 205 and column 5.
|
@@ -1380,6 +1380,8 @@ file-filter Templates 模板
|
||||
Graph 图表
|
||||
Graph Data 图表数据
|
||||
Graph Type 图表类型
|
||||
Graph Type… 图表类型…
|
||||
Graph Data… 图表数据…
|
||||
Graph Options 图表选项
|
||||
Left Axis 左轴
|
||||
Right Axis 右轴
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1415,6 +1415,8 @@ file-filter Templates 範本
|
||||
Graph 圖表
|
||||
Graph Data 圖表資料
|
||||
Graph Type 圖表類型
|
||||
Graph Type… 圖表類型…
|
||||
Graph Data… 圖表資料…
|
||||
Graph Options 圖表選項
|
||||
Left Axis 左軸
|
||||
Right Axis 右軸
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -69,6 +69,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
|
||||
objects_on_path_section(app, ui, &oop);
|
||||
divider(ui);
|
||||
}
|
||||
graph::section(app, ui);
|
||||
if matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Text(_))) {
|
||||
type_sections(app, ui);
|
||||
divider(ui);
|
||||
@@ -1050,6 +1051,7 @@ pub fn type_sections(app: &mut VectorcraftApp, ui: &mut Ui) {
|
||||
}
|
||||
|
||||
pub(crate) mod dynamic_text;
|
||||
pub(crate) mod graph;
|
||||
pub(crate) mod vertical_align;
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
//! The Properties panel's Graph section, for one selected graph or series of one graph picked with
|
||||
//! Group Selection: Graph Type… and Graph Data… open the dialogs of Object › Graph › Type… and
|
||||
//! Data… ([Format pie graphs](https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/visualize-data/format-pie-graphs.html)
|
||||
//! opens Graph Type from the Properties panel). Column… shows when every series it would change
|
||||
//! draws columns or bars, and Marker… when every one draws lines, scatter points or radar lines;
|
||||
//! both run the same route as their Object › Graph items.
|
||||
|
||||
use egui::Ui;
|
||||
use serde_json::json;
|
||||
use vectorcraft_doc::{Document, GraphKind, MAX_GRAPH_SERIES, NodeId};
|
||||
|
||||
use crate::VectorcraftApp;
|
||||
use crate::widgets::{self, divider, section_header};
|
||||
|
||||
/// The Graph section's optional buttons for the selection.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub(crate) struct Shown {
|
||||
/// Column… takes the series it would change.
|
||||
pub(crate) column: bool,
|
||||
/// Marker… takes the series it would change.
|
||||
pub(crate) marker: bool,
|
||||
}
|
||||
|
||||
/// What the Graph section shows for the selection; `None` unless everything selected is one graph
|
||||
/// or lies inside the same graph.
|
||||
pub(crate) fn shown(app: &VectorcraftApp) -> Option<Shown> {
|
||||
let st = app.session.active()?;
|
||||
let doc = &st.doc;
|
||||
let mut graph = None;
|
||||
for id in &st.selection.objects {
|
||||
let g = graph_of(doc, *id)?;
|
||||
if graph.is_some_and(|x| x != g) {
|
||||
return None;
|
||||
}
|
||||
graph = Some(g);
|
||||
}
|
||||
let graph = graph?;
|
||||
let spec = doc.node(graph)?.extras().graph.as_deref()?;
|
||||
let count = spec.rows.iter().map(Vec::len).max().unwrap_or(0).min(MAX_GRAPH_SERIES);
|
||||
// The series Column… and Marker… change: those picked with Group Selection when the selection is
|
||||
// only series, else every series (as `graph.column` and `graph.marker` pick them).
|
||||
let picked: Option<Vec<usize>> = st.selection.objects.iter().map(|id| series_of(doc, graph, *id).filter(|i| *i < count)).collect();
|
||||
let series = picked.unwrap_or_else(|| (0..count).collect());
|
||||
let kinds: Vec<GraphKind> = series.iter().map(|i| spec.series_kind(*i)).collect();
|
||||
let all = |ks: &[GraphKind]| !kinds.is_empty() && kinds.iter().all(|k| ks.contains(k));
|
||||
Some(Shown {
|
||||
column: all(&[GraphKind::Column, GraphKind::StackedColumn, GraphKind::Bar, GraphKind::StackedBar]),
|
||||
marker: all(&[GraphKind::Line, GraphKind::Scatter, GraphKind::Radar]),
|
||||
})
|
||||
}
|
||||
|
||||
/// The graph `id` is or lies in.
|
||||
fn graph_of(doc: &Document, id: NodeId) -> Option<NodeId> {
|
||||
let mut cur = Some(id);
|
||||
while let Some(c) = cur {
|
||||
if doc.node(c).is_some_and(|n| n.extras().graph.is_some()) {
|
||||
return Some(c);
|
||||
}
|
||||
cur = doc.parent_of(c);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The index of the series of `graph` that `id` is or lies in; `None` for the graph itself, its
|
||||
/// axes and its legend.
|
||||
fn series_of(doc: &Document, graph: NodeId, id: NodeId) -> Option<usize> {
|
||||
let mut cur = id;
|
||||
loop {
|
||||
let parent = doc.parent_of(cur)?;
|
||||
if parent == graph {
|
||||
return doc.node(cur)?.extras().series_index.and_then(|i| usize::try_from(i).ok());
|
||||
}
|
||||
cur = parent;
|
||||
}
|
||||
}
|
||||
|
||||
/// The Graph section for the selection, with the divider after it; nothing without a graph.
|
||||
pub(crate) fn section(app: &mut VectorcraftApp, ui: &mut Ui) {
|
||||
let Some(s) = shown(app) else { return };
|
||||
section_header(ui, tl!("Graph"));
|
||||
let mut buttons = vec![(tl!("Graph Type…"), "graph.setType"), (tl!("Graph Data…"), "graph.setData")];
|
||||
if s.column {
|
||||
buttons.push((tl!("Column…"), "graph.column"));
|
||||
}
|
||||
if s.marker {
|
||||
buttons.push((tl!("Marker…"), "graph.marker"));
|
||||
}
|
||||
let full = ui.available_width();
|
||||
let w = (full - 6.0) / 2.0;
|
||||
for pair in buttons.chunks(2) {
|
||||
// Two buttons share a row while both labels fit in half of it; a longer translated label
|
||||
// puts each button of the pair on a row of its own.
|
||||
if pair.iter().all(|(label, _)| widgets::flat_button_fit_width(ui, label, 0.0) <= w) {
|
||||
ui.horizontal(|ui| {
|
||||
for (label, id) in pair {
|
||||
if widgets::flat_button(ui, label, w).clicked() {
|
||||
crate::menus::invoke(app, id, json!({}));
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
for (label, id) in pair {
|
||||
if widgets::flat_button_fit(ui, label, full).clicked() {
|
||||
crate::menus::invoke(app, id, json!({}));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
divider(ui);
|
||||
}
|
||||
@@ -2014,3 +2014,154 @@ fn dynamic_text_rows_follow_the_selected_area_type() {
|
||||
app.run("text.thread.create", json!({})).unwrap();
|
||||
assert_eq!(dynamic_text::shown(&app).map(|s| (s.on, s.enabled)), Some((Some(false), false)));
|
||||
}
|
||||
|
||||
/// A document with a graph of `kind` and three series, selected → the graph's id.
|
||||
fn graph_doc(app: &mut VectorcraftApp, kind: &str, x: f64) -> u64 {
|
||||
if app.session.active().is_none() {
|
||||
app.run("file.new", json!({"width": 800, "height": 400})).unwrap();
|
||||
}
|
||||
let csv = ",a,b,c\nQ1,1,2,3\nQ2,3,4,5";
|
||||
app.run("graph.create", json!({"type": kind, "x": x, "y": 0, "width": 200, "height": 150, "csv": csv})).unwrap()["id"].as_u64().unwrap()
|
||||
}
|
||||
|
||||
/// The ids of graph `graph`'s series groups, in series order.
|
||||
fn series_groups(app: &VectorcraftApp, graph: u64) -> Vec<u64> {
|
||||
let st = app.session.active().unwrap();
|
||||
let mut groups: Vec<(u32, u64)> = st
|
||||
.doc
|
||||
.node(vectorcraft_doc::NodeId(graph))
|
||||
.and_then(vectorcraft_doc::Node::children)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|c| c.extras().series_index.map(|i| (i, c.id.0)))
|
||||
.collect();
|
||||
groups.sort_unstable();
|
||||
groups.into_iter().map(|(_, id)| id).collect()
|
||||
}
|
||||
|
||||
/// One selected column graph has a Graph section with Graph Type…, Graph Data… and Column…, and
|
||||
/// each button opens its Object › Graph dialog for the graph.
|
||||
#[test]
|
||||
fn one_selected_graph_has_a_graph_section_whose_buttons_open_the_graph_dialogs() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
graph_doc(&mut app, "column", 0.0);
|
||||
assert_eq!(graph::shown(&app), Some(graph::Shown { column: true, marker: false }));
|
||||
let ctx = egui::Context::default();
|
||||
let texts = frame(&mut app, &ctx, vec![]);
|
||||
for label in ["Graph", "Graph Type…", "Graph Data…", "Column…"] {
|
||||
assert!(texts.iter().any(|(t, _)| t == label), "no {label:?} in {texts:?}");
|
||||
}
|
||||
assert!(!texts.iter().any(|(t, _)| t == "Marker…"), "{texts:?}");
|
||||
let press = |app: &mut VectorcraftApp, label: &str| {
|
||||
let texts = panel_frame(app, &ctx, vec![], graph::section);
|
||||
let at = texts.iter().find(|(t, _)| t == label).map(|(_, r)| r.center()).unwrap_or_else(|| panic!("no {label:?} in {texts:?}"));
|
||||
let b = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
|
||||
panel_frame(app, &ctx, vec![Event::PointerMoved(at), b(true)], graph::section);
|
||||
panel_frame(app, &ctx, vec![b(false)], graph::section);
|
||||
app.ui.dialog.take().unwrap_or_else(|| panic!("{label:?} opened no dialog"))
|
||||
};
|
||||
let d = press(&mut app, "Graph Type…");
|
||||
assert_eq!((d.kind.as_str(), d.str("type")), (crate::dialogs::graph_type::KIND, "column".to_string()));
|
||||
assert_eq!(press(&mut app, "Graph Data…").kind, crate::dialogs::graph_data::KIND);
|
||||
assert_eq!(press(&mut app, "Column…").kind, crate::dialogs::graph_design::COLUMN);
|
||||
}
|
||||
|
||||
/// At the panel's narrowest, Graph Type… and Graph Data… share a row in English, and a translated
|
||||
/// label too long for half of the row puts each of them on a row of its own, drawn whole.
|
||||
#[test]
|
||||
fn the_graph_sections_long_labels_get_rows_of_their_own() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
graph_doc(&mut app, "column", 0.0);
|
||||
let ctx = egui::Context::default();
|
||||
let width = 220.0;
|
||||
let texts = |app: &mut VectorcraftApp| {
|
||||
let raw = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(width, 700.0))), ..Default::default() };
|
||||
let mut out = ctx.run_ui(raw, |ui| graph::section(app, ui));
|
||||
out.textures_delta.clear();
|
||||
out.shapes
|
||||
.iter()
|
||||
.filter_map(|s| {
|
||||
if let egui::Shape::Text(t) = &s.shape {
|
||||
Some((t.galley.text().to_string(), Rect::from_min_size(t.pos, t.galley.size())))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
};
|
||||
let rect = |texts: &[(String, Rect)], label: &str| {
|
||||
texts.iter().find(|(t, _)| t == label).map(|(_, r)| *r).unwrap_or_else(|| panic!("no {label:?} in {texts:?}"))
|
||||
};
|
||||
crate::i18n::set_current(crate::i18n::Lang::EN);
|
||||
let english = texts(&mut app);
|
||||
assert_eq!(rect(&english, "Graph Type…").center().y, rect(&english, "Graph Data…").center().y, "{english:?}");
|
||||
crate::i18n::set_current(crate::i18n::Lang::from_code("de").expect("de registered"));
|
||||
let german = texts(&mut app);
|
||||
crate::i18n::set_current(crate::i18n::Lang::EN);
|
||||
let (kind, data) = (rect(&german, "Diagrammtyp…"), rect(&german, "Diagrammdaten…"));
|
||||
assert!(kind.bottom() <= data.top(), "{german:?}");
|
||||
for r in [kind, data] {
|
||||
assert!(r.left() >= 0.0 && r.right() <= width, "{r:?} in {german:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Column… shows when every series it would change draws columns or bars, Marker… when every one
|
||||
/// draws lines, scatter points or radar lines: series picked with Group Selection count on their
|
||||
/// own, and a combined graph selected whole shows neither.
|
||||
#[test]
|
||||
fn the_graph_sections_column_and_marker_follow_the_series_they_would_change() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
let g = graph_doc(&mut app, "column", 0.0);
|
||||
app.run("graph.setType", json!({"seriesIndexes": [1], "type": "line"})).unwrap();
|
||||
app.run("select.set", json!({"ids": [g]})).unwrap();
|
||||
assert_eq!(graph::shown(&app), Some(graph::Shown { column: false, marker: false }), "column and line series");
|
||||
let groups = series_groups(&app, g);
|
||||
assert_eq!(groups.len(), 3, "{groups:?}");
|
||||
app.run("select.set", json!({"ids": [groups[1]]})).unwrap();
|
||||
assert_eq!(graph::shown(&app), Some(graph::Shown { column: false, marker: true }), "the line series");
|
||||
app.run("select.set", json!({"ids": [groups[0], groups[2]]})).unwrap();
|
||||
assert_eq!(graph::shown(&app), Some(graph::Shown { column: true, marker: false }), "the column series");
|
||||
app.run("select.set", json!({"ids": [groups[0], groups[1]]})).unwrap();
|
||||
assert_eq!(graph::shown(&app), Some(graph::Shown { column: false, marker: false }), "one of each");
|
||||
for (kind, shown) in [
|
||||
("line", (false, true)),
|
||||
("scatter", (false, true)),
|
||||
("radar", (false, true)),
|
||||
("bar", (true, false)),
|
||||
("pie", (false, false)),
|
||||
("area", (false, false)),
|
||||
] {
|
||||
let id = graph_doc(&mut app, kind, 300.0);
|
||||
app.run("select.set", json!({"ids": [id]})).unwrap();
|
||||
assert_eq!(graph::shown(&app).map(|s| (s.column, s.marker)), Some(shown), "{kind}");
|
||||
app.run("edit.clear", json!({})).unwrap();
|
||||
}
|
||||
// A graph whose data was cleared has no series for Column… or Marker… to change.
|
||||
for kind in ["column", "line"] {
|
||||
let id = graph_doc(&mut app, kind, 300.0);
|
||||
app.run("graph.setData", json!({"id": id, "series": [], "categories": [], "rows": []})).unwrap();
|
||||
app.run("select.set", json!({"ids": [id]})).unwrap();
|
||||
assert_eq!(graph::shown(&app), Some(graph::Shown { column: false, marker: false }), "an empty {kind} graph");
|
||||
app.run("edit.clear", json!({})).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
/// The Graph section shows only while everything selected is one graph or lies in it.
|
||||
#[test]
|
||||
fn the_graph_section_needs_one_graph_selected() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
let a = graph_doc(&mut app, "column", 0.0);
|
||||
let b = graph_doc(&mut app, "column", 300.0);
|
||||
let rect = app.run("shape.rectangle", json!({"x": 600, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
|
||||
for (ids, what) in [(vec![rect], "a rectangle"), (vec![a, rect], "a graph and a rectangle"), (vec![a, b], "two graphs")] {
|
||||
app.run("select.set", json!({ "ids": ids })).unwrap();
|
||||
assert_eq!(graph::shown(&app), None, "{what}");
|
||||
let texts = frame(&mut app, &egui::Context::default(), vec![]);
|
||||
assert!(!texts.iter().any(|(t, _)| t == "Graph Type…"), "{what}: {texts:?}");
|
||||
}
|
||||
let groups = series_groups(&app, a);
|
||||
app.run("select.set", json!({"ids": [groups[0], groups[1]]})).unwrap();
|
||||
assert!(graph::shown(&app).is_some(), "two series of one graph");
|
||||
app.run("select.set", json!({"ids": [groups[0], series_groups(&app, b)[0]]})).unwrap();
|
||||
assert_eq!(graph::shown(&app), None, "series of two graphs");
|
||||
}
|
||||
+9
-6
@@ -921,7 +921,8 @@ its own, can move or scale the plot at the next redraw. When all of a graph's ar
|
||||
the art measured has no width or no height, a redraw leaves the plot where it is and does not follow a move or scale of
|
||||
the graph. A graph opened from a `.ai` file
|
||||
saves `placedArt` too. A graph saved without `placedArt`, or with a `placedArt` that has no width or height, is
|
||||
measured on `placed`.
|
||||
measured on `placed`. `placed` includes the labels, so in such a graph moving an outermost label on its own can move or
|
||||
scale the plot at the next redraw.
|
||||
|
||||
The `appearance.*` commands, `graphicStyle.apply` and `graphicStyle.redefine`, and the paint, stroke, gradient and
|
||||
transparency commands given an `item` (or the Appearance panel's active row) store a graph label's object rows for its
|
||||
@@ -1420,9 +1421,11 @@ Drive a tool like a mouse:
|
||||
|
||||
Edit a gradient with the Gradient tool's annotator (the bar runs along the vector; stop chips sit 10 px under
|
||||
it, midpoint diamonds 7 px above): a click on the bar adds a stop, dragging a chip moves it (drag it off the bar to
|
||||
delete it, hold Alt to copy it), dragging the end handle changes the vector. Both ends of a vector drawn on the art,
|
||||
the start of one a click applies, and the dragged start and end handles snap as drawn points do; with Shift, the end
|
||||
or the handle keeps to 45° steps and snaps along them. The selected stop
|
||||
delete it, hold Alt to copy it), dragging the end handle changes the length (the end stays on the bar's line, at
|
||||
least 10 px from the start), and Alt-dragging it changes the length and angle together. Both ends of a vector drawn
|
||||
on the art, the start of one a click applies, and the dragged start and end handles snap as drawn points do (the end
|
||||
handle without Alt only onto points on the bar's line); with Shift, the end of a drawn vector, the Alt-dragged end
|
||||
handle or the start handle keeps to 45° steps and snaps along them. The selected stop
|
||||
(`gradient.selectStop`) takes Delete and ←/→:
|
||||
|
||||
```json
|
||||
@@ -10101,8 +10104,8 @@ other marks take the values of their letter. Setting one value leaves the other
|
||||
saved only when not 0, and character styles carry them (`charStyle.new`, `charStyle.setAttrs` and `charStyle.edit`
|
||||
refuse a value outside the range). A value that is not a number is refused with `` `diacriticHorizontal` must be a
|
||||
number ``, and one outside the range with `` `diacriticHorizontal` must be from -1000 to 1000 ``, naming the key. One
|
||||
undo step, and a `text.setFormat` call that gives the values the characters already have records none. With Show Middle Eastern
|
||||
Options on, the Character panel shows both fields, blank where the selected characters differ, with -200, -100, -50,
|
||||
undo step, and a `text.setFormat` call that gives the values the characters already have records none. With Show Indic Options
|
||||
on, the Character panel shows both fields, blank where the selected characters differ, with -200, -100, -50,
|
||||
0, 50, 100 and 200 in their menus, and a value typed past either end sets that end; Reset Panel sets both to 0.
|
||||
Character Style Options shows both fields in Advanced Character Formats. The canvas, PDF export and outlines draw the
|
||||
moved marks; SVG export writes type with a moved mark as outlines.
|
||||
|
||||
@@ -629,6 +629,7 @@ since 2026-10-01.
|
||||
- **`.ai`/EPS graphic styles that paint with a named gradient:** a graphic style library's style (or a file's listed style) whose fill, or the fill or stroke of a style of one paint, paints with one of the file's gradients by name loads with that gradient at the style's angle, fitted to the bounds of each object it is applied to (VectorCraft's own placement; the style stores only the gradient's name and angle). A style naming a gradient the file doesn't define, or painting with a pattern, is still left out. Evidence: `fileio::tests_aiimport::graphic_styles_in_a_ai_library_that_paint_with_a_named_gradient_load_with_it`, `style::tests::a_style_of_one_paint_reads_as_the_fill_and_stroke_its_xd_turns_on`. Scores unchanged.
|
||||
- **`.ai`/EPS type laid out closer to the file's page (#6137):** type from the text document keeps auto leading as auto, each line taking the paragraph's Auto Leading share (key 7) of the largest type on it ([Line and character spacing](https://helpx.adobe.com/illustrator/using/line-character-spacing.html)); the paragraph's hyphenation options (keys 10 to 15) are read; area type of one frame whose last lines the file sets, but which don't fit here, may get a frame taller from its bottom, by its lines' deepest descent plus 0.05 pt and only when that shows more of those lines and no more than the file has (`vectorcraft_text::fit_source_lines`), with a warning when it does: the frame can stay as it is, or show only some of them; and a line a soft return ends is justified as a wrapped line is, a paragraph's last line keeping its alignment. Evidence: `ate::tests::auto_leading_follows_the_size_of_each_line`, `ate::tests::a_paragraph_keeps_its_auto_leading`, `ate::tests::a_paragraph_keeps_its_hyphenation_options`, `ate::tests::the_last_lines_the_file_sets_in_its_frame_show`, `tests::fit_source_lines_keeps_the_last_lines_the_source_sets`, `tests::typo::soft_return_in_justified_text_spreads_like_a_wrapped_line`. Limits: frames grow only for area type of one frame, horizontal, by its lines' deepest descent plus 0.05 pt; type in a font that isn't installed, and hyphenation in a language that isn't imported, still lay out differently. Scores unchanged.
|
||||
- **Graphs saved to `.ai` keep their data and settings:** a grouped column, stacked column, line or area graph is written to a `.ai` file, in either form, with the records the `.ai` reader reads (`crates/eps/src/import/ai/read/graph.rs`, #7311): `%_Gs`, its plot, type, settings, axes and table, its series' groups each tagged `Go`, and `%_GS` ([the specification](https://13thmonkey.org/documentation/fonts/AI7FileFormat.pdf), §17 and appendix A). The file opens again with the same live graph. A graph with settings the reader doesn't keep, graph designs, label formatting, more than 10,000 categories or 256 series, or art the reader doesn't attach a graph to is written as its art, with a warning. `crates/eps/src/legacy_ai/tests.rs` and `crates/eps/src/ai_editing/tests.rs` write and read back each kind of graph; `a_drawn_graph_saved_as_ai_opens_as_a_graph_unless_the_save_warns` checks every graph type the graph tools draw. Scores unchanged.
|
||||
- **Graph section in the Properties panel:** with one graph selected, or series of one graph picked with Group Selection, the Properties panel shows a Graph section. Its Graph Type… button opens the dialog of Object › Graph › Type… ([Format pie graphs](https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/visualize-data/format-pie-graphs.html)). Its Graph Data… button opens the dialog of Object › Graph › Data…; this button is VectorCraft's own. Column… shows when every series it would change draws columns or bars, and Marker… when every one draws lines, scatter points or radar lines; this is VectorCraft's own rule. Regression tests in `crates/ui-egui/src/panels/properties/tests.rs`. Scores unchanged.
|
||||
- **Selected Grid Repeat handles (#2691):** `tools/src/repeat_grid.rs` tests place the handles outside the grid at zoom 0.5, 1 and 4, preview rows, columns and spacing, leave no undo step for a drag that ends where it began, and give bounding-box handles priority; a headless canvas regression drags the row handle two tiles down in a zoomed view (3 → 5 rows, the source unchanged, one Undo back) and the column-spacing slider. Scores and hours unchanged.
|
||||
- **Selected Mirror Repeat handles:** a headless canvas regression creates the default mirror repeat and drags its Top bounding-box handle where the axis crosses it; the repeat grows vertically while its width stays fixed. Existing mirror-axis checks cover center movement and end-handle hit priority. The focused UI mirror tests pass. Scores and hours unchanged.
|
||||
- **Transform effect options (#885):** Effect › Distort & Transform › Transform… has visible Transform Objects, Transform Patterns and Scale Strokes & Effects checkboxes (`distort.transform` params `objects`, `patterns`, `strokes`; files without them draw as before). With Transform Objects off the geometry stays and makes no copies; Scale Strokes & Effects scales stroke weights, dashes and the fills' and strokes' effect distances by the mean scale, and Transform Patterns moves pattern tiles, each copy `k` by the transformation `k` times. Such objects draw, export and expand through the same per-copy art, so the canvas and Expand Appearance agree (engine `tests_transformfx`, effects `tests_transformfx`, the dialog test). A Transform effect in a fill's or stroke's own effects applies the same options to that fill or stroke: its weight and dashes and its pattern follow the transformation, and with copies each copy is an object of its own; the canvas, export, Expand Appearance and Use Preview Bounds use the same art (effects `tests_transformfx`). The effects listed after it in that fill's or stroke's list keep their own distances and apply to the transformed art and to each copy, as an object's later effects do after the object's Transform effect: a Drop Shadow after it keeps its offset, an Offset Path after it offsets by its own distance, and an SVG filter after it keeps its scale and the origin of its user space. With Transform Objects off, the effects before it keep their distances too. Before, Scale Strokes & Effects scaled a fill's or stroke's later effects by the mean scale, so existing documents with such effects draw differently. Effects apply in the order they are listed ([Appearance attributes](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-graphic-styles/appearance-attributes-in-illustrator.html)); how the two options treat the effects after a fill's or stroke's own Transform effect is VectorCraft's own rule, following that order (effects `tests::rasterfollow::a_fills_own_transform_leaves_the_shadow_after_it`, `tests::rasterfollow::a_fills_own_transform_leaves_the_offset_after_it`, `tests::rasterfollow::a_fills_own_transform_leaves_the_svg_filter_after_it`, `tests::transformfx::a_fills_own_transform_with_scale_strokes_and_effects_leaves_its_later_effects`; engine `plugins::a_transform_after_a_painted_fill_effect_leaves_the_later_shadow_on_every_paint`). Public reference: [Scale objects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/scale-objects.html), [How to apply effects](https://helpx.adobe.com/illustrator/using/effects.html), [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html). Scores and hours unchanged.
|
||||
@@ -1451,7 +1452,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
Object › Flatten Transparency takes a frame of threaded text out of the thread in the same way when Convert All Text to Outlines outlines it or when the frame becomes flat regions or an image, and the other frames keep the text they hold.
|
||||
Object › Flatten Transparency, the Flattener Preview, and EPS, PDF and print output that flatten transparency stop building a group's flat regions at the first region past the raster/vector balance's limit (10^(balance/20), rounded down) and rasterize the whole group without building the remaining regions. Building every region gives the same flattened art and the same files. With Clip Complex Regions on, a group builds every region and its image is clipped to them.
|
||||
Object › Flatten Transparency, the Flattener Preview, and EPS, PDF and print output that flatten transparency leave art without transparency as it is when it overlaps only other art without transparency, unless it overlaps a member of a see-through object's group and lies above that member and below the group's topmost object. Such art joins the group, and the group takes the place of its topmost object, so the stacking order stays the same. In files without transparency with Clip Complex Regions on, art under the group within one image pixel of a member joins it too. The 1 pt antialiasing margin goes around a group's art once, however deeply its groups nest. On a grid of 3,000 rectangles with a 0.5 pt stroke, 60 of them with a drop shadow, the Flattener Preview counts 180 affected objects where it counted 3,000, and Flatten Transparency with the Medium preset makes 240 flat regions and 2 images where it made one image of the whole grid. These rules are VectorCraft's own (`tests::flatten::opaque_art_that_touches_only_opaque_art_stays`, `tests::flatten::opaque_art_the_group_would_move_under_joins_it`).
|
||||
When they group art for flattening, Object › Flatten Transparency, the Flattener Preview, and EPS, PDF and print output that flatten transparency compare the box of an object without transparency only with the boxes of see-through objects in the pass that splits art by transparency. In both passes, a box that lies inside an earlier box that ends no further right and joins everything it overlaps is not compared with later boxes. With one see-through object inside 512 nested objects without transparency, the grouping compares 1,024 pairs of boxes where it compared 262,145, and the groups stay the same (`cmd::flatten::analysis::tests::nested_opaque_boxes_meet_only_the_see_through_box`, `a_shrinking_nest_meets_only_its_outermost_box`). When a later box that joins everything it overlaps covers an earlier box to the right and below, the grouping compares the earlier box with still later boxes only above the later box's top: 512 boxes, each 1 pt right of and below the one before, compare 511 pairs where they compared 130,816, with and without transparency, and the groups stay the same (`cmd::flatten::analysis::tests::staggered_boxes_meet_only_the_box_before`, `staggered_boxes_group_as_comparing_every_pair`).
|
||||
When they group art for flattening, Object › Flatten Transparency, the Flattener Preview, and EPS, PDF and print output that flatten transparency compare the box of an object without transparency only with the boxes of see-through objects in the pass that splits art by transparency. In both passes, a box that lies inside an earlier box that ends no further right and joins everything it overlaps is not compared with later boxes. With one see-through object inside 512 nested objects without transparency, the grouping compares 1,024 pairs of boxes where it compared 262,145, and the groups stay the same (`cmd::flatten::analysis::tests::nested_opaque_boxes_meet_only_the_see_through_box`, `a_shrinking_nest_meets_only_its_outermost_box`). When a later box that joins everything it overlaps covers an earlier box to the right and below, the grouping compares the earlier box with still later boxes only above the later box's top: 512 boxes, each 1 pt right of and below the one before, compare 511 pairs where they compared 130,816, with and without transparency, and the groups stay the same (`cmd::flatten::analysis::tests::staggered_boxes_meet_only_the_box_before`, `staggered_boxes_group_as_comparing_every_pair`). When such a later box covers an earlier box to the right and above, the grouping compares the earlier box with still later boxes only below the later box's bottom: 512 boxes, each 1 pt right of and above the one before, or left of and below it, compare 511 pairs where they compared 130,816, with and without transparency, and the groups stay the same (`cmd::flatten::analysis::tests::boxes_staggered_up_meet_only_the_box_before`, `boxes_stepping_up_and_down_group_as_comparing_every_pair`).
|
||||
New Symbol and Redefine Symbol on a frame of threaded text take it out of the thread with the text it shows, which the symbol's art holds, and the other frames keep the text they hold. When the last frame goes into the symbol, the text it has no room for goes after the text of the last frame that stays. When every frame of a thread goes into the symbol, the copy of the last frame keeps all its text.
|
||||
With Optical Margin Alignment on, or Roman Hanging Punctuation on in the first paragraph, the glyphs at the ends of left-to-right type on a path hang outside its brackets, measured along the path. The type hangs at the start bracket when its line is placed there, hangs at the end bracket when the line is placed there, and hangs at both when it is centered. Glyphs that hang past the end bracket do not make the type overflow, and a hang stops at an open path's end. SVG export writes such type as outlines.
|
||||
Type › Type on a Path › Center on Top and Center on Bottom (`type.pathCenter.top`, `type.pathCenter.bottom`, also on the Contextual Task Bar for type on a closed path) slide type on a closed path so the middle of its span lands on the path's topmost or bottommost point as drawn, keep the span's length, and set the first paragraph to Center unless it is Center or Justify Center. This is VectorCraft's own behavior (`crates/geom/src/arc.rs`, `crates/engine/src/tests/pathtype.rs`).
|
||||
@@ -1794,7 +1795,8 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
A gap between glyphs of two sizes is measured against the smaller one, so a word set beside a much larger one with no space glyph between them (a browser's margin between two sizes, as in `≤ 4` and a small `hours`) keeps its word space (#3623).
|
||||
SVG import's style cascade, used for hidden objects, non-scaling strokes and type, tests each element only against the `<style>` rules for its id, its classes and its element name, and the rules whose selector ends in none of these (`*`, `[x]`).
|
||||
SVG import places right-to-left point type and type on a path as [SVG 2's `text-anchor`](https://www.w3.org/TR/SVG2/text.html#TextAnchoringProperties) says: with `direction: rtl`, `start` puts the right edge of the text at its position (on a path, the text ends at `startOffset`) and `end` puts the left edge there. Each line and each absolutely placed chunk is anchored by the `text-anchor` and `direction` of the element holding its first character, a `<tspan>`'s own included, and each line starts at its own `x`. An absolutely placed chunk is anchored by the left and right edges of its glyphs as they are drawn, so a chunk of several right-to-left characters, whose first character is drawn at its right, sits on its anchor too. A letter-spaced right-to-left line keeps the tracking of all its letters inside the advance it anchors (`rtl_point_text_start_and_end_use_directional_edges`, `rtl_type_on_a_path_starts_at_its_directional_edge`, `rtl_letter_spaced_lines_stay_on_their_anchor`, `rtl_lines_use_each_chunk_first_character_direction_and_anchor`, `each_line_starts_at_its_own_x`, `absolutely_placed_chunks_use_their_own_rtl_anchor` and `absolutely_placed_rtl_chunks_of_several_characters_anchor_by_their_visual_edges` in `crates/svg/tests/it/import_text.rs`).
|
||||
SVG import puts each absolutely placed character of right-to-left text on its own `x`, as [SVG 1.1's text chunks](https://www.w3.org/TR/SVG11/text.html#TextLayoutIntroduction) require, also when the characters run right to left on a later line: in `<text direction="rtl" font-size="20">`, `<tspan x="100 160" y="80 80">אב</tspan>` after a first line puts the right edges of `א` and `ב` at 100 and 160, where import put the right edge of `א` at 393.48 before. Chunks that overlap keep their own anchors, and characters stretched by `lengthAdjust="spacingAndGlyphs"` land on their `x` too. A left-to-right character drawn between two absolutely placed right-to-left characters leaves the one after it where the line puts it, and the import warns about it (`absolutely_placed_right_to_left_characters_sit_on_their_own_x` in `crates/svg/tests/it/import_text.rs`).
|
||||
SVG import puts each absolutely placed character of right-to-left text on its own `x`, as [SVG 1.1's text chunks](https://www.w3.org/TR/SVG11/text.html#TextLayoutIntroduction) require, also when the characters run right to left on a later line: in `<text direction="rtl" font-size="20">`, `<tspan x="100 160" y="80 80">אב</tspan>` after a first line puts the right edges of `א` and `ב` at 100 and 160, where import put the right edge of `א` at 393.48 before. Chunks that overlap keep their own anchors, and characters stretched by `lengthAdjust="spacingAndGlyphs"` land on their `x` too (`absolutely_placed_right_to_left_characters_sit_on_their_own_x` in `crates/svg/tests/it/import_text.rs`).
|
||||
SVG import puts an absolutely placed character on its `x` also when one text object cannot place it. [SVG 1.1 reorders right-to-left characters only within a text chunk](https://www.w3.org/TR/SVG11/text.html#RelationshipWithBi-directionality), while one object reorders the whole line: in `<text x="100 160 220" y="80" direction="rtl" font-size="20">אbג</text>`, the left-to-right `b` is drawn right before `ג` with no kerning between them, and import left `ג` where the line put it, with a warning, before. Such a text imports as a group of point type objects named after the element, cut before each character one object cannot place, with the right edges of `א`, `b` and `ג` at 100, 160 and 220, and the import warns that the text became several objects. A text that one object can place stays one object, and a split text in a clip path clips by the outlines of all its objects (`absolutely_placed_characters_one_object_cannot_place_import_as_a_group` in `crates/svg/tests/it/import_text.rs`, `a_text_imported_as_several_objects_clips_by_all_their_outlines` in `crates/svg/tests/it/clip_text.rs`).
|
||||
SVG import places type on a path of one closed subpath as [SVG 2's `startOffset` attribute](https://www.w3.org/TR/SVG2/text.html#TextPathElementStartOffsetAttribute) describes: text anchored to start before the path's start point, or offset past its end, wraps around the path, so text with `text-anchor="end"` at `startOffset` 0 ends at the start point, and a negative `startOffset` counts back from the end. Text longer than the loop draws its first characters whatever its anchor. A path of several closed subpaths still starts the text at the path's start or end (`text_on_a_closed_path_wraps_past_the_path_start` in `crates/svg/tests/it/import_text.rs`).
|
||||
Type on an open path can start before the path's start (`type.pathOptions` `start` below 0), and the characters whose middle falls before the path's start are not drawn, as [SVG 2's text on a path layout](https://www.w3.org/TR/SVG2/text.html#TextLayoutPath) describes for the path's start; past the path's end, text that does not fit is overflow, as for other type on a path. The text keeps every character, and the start bracket stays at the path's start. SVG import reads text anchored or offset before an open path's start this way instead of starting it at the path's start, and SVG export writes it with a negative `startOffset`. PDF export writes only the characters drawn on the path, the legacy `.ai` and `.ai` editing data writers write the type from the path's start with a warning, and Release Type on a Path keeps the first drawn character where it was drawn (`type_on_an_open_path_starts_before_the_path` in `crates/doc/src/text/tests.rs`, `on_path_open_start_before_the_path_hides_the_glyphs_before_it` in `crates/text/src/tests.rs`, `text_on_an_open_path_starts_before_the_path` in `crates/svg/tests/it/import_text.rs`, `text_on_an_open_path_starting_before_it_round_trips` in `crates/svg/tests/it/roundtrip.rs`, `options_start_type_before_an_open_path` in `crates/engine/src/tests/pathtype.rs`).
|
||||
SVG import reads the bidi embedding of a `<tspan>`, `<textPath>` or `<a>` inside a `<text>` as [SVG 1.1's bidi section](https://www.w3.org/TR/SVG11/text.html#RelationshipWithBi-directionality) describes: with `unicode-bidi: embed` its characters take its `direction` as their Character Direction, an element with `normal` stays in its parent's embedding, and the `<text>` keeps its own paragraph direction, so a run that SVG export writes with `direction` and `unicode-bidi="embed"` opens with its Character Direction again. Character Direction holds one level of embedding, so `bidi-override`, `isolate` and `isolate-override` are imported as embeddings in their `direction`, `plaintext` as an embedding in the direction of its first strong character, and an embedding inside another as an embedding of its own, each with an import warning. With `unicode-bidi: plaintext` on the `<text>`, each of its paragraphs runs, and each chunk is anchored, in the direction of its first strong character (`a_tspan_bidi_embedding_becomes_its_character_direction`, `unicode_bidi_is_not_inherited_and_reads_from_the_cascade` and `unicode_bidi_values_the_text_model_cannot_hold_are_reported` in `crates/svg/tests/it/import_text.rs`; `character_direction_reads_back` in `crates/svg/tests/it/text_layout.rs`).
|
||||
@@ -1951,6 +1953,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
- PDF export with Output › Convert to Destination and a CMYK destination, or an RGB destination other than sRGB that images are converted to, converts an RGB image that carries an ICC profile from that profile to sRGB and then to the destination, with the color settings' rendering intent, instead of reading its numbers as sRGB ([PDF options](https://helpx.adobe.com/illustrator/using/pdf-options.html)). An untagged image converts from sRGB as before, a gray image keeps its profile, and a profile the color engine can't read leaves the numbers read as sRGB, with a warning. An RGB destination other than sRGB that is the document's own RGB profile leaves RGB colors and RGB images as they are, so a tagged RGB image keeps its profile there (`convert_to_destination_converts_tagged_images_from_their_profile` in `crates/pdf/src/tests/compression.rs`).
|
||||
- SVG import shows a raster `<image>` whose EXIF orientation or TIFF Orientation tag turns or flips it upright, linked or as a data URL, and inside an SVG shown as an image: the pixels are stored turned, the width and height swap, and the `<image>` box fits the turned image under `preserveAspectRatio`, as CSS `image-orientation: from-image` describes (<https://www.w3.org/TR/css-images-3/#the-image-orientation>). A turned CMYK JPEG or TIFF keeps its inks as a CMYK TIFF, as does a CMYK TIFF that is not turned. TIFF data URLs (`image/tiff`, or untyped TIFF bytes) are read, and TIFFs with an alpha or other extra channel, CCITT Group 3 TIFFs and CMYK TIFFs stored one plane per ink are read as Open and Place read them. The pixels are decoded within the decode allowance, and a TIFF claiming more strips or tiles than the decoder can count is refused before it is decoded (`crates/svg/tests/it/image_orientation.rs`).
|
||||
- An image that SVG import stores again, as PNG or as a CMYK TIFF, keeps the resolution its PNG, JPEG, TIFF, WebP or BMP file declares, as Open and Place keep it: in a PNG `pHYs` chunk (<https://www.w3.org/TR/png-3/#11pHYs>) or the TIFF's resolution tags, with the horizontal and vertical values swapped when the image turns a quarter. An image that declares no resolution is stored without one (`a_turned_raster_keeps_its_resolution`, `an_upright_tiff_keeps_its_resolution` and `a_cmyk_tiff_keeps_its_resolution_turned_or_not` in `crates/svg/tests/it/image_orientation.rs`).
|
||||
- An image that SVG import stores again as PNG keeps the ICC profile its TIFF, PNG, JPEG or WebP file carries, as Open and Place keep it, as a PNG `iCCP` chunk, when the profile's color space is the stored samples': gray for gray samples, RGB for RGB ones (<https://www.w3.org/TR/png-3/#11iCCP>). By default, SVG reads an image's colors in the profile built into the image (<https://www.w3.org/TR/SVG11/color.html#ColorProfileProperty>). A profile of another color space, one too short to be a profile, and the profile of a TIFF whose pixels its own reader converts to RGBA (one with an alpha or other extra channel, or CCITT Group 3) are left out, and the image is still imported (`a_raster_written_again_as_png_keeps_its_icc_profile` in `crates/svg/tests/it/image_orientation.rs`).
|
||||
- SVG import leaves out an SVG shown as an image that it can't read (text that isn't XML, an SVG without a size) and goes on with the images after it, as SVG 2's error processing describes (<https://www.w3.org/TR/SVG2/conform.html>). Only images that decode count toward the 256 nested SVG images an SVG may show, so an image after many broken ones is imported. Every nested SVG image read, decoded or not, counts toward VectorCraft's own limits of 1,024 reads and 512 MB of text per import; past them, nested SVG images are left out with a warning (`crates/svg/tests/it/import_details.rs`).
|
||||
- SVG import decodes each image data URL (RFC 2397, <https://www.rfc-editor.org/rfc/rfc2397#section-2>) of an `<image>` or `<feImage>` once, in the imported SVG and in the SVGs shown as its images, however many `<use>` elements, filters or SVG images show it; every use gets the same image. The data URLs of one import decode to at most 512 MB together, VectorCraft's own limit: decoding stops where a URL would pass it, and that image is left out with a warning (`crates/svg/src/import/files.rs`, `crates/svg/tests/it/import_details.rs`).
|
||||
- SVG import measures what an SVG expands to before the SVG reader builds it: every copy a `<use>` shows (<https://www.w3.org/TR/SVG2/struct.html#UseElement>), chains of `<use>`s included, and the style values each copy gets from its `style` attribute and from the style sheet rules that match it. An SVG that expands to more than 999,999 elements (500,000 on the web) or to more than 64 MB of copied style values is refused with an error, and so is a loop of `<use>` references that would be copied without end. The declarations the import's own style cascade keeps count toward the 64 MB too, once for each element a rule matches, including those of rules the reader drops, such as ones with `:not()`. Matching the style sheets' selectors against those elements may take at most 50,000,000 tests; past that the SVG is refused, so a selector that never matches can't keep the import busy. These limits are VectorCraft's own. An SVG shown as an image, from a data URL or a linked SVG file, counts toward the same limits as the SVG showing it, and one past any of them refuses the whole import (`crates/svg/src/import/budget.rs`, `crates/svg/tests/it/import_details.rs`).
|
||||
@@ -1960,6 +1963,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
- In the Linux Flatpak on GNOME, where the clipboard goes through the compositor's core Wayland protocol, one Copy offers the PNG (`image/png`), the SVG (`image/svg+xml`, with Include SVG Code on) and the text, and Paste takes another app's SVG, text or PNG in that order, a picture over blank text or text that only names it; the Paste menu item is enabled by the types offered (`clipboard::wayland` tests in `apps/vectorcraft/src/clipboard.rs`; not yet run in the Flatpak on a GNOME session).
|
||||
- On that core Wayland clipboard, a paste from an app that leaves its pipe open and sends no data for 2 s fails and pastes nothing, and a paste of VectorCraft's Copy by an app that takes no data for 2 s is stopped and its pipe closed, so later pastes and copies are read and sent again; the 2 s limit is VectorCraft's own and starts again after each byte that moves (`clipboard::wayland::tests::a_read_from_an_app_that_stops_sending_fails_and_closes_the_pipe` and `a_send_to_an_app_that_stops_reading_fails_and_frees_its_thread`).
|
||||
- On that core Wayland clipboard, files copied in a file manager paste as the first one that is art, before the clipboard's other types, as on the other platforms: Paste reads the `text/uri-list` the file manager offers (RFC 2483), else GNOME Files' `x-special/gnome-copied-files`, off the UI thread, and takes the `file:` URIs with no host or `localhost` (RFC 8089), percent escapes decoded; other URIs are skipped, and a list of more than 1,024 URIs, VectorCraft's own limit, names no file. The Paste menu item is enabled when a file list is offered (`clipboard::wayland::tests::files_copied_in_a_file_manager_paste_as_their_art`; not yet run in the Flatpak on a GNOME session).
|
||||
- Through arboard (X11 and the Wayland data-control clipboard, and macOS), Edit › Paste is also enabled when the clipboard holds only files copied in a file manager, which the paste keys already pasted: the check reads the file list after the text, without opening a file, and a paste of text alone does not count the files (`clipboard::portable::tests::paste_is_available_for_files_copied_in_a_file_manager`; not yet run on macOS).
|
||||
- On the desktop with Enable Background Export on (Preferences › File Handling), File › Package… collects the linked files and fonts and writes the package from the document as it was at OK on the thread that writes background saves and exports, with "Packaging" in the status bar and the busy spinner until it is written; a save of unsaved changes that Package starts is written first. `file.package` over MCP and scripts replies as before.
|
||||
- On the desktop with Enable Background Export on, Export for Screens and the Asset Export panel's Export encode and write their files (into the folder, or one ZIP in it) from the document as it was at OK on the thread that writes background saves and exports, with "Exporting" in the status bar and the export progress dialog, which counts the files and whose Cancel stops before the next file. `document.exportForScreens` and `assets.export` over MCP and scripts reply as before.
|
||||
- With Enable Background Export on, an Export for Screens with no folder of its own also writes in the background into the folder its `exportPreset` keeps, with the same progress dialog and Cancel, and the status bar names that folder. When that folder is outside an MCP client's read roots, the reply, its errors and the status bar name it by its own name, as for an export made at once (`dialogs::tests_screens::an_export_into_a_presets_folder_writes_in_the_background`, `fileio::tests_screens::a_prepared_export_into_a_presets_folder_outside_the_read_root_leaves_it_out`). Behavior reference: the help page, https://helpx.adobe.com/illustrator/using/exporting-artwork.html (exports run in the background by default).
|
||||
|
||||
@@ -455,6 +455,7 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
|
||||
| Gradient panel: Method, Classic or Perceptual (30.0) | done | Method menu under the Stroke buttons for linear and radial gradients (`paint.editGradient` `method`); [public source](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/create-and-edit-gradients/control-perceptual-interpolation-in-gradients.html); `panels::gradient` test |
|
||||
| Gradient panel: Presets (30.0) | done | Presets menu by library (theme) plus Saved: applies a preset to the gradient behind the active proxy, keeping its placement, one undo step; panel menu Save Gradient Preset…, Delete Gradient Preset, Hide/Show Presets (`gradient.presets.*`); `panels::gradient` tests |
|
||||
| Gradient panel: delete a stop | done | Delete Stop at the right end of the ramp deletes the selected stop, and a stop dragged down off the ramp is deleted on release, never below two stops, one undo step each; [Gradient panel options](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/create-and-edit-gradients/gradient-tool-and-panel.html); `panels::gradient` test |
|
||||
| Gradient tool: the annotator's end handle changes the length; Alt-drag changes the length and angle together | done | A plain drag keeps the end on the bar's line, at least 10 px from the start (VectorCraft's own minimum); Alt-drag moves it freely, Shift with Alt at 45° steps; [Default keyboard shortcuts](https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html); `xform::gradient` tests |
|
||||
| Workspaces (save, reset, switch); each remembers the layout changes made in it across switches and restarts until Reset <name> | done | `UiState::workspace_changes` |
|
||||
| Opening a file: after 0.4 s a progress window with the file name, a moving bar (reading counts no steps), how many more files wait, Cancel (Esc: the file doesn't open) and Continue in Background; never over another dialog or progress window | done | #5930; `opening::show`, `file.cancelOpen`, `file.openInBackground`. Save, Place and Close still show only the status bar's spinner (Place and Save run off the UI thread; Close is immediate) |
|
||||
| Window › Help Bar shows or hides the tool-help strip apart from the status bar; kept with the preferences and in saved workspaces; Presentation Mode hides both bars | done | `window.helpBar`; `help_bar_toggle_is_independent_and_saved_in_workspaces`, `help_bar_and_status_bar_render_independently`, `legacy_help_bar_visibility_follows_each_layouts_status_bar` |
|
||||
|
||||
Reference in new issue
Block a user