Merge main into fix/graph-axis-paint-kept

This commit is contained in:
dotCooCoo
2026-11-14 21:49:46 -08:00
221 changed files with 9124 additions and 704 deletions
+1
View File
@@ -120,6 +120,7 @@ pub use style_libs::StyleLibrary;
pub use text::FontHeightReference;
pub use text::GlyphChoice;
pub use text::GlyphForm;
pub use text::PATH_LEAD_MAX;
pub use text::WarichuAlign;
pub use text::{
AreaFit, AreaOptions, Burasagari, CharAlign, CharPosition, CharStyle, Composer, Digits, FirstBaseline, HyphenationOptions, InlineArt,
+28
View File
@@ -358,6 +358,34 @@ mod tests {
assert!((p.x - 25.0).abs() < 1e-6 && (p.y - 25.0).abs() < 1e-6, "{p:?}");
}
#[test]
fn coons_places_are_where_the_patch_bends() {
// A rectangle's sides have 65 evenly spaced points.
let [u, v] = Coons::rect(Rect::new(0.0, 0.0, 100.0, 50.0)).places();
assert_eq!((u.len(), v.len()), (65, 65));
assert!(u.iter().enumerate().all(|(i, x)| (x - i as f64 / 64.0).abs() < 1e-12), "{u:?}");
// A top object with a curved top: between two places next to each other the patch is
// straight, in `u` and in `v`.
let mut path = kurbo::BezPath::new();
path.move_to((0.0, 0.0));
path.curve_to((30.0, -20.0), (70.0, 10.0), (100.0, 0.0));
path.line_to((100.0, 50.0));
path.line_to((40.0, 50.0));
path.line_to((0.0, 50.0));
path.close_path();
let c = Coons::from_top_object(&PathData::from_bezpath(&path), Some([0, 1, 2, 4])).unwrap();
let [u, v] = c.places();
assert!(u.first() == Some(&0.0) && u.last() == Some(&1.0) && u.windows(2).all(|w| w[0] < w[1]), "{u:?}");
assert!(v.first() == Some(&0.0) && v.last() == Some(&1.0) && v.windows(2).all(|w| w[0] < w[1]), "{v:?}");
for w in u.windows(2) {
for y in [0.0, 0.3, 1.0] {
let mid = c.eval((w[0] + w[1]) / 2.0, y);
let half = c.eval(w[0], y).midpoint(c.eval(w[1], y));
assert!(mid.distance(half) < 1e-9, "{w:?} {y}: {mid:?} {half:?}");
}
}
}
#[test]
fn maps_go_on_past_the_content_box() {
// A stroke outline reaches past the box: a flat mesh and a rectangle stay the identity there.
+25
View File
@@ -338,6 +338,31 @@ impl Coons {
let end = |side: &[Point]| side.last().copied().unwrap_or_default();
[self.top[0], end(&self.top), end(&self.bottom), self.bottom[0]]
}
/// The places in `u` where the top or bottom side has a point, and the places in `v` where the
/// left or right side has one, rising from 0 to 1. Between two places next to each other, each
/// side runs straight, so [`Self::eval`] changes linearly in `u` and in `v` inside each cell of
/// the grid they make.
pub fn places(&self) -> [Vec<f64>; 2] {
let sides = [&self.top, &self.right, &self.bottom, &self.left];
let at = |which: usize| -> Vec<f64> {
match self.knots.as_deref().and_then(|k| k.get(which)) {
Some(knots) => knots.clone(),
None => {
let last = sides[which].len().saturating_sub(1).max(1);
(0..=last).map(|i| i as f64 / last as f64).collect()
}
}
};
let merge = |a: usize, b: usize| {
let mut v = at(a);
v.extend(at(b));
v.sort_by(f64::total_cmp);
v.dedup();
v
};
[merge(0, 2), merge(1, 3)]
}
}
/// The most points one side of [`Coons::from_top_object`] holds while it adds points between its
+5
View File
@@ -173,6 +173,10 @@ pub struct PatternDef {
/// Size Tile to Art: the tile is the art bounds grown by the spacing.
#[serde(default)]
pub size_tile_to_art: bool,
/// Move Tile with Art: in pattern editing mode, a move of all of the tile art moves the tile by
/// the same offset.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub move_tile_with_art: bool,
#[serde(default)]
pub h_spacing: f64,
#[serde(default)]
@@ -202,6 +206,7 @@ impl PatternDef {
art,
overlap: Overlap::default(),
size_tile_to_art: false,
move_tile_with_art: false,
h_spacing: 0.0,
v_spacing: 0.0,
copies: 5,
+1
View File
@@ -29,6 +29,7 @@ pub use para_style::{
Burasagari, Composer, FirstBaseline, HyphenationOptions, JustificationOptions, Justify, Kashida, Kinsoku, KinsokuShoriType, LeadingModel,
Mojikumi, ParaDirection, ParaStyle, SingleWordJustify,
};
pub use runs::PATH_LEAD_MAX;
pub use runs::{INLINE_CHAR, INLINE_MAX_SCALE, InlineArt, RubyAlign, RubyPosition, RubySpan, TextKind, TextRun, TextStyleDef, TypeAntiAlias};
pub use tabs_lists::{
Bullet, DEFAULT_TAB_INTERVAL, LIST_HANGING_INDENT, LIST_LEVEL_INDENT, LIST_LEVELS, ListAlign, ListCounts, NumberStyle, ParaList, TabAlign,
+18
View File
@@ -298,6 +298,15 @@ impl GlyphForm {
GlyphForm::QuarterWidth => b"qwid",
})
}
/// Is this one of the monospaced width forms (`fwid`, `hwid`, `twid`, `qwid`)? A font may
/// draw them with other glyphs (`GSUB`) or with other widths for the same glyphs (`GPOS`), and
/// they set the characters on a fixed width, so Proportional Metrics (`palt`) is not applied
/// with them.
/// <https://learn.microsoft.com/en-us/typography/opentype/spec/features_fj#tag-fwid>
pub fn is_width(self) -> bool {
matches!(self, GlyphForm::FullWidth | GlyphForm::HalfWidth | GlyphForm::ThirdWidth | GlyphForm::QuarterWidth)
}
}
/// A glyph chosen for one character ([`CharStyle::glyph_alternate`]): the glyph id and the face it
@@ -785,6 +794,15 @@ impl CharStyle {
self.position = self.position.in_range();
self.small_caps = self.small_caps.map(small_caps_in_range);
}
/// Sets the East Asian glyph form ([`CharStyle::glyph_form`]). A form other than the default
/// also takes away the character's glyph choice ([`CharStyle::glyph_alternate`]), which would
/// otherwise keep drawing its own glyph; the default form keeps it.
pub fn set_glyph_form(&mut self, form: GlyphForm) {
self.glyph_form = form;
if form != GlyphForm::Default {
self.glyph_alternate = None;
}
}
}
impl crate::Document {
+4 -1
View File
@@ -352,7 +352,10 @@ impl TextObject {
}
/// Flip type on a path to the other side of its path (Type on a Path Options › Flip, or its
/// centre bracket dragged across the path): the path runs the other way and the brackets swap
/// ends, so the type keeps its stretch of the path. False, changing nothing, for other type.
/// ends, so the type keeps its stretch of the path. Type that starts before an open path's start
/// ([`TextKind::path_text_start`]) starts at its start bracket after the flip: the part of its
/// span before the path's start would come after the path's end. False, changing nothing, for
/// other type.
pub fn flip_on_path(&mut self) -> bool {
let Some((s, e)) = self.kind.path_span() else { return false };
let TextKind::OnPath { path, start, end } = &mut self.kind else { return false };
+18 -2
View File
@@ -93,8 +93,10 @@ pub enum TextKind {
/// Area type flowed inside `frame` (document coordinates, untransformed by `xf`).
Area { frame: PathData },
/// Type on a path, flowing from its start bracket `start` to its end bracket `end` (0..1 of the
/// path length; no `end`: the end of the path, or once round a closed path). See
/// [`TextKind::path_span`].
/// path length; no `end`: the end of the path, or once round a closed path). On an open path
/// `start` may be below 0: the type starts that far before the path's start, and the characters
/// whose middle falls before the path's start are not drawn ([`TextKind::path_text_start`]).
/// See [`TextKind::path_span`].
OnPath {
path: PathData,
start: f64,
@@ -117,8 +119,22 @@ impl TextKind {
(s, end.map_or(1.0, |e| fraction(e).max(s)))
})
}
/// Where type on a path's text starts, as a fraction of its path's length: its start bracket
/// ([`Self::path_span`]), or on an open path a start before the path's start (below 0, at most
/// [`PATH_LEAD_MAX`] path lengths before it). None for other type.
pub fn path_text_start(&self) -> Option<f64> {
let TextKind::OnPath { path, start, .. } = self else { return None };
if !path.is_closed() && start.is_finite() && *start < 0.0 { Some(start.max(-PATH_LEAD_MAX)) } else { self.path_span().map(|(s, _)| s) }
}
/// Does type on an open path start before its path's start ([`Self::path_text_start`])?
pub fn starts_before_path(&self) -> bool {
self.path_text_start().is_some_and(|s| s < 0.0)
}
}
/// How far before its path's start type on an open path may start, in lengths of the path.
pub const PATH_LEAD_MAX: f64 = 1e6;
/// Move anchors `refs` of `path`, in text space, by `d` in document space (`to_text`: the
/// document → text map). False when an anchor doesn't exist.
pub(super) fn move_anchors(path: &mut PathData, to_text: Affine, refs: &[(usize, usize)], d: Vec2) -> bool {
+27
View File
@@ -563,6 +563,33 @@ fn area_anchors_move_in_document_space() {
assert_eq!(t, before);
}
/// Type on an open path may start before the path's start: the start is kept, saved and read back,
/// while the start bracket stays at the path's start. On a closed path, and for a start that is not
/// finite, the start is the start bracket as before.
#[test]
fn type_on_an_open_path_starts_before_the_path() {
let pts = [Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 100.0)];
let on = |closed: bool, start: f64| TextKind::OnPath {
path: PathData::new(vec![vectorcraft_geom::SubPath::polyline(&pts, closed)]),
start,
end: None,
};
let open = on(false, -0.25);
assert_eq!(open.path_text_start(), Some(-0.25));
assert!(open.starts_before_path());
assert_eq!(open.path_span(), Some((0.0, 1.0)));
let saved = serde_json::to_value(&open).unwrap();
assert_eq!(saved["start"], -0.25);
assert_eq!(serde_json::from_value::<TextKind>(saved).unwrap(), open);
assert_eq!(on(false, -1e9).path_text_start(), Some(-PATH_LEAD_MAX));
assert_eq!(on(false, f64::NEG_INFINITY).path_text_start(), Some(0.0));
assert_eq!(on(false, 0.25).path_text_start(), Some(0.25));
assert!(!on(false, 0.0).starts_before_path());
assert_eq!(on(true, -0.25).path_text_start(), Some(0.0));
assert!(!on(true, -0.25).starts_before_path());
assert_eq!(TextKind::Point.path_text_start(), None);
}
/// Builds from before [`Justify::Auto`] read new type's alignment as Left or Right (and ignore
/// `justify_auto`); this build reads Auto back.
#[test]