use egui::{Response, RichText, Sense, Ui, Vec2};
use makeover_layout::{Awaiting, Token, Tone, progress_reading};
use makeover_timing::{MotionPreference, blink};
use std::time::Duration;
use crate::Palette;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PieceStyle {
pub meter_height: f32,
pub meter_width: Option<f32>,
pub chart_height: f32,
pub radius: u8,
pub token_padding: Vec2,
pub figure_gap: f32,
pub figure_scale: f32,
pub mark_size: f32,
}
impl Default for PieceStyle {
fn default() -> Self {
Self {
meter_height: 6.0,
meter_width: None,
chart_height: 200.0,
radius: 3,
token_padding: Vec2::new(6.0, 2.0),
figure_gap: 2.0,
figure_scale: 2.0,
mark_size: 8.0,
}
}
}
pub fn token(
ui: &mut Ui,
label: &str,
kind: Token,
tone: Tone,
latched: bool,
palette: &Palette,
style: &PieceStyle,
) -> Response {
let painted = palette.tone(tone);
let radius = style.radius;
let sense = if kind.interactive() {
Sense::click()
} else {
Sense::hover()
};
let neutral = tone == Tone::Neutral;
let ink = match kind {
Token::Chip { .. } if latched && neutral => palette.page,
_ => palette.content,
};
let galley = ui.painter().layout_no_wrap(
label.to_owned(),
egui::TextStyle::Body.resolve(ui.style()),
ink,
);
let size = galley.size() + style.token_padding * 2.0;
let (rect, response) = ui.allocate_exact_size(size, sense);
if kind == Token::Badge {
ui.painter().rect(
rect,
radius,
palette.tone_surface(tone),
egui::Stroke::new(1.0, palette.tone_edge(tone)),
egui::StrokeKind::Inside,
);
} else if latched && neutral {
ui.painter().rect_filled(rect, radius, painted);
} else if latched {
ui.painter().rect(
rect,
radius,
palette.tone_surface(tone),
egui::Stroke::new(1.0, painted),
egui::StrokeKind::Inside,
);
} else {
ui.painter().rect_stroke(
rect,
radius,
egui::Stroke::new(1.0, painted),
egui::StrokeKind::Inside,
);
}
ui.painter()
.galley(rect.center() - galley.size() / 2.0, galley, ink);
let role = if kind.interactive() {
egui::WidgetType::Button
} else {
egui::WidgetType::Label
};
response.widget_info(|| {
let mut info = egui::WidgetInfo::labeled(role, ui.is_enabled(), label);
if kind.interactive() {
info.selected = Some(latched);
}
info
});
response
}
pub use makeover_layout::Progress;
pub fn activity(
ui: &mut Ui,
motion: MotionPreference,
palette: &Palette,
style: &PieceStyle,
) -> Response {
let (rect, response) = ui.allocate_exact_size(Vec2::splat(style.mark_size), Sense::hover());
let elapsed = Duration::try_from_secs_f64(ui.input(|input| input.time)).unwrap_or_default();
let (lit, until) = blink(elapsed, motion);
if let Some(until) = until {
ui.ctx().request_repaint_after(until);
}
let colour = if lit { palette.action } else { palette.sunken };
ui.painter().rect_filled(rect, style.radius, colour);
response
}
pub fn awaiting(
ui: &mut Ui,
awaiting: Awaiting,
progress: Progress,
motion: MotionPreference,
palette: &Palette,
style: &PieceStyle,
) -> Response {
let (Some(total), Some(done)) = (awaiting.amount, progress.delivered) else {
return activity(ui, motion, palette, style);
};
let reading = progress_reading(done, total, progress.elapsed);
let width = style.meter_width.unwrap_or_else(|| {
let text = RichText::new(&reading).color(palette.content_muted);
let galley = egui::WidgetText::from(text).into_galley(
ui,
Some(egui::TextWrapMode::Extend),
f32::INFINITY,
egui::TextStyle::Body,
);
(ui.available_width() - galley.size().x - ui.spacing().item_spacing.x).max(1.0)
});
ui.horizontal(|ui| {
let (rect, response) =
ui.allocate_exact_size(Vec2::new(width, style.meter_height), Sense::hover());
ui.painter().rect_filled(rect, style.radius, palette.sunken);
let share = if total == 0 {
0.0
} else {
#[expect(
clippy::cast_precision_loss,
reason = "a byte count past 2^53 is not a wait anyone is watching a bar for"
)]
let share = (done as f64 / total as f64).min(1.0);
share
};
#[expect(
clippy::cast_possible_truncation,
reason = "a share is 0..=1 and the product is a width in points"
)]
let filled = (f64::from(rect.width()) * share) as f32;
if filled > 0.0 {
let mut fill = rect;
fill.set_width(filled);
ui.painter().rect_filled(fill, style.radius, palette.action);
}
ui.label(RichText::new(reading).color(palette.content_muted));
response
})
.inner
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tests::palette;
fn announced(
draw: impl FnMut(&mut Ui),
) -> Vec<(
egui::accesskit::Role,
String,
Option<egui::accesskit::Toggled>,
)> {
let ctx = egui::Context::default();
ctx.enable_accesskit();
let mut draw = draw;
let input = || egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(
egui::Pos2::ZERO,
egui::vec2(600.0, 400.0),
)),
..Default::default()
};
ctx.run_ui(input(), &mut draw).textures_delta.clear();
let mut out = ctx.run_ui(input(), &mut draw);
out.textures_delta.clear();
out.platform_output
.accesskit_update
.expect("accesskit is on")
.nodes
.iter()
.map(|(_, node)| {
(
node.role(),
node.label()
.or_else(|| node.value())
.unwrap_or_default()
.to_owned(),
node.toggled(),
)
})
.collect()
}
fn inked(draw: impl FnMut(&mut Ui)) -> Vec<(String, egui::Color32)> {
fn walk(shape: &egui::Shape, out: &mut Vec<(String, egui::Color32)>) {
match shape {
egui::Shape::Text(t) => {
let format = t.galley.job.sections.first().map(|s| s.format.color);
let colour = format
.filter(|c| *c != egui::Color32::PLACEHOLDER)
.unwrap_or(t.fallback_color);
out.push((t.galley.job.text.clone(), colour));
}
egui::Shape::Vec(shapes) => shapes.iter().for_each(|s| walk(s, out)),
_ => {}
}
}
let ctx = egui::Context::default();
let mut draw = draw;
let input = egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(
egui::Pos2::ZERO,
egui::vec2(600.0, 400.0),
)),
..Default::default()
};
let mut output = ctx.run_ui(input, &mut draw);
output.textures_delta.clear();
let mut out = Vec::new();
for clipped in &output.shapes {
walk(&clipped.shape, &mut out);
}
out
}
#[test]
fn a_toned_tokens_words_are_content_whether_or_not_it_is_latched() {
let p = palette();
let style = PieceStyle::default();
for kind in [Token::Badge, Token::Chip { removable: false }] {
for latched in [false, true] {
let drawn = inked(|ui| {
token(ui, "overdue", kind, Tone::Danger, latched, &p, &style);
});
let (_, colour) = drawn
.iter()
.find(|(text, _)| text == "overdue")
.unwrap_or_else(|| panic!("nothing painted: {drawn:?}"));
assert_eq!(*colour, p.content, "{kind:?} latched {latched}");
}
}
}
#[test]
fn a_chip_is_announced_as_a_control_and_says_whether_it_is_held() {
let p = palette();
let style = PieceStyle::default();
let drawn = announced(|ui| {
token(
ui,
"C#",
Token::Chip { removable: false },
Tone::Neutral,
true,
&p,
&style,
);
});
let chip = drawn
.iter()
.find(|(role, name, _)| *role == egui::accesskit::Role::Button && name == "C#")
.unwrap_or_else(|| panic!("the chip is not in the tree: {drawn:?}"));
assert_eq!(
chip.2,
Some(egui::accesskit::Toggled::True),
"a latched chip is held down and says so: {drawn:?}"
);
}
#[test]
fn a_badge_is_announced_as_the_text_it_is() {
let p = palette();
let style = PieceStyle::default();
let drawn = announced(|ui| {
token(ui, "wav", Token::Badge, Tone::Neutral, false, &p, &style);
});
assert!(
drawn
.iter()
.any(|(role, name, _)| *role == egui::accesskit::Role::Label && name == "wav"),
"{drawn:?}"
);
assert!(
!drawn
.iter()
.any(|(role, _, _)| *role == egui::accesskit::Role::Button),
"a badge answers nothing and must not claim to: {drawn:?}"
);
}
#[test]
fn every_tone_resolves_and_no_two_share_a_colour() {
let p = palette();
let all = [
p.tone(Tone::Neutral),
p.tone(Tone::Info),
p.tone(Tone::Success),
p.tone(Tone::Warning),
p.tone(Tone::Danger),
];
for (i, a) in all.iter().enumerate() {
for b in &all[i + 1..] {
assert_ne!(a, b, "two tones resolved to one colour");
}
}
assert_eq!(p.tone(Tone::Neutral), p.content, "neutral is ordinary text");
}
#[test]
fn a_wait_draws_a_bar_only_when_something_is_counting_it() {
let p = palette();
let style = PieceStyle::default();
egui::__run_test_ui(|ui| {
awaiting(
ui,
Awaiting::unmeasured(),
Progress::default(),
MotionPreference::Full,
&p,
&style,
);
awaiting(
ui,
Awaiting::of(41_943_040),
Progress::default(),
MotionPreference::Full,
&p,
&style,
);
awaiting(
ui,
Awaiting::of(41_943_040),
Progress {
delivered: Some(10_485_760),
elapsed: Some(Duration::from_secs(3)),
},
MotionPreference::Full,
&p,
&style,
);
awaiting(
ui,
Awaiting::of(0),
Progress {
delivered: Some(9),
elapsed: None,
},
MotionPreference::Full,
&p,
&style,
);
awaiting(
ui,
Awaiting::of(4),
Progress {
delivered: Some(9),
elapsed: None,
},
MotionPreference::Full,
&p,
&style,
);
});
}
#[test]
fn reduced_motion_stills_the_mark_and_does_not_remove_it() {
let p = palette();
let style = PieceStyle::default();
egui::__run_test_ui(|ui| {
let still = activity(ui, MotionPreference::Reduced, &p, &style);
let blinking = activity(ui, MotionPreference::Full, &p, &style);
assert_eq!(
still.rect.size(),
blinking.rect.size(),
"the mark occupies the same space either way"
);
});
}
#[test]
fn a_chip_answers_a_click_and_a_badge_does_not() {
let p = palette();
let style = PieceStyle::default();
egui::__run_test_ui(|ui| {
let badge = token(ui, "beta", Token::Badge, Tone::Info, false, &p, &style);
assert!(!badge.sense.senses_click(), "a badge answers no click");
let chip = token(
ui,
"drums",
Token::Chip { removable: false },
Tone::Neutral,
false,
&p,
&style,
);
assert!(chip.sense.senses_click(), "a chip answers a click");
});
}
#[test]
fn a_wait_keeps_its_reading_inside_the_panel() {
let ctx = egui::Context::default();
ctx.set_fonts(egui::FontDefinitions::default());
ctx.memory_mut(|m| m.options.max_passes = std::num::NonZeroUsize::new(1).unwrap());
let p = palette();
let style = PieceStyle::default();
let mut used = 0.0f32;
let mut budget = 0.0f32;
let input = egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(
egui::Pos2::ZERO,
egui::Vec2::new(300.0, 400.0),
)),
..Default::default()
};
let output = ctx.run_ui(input, |ui| {
let left = ui.min_rect().left();
budget = ui.available_width();
awaiting(
ui,
Awaiting::of(41_943_040),
Progress {
delivered: Some(10_485_760),
elapsed: Some(Duration::from_secs(3)),
},
MotionPreference::Full,
&p,
&style,
);
used = ui.min_rect().right() - left;
});
output.drop_without_applying_deltas();
assert!(
used <= budget + 0.5,
"the bar and its reading drew to {used}, past the {budget}pt on offer"
);
}
}