refactor(geom): split preset.rs into preset/{catalog,builder,build,shapes}.rs

This commit is contained in:
aiongg committed 2026-10-26 22:08:44 +00:00
1 parent 838d51ed59
commit 6b57773373
5 files changed
+2242 -2215

No files matched your search

+9 -2215
View File
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+344
View File
@@ -0,0 +1,344 @@
use super::catalog::{FillMode, Geometry, Handle, SubPath};
use super::*;
// ---------- path builder ----------
pub(super) struct Pb {
pub(super) p: BezPath,
pub(super) cur: Point,
}
impl Pb {
pub(super) fn new() -> Self {
Pb { p: BezPath::new(), cur: Point::ZERO }
}
pub(super) fn m(&mut self, x: f64, y: f64) -> &mut Self {
self.cur = Point::new(x, y);
self.p.move_to(self.cur);
self
}
pub(super) fn l(&mut self, x: f64, y: f64) -> &mut Self {
self.cur = Point::new(x, y);
self.p.line_to(self.cur);
self
}
pub(super) fn c(&mut self, x1: f64, y1: f64, x2: f64, y2: f64, x: f64, y: f64) -> &mut Self {
self.cur = Point::new(x, y);
self.p.curve_to(Point::new(x1, y1), Point::new(x2, y2), self.cur);
self
}
pub(super) fn q(&mut self, x1: f64, y1: f64, x: f64, y: f64) -> &mut Self {
self.cur = Point::new(x, y);
self.p.quad_to(Point::new(x1, y1), self.cur);
self
}
/// Elliptic arc continuing from the current point, which lies on the ellipse at parametric
/// angle `st` (degrees); sweeps `sw` degrees (positive = clockwise on screen).
pub(super) fn arc(&mut self, wr: f64, hr: f64, st: f64, sw: f64) -> &mut Self {
let (s, e) = (st.to_radians(), (st + sw).to_radians());
let c = Point::new(self.cur.x - wr * s.cos(), self.cur.y - hr * s.sin());
let a = Arc::new(c, Vec2::new(wr.abs(), hr.abs()), s, e - s, 0.0);
a.to_cubic_beziers(0.05, |p1, p2, p| {
self.p.curve_to(p1, p2, p);
});
self.cur = Point::new(c.x + wr * e.cos(), c.y + hr * e.sin());
self
}
/// A DrawingML `arcTo`: angles are where the ray from the ellipse's centre at that angle
/// meets it (not the ellipse's parameter), so elliptical arcs start and end where the
/// standard's shapes expect.
pub(super) fn arc_spec(&mut self, wr: f64, hr: f64, st: f64, sw: f64) -> &mut Self {
let par = |a: f64| {
let a = a.to_radians();
(wr * a.sin()).atan2(hr * a.cos())
};
let t0 = par(st);
let mut d = par(st + sw) - t0;
let tau = std::f64::consts::TAU;
if sw.abs() >= 360.0 {
d = tau.copysign(sw);
} else {
while sw > 0.0 && d < 0.0 {
d += tau;
}
while sw < 0.0 && d > 0.0 {
d -= tau;
}
}
self.arc(wr, hr, t0.to_degrees(), d.to_degrees())
}
pub(super) fn z(&mut self) -> &mut Self {
self.p.close_path();
self
}
pub(super) fn poly(&mut self, pts: &[(f64, f64)]) -> &mut Self {
for (i, (x, y)) in pts.iter().enumerate() {
if i == 0 {
self.m(*x, *y);
} else {
self.l(*x, *y);
}
}
self.z()
}
pub(super) fn ellipse(&mut self, cx: f64, cy: f64, rx: f64, ry: f64) -> &mut Self {
self.m(cx + rx, cy);
self.arc(rx, ry, 0.0, 360.0);
self.z()
}
pub(super) fn take(&mut self) -> BezPath {
std::mem::take(&mut self.p)
}
}
pub(super) fn fill(p: BezPath) -> SubPath {
SubPath { path: p, fill: FillMode::Norm, stroke: true, even_odd: false }
}
pub(super) fn fill_eo(p: BezPath) -> SubPath {
SubPath { path: p, fill: FillMode::Norm, stroke: true, even_odd: true }
}
pub(super) fn shade(p: BezPath, m: FillMode) -> SubPath {
SubPath { path: p, fill: m, stroke: true, even_odd: false }
}
pub(super) fn stroke_only(p: BezPath) -> SubPath {
SubPath { path: p, fill: FillMode::None, stroke: true, even_odd: false }
}
pub(super) fn fill_only(p: BezPath) -> SubPath {
SubPath { path: p, fill: FillMode::Norm, stroke: false, even_odd: false }
}
/// Parametric angle on an rx×ry ellipse for a visual angle `deg` (file angles are visual).
pub(super) fn vis(deg: f64, rx: f64, ry: f64) -> f64 {
let t = deg.to_radians();
(rx * t.sin()).atan2(ry * t.cos()).to_degrees()
}
pub(super) fn polygon_regular(n: usize, w: f64, h: f64, phase: f64) -> Vec<(f64, f64)> {
let pts: Vec<(f64, f64)> = (0..n)
.map(|i| {
let a = (phase + 360.0 * i as f64 / n as f64).to_radians();
(a.cos(), a.sin())
})
.collect();
normalize(&pts, w, h)
}
/// Scale `pts` so their bounding box fills 0..w × 0..h.
fn normalize(pts: &[(f64, f64)], w: f64, h: f64) -> Vec<(f64, f64)> {
let (mut x0, mut y0, mut x1, mut y1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
for (x, y) in pts {
x0 = x0.min(*x);
y0 = y0.min(*y);
x1 = x1.max(*x);
y1 = y1.max(*y);
}
let sx = if x1 - x0 > 1e-12 { w / (x1 - x0) } else { 0.0 };
let sy = if y1 - y0 > 1e-12 { h / (y1 - y0) } else { 0.0 };
pts.iter().map(|(x, y)| ((x - x0) * sx, (y - y0) * sy)).collect()
}
/// An n-pointed star as ECMA-376 draws it: points on an ellipse around (hc, vc · vf) with radii
/// half the box stretched by the preset's `hf` / `vf` (so a five-pointed star fills its box and
/// looks regular in a square), the inner corners `inner` of the way out.
pub(super) fn star(n: usize, w: f64, h: f64, inner: f64) -> Vec<(f64, f64)> {
let (hf, vf) = match n {
5 => (1.05146, 1.10557),
6 => (1.15470, 1.0),
7 => (1.02572, 1.05210),
10 => (1.05146, 1.0),
_ => (1.0, 1.0),
};
let (rx, ry, cy) = (w / 2.0 * hf, h / 2.0 * vf, h / 2.0 * vf);
let mut pts = Vec::with_capacity(n * 2);
for i in 0..n * 2 {
let a = (-90.0 + 180.0 * i as f64 / n as f64).to_radians();
let r = if i % 2 == 0 { 1.0 } else { inner };
pts.push((w / 2.0 + r * rx * a.cos(), cy + r * ry * a.sin()));
}
pts
}
/// The text rectangle ECMA-376's presetShapeDefinitions give a star (`inner` is the adjust value
/// over 50000), where known: star4's is the square inside its inner points, star5's spans the
/// inner pentagon from its upper side points to its bottom inner point.
pub(super) fn star_text_rect(n: usize, w: f64, h: f64, inner: f64) -> Option<Rect> {
let (hc, vc) = (w / 2.0, h / 2.0);
match n {
4 => {
let (dx, dy) = (hc * inner * 45f64.to_radians().cos(), vc * inner * 45f64.to_radians().sin());
Some(Rect::new(hc - dx, vc - dy, hc + dx, vc + dy))
}
5 => {
let (swd2, shd2, svc) = (hc * 1.05146, vc * 1.10557, vc * 1.10557);
let (iwd2, ihd2) = (swd2 * inner, shd2 * inner);
let sdx1 = iwd2 * 18f64.to_radians().cos();
let sdy1 = ihd2 * 54f64.to_radians().sin();
Some(Rect::new(hc - sdx1, svc - sdy1, hc + sdx1, svc + ihd2))
}
_ => None,
}
}
#[derive(Clone, Copy)]
pub(super) enum Corner {
Square,
Round(f64),
Snip(f64),
}
/// A rectangle with each corner (TL, TR, BR, BL) square, rounded or snipped.
pub(super) fn corner_rect(w: f64, h: f64, c: [Corner; 4]) -> BezPath {
let mut b = Pb::new();
let size = |k: Corner| match k {
Corner::Square => 0.0,
Corner::Round(r) | Corner::Snip(r) => r.max(0.0),
};
let s0 = size(c[0]);
b.m(s0, 0.0);
// top edge → TR
let s1 = size(c[1]);
b.l(w - s1, 0.0);
match c[1] {
Corner::Round(r) if r > 0.0 => {
b.arc(r, r, 270.0, 90.0);
}
Corner::Snip(_) => {
b.l(w, s1);
}
_ => {}
}
let s2 = size(c[2]);
b.l(w, h - s2);
match c[2] {
Corner::Round(r) if r > 0.0 => {
b.arc(r, r, 0.0, 90.0);
}
Corner::Snip(_) => {
b.l(w - s2, h);
}
_ => {}
}
let s3 = size(c[3]);
b.l(s3, h);
match c[3] {
Corner::Round(r) if r > 0.0 => {
b.arc(r, r, 90.0, 90.0);
}
Corner::Snip(_) => {
b.l(0.0, h - s3);
}
_ => {}
}
b.l(0.0, s0);
match c[0] {
Corner::Round(r) if r > 0.0 => {
b.arc(r, r, 180.0, 90.0);
}
Corner::Snip(_) => {
b.l(s0, 0.0);
}
_ => {}
}
b.z();
b.take()
}
pub(super) fn mid_sites(w: f64, h: f64) -> Vec<Point> {
vec![Point::new(w / 2.0, 0.0), Point::new(0.0, h / 2.0), Point::new(w / 2.0, h), Point::new(w, h / 2.0)]
}
/// Orientation for single-axis arrows built along +x.
#[derive(Clone, Copy)]
pub(super) enum Dir {
Right,
Left,
Up,
Down,
}
/// Map canonical (u along the arrow's length L, v across thickness T) to shape space.
pub(super) fn orient(d: Dir, w: f64, h: f64, pts: &[(f64, f64)]) -> Vec<(f64, f64)> {
pts.iter()
.map(|&(u, v)| match d {
Dir::Right => (u, v),
Dir::Left => (w - u, v),
Dir::Up => (v, h - u),
Dir::Down => (v, u),
})
.collect()
}
pub(super) fn len_thick(d: Dir, w: f64, h: f64) -> (f64, f64) {
match d {
Dir::Right | Dir::Left => (w, h),
Dir::Up | Dir::Down => (h, w),
}
}
pub(super) fn arrow(d: Dir, w: f64, h: f64, a1: f64, a2: f64) -> Geometry {
let (l, t) = len_thick(d, w, h);
let ss = l.min(t);
let a1 = a1.clamp(0.0, 100000.0) / 100000.0;
let dx = (ss * a2.clamp(0.0, 100000.0 * l / ss.max(1e-9)) / 100000.0).min(l);
let y1 = t / 2.0 - t * a1 / 2.0;
let y2 = t / 2.0 + t * a1 / 2.0;
let pts = [(0.0, y1), (l - dx, y1), (l - dx, 0.0), (l, t / 2.0), (l - dx, t), (l - dx, y2), (0.0, y2)];
let pts = orient(d, w, h, &pts);
let tr = orient(d, w, h, &[(0.0, y1), (l - dx + dx * (y1 / (t / 2.0).max(1e-9)), y2)]);
let mut text = Rect::from_points(tr[0], tr[1]);
text = text.abs();
let mut g = Geometry { paths: vec![fill(Pb::new().poly(&pts).take())], text_rect: text, handles: vec![], sites: mid_sites(w, h) };
// handle 0: shaft thickness on the head base; handle 1: head length.
let o = orient(d, w, h, &[(l - dx, t / 2.0), (l, t / 2.0)]);
let (o0, o1) = (Point::new(o[0].0, o[0].1), Point::new(o[1].0, o[1].1));
let across = match d {
Dir::Right | Dir::Left => Vec2::new(0.0, -t / 2.0 / 100000.0),
Dir::Up | Dir::Down => Vec2::new(-t / 2.0 / 100000.0, 0.0),
};
let along = (o0 - o1) * (ss / 100000.0 / dx.max(1e-9));
g.handles.push(Handle::new(0, o0, across, a1 * 100000.0, 0.0, 100000.0));
if dx > 1e-9 {
g.handles.push(Handle::new(1, o1, along, a2, 0.0, 100000.0 * l / ss.max(1e-9)));
}
g
}
pub(super) fn double_arrow(vertical: bool, w: f64, h: f64, a1: f64, a2: f64) -> Geometry {
let (l, t) = if vertical { (h, w) } else { (w, h) };
let ss = l.min(t);
let a1 = a1.clamp(0.0, 100000.0) / 100000.0;
let dx = (ss * a2.max(0.0) / 100000.0).min(l / 2.0);
let y1 = t / 2.0 - t * a1 / 2.0;
let y2 = t / 2.0 + t * a1 / 2.0;
let pts = [(0.0, t / 2.0), (dx, 0.0), (dx, y1), (l - dx, y1), (l - dx, 0.0), (l, t / 2.0), (l - dx, t), (l - dx, y2), (dx, y2), (dx, t)];
let pts = orient(if vertical { Dir::Down } else { Dir::Right }, w, h, &pts);
let r = if vertical { Rect::new(y1, dx, y2, h - dx) } else { Rect::new(dx, y1, w - dx, y2) };
Geometry { paths: vec![fill(Pb::new().poly(&pts).take())], text_rect: r, handles: vec![], sites: mid_sites(w, h) }
}
/// Points given in 21600ths of the box (as ECMA-376 defines many fixed shapes), scaled to it.
pub(super) fn spec_pts(pts: &[(i32, i32)], w: f64, h: f64) -> Vec<(f64, f64)> {
pts.iter().map(|(x, y)| (w * *x as f64 / 21600.0, h * *y as f64 / 21600.0)).collect()
}
pub(super) fn simple(path: BezPath, text: Rect, w: f64, h: f64) -> Geometry {
Geometry { paths: vec![fill(path)], text_rect: text, handles: vec![], sites: mid_sites(w, h) }
}
pub(super) fn ellipse_sites(w: f64, h: f64) -> Vec<Point> {
(0..8)
.map(|i| {
let a = (-90.0 - 45.0 * i as f64).to_radians();
Point::new(w / 2.0 + w / 2.0 * a.cos(), h / 2.0 + h / 2.0 * a.sin())
})
.collect()
}
pub(super) fn tip_handle(w: f64, h: f64, tip: Point) -> Handle {
// A free 2-D handle is represented as index 0 with zero direction; callers move both values.
Handle { index: 0, pos: tip, origin: Point::new(w / 2.0, h / 2.0), dir: Vec2::new(w / 1e5, h / 1e5), min: -1e6, max: 1e6, angle: false }
}
+391
View File
@@ -0,0 +1,391 @@
use super::builder::vis;
use super::*;
/// How a sub-path is filled. `Lighten`/`Darken` variants shade the shape's fill (3-D looking faces).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum FillMode {
Norm,
None,
Lighten,
LightenLess,
Darken,
DarkenLess,
}
#[derive(Clone, Debug)]
pub struct SubPath {
pub path: BezPath,
pub fill: FillMode,
pub stroke: bool,
/// Even-odd fill (holes in donuts and frames).
pub even_odd: bool,
}
/// A draggable adjust handle (the yellow dot). `pos = origin + dir * value`; dragging projects
/// the pointer onto `dir`. An `angle` handle instead measures the pointer's angle about `origin`
/// (1/60 000 degree, y down, 0° at +x).
#[derive(Clone, Debug, PartialEq)]
pub struct Handle {
pub index: usize,
pub pos: Point,
pub origin: Point,
pub dir: Vec2,
pub min: f64,
pub max: f64,
pub angle: bool,
}
impl Handle {
pub(super) fn new(index: usize, origin: Point, dir: Vec2, value: f64, min: f64, max: f64) -> Self {
Handle { index, pos: origin + dir * value, origin, dir, min, max, angle: false }
}
/// An angle handle on the `rx`×`ry` ellipse around `center` at visual angle `value`.
pub(super) fn angle(index: usize, center: Point, rx: f64, ry: f64, value: f64) -> Self {
let t = vis(value / 60000.0, rx, ry).to_radians();
let pos = Point::new(center.x + rx * t.cos(), center.y + ry * t.sin());
Handle { index, pos, origin: center, dir: Vec2::ZERO, min: 0.0, max: 21600000.0, angle: true }
}
/// The adjust value for a pointer at `p` (shape-local space).
pub fn value_at(&self, p: Point) -> f64 {
if self.angle {
let d = p - self.origin;
if !(d.x.is_finite() && d.y.is_finite()) || d.hypot() < 1e-9 {
return self.min;
}
let v = (d.y.atan2(d.x).to_degrees().rem_euclid(360.0) * 60000.0).round();
return if v >= self.max { self.min } else { v };
}
let l2 = self.dir.hypot2();
if l2 < 1e-18 {
return self.min;
}
let v = (p - self.origin).dot(self.dir) / l2;
if !v.is_finite() {
return self.min;
}
v.clamp(self.min.min(self.max), self.max.max(self.min)).round()
}
}
#[derive(Clone, Debug)]
pub struct Geometry {
pub paths: Vec<SubPath>,
/// Where text goes, in shape-local space.
pub text_rect: Rect,
pub handles: Vec<Handle>,
/// Connector glue points, shape-local.
pub sites: Vec<Point>,
}
impl Geometry {
/// The union outline used for hit testing and selection (all filled or stroked sub-paths).
pub fn outline(&self) -> BezPath {
let mut p = BezPath::new();
for s in &self.paths {
p.extend(s.path.iter());
}
p
}
/// Whether nothing is filled (lines, connectors, arcs, brackets).
pub fn is_open(&self) -> bool {
self.paths.iter().all(|s| s.fill == FillMode::None)
}
}
/// Gallery category, as in the Shapes menu.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Category {
Lines,
Rectangles,
BasicShapes,
BlockArrows,
EquationShapes,
Flowchart,
StarsAndBanners,
Callouts,
ActionButtons,
}
impl Category {
pub const ALL: [Category; 9] = [
Category::Lines,
Category::Rectangles,
Category::BasicShapes,
Category::BlockArrows,
Category::EquationShapes,
Category::Flowchart,
Category::StarsAndBanners,
Category::Callouts,
Category::ActionButtons,
];
pub fn label(self) -> &'static str {
match self {
Category::Lines => "Lines",
Category::Rectangles => "Rectangles",
Category::BasicShapes => "Basic Shapes",
Category::BlockArrows => "Block Arrows",
Category::EquationShapes => "Equation Shapes",
Category::Flowchart => "Flowchart",
Category::StarsAndBanners => "Stars and Banners",
Category::Callouts => "Callouts",
Category::ActionButtons => "Action Buttons",
}
}
}
pub struct PresetInfo {
pub name: &'static str,
pub label: &'static str,
pub category: Category,
/// Default adjust values.
pub defaults: &'static [f64],
}
macro_rules! p {
($n:literal, $l:literal, $c:ident, [$($d:expr),*]) => {
PresetInfo { name: $n, label: $l, category: Category::$c, defaults: &[$($d as f64),*] }
};
}
/// Every preset we generate, in gallery order.
pub static CATALOG: &[PresetInfo] = &[
p!("line", "Line", Lines, []),
p!("straightConnector1", "Arrow", Lines, []),
p!("bentConnector3", "Connector: Elbow", Lines, [50000]),
p!("curvedConnector3", "Connector: Curved", Lines, [50000]),
p!("bentConnector2", "Connector: Elbow (one bend)", Lines, []),
p!("lineInv", "Line: Rising", Lines, []),
p!("rect", "Rectangle", Rectangles, []),
p!("roundRect", "Rectangle: Rounded Corners", Rectangles, [16667]),
p!("snip1Rect", "Rectangle: Single Corner Snipped", Rectangles, [16667]),
p!("snip2SameRect", "Rectangle: Top Corners Snipped", Rectangles, [16667, 0]),
p!("snip2DiagRect", "Rectangle: Diagonal Corners Snipped", Rectangles, [0, 16667]),
p!("snipRoundRect", "Rectangle: Top Corners One Rounded and One Snipped", Rectangles, [16667, 16667]),
p!("round1Rect", "Rectangle: Single Corner Rounded", Rectangles, [16667]),
p!("round2SameRect", "Rectangle: Top Corners Rounded", Rectangles, [16667, 0]),
p!("round2DiagRect", "Rectangle: Diagonal Corners Rounded", Rectangles, [16667, 0]),
p!("textBox", "Text Box", BasicShapes, []),
p!("ellipse", "Oval", BasicShapes, []),
p!("triangle", "Isosceles Triangle", BasicShapes, [50000]),
p!("rtTriangle", "Right Triangle", BasicShapes, []),
p!("parallelogram", "Parallelogram", BasicShapes, [25000]),
p!("trapezoid", "Trapezoid", BasicShapes, [25000]),
p!("nonIsoscelesTrapezoid", "Trapezoid: Uneven Sides", BasicShapes, [25000, 25000]),
p!("diamond", "Diamond", BasicShapes, []),
p!("pentagon", "Regular Pentagon", BasicShapes, []),
p!("hexagon", "Hexagon", BasicShapes, [25000]),
p!("heptagon", "Heptagon", BasicShapes, []),
p!("octagon", "Octagon", BasicShapes, [29289]),
p!("decagon", "Decagon", BasicShapes, []),
p!("dodecagon", "Dodecagon", BasicShapes, []),
p!("pie", "Partial Circle", BasicShapes, [0, 16200000]),
p!("pieWedge", "Quarter Wedge", BasicShapes, []),
p!("chord", "Chord", BasicShapes, [2700000, 16200000]),
p!("teardrop", "Teardrop", BasicShapes, [100000]),
p!("frame", "Frame", BasicShapes, [12500]),
p!("cornerTabs", "Corner Tabs: Triangles", BasicShapes, []),
p!("squareTabs", "Corner Tabs: Squares", BasicShapes, []),
p!("plaqueTabs", "Corner Tabs: Quarter Circles", BasicShapes, []),
p!("halfFrame", "Half Frame", BasicShapes, [33333, 33333]),
p!("corner", "L-Shape", BasicShapes, [50000, 50000]),
p!("diagStripe", "Diagonal Stripe", BasicShapes, [50000]),
p!("plus", "Cross", BasicShapes, [25000]),
p!("plaque", "Plaque", BasicShapes, [16667]),
p!("can", "Cylinder", BasicShapes, [25000]),
p!("cube", "Cube", BasicShapes, [25000]),
p!("bevel", "Bevel", BasicShapes, [12500]),
p!("donut", "Donut", BasicShapes, [25000]),
p!("noSmoking", "\"Not Allowed\" Symbol", BasicShapes, [18750]),
p!("blockArc", "Block Arc", BasicShapes, [10800000, 0, 25000]),
p!("foldedCorner", "Folded Corner", BasicShapes, [16667]),
p!("smileyFace", "Smiley Face", BasicShapes, [4653]),
p!("heart", "Heart", BasicShapes, []),
p!("lightningBolt", "Lightning Bolt", BasicShapes, []),
p!("sun", "Sun", BasicShapes, [25000]),
p!("moon", "Moon", BasicShapes, [50000]),
p!("cloud", "Cloud", BasicShapes, []),
p!("gear6", "Gear: 6 Teeth", BasicShapes, [15000, 3526]),
p!("gear9", "Gear: 9 Teeth", BasicShapes, [10000, 1763]),
p!("funnel", "Funnel", BasicShapes, []),
p!("arc", "Arc", BasicShapes, [16200000, 0]),
p!("bracketPair", "Double Bracket", BasicShapes, [16667]),
p!("bracePair", "Double Brace", BasicShapes, [8333]),
p!("leftBracket", "Left Bracket", BasicShapes, [8333]),
p!("rightBracket", "Right Bracket", BasicShapes, [8333]),
p!("leftBrace", "Left Brace", BasicShapes, [8333, 50000]),
p!("rightBrace", "Right Brace", BasicShapes, [8333, 50000]),
p!("chartX", "Chart Marker: Cross Lines", BasicShapes, []),
p!("chartStar", "Chart Marker: Star Lines", BasicShapes, []),
p!("chartPlus", "Chart Marker: Plus Lines", BasicShapes, []),
p!("rightArrow", "Arrow: Right", BlockArrows, [50000, 50000]),
p!("leftArrow", "Arrow: Left", BlockArrows, [50000, 50000]),
p!("upArrow", "Arrow: Up", BlockArrows, [50000, 50000]),
p!("downArrow", "Arrow: Down", BlockArrows, [50000, 50000]),
p!("leftRightArrow", "Arrow: Left-Right", BlockArrows, [50000, 50000]),
p!("upDownArrow", "Arrow: Up-Down", BlockArrows, [50000, 50000]),
p!("quadArrow", "Arrow: Quad", BlockArrows, [22500, 22500, 22500]),
p!("leftRightUpArrow", "Arrow: Left-Right-Up", BlockArrows, [25000, 25000, 25000]),
p!("bentArrow", "Arrow: Bent", BlockArrows, [25000, 25000, 25000, 43750]),
p!("uturnArrow", "Arrow: U-Turn", BlockArrows, [25000, 25000, 25000, 43750, 75000]),
p!("curvedRightArrow", "Arrow: Curved Right", BlockArrows, [25000, 50000, 25000]),
p!("curvedLeftArrow", "Arrow: Curved Left", BlockArrows, [25000, 50000, 25000]),
p!("curvedUpArrow", "Arrow: Curved Up", BlockArrows, [25000, 50000, 25000]),
p!("curvedDownArrow", "Arrow: Curved Down", BlockArrows, [25000, 50000, 25000]),
p!("leftUpArrow", "Arrow: Left-Up", BlockArrows, [25000, 25000, 25000]),
p!("bentUpArrow", "Arrow: Bent-Up", BlockArrows, [25000, 25000, 25000]),
p!("stripedRightArrow", "Arrow: Striped Right", BlockArrows, [50000, 50000]),
p!("notchedRightArrow", "Arrow: Notched Right", BlockArrows, [50000, 50000]),
p!("homePlate", "Arrow: Pentagon", BlockArrows, [50000]),
p!("chevron", "Arrow: Chevron", BlockArrows, [50000]),
p!("circularArrow", "Arrow: Circular", BlockArrows, [12500, 1142319, 20457681, 10800000, 12500]),
p!("leftCircularArrow", "Arrow: Circular Counter-clockwise", BlockArrows, [12500, -1142319, 1142319, 10800000, 12500]),
p!("leftRightCircularArrow", "Arrow: Circular Two-headed", BlockArrows, [12500, 1142319, 20457681, 11942319, 12500]),
p!("swooshArrow", "Arrow: Swoosh", BlockArrows, [25000, 16667]),
p!("rightArrowCallout", "Callout: Right Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
p!("downArrowCallout", "Callout: Down Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
p!("leftArrowCallout", "Callout: Left Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
p!("upArrowCallout", "Callout: Up Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
p!("leftRightArrowCallout", "Callout: Left-Right Arrow", BlockArrows, [25000, 25000, 25000, 48123]),
p!("upDownArrowCallout", "Callout: Up-Down Arrow", BlockArrows, [25000, 25000, 25000, 48123]),
p!("quadArrowCallout", "Callout: Quad Arrow", BlockArrows, [18515, 18515, 18515, 48123]),
p!("mathPlus", "Plus Sign", EquationShapes, [23520]),
p!("mathMinus", "Minus Sign", EquationShapes, [23520]),
p!("mathMultiply", "Multiplication Sign", EquationShapes, [23520]),
p!("mathDivide", "Division Sign", EquationShapes, [23520, 5880, 11760]),
p!("mathEqual", "Equals", EquationShapes, [23520, 11760]),
p!("mathNotEqual", "Not Equal", EquationShapes, [23520, 6600000, 11760]),
p!("flowChartProcess", "Flowchart: Process", Flowchart, []),
p!("flowChartAlternateProcess", "Flowchart: Alternate Process", Flowchart, []),
p!("flowChartDecision", "Flowchart: Decision", Flowchart, []),
p!("flowChartInputOutput", "Flowchart: Data", Flowchart, []),
p!("flowChartPredefinedProcess", "Flowchart: Predefined Process", Flowchart, []),
p!("flowChartInternalStorage", "Flowchart: Internal Storage", Flowchart, []),
p!("flowChartDocument", "Flowchart: Document", Flowchart, []),
p!("flowChartMultidocument", "Flowchart: Multidocument", Flowchart, []),
p!("flowChartTerminator", "Flowchart: Terminator", Flowchart, []),
p!("flowChartPreparation", "Flowchart: Preparation", Flowchart, []),
p!("flowChartManualInput", "Flowchart: Manual Input", Flowchart, []),
p!("flowChartManualOperation", "Flowchart: Manual Operation", Flowchart, []),
p!("flowChartConnector", "Flowchart: Connector", Flowchart, []),
p!("flowChartOffpageConnector", "Flowchart: Off-page Connector", Flowchart, []),
p!("flowChartPunchedCard", "Flowchart: Card", Flowchart, []),
p!("flowChartPunchedTape", "Flowchart: Punched Tape", Flowchart, []),
p!("flowChartSummingJunction", "Flowchart: Summing Junction", Flowchart, []),
p!("flowChartOr", "Flowchart: Or", Flowchart, []),
p!("flowChartCollate", "Flowchart: Collate", Flowchart, []),
p!("flowChartSort", "Flowchart: Sort", Flowchart, []),
p!("flowChartExtract", "Flowchart: Extract", Flowchart, []),
p!("flowChartMerge", "Flowchart: Merge", Flowchart, []),
p!("flowChartOnlineStorage", "Flowchart: Stored Data", Flowchart, []),
p!("flowChartDelay", "Flowchart: Delay", Flowchart, []),
p!("flowChartMagneticTape", "Flowchart: Sequential Access Storage", Flowchart, []),
p!("flowChartMagneticDisk", "Flowchart: Magnetic Disk", Flowchart, []),
p!("flowChartMagneticDrum", "Flowchart: Direct Access Storage", Flowchart, []),
p!("flowChartDisplay", "Flowchart: Display", Flowchart, []),
p!("flowChartOfflineStorage", "Flowchart: Offline Storage", Flowchart, []),
p!("irregularSeal1", "Explosion: 8 Points", StarsAndBanners, []),
p!("irregularSeal2", "Explosion: 14 Points", StarsAndBanners, []),
p!("star4", "Star: 4 Points", StarsAndBanners, [12500]),
p!("star5", "Star: 5 Points", StarsAndBanners, [19098]),
p!("star6", "Star: 6 Points", StarsAndBanners, [28868]),
p!("star7", "Star: 7 Points", StarsAndBanners, [34601]),
p!("star8", "Star: 8 Points", StarsAndBanners, [37500]),
p!("star10", "Star: 10 Points", StarsAndBanners, [42533]),
p!("star12", "Star: 12 Points", StarsAndBanners, [37500]),
p!("star16", "Star: 16 Points", StarsAndBanners, [37500]),
p!("star24", "Star: 24 Points", StarsAndBanners, [37500]),
p!("star32", "Star: 32 Points", StarsAndBanners, [37500]),
p!("ribbon2", "Ribbon: Tilted Up", StarsAndBanners, [16667, 50000]),
p!("ribbon", "Ribbon: Tilted Down", StarsAndBanners, [16667, 50000]),
p!("ellipseRibbon2", "Ribbon: Curved and Tilted Up", StarsAndBanners, [25000, 50000, 12500]),
p!("ellipseRibbon", "Ribbon: Curved and Tilted Down", StarsAndBanners, [25000, 50000, 12500]),
p!("leftRightRibbon", "Ribbon: Left-Right Fold", StarsAndBanners, [50000, 50000, 16667]),
p!("verticalScroll", "Scroll: Vertical", StarsAndBanners, [12500]),
p!("horizontalScroll", "Scroll: Horizontal", StarsAndBanners, [12500]),
p!("wave", "Wave", StarsAndBanners, [12500, 0]),
p!("doubleWave", "Double Wave", StarsAndBanners, [6250, 0]),
p!("wedgeRectCallout", "Speech Bubble: Rectangle", Callouts, [-20833, 62500]),
p!("wedgeRoundRectCallout", "Speech Bubble: Rectangle with Corners Rounded", Callouts, [-20833, 62500, 16667]),
p!("wedgeEllipseCallout", "Speech Bubble: Oval", Callouts, [-20833, 62500]),
p!("cloudCallout", "Thought Bubble: Cloud", Callouts, [-20833, 62500]),
p!("borderCallout1", "Callout: Line", Callouts, [18750, -8333, 112500, -38333]),
p!("borderCallout2", "Callout: Bent Line", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
p!("borderCallout3", "Callout: Double Bent Line", Callouts, [18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]),
p!("accentCallout1", "Callout: Line with Accent Bar", Callouts, [18750, -8333, 112500, -38333]),
p!("accentCallout2", "Callout: Bent Line with Accent Bar", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
p!("accentCallout3", "Callout: Double Bent Line with Accent Bar", Callouts, [18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]),
p!("callout1", "Callout: Line with No Border", Callouts, [18750, -8333, 112500, -38333]),
p!("callout2", "Callout: Bent Line with No Border", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
p!("callout3", "Callout: Double Bent Line with No Border", Callouts, [18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]),
p!("accentBorderCallout1", "Callout: Line with Border and Accent Bar", Callouts, [18750, -8333, 112500, -38333]),
p!("accentBorderCallout2", "Callout: Bent Line with Border and Accent Bar", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
p!(
"accentBorderCallout3",
"Callout: Double Bent Line with Border and Accent Bar",
Callouts,
[18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]
),
p!("actionButtonBackPrevious", "Action Button: Go Back or Previous", ActionButtons, []),
p!("actionButtonForwardNext", "Action Button: Go Forward or Next", ActionButtons, []),
p!("actionButtonBeginning", "Action Button: Go to Beginning", ActionButtons, []),
p!("actionButtonEnd", "Action Button: Go to End", ActionButtons, []),
p!("actionButtonHome", "Action Button: Go Home", ActionButtons, []),
p!("actionButtonInformation", "Action Button: Get Information", ActionButtons, []),
p!("actionButtonReturn", "Action Button: Go Back", ActionButtons, []),
p!("actionButtonMovie", "Action Button: Video", ActionButtons, []),
p!("actionButtonDocument", "Action Button: Document", ActionButtons, []),
p!("actionButtonSound", "Action Button: Sound", ActionButtons, []),
p!("actionButtonHelp", "Action Button: Help", ActionButtons, []),
p!("actionButtonBlank", "Action Button: Custom", ActionButtons, []),
];
pub fn info(name: &str) -> Option<&'static PresetInfo> {
CATALOG.iter().find(|p| p.name == name)
}
/// Whether PowerPoint joins this preset's outline with sharp (miter) corners when the line names
/// no join (it rounds them otherwise). Observed per preset on its export: the plus, the right,
/// up and down block arrows (not the left one), chevrons, stars from five points up, the
/// equation shapes, curved ribbons and the action buttons are mitred.
pub fn mitred_by_default(name: &str) -> bool {
matches!(
name,
"plus"
| "rightArrow"
| "upArrow"
| "downArrow"
| "upDownArrow"
| "leftUpArrow"
| "bentUpArrow"
| "stripedRightArrow"
| "notchedRightArrow"
| "chevron"
| "leftArrowCallout"
| "leftRightArrowCallout"
| "upDownArrowCallout"
| "quadArrowCallout"
| "mathPlus"
| "mathMinus"
| "mathMultiply"
| "mathEqual"
| "mathNotEqual"
| "star5"
| "star6"
| "star8"
| "star10"
| "star12"
| "star16"
| "star24"
| "star32"
| "ellipseRibbon"
| "ellipseRibbon2"
) || name.starts_with("actionButton")
}
pub fn is_line_like(name: &str) -> bool {
matches!(name, "line" | "straightConnector1" | "bentConnector2" | "bentConnector3" | "curvedConnector3" | "arc")
|| name.starts_with("bentConnector")
|| name.starts_with("curvedConnector")
}
+375
View File
@@ -0,0 +1,375 @@
use super::builder::{Corner, Pb, corner_rect, fill, mid_sites, shade, simple, stroke_only, tip_handle};
use super::catalog::{FillMode, Geometry};
use super::*;
pub(super) fn wedge_rect(w: f64, h: f64, a0: f64, a1: f64, r: f64) -> Geometry {
let tip = Point::new(w / 2.0 + w * a0 / 1e5, h / 2.0 + h * a1 / 1e5);
let inside = tip.x > 0.0 && tip.x < w && tip.y > 0.0 && tip.y < h;
let (dx, dy) = ((tip.x - w / 2.0) / w.max(1e-9), (tip.y - h / 2.0) / h.max(1e-9));
let mut b = Pb::new();
let r = r.min(w / 2.0).min(h / 2.0);
// Walk clockwise from the top-left; insert the wedge on the edge facing the tip.
let horiz = dx.abs() > dy.abs();
// The wedge's base: 2..5 twelfths of the edge on the tip's side of the centre when it is
// before it, 7..10 twelfths when after (presetShapeDefinitions' xg1/xg2, yg1/yg2).
let (bx0, bx1) = if tip.x < w / 2.0 { (w * 2.0 / 12.0, w * 5.0 / 12.0) } else { (w * 7.0 / 12.0, w * 10.0 / 12.0) };
let (by0, by1) = if tip.y < h / 2.0 { (h * 2.0 / 12.0, h * 5.0 / 12.0) } else { (h * 7.0 / 12.0, h * 10.0 / 12.0) };
b.m(r, 0.0);
if !inside && !horiz && dy < 0.0 {
b.l(bx0, 0.0).l(tip.x, tip.y).l(bx1, 0.0);
}
b.l(w - r, 0.0);
if r > 0.0 {
b.arc(r, r, 270.0, 90.0);
}
if !inside && horiz && dx > 0.0 {
b.l(w, by0).l(tip.x, tip.y).l(w, by1);
}
b.l(w, h - r);
if r > 0.0 {
b.arc(r, r, 0.0, 90.0);
}
if !inside && !horiz && dy > 0.0 {
b.l(bx1, h).l(tip.x, tip.y).l(bx0, h);
}
b.l(r, h);
if r > 0.0 {
b.arc(r, r, 90.0, 90.0);
}
if !inside && horiz && dx < 0.0 {
b.l(0.0, by1).l(tip.x, tip.y).l(0.0, by0);
}
b.l(0.0, r);
if r > 0.0 {
b.arc(r, r, 180.0, 90.0);
}
b.z();
let mut g = simple(b.take(), Rect::new(0.0, 0.0, w, h).inset(-r * 0.29289), w, h);
g.handles.push(tip_handle(w, h, tip));
g
}
/// ECMA-376 cloud outline arcs (radii in 43200ths of the box, angles in 60000ths of a degree,
/// as DrawingML `arcTo` takes them), from the start point (3900, 14370).
const CLOUD_ARCS: [(f64, f64, f64, f64); 11] = [
(6753.0, 9190.0, -11429249.0, 7426832.0),
(5333.0, 7267.0, -8646143.0, 5396714.0),
(4365.0, 5945.0, -8748475.0, 5983381.0),
(4857.0, 6595.0, -7859164.0, 7034504.0),
(5333.0, 7273.0, -4722533.0, 6541615.0),
(6775.0, 9220.0, -2776035.0, 7816140.0),
(5785.0, 7867.0, 37501.0, 6842000.0),
(6752.0, 9215.0, 1347096.0, 6910353.0),
(7720.0, 10543.0, 3974558.0, 4542661.0),
(4360.0, 5918.0, -16496525.0, 8804134.0),
(4345.0, 5945.0, -14809710.0, 9151131.0),
];
/// The cloud's creases: short arcs inside the outline, each from its own start point.
const CLOUD_CREASES: [(f64, f64, f64, f64, f64, f64); 11] = [
(4693.0, 26177.0, 4345.0, 5945.0, 5204520.0, 1585770.0),
(6928.0, 34899.0, 4360.0, 5918.0, 4416628.0, 686848.0),
(16478.0, 39090.0, 6752.0, 9215.0, 8257449.0, 844866.0),
(28827.0, 34751.0, 6752.0, 9215.0, 387196.0, 959901.0),
(34129.0, 22954.0, 5785.0, 7867.0, -4217541.0, 4255042.0),
(41798.0, 15354.0, 5333.0, 7273.0, 1819082.0, 1665090.0),
(38324.0, 5426.0, 4857.0, 6595.0, -824660.0, 891534.0),
(29078.0, 3952.0, 4857.0, 6595.0, -8950887.0, 1091722.0),
(22141.0, 4720.0, 4365.0, 5945.0, -9809656.0, 1061181.0),
(14000.0, 5192.0, 6753.0, 9190.0, -4002417.0, 739161.0),
(4127.0, 15789.0, 6753.0, 9190.0, 9459261.0, 711490.0),
];
pub(super) fn cloud(name: &str, w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
// Drawn in the path's own 43200-unit square, then stretched to the box (as DrawingML lays out
// a path with its own w and h), so the arcs keep their shape's proportions at any aspect.
let to_box = kurbo::Affine::scale_non_uniform(w / 43200.0, h / 43200.0);
let deg = |v: f64| v / 60000.0;
let mut b = Pb::new();
b.m(3900.0, 14370.0);
for (wr, hr, st, sw) in CLOUD_ARCS {
b.arc_spec(wr, hr, deg(st), deg(sw));
}
b.z();
let mut creases = Pb::new();
for (x, y, wr, hr, st, sw) in CLOUD_CREASES {
creases.m(x, y).arc_spec(wr, hr, deg(st), deg(sw));
}
let mut outline = b.take();
outline.apply_affine(to_box);
let mut paths = vec![fill(outline)];
if name == "cloud" {
let mut c = creases.take();
c.apply_affine(to_box);
paths.push(stroke_only(c));
}
let text_rect = Rect::new(w * 2977.0 / 21600.0, h * 3262.0 / 21600.0, w * 17087.0 / 21600.0, h * 17337.0 / 21600.0);
let mut handles = vec![];
if name == "cloudCallout" {
let tip = Point::new(w / 2.0 + w * a0 / 1e5, h / 2.0 + h * a1 / 1e5);
let c = Point::new(w / 2.0, h / 2.0);
let mut bubbles = Pb::new();
for (k, r) in [(0.55, 0.06), (0.75, 0.045), (0.95, 0.03)] {
let p = c + (tip - c) * k;
if !(p.x > w * 0.1 && p.x < w * 0.9 && p.y > h * 0.1 && p.y < h * 0.9) || k > 0.9 {
bubbles.ellipse(p.x, p.y, w * r, h * r);
}
}
paths.push(fill(bubbles.take()));
handles.push(tip_handle(w, h, tip));
}
Geometry { paths, text_rect, handles, sites: mid_sites(w, h) }
}
/// The equation shapes, by ECMA-376's formulas (checked against PowerPoint's outlines at several
/// sizes and adjust values). Their bars span 73.49% of the width; the plus and multiply bars are
/// `adj1` of the shorter side thick, the others' `adj1` of the height.
pub(super) fn math(name: &str, w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
let pin = |lo: f64, v: f64, hi: f64| v.max(lo).min(hi.max(lo));
let ss = w.min(h);
let (hc, vc) = (w / 2.0, h / 2.0);
let dx1 = w * 73490.0 / 200000.0;
let (x1, x2) = (hc - dx1, hc + dx1);
let mut b = Pb::new();
let text = match name {
"mathPlus" => {
let a = pin(0.0, a0, 73490.0);
let dy1 = h * 73490.0 / 200000.0;
let dx2 = ss * a / 200000.0;
let (y1, y2, y3, y4) = (vc - dy1, vc - dx2, vc + dx2, vc + dy1);
let (xa, xb) = (hc - dx2, hc + dx2);
b.poly(&[(x1, y2), (xa, y2), (xa, y1), (xb, y1), (xb, y2), (x2, y2), (x2, y3), (xb, y3), (xb, y4), (xa, y4), (xa, y3), (x1, y3)]);
Rect::new(x1, y2, x2, y3)
}
"mathMinus" => {
let dy1 = h * pin(0.0, a0, 100000.0) / 200000.0;
b.poly(&[(x1, vc - dy1), (x2, vc - dy1), (x2, vc + dy1), (x1, vc + dy1)]);
Rect::new(x1, vc - dy1, x2, vc + dy1)
}
"mathEqual" => {
let a = pin(0.0, a0, 36745.0);
let g = pin(0.0, a1, 100000.0 - 2.0 * a);
let (dy1, dy2) = (h * a / 100000.0, h * g / 200000.0);
let (y2, y3) = (vc - dy2, vc + dy2);
let (y1, y4) = (y2 - dy1, y3 + dy1);
b.poly(&[(x1, y1), (x2, y1), (x2, y2), (x1, y2)]);
b.poly(&[(x1, y3), (x2, y3), (x2, y4), (x1, y4)]);
Rect::new(x1, y1, x2, y4)
}
"mathNotEqual" => {
let a = pin(0.0, a0, 50000.0);
let cr_ang = pin(4200000.0, a1, 6600000.0);
let g = pin(0.0, a2, 100000.0 - 2.0 * a);
let (dy1, dy2) = (h * a / 100000.0, h * g / 200000.0);
let hd2 = (h / 2.0).max(1e-9);
let (y2, y3) = (vc - dy2, vc + dy2);
let (y1, y4) = (y2 - dy1, y3 + dy1);
let cadj2 = cr_ang - 5400000.0;
let xadj2 = hd2 * (cadj2 / 60000.0).to_radians().tan();
let len = xadj2.hypot(hd2);
let bhw = len * dy1 / hd2;
let x7 = hc + xadj2 - bhw / 2.0;
let at = |y: f64| x7 - xadj2 * y / hd2;
let (x6, x5, x4, x3) = (at(y1), at(y2), at(y3), at(y4));
let rx7 = x7 + bhw;
let dx7 = dy1 * hd2 / len;
let dy3 = dy1 * xadj2 / len;
let (rx, lx, ry, ly) = if cadj2 > 0.0 { (x7 + dx7, x7, dy3, 0.0) } else { (rx7, rx7 - dx7, 0.0, -dy3) };
b.poly(&[
(x1, y1),
(x6, y1),
(lx, ly),
(rx, ry),
(x6 + bhw, y1),
(x2, y1),
(x2, y2),
(x5 + bhw, y2),
(x4 + bhw, y3),
(x2, y3),
(x2, y4),
(x3 + bhw, y4),
(w - lx, h - ly),
(w - rx, h - ry),
(x3, y4),
(x1, y4),
(x1, y3),
(x4, y3),
(x5, y2),
(x1, y2),
]);
Rect::new(x1, y1, x2, y4)
}
"mathDivide" => {
let a = pin(1000.0, a0, 36745.0);
let max3 = ((73490.0 - a) / 4.0).min(36745.0 * w / h.max(1e-9));
let r3 = pin(1000.0, a2, max3);
let g = pin(0.0, a1, 73490.0 - 4.0 * r3 - a);
let dy1 = h * a / 200000.0;
let yg = h * g / 100000.0;
let rad = h * r3 / 100000.0;
let (y3, y4) = (vc - dy1, vc + dy1);
let y2 = y3 - (yg + rad);
let y1 = y2 - rad;
b.ellipse(hc, y1 + rad, rad, rad);
b.ellipse(hc, h - y1 - rad, rad, rad);
b.poly(&[(x1, y3), (x2, y3), (x2, y4), (x1, y4)]);
Rect::new(x1, y3, x2, y4)
}
_ => {
// mathMultiply: an X whose arms run along the box's diagonals.
let th = ss * pin(0.0, a0, 51965.0) / 100000.0;
let ang = h.atan2(w);
let (sa, ca, ta) = (ang.sin(), ang.cos(), ang.tan().max(1e-9));
let lm = w.hypot(h) * (1.0 - 51965.0 / 100000.0);
let (xm, ym) = (ca * lm / 2.0, sa * lm / 2.0);
let (dxam, dyam) = (sa * th / 2.0, ca * th / 2.0);
let (xa, ya, xb, yb) = (xm - dxam, ym + dyam, xm + dxam, ym - dyam);
let yc = (hc - xb) * ta + yb;
let (xd, xe) = (w - xb, w - xa);
let xfe = (vc - ya) / ta;
let (xf, xl) = (xe - xfe, xa + xfe);
let (yg, yh, yi) = (h - ya, h - yb, h - yc);
b.poly(&[(xa, ya), (xb, yb), (hc, yc), (xd, yb), (xe, ya), (xf, vc), (xe, yg), (xd, yh), (hc, yi), (xb, yh), (xa, yg), (xl, vc)]);
Rect::new(xa, yb, xe, yh)
}
};
Geometry { paths: vec![fill(b.take())], text_rect: text, handles: vec![], sites: mid_sites(w, h) }
}
pub(super) fn ribbon(up: bool, w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
let fold = h * a0.clamp(0.0, 33333.0) / 1e5;
let cw = w * a1.clamp(25000.0, 75000.0) / 1e5; // centre band width
let x0 = (w - cw) / 2.0;
let x1 = w - x0;
let ear = w / 8.0;
let (top, bot) = (0.0, h);
let mut b = Pb::new();
let mut shade_p = Pb::new();
if up {
// centre band sits high; ends hang low.
b.poly(&[(x0, top), (x1, top), (x1, bot - fold), (x0, bot - fold)]);
let mut ends = Pb::new();
ends.poly(&[(0.0, fold), (x0 + ear * 0.5, fold), (x0 + ear * 0.5, bot), (0.0, bot), (ear, (fold + bot) / 2.0)]);
ends.poly(&[(w, fold), (x1 - ear * 0.5, fold), (x1 - ear * 0.5, bot), (w, bot), (w - ear, (fold + bot) / 2.0)]);
shade_p.poly(&[(x0, bot - fold), (x0 + ear * 0.5, bot - fold), (x0 + ear * 0.5, bot)]);
shade_p.poly(&[(x1, bot - fold), (x1 - ear * 0.5, bot - fold), (x1 - ear * 0.5, bot)]);
let text = Rect::new(x0, top, x1, bot - fold);
return Geometry {
paths: vec![fill(ends.take()), shade(shade_p.take(), FillMode::DarkenLess), fill(b.take())],
text_rect: text,
handles: vec![],
sites: mid_sites(w, h),
};
}
b.poly(&[(x0, top + fold), (x1, top + fold), (x1, bot), (x0, bot)]);
let mut ends = Pb::new();
ends.poly(&[(0.0, top), (x0 + ear * 0.5, top), (x0 + ear * 0.5, bot - fold), (0.0, bot - fold), (ear, (bot - fold) / 2.0)]);
ends.poly(&[(w, top), (x1 - ear * 0.5, top), (x1 - ear * 0.5, bot - fold), (w, bot - fold), (w - ear, (bot - fold) / 2.0)]);
shade_p.poly(&[(x0, top + fold), (x0 + ear * 0.5, top + fold), (x0 + ear * 0.5, top)]);
shade_p.poly(&[(x1, top + fold), (x1 - ear * 0.5, top + fold), (x1 - ear * 0.5, top)]);
let text = Rect::new(x0, top + fold, x1, bot);
Geometry {
paths: vec![fill(ends.take()), shade(shade_p.take(), FillMode::DarkenLess), fill(b.take())],
text_rect: text,
handles: vec![],
sites: mid_sites(w, h),
}
}
pub(super) fn scroll(vertical: bool, w: f64, h: f64, a0: f64) -> Geometry {
let ss = w.min(h);
let r = ss * a0.clamp(0.0, 25000.0) / 1e5 / 2.0;
let mut b = Pb::new();
let mut curl = Pb::new();
if vertical {
b.poly(&[(r, r * 2.0), (w - r, r * 2.0), (w - r, h - r), (r, h - r)]);
b.ellipse(w / 2.0, r, w / 2.0 - r * 0.0, r);
curl.ellipse(r, h - r, r, r);
curl.ellipse(w - r * 2.0, r, r * 0.5, r * 0.5);
let text = Rect::new(r, r * 2.0, w - r, h - r);
return Geometry {
paths: vec![fill(b.take()), shade(curl.take(), FillMode::DarkenLess)],
text_rect: text,
handles: vec![],
sites: mid_sites(w, h),
};
}
b.poly(&[(r * 2.0, r), (w - r, r), (w - r, h - r), (r * 2.0, h - r)]);
b.ellipse(r, h / 2.0, r, h / 2.0);
curl.ellipse(w - r, r, r, r);
curl.ellipse(r, h - r * 2.0, r * 0.5, r * 0.5);
let text = Rect::new(r * 2.0, r, w - r, h - r);
Geometry { paths: vec![fill(b.take()), shade(curl.take(), FillMode::DarkenLess)], text_rect: text, handles: vec![], sites: mid_sites(w, h) }
}
pub(super) fn action_button(name: &str, w: f64, h: f64) -> Geometry {
let body = corner_rect(w, h, [Corner::Square; 4]);
let ss = w.min(h);
let (cx, cy) = (w / 2.0, h / 2.0);
let s = ss * 0.3;
let mut g = Pb::new();
match name {
"actionButtonBackPrevious" => {
g.poly(&[(cx + s, cy - s), (cx + s, cy + s), (cx - s, cy)]);
}
"actionButtonForwardNext" => {
g.poly(&[(cx - s, cy - s), (cx - s, cy + s), (cx + s, cy)]);
}
"actionButtonBeginning" => {
g.poly(&[(cx + s, cy - s), (cx + s, cy + s), (cx - s * 0.6, cy)]);
g.poly(&[(cx - s, cy - s), (cx - s * 0.7, cy - s), (cx - s * 0.7, cy + s), (cx - s, cy + s)]);
}
"actionButtonEnd" => {
g.poly(&[(cx - s, cy - s), (cx - s, cy + s), (cx + s * 0.6, cy)]);
g.poly(&[(cx + s * 0.7, cy - s), (cx + s, cy - s), (cx + s, cy + s), (cx + s * 0.7, cy + s)]);
}
"actionButtonHome" => {
g.poly(&[
(cx, cy - s),
(cx + s, cy),
(cx + s * 0.7, cy),
(cx + s * 0.7, cy + s),
(cx - s * 0.7, cy + s),
(cx - s * 0.7, cy),
(cx - s, cy),
]);
}
"actionButtonInformation" | "actionButtonHelp" => {
g.ellipse(cx, cy, s, s);
}
"actionButtonReturn" => {
g.m(cx + s, cy - s * 0.6).l(cx + s, cy + s * 0.2).q(cx + s, cy + s * 0.8, cx + s * 0.4, cy + s * 0.8).l(cx - s * 0.5, cy + s * 0.8);
g.l(cx - s * 0.5, cy + s * 0.4)
.l(cx - s, cy + s * 0.9)
.l(cx - s * 0.5, cy + s * 1.4)
.l(cx - s * 0.5, cy + s)
.l(cx + s * 0.6, cy + s)
.l(cx + s * 0.6, cy - s * 0.6)
.z();
}
"actionButtonMovie" => {
g.poly(&[(cx - s, cy - s * 0.6), (cx + s * 0.4, cy - s * 0.6), (cx + s * 0.4, cy + s * 0.6), (cx - s, cy + s * 0.6)]);
g.poly(&[(cx + s * 0.4, cy), (cx + s, cy - s * 0.5), (cx + s, cy + s * 0.5)]);
}
"actionButtonDocument" => {
g.poly(&[(cx - s * 0.7, cy - s), (cx + s * 0.3, cy - s), (cx + s * 0.7, cy - s * 0.6), (cx + s * 0.7, cy + s), (cx - s * 0.7, cy + s)]);
}
"actionButtonSound" => {
g.poly(&[
(cx - s, cy - s * 0.35),
(cx - s * 0.5, cy - s * 0.35),
(cx, cy - s),
(cx, cy + s),
(cx - s * 0.5, cy + s * 0.35),
(cx - s, cy + s * 0.35),
]);
}
_ => {}
}
Geometry {
paths: vec![fill(body), shade(g.take(), FillMode::DarkenLess)],
text_rect: Rect::new(0.0, 0.0, w, h),
handles: vec![],
sites: mid_sites(w, h),
}
}