mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 22:14:30 +00:00
- framework-01-w2: repair 1 - framework-01-w2: RowStyle and ShapeTokens::rows go (size.rs, lib.rs rows of the sheet) - framework-01-w2: list rows: option rows rounded, others square; layer rules in every theme (show.rs row of the sheet) - framework-01-w2: review fixes (review-1) - framework-01-w2: review fixes (review-1, files the rulings name) - framework-01-w2: the escaped-sweep trial follows the sweep rule: only the eyes it switched are restored (fw01 round 2) - framework-01-w2: a drop past the last item in reading order lands at the end, in every layout (fwcw round 3)
276 lines
10 KiB
Rust
276 lines
10 KiB
Rust
//! Token text dump: every token of a resolved [`Tokens`] as ordered `key = value` lines.
|
|
//!
|
|
//! The struct destructuring is exhaustive on purpose: a new token doesn't compile until it is
|
|
//! dumped.
|
|
|
|
use std::fmt::Write as _;
|
|
|
|
use crate::{
|
|
BarSizes, ColorToken, ControlSizes, DialogSizes, DockColumnSizes, Easing, Edge, Elevation, ElevationTokens, FloatSizes, FontSlot, Gaps,
|
|
HandleSizes, HitSizes, IconSizes, Insets, KnobShape, LengthSizes, Motion, MotionTokens, NoticeSizes, Pads, PaneSizes, PlotSizes, RadiusSet,
|
|
RailSizes, RampSizes, Rgba, RowSizes, RulerSizes, RulerTickSizes, ShapeTokens, SizeTokens, SpaceTokens, StorySizes, StrokeTokens, ThumbSamples,
|
|
ThumbSizes, Tokens, TypeStyle, TypeTokens, WellShape, WindowSizes,
|
|
};
|
|
|
|
/// The text of every token, one `key = value` line each, in a fixed order.
|
|
pub fn tokens_text(tokens: &Tokens) -> String {
|
|
let mut out = Lines::default();
|
|
|
|
let Tokens { color, shape, space, size, stroke, typography, elevation, motion } = tokens;
|
|
for &token in ColorToken::ALL {
|
|
out.line(token.path(), hex(color.get(token)));
|
|
}
|
|
shape_lines(&mut out, shape);
|
|
space_lines(&mut out, space);
|
|
size_lines(&mut out, size);
|
|
stroke_lines(&mut out, stroke);
|
|
type_lines(&mut out, typography);
|
|
elevation_lines(&mut out, elevation);
|
|
motion_lines(&mut out, motion);
|
|
out.0
|
|
}
|
|
|
|
/// Ordered `key = value` lines.
|
|
#[derive(Default)]
|
|
struct Lines(String);
|
|
|
|
impl Lines {
|
|
fn line(&mut self, key: &str, value: impl std::fmt::Display) {
|
|
let _ = writeln!(self.0, "{key} = {value}");
|
|
}
|
|
}
|
|
|
|
/// `#rrggbbaa`, alpha always written.
|
|
fn hex(c: Rgba) -> String {
|
|
let [r, g, b, a] = c.0;
|
|
format!("#{r:02x}{g:02x}{b:02x}{a:02x}")
|
|
}
|
|
|
|
/// A length with up to two decimals.
|
|
fn len(v: f32) -> String {
|
|
decimals(v, 2)
|
|
}
|
|
|
|
/// `v` with up to `places` decimals, trailing zeros dropped.
|
|
fn decimals(v: f32, places: usize) -> String {
|
|
let s = format!("{v:.places$}");
|
|
let s = if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.') } else { &s };
|
|
if s == "-0" { "0".to_owned() } else { s.to_owned() }
|
|
}
|
|
|
|
fn edge(e: Edge) -> String {
|
|
match e {
|
|
Edge::Flat => "flat".to_owned(),
|
|
Edge::Bevel { light, dark, width } => format!("bevel {} {} {}", hex(light), hex(dark), len(width)),
|
|
}
|
|
}
|
|
|
|
fn shape_lines(out: &mut Lines, shape: &ShapeTokens) {
|
|
let ShapeTokens { radius, edge: e, knob, wells } = shape;
|
|
let RadiusSet { sm, control, surface, window, panel, button, pill } = radius;
|
|
for (k, v) in [("sm", sm), ("control", control), ("surface", surface), ("window", window), ("panel", panel), ("button", button), ("pill", pill)] {
|
|
out.line(&format!("shape.radius.{k}"), len(*v));
|
|
}
|
|
out.line("shape.edge", edge(*e));
|
|
|
|
out.line("shape.knob", if *knob == KnobShape::Round { "round" } else { "tab" });
|
|
out.line("shape.wells", if *wells == WellShape::Square { "square" } else { "round" });
|
|
}
|
|
|
|
fn stroke_lines(out: &mut Lines, stroke: &StrokeTokens) {
|
|
let StrokeTokens { thin, medium, thick, heavy, dash, dash_gap, icon } = stroke;
|
|
for (k, v) in [("thin", thin), ("medium", medium), ("thick", thick), ("heavy", heavy), ("dash", dash), ("dash_gap", dash_gap)] {
|
|
out.line(&format!("stroke.{k}"), len(*v));
|
|
}
|
|
out.line("stroke.icon", decimals(*icon, 4));
|
|
}
|
|
|
|
fn space_lines(out: &mut Lines, space: &SpaceTokens) {
|
|
let SpaceTokens { gap, pad, inset } = space;
|
|
let Gaps { tight, inline, row, stack, item, section, card_column, card_row } = gap;
|
|
for (k, v) in [
|
|
("tight", tight),
|
|
("inline", inline),
|
|
("row", row),
|
|
("stack", stack),
|
|
("item", item),
|
|
("section", section),
|
|
("card_column", card_column),
|
|
("card_row", card_row),
|
|
] {
|
|
out.line(&format!("space.gap.{k}"), len(*v));
|
|
}
|
|
let Pads { control, regular, roomy, chip, segment } = pad;
|
|
for (k, v) in [("control", control), ("regular", regular), ("roomy", roomy), ("chip", chip), ("segment", segment)] {
|
|
out.line(&format!("space.pad.{k}"), len(*v));
|
|
}
|
|
let Insets { screen } = inset;
|
|
out.line("space.inset.screen", len(*screen));
|
|
}
|
|
|
|
fn size_lines(out: &mut Lines, size: &SizeTokens) {
|
|
let SizeTokens {
|
|
control,
|
|
icon,
|
|
rail,
|
|
bar,
|
|
panel_header,
|
|
popup_min,
|
|
scroll_fade,
|
|
thumb: thumbs,
|
|
handle,
|
|
hit,
|
|
checker,
|
|
plot,
|
|
length,
|
|
row,
|
|
groove,
|
|
ramp,
|
|
pointer_tip,
|
|
float,
|
|
window,
|
|
pane,
|
|
ruler,
|
|
dock,
|
|
notice,
|
|
dialog,
|
|
story,
|
|
} = size;
|
|
let ControlSizes { sm, md } = control;
|
|
out.line("size.control.sm", len(*sm));
|
|
out.line("size.control.md", len(*md));
|
|
let IconSizes { sm, md, lg, glyph_sm, glyph_md } = icon;
|
|
out.line("size.icon.sm", len(*sm));
|
|
out.line("size.icon.md", len(*md));
|
|
out.line("size.icon.lg", len(*lg));
|
|
out.line("size.icon.glyph_sm", len(*glyph_sm));
|
|
out.line("size.icon.glyph_md", len(*glyph_md));
|
|
let RailSizes { width, button } = rail;
|
|
out.line("size.rail.width", len(*width));
|
|
out.line("size.rail.button", len(*button));
|
|
let BarSizes { title, tab, status, options, options_narrow } = bar;
|
|
for (k, v) in [("title", title), ("tab", tab), ("status", status), ("options", options), ("options_narrow", options_narrow)] {
|
|
out.line(&format!("size.bar.{k}"), len(*v));
|
|
}
|
|
out.line("size.panel_header", len(*panel_header));
|
|
out.line("size.popup_min", len(*popup_min));
|
|
out.line("size.scroll_fade", len(*scroll_fade));
|
|
let ThumbSizes { sm, md, lg, card, sample } = thumbs;
|
|
out.line("size.thumb.sm", len(*sm));
|
|
out.line("size.thumb.md", len(*md));
|
|
out.line("size.thumb.lg", len(*lg));
|
|
out.line("size.thumb.card", len(*card));
|
|
let ThumbSamples { sm, md, lg } = sample;
|
|
out.line("size.thumb.sample.sm", len(*sm));
|
|
out.line("size.thumb.sample.md", len(*md));
|
|
out.line("size.thumb.sample.lg", len(*lg));
|
|
let HandleSizes { sm, md, ring } = handle;
|
|
out.line("size.handle.sm", len(*sm));
|
|
out.line("size.handle.md", len(*md));
|
|
out.line("size.handle.ring", len(*ring));
|
|
let HitSizes { slop, target, edge } = hit;
|
|
out.line("size.hit.slop", len(*slop));
|
|
out.line("size.hit.target", len(*target));
|
|
out.line("size.hit.edge", len(*edge));
|
|
out.line("size.checker", len(*checker));
|
|
let PlotSizes { width, height } = plot;
|
|
out.line("size.plot.width", len(*width));
|
|
out.line("size.plot.height", len(*height));
|
|
let LengthSizes { field, track, short, number } = length;
|
|
out.line("size.length.field.sm", len(field.sm));
|
|
out.line("size.length.field.md", len(field.md));
|
|
out.line("size.length.track", len(*track));
|
|
out.line("size.length.short", len(*short));
|
|
out.line("size.length.number.sm", len(number.sm));
|
|
out.line("size.length.number.md", len(number.md));
|
|
let RowSizes { text } = row;
|
|
out.line("size.row.text", len(*text));
|
|
out.line("size.groove", len(*groove));
|
|
let RampSizes { bar, groove: ramp_groove } = ramp;
|
|
out.line("size.ramp.bar", len(*bar));
|
|
out.line("size.ramp.groove", len(*ramp_groove));
|
|
out.line("size.pointer_tip.x", len(pointer_tip.x));
|
|
out.line("size.pointer_tip.y", len(pointer_tip.y));
|
|
let FloatSizes { width, height } = float;
|
|
out.line("size.float.width", len(*width));
|
|
out.line("size.float.height", len(*height));
|
|
let WindowSizes { cascade } = window;
|
|
out.line("size.window.cascade", len(*cascade));
|
|
let PaneSizes { least } = pane;
|
|
out.line("size.pane.least", len(*least));
|
|
let RulerSizes { tick } = ruler;
|
|
let RulerTickSizes { mid } = tick;
|
|
out.line("size.ruler.tick.mid", len(*mid));
|
|
let DockColumnSizes { column } = dock;
|
|
out.line("size.dock.column", len(*column));
|
|
let NoticeSizes { width } = notice;
|
|
out.line("size.notice.width", len(*width));
|
|
let DialogSizes { least, wrap, button, side_button } = dialog;
|
|
out.line("size.dialog.least", len(*least));
|
|
out.line("size.dialog.wrap", len(*wrap));
|
|
out.line("size.dialog.button", len(*button));
|
|
out.line("size.dialog.side_button", len(*side_button));
|
|
let StorySizes { height, width_min, width_max } = story;
|
|
out.line("size.story.height", len(*height));
|
|
out.line("size.story.width_min", len(*width_min));
|
|
out.line("size.story.width_max", len(*width_max));
|
|
}
|
|
|
|
fn slot(s: FontSlot) -> &'static str {
|
|
match s {
|
|
FontSlot::Ui => "ui",
|
|
FontSlot::UiSemibold => "ui_semibold",
|
|
FontSlot::Mono => "mono",
|
|
}
|
|
}
|
|
|
|
fn type_lines(out: &mut Lines, t: &TypeTokens) {
|
|
let TypeTokens { caption, label, body, body_strong, title, heading, body_large, mono, display } = t;
|
|
let roles = [
|
|
("caption", caption),
|
|
("label", label),
|
|
("body", body),
|
|
("body_strong", body_strong),
|
|
("title", title),
|
|
("heading", heading),
|
|
("body_large", body_large),
|
|
("mono", mono),
|
|
("display", display),
|
|
];
|
|
for (k, style) in roles {
|
|
let TypeStyle { size, line_height, font } = style;
|
|
out.line(&format!("typography.{k}.size"), len(*size));
|
|
out.line(&format!("typography.{k}.line_height"), len(*line_height));
|
|
out.line(&format!("typography.{k}.font"), slot(*font));
|
|
}
|
|
}
|
|
|
|
fn elevation_lines(out: &mut Lines, e: &ElevationTokens) {
|
|
let ElevationTokens { popup, floating, knob } = e;
|
|
for (k, level) in [("popup", popup), ("floating", floating), ("knob", knob)] {
|
|
let Elevation { offset: [x, y], blur, spread, alpha } = level;
|
|
out.line(&format!("elevation.{k}.offset"), format!("{} {}", len(*x), len(*y)));
|
|
out.line(&format!("elevation.{k}.blur"), len(*blur));
|
|
out.line(&format!("elevation.{k}.spread"), len(*spread));
|
|
out.line(&format!("elevation.{k}.alpha"), decimals(*alpha, 3));
|
|
}
|
|
}
|
|
|
|
fn easing(e: Easing) -> &'static str {
|
|
match e {
|
|
Easing::Standard => "standard",
|
|
Easing::Enter => "enter",
|
|
Easing::Exit => "exit",
|
|
}
|
|
}
|
|
|
|
fn motion_lines(out: &mut Lines, m: &MotionTokens) {
|
|
let MotionTokens { hover, open, r#move, caret, outline, reduced } = m;
|
|
for (k, motion) in [("hover", hover), ("open", open), ("move", r#move), ("caret", caret), ("outline", outline)] {
|
|
let Motion { millis, easing: e } = motion;
|
|
out.line(&format!("motion.{k}.millis"), millis);
|
|
out.line(&format!("motion.{k}.easing"), easing(*e));
|
|
}
|
|
out.line("motion.reduced", reduced);
|
|
}
|