daniel
91f71f92bd
Decouples the keyboard strip's mid stop from accent/secondary, which the deep-teal darkening had inverted. Adds overlay/trace (#816AA6), the first value to clear 3:1 against the waveform. Replaces the frozen-premise test.
182 lines
8.4 KiB
C++
182 lines
8.4 KiB
C++
// theme — pure implementation. See theme.h.
|
|
|
|
#include "core/ui/theme.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
|
|
namespace reasampler::ui {
|
|
|
|
namespace {
|
|
|
|
// ===========================================================================
|
|
// THE ONE DIRECTION CONSTANTS BLOCK. Every role color below is one of these constants;
|
|
// roleColor() is a pure switch over them — this is the single point of change for the
|
|
// visual direction. Values are locked against each WCAG floor (proven by test_theme.cpp):
|
|
// text/dim is lifted to the lightest grey that still clears AA 4.5:1 body on the greyest
|
|
// surface it draws on; each pastel accent is the softest tint that still clears the 3:1
|
|
// indicator floor on bg/cell ("punch from the soft side").
|
|
// ===========================================================================
|
|
|
|
// REAPER-theme mid-grey elevation stack, matching Daniel's REAPER theme so the dock reads as
|
|
// part of REAPER: base = window chrome grey, panel/cell one step lighter each. Elevation-ladder
|
|
// discipline: base < panel < cell by a few %, micro-gradient + inner highlight/shadow carry
|
|
// elevation, not hard borders.
|
|
constexpr KitColor kDirBgBase {43, 43, 43, 255}; // #2b2b2b — REAPER chrome grey
|
|
constexpr KitColor kDirBgPanel {51, 51, 51, 255}; // #333333 — one step lighter
|
|
constexpr KitColor kDirBgCell {58, 58, 58, 255}; // #3a3a3a — REAPER track bg
|
|
constexpr KitColor kDirHairline {74, 74, 74, 255}; // #4a4a4a — subtle step above cell
|
|
|
|
// Text: REAPER body light-grey primary (#dcdcdc, clears ~8:1 on bg/cell) + a dimmer grey
|
|
// secondary. Mid-grey-on-mid-grey is the classic AA failure: the spec-start #a0a0a0 lands
|
|
// ~4.35:1 on bg/cell, under the AA 4.5 body floor — lifted to #a8a8a8 (~4.78:1), the lightest
|
|
// grey that still reads dim while clearing the floor. Locked by test_theme.cpp.
|
|
constexpr KitColor kDirTextPrimary{220, 220, 220, 255}; // #dcdcdc
|
|
constexpr KitColor kDirTextDim {168, 168, 168, 255}; // #a8a8a8 (lifted from #a0a0a0)
|
|
|
|
// Accent system: primary = pastel lime (the live/active/selected signal); secondary = deep
|
|
// teal, tertiary = pastel purple (CATEGORICAL distinctions — a KIND, never intensity).
|
|
// accent/hot is a brighter tint OF the primary for hover/live/drag. Secondary is the one
|
|
// accent off the pastel side: its binding limiter is the AA 4.5:1 text-on-fill pair (a bg/base
|
|
// label on a secondary fill), NOT the 3:1 indicator floor, so it cannot go darker than this.
|
|
// warn is reserved for byte-deleting states only.
|
|
constexpr KitColor kDirAccentPrimary {176, 224, 152, 255}; // #B0E098 — pastel lime
|
|
constexpr KitColor kDirAccentSecondary{56, 168, 160, 255}; // #38A8A0 — deep teal
|
|
constexpr KitColor kDirAccentTertiary {194, 170, 232, 255}; // #C2AAE8 — pastel purple
|
|
constexpr KitColor kDirAccentHot {200, 236, 178, 255}; // #C8ECB2 — lighter pastel lime
|
|
constexpr KitColor kDirWarn {235, 120, 90, 255}; // #eb785a — destructive only
|
|
|
|
// The envelope trace over the waveform. Two neighbours pin it at once — the lime accent it
|
|
// crosses and bg/base behind it — which bound ANY single value to 3.07:1 against both; this is
|
|
// that optimum, with no room in either direction. No categorical accent can carry it: every
|
|
// one of them is light enough to fall under 2:1 against the lime.
|
|
constexpr KitColor kDirOverlayTrace{129, 106, 166, 255}; // #816AA6 — muted violet
|
|
|
|
// Spectral ramp: pastel lime (low) -> pastel teal (mid) -> pastel purple (high). The mid stop
|
|
// is its OWN value rather than the secondary accent it once aliased — the ramp is a luminance
|
|
// progression while the accents are categorical roles, and darkening secondary for a
|
|
// categorical reason inverted lo->mid->hi. Do not re-alias it.
|
|
constexpr KitColor kDirSpectralLo = kDirAccentPrimary;
|
|
constexpr KitColor kDirSpectralMid{132, 214, 208, 255}; // #84D6D0 — pastel teal
|
|
constexpr KitColor kDirSpectralHi = kDirAccentTertiary;
|
|
|
|
// --- state transform helpers -------------------------------------------------
|
|
|
|
std::uint8_t clamp8(int v) {
|
|
return static_cast<std::uint8_t>(v < 0 ? 0 : (v > 255 ? 255 : v));
|
|
}
|
|
|
|
// Linear blend from a toward b by t in [0, 1] (alpha carried from a — a state tint changes
|
|
// hue/brightness, not opacity; disabled handles alpha separately).
|
|
KitColor mix(const KitColor& a, const KitColor& b, double t) {
|
|
return KitColor{
|
|
clamp8(static_cast<int>(std::lround(a.r + (b.r - a.r) * t))),
|
|
clamp8(static_cast<int>(std::lround(a.g + (b.g - a.g) * t))),
|
|
clamp8(static_cast<int>(std::lround(a.b + (b.b - a.b) * t))),
|
|
a.a,
|
|
};
|
|
}
|
|
|
|
KitColor scale(const KitColor& c, double factor) {
|
|
return KitColor{
|
|
clamp8(static_cast<int>(std::lround(c.r * factor))),
|
|
clamp8(static_cast<int>(std::lround(c.g * factor))),
|
|
clamp8(static_cast<int>(std::lround(c.b * factor))),
|
|
c.a,
|
|
};
|
|
}
|
|
|
|
// Desaturate toward the color's own luminance-gray by amount in [0, 1].
|
|
KitColor desaturate(const KitColor& c, double amount) {
|
|
const int gray = clamp8(static_cast<int>(
|
|
std::lround(0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b)));
|
|
const KitColor g{static_cast<std::uint8_t>(gray),
|
|
static_cast<std::uint8_t>(gray),
|
|
static_cast<std::uint8_t>(gray), c.a};
|
|
return mix(c, g, amount);
|
|
}
|
|
|
|
double linearizeChannel(std::uint8_t v) {
|
|
const double s = v / 255.0;
|
|
return s <= 0.03928 ? s / 12.92 : std::pow((s + 0.055) / 1.055, 2.4);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
KitColor roleColor(Role role) {
|
|
switch (role) {
|
|
case Role::BgBase: return kDirBgBase;
|
|
case Role::BgPanel: return kDirBgPanel;
|
|
case Role::BgCell: return kDirBgCell;
|
|
case Role::LineHairline: return kDirHairline;
|
|
case Role::TextPrimary: return kDirTextPrimary;
|
|
case Role::TextDim: return kDirTextDim;
|
|
case Role::AccentPrimary: return kDirAccentPrimary;
|
|
case Role::AccentSecondary: return kDirAccentSecondary;
|
|
case Role::AccentTertiary: return kDirAccentTertiary;
|
|
case Role::AccentHot: return kDirAccentHot;
|
|
case Role::OverlayTrace: return kDirOverlayTrace;
|
|
case Role::Warn: return kDirWarn;
|
|
}
|
|
return kDirBgBase; // unreachable; keeps non-void control flow total
|
|
}
|
|
|
|
KitColor roleColorState(Role role, InteractionState state) {
|
|
const KitColor base = roleColor(role);
|
|
switch (state) {
|
|
case InteractionState::Rest:
|
|
return base;
|
|
case InteractionState::Hover:
|
|
// Lighten toward the hot accent (~10%) — the "alive" cue.
|
|
return mix(base, roleColor(Role::AccentHot), 0.10);
|
|
case InteractionState::Active:
|
|
// "This is live" is always the primary hue — secondary/tertiary stay categorical.
|
|
return roleColor(Role::AccentPrimary);
|
|
case InteractionState::Pressed:
|
|
return scale(base, 0.82); // the surface "pushes in"
|
|
case InteractionState::Dragging:
|
|
return mix(roleColor(Role::AccentPrimary), roleColor(Role::AccentHot), 0.30);
|
|
case InteractionState::Focus:
|
|
// Focus keeps the surface; the shell draws a text/primary ring on top, and the
|
|
// fill nudges toward the primary accent so focus reads pre-ring.
|
|
return mix(base, roleColor(Role::AccentPrimary), 0.08);
|
|
case InteractionState::Disabled: {
|
|
KitColor d = desaturate(base, 0.6);
|
|
d.a = static_cast<std::uint8_t>(std::lround(base.a * 0.4));
|
|
return d;
|
|
}
|
|
}
|
|
return base;
|
|
}
|
|
|
|
KitColor spectralColor(double t) {
|
|
if (t < 0.0) t = 0.0;
|
|
if (t > 1.0) t = 1.0;
|
|
// Interpolate each half separately so the mid stop is actually hit — a single Lo->Hi lerp
|
|
// would skip it and drift the ramp off the pastel arc.
|
|
if (t <= 0.5) {
|
|
return mix(kDirSpectralLo, kDirSpectralMid, t / 0.5);
|
|
}
|
|
return mix(kDirSpectralMid, kDirSpectralHi, (t - 0.5) / 0.5);
|
|
}
|
|
|
|
double relativeLuminance(const KitColor& c) {
|
|
return 0.2126 * linearizeChannel(c.r) +
|
|
0.7152 * linearizeChannel(c.g) +
|
|
0.0722 * linearizeChannel(c.b);
|
|
}
|
|
|
|
double contrastRatio(const KitColor& a, const KitColor& b) {
|
|
const double la = relativeLuminance(a);
|
|
const double lb = relativeLuminance(b);
|
|
const double lighter = std::max(la, lb);
|
|
const double darker = std::min(la, lb);
|
|
return (lighter + 0.05) / (darker + 0.05);
|
|
}
|
|
|
|
double textFloor(TextClass cls) {
|
|
return cls == TextClass::Body ? 4.5 : 3.0;
|
|
}
|
|
|
|
} // namespace reasampler::ui
|