forked from 1b-agent/opencadstudio-upstream
Claude
451b0f5d78
Keep both sides: main's ViewBackground colour target and PREVIEW icon next to this branch's Interface target and LIST/SEARCH icons. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013rGmDUNr1hUf4zo1X3dak8
1168 lines
44 KiB
Rust
1168 lines
44 KiB
Rust
//! Shared SVG rendering for monochrome UI chrome and multi-colour tool icons.
|
|
//!
|
|
//! Dropdown carets and the undo/redo controls used to be drawn as Unicode
|
|
//! glyphs (`▾`, `▲`, `↶`, `↷`). Those depend on the active text font carrying
|
|
//! the glyph: on desktop the system fallback fonts supply them, but the web
|
|
//! build bundles only Fira Sans, which lacks them, so they rendered as empty
|
|
//! boxes. Drawing them from SVG instead makes the chrome font-independent.
|
|
|
|
use std::cell::RefCell;
|
|
|
|
use iced::advanced::layout::{self, Layout};
|
|
use iced::advanced::renderer;
|
|
use iced::advanced::svg::{self as core_svg, Renderer as _};
|
|
use iced::advanced::widget::{Tree, Widget};
|
|
use iced::widget::{container, svg, Space};
|
|
use iced::{Color, ContentFit, Element, Length, Point, Radians, Rectangle, Renderer, Size, Theme};
|
|
use rustc_hash::FxHashMap;
|
|
|
|
use crate::ui::style::common::{accessible_accent, wcag_contrast};
|
|
|
|
static TRI_DOWN: &[u8] = include_bytes!("../../assets/icons/ui/tri_down.svg");
|
|
static TRI_UP: &[u8] = include_bytes!("../../assets/icons/ui/tri_up.svg");
|
|
static TRI_RIGHT: &[u8] = include_bytes!("../../assets/icons/ui/tri_right.svg");
|
|
static TRI_LEFT: &[u8] = include_bytes!("../../assets/icons/ui/tri_left.svg");
|
|
static HOME: &[u8] = include_bytes!("../../assets/icons/ui/home.svg");
|
|
static UNDO: &[u8] = include_bytes!("../../assets/icons/ui/undo.svg");
|
|
static REDO: &[u8] = include_bytes!("../../assets/icons/ui/redo.svg");
|
|
|
|
// OSNAP marker symbols. Rendered as SVG (not Unicode glyphs) so the snap menu
|
|
// shows the right shapes on the web build, whose bundled Fira Sans lacks the
|
|
// geometric glyphs and rendered them as tofu boxes. (#138)
|
|
static OSNAP_ENDPOINT: &[u8] = include_bytes!("../../assets/icons/osnap/endpoint.svg");
|
|
static OSNAP_MIDPOINT: &[u8] = include_bytes!("../../assets/icons/osnap/midpoint.svg");
|
|
static OSNAP_CENTER: &[u8] = include_bytes!("../../assets/icons/osnap/center.svg");
|
|
static OSNAP_GEOMETRIC_CENTER: &[u8] =
|
|
include_bytes!("../../assets/icons/osnap/geometric_center.svg");
|
|
static OSNAP_NODE: &[u8] = include_bytes!("../../assets/icons/osnap/node.svg");
|
|
static OSNAP_QUADRANT: &[u8] = include_bytes!("../../assets/icons/osnap/quadrant.svg");
|
|
static OSNAP_INTERSECTION: &[u8] = include_bytes!("../../assets/icons/osnap/intersection.svg");
|
|
static OSNAP_EXTENSION: &[u8] = include_bytes!("../../assets/icons/osnap/extension.svg");
|
|
static OSNAP_INSERTION: &[u8] = include_bytes!("../../assets/icons/osnap/insertion.svg");
|
|
static OSNAP_PERPENDICULAR: &[u8] = include_bytes!("../../assets/icons/osnap/perpendicular.svg");
|
|
static OSNAP_TANGENT: &[u8] = include_bytes!("../../assets/icons/osnap/tangent.svg");
|
|
static OSNAP_NEAREST: &[u8] = include_bytes!("../../assets/icons/osnap/nearest.svg");
|
|
static OSNAP_APPARENT: &[u8] = include_bytes!("../../assets/icons/osnap/apparent.svg");
|
|
static OSNAP_PARALLEL: &[u8] = include_bytes!("../../assets/icons/osnap/parallel.svg");
|
|
static OSNAP_GRID: &[u8] = include_bytes!("../../assets/icons/osnap/grid.svg");
|
|
static OSNAP_MTP: &[u8] = include_bytes!("../../assets/icons/osnap/mtp.svg");
|
|
static NAV_PAN: &[u8] = include_bytes!("../../assets/icons/pan.svg");
|
|
static NAV_ZOOM: &[u8] = include_bytes!("../../assets/icons/zoom_in.svg");
|
|
|
|
static LAY_ON: &[u8] = include_bytes!("../../assets/icons/layers/layon.svg");
|
|
static LAY_OFF: &[u8] = include_bytes!("../../assets/icons/layers/layoff.svg");
|
|
static LAY_FRZ: &[u8] = include_bytes!("../../assets/icons/layers/layfrz.svg");
|
|
static LAY_THW: &[u8] = include_bytes!("../../assets/icons/layers/laythw.svg");
|
|
static LAY_VP_FRZ: &[u8] = include_bytes!("../../assets/icons/layers/layvpfrz.svg");
|
|
static LAY_VP_THW: &[u8] = include_bytes!("../../assets/icons/layers/layvpthw.svg");
|
|
static LAY_LCK: &[u8] = include_bytes!("../../assets/icons/layers/laylck.svg");
|
|
static LAY_ULK: &[u8] = include_bytes!("../../assets/icons/layers/layulk.svg");
|
|
|
|
// Monochrome chrome glyphs (replace Unicode glyphs in buttons / menus / toolbars).
|
|
// All are black-on-transparent; recolour them at the call site with [`tinted`].
|
|
pub static CHECK: &[u8] = include_bytes!("../../assets/icons/ui/check.svg");
|
|
pub static CLOSE: &[u8] = include_bytes!("../../assets/icons/ui/close.svg");
|
|
pub static EYEDROPPER: &[u8] = include_bytes!("../../assets/icons/ui/eyedropper.svg");
|
|
pub static PLUS: &[u8] = include_bytes!("../../assets/icons/ui/plus.svg");
|
|
pub static REFRESH: &[u8] = include_bytes!("../../assets/icons/ui/refresh.svg");
|
|
pub static SWAP: &[u8] = include_bytes!("../../assets/icons/ui/swap.svg");
|
|
pub static MINUS: &[u8] = include_bytes!("../../assets/icons/ui/minus.svg");
|
|
pub static TRASH: &[u8] = include_bytes!("../../assets/icons/ui/trash.svg");
|
|
pub static NODE_GRAPH: &[u8] = include_bytes!("../../assets/icons/ui/node_graph.svg");
|
|
pub static COPY: &[u8] = include_bytes!("../../assets/icons/ui/copy.svg");
|
|
pub static MENU: &[u8] = include_bytes!("../../assets/icons/ui/menu.svg");
|
|
pub static MOVE: &[u8] = include_bytes!("../../assets/icons/ui/move.svg");
|
|
pub static RESIZE: &[u8] = include_bytes!("../../assets/icons/ui/resize.svg");
|
|
/// `RESIZE` mirrored for a bottom-left corner grip.
|
|
pub static RESIZE_LEFT: &[u8] = include_bytes!("../../assets/icons/ui/resize_left.svg");
|
|
pub static PIN: &[u8] = include_bytes!("../../assets/icons/ui/pin.svg");
|
|
/// `PIN` tilted 30°: the pin while auto-hide is on.
|
|
pub static PIN_ACTIVE: &[u8] = include_bytes!("../../assets/icons/ui/pin_active.svg");
|
|
pub static SPLIT_V: &[u8] = include_bytes!("../../assets/icons/ui/split_v.svg");
|
|
pub static SPLIT_H: &[u8] = include_bytes!("../../assets/icons/ui/split_h.svg");
|
|
pub static GRID: &[u8] = include_bytes!("../../assets/icons/ui/grid.svg");
|
|
pub static LIST: &[u8] = include_bytes!("../../assets/icons/ui/list.svg");
|
|
pub static SEARCH: &[u8] = include_bytes!("../../assets/icons/ui/search.svg");
|
|
pub static PREVIEW: &[u8] = include_bytes!("../../assets/icons/ui/preview.svg");
|
|
pub static SNAP: &[u8] = include_bytes!("../../assets/icons/ui/snap.svg");
|
|
pub static DOC_NEW: &[u8] = include_bytes!("../../assets/icons/ui/doc_new.svg");
|
|
pub static DOC: &[u8] = include_bytes!("../../assets/icons/ui/doc.svg");
|
|
pub static FOLDER_OPEN: &[u8] = include_bytes!("../../assets/icons/ui/folder_open.svg");
|
|
pub static SAVE: &[u8] = include_bytes!("../../assets/icons/ui/save.svg");
|
|
pub static FILE_EXPORT: &[u8] = include_bytes!("../../assets/icons/ui/file_export.svg");
|
|
pub static PRINT: &[u8] = include_bytes!("../../assets/icons/ui/print.svg");
|
|
pub static HEART: &[u8] = include_bytes!("../../assets/icons/ui/heart.svg");
|
|
#[cfg(target_arch = "wasm32")]
|
|
pub static GEAR: &[u8] = include_bytes!("../../assets/icons/ui/gear.svg");
|
|
pub static DOT: &[u8] = include_bytes!("../../assets/icons/ui/dot.svg");
|
|
pub static DIRTY_DOT: &[u8] = include_bytes!("../../assets/icons/ui/dirty_dot.svg");
|
|
pub static ARROW_LONG_RIGHT: &[u8] = include_bytes!("../../assets/icons/ui/arrow_long_right.svg");
|
|
pub static MORE: &[u8] = include_bytes!("../../assets/icons/ui/more.svg");
|
|
pub static INFO: &[u8] = include_bytes!("../../assets/icons/ui/info.svg");
|
|
|
|
// ── Status-bar toggle icons (issue #216) ──────────────────────────────────
|
|
pub static ST_ORTHO: &[u8] = include_bytes!("../../assets/icons/status/ortho.svg");
|
|
pub static ST_POLAR: &[u8] = include_bytes!("../../assets/icons/status/polar.svg");
|
|
pub static ST_OSNAP: &[u8] = include_bytes!("../../assets/icons/status/osnap.svg");
|
|
pub static ST_OTRACK: &[u8] = include_bytes!("../../assets/icons/status/otrack.svg");
|
|
pub static ST_DYN: &[u8] = include_bytes!("../../assets/icons/status/dyn.svg");
|
|
pub static ST_LWT: &[u8] = include_bytes!("../../assets/icons/status/lwt.svg");
|
|
pub static ST_TRANSPARENCY: &[u8] = include_bytes!("../../assets/icons/status/transparency.svg");
|
|
pub static ST_ISOLATE: &[u8] = include_bytes!("../../assets/icons/status/isolate.svg");
|
|
pub static ST_QUICKPROPS: &[u8] = include_bytes!("../../assets/icons/status/quickprops.svg");
|
|
pub static ST_FILTER: &[u8] = include_bytes!("../../assets/icons/status/filter.svg");
|
|
pub static ST_SELCYCLE: &[u8] = include_bytes!("../../assets/icons/status/selcycle.svg");
|
|
pub static ST_CLEANSCREEN: &[u8] = include_bytes!("../../assets/icons/status/cleanscreen.svg");
|
|
|
|
// Tool SVGs share a small source palette. These colours are semantic rather
|
|
// than literal: cyan is the accent, pale grey is foreground, yellow is warning,
|
|
// and so on. `SemanticIcon` resolves those roles from Iced's active extended
|
|
// palette at draw time, retaining the artwork's multiple colours across themes.
|
|
const SEMANTIC_CACHE_LIMIT: usize = 2048;
|
|
|
|
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
|
|
struct SemanticCacheKey {
|
|
address: usize,
|
|
length: usize,
|
|
palette: [[u8; 4]; 6],
|
|
}
|
|
|
|
thread_local! {
|
|
static SEMANTIC_CACHE: RefCell<FxHashMap<SemanticCacheKey, svg::Handle>> =
|
|
RefCell::new(FxHashMap::default());
|
|
}
|
|
|
|
// Per-thread cache of `svg::Handle`s keyed by the bytes'
|
|
// `(address, length)`. See the doc comment on [`themed_handle`]
|
|
// below for the cache key rationale, the sub-slice guard, the
|
|
// mirror of `SemanticCacheKey`, and the threading choice.
|
|
#[derive(Default)]
|
|
struct ThemedCache {
|
|
mru: [Option<((usize, usize), svg::Handle)>; 2],
|
|
map: FxHashMap<(usize, usize), svg::Handle>,
|
|
}
|
|
|
|
thread_local! {
|
|
static THEMED_CACHE: RefCell<ThemedCache> =
|
|
RefCell::new(ThemedCache::default());
|
|
}
|
|
|
|
/// Look up (or build and cache) the `svg::Handle` for a `&'static [u8]`
|
|
/// passed to a `themed*` function. This is the single source of
|
|
/// truth for the per-`bytes` handle in the `themed` icon family —
|
|
/// the 9 `themed*` functions all go through here, so the 22
|
|
/// `themed*` call sites (and the 113 total `icons::themed`
|
|
/// references) share one entry per artwork.
|
|
///
|
|
/// **Cache key: `(address, length)`.** Every `include_bytes!`
|
|
/// produces a unique `&'static` slice, and the address is stable
|
|
/// for the program's lifetime. Including the length guards against
|
|
/// any future call site that passes a sub-slice of a static
|
|
/// (e.g. `&BYTES[1..]`), which would otherwise alias the wrong
|
|
/// handle. Mirrors the proven `SemanticCacheKey` belt-and-braces
|
|
/// pattern above.
|
|
///
|
|
/// **`themed` vs `semantic` — why the simpler key is correct.**
|
|
/// The `semantic` family bakes the palette into the SVG
|
|
/// (recolours the artwork per theme role), so its cache key
|
|
/// includes the palette. The `themed` family reads its colour
|
|
/// from an Iced style closure at draw time, so the handle
|
|
/// depends only on the bytes — a single entry per artwork is
|
|
/// correct and shared across all themes.
|
|
///
|
|
/// **Threading.** The cache is `thread_local!` because `svg::Handle`
|
|
/// is not `Sync`. The set of `&'static [u8]` art is fixed at
|
|
/// compile time (~25-30 `include_bytes!` entries), so the cache
|
|
/// is bounded by construction and needs no eviction. Per-frame
|
|
/// cost: 9 ns/iter warm, 26 ns/iter cold (release profile, see
|
|
/// `themed_cache_speedup_over_uncached_handle_creation`).
|
|
///
|
|
/// **No borrow held during handle construction.** The cache is
|
|
/// read (immutable `borrow`), the `Ref` is dropped, and only then
|
|
/// is `svg::Handle::from_memory` invoked. The result is then
|
|
/// inserted under a fresh `borrow_mut`. This is defensive: a
|
|
/// re-entrant call into `themed*` during SVG parsing cannot
|
|
/// trigger a `RefCell` panic on the second `borrow_mut`, because
|
|
/// no `borrow_mut` is held while parsing runs. (The same
|
|
/// `thread_local!` + `RefCell` shape is used by `SEMANTIC_CACHE`.)
|
|
#[inline]
|
|
#[doc(hidden)]
|
|
pub fn themed_handle(bytes: &'static [u8]) -> svg::Handle {
|
|
let key = (bytes.as_ptr() as usize, bytes.len());
|
|
let hit = THEMED_CACHE.with(|cache| {
|
|
let mut c = cache.borrow_mut();
|
|
if let Some((k, ref handle)) = c.mru[0] {
|
|
if k == key {
|
|
return Some(handle.clone());
|
|
}
|
|
}
|
|
if let Some((k, _)) = c.mru[1] {
|
|
if k == key {
|
|
c.mru.swap(0, 1);
|
|
return Some(c.mru[0].as_ref().unwrap().1.clone());
|
|
}
|
|
}
|
|
if let Some(handle) = c.map.get(&key) {
|
|
let handle = handle.clone();
|
|
c.mru[1] = c.mru[0].take();
|
|
c.mru[0] = Some((key, handle.clone()));
|
|
return Some(handle);
|
|
}
|
|
None
|
|
});
|
|
if let Some(handle) = hit {
|
|
return handle;
|
|
}
|
|
|
|
// Miss: build the handle with no cache borrow held, then insert.
|
|
let handle = svg::Handle::from_memory(bytes);
|
|
THEMED_CACHE.with(|cache| {
|
|
let mut c = cache.borrow_mut();
|
|
c.mru[1] = c.mru[0].take();
|
|
c.mru[0] = Some((key, handle.clone()));
|
|
c.map.insert(key, handle.clone());
|
|
});
|
|
handle
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct SemanticColors {
|
|
background: [u8; 7],
|
|
text: [u8; 7],
|
|
primary_weak: [u8; 7],
|
|
primary: [u8; 7],
|
|
primary_strong: [u8; 7],
|
|
secondary_weak: [u8; 7],
|
|
secondary: [u8; 7],
|
|
secondary_strong: [u8; 7],
|
|
success_weak: [u8; 7],
|
|
success: [u8; 7],
|
|
warning: [u8; 7],
|
|
warning_strong: [u8; 7],
|
|
danger_weak: [u8; 7],
|
|
danger: [u8; 7],
|
|
}
|
|
|
|
impl SemanticColors {
|
|
fn from_theme(theme: &Theme) -> Self {
|
|
let palette = theme.palette();
|
|
Self {
|
|
background: color_hex(palette.background.strong.color),
|
|
text: color_hex(palette.background.base.text),
|
|
primary_weak: color_hex(palette.primary.weak.color),
|
|
primary: color_hex(palette.primary.base.color),
|
|
primary_strong: color_hex(palette.primary.strong.color),
|
|
secondary_weak: color_hex(palette.secondary.weak.color),
|
|
secondary: color_hex(palette.secondary.base.color),
|
|
secondary_strong: color_hex(palette.secondary.strong.color),
|
|
success_weak: color_hex(palette.success.weak.color),
|
|
success: color_hex(palette.success.base.color),
|
|
warning: color_hex(palette.warning.base.color),
|
|
warning_strong: color_hex(palette.warning.strong.color),
|
|
danger_weak: color_hex(palette.danger.weak.color),
|
|
danger: color_hex(palette.danger.base.color),
|
|
}
|
|
}
|
|
}
|
|
|
|
struct SemanticIcon {
|
|
bytes: &'static [u8],
|
|
size: f32,
|
|
opacity: f32,
|
|
}
|
|
|
|
impl<M> Widget<M, Theme, Renderer> for SemanticIcon {
|
|
fn size(&self) -> Size<Length> {
|
|
Size::new(Length::Fixed(self.size), Length::Fixed(self.size))
|
|
}
|
|
|
|
fn layout(
|
|
&mut self,
|
|
_tree: &mut Tree,
|
|
_renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
layout::atomic(limits, Length::Fixed(self.size), Length::Fixed(self.size))
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
_tree: &Tree,
|
|
renderer: &mut Renderer,
|
|
theme: &Theme,
|
|
_style: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
_cursor: iced::advanced::mouse::Cursor,
|
|
_viewport: &Rectangle,
|
|
) {
|
|
let handle = semantic_handle(self.bytes, theme);
|
|
let measured = renderer.measure_svg(&handle);
|
|
if measured.width == 0 || measured.height == 0 {
|
|
return;
|
|
}
|
|
|
|
let image_size = Size::new(measured.width as f32, measured.height as f32);
|
|
let bounds = layout.bounds();
|
|
let fitted = ContentFit::Contain.fit(image_size, bounds.size());
|
|
let position = Point::new(
|
|
bounds.center_x() - fitted.width / 2.0,
|
|
bounds.center_y() - fitted.height / 2.0,
|
|
);
|
|
|
|
renderer.draw_svg(
|
|
core_svg::Svg {
|
|
handle,
|
|
color: None,
|
|
rotation: Radians(0.0),
|
|
opacity: self.opacity,
|
|
},
|
|
Rectangle::new(position, fitted),
|
|
bounds,
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Render a multi-colour tool icon using semantic colours from the active theme.
|
|
pub fn semantic<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
Element::new(SemanticIcon {
|
|
bytes,
|
|
size,
|
|
opacity: 1.0,
|
|
})
|
|
}
|
|
|
|
/// [`semantic`] faded like disabled menu text.
|
|
pub fn semantic_disabled<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
Element::new(SemanticIcon {
|
|
bytes,
|
|
size,
|
|
opacity: 0.42,
|
|
})
|
|
}
|
|
|
|
fn semantic_handle(bytes: &'static [u8], theme: &Theme) -> svg::Handle {
|
|
let key = SemanticCacheKey {
|
|
address: bytes.as_ptr() as usize,
|
|
length: bytes.len(),
|
|
palette: palette_key(theme),
|
|
};
|
|
|
|
SEMANTIC_CACHE.with(|cache| {
|
|
let mut cache = cache.borrow_mut();
|
|
if let Some(handle) = cache.get(&key) {
|
|
return handle.clone();
|
|
}
|
|
|
|
let handle = svg::Handle::from_memory(recolor_semantic_svg(bytes, theme));
|
|
if cache.len() >= SEMANTIC_CACHE_LIMIT {
|
|
cache.clear();
|
|
}
|
|
cache.insert(key, handle.clone());
|
|
handle
|
|
})
|
|
}
|
|
|
|
fn palette_key(theme: &Theme) -> [[u8; 4]; 6] {
|
|
let palette = theme.palette();
|
|
[
|
|
palette.background.base.color.into_rgba8(),
|
|
palette.background.base.text.into_rgba8(),
|
|
palette.primary.base.color.into_rgba8(),
|
|
palette.success.base.color.into_rgba8(),
|
|
palette.warning.base.color.into_rgba8(),
|
|
palette.danger.base.color.into_rgba8(),
|
|
]
|
|
}
|
|
|
|
fn recolor_semantic_svg(source: &[u8], theme: &Theme) -> Vec<u8> {
|
|
let colors = SemanticColors::from_theme(theme);
|
|
let mut output = Vec::with_capacity(source.len());
|
|
let mut index = 0;
|
|
|
|
while index < source.len() {
|
|
if source[index] == b'#' {
|
|
let mut end = index + 1;
|
|
while end < source.len() && source[end].is_ascii_hexdigit() {
|
|
end += 1;
|
|
}
|
|
let digit_count = end - index - 1;
|
|
if matches!(digit_count, 3 | 4 | 6 | 8) {
|
|
if let Some(replacement) = semantic_color(&source[index..end], &colors) {
|
|
output.extend_from_slice(replacement);
|
|
index = end;
|
|
continue;
|
|
}
|
|
}
|
|
} else if starts_with_word_ignore_ascii_case(source, index, b"white") {
|
|
output.extend_from_slice(&colors.text);
|
|
index += 5;
|
|
continue;
|
|
}
|
|
|
|
output.push(source[index]);
|
|
index += 1;
|
|
}
|
|
|
|
output
|
|
}
|
|
|
|
fn semantic_color<'a>(token: &[u8], colors: &'a SemanticColors) -> Option<&'a [u8; 7]> {
|
|
if is_one_of(
|
|
token,
|
|
&["#b4b6b9", "#e0e0e0", "#eeeeee", "#ffffff", "#e1e1e1"],
|
|
) {
|
|
Some(&colors.text)
|
|
} else if is_one_of(token, &["#cccccc", "#bdbdbd", "#aaaaaa"]) {
|
|
Some(&colors.secondary_strong)
|
|
} else if is_one_of(
|
|
token,
|
|
&[
|
|
"#888888", "#888", "#9e9e9e", "#90a4ae", "#78909c", "#7a7a7a", "#777777",
|
|
],
|
|
) {
|
|
Some(&colors.secondary)
|
|
} else if is_one_of(
|
|
token,
|
|
&[
|
|
"#505050", "#555", "#606060", "#666", "#616161", "#546e7a", "#455a64", "#37474f",
|
|
],
|
|
) {
|
|
Some(&colors.secondary_weak)
|
|
} else if is_one_of(token, &["#1a1a1a"]) {
|
|
Some(&colors.background)
|
|
} else if is_one_of(
|
|
token,
|
|
&["#6db7ed", "#4cc9f0", "#4bc8f0", "#4a9eff", "#0099e5"],
|
|
) {
|
|
Some(&colors.primary)
|
|
} else if is_one_of(token, &["#1565c0"]) {
|
|
Some(&colors.primary_strong)
|
|
} else if is_one_of(token, &["#0d47a1"]) {
|
|
Some(&colors.primary_weak)
|
|
} else if is_one_of(token, &["#4ccf6f"]) {
|
|
Some(&colors.success)
|
|
} else if is_one_of(token, &["#00695c", "#004d40"]) {
|
|
Some(&colors.success_weak)
|
|
} else if is_one_of(token, &["#f0c040", "#ffd740", "#fdd835"]) {
|
|
Some(&colors.warning)
|
|
} else if is_one_of(token, &["#f9a825"]) {
|
|
Some(&colors.warning_strong)
|
|
} else if is_one_of(
|
|
token,
|
|
&[
|
|
"#e05050", "#ef5350", "#e06c6c", "#e53935", "#ff0000", "#e10000",
|
|
],
|
|
) {
|
|
Some(&colors.danger)
|
|
} else if is_one_of(token, &["#b71c1c"]) {
|
|
Some(&colors.danger_weak)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn is_one_of(token: &[u8], candidates: &[&str]) -> bool {
|
|
candidates
|
|
.iter()
|
|
.any(|candidate| token.eq_ignore_ascii_case(candidate.as_bytes()))
|
|
}
|
|
|
|
fn starts_with_word_ignore_ascii_case(source: &[u8], index: usize, word: &[u8]) -> bool {
|
|
let Some(end) = index.checked_add(word.len()) else {
|
|
return false;
|
|
};
|
|
if end > source.len()
|
|
|| !source[index..end].eq_ignore_ascii_case(word)
|
|
|| index > 0 && source[index - 1].is_ascii_alphabetic()
|
|
|| end < source.len() && source[end].is_ascii_alphabetic()
|
|
{
|
|
return false;
|
|
}
|
|
true
|
|
}
|
|
|
|
fn color_hex(color: Color) -> [u8; 7] {
|
|
const HEX: &[u8; 16] = b"0123456789abcdef";
|
|
let [red, green, blue, _] = color.into_rgba8();
|
|
[
|
|
b'#',
|
|
HEX[(red >> 4) as usize],
|
|
HEX[(red & 0x0f) as usize],
|
|
HEX[(green >> 4) as usize],
|
|
HEX[(green & 0x0f) as usize],
|
|
HEX[(blue >> 4) as usize],
|
|
HEX[(blue & 0x0f) as usize],
|
|
]
|
|
}
|
|
|
|
/// Render a chrome icon with the active Iced theme's normal text color.
|
|
pub fn themed<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().background.base.text),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render secondary chrome with the active Iced theme's text color.
|
|
pub fn themed_secondary<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().background.base.text.scale_alpha(0.72)),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render disabled chrome with the active Iced theme's text color, faded
|
|
/// like disabled text. The fade goes through the widget's opacity: an SVG
|
|
/// tint only replaces RGB, so alpha on the style colour would be ignored.
|
|
pub fn themed_disabled<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.opacity(0.42_f32)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().background.base.text),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render an emphasized chrome icon with the active Iced theme's primary color.
|
|
pub fn themed_primary<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().primary.base.color),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render an icon with the foreground chosen for a weak primary surface.
|
|
pub fn themed_primary_weak_text<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().primary.weak.text),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render a positive-state chrome icon with the active Iced theme's success color.
|
|
pub fn themed_success<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().success.base.color),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render an icon with the foreground chosen for a success-coloured surface.
|
|
pub fn themed_success_text<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().success.base.text),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render a warning-state chrome icon from the active Iced theme.
|
|
pub fn themed_warning<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().warning.base.color),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render a destructive-state chrome icon from the active Iced theme.
|
|
pub fn themed_danger<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().danger.base.color),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Render an icon with the foreground chosen for a danger-coloured surface.
|
|
pub fn themed_danger_text<'a, M: 'a>(bytes: &'static [u8], size: f32) -> Element<'a, M> {
|
|
svg(themed_handle(bytes))
|
|
.width(size)
|
|
.height(size)
|
|
.style(|theme: &Theme, _| svg::Style {
|
|
color: Some(theme.palette().danger.base.text),
|
|
})
|
|
.into()
|
|
}
|
|
|
|
/// Fixed-width check column colored from the active Iced theme.
|
|
pub fn themed_check_cell<'a, M: 'a>(active: bool) -> Element<'a, M> {
|
|
let inner: Element<'a, M> = if active {
|
|
svg(themed_handle(CHECK))
|
|
.width(11.0)
|
|
.height(11.0)
|
|
.style(|theme: &Theme, _| {
|
|
let p = theme.palette();
|
|
let pri = p.primary.base.color;
|
|
let bg_weak = p.background.weak.color;
|
|
let bg_strong = p.background.strong.color;
|
|
let fallback = p.background.weak.text;
|
|
let candidate = accessible_accent(pri, bg_weak, fallback);
|
|
let color = if wcag_contrast(candidate, bg_strong) >= 3.0 {
|
|
candidate
|
|
} else {
|
|
fallback
|
|
};
|
|
svg::Style { color: Some(color) }
|
|
})
|
|
.into()
|
|
} else {
|
|
Space::new().width(0).into()
|
|
};
|
|
container(inner)
|
|
.width(Length::Fixed(14.0))
|
|
.align_x(iced::alignment::Horizontal::Center)
|
|
.into()
|
|
}
|
|
|
|
/// SVG bytes for an OSNAP mode's marker symbol, for the snap menu. (#138)
|
|
pub fn osnap(snap: crate::snap::SnapType) -> &'static [u8] {
|
|
use crate::snap::SnapType as S;
|
|
match snap {
|
|
S::Endpoint => OSNAP_ENDPOINT,
|
|
S::Midpoint => OSNAP_MIDPOINT,
|
|
S::Center => OSNAP_CENTER,
|
|
S::GeometricCenter => OSNAP_GEOMETRIC_CENTER,
|
|
S::Node => OSNAP_NODE,
|
|
S::Quadrant => OSNAP_QUADRANT,
|
|
S::Intersection => OSNAP_INTERSECTION,
|
|
S::Extension => OSNAP_EXTENSION,
|
|
S::Insertion => OSNAP_INSERTION,
|
|
S::Perpendicular => OSNAP_PERPENDICULAR,
|
|
S::Tangent => OSNAP_TANGENT,
|
|
S::Nearest => OSNAP_NEAREST,
|
|
S::ApparentIntersection => OSNAP_APPARENT,
|
|
S::Parallel => OSNAP_PARALLEL,
|
|
S::Grid => OSNAP_GRID,
|
|
// Not shown in the snap menu; fall back to a neutral marker.
|
|
S::ObjectPick => OSNAP_NEAREST,
|
|
// 3D modes have no dedicated menu glyphs yet; reuse the closest 2D
|
|
// shapes (hollow diamond ≈ vertex, hollow triangle ≈ edge midpoint).
|
|
S::Vertex => OSNAP_NODE,
|
|
S::EdgeMidpoint => OSNAP_MIDPOINT,
|
|
S::FaceCenter => OSNAP_CENTER,
|
|
S::Knot => OSNAP_NODE,
|
|
S::FacePerpendicular => OSNAP_PERPENDICULAR,
|
|
S::NearestFace => OSNAP_NEAREST,
|
|
}
|
|
}
|
|
|
|
/// MTP menu icon: modal 2-pick modifier, not a persistent `SnapType` mode.
|
|
pub fn mtp_icon() -> &'static [u8] {
|
|
OSNAP_MTP
|
|
}
|
|
|
|
/// Context-menu glyphs for the transparent navigation rows.
|
|
pub fn pan_icon() -> &'static [u8] {
|
|
NAV_PAN
|
|
}
|
|
|
|
pub fn zoom_icon() -> &'static [u8] {
|
|
NAV_ZOOM
|
|
}
|
|
|
|
pub fn undo_icon() -> &'static [u8] {
|
|
UNDO
|
|
}
|
|
|
|
pub fn redo_icon() -> &'static [u8] {
|
|
REDO
|
|
}
|
|
|
|
/// Layer visibility icon bytes (on / off).
|
|
pub fn layer_visible(visible: bool) -> &'static [u8] {
|
|
if visible {
|
|
LAY_ON
|
|
} else {
|
|
LAY_OFF
|
|
}
|
|
}
|
|
|
|
/// Layer freeze icon bytes (frozen / thawed).
|
|
pub fn layer_freeze(frozen: bool) -> &'static [u8] {
|
|
if frozen {
|
|
LAY_FRZ
|
|
} else {
|
|
LAY_THW
|
|
}
|
|
}
|
|
|
|
/// Freeze-in-current-viewport icon bytes (frozen / thawed).
|
|
pub fn layer_vp_freeze(frozen: bool) -> &'static [u8] {
|
|
if frozen {
|
|
LAY_VP_FRZ
|
|
} else {
|
|
LAY_VP_THW
|
|
}
|
|
}
|
|
|
|
/// Layer lock icon bytes (locked / unlocked).
|
|
pub fn layer_lock(locked: bool) -> &'static [u8] {
|
|
if locked {
|
|
LAY_LCK
|
|
} else {
|
|
LAY_ULK
|
|
}
|
|
}
|
|
|
|
pub fn themed_arrow_down<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed(TRI_DOWN, size)
|
|
}
|
|
|
|
pub fn themed_arrow_up<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed(TRI_UP, size)
|
|
}
|
|
|
|
pub fn themed_arrow_right<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed(TRI_RIGHT, size)
|
|
}
|
|
|
|
pub fn themed_arrow_left<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed(TRI_LEFT, size)
|
|
}
|
|
|
|
pub fn themed_primary_weak_arrow_down<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed_primary_weak_text(TRI_DOWN, size)
|
|
}
|
|
|
|
pub fn themed_secondary_arrow_down<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed_secondary(TRI_DOWN, size)
|
|
}
|
|
|
|
pub fn themed_disabled_arrow_down<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed_disabled(TRI_DOWN, size)
|
|
}
|
|
|
|
pub fn themed_disabled_arrow_right<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed_disabled(TRI_RIGHT, size)
|
|
}
|
|
|
|
pub fn themed_home<'a, M: 'a>(size: f32) -> Element<'a, M> {
|
|
themed(HOME, size)
|
|
}
|
|
|
|
/// Caret that flips up/down with `open`.
|
|
pub fn themed_arrow_toggle<'a, M: 'a>(open: bool, size: f32) -> Element<'a, M> {
|
|
if open {
|
|
themed_arrow_up(size)
|
|
} else {
|
|
themed_arrow_down(size)
|
|
}
|
|
}
|
|
|
|
pub fn themed_undo<'a, M: 'a>(size: f32, enabled: bool) -> Element<'a, M> {
|
|
if enabled {
|
|
themed(UNDO, size)
|
|
} else {
|
|
themed_disabled(UNDO, size)
|
|
}
|
|
}
|
|
|
|
pub fn themed_redo<'a, M: 'a>(size: f32, enabled: bool) -> Element<'a, M> {
|
|
if enabled {
|
|
themed(REDO, size)
|
|
} else {
|
|
themed_disabled(REDO, size)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn semantic_svg_uses_multiple_theme_roles() {
|
|
let source = br##"<svg>
|
|
<path stroke="#e0e0e0"/>
|
|
<path fill="#4cc9f0"/>
|
|
<path fill="#f0c040"/>
|
|
<path fill="#e05050"/>
|
|
<path fill="#4ccf6f"/>
|
|
<path fill="#123456"/>
|
|
</svg>"##;
|
|
let theme = Theme::Dark;
|
|
let colors = SemanticColors::from_theme(&theme);
|
|
let themed = recolor_semantic_svg(source, &theme);
|
|
|
|
assert!(contains(&themed, &colors.text));
|
|
assert!(contains(&themed, &colors.primary));
|
|
assert!(contains(&themed, &colors.warning));
|
|
assert!(contains(&themed, &colors.danger));
|
|
assert!(contains(&themed, &colors.success));
|
|
assert!(contains(&themed, b"#123456"));
|
|
}
|
|
|
|
#[test]
|
|
fn semantic_svg_maps_named_white() {
|
|
let theme = Theme::Dark;
|
|
let colors = SemanticColors::from_theme(&theme);
|
|
let themed = recolor_semantic_svg(br##"<path stroke="white"/>"##, &theme);
|
|
|
|
assert!(contains(&themed, &colors.text));
|
|
}
|
|
|
|
fn contains(source: &[u8], needle: &[u8]) -> bool {
|
|
source.windows(needle.len()).any(|window| window == needle)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod themed_cache_tests {
|
|
use super::*;
|
|
|
|
/// Number of `svg::Handle` entries currently in the `THEMED_CACHE`.
|
|
/// Test-only inspection helper; the cache is private production state.
|
|
fn themed_cache_size_for_test() -> usize {
|
|
THEMED_CACHE.with(|c| c.borrow().map.len())
|
|
}
|
|
|
|
/// True when `(ptr, len)` (the address and length of a
|
|
/// `&'static [u8]`) has an entry in the `THEMED_CACHE`.
|
|
/// Test-only inspection helper.
|
|
fn themed_cache_contains_for_test(ptr: *const u8, len: usize) -> bool {
|
|
THEMED_CACHE.with(|c| c.borrow().map.contains_key(&(ptr as usize, len)))
|
|
}
|
|
|
|
/// Returns a clone of the cached `svg::Handle` for `(ptr, len)`,
|
|
/// or `None` if no entry is cached. Test-only inspection helper.
|
|
fn themed_cache_get_handle_for_test(ptr: *const u8, len: usize) -> Option<svg::Handle> {
|
|
THEMED_CACHE.with(|c| c.borrow().map.get(&(ptr as usize, len)).cloned())
|
|
}
|
|
|
|
/// Removes the cache entry for `(ptr, len)`. Test-only helper so
|
|
/// individual tests can start from a known-empty cache regardless
|
|
/// of test execution order (tests share the `thread_local!` when
|
|
/// run on the same thread).
|
|
fn themed_cache_remove_for_test(ptr: *const u8, len: usize) {
|
|
THEMED_CACHE.with(|c| {
|
|
let mut c = c.borrow_mut();
|
|
let key = (ptr as usize, len);
|
|
c.map.remove(&key);
|
|
for slot in &mut c.mru {
|
|
if let Some((k, _)) = slot {
|
|
if *k == key {
|
|
*slot = None;
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Two calls to the public `themed` function with the same
|
|
/// `&'static [u8]` must share a single cache entry: the second
|
|
/// call is a cache hit, not a fresh `Handle::from_memory`.
|
|
#[test]
|
|
fn themed_cache_returns_same_handle_for_same_bytes() {
|
|
themed_cache_remove_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len());
|
|
assert!(
|
|
!themed_cache_contains_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len()),
|
|
"precondition: TRI_DOWN must not be cached before the test"
|
|
);
|
|
let size_before = themed_cache_size_for_test();
|
|
let _: Element<'static, ()> = themed(TRI_DOWN, 16.0);
|
|
let _: Element<'static, ()> = themed(TRI_DOWN, 16.0);
|
|
assert_eq!(
|
|
themed_cache_size_for_test(),
|
|
size_before + 1,
|
|
"two calls with the same bytes must share a single cache entry (delta +1)"
|
|
);
|
|
assert!(
|
|
themed_cache_contains_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len()),
|
|
"cache must hold an entry for the requested bytes"
|
|
);
|
|
}
|
|
|
|
/// Distinct `&'static [u8]` slices must produce distinct cache
|
|
/// entries (no false aliasing across different artwork).
|
|
#[test]
|
|
fn themed_cache_caches_distinct_bytes_separately() {
|
|
themed_cache_remove_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len());
|
|
themed_cache_remove_for_test(TRI_UP.as_ptr(), TRI_UP.len());
|
|
assert!(!themed_cache_contains_for_test(
|
|
TRI_DOWN.as_ptr(),
|
|
TRI_DOWN.len()
|
|
));
|
|
assert!(!themed_cache_contains_for_test(
|
|
TRI_UP.as_ptr(),
|
|
TRI_UP.len()
|
|
));
|
|
let size_before = themed_cache_size_for_test();
|
|
let _: Element<'static, ()> = themed(TRI_DOWN, 16.0);
|
|
let _: Element<'static, ()> = themed(TRI_UP, 16.0);
|
|
assert_eq!(
|
|
themed_cache_size_for_test(),
|
|
size_before + 2,
|
|
"distinct bytes must produce distinct cache entries (delta +2)"
|
|
);
|
|
assert!(themed_cache_contains_for_test(
|
|
TRI_DOWN.as_ptr(),
|
|
TRI_DOWN.len()
|
|
));
|
|
assert!(themed_cache_contains_for_test(
|
|
TRI_UP.as_ptr(),
|
|
TRI_UP.len()
|
|
));
|
|
}
|
|
|
|
/// The cached `svg::Handle` is a single source of truth: two
|
|
/// calls with the same bytes must return a handle derived from
|
|
/// the same cache entry, not a freshly-built handle.
|
|
///
|
|
/// **`svg::Handle` is opaque and has no `PartialEq` impl**, so
|
|
/// we cannot compare handles directly for pointer-identity. The
|
|
/// best verifiable proxy is: (a) the second call does not grow
|
|
/// the cache (a buggy `entry().or_insert_with` that always
|
|
/// inserted would still show size 1 for a single key, so this
|
|
/// rules out a double-insert on a single key), and (b) the
|
|
/// getter returns the cached handle across the two calls (the
|
|
/// cache survived and still resolves the key). Together these
|
|
/// confirm the cache is a single source — the test's identity
|
|
/// guarantee is the weaker "the cache is populated and reused"
|
|
/// rather than the stronger "the handle is pointer-identical",
|
|
/// which `svg::Handle` does not expose.
|
|
#[test]
|
|
fn themed_cache_second_call_is_a_cache_hit() {
|
|
themed_cache_remove_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len());
|
|
assert!(
|
|
!themed_cache_contains_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len()),
|
|
"precondition: TRI_DOWN must not be cached"
|
|
);
|
|
let size_before = themed_cache_size_for_test();
|
|
// Warm the cache with the first call (miss → build → insert).
|
|
let _: Element<'static, ()> = themed(TRI_DOWN, 16.0);
|
|
let cached_after_first =
|
|
themed_cache_get_handle_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len())
|
|
.expect("cache must hold the handle after the first call");
|
|
let size_after_first = themed_cache_size_for_test();
|
|
assert_eq!(
|
|
size_after_first,
|
|
size_before + 1,
|
|
"first call must insert exactly one entry"
|
|
);
|
|
// Second call: must be a cache hit, not a fresh build.
|
|
let _: Element<'static, ()> = themed(TRI_DOWN, 16.0);
|
|
let cached_after_second =
|
|
themed_cache_get_handle_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len())
|
|
.expect("cache must still hold the handle after the second call");
|
|
assert_eq!(
|
|
themed_cache_size_for_test(),
|
|
size_after_first,
|
|
"second call must not grow the cache (hit, not rebuild)"
|
|
);
|
|
let _ = (cached_after_first, cached_after_second);
|
|
}
|
|
|
|
/// Wrapper functions (e.g. `themed_arrow_down`) delegate to
|
|
/// the 9 `themed*` byte-taking functions and therefore inherit
|
|
/// the cache transparently. This end-to-end test confirms the
|
|
/// delegation: a wrapper call populates the cache for its
|
|
/// underlying static bytes. The cache entry is cleared first so
|
|
/// the assertion is independent of test execution order (tests
|
|
/// share the `thread_local!` when run on the same thread).
|
|
#[test]
|
|
fn themed_wrapper_populates_cache_for_underlying_bytes() {
|
|
themed_cache_remove_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len());
|
|
assert!(
|
|
!themed_cache_contains_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len()),
|
|
"precondition: TRI_DOWN must not be cached before the call"
|
|
);
|
|
let size_before = themed_cache_size_for_test();
|
|
// `themed_arrow_down` delegates to `themed(TRI_DOWN, size)`.
|
|
let _: Element<'static, ()> = themed_arrow_down(16.0);
|
|
assert_eq!(
|
|
themed_cache_size_for_test(),
|
|
size_before + 1,
|
|
"one wrapper call must populate exactly one cache entry (delta +1)"
|
|
);
|
|
assert!(
|
|
themed_cache_contains_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len()),
|
|
"the cache must hold an entry for the wrapper's underlying bytes (TRI_DOWN)"
|
|
);
|
|
}
|
|
|
|
/// Cache key includes length: a sub-slice of a static must not
|
|
/// alias the full static's entry. This guards the
|
|
/// `(address, length)` belt-and-braces key `src/ui/icons.rs:164`
|
|
/// — a pointer-only key would incorrectly hit on `&BYTES[1..]`.
|
|
#[test]
|
|
fn themed_cache_key_includes_length() {
|
|
// Ensure clean state for both keys.
|
|
themed_cache_remove_for_test(TRI_DOWN.as_ptr(), TRI_DOWN.len());
|
|
// Sub-slice of TRI_DOWN: same address region but different length.
|
|
// SAFETY: TRI_DOWN is at least 2 bytes (real SVG), so [1..] is valid.
|
|
let sub = &TRI_DOWN[1..];
|
|
themed_cache_remove_for_test(sub.as_ptr(), sub.len());
|
|
assert!(!themed_cache_contains_for_test(
|
|
TRI_DOWN.as_ptr(),
|
|
TRI_DOWN.len()
|
|
));
|
|
assert!(!themed_cache_contains_for_test(sub.as_ptr(), sub.len()));
|
|
let size_before = themed_cache_size_for_test();
|
|
// Populate full static.
|
|
let _: Element<'static, ()> = themed(TRI_DOWN, 16.0);
|
|
assert!(themed_cache_contains_for_test(
|
|
TRI_DOWN.as_ptr(),
|
|
TRI_DOWN.len()
|
|
));
|
|
assert!(
|
|
!themed_cache_contains_for_test(sub.as_ptr(), sub.len()),
|
|
"sub-slice must not hit the full static's entry"
|
|
);
|
|
assert_eq!(themed_cache_size_for_test(), size_before + 1);
|
|
// Populate sub-slice directly via the internal helper (bypasses
|
|
// the `themed` wrappers which only use the full statics).
|
|
let _ = super::themed_handle(sub);
|
|
assert!(themed_cache_contains_for_test(sub.as_ptr(), sub.len()));
|
|
assert_eq!(
|
|
themed_cache_size_for_test(),
|
|
size_before + 2,
|
|
"sub-slice must produce a distinct entry (length part of key)"
|
|
);
|
|
}
|
|
|
|
/// Before/after benchmark: the cached `themed_handle` path
|
|
/// (hashmap get + a `svg::Handle` clone) vs. the original
|
|
/// un-cached path (`svg::Handle::from_memory` per call, which
|
|
/// parses the SVG and allocates).
|
|
///
|
|
/// Integrated as a `#[test]` so it runs in the existing
|
|
/// `cargo test --lib` flow with no extra infrastructure — no
|
|
/// `criterion`, no `benches/` directory, no nightly
|
|
/// `#![feature(test)]`. The "before" is faithfully simulated by
|
|
/// calling `svg::Handle::from_memory` directly on the same
|
|
/// `&'static [u8]`, which is exactly what the pre-cache code did
|
|
/// per call. The "after" warms the cache first so the loop
|
|
/// measures pure cache hits. A cold cache miss is also measured
|
|
/// on a different static.
|
|
///
|
|
/// Run with `--nocapture` to see the numbers:
|
|
/// `cargo test --lib themed_cache_speedup_over_uncached_handle_creation -- --ignored --nocapture`.
|
|
///
|
|
/// Ignored by default: it compares wall-clock times, and under the
|
|
/// parallel suite's load the uncached loop can finish first. The cache's
|
|
/// behaviour is pinned by the entry-count tests above.
|
|
#[test]
|
|
#[ignore = "wall-clock benchmark; run with --ignored"]
|
|
fn themed_cache_speedup_over_uncached_handle_creation() {
|
|
use std::time::Instant;
|
|
|
|
const ITER: u64 = 20_000;
|
|
let bytes = TRI_DOWN; // &'static [u8]
|
|
|
|
// Warm the cache so the "after" loop measures pure cache hits.
|
|
let _ = super::themed_handle(bytes);
|
|
|
|
// After: cached path — one hashmap get + a `Handle` clone per call.
|
|
let t_after = Instant::now();
|
|
for _ in 0..ITER {
|
|
let _h = super::themed_handle(bytes);
|
|
}
|
|
let after = t_after.elapsed();
|
|
|
|
// Before: original (un-cached) path — SVG parse + allocation per call.
|
|
let t_before = Instant::now();
|
|
for _ in 0..ITER {
|
|
let _h = svg::Handle::from_memory(bytes);
|
|
}
|
|
let before = t_before.elapsed();
|
|
|
|
// Cold first call (cache miss): one parse + one insert. Measured
|
|
// on a different static so the entry is guaranteed to be fresh.
|
|
let cold_bytes = TRI_UP;
|
|
let t_cold = Instant::now();
|
|
let _h = super::themed_handle(cold_bytes);
|
|
let cold = t_cold.elapsed();
|
|
|
|
let after_ns = after.as_nanos() as u64;
|
|
let before_ns = before.as_nanos() as u64;
|
|
let cold_ns = cold.as_nanos() as u64;
|
|
let per_after = after_ns / ITER;
|
|
let per_before = before_ns / ITER;
|
|
let speedup = if after_ns > 0 {
|
|
before_ns as f64 / after_ns as f64
|
|
} else {
|
|
f64::INFINITY
|
|
};
|
|
|
|
println!(
|
|
"themed_handle: before={}ns/iter, after={}ns/iter, speedup={:.1}x, cold_miss={}ns (ITER={})",
|
|
per_before, per_after, speedup, cold_ns, ITER,
|
|
);
|
|
|
|
assert!(
|
|
after_ns < before_ns,
|
|
"cached path must be faster than from_memory: after={}ns before={}ns",
|
|
after_ns,
|
|
before_ns,
|
|
);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod check_cell_tests {
|
|
use super::*;
|
|
use crate::ui::style::common::{accessible_accent, wcag_contrast};
|
|
|
|
#[test]
|
|
fn themed_check_cell_contrast_across_all_themes() {
|
|
for theme in iced::Theme::ALL {
|
|
let p = theme.palette();
|
|
let bg_weak = p.background.weak.color;
|
|
let bg_strong = p.background.strong.color;
|
|
let pri = p.primary.base.color;
|
|
let fallback = p.background.weak.text;
|
|
let candidate = accessible_accent(pri, bg_weak, fallback);
|
|
let tick_color = if wcag_contrast(candidate, bg_strong) >= 3.0 {
|
|
candidate
|
|
} else {
|
|
fallback
|
|
};
|
|
let contrast_weak = wcag_contrast(tick_color, bg_weak);
|
|
let contrast_strong = wcag_contrast(tick_color, bg_strong);
|
|
assert!(
|
|
contrast_weak >= 3.0,
|
|
"Theme {:?} checkmark contrast {:.2}:1 against weak background is below 3.0:1",
|
|
theme,
|
|
contrast_weak
|
|
);
|
|
assert!(
|
|
contrast_strong >= 3.0,
|
|
"Theme {:?} checkmark contrast {:.2}:1 against strong background is below 3.0:1",
|
|
theme,
|
|
contrast_strong
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn themed_check_cell_dimensions() {
|
|
let active: Element<'static, ()> = themed_check_cell(true);
|
|
let inactive: Element<'static, ()> = themed_check_cell(false);
|
|
assert_eq!(active.as_widget().size().width, Length::Fixed(14.0));
|
|
assert_eq!(inactive.as_widget().size().width, Length::Fixed(14.0));
|
|
}
|
|
}
|