mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-20 17:37:10 +01:00
Merge main into #7766
This commit is contained in:
commit
ae325e674f
39 files changed
+681
-49
No files matched your search
@@ -128,6 +128,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
|
||||
|
||||
- 2026-11-14: Built-in symbol library Weather Icons: adds a sixth procedural symbol library (Window › Symbol Libraries, the Symbols panel's Symbol Libraries Menu) containing six original vector symbols (Sun, Moon, Cloud, Rain, Thunder, Snow) generated in code without default 9-slice guides (part of Gap 5). Headline numbers unchanged.
|
||||
- 2026-11-14: Built-in Tech Circuit brush library: Circuit Trace (chamfered art with 45-degree elbows and terminal pads), Bus Lines (parallel conductor pattern) and Terminal Nodes (repeating solder pads, test points and leads), all original geometry generated in code. Ten built-in brush libraries; G5 remaining estimate 3–13 h (estimated), headline numbers unchanged.
|
||||
- 2026-11-18: Built-in Paint brush library: Flat Sweep, Dry Drag, Loaded Stroke and Fan Sweep, original art brushes generated in code that take the stroke color as tints. Thirteen built-in brush libraries; headline numbers unchanged.
|
||||
|
||||
- 2026-11-05: Window › Toolbars › Keep Tools Beside the Canvas, off by default, docks the Tools panel between left-side panels and the canvas instead of at the window's left edge, and the canvas's left edge then also docks a floating Tools panel (`window.toolsBesideCanvas`, #5395). Workspaces keep the setting; workspaces saved without it keep Tools at the window's edge. An optional VectorCraft layout choice; headline numbers unchanged.
|
||||
- 2026-11-17: The canvas's left edge docks a floating Tools panel whichever way Keep Tools Beside the Canvas is set: a drop there, right of panels docked on the left, turns the setting on, and a drop on the window's left edge turns it off (#7837). Headline numbers unchanged.
|
||||
|
||||
@@ -175,6 +175,7 @@ pub const BUILTIN: &[BuiltinBrushLibrary] = &[
|
||||
BuiltinBrushLibrary { id: "calligraphic-nibs", name: "Calligraphic Nibs", make: calligraphic_nibs },
|
||||
BuiltinBrushLibrary { id: "pressure-sensitive", name: "Pressure Sensitive", make: pressure_sensitive },
|
||||
BuiltinBrushLibrary { id: "bristle-brushes", name: "Bristle Brushes", make: bristle_brushes },
|
||||
BuiltinBrushLibrary { id: "paint", name: "Paint", make: paint },
|
||||
BuiltinBrushLibrary { id: "pattern-borders", name: "Pattern Borders", make: pattern_borders },
|
||||
BuiltinBrushLibrary { id: "scatter-shapes", name: "Scatter Shapes", make: scatter_shapes },
|
||||
BuiltinBrushLibrary { id: "stipple", name: "Stipple", make: stipple },
|
||||
@@ -594,6 +595,45 @@ fn spacer(r: Rect) -> Node {
|
||||
Node::path(NodeId(0), shapes::rectangle(r), Appearance::default())
|
||||
}
|
||||
|
||||
/// Paint: original filled vector art with broad, broken, loaded, and fanned marks. Each is one
|
||||
/// stroke stretched along the path, with an intentionally different edge and paint distribution.
|
||||
fn paint() -> BrushLibrary {
|
||||
let flat_sweep = group(vec![
|
||||
black(band(100.0, 5.0, 64, |x| 0.8 * (x / 100.0 * std::f64::consts::TAU).sin())),
|
||||
black(polygon(&[(0.0, -2.5), (7.0, -3.8), (18.0, -2.5)])),
|
||||
black(polygon(&[(78.0, 2.5), (94.0, 4.0), (100.0, 2.5)])),
|
||||
]);
|
||||
let mut dry_drag = vec![];
|
||||
for (y, shift) in [(-5.0, 0.0), (-3.2, 4.0), (-1.3, 1.0), (0.8, 6.0), (2.8, 3.0), (4.8, 8.0)] {
|
||||
dry_drag.push(black(shapes::rectangle(Rect::new(2.0 + shift, y, 35.0 + shift, y + 0.8))));
|
||||
dry_drag.push(black(shapes::rectangle(Rect::new(40.0 + shift, y, 75.0 - shift / 2.0, y + 0.8))));
|
||||
dry_drag.push(black(shapes::rectangle(Rect::new(80.0 - shift / 2.0, y, 98.0, y + 0.8))));
|
||||
}
|
||||
let mut loaded_stroke = vec![black(band(100.0, 6.0, 64, |x| 1.2 * (x / 100.0 * 2.0 * std::f64::consts::TAU).sin()))];
|
||||
for (x, r) in [(12.0, 4.2), (39.0, 3.6), (64.0, 4.8), (88.0, 3.9)] {
|
||||
loaded_stroke.push(black(shapes::ellipse(Rect::new(x - r, -r - 1.5, x + r, r + 1.5))));
|
||||
}
|
||||
let mut fan_sweep = vec![];
|
||||
for i in -2..=2 {
|
||||
let offset = i as f64;
|
||||
fan_sweep.push(black(band(100.0, 1.2, 48, |x| offset * (1.4 + x * 0.045) + 0.3 * (x / 100.0 * std::f64::consts::TAU).sin())));
|
||||
}
|
||||
let paint_art = |name: &str, art: Node| Brush {
|
||||
name: name.into(),
|
||||
kind: BrushKind::Art(ArtBrush { art, width: 150.0, colorization: Colorization::Tints, ..Default::default() }),
|
||||
};
|
||||
built(
|
||||
"Paint",
|
||||
Document::new(100.0, 100.0),
|
||||
vec![
|
||||
paint_art("Flat Sweep", flat_sweep),
|
||||
paint_art("Dry Drag", group(dry_drag)),
|
||||
paint_art("Loaded Stroke", group(loaded_stroke)),
|
||||
paint_art("Fan Sweep", group(fan_sweep)),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
/// Pattern Borders: pattern brushes of tiles drawn here; Beads has corner tiles.
|
||||
fn pattern_borders() -> BrushLibrary {
|
||||
let zigzag = black(polygon(&[(0.0, 1.4), (5.0, -2.6), (10.0, 1.4), (10.0, 2.6), (5.0, -1.4), (0.0, 2.6)]));
|
||||
|
||||
@@ -112,6 +112,7 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
|
||||
"calligraphic-nibs",
|
||||
"pressure-sensitive",
|
||||
"bristle-brushes",
|
||||
"paint",
|
||||
"pattern-borders",
|
||||
"scatter-shapes",
|
||||
"stipple",
|
||||
@@ -170,6 +171,7 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
|
||||
("calligraphic-nibs", "calligraphic"),
|
||||
("pressure-sensitive", "art"),
|
||||
("bristle-brushes", "bristle"),
|
||||
("paint", "art"),
|
||||
("pattern-borders", "pattern"),
|
||||
("scatter-shapes", "scatter"),
|
||||
("stipple", "scatter"),
|
||||
@@ -544,6 +546,37 @@ fn pressure_sensitive_brushes_widen_with_pen_pressure_and_survive_a_saved_librar
|
||||
assert_eq!(vectorcraft_brush::library(&reopened), lib.brushes);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paint_brushes_draw_distinct_marks_and_survive_a_saved_library() {
|
||||
let mut s = session();
|
||||
let (_, lib) = cmd::brushlib::library(&s, "Paint").unwrap();
|
||||
let names = ["Flat Sweep", "Dry Drag", "Loaded Stroke", "Fan Sweep"];
|
||||
assert_eq!(lib.brushes.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(), names);
|
||||
let path = run(&mut s, "shape.line", json!({"x1": 10, "y1": 40, "x2": 190, "y2": 40}))["id"].as_u64().unwrap();
|
||||
let mut curve = line_to(20.0);
|
||||
curve.curve_to((60.0, -25.0), (140.0, 25.0), (180.0, 0.0));
|
||||
for b in &lib.brushes {
|
||||
let BrushKind::Art(art) = &b.kind else { panic!("{} is not an art brush", b.name) };
|
||||
assert_eq!(art.colorization, vectorcraft_brush::Colorization::Tints);
|
||||
assert_eq!(art.width, 150.0);
|
||||
for line in [line_to(2.0), line_to(180.0), curve.clone()] {
|
||||
let pieces = vectorcraft_brush::stroke_pieces(&lib.doc, b, &line, &black_stroke());
|
||||
let points = anchors(&pieces.iter().collect::<Vec<_>>());
|
||||
assert!(!points.is_empty() && points.iter().all(|p| p.x.is_finite() && p.y.is_finite()), "{}", b.name);
|
||||
}
|
||||
let before = undo_len(&s);
|
||||
let added = run(&mut s, "brush.addFromLibrary", json!({"library": "paint", "name": b.name, "apply": true, "ids": [path]}));
|
||||
assert_eq!(strs(&added["added"]), [b.name.as_str()]);
|
||||
assert_eq!(added["applied"], json!([path]));
|
||||
assert_eq!(undo_len(&s), before + 1);
|
||||
assert_eq!(doc(&s).node(NodeId(path)).unwrap().appearance.stroke().unwrap().brush.as_deref(), Some(b.name.as_str()));
|
||||
}
|
||||
let saved = run(&mut s, "brush.saveLibrary", json!({"names": names}));
|
||||
let bytes = vectorcraft_format::base64_decode(saved["dataBase64"].as_str().unwrap()).unwrap();
|
||||
let reopened = vectorcraft_format::load(&bytes).unwrap();
|
||||
assert_eq!(vectorcraft_brush::library(&reopened), lib.brushes);
|
||||
}
|
||||
|
||||
/// Ink and Wash: a tapered ink art brush, a brush pen whose size follows the pen pressure and two
|
||||
/// translucent washes, with names of their own and a few paths of art each.
|
||||
#[test]
|
||||
|
||||
@@ -16,7 +16,11 @@
|
||||
//! range reaches, or a tab) are point type of their own, and an underline or strikethrough is carried across the space between.
|
||||
//! It is also carried on to the end of the last character's advance. Type on more than one line
|
||||
//! is placed a line at a time: each line is aligned by its own advances and split as a single
|
||||
//! line is.
|
||||
//! line is. A character cell runs from the font's OS/2 usWinAscent above the baseline to its
|
||||
//! usWinDescent below it, and top or bottom aligned text has the top or the bottom of its cells
|
||||
//! at the reference point. Text drawn in the opaque background mode (the mode a playback starts
|
||||
//! in) has one rectangle of the background color behind the character cells of each line, as
|
||||
//! far as its advances reach.
|
||||
//! - Clip regions and clip paths become clipping groups around what they clip; a rectangle around
|
||||
//! the whole picture clips nothing and is left out.
|
||||
//!
|
||||
@@ -541,22 +545,38 @@ impl Mapper {
|
||||
// one for every character: a NUL's advance goes to the character before it, or moves the
|
||||
// start when the string begins with one.
|
||||
let advances = t.dx.len() == t.text.chars().count() && t.dx.iter().all(|d| d.is_finite());
|
||||
let (mut s, mut dx, mut lead) = (String::new(), Vec::new(), 0.0f64);
|
||||
let (mut s, mut dx) = (String::new(), Vec::new());
|
||||
// How far before and after its start each character's advances (its own and the NULs'
|
||||
// after it) reach (text units): an advance may be negative. And the advance of the NULs
|
||||
// that move the start, with how far they reach.
|
||||
let mut reach = Vec::new();
|
||||
let mut lead = Lead::default();
|
||||
for (c, d) in t.text.chars().zip(t.dx.iter().map(|d| f64::from(*d)).chain(std::iter::repeat(0.0))) {
|
||||
if c != '\0' {
|
||||
s.push(c);
|
||||
dx.push(d);
|
||||
} else if let Some(last) = dx.last_mut() {
|
||||
reach.push((d.min(0.0), d.max(0.0)));
|
||||
} else if let (Some(last), Some(r)) = (dx.last_mut(), reach.last_mut()) {
|
||||
*last += d;
|
||||
*r = (r.0.min(*last), r.1.max(*last));
|
||||
} else {
|
||||
lead += d;
|
||||
lead.by += d;
|
||||
lead.reach = (lead.reach.0.min(lead.by), lead.reach.1.max(lead.by));
|
||||
}
|
||||
}
|
||||
if !advances {
|
||||
dx.clear();
|
||||
lead = 0.0;
|
||||
reach.clear();
|
||||
lead = Lead::default();
|
||||
}
|
||||
if s.trim().is_empty() || t.color[3] == 0 {
|
||||
// The leading NULs, of the text or of a string of NULs alone.
|
||||
let first = lead;
|
||||
// Type that draws nothing still fills its character cells on an opaque background.
|
||||
let background = t.background.filter(|c| c[3] > 0);
|
||||
let shows = !s.trim().is_empty() && t.color[3] > 0;
|
||||
// A string of NULs only fills the cells across its advances.
|
||||
let nuls = s.is_empty() && first.reach.0 < first.reach.1 && background.is_some();
|
||||
if (s.is_empty() && !nuls) || !(shows || background.is_some()) {
|
||||
return;
|
||||
}
|
||||
// Text space → document without the move: its vertical scale gives the type size, and what
|
||||
@@ -613,11 +633,26 @@ impl Mapper {
|
||||
if !dx.is_empty() {
|
||||
style.kerning = Some(0.0);
|
||||
}
|
||||
// Where the baseline is below the reference point.
|
||||
// The character cell above and below the baseline (points): the face's OS/2 usWinAscent
|
||||
// and usWinDescent at the type size (its own ascent and descent when it has no OS/2
|
||||
// table), as tall as a positive height asks.
|
||||
let cell = face
|
||||
.as_ref()
|
||||
.map(|face| {
|
||||
let (a, d) = face.win_ascent_descent().unwrap_or_else(|| face.vertical_metrics());
|
||||
(a / face.units_per_em() * size, d / face.units_per_em() * size)
|
||||
})
|
||||
.filter(|(a, d)| a.is_finite() && d.is_finite() && *a >= 0.0 && *d >= 0.0 && a + d > 0.0)
|
||||
.unwrap_or_else(|| {
|
||||
let c = if h > 0.0 { size / 0.85 } else { size };
|
||||
(0.8 * c, 0.2 * c)
|
||||
});
|
||||
// Where the baseline is below the reference point: the top or the bottom of the cell is at
|
||||
// the reference point.
|
||||
let drop = match t.v_align {
|
||||
VAlign::Baseline => 0.0,
|
||||
VAlign::Bottom => -0.2 * size,
|
||||
VAlign::Top => 0.8 * size,
|
||||
VAlign::Bottom => -cell.1,
|
||||
VAlign::Top => cell.0,
|
||||
};
|
||||
let origin = self.xf * Point::new(t.transform[4], t.transform[5]);
|
||||
let base = Affine::translate(origin.to_vec2()) * shape;
|
||||
@@ -633,19 +668,65 @@ impl Mapper {
|
||||
};
|
||||
let whole = point(&s);
|
||||
let opacity = f32::from(t.color[3]) / 255.0;
|
||||
let line = Line {
|
||||
base,
|
||||
drop,
|
||||
align: &t.h_align,
|
||||
decorated: f.underline || f.strike,
|
||||
shows,
|
||||
color: t.color,
|
||||
opacity,
|
||||
background,
|
||||
cell,
|
||||
point: &point,
|
||||
};
|
||||
// The backgrounds of every line and piece, and the type added after them so that none of
|
||||
// them covers it.
|
||||
let mut out = TextOut::default();
|
||||
if dx.is_empty() {
|
||||
let mut text = whole;
|
||||
let laid = vectorcraft_text::layout(db, &text);
|
||||
text.xf = base * Affine::translate((0.0, drop));
|
||||
text.cached_bounds = Some(vectorcraft_text::layout(db, &text).bounds);
|
||||
let mut n = Node::new(NodeId(0), NodeKind::Text(Box::new(text)));
|
||||
n.opacity = opacity;
|
||||
self.push(chain, n);
|
||||
return;
|
||||
text.cached_bounds = Some(laid.bounds);
|
||||
if background.is_some() {
|
||||
// How far one line's glyphs reach each way, and the sum of their advances, its
|
||||
// trailing blanks included.
|
||||
let along = laid.glyphs.iter().fold((f64::INFINITY, f64::NEG_INFINITY, 0.0), |(from, to, width), g| {
|
||||
let (a, b) = (g.origin.x, g.origin.x + g.advance);
|
||||
(from.min(a.min(b)), to.max(a.max(b)), width + g.advance)
|
||||
});
|
||||
let one = laid.lines.len() == 1 && along.0.is_finite() && along.1.is_finite() && along.2.is_finite();
|
||||
// The cells of one line run as far as its glyphs' advances reach, or for blanks
|
||||
// alone, which draw no type, where the alignment puts a line that long.
|
||||
// Those of more than one line run across each line's glyphs. NULs alone span
|
||||
// their advances, where the alignment puts them.
|
||||
let cells = if nuls {
|
||||
let start = aligned(first.by * k, 0.0, &t.h_align) - first.by * k;
|
||||
cell_rect(start + first.reach.0 * k, start + first.reach.1 * k, 0.0, cell)
|
||||
} else if one {
|
||||
let (x0, x1) = if shows {
|
||||
(along.0, along.1)
|
||||
} else {
|
||||
let x0 = aligned(0.0, along.2, &t.h_align);
|
||||
(x0, x0 + along.2)
|
||||
};
|
||||
cell_rect(x0, x1, laid.glyphs.first().map_or(0.0, |g| g.origin.y), cell)
|
||||
} else {
|
||||
cells(&laid, &s, cell, &t.h_align, shows && line.decorated)
|
||||
};
|
||||
out.backs.extend(self.background(&line, cells, text.xf));
|
||||
}
|
||||
if shows {
|
||||
let mut n = Node::new(NodeId(0), NodeKind::Text(Box::new(text)));
|
||||
n.opacity = opacity;
|
||||
out.texts.push(n);
|
||||
}
|
||||
return self.add_text(&chain, out);
|
||||
}
|
||||
// Text units grow by `k` along the baseline in the text object's own space.
|
||||
let dx: Vec<f64> = dx.iter().map(|d| d * k).collect();
|
||||
let reach: Vec<(f64, f64)> = reach.iter().map(|(lo, hi)| (lo * k, hi * k)).collect();
|
||||
let chars: Vec<char> = s.chars().collect();
|
||||
let line = Line { base, drop, align: &t.h_align, decorated: f.underline || f.strike, color: t.color, opacity, point: &point, chain: &chain };
|
||||
// Type on more than one line is placed a line at a time, each line aligned by its own
|
||||
// advances (layout leaves the tracking after a line's last character out of the width it
|
||||
// aligns, and each line ends with its own) and its underline carried on to its own end.
|
||||
@@ -655,25 +736,68 @@ impl Mapper {
|
||||
// a search.
|
||||
let starts: Vec<usize> = s.char_indices().map(|(at, _)| at).collect();
|
||||
let count = |to: usize| starts.partition_point(|at| *at < to);
|
||||
let first = laid.lines.first().map_or(0.0, |l| l.baseline);
|
||||
let top = laid.lines.first().map_or(0.0, |l| l.baseline);
|
||||
for (n, l) in laid.lines.iter().enumerate() {
|
||||
let (from, to) = (count(l.start), count(l.end));
|
||||
let (Some(cs), Some(dx)) = (chars.get(from..to), dx.get(from..to)) else { continue };
|
||||
let (Some(cs), Some(dx), Some(reach)) = (chars.get(from..to), dx.get(from..to), reach.get(from..to)) else { continue };
|
||||
// A leading NUL's advance comes before the first line only.
|
||||
let lead = if n == 0 { lead * k } else { 0.0 };
|
||||
let down = l.baseline - first;
|
||||
self.line(&line, cs, dx, lead, if down.is_finite() { down } else { 0.0 });
|
||||
let lead = if n == 0 { first.scaled(k) } else { Lead::default() };
|
||||
let down = l.baseline - top;
|
||||
self.line(&line, cs, Advances { dx, reach, lead }, if down.is_finite() { down } else { 0.0 }, &mut out);
|
||||
}
|
||||
} else {
|
||||
self.line(&line, &chars, &dx, lead * k, 0.0);
|
||||
self.line(&line, &chars, Advances { dx: &dx, reach: &reach, lead: first.scaled(k) }, 0.0, &mut out);
|
||||
}
|
||||
self.add_text(&chain, out);
|
||||
}
|
||||
|
||||
/// Adds a text record's backgrounds and then its type, leaving out backgrounds when there is
|
||||
/// no room for both.
|
||||
fn add_text(&mut self, chain: &[Arc<Clip>], out: TextOut) {
|
||||
let TextOut { mut backs, texts } = out;
|
||||
let keep = MAX_NODES.saturating_sub(self.out.len()).saturating_sub(texts.len());
|
||||
if backs.len() > keep {
|
||||
backs.truncate(keep);
|
||||
self.warn(TOO_MANY);
|
||||
}
|
||||
for n in backs.into_iter().chain(texts) {
|
||||
self.push(chain.to_vec(), n);
|
||||
}
|
||||
}
|
||||
|
||||
/// One line of text with advances `dx` (points along the baseline) for its characters `chars`,
|
||||
/// `down` below the first line's baseline: in pieces, each a text object of its own, a new
|
||||
/// piece after each cluster that tracking can't space by its advance.
|
||||
fn line(&mut self, line: &Line, chars: &[char], dx: &[f64], lead: f64, down: f64) {
|
||||
if chars.is_empty() || (chars.iter().all(|c| c.is_whitespace()) && !line.decorated) {
|
||||
/// Character cells `cells`, placed by `xf`, filled with the line's background when it has one.
|
||||
fn background(&self, line: &Line, mut cells: BezPath, xf: Affine) -> Option<Node> {
|
||||
let bg = line.background?;
|
||||
if cells.elements().is_empty() {
|
||||
return None;
|
||||
}
|
||||
cells.apply_affine(xf);
|
||||
self.path_node(cells, Some(bg), None, false)
|
||||
}
|
||||
|
||||
/// One line of text with advances `adv` (points along the baseline) for its characters
|
||||
/// `chars`, `down` below the first line's baseline: in pieces, each a text object of its own,
|
||||
/// a new piece after each cluster that tracking can't space by its advance.
|
||||
fn line(&mut self, line: &Line, chars: &[char], adv: Advances, down: f64, out: &mut TextOut) {
|
||||
let Advances { dx, reach, lead } = adv;
|
||||
// The line's cells, one rectangle behind every piece, run as far each way as its
|
||||
// advances reach (an advance may be negative), from where the leading NULs' advances
|
||||
// start, which the alignment puts where it puts a line as long as its advances. A line
|
||||
// of leading NULs alone fills the cells across their advances.
|
||||
let start = aligned(lead.by, dx.iter().sum(), line.align);
|
||||
if line.background.is_some() {
|
||||
let (mut lo, mut hi, mut pos) = (lead.reach.0 - lead.by, lead.reach.1 - lead.by, 0.0f64);
|
||||
for (d, r) in dx.iter().zip(reach) {
|
||||
(lo, hi) = (lo.min(pos + r.0), hi.max(pos + r.1));
|
||||
pos += d;
|
||||
}
|
||||
let xf = line.base * Affine::translate((0.0, line.drop + down));
|
||||
out.backs.extend(self.background(line, cell_rect(start + lo, start + hi, 0.0, line.cell), xf));
|
||||
}
|
||||
let blank = |cs: &[char]| cs.iter().all(|c| c.is_whitespace());
|
||||
// A piece's type draws when it shows: blanks only when underlined or struck through.
|
||||
let draws = |cs: &[char]| line.shows && (!blank(cs) || line.decorated);
|
||||
if chars.is_empty() || !draws(chars) {
|
||||
return;
|
||||
}
|
||||
let db = vectorcraft_text::FontDb::global();
|
||||
@@ -684,13 +808,13 @@ impl Mapper {
|
||||
// Along the baseline (the text object's own space), where the next piece starts from the
|
||||
// reference point: the line as long as its advances (a leading NUL's included), where the
|
||||
// alignment puts it.
|
||||
let mut at = aligned(lead, dx.iter().sum(), line.align);
|
||||
let mut at = start;
|
||||
let last = pieces.len().saturating_sub(1);
|
||||
for (i, (from, to)) in pieces.into_iter().enumerate() {
|
||||
let piece: String = chars.get(from..to).unwrap_or_default().iter().collect();
|
||||
let cs = chars.get(from..to).unwrap_or_default();
|
||||
let piece: String = cs.iter().collect();
|
||||
let dx = dx.get(from..to).unwrap_or_default();
|
||||
// Blanks of their own draw nothing unless they are underlined or struck through.
|
||||
if piece.trim().is_empty() && !line.decorated {
|
||||
if !draws(cs) {
|
||||
at += dx.iter().sum::<f64>();
|
||||
continue;
|
||||
}
|
||||
@@ -715,12 +839,12 @@ impl Mapper {
|
||||
let gap = if (split && i < last) || (i == last && line.decorated) { gaps(&laid, db, &text, x0 + span) } else { BezPath::new() };
|
||||
let mut n = Node::new(NodeId(0), NodeKind::Text(Box::new(text.clone())));
|
||||
n.opacity = line.opacity;
|
||||
self.push(line.chain.to_vec(), n);
|
||||
out.texts.push(n);
|
||||
if !gap.elements().is_empty() {
|
||||
let mut gap = gap;
|
||||
gap.apply_affine(text.xf);
|
||||
if let Some(n) = self.path_node(gap, Some(line.color), None, false) {
|
||||
self.push(line.chain.to_vec(), n);
|
||||
out.texts.push(n);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -785,16 +909,95 @@ fn aligned(lead: f64, span: f64, align: &HAlign) -> f64 {
|
||||
|
||||
/// What every piece of a text record's lines shares: the text space (`base`, with the baseline
|
||||
/// `drop` below the reference point), the alignment, whether the type is underlined or struck
|
||||
/// through, its color and opacity, a point type object of a string in its style, and its clips.
|
||||
/// through, whether the type shows, its color and opacity, its background and the character cell
|
||||
/// above and below the baseline (points), and a point type object of a string in its style.
|
||||
struct Line<'a> {
|
||||
base: Affine,
|
||||
drop: f64,
|
||||
align: &'a HAlign,
|
||||
decorated: bool,
|
||||
shows: bool,
|
||||
color: [u8; 4],
|
||||
opacity: f32,
|
||||
background: Option<[u8; 4]>,
|
||||
cell: (f64, f64),
|
||||
point: &'a dyn Fn(&str) -> TextObject,
|
||||
chain: &'a [Arc<Clip>],
|
||||
}
|
||||
|
||||
/// What a text record draws: the backgrounds behind its character cells, and its type (with the
|
||||
/// bars that carry an underline or strikethrough on), added after them.
|
||||
#[derive(Default)]
|
||||
struct TextOut {
|
||||
backs: Vec<Node>,
|
||||
texts: Vec<Node>,
|
||||
}
|
||||
|
||||
/// One line's advances (points along the baseline): each character's own, how far before and
|
||||
/// after its start the advances from it to the next character reach, and the leading NULs'.
|
||||
struct Advances<'a> {
|
||||
dx: &'a [f64],
|
||||
reach: &'a [(f64, f64)],
|
||||
lead: Lead,
|
||||
}
|
||||
|
||||
/// The NULs that move a line's start: their advance, and how far before and after the line's
|
||||
/// start they reach.
|
||||
#[derive(Clone, Copy, Default)]
|
||||
struct Lead {
|
||||
by: f64,
|
||||
reach: (f64, f64),
|
||||
}
|
||||
|
||||
impl Lead {
|
||||
/// The same NULs with their advances grown by `k`.
|
||||
fn scaled(self, k: f64) -> Lead {
|
||||
Lead { by: self.by * k, reach: (self.reach.0 * k, self.reach.1 * k) }
|
||||
}
|
||||
}
|
||||
|
||||
/// The character cell from `x0` to `x1` along a baseline at `y`, `cell.0` above and `cell.1`
|
||||
/// below it (points); empty when it has no area.
|
||||
fn cell_rect(x0: f64, x1: f64, y: f64, cell: (f64, f64)) -> BezPath {
|
||||
let r = Rect::new(x0, y - cell.0, x1, y + cell.1).abs();
|
||||
if r.width() > 0.0 && r.height() > 0.0 && r.is_finite() { shapes::rectangle(r).to_bezpath() } else { BezPath::new() }
|
||||
}
|
||||
|
||||
/// The character cells of `laid` (the type `s` laid out on more than one line), `cell.0` above
|
||||
/// and `cell.1` below each baseline (points), as one rectangle a line: across the line as layout
|
||||
/// places it and across its glyphs' advances, its trailing blanks included (layout leaves them
|
||||
/// out of the width it aligns). A line of blanks alone runs across its glyphs' advances when
|
||||
/// the type draws its underline or strikethrough (`decorated`), and otherwise as wide as their
|
||||
/// advances, where `align` puts a line that long.
|
||||
fn cells(laid: &vectorcraft_text::TextLayout, s: &str, cell: (f64, f64), align: &HAlign, decorated: bool) -> BezPath {
|
||||
// Each line's baseline, the sum of its glyphs' advances, how far before and after the
|
||||
// reference point they reach, and whether they are all blanks. Glyphs come line by line.
|
||||
type Row = (usize, f64, f64, (f64, f64), bool);
|
||||
let mut lines: Vec<Row> = Vec::new();
|
||||
for g in &laid.glyphs {
|
||||
let blank = s.get(g.byte..).and_then(|r| r.chars().next()).is_none_or(char::is_whitespace);
|
||||
let (from, to) = (g.origin.x.min(g.origin.x + g.advance), g.origin.x.max(g.origin.x + g.advance));
|
||||
match lines.last_mut() {
|
||||
Some((line, _, width, reach, all)) if *line == g.line => {
|
||||
*width += g.advance;
|
||||
*reach = (reach.0.min(from), reach.1.max(to));
|
||||
*all &= blank;
|
||||
}
|
||||
_ => lines.push((g.line, g.origin.y, g.advance, (from, to), blank)),
|
||||
}
|
||||
}
|
||||
let mut bp = BezPath::new();
|
||||
for (line, y, width, reach, blank) in lines {
|
||||
let (x0, x1) = match laid.lines.get(line) {
|
||||
Some(l) if !blank => (l.x0.min(reach.0), l.x1.max(reach.1)),
|
||||
_ if decorated => reach,
|
||||
_ => {
|
||||
let x0 = aligned(0.0, width, align);
|
||||
(x0, x0 + width)
|
||||
}
|
||||
};
|
||||
bp.extend(cell_rect(x0, x1, y, cell));
|
||||
}
|
||||
bp
|
||||
}
|
||||
|
||||
/// The most times [`advanced`] lays the type out again to correct its tracking.
|
||||
|
||||
@@ -274,7 +274,9 @@ fn hand_built_emf_plays_like_gdi() {
|
||||
let lines = &children[1];
|
||||
assert_eq!(lines.appearance.items.len(), 1);
|
||||
assert!(near(lines.geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 5.0 * mm, 5.0 * mm), 0.01));
|
||||
let NodeKind::Text(t) = &children[2].kind else { panic!("text") };
|
||||
// The background mode starts opaque: the text's cells are filled white behind it.
|
||||
assert_eq!(fill_rgb(&children[2]), Some([255, 255, 255]));
|
||||
let NodeKind::Text(t) = &children[3].kind else { panic!("text") };
|
||||
assert_eq!(t.plain_text(), "Hi");
|
||||
let st = &t.runs[0].style;
|
||||
assert_eq!((st.font_family.as_str(), st.font_style.as_str()), ("Arial", "Bold"));
|
||||
@@ -884,6 +886,38 @@ fn wmf_font_width_becomes_horizontal_scale() {
|
||||
assert!((st.h_scale - want).abs() < 1e-9, "{} for {want}", st.h_scale);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wmf_text_fills_its_cells_in_the_opaque_background_mode() {
|
||||
// CREATEFONTINDIRECT and SELECTOBJECT: a 0.1 inch em; SETBKCOLOR green; SETBKMODE `mode`
|
||||
// (none when 0); TEXTOUT "Hi" at (720, 360), top aligned.
|
||||
let backgrounds = |mode: i16| {
|
||||
let mut font = le16(&[-144, 0, 0, 0, 400]);
|
||||
font.extend([0u8; 8]);
|
||||
font.extend(b"Source Sans 3".iter().copied().chain(std::iter::repeat_n(0, 19)));
|
||||
let mut text = le16(&[2]);
|
||||
text.extend(b"Hi");
|
||||
text.extend(le16(&[360, 720]));
|
||||
let mut records = vec![(0x02FB, font), (0x012D, le16(&[0])), (0x0201, 0x0000_ff00u32.to_le_bytes().to_vec())];
|
||||
if mode != 0 {
|
||||
records.push((0x0102, le16(&[mode, 0])));
|
||||
}
|
||||
records.push((0x0521, text));
|
||||
paths(&import(&hand_wmf(1440, 1440, &records)).unwrap().document)
|
||||
};
|
||||
let mm = 72.0 / 25.4;
|
||||
// A file that never sets the mode, and one that sets OPAQUE: one green rectangle whose top
|
||||
// is at the reference point and whose left edge is at the start of the text.
|
||||
for mode in [0, 2] {
|
||||
let p = backgrounds(mode);
|
||||
assert_eq!(p.len(), 1, "{mode}");
|
||||
assert_eq!(fill_rgb(&p[0]), Some([0, 255, 0]), "{mode}");
|
||||
let b = p[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 12.7 * mm).abs() < 0.01 && (b.y0 - 6.35 * mm).abs() < 0.01 && b.x1 > b.x0 && b.y1 > b.y0, "{mode}: {b:?}");
|
||||
}
|
||||
// TRANSPARENT: no background.
|
||||
assert!(backgrounds(1).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_clip_whose_box_holds_the_picture_still_clips() {
|
||||
// A diamond around the middle of the picture, whose box holds the whole frame but which cuts
|
||||
@@ -1001,7 +1035,8 @@ fn clipped_text_is_clipped_to_its_rectangle() {
|
||||
let mut font = le(&[2, -1000, 0, 0, 0, 400]);
|
||||
font.extend([0, 1, 1, 0, 0, 0, 0, 0]);
|
||||
font.extend("Arial".encode_utf16().chain(std::iter::repeat_n(0, 27)).flat_map(u16::to_le_bytes));
|
||||
let mut records = vec![(82, font), (37, le(&[2])), (84, text)];
|
||||
// SETBKMODE TRANSPARENT: no background behind the text.
|
||||
let mut records = vec![(18, le(&[1])), (82, font), (37, le(&[2])), (84, text)];
|
||||
let back = import(&hand_emf(5000, 3000, &records)).unwrap();
|
||||
let layer = back.document.layers[0].children().unwrap();
|
||||
assert_eq!(layer.len(), 1);
|
||||
@@ -1030,6 +1065,156 @@ fn clipped_text_is_clipped_to_its_rectangle() {
|
||||
assert!(matches!(children[1].kind, NodeKind::Text(_)));
|
||||
}
|
||||
|
||||
/// The layer of an EMF that sets the background color green, the background mode `mode` (none
|
||||
/// when 0) and the text alignment `align`, then draws `s` at (`x`, 1500) in `font` with the
|
||||
/// advances `dx`.
|
||||
fn on_background(mode: i32, align: i32, x: i32, font: Vec<u8>, s: &str, dx: &[i32]) -> Vec<std::sync::Arc<Node>> {
|
||||
let mut records = vec![(25, le(&[0x0000_ff00])), (22, le(&[align])), (82, font), (37, le(&[2])), (84, text_out(x, s, dx))];
|
||||
if mode > 0 {
|
||||
records.insert(0, (18, le(&[mode])));
|
||||
}
|
||||
import(&hand_emf(5000, 3000, &records)).unwrap().document.layers[0].children().unwrap().clone()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn opaque_backgrounds_fill_behind_the_character_cells() {
|
||||
let mm = 72.0 / 25.4;
|
||||
let aligned = on_background;
|
||||
// TA_BASELINE: the baseline at (10, 15) mm.
|
||||
let drawn = |mode: i32, font: Vec<u8>, s: &str, dx: &[i32]| aligned(mode, 24, 1000, font, s, dx);
|
||||
let opaque = |font: Vec<u8>, s: &str, dx: &[i32]| drawn(2, font, s, dx);
|
||||
// "Hi" with advances of 20 and 10 mm in a 10 mm em: the cells run across the advances, from
|
||||
// the face's usWinAscent above the baseline to its usWinDescent below it, behind the type.
|
||||
let layer = opaque(arial(), "Hi", &[2000, 1000]);
|
||||
assert_eq!(layer.len(), 2);
|
||||
assert_eq!(fill_rgb(&layer[0]), Some([0, 255, 0]));
|
||||
let NodeKind::Text(t) = &layer[1].kind else { panic!("text") };
|
||||
let face = vectorcraft_text::FontDb::global().style_face(&t.runs[0].style).unwrap();
|
||||
let (a, d) = face.win_ascent_descent().unwrap();
|
||||
let em = face.units_per_em();
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!(near(b, Rect::new(10.0 * mm, (15.0 - 10.0 * a / em) * mm, 40.0 * mm, (15.0 + 10.0 * d / em) * mm), 0.01), "{b:?}");
|
||||
// TA_TOP and TA_BOTTOM put the top and the bottom of the cell at the reference point: the
|
||||
// baseline is usWinAscent below it, or usWinDescent above it.
|
||||
for (align, top) in [(0, 15.0), (8, 15.0 - 10.0 * (a + d) / em)] {
|
||||
let layer = aligned(2, align, 1000, arial(), "Hi", &[2000, 1000]);
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!((b.y0 - top * mm).abs() < 0.01 && (b.height() - 10.0 * (a + d) / em * mm).abs() < 0.01, "{align}: {b:?}");
|
||||
let NodeKind::Text(t) = &layer[1].kind else { panic!("text") };
|
||||
let baseline = (t.xf * vectorcraft_geom::Point::ZERO).y;
|
||||
assert!((baseline - (top + 10.0 * a / em) * mm).abs() < 0.01, "{align}: {baseline}");
|
||||
}
|
||||
// A leading NUL's advance is filled too: right aligned at 50 mm, "\0Hi" fills from 10 mm.
|
||||
let b = aligned(2, 26, 5000, arial(), "\0Hi", &[1000, 2000, 1000])[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 10.0 * mm).abs() < 0.01 && (b.x1 - 50.0 * mm).abs() < 0.01, "{b:?}");
|
||||
// A positive height is the cell: 10 mm from top to bottom.
|
||||
let mut font = le(&[2, 1000, 0, 0, 0, 400]);
|
||||
font.extend([0; 8]);
|
||||
font.extend("Arial".encode_utf16().chain(std::iter::repeat_n(0, 27)).flat_map(u16::to_le_bytes));
|
||||
let b = opaque(font, "Hi", &[2000, 1000])[0].geometric_bounds().unwrap();
|
||||
assert!((b.height() - 10.0 * mm).abs() < 0.01, "{b:?}");
|
||||
// Without advances the cells run across the glyphs' own advances.
|
||||
let layer = opaque(arial(), "Hi", &[]);
|
||||
let NodeKind::Text(t) = &layer[1].kind else { panic!("text") };
|
||||
let (xs, end) = glyph_xs(t);
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - xs[0]).abs() < 0.01 && (b.x1 - end).abs() < 0.01, "{b:?} {xs:?} {end}");
|
||||
// Type split where an advance is further than tracking reaches: one background across the
|
||||
// whole line's advances comes before both pieces of type.
|
||||
let layer = opaque(arial(), "Hiy", &[12000, 500, 1000]);
|
||||
let kinds: Vec<bool> = layer.iter().map(|n| matches!(n.kind, NodeKind::Text(_))).collect();
|
||||
assert_eq!(kinds, [false, true, true]);
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 10.0 * mm).abs() < 0.01 && (b.x1 - 145.0 * mm).abs() < 0.01, "{b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn opaque_backgrounds_reach_as_far_as_the_advances() {
|
||||
let mm = 72.0 / 25.4;
|
||||
let aligned = on_background;
|
||||
// TA_BASELINE: the baseline at (10, 15) mm.
|
||||
let drawn = |mode: i32, font: Vec<u8>, s: &str, dx: &[i32]| aligned(mode, 24, 1000, font, s, dx);
|
||||
let opaque = |font: Vec<u8>, s: &str, dx: &[i32]| drawn(2, font, s, dx);
|
||||
// Two lines: a rectangle behind each, not one block over the space between them.
|
||||
let layer = opaque(arial(), "Hi\nHi", &[]);
|
||||
let NodeKind::Path { path, .. } = &layer[0].kind else { panic!("a path") };
|
||||
let rects = path.to_bezpath().elements().iter().filter(|e| matches!(e, vectorcraft_geom::PathEl::MoveTo(_))).count();
|
||||
assert_eq!(rects, 2);
|
||||
// Without advances, one line's cells run across its glyphs' advances, trailing spaces
|
||||
// included: right aligned, they run from the "H" to the end of the space after the "i".
|
||||
let layer = aligned(2, 26, 4000, arial(), "Hi ", &[]);
|
||||
let NodeKind::Text(t) = &layer[1].kind else { panic!("text") };
|
||||
let (xs, end) = glyph_xs(t);
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!(xs.len() == 3, "{xs:?} {end}");
|
||||
assert!((b.x0 - xs[0]).abs() < 0.01 && (b.x1 - end).abs() < 0.01, "{b:?} {xs:?} {end}");
|
||||
// Layout aligns a line without its trailing spaces: right aligned at 40 mm, the space after
|
||||
// the "i" runs on past it. On more than one line, the cells also run across the trailing
|
||||
// spaces, as far as on one line.
|
||||
assert!(end > 41.0 * mm, "{end}");
|
||||
let b = aligned(2, 26, 4000, arial(), "Hi \nHi", &[])[0].geometric_bounds().unwrap();
|
||||
assert!((b.x1 - end).abs() < 0.01, "{b:?} {end}");
|
||||
// Leading NULs on a line of their own fill their cells across their advances, before the
|
||||
// next line: from 10 to 30 mm.
|
||||
let layer = opaque(arial(), "\0\nA", &[2000, 0, 1000]);
|
||||
let first = layer[0].geometric_bounds().unwrap();
|
||||
assert!((first.x0 - 10.0 * mm).abs() < 0.01 && (first.x1 - 30.0 * mm).abs() < 0.01, "{first:?}");
|
||||
assert!(matches!(layer[1].kind, NodeKind::Path { .. }) && matches!(layer[2].kind, NodeKind::Text(_)), "{layer:?}");
|
||||
// An underlined line of blanks between two others draws its bar across its glyphs, and its
|
||||
// cells run across the same glyphs.
|
||||
let layer = opaque(font_of("Arial", true), "A\n \nB", &[]);
|
||||
let (NodeKind::Path { path, .. }, NodeKind::Text(t)) = (&layer[0].kind, &layer[1].kind) else { panic!("a path and type") };
|
||||
let mut rects: Vec<(f64, f64, f64)> = Vec::new();
|
||||
for el in path.to_bezpath().elements() {
|
||||
let p = match el {
|
||||
vectorcraft_geom::PathEl::MoveTo(p) => {
|
||||
rects.push((p.x, p.x, p.y));
|
||||
*p
|
||||
}
|
||||
vectorcraft_geom::PathEl::LineTo(p) => *p,
|
||||
_ => continue,
|
||||
};
|
||||
if let Some(r) = rects.last_mut() {
|
||||
*r = (r.0.min(p.x), r.1.max(p.x), r.2.min(p.y));
|
||||
}
|
||||
}
|
||||
rects.sort_by(|a, b| a.2.total_cmp(&b.2));
|
||||
let laid = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
|
||||
let spaces: Vec<(f64, f64)> =
|
||||
laid.glyphs.iter().filter(|g| g.line == 1).map(|g| ((t.xf * g.origin).x, (t.xf * g.origin).x + g.advance)).collect();
|
||||
let (from, to) = spaces.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), (x0, x1)| (a.min(*x0), b.max(*x1)));
|
||||
assert!(rects.len() == 3 && (rects[1].0 - from).abs() < 0.01 && (rects[1].1 - to).abs() < 0.01, "{rects:?} {spaces:?}");
|
||||
// NULs whose advances go forward and back again still fill as far as they reach.
|
||||
let layer = opaque(arial(), "\0\0", &[1000, -1000]);
|
||||
assert_eq!(layer.len(), 1);
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 10.0 * mm).abs() < 0.01 && (b.x1 - 20.0 * mm).abs() < 0.01, "{b:?}");
|
||||
let b = opaque(arial(), "H\0i", &[3000, -2000, 1000])[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 10.0 * mm).abs() < 0.01 && (b.x1 - 40.0 * mm).abs() < 0.01, "{b:?}");
|
||||
// An advance that goes back: the cells reach as far as the advances go, here to 30 mm.
|
||||
let b = opaque(arial(), "Hi", &[2000, -1000])[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 10.0 * mm).abs() < 0.01 && (b.x1 - 30.0 * mm).abs() < 0.01, "{b:?}");
|
||||
// NULs alone fill across their advances.
|
||||
let layer = opaque(arial(), "\0", &[2000]);
|
||||
assert_eq!(layer.len(), 1);
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 10.0 * mm).abs() < 0.01 && (b.x1 - 30.0 * mm).abs() < 0.01, "{b:?}");
|
||||
// Blanks on an opaque background still fill their cells, from the reference point on; on a
|
||||
// transparent one nothing is left.
|
||||
let layer = opaque(arial(), " \t", &[]);
|
||||
assert_eq!(layer.len(), 1);
|
||||
let b = layer[0].geometric_bounds().unwrap();
|
||||
assert!((b.x0 - 10.0 * mm).abs() < 0.01 && b.x1 > 10.0 * mm, "{b:?}");
|
||||
assert!(drawn(1, arial(), " \t", &[]).is_empty());
|
||||
// NULs alone in an underlined font fill their cells and add no type.
|
||||
let layer = opaque(font_of("Arial", true), "\0", &[2000]);
|
||||
assert!(layer.len() == 1 && matches!(layer[0].kind, NodeKind::Path { .. }), "{layer:?}");
|
||||
// A file that never sets the mode draws in the opaque mode a playback starts in.
|
||||
let layer = drawn(0, arial(), "Hi", &[]);
|
||||
assert_eq!(fill_rgb(&layer[0]), Some([0, 255, 0]));
|
||||
assert!(drawn(1, arial(), "Hi", &[]).iter().all(|n| matches!(n.kind, NodeKind::Text(_))));
|
||||
}
|
||||
|
||||
/// The first text object of `d`.
|
||||
fn first_text(d: &Document) -> TextObject {
|
||||
all(d)
|
||||
@@ -1195,8 +1380,8 @@ fn multiline_text_with_advances_aligns_each_line() {
|
||||
}
|
||||
assert!(drops.iter().all(|d| (d - drops[0]).abs() < 0.01), "{drops:?}");
|
||||
// Underlined and left aligned, each line's underline ends with its own advances: no bar runs on
|
||||
// past either line.
|
||||
let records = vec![(82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(1000, "Hi\nHi", &[2000, 1000, 0, 2000, 1000]))];
|
||||
// past either line (on a transparent background, SETBKMODE).
|
||||
let records = vec![(18, le(&[1])), (82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(1000, "Hi\nHi", &[2000, 1000, 0, 2000, 1000]))];
|
||||
let back = import(&hand_emf(5000, 3000, &records)).unwrap();
|
||||
assert!(all(&back.document).iter().all(|n| !matches!(n.kind, NodeKind::Path { .. })));
|
||||
for (align, x, second) in [(6, 2500, [15.0, 30.0]), (2, 4000, [20.0, 35.0])] {
|
||||
@@ -1254,8 +1439,9 @@ fn wmf_text_is_spaced_by_its_advances() {
|
||||
fn split_type_keeps_its_underline_and_right_to_left_order() {
|
||||
let mm = 72.0 / 25.4;
|
||||
// Underlined "Hiy" with an advance further than tracking reaches after the "H": the bar runs on
|
||||
// from the end of the "H"'s underline to where "iy" starts, at 130 mm.
|
||||
let records = vec![(82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(1000, "Hiy", &[12000, 500, 1000]))];
|
||||
// from the end of the "H"'s underline to where "iy" starts, at 130 mm. The background is
|
||||
// transparent (SETBKMODE) throughout.
|
||||
let records = vec![(18, le(&[1])), (82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(1000, "Hiy", &[12000, 500, 1000]))];
|
||||
let back = import(&hand_emf(20000, 3000, &records)).unwrap();
|
||||
assert_eq!(texts_at(&back.document), vec![("H".to_string(), vec![10.0]), ("iy".to_string(), vec![130.0, 135.0])]);
|
||||
let bars: Vec<Rect> =
|
||||
@@ -1265,7 +1451,7 @@ fn split_type_keeps_its_underline_and_right_to_left_order() {
|
||||
assert!(b.x0 > 10.0 * mm && b.x0 < 130.0 * mm && (b.x1 - 130.0 * mm).abs() < 0.01 && b.height() < 2.0 * mm, "{b:?}");
|
||||
// The "H" and the "i" before the split are tracked apart and draw a bar each: only the bar that
|
||||
// ends the piece runs on, from the end of the "i" to 130 mm.
|
||||
let records = vec![(82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(1000, "Hiy", &[1000, 12000, 1000]))];
|
||||
let records = vec![(18, le(&[1])), (82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(1000, "Hiy", &[1000, 12000, 1000]))];
|
||||
let back = import(&hand_emf(20000, 3000, &records)).unwrap();
|
||||
assert_eq!(texts_at(&back.document), vec![("Hi".to_string(), vec![10.0, 20.0]), ("y".to_string(), vec![140.0])]);
|
||||
let gaps: Vec<Node> = all(&back.document).into_iter().filter(|n| matches!(n.kind, NodeKind::Path { .. })).collect();
|
||||
@@ -1276,12 +1462,12 @@ fn split_type_keeps_its_underline_and_right_to_left_order() {
|
||||
let b = gaps[0].geometric_bounds().unwrap();
|
||||
assert!(b.x0 > 20.0 * mm && (b.x1 - 140.0 * mm).abs() < 0.01, "{b:?}");
|
||||
// Without an underline, nothing but the type.
|
||||
let records = vec![(82, arial()), (37, le(&[2])), (84, text_out(1000, "Hiy", &[12000, 500, 1000]))];
|
||||
let records = vec![(18, le(&[1])), (82, arial()), (37, le(&[2])), (84, text_out(1000, "Hiy", &[12000, 500, 1000]))];
|
||||
let back = import(&hand_emf(20000, 3000, &records)).unwrap();
|
||||
assert!(all(&back.document).iter().all(|n| !matches!(n.kind, NodeKind::Path { .. })));
|
||||
// A last advance further than tracking reaches, right aligned at 140 mm: the "H" and the "i"
|
||||
// start at 10 and 20 mm, and the underline runs on from the "i" to 140 mm.
|
||||
let records = vec![(22, le(&[2])), (82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(14000, "Hi", &[1000, 12000]))];
|
||||
let records = vec![(18, le(&[1])), (22, le(&[2])), (82, font_of("Arial", true)), (37, le(&[2])), (84, text_out(14000, "Hi", &[1000, 12000]))];
|
||||
let back = import(&hand_emf(20000, 3000, &records)).unwrap();
|
||||
assert_eq!(texts_at(&back.document), vec![("Hi".to_string(), vec![10.0, 20.0])]);
|
||||
let bars: Vec<Rect> =
|
||||
|
||||
@@ -372,6 +372,12 @@ impl FontFace {
|
||||
/// `usWinDescent`, at the face's location in a variable font), in font units; `None` when the
|
||||
/// font has no OS/2 table or the sum isn't positive.
|
||||
pub fn win_cell_height(&self) -> Option<f64> {
|
||||
self.win_ascent_descent().map(|(a, d)| a + d)
|
||||
}
|
||||
/// The face's character cell on Windows above and below the baseline (the OS/2 table's
|
||||
/// `usWinAscent` and `usWinDescent`, at the face's location in a variable font), in font
|
||||
/// units; `None` when the font has no OS/2 table or the sum isn't positive.
|
||||
pub fn win_ascent_descent(&self) -> Option<(f64, f64)> {
|
||||
use skrifa::raw::TableProvider;
|
||||
let f = self.skrifa()?;
|
||||
let o = f.os2().ok()?;
|
||||
@@ -380,8 +386,8 @@ impl FontFace {
|
||||
let varied = |tag: &[u8; 4]| {
|
||||
f.mvar().ok().and_then(|m| m.metric_delta(skrifa::Tag::new(tag), self.location().coords()).ok()).map_or(0.0, |d| d.to_f64())
|
||||
};
|
||||
let h = f64::from(o.us_win_ascent()) + varied(b"hcla") + f64::from(o.us_win_descent()) + varied(b"hcld");
|
||||
(h > 0.0 && h.is_finite()).then_some(h)
|
||||
let (a, d) = (f64::from(o.us_win_ascent()) + varied(b"hcla"), f64::from(o.us_win_descent()) + varied(b"hcld"));
|
||||
(a + d > 0.0 && (a + d).is_finite()).then_some((a, d))
|
||||
}
|
||||
/// The average width of the face's characters (the OS/2 table's `xAvgCharWidth`), in font
|
||||
/// units; `None` when the font has no OS/2 table or gives no positive width.
|
||||
|
||||
@@ -875,7 +875,8 @@ fn on_path_align_takes_a_variable_font_instances_em_box() {
|
||||
}
|
||||
|
||||
/// A variable font's instance takes its Windows character cell from the `usWinAscent` and
|
||||
/// `usWinDescent` its `MVAR` table varies: 200 units taller in Bold.
|
||||
/// `usWinDescent` its `MVAR` table varies: 200 units taller in Bold, 120 above the baseline and
|
||||
/// 80 below it.
|
||||
#[test]
|
||||
fn win_cell_height_takes_a_variable_font_instances_mvar() {
|
||||
use crate::test_fonts::{PATH_ALIGN_VARIABLE_FAMILY, path_align_font};
|
||||
@@ -885,6 +886,10 @@ fn win_cell_height_takes_a_variable_font_instances_mvar() {
|
||||
let cell = |font_style: &str| db.style_face(&st(font_style)).and_then(|f| f.win_cell_height()).unwrap();
|
||||
let (regular, bold) = (cell("Regular"), cell("Bold"));
|
||||
assert!((bold - regular - 200.0).abs() < 1e-6, "Regular {regular}, Bold {bold}");
|
||||
let split = |font_style: &str| db.style_face(&st(font_style)).and_then(|f| f.win_ascent_descent()).unwrap();
|
||||
let ((ra, rd), (ba, bd)) = (split("Regular"), split("Bold"));
|
||||
assert!((ba - ra - 120.0).abs() < 1e-6 && (bd - rd - 80.0).abs() < 1e-6, "Regular {ra}/{rd}, Bold {ba}/{bd}");
|
||||
assert!((ra + rd - regular).abs() < 1e-6);
|
||||
}
|
||||
|
||||
/// In vertical type, Align to Path moves the glyphs half an em, with their horizontal scale and not
|
||||
|
||||
@@ -7886,6 +7886,11 @@ breakText Glyphs Глифи
|
||||
@msg A joint does not close by {gap} pt. Една връзка не се затваря с {gap} pt.
|
||||
@msg Two panels pass through each other. Два панела минават един през друг.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer трябва да е "singleLine", "everyLine", "standardSingleLine" или "standardEveryLine"
|
||||
Paint Боя
|
||||
Flat Sweep Плосък замах
|
||||
Dry Drag Сухо влачене
|
||||
Loaded Stroke Плътен мазок
|
||||
Fan Sweep Ветрилообразен замах
|
||||
@msg `at` must be "start" or "end" `at` трябва да е "start" или "end"
|
||||
@msg give exactly one of `through` and `toward` посочете точно едно от `through` и `toward`
|
||||
@msg no arc fits these points: two are the same or all three lie on one line няма дъга през тези точки: две съвпадат или и трите лежат на една права
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -7941,6 +7941,11 @@ shape Open Otvoren
|
||||
@msg A joint does not close by {gap} pt. Spoj se ne zatvara za {gap} pt.
|
||||
@msg Two panels pass through each other. Dva panela prolaze jedan kroz drugi.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer mora biti "singleLine", "everyLine", "standardSingleLine" ili "standardEveryLine"
|
||||
Paint Boja
|
||||
Flat Sweep Ravni potez
|
||||
Dry Drag Suhi potez
|
||||
Loaded Stroke Bogati potez
|
||||
Fan Sweep Lepezasti potez
|
||||
@msg `at` must be "start" or "end" `at` mora biti "start" ili "end"
|
||||
@msg give exactly one of `through` and `toward` navedite tačno jedno od `through` i `toward`
|
||||
@msg no arc fits these points: two are the same or all three lie on one line nijedan luk ne odgovara ovim tačkama: dvije su iste ili sve tri leže na jednoj pravoj
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -8922,6 +8922,11 @@ breakText Glyphs Glifs
|
||||
@msg A joint does not close by {gap} pt. Una unió no es tanca per {gap} pt.
|
||||
@msg Two panels pass through each other. Dos panells es travessen l’un a l’altre.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer ha de ser "singleLine", "everyLine", "standardSingleLine" o "standardEveryLine"
|
||||
Paint Pintura
|
||||
Flat Sweep Traç pla
|
||||
Dry Drag Arrossegament sec
|
||||
Loaded Stroke Traç carregat
|
||||
Fan Sweep Traç en ventall
|
||||
Engraving Gravat
|
||||
Fine Hatching Ratllat fi
|
||||
Dense Hatching Ratllat dens
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10746,6 +10746,11 @@ breakText Glyphs Glyfy
|
||||
@msg A panel is not joined to the rest by a crease. Panel není se zbytkem spojen žádnou linií bigu.
|
||||
@msg A fold line is on a non-printing layer. Linie skladu je na netisknutelné vrstvě.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Panely: {panels}, panty: {hinges}, chyby: {errors}, upozornění: {warnings}
|
||||
Paint Malba
|
||||
Flat Sweep Plochý tah
|
||||
Dry Drag Suchý tah
|
||||
Loaded Stroke Sytý tah
|
||||
Fan Sweep Vějířový tah
|
||||
Engraving Rytina
|
||||
Fine Hatching Jemné šrafování
|
||||
Dense Hatching Husté šrafování
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10808,6 +10808,11 @@ breakText Glyphs Glyffer
|
||||
@msg A joint does not close by {gap} pt. En samling lukker ikke med {gap} pt.
|
||||
@msg Two panels pass through each other. To paneler går gennem hinanden.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer skal være "singleLine", "everyLine", "standardSingleLine" eller "standardEveryLine"
|
||||
Paint Maling
|
||||
Flat Sweep Fladt strøg
|
||||
Dry Drag Tørt træk
|
||||
Loaded Stroke Fyldigt strøg
|
||||
Fan Sweep Viftestrøg
|
||||
Engraving Gravering
|
||||
Fine Hatching Fin skravering
|
||||
Dense Hatching Tæt skravering
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10387,6 +10387,11 @@ breakText Glyphs Glyphen
|
||||
@msg A panel is not joined to the rest by a crease. Ein Feld ist durch keine Rilllinie mit den übrigen verbunden.
|
||||
@msg A fold line is on a non-printing layer. Eine Faltlinie liegt auf einer nicht druckbaren Ebene.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Felder: {panels}, Scharniere: {hinges}, Fehler: {errors}, Warnungen: {warnings}
|
||||
Paint Farbe
|
||||
Flat Sweep Flacher Schwung
|
||||
Dry Drag Trockener Zug
|
||||
Loaded Stroke Satter Pinselstrich
|
||||
Fan Sweep Fächerschwung
|
||||
Engraving Gravur
|
||||
Fine Hatching Feine Schraffur
|
||||
Dense Hatching Dichte Schraffur
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -8895,6 +8895,11 @@ breakText Glyphs Γλύφοι
|
||||
@msg A joint does not close by {gap} pt. Μια ένωση δεν κλείνει κατά {gap} pt.
|
||||
@msg Two panels pass through each other. Δύο πάνελ διαπερνούν το ένα το άλλο.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" το composer πρέπει να είναι "singleLine", "everyLine", "standardSingleLine" ή "standardEveryLine"
|
||||
Paint Ζωγραφική
|
||||
Flat Sweep Επίπεδη πινελιά
|
||||
Dry Drag Στεγνό σύρσιμο
|
||||
Loaded Stroke Γεμάτη πινελιά
|
||||
Fan Sweep Βεντάλια
|
||||
Engraving Χαρακτική
|
||||
Fine Hatching Λεπτή διαγράμμιση
|
||||
Dense Hatching Πυκνή διαγράμμιση
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10639,6 +10639,11 @@ breakText Glyphs Glifos
|
||||
@msg A joint does not close by {gap} pt. Una unión no cierra por {gap} pt.
|
||||
@msg Two panels pass through each other. Dos paneles se atraviesan entre sí.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer debe ser "singleLine", "everyLine", "standardSingleLine" o "standardEveryLine"
|
||||
Paint Pintura
|
||||
Flat Sweep Barrido plano
|
||||
Dry Drag Arrastre seco
|
||||
Loaded Stroke Trazo cargado
|
||||
Fan Sweep Barrido en abanico
|
||||
Engraving Grabado
|
||||
Fine Hatching Rayado fino
|
||||
Dense Hatching Rayado denso
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -8978,6 +8978,11 @@ breakText Glyphs Merkit
|
||||
@msg A joint does not close by {gap} pt. Liitos ei sulkeudu, rako {gap} pt.
|
||||
@msg Two panels pass through each other. Kaksi paneelia kulkee toistensa läpi.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer on oltava "singleLine", "everyLine", "standardSingleLine" tai "standardEveryLine"
|
||||
Paint Maalaus
|
||||
Flat Sweep Tasainen veto
|
||||
Dry Drag Kuiva veto
|
||||
Loaded Stroke Runsas siveltimenveto
|
||||
Fan Sweep Viuhkaveto
|
||||
Engraving Kaiverrus
|
||||
Fine Hatching Hieno viivoitus
|
||||
Dense Hatching Tiheä viivoitus
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10709,6 +10709,11 @@ breakText Glyphs Glyphes
|
||||
@msg A joint does not close by {gap} pt. Un joint ne se ferme pas, avec un écart de {gap} pt.
|
||||
@msg Two panels pass through each other. Deux panneaux se traversent.
|
||||
@msg {_1} × {_2} pixels is too large for GIF (at most 65535 pixels a side): lower the resolution {_1} × {_2} pixels, c’est trop grand pour le GIF (65535 pixels par côté au plus) : réduisez la résolution
|
||||
Paint Peinture
|
||||
Flat Sweep Balayage plat
|
||||
Dry Drag Traînée sèche
|
||||
Loaded Stroke Trait chargé
|
||||
Fan Sweep Balayage en éventail
|
||||
Engraving Gravure
|
||||
Fine Hatching Hachures fines
|
||||
Dense Hatching Hachures denses
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5634,6 +5634,11 @@ swatch [Registration] [રજિસ્ટ્રેશન]
|
||||
Standard Single-line Composer સ્ટાન્ડર્ડ સિંગલ-લાઇન કમ્પોઝર
|
||||
Standard Every-line Composer સ્ટાન્ડર્ડ એવરી-લાઇન કમ્પોઝર
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer આમાંથી એક હોવું જોઈએ: "singleLine", "everyLine", "standardSingleLine" અથવા "standardEveryLine"
|
||||
Paint રંગકામ
|
||||
Flat Sweep સપાટ લસરકો
|
||||
Dry Drag સૂકો ઘસારો
|
||||
Loaded Stroke ઘાટો પીંછીનો ઘસારો
|
||||
Fan Sweep પંખા જેવો લસરકો
|
||||
@msg `at` must be "start" or "end" `at` "start" અથવા "end" હોવું જોઈએ
|
||||
@msg give exactly one of `through` and `toward` `through` અને `toward` માંથી બરાબર એક આપો
|
||||
@msg no arc fits these points: two are the same or all three lie on one line આ પૉઇન્ટ્સમાં કોઈ આર્ક બેસતો નથી: બે એકસરખા છે અથવા ત્રણેય એક જ રેખા પર છે
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 72 and column 5.
|
@@ -10352,6 +10352,11 @@ theme Appearance अपीयरेंस
|
||||
@msg A panel is not joined to the rest by a crease. कोई पैनल किसी क्रीज़ लाइन से बाकी से जुड़ा नहीं है।
|
||||
@msg A fold line is on a non-printing layer. एक फ़ोल्ड लाइन नॉन-प्रिंटिंग लेयर पर है।
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} पैनल: {panels}, हिंज: {hinges}, एरर: {errors}, वॉर्निंग: {warnings}
|
||||
Paint चित्रकारी
|
||||
Flat Sweep सपाट फेरा
|
||||
Dry Drag सूखा घिसाव
|
||||
Loaded Stroke गाढ़ा ब्रश स्ट्रोक
|
||||
Fan Sweep पंखे जैसा फेरा
|
||||
Engraving नक्काशी
|
||||
Fine Hatching बारीक रेखांकन
|
||||
Dense Hatching घना रेखांकन
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10735,6 +10735,11 @@ breakText Glyphs Glifák
|
||||
@msg A panel is not joined to the rest by a crease. Egy panelt egyetlen bigvonal sem köt a többihez.
|
||||
@msg A fold line is on a non-printing layer. Egy hajtásvonal nem nyomtatható rétegen van.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Panelek: {panels}, zsanérok: {hinges}, hibák: {errors}, figyelmeztetések: {warnings}
|
||||
Paint Festék
|
||||
Flat Sweep Lapos húzás
|
||||
Dry Drag Száraz húzás
|
||||
Loaded Stroke Telített ecsetvonás
|
||||
Fan Sweep Legyezővonás
|
||||
Engraving Metszet
|
||||
Fine Hatching Finom vonalkázás
|
||||
Dense Hatching Sűrű vonalkázás
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -8584,6 +8584,11 @@ breakText Glyphs Glif
|
||||
@msg A joint does not close by {gap} pt. Sebuah sambungan tidak menutup sejauh {gap} pt.
|
||||
@msg Two panels pass through each other. Dua panel saling menembus.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer harus "singleLine", "everyLine", "standardSingleLine", atau "standardEveryLine"
|
||||
Paint Cat
|
||||
Flat Sweep Sapuan Datar
|
||||
Dry Drag Tarikan Kering
|
||||
Loaded Stroke Sapuan Tebal
|
||||
Fan Sweep Sapuan Kipas
|
||||
@msg `at` must be "start" or "end" `at` harus "start" atau "end"
|
||||
@msg give exactly one of `through` and `toward` berikan tepat satu dari `through` dan `toward`
|
||||
@msg no arc fits these points: two are the same or all three lie on one line tidak ada busur yang cocok dengan titik-titik ini: dua titik sama atau ketiganya segaris
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10421,6 +10421,11 @@ breakText Glyphs Glifi
|
||||
@msg A panel is not joined to the rest by a crease. Un pannello non è unito al resto da alcuna linea di cordonatura.
|
||||
@msg A fold line is on a non-printing layer. Una linea di piega si trova su un livello non stampabile.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Pannelli: {panels}, cerniere: {hinges}, errori: {errors}, avvisi: {warnings}
|
||||
Paint Pittura
|
||||
Flat Sweep Passata piatta
|
||||
Dry Drag Trascinamento secco
|
||||
Loaded Stroke Tratto carico
|
||||
Fan Sweep Passata a ventaglio
|
||||
Engraving Incisione
|
||||
Fine Hatching Tratteggio fine
|
||||
Dense Hatching Tratteggio fitto
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10484,6 +10484,11 @@ breakText Glyphs 字形
|
||||
@msg A panel is not joined to the rest by a crease. パネルがどの筋入れ線でも他とつながっていません。
|
||||
@msg A fold line is on a non-printing layer. 折り線が印刷しないレイヤーにあります。
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} パネル: {panels}、ヒンジ: {hinges}、エラー: {errors}、警告: {warnings}
|
||||
Paint ペイント
|
||||
Flat Sweep 平筆の一掃き
|
||||
Dry Drag ドライドラッグ
|
||||
Loaded Stroke 厚塗りストローク
|
||||
Fan Sweep 扇形の一掃き
|
||||
Engraving 彫刻
|
||||
Fine Hatching 細いハッチング
|
||||
Dense Hatching 密なハッチング
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -11032,6 +11032,11 @@ font-script Japanese იაპონური
|
||||
@msg A joint does not close by {gap} pt. შეერთება არ იხურება {gap} pt-ით.
|
||||
@msg Two panels pass through each other. ორი პანელი ერთმანეთში გადის.
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer უნდა იყოს "singleLine", "everyLine", "standardSingleLine" ან "standardEveryLine"
|
||||
Paint საღებავი
|
||||
Flat Sweep ბრტყელი მოსმა
|
||||
Dry Drag მშრალი მოსმა
|
||||
Loaded Stroke სქელი მონასმი
|
||||
Fan Sweep მარაოსებრი მოსმა
|
||||
Engraving გრავიურა
|
||||
Fine Hatching წვრილი შტრიხები
|
||||
Dense Hatching მჭიდრო შტრიხები
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10384,6 +10384,11 @@ breakText Glyphs 글리프
|
||||
@msg A panel is not joined to the rest by a crease. 패널이 어떤 오시선으로도 나머지와 연결되어 있지 않습니다.
|
||||
@msg A fold line is on a non-printing layer. 접는 선이 인쇄되지 않는 레이어에 있습니다.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} 패널: {panels}, 힌지: {hinges}, 오류: {errors}, 경고: {warnings}
|
||||
Paint 페인트
|
||||
Flat Sweep 평평한 붓질
|
||||
Dry Drag 마른 붓질
|
||||
Loaded Stroke 두터운 붓질
|
||||
Fan Sweep 부채꼴 붓질
|
||||
Engraving 판화
|
||||
Fine Hatching 가는 해칭
|
||||
Dense Hatching 촘촘한 해칭
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10785,6 +10785,11 @@ breakText Glyphs Glyphs
|
||||
@msg A panel is not joined to the rest by a crease. Een paneel is door geen rillijn met de rest verbonden.
|
||||
@msg A fold line is on a non-printing layer. Een vouwlijn staat op een laag die niet wordt afgedrukt.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Panelen: {panels}, scharnieren: {hinges}, fouten: {errors}, waarschuwingen: {warnings}
|
||||
Paint Verf
|
||||
Flat Sweep Vlakke streek
|
||||
Dry Drag Droge sleep
|
||||
Loaded Stroke Dikke verfstreek
|
||||
Fan Sweep Waaierstreek
|
||||
Engraving Gravure
|
||||
Fine Hatching Fijne arcering
|
||||
Dense Hatching Dichte arcering
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10609,6 +10609,11 @@ breakText Glyphs Glify
|
||||
@msg A panel is not joined to the rest by a crease. Panel nie jest połączony z resztą żadną linią bigowania.
|
||||
@msg A fold line is on a non-printing layer. Linia zgięcia znajduje się na warstwie niedrukowanej.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Panele: {panels}, zawiasy: {hinges}, błędy: {errors}, ostrzeżenia: {warnings}
|
||||
Paint Farba
|
||||
Flat Sweep Płaskie pociągnięcie
|
||||
Dry Drag Suche przeciągnięcie
|
||||
Loaded Stroke Grube pociągnięcie
|
||||
Fan Sweep Wachlarzowy ślad
|
||||
Engraving Grawerowanie
|
||||
Fine Hatching Drobne kreskowanie
|
||||
Dense Hatching Gęste kreskowanie
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10818,6 +10818,11 @@ swatch Yellow Green Verde-amarelado
|
||||
@msg A panel is not joined to the rest by a crease. Um painel não está unido ao restante por nenhuma linha de vinco.
|
||||
@msg A fold line is on a non-printing layer. Uma linha de dobra está em uma camada não imprimível.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Painéis: {panels}, dobradiças: {hinges}, erros: {errors}, avisos: {warnings}
|
||||
Paint Pintura
|
||||
Flat Sweep Pincelada plana
|
||||
Dry Drag Arrasto seco
|
||||
Loaded Stroke Traço carregado
|
||||
Fan Sweep Pincelada em leque
|
||||
Engraving Gravura
|
||||
Fine Hatching Hachuras finas
|
||||
Dense Hatching Hachuras densas
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10802,6 +10802,11 @@ shape Open Открытый
|
||||
@msg Two panels pass through each other. Две панели проходят друг сквозь друга.
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} пикселей — слишком большой размер для PSD (не более {MAX_SIDE} пикселей по стороне): уменьшите разрешение
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer должен быть "singleLine", "everyLine", "standardSingleLine" или "standardEveryLine"
|
||||
Paint Краска
|
||||
Flat Sweep Плоский мазок
|
||||
Dry Drag Сухой протяг
|
||||
Loaded Stroke Густой мазок
|
||||
Fan Sweep Веерный мазок
|
||||
Engraving Гравировка
|
||||
Fine Hatching Тонкая штриховка
|
||||
Dense Hatching Плотная штриховка
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10839,6 +10839,11 @@ digits Hindi Hindi
|
||||
@msg A joint does not close by {gap} pt. En fog sluter inte med {gap} pt.
|
||||
@msg Two panels pass through each other. Två paneler går igenom varandra.
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} pixlar är för stort för PSD (högst {MAX_SIDE} pixlar per sida): sänk upplösningen
|
||||
Paint Färg
|
||||
Flat Sweep Platt penseldrag
|
||||
Dry Drag Torrt drag
|
||||
Loaded Stroke Fylligt penseldrag
|
||||
Fan Sweep Solfjädersdrag
|
||||
Engraving Gravyr
|
||||
Fine Hatching Fin skraffering
|
||||
Dense Hatching Tät skraffering
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10704,6 +10704,11 @@ breakText Glyphs Glifler
|
||||
@msg A panel is not joined to the rest by a crease. Bir panel geri kalanlara hiçbir pilyaj çizgisiyle bağlı değil.
|
||||
@msg A fold line is on a non-printing layer. Bir katlama çizgisi yazdırılmayan bir katmanda.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Paneller: {panels}, menteşeler: {hinges}, hatalar: {errors}, uyarılar: {warnings}
|
||||
Paint Boya
|
||||
Flat Sweep Düz fırça izi
|
||||
Dry Drag Kuru sürükleme
|
||||
Loaded Stroke Yoğun fırça izi
|
||||
Fan Sweep Yelpaze izi
|
||||
Engraving Gravür
|
||||
Fine Hatching İnce tarama
|
||||
Dense Hatching Yoğun tarama
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10397,6 +10397,11 @@ breakText Glyphs Гліфи
|
||||
@msg A panel is not joined to the rest by a crease. Панель не з’єднана з рештою жодною лінією біговки.
|
||||
@msg A fold line is on a non-printing layer. Лінія згину лежить на шарі, що не друкується.
|
||||
@msg Panels: {panels}, hinges: {hinges}, errors: {errors}, warnings: {warnings} Панелі: {panels}, шарніри: {hinges}, помилки: {errors}, попередження: {warnings}
|
||||
Paint Фарба
|
||||
Flat Sweep Плоский мазок
|
||||
Dry Drag Сухий протяг
|
||||
Loaded Stroke Густий мазок
|
||||
Fan Sweep Віяловий мазок
|
||||
Engraving Гравіювання
|
||||
Fine Hatching Тонке штрихування
|
||||
Dense Hatching Щільне штрихування
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -8594,6 +8594,11 @@ breakText Glyphs Glyph
|
||||
@msg {width} × {height} pixels is too large for Targa (at most 65535 pixels a side): lower the resolution {width} × {height} điểm ảnh quá lớn cho Targa (tối đa 65535 điểm ảnh mỗi cạnh): hãy giảm độ phân giải
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} điểm ảnh quá lớn cho PSD (tối đa {MAX_SIDE} điểm ảnh mỗi cạnh): hãy giảm độ phân giải
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer phải là "singleLine", "everyLine", "standardSingleLine" hoặc "standardEveryLine"
|
||||
Paint Sơn
|
||||
Flat Sweep Nét quét phẳng
|
||||
Dry Drag Nét kéo khô
|
||||
Loaded Stroke Nét cọ đậm
|
||||
Fan Sweep Nét quét hình quạt
|
||||
Engraving Khắc nét
|
||||
Fine Hatching Nét gạch mảnh
|
||||
Dense Hatching Nét gạch dày
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10589,6 +10589,11 @@ breakText Glyphs 字形
|
||||
@msg A joint does not close by {gap} pt. 有一处接缝相差 {gap} pt 未闭合。
|
||||
@msg Two panels pass through each other. 两个面板相互穿插。
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} 像素对 PSD 而言过大 (每边最多 {MAX_SIDE} 像素):请降低分辨率
|
||||
Paint 绘画
|
||||
Flat Sweep 平刷
|
||||
Dry Drag 干拖
|
||||
Loaded Stroke 厚涂笔触
|
||||
Fan Sweep 扇形笔触
|
||||
Engraving 雕刻
|
||||
Fine Hatching 细线排线
|
||||
Dense Hatching 密集排线
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -10404,6 +10404,11 @@ breakText Glyphs 字符
|
||||
@msg A joint does not close by {gap} pt. 有一處接縫相差 {gap} pt 未閉合。
|
||||
@msg Two panels pass through each other. 兩個面板相互穿插。
|
||||
@msg {what} would print on more than {MAX_TILES} tiles: scale it down {what} 會列印在超過 {MAX_TILES} 個拼貼上:請縮小
|
||||
Paint 繪畫
|
||||
Flat Sweep 平刷
|
||||
Dry Drag 乾拖
|
||||
Loaded Stroke 厚塗筆觸
|
||||
Fan Sweep 扇形筆觸
|
||||
Engraving 雕刻
|
||||
Fine Hatching 細線排線
|
||||
Dense Hatching 密集排線
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -197,6 +197,7 @@ fn the_window_menu_and_the_brushes_panel_open_brush_libraries() {
|
||||
json!("calligraphic-nibs"),
|
||||
json!("pressure-sensitive"),
|
||||
json!("bristle-brushes"),
|
||||
json!("paint"),
|
||||
json!("pattern-borders"),
|
||||
json!("scatter-shapes"),
|
||||
json!("stipple"),
|
||||
@@ -248,10 +249,21 @@ fn the_window_menu_and_the_brushes_panel_open_brush_libraries() {
|
||||
app.session.doc().unwrap().doc.node(vectorcraft_doc::NodeId(path)).unwrap().appearance.stroke().unwrap().brush.as_deref(),
|
||||
Some("Flex Ribbon")
|
||||
);
|
||||
let r = app.run("window.brushLibrary", json!({"library": "Paint"})).unwrap();
|
||||
assert_eq!((r["open"].as_str(), r["count"].as_u64()), (Some("paint"), Some(4)));
|
||||
let path = app.run("shape.line", json!({"x1": 10, "y1": 140, "x2": 180, "y2": 140})).unwrap()["id"].as_u64().unwrap();
|
||||
let undo = undo_len(&app);
|
||||
click(&mut app, &ctx, "Flat Sweep", Modifiers::NONE, 4.0);
|
||||
assert!(has(&app, "Flat Sweep") && !has(&app, "Dry Drag"));
|
||||
assert_eq!(undo_len(&app), undo + 1);
|
||||
assert_eq!(
|
||||
app.session.doc().unwrap().doc.node(vectorcraft_doc::NodeId(path)).unwrap().appearance.stroke().unwrap().brush.as_deref(),
|
||||
Some("Flat Sweep")
|
||||
);
|
||||
let r = app.run("window.brushLibrary", json!({"library": "Image Brush"})).unwrap();
|
||||
assert_eq!((r["open"].as_str(), r["count"].as_u64()), (Some("image-brush"), Some(4)));
|
||||
let undo = undo_len(&app);
|
||||
click(&mut app, &ctx, "Soft Bloom", Modifiers::NONE, 4.0);
|
||||
click(&mut app, &ctx, "Soft Bloom", Modifiers::NONE, 5.0);
|
||||
assert!(has(&app, "Soft Bloom") && !has(&app, "Color Flecks"));
|
||||
assert_eq!(undo_len(&app), undo + 1);
|
||||
// Without brushes there is nothing to save.
|
||||
|
||||
+5
-1
@@ -10052,7 +10052,11 @@ images and point type in the font the file names. Type keeps the file's characte
|
||||
kerning off. On a single left to right line, an advance that tracking can't give (wider than its range, or a tab)
|
||||
starts a new point type object at the position the advance gives, and an underline or strikethrough is filled across the space between and on to the end
|
||||
of the last character's advance. Type on more than one line is placed a line at a time: each line is aligned by its own advances and
|
||||
split as a single line is. An EMF that
|
||||
split as a single line is. A character cell runs from the font's OS/2
|
||||
`usWinAscent` above the baseline to its `usWinDescent` below it: top and bottom aligned text has the top or the
|
||||
bottom of its cells at the reference point. Text drawn in the opaque background mode, which a file is in until it
|
||||
sets the mode to transparent, gets one filled rectangle of the background color behind the character cells of each
|
||||
line, as far as its advances reach (NULs' included), placed before the type. An EMF that
|
||||
draws with EMF+ records is read from them. Hatched and pattern brushes fill with their average color. Records VectorCraft doesn't read are skipped with one warning.
|
||||
A file, or a metafile image inside it, cut short by one of the reader's limits adds one warning without a count.
|
||||
Each of these adds one warning, with a count: images and pattern brushes whose bitmap can't be read, which are left
|
||||
|
||||
@@ -1239,6 +1239,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
- **Engraving library** ([About brushes](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/apply-and-edit-strokes/about-brushes.html)): Fine Hatching, Dense Hatching, Tapered Hatching and Broken Hatching make fine parallel-line textures along paths. These four 100 pt art brushes are original VectorCraft geometry, with Tints colorization; they can be added, applied and saved through the existing library controls.
|
||||
- **Image Brush library** ([About brushes](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/apply-and-edit-strokes/about-brushes.html)): Window › Brush Libraries › Image Brush offers Soft Bloom, Halftone Field, Solar Grain and Color Flecks as original image stamp designs. Each preset places copies of its embedded, transparent PNG along a path as a scatter brush; adding a brush carries its image resource into the document, and saving a library keeps the pixels. The public page names the category but not these presets. Evidence: `image_brush_stamps_draw_and_carry_their_pixels_when_added_and_saved` in `crates/engine/src/tests/brushlib.rs` covers stamps, add/apply and reopening; `the_window_menu_and_the_brushes_panel_open_brush_libraries` covers the UI.
|
||||
- **Pressure Sensitive library** ([About brushes](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/apply-and-edit-strokes/about-brushes.html)): Window › Brush Libraries › Pressure Sensitive offers Flex Ribbon, Pulse Stroke, Round Flow and Chisel Flow. The first two are art brushes whose width follows recorded pen pressure; the other two are calligraphic nibs whose size follows it. They use the engine's existing pressure input where the device and platform deliver it, and a neutral width for a mouse path. These presets and names are VectorCraft's own. Evidence: `pressure_sensitive_brushes_widen_with_pen_pressure_and_survive_a_saved_library` in `crates/engine/src/tests/brushlib.rs` checks light and heavy pressure, short and curved paths, add/apply and saved-library reopening; `the_window_menu_and_the_brushes_panel_open_brush_libraries` covers opening and clicking from the UI.
|
||||
- **Paint library** ([About brushes](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/apply-and-edit-strokes/about-brushes.html)): Window › Brush Libraries › Paint offers Flat Sweep, Dry Drag, Loaded Stroke and Fan Sweep. These original art brushes stretch broad, broken, loaded and fanned vector marks along a path and take the stroke color as tints. The public source describes the Paint category's varied thickness, textured edges and natural effects; the preset designs and names are VectorCraft's own. Evidence: `paint_brushes_draw_distinct_marks_and_survive_a_saved_library` in `crates/engine/src/tests/brushlib.rs` covers finite output on short, long and curved paths, add/apply and saved-library reopening; `the_window_menu_and_the_brushes_panel_open_brush_libraries` covers opening and clicking from the UI.
|
||||
- **Dry Media library** ([help page](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/apply-and-edit-strokes/about-brushes.html)): Window › Brush Libraries › Dry Media holds four art brushes with textured strokes like dry drawing materials, each 100 pt long: Chalk Grain (about 8 pt high), Graphite Pencil (about 2.3 pt), Wax Crayon (about 5.5 pt) and Charcoal Dust (about 7 pt). The brushes, their names, sizes and art are VectorCraft's own: each is filled vector paths from a fixed seed, at most 80 paths and 500 anchors, stretched along the path with Tints colorization, and the chalk and crayon art has even-odd gaps where the paper shows (`brush.libraries`, `brush.addFromLibrary`; `the_dry_media_library_holds_grainy_art_brushes_with_bounded_art`).
|
||||
- **Arrows library:** Window › Brush Libraries › Arrows holds five art brushes, each 100 pt long: Solid Arrow, Open Arrow (an outlined head), Double Arrow (a head at each end), Chevron Arrow (a second chevron on the shaft) and Dashed Arrow (five separate dashes and a head). Each brush stretches only the part between its guides, so the shaft follows the path's length and the heads keep their proportions, with Tints colorization. The brushes, their names and their art are VectorCraft's own, generated in code (`brush.libraries`, `brush.addFromLibrary`; `arrows_library_lists_renders_and_applies_original_brushes`, `dashed_arrow_keeps_separate_dashes_and_survives_library_save`).
|
||||
- **Brush names in library panels**: a built-in brush library's panel shows its brushes' names in the UI language, in its list rows and tooltips, and its Find field matches the name shown or the English name. This is VectorCraft's own rule. A User Defined or Other Library… library's brushes, and the document's Brushes panel, show names as they are stored. A click, a drag, Add to Brushes and `brush.addFromLibrary` still use the English name, so the brush comes into the document under that name (`built_in_library_brushes_are_listed_in_the_ui_language`, `built_in_library_brush_names_are_in_complete_catalogs`).
|
||||
@@ -2292,6 +2293,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
- EMF and WMF type takes its size from the font's height, where a negative height is the em and a positive height is the character cell, and a font's average character width becomes Horizontal Scale against the face's own average width (OS/2 `xAvgCharWidth`) when the face gives one, as [LOGFONT](https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-logfontw) and [MS-EMF 2.2.13](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-emf/1cd7cb7a-1a7c-48d2-b4a4-c218f9d12100) describe the two fields. VectorCraft's own rules are that the cell is the face's `usWinAscent` plus `usWinDescent` at a variable font's instance (its ascent plus descent without an OS/2 table), that a negative width is read as its absolute value, and that the width is ignored when the height is 0 (`a_font_width_becomes_horizontal_scale`, `a_positive_font_height_is_the_character_cell`, `a_font_the_system_lacks_is_measured_in_the_face_that_draws_it`, `wmf_font_width_becomes_horizontal_scale`).
|
||||
- EMF and WMF files are read by the shared `craft-metafile` reader and open, place and paste as editable paths, clipping groups, images and point type: an EMF drawn with EMF+ records (on their own, or beside plain records) is read from them instead of opening empty, and hatched and pattern brushes fill with their average color (`crates/metafile/src/tests/import.rs`).
|
||||
- EMF, WMF and EMF+ text keeps the character advances the file gives (ExtTextOut's `lpDx`, DrawDriverString positions) as tracking, with pair kerning off; on a single left to right line, an advance that tracking can't give (wider than its range, or a tab) starts a new point type object where the advance puts it, with an underline or strikethrough filled across the space between and on to the end of the last character's advance; type on more than one line is placed a line at a time, each line aligned by its own advances and split as a single line is (`text_is_spaced_by_its_advances`, `multiline_text_with_advances_aligns_each_line`, `wmf_text_is_spaced_by_its_advances`, `emf_plus_driver_strings_keep_their_positions`, `split_type_keeps_its_underline_and_right_to_left_order`).
|
||||
- EMF and WMF text drawn in the opaque background mode, which a playback starts in ([MS-EMF 2.1.4 BackgroundMode](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-emf/2f57054c-2b69-4303-a6f8-5aacd401f759), [SetBkMode](https://learn.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-setbkmode)), gets one rectangle of the background color behind each line's character cells, placed before the type; transparent text gets none. A character cell runs from the font's OS/2 `usWinAscent` above the baseline to its `usWinDescent` below it, and top or bottom aligned text puts the top or the bottom of the cell at the reference point (`opaque_backgrounds_fill_behind_the_character_cells`, `opaque_backgrounds_reach_as_far_as_the_advances`, `wmf_text_fills_its_cells_in_the_opaque_background_mode`).
|
||||
- EMF and WMF import warns about what the reader leaves out or does not play as the file asks: a file, or a metafile image inside it, cut short by one of the reader's limits (items, bytes kept, saved states, clip paths), with one warning without a count, and, with counts, images and pattern brushes that are not read, clips that are not applied, and raster operations other than a plain copy (`a_file_cut_short_by_another_limit_says_so`, `images_the_reader_does_not_read_are_counted`, `clips_that_are_not_applied_are_counted`, `raster_operations_that_are_not_played_are_counted`, `a_wmf_reports_unread_pattern_brushes_and_raster_operations`).
|
||||
- Export As › HP-GL (`document.export {format: "hpgl"}`) writes a `.plt` plot of an artboard, each artboard or the art for pen plotters and cutters: each visible path once along its line in plotter units from the artboard's bottom-left corner or center, a pen per color or a pen table, curves flattened to a tolerance, type as outlines, clipping masks and the artboard's edges applied, and HP-GL or HP-GL/2 (pen colors and encoded polylines); plots read back by the HP-GL reader give the same lines (`crates/cad/src/hpgl/write/tests.rs`, `crates/engine/src/cmd/fileio/tests_hpgl.rs`).
|
||||
- HP-GL export's `insideFirst` cuts each pen's paths inside before outside: a path is drawn only after the pen's paths that lie inside it (a letter's counter, a part's holes, rings within rings), touching outlines counted as inside and crossing ones not, in paint order or nearest first with `sortPaths`, within the plot's work budget; these order rules are VectorCraft's own (`crates/cad/src/hpgl/write/nest.rs`, `crates/cad/src/hpgl/write/tests.rs`, `crates/engine/src/cmd/fileio/tests_hpgl.rs`).
|
||||
|
||||
@@ -5,7 +5,7 @@ use std::process::Command;
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
const REV: &str = "64b181977a0488e4d1e167bc5cc8cfededc2ed4b";
|
||||
const REV: &str = "50b0ee7bf811e363b5f238382b5c77318cf33e46";
|
||||
const PACKAGES: &[(&str, &str, &str)] = &[
|
||||
("craft-pdf", "0.1.0", REV),
|
||||
("krilla", "0.8.2", REV),
|
||||
|
||||
Reference in new issue
Block a user