mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 05:14:24 +00:00
237 lines
7.2 KiB
Rust
237 lines
7.2 KiB
Rust
//! Primitive scales: space, radius, stroke, elevation, motion and opacity.
|
|
//!
|
|
//! Lengths are in logical pixels.
|
|
|
|
/// The spacing scale; semantic gaps and paddings pick from it.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
pub enum Space {
|
|
/// 0 px.
|
|
S0,
|
|
/// 2 px.
|
|
S2,
|
|
/// 4 px.
|
|
S4,
|
|
/// 6 px.
|
|
S6,
|
|
/// 8 px.
|
|
S8,
|
|
/// 12 px.
|
|
S12,
|
|
/// 16 px.
|
|
S16,
|
|
/// 20 px.
|
|
S20,
|
|
/// 24 px.
|
|
S24,
|
|
/// 32 px.
|
|
S32,
|
|
}
|
|
|
|
impl Space {
|
|
/// Every step, smallest first.
|
|
pub const ALL: [Space; 10] = [Space::S0, Space::S2, Space::S4, Space::S6, Space::S8, Space::S12, Space::S16, Space::S20, Space::S24, Space::S32];
|
|
|
|
/// The size in logical pixels.
|
|
pub const fn px(self) -> f32 {
|
|
match self {
|
|
Space::S0 => 0.0,
|
|
Space::S2 => 2.0,
|
|
Space::S4 => 4.0,
|
|
Space::S6 => 6.0,
|
|
Space::S8 => 8.0,
|
|
Space::S12 => 12.0,
|
|
Space::S16 => 16.0,
|
|
Space::S20 => 20.0,
|
|
Space::S24 => 24.0,
|
|
Space::S32 => 32.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The corner-radius scale.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
pub enum Radius {
|
|
/// Square corners.
|
|
R0,
|
|
/// 2 px.
|
|
R2,
|
|
/// 3 px.
|
|
R3,
|
|
/// 4 px.
|
|
R4,
|
|
/// 6 px.
|
|
R6,
|
|
/// 8 px.
|
|
R8,
|
|
/// 12 px.
|
|
R12,
|
|
/// Fully rounded (pill or circle).
|
|
Full,
|
|
}
|
|
|
|
impl Radius {
|
|
/// Every step, smallest first.
|
|
pub const ALL: [Radius; 8] = [Radius::R0, Radius::R2, Radius::R3, Radius::R4, Radius::R6, Radius::R8, Radius::R12, Radius::Full];
|
|
|
|
/// Radius in logical pixels. `Full` is 999, larger than any control, so renderers that clamp
|
|
/// the radius to half the shortest side get a pill.
|
|
pub const fn px(self) -> f32 {
|
|
match self {
|
|
Radius::R0 => 0.0,
|
|
Radius::R2 => 2.0,
|
|
Radius::R3 => 3.0,
|
|
Radius::R4 => 4.0,
|
|
Radius::R6 => 6.0,
|
|
Radius::R8 => 8.0,
|
|
Radius::R12 => 12.0,
|
|
Radius::Full => 999.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The line-width scale.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
pub enum Stroke {
|
|
/// One physical pixel, whatever the display scale. Resolve with [`Stroke::width`].
|
|
Hairline,
|
|
/// 1 logical px.
|
|
W1,
|
|
/// 1.5 logical px.
|
|
W1_5,
|
|
/// 2 logical px.
|
|
W2,
|
|
/// 3 logical px.
|
|
W3,
|
|
}
|
|
|
|
impl Stroke {
|
|
/// Every step, thinnest first.
|
|
pub const ALL: [Stroke; 5] = [Stroke::Hairline, Stroke::W1, Stroke::W1_5, Stroke::W2, Stroke::W3];
|
|
|
|
/// Width in logical pixels at `pixels_per_point` physical pixels per logical pixel.
|
|
pub fn width(self, pixels_per_point: f32) -> f32 {
|
|
match self {
|
|
Stroke::Hairline => 1.0 / pixels_per_point.max(f32::EPSILON),
|
|
Stroke::W1 => 1.0,
|
|
Stroke::W1_5 => 1.5,
|
|
Stroke::W2 => 2.0,
|
|
Stroke::W3 => 3.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A drop shadow: how far it is offset, how soft and large it is, and how opaque.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub struct Elevation {
|
|
/// Horizontal and vertical offset in logical pixels.
|
|
pub offset: [f32; 2],
|
|
/// Blur radius in logical pixels.
|
|
pub blur: f32,
|
|
/// Growth (positive) or shrink (negative) of the shadow rectangle in logical pixels.
|
|
pub spread: f32,
|
|
/// Opacity of the shadow colour, 0..=1.
|
|
pub alpha: f32,
|
|
}
|
|
|
|
impl Elevation {
|
|
/// Levels 0 (flat, no shadow) to 3 (highest), for a `float.shadow` override.
|
|
pub const LEVELS: [Elevation; 4] = [
|
|
Elevation { offset: [0.0, 0.0], blur: 0.0, spread: 0.0, alpha: 0.0 },
|
|
Elevation { offset: [0.0, 1.0], blur: 3.0, spread: 0.0, alpha: 0.14 },
|
|
Elevation { offset: [0.0, 4.0], blur: 12.0, spread: 0.0, alpha: 0.20 },
|
|
Elevation { offset: [0.0, 10.0], blur: 28.0, spread: 0.0, alpha: 0.28 },
|
|
];
|
|
|
|
/// The shadow for `level`; levels above 3 give level 3.
|
|
pub const fn level(level: usize) -> Elevation {
|
|
Self::LEVELS[if level > 3 { 3 } else { level }]
|
|
}
|
|
}
|
|
|
|
/// The motion duration scale.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
pub enum Duration {
|
|
/// 80 ms: hover and press feedback.
|
|
Fast,
|
|
/// 150 ms: most state changes.
|
|
Normal,
|
|
/// 250 ms: large surfaces opening or moving.
|
|
Slow,
|
|
}
|
|
|
|
impl Duration {
|
|
/// The duration in milliseconds.
|
|
pub const fn millis(self) -> u32 {
|
|
match self {
|
|
Duration::Fast => 80,
|
|
Duration::Normal => 150,
|
|
Duration::Slow => 250,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The easing curves for motion.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
|
pub enum Easing {
|
|
/// Movement within the screen.
|
|
Standard,
|
|
/// Elements entering: starts fast, settles slowly.
|
|
Enter,
|
|
/// Elements leaving: starts slowly, ends fast.
|
|
Exit,
|
|
}
|
|
|
|
impl Easing {
|
|
/// CSS-style cubic-bezier control points `[x1, y1, x2, y2]`.
|
|
pub const fn bezier(self) -> [f32; 4] {
|
|
match self {
|
|
Easing::Standard => [0.2, 0.0, 0.0, 1.0],
|
|
Easing::Enter => [0.0, 0.0, 0.0, 1.0],
|
|
Easing::Exit => [0.3, 0.0, 1.0, 1.0],
|
|
}
|
|
}
|
|
|
|
/// The curve's progress at time `t` (both 0 to 1), as CSS `cubic-bezier` computes it.
|
|
pub fn at(self, t: f32) -> f32 {
|
|
let [x1, y1, x2, y2] = self.bezier();
|
|
// One coordinate of the curve with control values `a` and `b` at parameter `s`.
|
|
let curve = |a: f32, b: f32, s: f32| ((1.0 - 3.0 * b + 3.0 * a) * s + (3.0 * b - 6.0 * a)) * s * s + 3.0 * a * s;
|
|
let t = t.clamp(0.0, 1.0);
|
|
// x is monotonic in s on [0, 1] for CSS curves (x1, x2 in 0..=1), so bisection finds s.
|
|
let (mut lo, mut hi) = (0.0_f32, 1.0_f32);
|
|
for _ in 0..24 {
|
|
let mid = (lo + hi) / 2.0;
|
|
if curve(x1, x2, mid) < t {
|
|
lo = mid;
|
|
} else {
|
|
hi = mid;
|
|
}
|
|
}
|
|
curve(y1, y2, (lo + hi) / 2.0)
|
|
}
|
|
}
|
|
|
|
/// Opacity primitives.
|
|
pub struct Opacity;
|
|
|
|
impl Opacity {
|
|
/// How much of its look a disabled thing keeps: the opacity of a faded component (`DisabledLook::Faded`) and of
|
|
/// the data colours a disabled component in its Disabled state paints, and the share a disabled knob's fill moves
|
|
/// toward the disabled fill.
|
|
pub const DISABLED: f32 = 0.5;
|
|
/// Alpha of a window or layer while it moves over a drop target, so what lies under it shows through.
|
|
pub const MOVING: f32 = 0.75;
|
|
/// Alpha of a mark the app derived, drawn beside the user's own marks of the same kind so those stand out.
|
|
pub const DERIVED: f32 = 0.7;
|
|
/// Alpha of a colour that faintly washes an area behind its content: a track's label colour over its lane.
|
|
pub const WASH: f32 = 0.10;
|
|
/// Alpha of a colour that tints an area behind or over content so the area stands out while the content still
|
|
/// reads: a track's label colour over its header, an inspected element's padding.
|
|
pub const TINT: f32 = 0.18;
|
|
/// Alpha of a data colour filling a span bar beside the solid mark it belongs to: a range marker's duration.
|
|
pub const SPAN: f32 = 0.5;
|
|
/// Alpha of secondary ink drawn over a data colour, below the primary ink of the same surface: the author's name
|
|
/// over a chat bubble's message.
|
|
pub const SECONDARY: f32 = 0.8;
|
|
}
|