Files
jyviko b34a0ad748 UI kit: the shared crate solidcraft-ui-kit (closes #14251) (#14492)
* Theme files: the built-in themes are host data

theme_files reads the built-in themes from a table the host installs
(install_builtin, once per process, like the icon set and the tab table)
instead of including ui-egui's generated table. SolidCraft keeps
generating its table from assets/styles/ui/themes and installs it with
theme::install_builtin_themes() in SolveApp::new, test_support::host_data
and both apps' start. builtin() is empty until then.

Tests that iterate the shipped themes now install the host data first,
so none of them passes on an empty list.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

* Kit tests: the ones that need SolidCraft's data are SolidCraft's

Before the kit moves into a crate of its own, its tests split by what
they need:

- Tests that read SolidCraft's shipped themes, tab table, icon set,
  fonts, view styles, expressions or panel runtime move to ui-egui:
  kit_host_tests.rs (actions, checks, fields, layout, navigation,
  panel), theme_files_tests.rs (26 theme-file tests, with the 1-bit
  checks and the original built-in ids), kit_gallery_tests.rs (the
  visual-style dropdown, now an app specimen) and
  navigation_bar_tests.rs (SolidCraft's slot catalogue), mounted from
  lib.rs. Bodies are unchanged apart from paths.
- The navigation bar component's own tests (plain data) are
  nav_bar_tests.rs beside nav_bar.rs.
- The kit gallery draws on the kit's test context (egui's default faces,
  the kit's catalog); check_elements takes the context, so SolidCraft's
  app specimens still use its fonts. The kit's dropdown_icons specimen
  shows plain options. Ribbon and history bar tests take their accent
  from the theme crate (TabAccent::for_ramp, the same value SolidCraft's
  MODEL and SKETCH tabs give).
- Settings search tests name their own page numbers (the same 2 and 3).
- SolidCraft's two-colour theme ids and the tab fixture are host test
  support (test_support::{is_two_colour, tab_fixture}); theme file
  fixtures shared by both sides are theme_files::fixtures; the raster
  helpers and the host window marker are the kit's test_support.

Items the moved tests reach are pub(crate) (theme_files' parse_color,
resolve_base, slot, ...; fields' literal and scrub helpers; layout's
selection_ink; the feature window's background path), and the gallery
coverage test exempts the parsers and accessor among them.

Path fixes: checks.rs paints through the kit's icons, blur_native names
the viewport GPU crate's Renderer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

* UI kit: the shared crate solidcraft-ui-kit (#14251, step 2)

The kit (crates/ui-egui/src/ui_kit/) and its components (ribbon, app bar,
history bar, navigation bar and its drawn bar nav_bar, view compass,
preferences window, start page, window chrome, frame, blur, theme files
and options) move with git mv into crates/ui-kit, a shared crate
(Class::Shared, [lints] workspace, licence, README). The kit's mod.rs is
the crate root; the components are modules beside it.

Dependencies: shared crates only (theme, ui-registry, ui-text, color,
viewport-gpu and viewport-egui for the blur backing), egui, egui-wgpu,
serde, serde_json, log, web-time, tiny-skia, arboard (desktop), muda
(macOS). `cargo xtask shared` builds and tests it on its own (288 tests).

Path fixes only, otherwise:
- In the kit, `crate::ui_kit::` is `crate::`; what was crate-visible is
  the crate's public API (pub(crate) -> pub), since SolidCraft uses it.
- ui-egui mounts the crate where the modules were (`pub use
  solidcraft_ui_kit as ui_kit`, `pub use solidcraft_ui_kit::{ribbon, ...}`),
  so SolidCraft's code and both apps keep their paths. The muda
  dependency moves with window_chrome.
- The kit's test fixtures SolidCraft's tests use (test_support, the
  gallery and its element! macro, theme_files::fixtures, the blur and
  panel fixtures) are behind a `test-support` feature, which ui-egui's
  dev-dependency turns on.
- SolidCraft's source guards (raw widgets, sliders, checkboxes,
  disclosures, colour and font literals, catalog literals, host tab
  names, command ids and message ids) read the kit crate's sources under
  the names they had in ui-egui (test_support::kit_files); a component's
  `crate::` paths are the kit's. They still fail on a SolidCraft tab name
  or message id put back into kit code.
- xtask's layer table and container exemption, docs/architecture.md,
  docs/layers.md, docs/ui-kit.md, the UI skill and the figure generator
  name the new paths.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

* UI kit: the whole-number settings field is public, as the Design page calls it

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

* UI kit: the whole-number field and the copy cell are public, as SolidCraft calls them

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

* UI kit: the view compass's tip text is a translated message

The compass built its hover text with a hard-coded English format string,
so it stayed English in every language. It now reads the whole sentence
from the kit's ui. vocabulary (ui.view_compass_tip, and
ui.view_compass_tip_snap with the Shift hint), with the axis as the
{axis} argument, the way the kit formats other text with arguments.

A host test hovers a tip in Japanese and expects the catalog's sentence;
on the old code it read the English text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

* Preferences: the colour vision sample is SolidCraft's, with a message id for Bends

The sample (fixed and projected sketch lines, axes, bends, draft and a
failed feature) and its names were in the kit, though only SolidCraft's
Interface page shows it. It moves beside the status palette sample in
prefs::figures; the kit keeps the figure painter, now public as
paint_colour_vision, and the host gallery draws the sample instead of
the kit's.

Its names read "Bends" through tr as if it were an id; it is now
ui.colour_vision_bends, with the catalogs' existing translations. A new
guard rejects a list of message ids that holds an English-label key in
the kit or the host; on the old code it reported ui_kit/preferences.rs:
["Bends"].

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

* UI kit: the navigation bar's layout is the kit's nav_bar_layout

measure, editor_layout and BarLayout laid out the kit's bar from kit
types and metrics but lived in ui-egui. They move to the public
nav_bar_layout module beside nav_bar and navigation_bar; the app's
wiring (canvas caps, placement in the shell's free region, slot views,
menus and commands) stays in navigation_bar_view.

The layout takes the slots the canvas shows as a predicate instead of
the app's NavCaps (which gains shows(slot) for the callers), and
reserves a menu value's width for any menu slot whose display is Icon
and value instead of naming visual_style; the catalogue's icon_menus
already keep the View menu icon-only, so the bar is unchanged. The
slot view uses the same rule. The layout tests stay in ui-egui, as
they use SolidCraft's slot catalogue; only their paths and the caps
argument change, no expected value.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M2MmcDrkcWhQeHS2K8

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 07:13:05 +00:00

590 lines
24 KiB
Python

#!/usr/bin/env python3
"""Compile docs/design/preferences/figures/*.svg into crates/ui-kit/src/preferences_figure_data.rs.
Each figure becomes a list of drawing operations (rectangles, circles, flattened polygons, text) in
the figure's own coordinates, with colours as roles (`Ink`) instead of hex values. A role is the
light/dark colour pair the board used at that position; docs/design/preferences/tokens.md says which
`theme::Tokens` field each role reads. Run from the repository root:
python3 tools/preferences-figures/generate.py
"""
import collections
import json
import math
import os
import re
import sys
import xml.etree.ElementTree as ET
ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
FIGS = os.path.join(ROOT, 'docs/design/preferences/figures')
OUT = os.path.join(ROOT, 'crates/ui-kit/src/preferences_figure_data.rs')
# Skipped: the Orientation figures already exist in ui_kit and stay as they are.
SKIP = {'orientation-z-up', 'orientation-y-up', 'style-shaded-edges'}
THEMES = ['theme-light', 'theme-dark', 'theme-gruvbox', 'theme-imported']
PAIRS = {
('#F7F8FA', '#1C1F26'): 'Ground',
('#6F7C8F', '#A3AEC2'): 'Line',
('#236EAD', '#8CBEF5'): 'Accent',
('#FFFFFF', '#6B7790'): 'Top',
('#4A5868', '#B4BBC8'): 'Dim',
('#E4E9F0', '#515B72'): 'Left',
('#C9D2DE', '#394256'): 'Right',
('#D5DBE3', '#3F4552'): 'Border',
('#C3CBD6', '#4A5262'): 'ControlBorder',
('#FFFFFF', '#2F343E'): 'Card',
('#1B2430', '#DEE2E8'): 'Text',
('#8A5300', '#E8C24A'): 'Reference',
('#2F6FD0', '#6CA8F7'): 'AxisZ',
('#D64545', '#F27A7A'): 'AxisX',
('#2E9E5B', '#62D48E'): 'AxisY',
('#FFFFFF', '#FFFFFF'): 'White',
('#B84A00', '#F0A27A'): 'Note',
('#FBEBDD', '#4A3326'): 'NoteFill',
('#2F7D5B', '#7FD1AE'): 'Ok',
('#C98A00', '#E8C24A'): 'Warn',
('#FFFFFF', '#1C1F26'): 'Control',
('#0072B2', '#56B4E9'): 'Cv0',
('#E69F00', '#F0C060'): 'Cv1',
('#E69F00', '#E69F00'): 'Cv1',
('#D55E00', '#F0A27A'): 'Cv2',
('#56B4E9', '#8CBEF5'): 'Cv3',
('#56B4E9', '#56B4E9'): 'Cv3',
('#CC79A7', '#CC79A7'): 'Cv4',
}
def num(v, d=0.0):
return d if v is None else float(re.match(r'-?[\d.]+(?:e-?\d+)?', v.strip()).group(0))
def parse_color(v):
"""(hex6 upper, alpha) or None for none/url."""
if v is None or v == 'none':
return None
v = v.strip()
if v.startswith('url('):
return ('url', re.search(r'#([\w-]+)', v).group(1))
m = re.fullmatch(r'#([0-9A-Fa-f]{3,8})', v)
if not m:
raise ValueError(v)
h = m.group(1)
if len(h) == 3:
h = ''.join(c * 2 for c in h)
a = 1.0
if len(h) == 8:
a = int(h[6:], 16) / 255.0
h = h[:6]
return ('#' + h.upper(), a)
def mat_mul(a, b):
return (a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3],
a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5])
def parse_transform(s):
m = (1, 0, 0, 1, 0, 0)
for name, args in re.findall(r'(\w+)\(([^)]*)\)', s or ''):
v = [float(x) for x in re.split(r'[ ,]+', args.strip())]
if name == 'translate':
t = (1, 0, 0, 1, v[0], v[1] if len(v) > 1 else 0)
elif name == 'scale':
t = (v[0], 0, 0, v[1] if len(v) > 1 else v[0], 0, 0)
elif name == 'matrix':
t = tuple(v)
else:
raise ValueError(name)
m = mat_mul(m, t)
return m
def ap(m, x, y):
return (m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5])
def flatten_path(d, m):
toks = re.findall(r'[MmLlHhVvZzAaQqCc]|-?[\d.]+(?:e-?\d+)?', d)
i = 0
subs = []
cur = None
x = y = sx = sy = 0.0
cmd = None
def nxt():
nonlocal i
v = float(toks[i])
i += 1
return v
def add(px, py):
cur.append(ap(m, px, py))
while i < len(toks):
if re.fullmatch(r'[A-Za-z]', toks[i]):
cmd = toks[i]
i += 1
if cmd in 'Zz':
if cur:
subs.append((cur, True))
cur = None
x, y = sx, sy
continue
c = cmd
if c in 'Mm':
if cur and len(cur) > 0:
subs.append((cur, False))
nx, ny = nxt(), nxt()
if c == 'm':
nx, ny = x + nx, y + ny
x, y = sx, sy = nx, ny
cur = []
add(x, y)
cmd = 'L' if c == 'M' else 'l'
elif c in 'Ll':
nx, ny = nxt(), nxt()
if c == 'l':
nx, ny = x + nx, y + ny
x, y = nx, ny
if cur is None:
cur = []
add(sx, sy)
add(x, y)
elif c in 'Hh':
nx = nxt()
x = x + nx if c == 'h' else nx
if cur is None:
cur = []
add(sx, sy)
add(x, y)
elif c in 'Vv':
ny = nxt()
y = y + ny if c == 'v' else ny
if cur is None:
cur = []
add(sx, sy)
add(x, y)
elif c in 'Qq':
a, b, e, f = nxt(), nxt(), nxt(), nxt()
if c == 'q':
a, b, e, f = x + a, y + b, x + e, y + f
for k in range(1, 13):
t = k / 12
add((1 - t) ** 2 * x + 2 * (1 - t) * t * a + t * t * e, (1 - t) ** 2 * y + 2 * (1 - t) * t * b + t * t * f)
x, y = e, f
elif c in 'Cc':
a, b, e, f, g, h = (nxt() for _ in range(6))
if c == 'c':
a, b, e, f, g, h = x + a, y + b, x + e, y + f, x + g, y + h
for k in range(1, 17):
t = k / 16
u = 1 - t
add(u ** 3 * x + 3 * u * u * t * a + 3 * u * t * t * e + t ** 3 * g, u ** 3 * y + 3 * u * u * t * b + 3 * u * t * t * f + t ** 3 * h)
x, y = g, h
elif c in 'Aa':
rx, ry, rot, la, sw, ex, ey = (nxt() for _ in range(7))
if c == 'a':
ex, ey = x + ex, y + ey
pts = arc(x, y, rx, ry, rot, int(la), int(sw), ex, ey)
for px, py in pts:
add(px, py)
x, y = ex, ey
else:
raise ValueError(c)
if cur:
subs.append((cur, False))
return subs
def arc(x1, y1, rx, ry, phi, fa, fs, x2, y2):
if rx == 0 or ry == 0:
return [(x2, y2)]
ph = math.radians(phi)
cp, sp = math.cos(ph), math.sin(ph)
dx, dy = (x1 - x2) / 2, (y1 - y2) / 2
x1p, y1p = cp * dx + sp * dy, -sp * dx + cp * dy
rx, ry = abs(rx), abs(ry)
lam = x1p ** 2 / rx ** 2 + y1p ** 2 / ry ** 2
if lam > 1:
rx *= math.sqrt(lam)
ry *= math.sqrt(lam)
num_ = rx ** 2 * ry ** 2 - rx ** 2 * y1p ** 2 - ry ** 2 * x1p ** 2
den = rx ** 2 * y1p ** 2 + ry ** 2 * x1p ** 2
co = math.sqrt(max(0, num_ / den)) * (-1 if fa == fs else 1)
cxp, cyp = co * rx * y1p / ry, -co * ry * x1p / rx
cx, cy = cp * cxp - sp * cyp + (x1 + x2) / 2, sp * cxp + cp * cyp + (y1 + y2) / 2
def ang(ux, uy, vx, vy):
a = math.atan2(ux * vy - uy * vx, ux * vx + uy * vy)
return a
th1 = ang(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
dth = ang((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry)
if not fs and dth > 0:
dth -= 2 * math.pi
if fs and dth < 0:
dth += 2 * math.pi
n = max(6, int(abs(dth) / (math.pi / 16)))
out = []
for k in range(1, n + 1):
t = th1 + dth * k / n
out.append((cp * rx * math.cos(t) - sp * ry * math.sin(t) + cx, sp * rx * math.cos(t) + cp * ry * math.sin(t) + cy))
return out
def rr_poly(x, y, w, h, r, m, seg=6):
pts = []
if r <= 0:
for px, py in ((x, y), (x + w, y), (x + w, y + h), (x, y + h)):
pts.append(ap(m, px, py))
return pts
r = min(r, w / 2, h / 2)
for cx, cy, a0 in ((x + w - r, y + r, -90), (x + w - r, y + h - r, 0), (x + r, y + h - r, 90), (x + r, y + r, 180)):
for k in range(seg + 1):
a = math.radians(a0 + 90 * k / seg)
pts.append(ap(m, cx + r * math.cos(a), cy + r * math.sin(a)))
return pts
class Walker:
"""Walks one SVG into a flat op list; colours stay as hex until paired."""
def __init__(self, root):
self.defs = {}
self.clips = {}
self.ops = []
self.root = root
@staticmethod
def tag(e):
return e.tag.split('}')[-1]
def collect(self, e):
for c in e:
t = self.tag(c)
if t in ('linearGradient', 'radialGradient'):
self.defs[c.get('id')] = c
elif t == 'clipPath':
self.clips[c.get('id')] = c
elif t == 'defs':
self.collect(c)
else:
self.collect(c)
def run(self):
self.collect(self.root)
vb = [float(v) for v in self.root.get('viewBox').split()]
self.size = (vb[2], vb[3])
self.walk(self.root, (1, 0, 0, 1, -vb[0], -vb[1]), None, root=True)
return self.ops
def style(self, e, mscale):
f = parse_color(e.get('fill', '#000000'))
s = parse_color(e.get('stroke'))
fo = num(e.get('fill-opacity'), 1.0) * num(e.get('opacity'), 1.0)
so = num(e.get('stroke-opacity'), 1.0) * num(e.get('opacity'), 1.0)
sw = num(e.get('stroke-width'), 1.0) * mscale if s else 0
dash = None
if e.get('stroke-dasharray'):
dv = [float(v) for v in re.split(r'[ ,]+', e.get('stroke-dasharray').strip())]
if len(dv) >= 2 and dv[1] > 0:
dash = (dv[0] * mscale, dv[1] * mscale)
round_cap = e.get('stroke-linecap') == 'round'
return f, fo, s, so, sw, dash, round_cap
def walk(self, e, m, clip, root=False):
for c in e:
t = self.tag(c)
if t in ('defs', 'linearGradient', 'radialGradient', 'clipPath', 'stop'):
continue
mc = m
if t == 'svg':
x, y = num(c.get('x'), 0), num(c.get('y'), 0)
w, h = num(c.get('width')), num(c.get('height'))
vb = [float(v) for v in c.get('viewBox').split()]
mc = mat_mul(m, (1, 0, 0, 1, x, y))
mc = mat_mul(mc, (w / vb[2], 0, 0, h / vb[3], -vb[0] * w / vb[2], -vb[1] * h / vb[3]))
self.collect_clips(c)
# A nested svg clips its content to its own viewport.
self.ops.append(('clip', rr_poly(x, y, w, h, 0, m)))
self.walk(c, mc, clip)
self.ops.append(('unclip',))
continue
if t == 'g':
mc = mat_mul(m, parse_transform(c.get('transform')))
cl = clip
if c.get('clip-path'):
cid = re.search(r'#([\w-]+)', c.get('clip-path')).group(1)
cp = self.clips[cid]
pts = self.clip_points(cp, mc)
self.ops.append(('clip', pts))
self.walk(c, mc, cl)
self.ops.append(('unclip',))
else:
self.walk(c, mc, cl)
continue
if c.get('transform'):
mc = mat_mul(m, parse_transform(c.get('transform')))
det = abs(mc[0] * mc[3] - mc[1] * mc[2])
ms = math.sqrt(det)
f, fo, s, so, sw, dash, rc = self.style(c, ms)
axis = abs(mc[1]) < 1e-9 and abs(mc[2]) < 1e-9
if t == 'rect':
x, y, w, h = num(c.get('x'), 0), num(c.get('y'), 0), num(c.get('width')), num(c.get('height'))
r = num(c.get('rx'), 0)
if f and f[0] == 'url' and f[1] in self.defs:
g = self.defs[f[1]]
stops = [(num(st.get('offset')), parse_color(st.get('stop-color'))[0]) for st in g]
self.ops.append(('poly', rr_poly(x, y, w, h, r, mc), True, ('grad', stops[0][1], stops[-1][1], ap(mc, 0, y)[1], ap(mc, 0, y + h)[1]), fo, s, so, sw, dash, rc))
elif axis and mc[0] > 0 and mc[3] > 0:
p0 = ap(mc, x, y)
self.ops.append(('rect', p0[0], p0[1], w * mc[0], h * mc[3], r * mc[0], f, fo, s, so, sw, dash))
else:
self.ops.append(('poly', rr_poly(x, y, w, h, r, mc), True, f and ('solid', f), fo, s, so, sw, dash, rc))
elif t == 'circle':
cx, cy, r = num(c.get('cx')), num(c.get('cy')), num(c.get('r'))
if abs(mc[1]) < 1e-9 and abs(mc[2]) < 1e-9 and abs(mc[0] - mc[3]) < 1e-9:
p0 = ap(mc, cx, cy)
self.ops.append(('circle', p0[0], p0[1], r * mc[0], f, fo, s, so, sw, dash))
else:
pts = [ap(mc, cx + r * math.cos(a * math.pi / 12), cy + r * math.sin(a * math.pi / 12)) for a in range(24)]
self.ops.append(('poly', pts, True, f and ('solid', f), fo, s, so, sw, dash, rc))
elif t == 'ellipse':
cx, cy, rx, ry = num(c.get('cx')), num(c.get('cy')), num(c.get('rx')), num(c.get('ry'))
if f and f[0] == 'url':
g = self.defs[f[1]]
stops = [num(st.get('stop-opacity'), 1.0) for st in g]
p0 = ap(mc, cx, cy)
self.ops.append(('glow', p0[0], p0[1], rx * mc[0], ry * mc[3], stops[0] * fo))
else:
pts = [ap(mc, cx + rx * math.cos(a * math.pi / 16), cy + ry * math.sin(a * math.pi / 16)) for a in range(32)]
self.ops.append(('poly', pts, True, f and ('solid', f), fo, s, so, sw, dash, rc))
elif t in ('polygon', 'polyline'):
nums = [float(v) for v in re.split(r'[ ,]+', c.get('points').strip())]
pts = [ap(mc, nums[k], nums[k + 1]) for k in range(0, len(nums), 2)]
self.ops.append(('poly', pts, t == 'polygon', f and ('solid', f), fo, s, so, sw, dash, rc))
elif t == 'path' and s and s[0] == 'url':
g = self.defs[s[1]]
stops = [(num(st.get('offset')), parse_color(st.get('stop-color')), num(st.get('stop-opacity'), 1.0)) for st in g]
for pts, closed in flatten_path(c.get('d'), mc):
(x0, y0), (x1, y1) = pts[0], pts[-1]
self.ops.append(('gline', x0, y0, x1, y1, stops[0][1], stops[0][2], stops[-1][2], sw))
elif t == 'path':
for pts, closed in flatten_path(c.get('d'), mc):
if len(pts) >= 2:
fill = f and ('solid', f) if (closed or len(pts) >= 3) else None
self.ops.append(('poly', pts, closed, fill, fo, s, so, sw, dash, rc))
elif t == 'text':
x, y = num(c.get('x')), num(c.get('y'))
p0 = ap(mc, x, y)
self.ops.append(('text', p0[0], p0[1], num(c.get('font-size')) * ms, c.get('text-anchor', 'start'), f, fo, ''.join(c.itertext()), num(c.get('font-weight'), 400) >= 600))
elif t == 'g':
pass
else:
raise ValueError('unhandled ' + t)
def collect_clips(self, e):
for c in e:
if self.tag(c) == 'clipPath':
self.clips[c.get('id')] = c
def clip_points(self, cp, m):
out = []
for c in cp:
t = self.tag(c)
if t == 'path':
for pts, _ in flatten_path(c.get('d'), m):
out.extend(pts)
elif t == 'rect':
out.extend(rr_poly(num(c.get('x'), 0), num(c.get('y'), 0), num(c.get('width')), num(c.get('height')), 0, m))
else:
raise ValueError('clip ' + t)
return out
def load(name, theme):
tree = ET.parse(os.path.join(FIGS, '%s.%s.svg' % (name, theme)))
w = Walker(tree.getroot())
return w.run(), w.size
def color_fields(op):
"""Positions of (colour, alpha) tuples in an op, as (index) list."""
k = op[0]
if k == 'rect':
return [6, 9]
if k == 'circle':
return [4, 7]
if k == 'poly':
return [None, 5]
if k == 'text':
return [5]
return []
def ink_of(l, d, slots=None):
if slots is not None:
key = tuple(slots)
if key not in SLOTS:
SLOTS[key] = len(SLOTS)
return 'Slot(%d)' % SLOTS[key]
if l == '#000000':
return 'Black'
r = PAIRS.get((l, d))
if r is None:
raise KeyError((l, d))
return r
SLOTS = collections.OrderedDict()
def f32(v):
s = ('%.3f' % v).rstrip('0').rstrip('.')
if s in ('', '-0'):
s = '0'
return s + ('' if '.' in s else '.0')
def paint(l, d, alpha, slots=None):
"""Option<Paint> source."""
if l is None:
return 'None'
return 'Some(P { ink: Ink::%s, a: %s })' % (ink_of(l[0], d[0], slots), f32(alpha))
def line(sl, sd, so, sw, dash, rc, slots=None):
if sl is None or sw <= 0:
return 'None'
ds = dash or (0, 0)
return 'Some(L { ink: Ink::%s, a: %s, w: %s, dash: [%s, %s], round: %s })' % (ink_of(sl[0], sd[0], slots), f32(so), f32(sw), f32(ds[0]), f32(ds[1]), 'true' if rc else 'false')
def emit(name, ops_l, ops_d, slotsets=None):
out = []
assert len(ops_l) == len(ops_d), (name, len(ops_l), len(ops_d))
for idx, (a, b) in enumerate(zip(ops_l, ops_d)):
assert a[0] == b[0], (name, idx, a[0], b[0])
sl = None
if slotsets is not None:
sl = [s[idx] for s in slotsets]
k = a[0]
if k == 'rect':
_, x, y, w, h, r, f, fo, s, so, sw, dash = a
_, _, _, _, _, _, fd, _, sd, _, _, _ = b
fs = fsl = None
if slotsets is not None:
fs = [t[6][0] if t[6] else None for t in sl]
ss = [t[8][0] if t[8] else None for t in sl]
out.append('Op::Rect { r: [%s, %s, %s, %s], radius: %s, fill: %s, line: %s }' % (
f32(x), f32(y), f32(w), f32(h), f32(r),
paint(f, fd, fo, fs if slotsets is not None and f else None),
line(s, sd, so, sw, dash, False, ss if slotsets is not None and s else None)))
elif k == 'circle':
_, x, y, r, f, fo, s, so, sw, dash = a
fd, sd = b[4], b[6]
fs = ss = None
if slotsets is not None:
fs = [t[4][0] if t[4] else None for t in sl]
ss = [t[6][0] if t[6] else None for t in sl]
out.append('Op::Circle { c: [%s, %s, %s], fill: %s, line: %s }' % (
f32(x), f32(y), f32(r), paint(f, fd, fo, fs if f and slotsets is not None else None),
line(s, sd, so, sw, dash, False, ss if s and slotsets is not None else None)))
elif k == 'poly':
_, pts, closed, fill, fo, s, so, sw, dash, rc = a
fd, sd = b[3], b[5]
pts_s = ', '.join('[%s, %s]' % (f32(px), f32(py)) for px, py in pts)
fs = ss = None
if slotsets is not None:
fs = [t[3][1][0] if t[3] and t[3][0] == 'solid' else None for t in sl]
ss = [t[5][0] if t[5] else None for t in sl]
grad = 'None'
fill_s = 'None'
if fill and fill[0] == 'grad':
_, top, bot, y0, y1 = fill
gd = b[3]
if slotsets is not None:
tops = [t[3][1] for t in sl]
bots = [t[3][2] for t in sl]
grad = 'Some(G { top: Ink::%s, bottom: Ink::%s, y: [%s, %s] })' % (ink_of(top, gd[1], tops), ink_of(bot, gd[2], bots), f32(y0), f32(y1))
else:
grad = 'Some(G { top: Ink::%s, bottom: Ink::%s, y: [%s, %s] })' % (ink_of(top, gd[1]), ink_of(bot, gd[2]), f32(y0), f32(y1))
elif fill:
fill_s = paint(fill[1], fd[1], fo, fs if slotsets is not None else None)
out.append('Op::Poly { pts: &[%s], closed: %s, fill: %s, grad: %s, line: %s }' % (
pts_s, 'true' if closed else 'false', fill_s, grad,
line(s, sd, so, sw, dash, rc, ss if s and slotsets is not None else None)))
elif k == 'gline':
_, x0, y0, x1, y1, col, a0, a1, sw = a
out.append('Op::Gradient { pts: [[%s, %s], [%s, %s]], w: %s, ink: Ink::%s, a: [%s, %s] }' % (
f32(x0), f32(y0), f32(x1), f32(y1), f32(sw), ink_of(col[0], b[5][0]), f32(a0), f32(a1)))
elif k == 'glow':
_, x, y, rx, ry, al = a
out.append('Op::Glow { c: [%s, %s, %s, %s], a: %s }' % (f32(x), f32(y), f32(rx), f32(ry), f32(al)))
elif k == 'text':
_, x, y, size, anchor, f, fo, txt, bold = a
fd = b[5]
fs = [t[5][0] for t in sl] if slotsets is not None else None
out.append('Op::Text { at: [%s, %s], size: %s, anchor: %d, ink: Ink::%s, a: %s, s: %s, bold: %s }' % (
f32(x), f32(y), f32(size), {'start': 0, 'middle': 1, 'end': 2}[anchor], ink_of(f[0], fd[0], fs), f32(fo), '"' + txt.replace('\\', '\\\\').replace('"', '\\"') + '"', 'true' if bold else 'false'))
elif k == 'clip':
pts_s = ', '.join('[%s, %s]' % (f32(px), f32(py)) for px, py in a[1])
out.append('Op::Clip(&[%s])' % pts_s)
elif k == 'unclip':
out.append('Op::Unclip')
else:
raise ValueError(k)
return out
def const_name(n):
return n.upper().replace('-', '_')
def fn_name(n):
return 'paint_' + n.replace('-', '_')
def main():
man = sorted({f.split('.')[0] for f in os.listdir(FIGS) if f.endswith('.svg')})
parts = []
parts.append('//! Generated by `tools/preferences-figures/generate.py` from `docs/design/preferences/figures/*.svg`.\n'
'//! Do not edit by hand: change the SVG and run the script again.\n'
'#![allow(clippy::approx_constant, clippy::excessive_precision)]\n'
'use super::preferences_figure_ops::{Figure, G, Ink, L, Op, P};\n')
fns = []
names = []
for name in man:
if name in SKIP or name.startswith('theme-'):
continue
ol, size = load(name, 'light')
od, size2 = load(name, 'dark')
assert size == size2
ops = emit(name, ol, od)
parts.append('pub(super) const %s: Figure = Figure { size: [%s, %s], ops: &[\n %s,\n] };\n' % (const_name(name), f32(size[0]), f32(size[1]), ',\n '.join(ops)))
names.append(name)
# theme thumbnail: slots from the four themes
loaded = [load(t, 'light')[0] for t in THEMES]
size = load('theme-light', 'light')[1]
ops = emit('theme-thumbnail', loaded[0], loaded[0], slotsets=loaded)
parts.append('pub(super) const THEME_THUMBNAIL: Figure = Figure { size: [%s, %s], ops: &[\n %s,\n] };\n' % (f32(size[0]), f32(size[1]), ',\n '.join(ops)))
slot_table = ['// Theme thumbnail slots (light, dark, gruvbox, imported sample colours):']
for key, i in SLOTS.items():
slot_table.append('// %d: %s' % (i, ' '.join(str(k) for k in key)))
parts.append('\n'.join(slot_table) + '\n')
parts.append('use egui::{Painter, Rect};\nuse super::preferences_figure_ops::paint;\n')
for n in names:
if n == 'mouse-mapping':
parts.append('/// The mouse figure, with its own slightly heavier lettering.\npub(crate) fn paint_mouse_mapping(p: &Painter, rect: Rect) {\n super::preferences_figure_ops::paint_mouse(p, rect);\n}\n')
continue
parts.append('/// The `%s` figure of `docs/design/preferences/figures`.\npub(crate) fn %s(p: &Painter, rect: Rect) {\n paint(p, rect, &%s, None, None);\n}\n' % (n, fn_name(n), const_name(n)))
parts.append('/// Every figure painter by file name, for the gallery and the tests.\npub(crate) const FIGURES: &[(&str, [f32; 2], fn(&Painter, Rect))] = &[\n%s];\n' % ''.join(' ("%s", %s.size, %s),\n' % (n, const_name(n), fn_name(n)) for n in names))
open(OUT, 'w', encoding='utf8', newline='\n').write('\n'.join(parts))
print('figures', len(names), 'slots', len(SLOTS), file=sys.stderr)
if __name__ == '__main__':
main()