use crabshell_reactive::Signal;
use crabshell_ui::{
Align, Canvas, Cap, Color, Gradient, Join, PanelWindow, Path, Point, Rect, Row, Stack, Stroke,
Style,
};
use super::{Buffer, Scene, assert_golden};
use crate::DamageHistory;
const BACKGROUND: Style = Style::new().background(Color::hex("#1e1e2e"));
const TRACK: Color = Color::hex("#45475a");
const GREEN: Color = Color::hex("#a6e3a1");
const BLUE: Color = Color::hex("#89b4fa");
const PEACH: Color = Color::hex("#fab387");
fn ring(progress: Signal<f32>) -> Canvas {
Canvas::new(move |pen| {
let size = pen.size();
let middle = Point::new(size.width / 2.0, size.height / 2.0);
let radius = size.width.min(size.height) / 2.0 - 4.0;
pen.stroke(&Path::circle(middle, radius), &Stroke::new(4.0, TRACK));
let arc = Path::new().arc(middle, radius, -90.0, 360.0 * progress.get());
pen.stroke(&arc, &Stroke::new(4.0, GREEN).cap(Cap::Round));
})
.style(Style::new().width(36.0).height(36.0))
}
fn points(samples: &[f32], width: f32, height: f32) -> Vec<Point> {
let step = width / (samples.len() - 1) as f32;
samples
.iter()
.enumerate()
.map(|(i, sample)| Point::new(i as f32 * step, height * (1.0 - sample)))
.collect()
}
fn graph(samples: Signal<Vec<f32>>) -> Canvas {
Canvas::new(move |pen| {
let size = pen.size();
let points = points(&samples.get(), size.width, size.height);
let line = points[1..]
.iter()
.fold(Path::new().move_to(points[0]), |path, &p| path.line_to(p));
let area = line
.clone()
.line_to(Point::new(size.width, size.height))
.line_to(Point::new(0.0, size.height))
.close();
pen.fill(
&area,
Gradient::linear(
180.0,
Color::rgba(0x89, 0xb4, 0xfa, 0xc0),
Color::rgba(0x89, 0xb4, 0xfa, 0),
),
);
pen.stroke(&line, &Stroke::new(1.5, BLUE).join(Join::Round));
})
.style(Style::new().width(80.0).height(36.0))
}
fn dashes() -> Canvas {
Canvas::new(|pen| {
let zigzag = Path::new()
.move_to(Point::new(4.0, 30.0))
.line_to(Point::new(16.0, 6.0))
.line_to(Point::new(28.0, 30.0))
.line_to(Point::new(40.0, 6.0));
let dashed = Stroke::new(2.0, PEACH)
.cap(Cap::Square)
.join(Join::Bevel)
.dash(&[5.0, 3.0], 1.0);
pen.stroke(&zigzag, &dashed);
let curves = Path::new()
.move_to(Point::new(46.0, 30.0))
.cubic_to(
Point::new(50.0, 0.0),
Point::new(60.0, 40.0),
Point::new(64.0, 8.0),
)
.quad_to(Point::new(70.0, 0.0), Point::new(76.0, 30.0));
pen.stroke(
&curves,
&Stroke::new(2.0, GREEN)
.cap(Cap::Round)
.dash(&[0.0, 4.0], 0.0),
);
})
.style(Style::new().width(80.0).height(36.0))
}
fn layered() -> Stack {
Stack::new()
.style(Style::new().opacity(0.6).rotate(12.0))
.child(
Canvas::new(|pen| {
pen.fill(&Path::ellipse(Point::new(18.0, 18.0), 26.0, 12.0), PEACH);
pen.fill(
&Path::rounded_rect(Rect::new(8.0, 8.0, 20.0, 20.0), 4.0),
BLUE,
);
})
.style(
Style::new()
.width(36.0)
.height(36.0)
.radius(10.0)
.border(1.0, GREEN),
),
)
}
fn panel(scene: &Scene) -> PanelWindow {
let progress = scene.cx.signal(0.7_f32);
let samples = scene
.cx
.signal(vec![0.2, 0.5, 0.35, 0.8, 0.6, 0.9, 0.4, 0.55]);
scene.panel().style(BACKGROUND).child(
Row::new()
.padding(4, 6)
.gap(8)
.align(Align::Center)
.child(ring(progress))
.child(graph(samples))
.child(dashes())
.child(layered()),
)
}
#[test]
fn canvases() {
for (scale, suffix) in [(1.0, "1x"), (1.5, "1.5x"), (2.0, "2x")] {
let mut scene = Scene::new();
let panel = panel(&scene);
let window = scene.window(panel, 270.0, 44.0);
let buffer = scene.full(&window, scale);
assert_golden(&format!("canvas@{suffix}"), &buffer);
}
}
#[test]
fn a_canvas_redrawn_after_a_change_matches_a_fresh_draw() {
for scale in [1.0, 1.25, 1.5, 1.75, 2.0] {
let mut scene = Scene::new();
let progress = scene.cx.signal(0.3_f32);
let samples = scene.cx.signal(vec![0.1, 0.9, 0.3]);
let panel = scene.panel().style(BACKGROUND).child(
Row::new()
.padding(4, 6)
.gap(8)
.align(Align::Center)
.child(ring(progress))
.child(graph(samples))
.child(layered()),
);
let window = scene.window(panel, 200.0, 44.0);
let mut history = DamageHistory::new();
let mut buffer = Buffer::new(&window, scale);
scene.draw(&window, &mut history, &mut buffer);
progress.set(0.85);
samples.set(vec![0.7, 0.2, 0.6, 0.4]);
scene.frame(&window);
let damage = window.take_damage();
let canvases = [
super::node_at(window.view().root(), &[0, 0]).bounds(),
super::node_at(window.view().root(), &[0, 1]).bounds(),
];
assert_eq!(damage, canvases, "only the two canvases repaint");
super::repaint::repaint(&mut scene, &window, &damage, &mut history, &mut buffer);
let full = scene.full(&window, scale);
assert!(buffer.pixels == full.pixels, "at {scale}");
}
}
#[test]
fn a_canvas_draws_only_inside_its_box() {
let mut scene = Scene::new();
let canvas = Canvas::new(|pen| {
pen.fill(&Path::rect(Rect::new(-50.0, -50.0, 200.0, 200.0)), BLUE);
})
.style(Style::new().width(20.0).height(10.0));
let panel = scene.panel().child(Row::new().padding(5, 5).child(canvas));
let window = scene.window(panel, 40.0, 30.0);
for scale in [1.0, 1.5, 2.0] {
let buffer = scene.full(&window, scale);
let px = |x: f32, y: f32| buffer.pixel((x * scale) as u32, (y * scale) as u32);
assert_eq!(px(10.0, 8.0), [0x89, 0xb4, 0xfa, 255], "inside at {scale}");
for (x, y) in [(2.0, 8.0), (27.0, 8.0), (10.0, 2.0), (10.0, 17.0)] {
assert_eq!(px(x, y), [0, 0, 0, 0], "outside at {x}, {y} at {scale}");
}
}
}