use std::{
cell::RefCell,
collections::BTreeMap,
rc::Rc,
sync::{Arc, Mutex, MutexGuard},
};
use sui_core::{
Color, Event, KeyState, Path, PathBuilder, PathElement, Point, PointerButton, PointerEvent,
PointerEventKind, PointerKind, Rect, ScrollDelta, SemanticsAction, SemanticsNode,
SemanticsRole, SemanticsValue, Size, Transform, Vector,
};
use sui_layout::Constraints;
use sui_runtime::{
ArrangeCtx, EventCtx, EventPhase, MeasureCtx, PaintCtx, SemanticsCtx, SingleChild, Widget,
WidgetPod, WidgetPodMutVisitor, WidgetPodVisitor,
};
use sui_scene::{ImageSampling, ImageSource, RegisteredImage, StrokeStyle};
use sui_text::{FontFeature, TextAlign, TextMeasurement, TextStyle};
use crate::frame::{physical_pixels, stroke_border};
use crate::{DefaultTheme, text_align::paint_text};
const AXIS_ALIGNED_EPSILON: f32 = 0.0001;
const MIN_CANVAS_GRID_SCREEN_SPACING: f32 = 12.0;
const PIXEL_CANVAS_HISTORY_LIMIT: usize = 32;
const CANVAS_RULER_MAX_TICKS: usize = 400;
type AnimatedScalar = crate::Progress;
fn set_focus_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) {
animation.animate(target, theme.motion.focus_spec(), ctx);
}
fn draw_focus_ring(ctx: &mut PaintCtx, bounds: Rect, theme: &DefaultTheme, progress: f32) {
if progress <= AnimatedScalar::EPSILON || bounds.is_empty() {
return;
}
let metrics = theme.metrics;
crate::frame::draw_focus_ring(
ctx,
bounds,
metrics.corner_radius,
metrics,
theme
.palette
.focus_ring
.with_alpha(theme.palette.focus_ring.alpha * progress),
);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CanvasRulerAxis {
Horizontal,
Vertical,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CanvasGridStyle {
None,
Dots,
Cross,
#[default]
Lines,
}
#[deprecated(note = "use `CanvasColors`")]
pub type CanvasAppearance = CanvasColors;
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct CanvasColors {
pub background: Option<Color>,
pub grid: Option<Color>,
pub axis_x: Option<Color>,
pub axis_y: Option<Color>,
}
impl CanvasColors {
fn resolve(self, theme: &DefaultTheme) -> [Color; 4] {
let dark = theme.surfaces.dark;
[
self.background.unwrap_or(theme.palette.surface),
self.grid.unwrap_or(
theme
.palette
.border
.with_alpha(if dark { 0.30 } else { 0.18 }),
),
self.axis_x.unwrap_or(
theme
.colors
.danger
.with_alpha(if dark { 0.72 } else { 0.55 }),
),
self.axis_y.unwrap_or(
theme
.colors
.success
.with_alpha(if dark { 0.72 } else { 0.55 }),
),
]
}
}
#[deprecated(note = "use `CanvasRulerColors`")]
pub type CanvasRulerAppearance = CanvasRulerColors;
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct CanvasRulerColors {
pub background: Option<Color>,
pub border: Option<Color>,
pub tick: Option<Color>,
pub text: Option<Color>,
}
impl CanvasRulerColors {
fn resolve(self, theme: &DefaultTheme) -> [Color; 4] {
[
self.background.unwrap_or(theme.palette.surface_raised),
self.border.unwrap_or(theme.palette.border.with_alpha(0.78)),
self.tick
.unwrap_or(theme.palette.text_muted.with_alpha(0.72)),
self.text.unwrap_or(theme.palette.text.with_alpha(0.76)),
]
}
}
#[deprecated(note = "use `PixelCanvasColors`")]
pub type PixelCanvasAppearance = PixelCanvasColors;
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct PixelCanvasColors {
pub background: Option<Color>,
pub paper: Option<Color>,
pub document_edge: Option<Color>,
pub shadow_near: Option<Color>,
pub shadow_far: Option<Color>,
pub grid: Option<Color>,
}
impl PixelCanvasColors {
fn resolve(self, theme: &DefaultTheme) -> [Color; 6] {
let dark = theme.surfaces.dark;
[
self.background.unwrap_or(theme.palette.surface),
self.paper.unwrap_or(theme.surfaces.pixel_canvas_paper),
self.document_edge
.unwrap_or(
theme
.palette
.text
.with_alpha(if dark { 0.82 } else { 0.72 }),
),
self.shadow_near
.unwrap_or(Color::BLACK.with_alpha(if dark { 0.30 } else { 0.16 })),
self.shadow_far
.unwrap_or(Color::BLACK.with_alpha(if dark { 0.18 } else { 0.08 })),
self.grid.unwrap_or(
theme
.palette
.text
.with_alpha(if dark { 0.32 } else { 0.28 }),
),
]
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CanvasViewport {
pub pan: Vector,
pub zoom: f32,
pub rotation: f32,
}
impl Default for CanvasViewport {
fn default() -> Self {
Self {
pan: Vector::ZERO,
zoom: 1.0,
rotation: 0.0,
}
}
}
impl CanvasViewport {
pub fn new() -> Self {
Self::default()
}
pub fn pan(mut self, pan: Vector) -> Self {
self.pan = pan;
self
}
pub fn zoom(mut self, zoom: f32) -> Self {
self.zoom = zoom;
self
}
fn effective_zoom(self) -> f32 {
if self.zoom.is_finite() {
self.zoom.max(0.01)
} else {
1.0
}
}
pub fn rotation(mut self, rotation: f32) -> Self {
self.rotation = rotation;
self
}
pub fn center(bounds: Rect) -> Point {
Point::new(
bounds.x() + (bounds.width() * 0.5),
bounds.y() + (bounds.height() * 0.5),
)
}
pub fn transform(self, bounds: Rect, document_origin: Point) -> Transform {
let center = Self::center(bounds) + self.pan;
Transform::translation(-document_origin.x, -document_origin.y)
.then(Transform::scale(
self.effective_zoom(),
self.effective_zoom(),
))
.then(Transform::rotation(self.rotation))
.then(Transform::translation(center.x, center.y))
}
pub fn screen_to_world(self, bounds: Rect, point: Point, document_origin: Point) -> Point {
let center = Self::center(bounds) + self.pan;
let relative = point - center;
let (sin, cos) = (-self.rotation).sin_cos();
let rotated = Vector::new(
(relative.x * cos) + (relative.y * -sin),
(relative.x * sin) + (relative.y * cos),
);
let zoom = self.effective_zoom();
Point::new(
document_origin.x + (rotated.x / zoom),
document_origin.y + (rotated.y / zoom),
)
}
pub fn world_to_screen(self, bounds: Rect, point: Point, document_origin: Point) -> Point {
self.transform(bounds, document_origin)
.transform_point(point)
}
pub fn zoom_around(
&mut self,
bounds: Rect,
anchor: Point,
factor: f32,
document_origin: Point,
) {
let before = self.screen_to_world(bounds, anchor, document_origin);
self.zoom = (self.effective_zoom() * factor.max(0.01)).max(0.01);
let after = self.world_to_screen(bounds, before, document_origin);
self.pan += anchor - after;
}
pub fn rotate_around(
&mut self,
bounds: Rect,
anchor: Point,
radians: f32,
document_origin: Point,
) {
let before = self.screen_to_world(bounds, anchor, document_origin);
self.rotation += radians;
let after = self.world_to_screen(bounds, before, document_origin);
self.pan += anchor - after;
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CanvasSurface {
pub viewport: CanvasViewport,
pub document_origin: Point,
pub grid_spacing: f32,
pub grid_style: CanvasGridStyle,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CanvasZoomContext {
pub viewport: CanvasViewport,
pub canvas_bounds: Rect,
pub document_origin: Point,
pub content_bounds: Rect,
}
#[derive(Clone, Default)]
pub enum CanvasZoomBehavior {
#[default]
Uniform,
ScreenSpace,
Custom(Rc<dyn Fn(CanvasZoomContext) -> Transform>),
}
impl CanvasZoomBehavior {
pub fn custom<F>(resolver: F) -> Self
where
F: Fn(CanvasZoomContext) -> Transform + 'static,
{
Self::Custom(Rc::new(resolver))
}
pub fn transform(&self, context: CanvasZoomContext) -> Transform {
match self {
Self::Uniform => context
.viewport
.transform(context.canvas_bounds, context.document_origin),
Self::ScreenSpace => {
let anchor = context.viewport.world_to_screen(
context.canvas_bounds,
context.content_bounds.origin,
context.document_origin,
);
Transform::translation(
anchor.x - context.content_bounds.x(),
anchor.y - context.content_bounds.y(),
)
}
Self::Custom(resolver) => resolver(context),
}
}
pub const fn is_uniform(&self) -> bool {
matches!(self, Self::Uniform)
}
}
impl std::fmt::Debug for CanvasZoomBehavior {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Uniform => formatter.write_str("Uniform"),
Self::ScreenSpace => formatter.write_str("ScreenSpace"),
Self::Custom(_) => formatter.write_str("Custom(..)"),
}
}
}
struct CanvasWidgetEntry {
child: WidgetPod,
bounds: Rect,
zoom: CanvasZoomBehavior,
}
impl Default for CanvasSurface {
fn default() -> Self {
Self::new(CanvasViewport::default())
}
}
impl CanvasSurface {
pub fn new(viewport: CanvasViewport) -> Self {
Self {
viewport,
document_origin: Point::ZERO,
grid_spacing: 24.0,
grid_style: CanvasGridStyle::Lines,
}
}
pub fn document_origin(mut self, origin: Point) -> Self {
self.document_origin = origin;
self
}
pub fn grid_spacing(mut self, spacing: f32) -> Self {
self.grid_spacing = spacing;
self
}
pub fn grid_style(mut self, style: CanvasGridStyle) -> Self {
self.grid_style = style;
self
}
pub fn transform(self, bounds: Rect) -> Transform {
self.viewport.transform(bounds, self.document_origin)
}
pub fn screen_to_world(self, bounds: Rect, point: Point) -> Point {
self.viewport
.screen_to_world(bounds, point, self.document_origin)
}
pub fn world_to_screen(self, bounds: Rect, point: Point) -> Point {
self.viewport
.world_to_screen(bounds, point, self.document_origin)
}
pub fn paint_background(
self,
ctx: &mut PaintCtx,
bounds: Rect,
background: Color,
grid: Color,
) {
ctx.fill_rect(bounds, background);
ctx.push_clip_rect(bounds);
paint_canvas_grid(
ctx,
self.viewport,
bounds,
self.document_origin,
self.grid_spacing,
self.grid_style,
grid,
);
ctx.pop_clip();
}
}
pub struct CanvasRuler {
theme: DefaultTheme,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
axis: CanvasRulerAxis,
name: String,
document_size: Size,
viewport: CanvasViewport,
viewport_size: Size,
viewport_reader: Option<Box<dyn Fn() -> (CanvasViewport, Size)>>,
extent: Option<f32>,
appearance: CanvasRulerColors,
}
impl CanvasRuler {
pub fn new(axis: CanvasRulerAxis, name: impl Into<String>, document_size: Size) -> Self {
Self {
theme: DefaultTheme::default(),
theme_reader: None,
axis,
name: name.into(),
document_size: Size::new(document_size.width.max(1.0), document_size.height.max(1.0)),
viewport: CanvasViewport::default(),
viewport_size: Size::ZERO,
viewport_reader: None,
extent: None,
appearance: CanvasRulerColors::default(),
}
}
pub fn horizontal(name: impl Into<String>, document_size: Size) -> Self {
Self::new(CanvasRulerAxis::Horizontal, name, document_size)
}
pub fn vertical(name: impl Into<String>, document_size: Size) -> Self {
Self::new(CanvasRulerAxis::Vertical, name, document_size)
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = theme;
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn viewport(mut self, viewport: CanvasViewport, viewport_size: Size) -> Self {
self.viewport = viewport;
self.viewport_size = viewport_size;
self.viewport_reader = None;
self
}
pub fn viewport_when<F>(mut self, reader: F) -> Self
where
F: Fn() -> (CanvasViewport, Size) + 'static,
{
self.viewport_reader = Some(Box::new(reader));
self
}
pub fn extent(mut self, extent: f32) -> Self {
self.extent = Some(extent.max(0.0));
self
}
pub fn colors(mut self, colors: CanvasRulerColors) -> Self {
self.appearance = colors;
self
}
#[deprecated(note = "use `colors`")]
pub fn appearance(self, appearance: CanvasRulerColors) -> Self {
self.colors(appearance)
}
fn viewport_snapshot(&self) -> (CanvasViewport, Size) {
self.viewport_reader
.as_ref()
.map(|reader| reader())
.unwrap_or((self.viewport, self.viewport_size))
}
fn document_axis_length(&self) -> f32 {
match self.axis {
CanvasRulerAxis::Horizontal => self.document_size.width,
CanvasRulerAxis::Vertical => self.document_size.height,
}
}
fn axis_label(&self) -> &'static str {
match self.axis {
CanvasRulerAxis::Horizontal => "horizontal",
CanvasRulerAxis::Vertical => "vertical",
}
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(self.theme)
}
fn resolved_extent(&self, theme: &DefaultTheme) -> f32 {
self.extent
.unwrap_or(theme.metrics.canvas_ruler_extent)
.max(0.0)
}
}
impl Widget for CanvasRuler {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let theme = self.resolved_theme();
let extent = self.resolved_extent(&theme);
let natural = match self.axis {
CanvasRulerAxis::Horizontal => Size::new(
if constraints.max.width.is_finite() {
constraints.max.width
} else {
320.0
},
extent,
),
CanvasRulerAxis::Vertical => Size::new(
extent,
if constraints.max.height.is_finite() {
constraints.max.height
} else {
240.0
},
),
};
constraints.clamp(natural)
}
fn paint(&self, ctx: &mut PaintCtx) {
let theme = self.resolved_theme();
let [background, border, tick, text] = self.appearance.resolve(&theme);
let bounds = ctx.bounds();
let (viewport, viewport_size) = self.viewport_snapshot();
let text_style = TextStyle {
font_size: theme.text.xs.size,
line_height: theme.text.xs.line_height,
color: text,
..theme.body_text_style()
};
ctx.fill_rect(bounds, background);
paint_canvas_ruler_divider(ctx, bounds, self.axis, border);
ctx.push_clip_rect(bounds);
paint_canvas_ruler_ticks(
ctx,
bounds,
self.axis,
self.document_size,
viewport,
viewport_size,
&theme,
tick,
text_style,
);
ctx.pop_clip();
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(
ctx.widget_id(),
SemanticsRole::GenericContainer,
ctx.bounds(),
);
node.name = Some(self.name.clone());
node.value = Some(SemanticsValue::Text(format!(
"{} ruler, {:.0} px document axis",
self.axis_label(),
self.document_axis_length()
)));
ctx.push(node);
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CanvasStroke {
pub color: Color,
pub width: f32,
}
impl CanvasStroke {
pub const fn new(color: Color, width: f32) -> Self {
Self { color, width }
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum CanvasShape {
Path {
path: Path,
fill: Option<Color>,
stroke: Option<CanvasStroke>,
},
}
impl CanvasShape {
pub fn path(path: Path) -> Self {
let accent = DefaultTheme::default().palette.accent;
Self::Path {
path,
fill: None,
stroke: Some(CanvasStroke::new(accent, 2.0)),
}
}
pub fn rect(rect: Rect, fill: Option<Color>, stroke: Option<CanvasStroke>) -> Self {
Self::Path {
path: Path::rect(rect),
fill,
stroke,
}
}
pub fn circle(
center: Point,
radius: f32,
fill: Option<Color>,
stroke: Option<CanvasStroke>,
) -> Self {
Self::Path {
path: Path::circle(center, radius),
fill,
stroke,
}
}
pub fn polyline(points: &[Point], stroke: CanvasStroke) -> Option<Self> {
path_from_points(points).map(|path| Self::Path {
path,
fill: None,
stroke: Some(stroke),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
enum CanvasDrag {
Pan {
pointer_id: u64,
last_position: Point,
},
Draw {
pointer_id: u64,
},
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct CanvasPinch {
pointers: [u64; 2],
last_center: Point,
last_distance: f32,
}
pub struct Canvas {
theme: DefaultTheme,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
viewport: CanvasViewport,
shapes: Vec<CanvasShape>,
active_stroke: Option<Vec<Point>>,
drag: Option<CanvasDrag>,
draw_stroke: CanvasStroke,
focus_animation: AnimatedScalar,
desired_size: Size,
appearance: CanvasColors,
content: Option<SingleChild>,
content_bounds: Rect,
content_zoom: CanvasZoomBehavior,
widgets: Vec<CanvasWidgetEntry>,
active_touches: BTreeMap<u64, Point>,
pinch: Option<CanvasPinch>,
}
impl Canvas {
pub fn new(name: impl Into<String>) -> Self {
let theme = DefaultTheme::default();
Self {
theme,
theme_reader: None,
name: name.into(),
viewport: CanvasViewport::default(),
shapes: Vec::new(),
active_stroke: None,
drag: None,
draw_stroke: CanvasStroke::new(theme.palette.accent, 2.5),
focus_animation: AnimatedScalar::new(0.0),
desired_size: Size::new(520.0, 360.0),
appearance: CanvasColors::default(),
content: None,
content_bounds: Rect::new(0.0, 0.0, 520.0, 360.0),
content_zoom: CanvasZoomBehavior::Uniform,
widgets: Vec::new(),
active_touches: BTreeMap::new(),
pinch: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = theme;
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn viewport(mut self, viewport: CanvasViewport) -> Self {
self.viewport = viewport;
self
}
pub fn desired_size(mut self, size: Size) -> Self {
self.desired_size = Size::new(size.width.max(1.0), size.height.max(1.0));
self
}
pub fn shape(mut self, shape: CanvasShape) -> Self {
self.shapes.push(shape);
self
}
pub fn shapes<I>(mut self, shapes: I) -> Self
where
I: IntoIterator<Item = CanvasShape>,
{
self.shapes.extend(shapes);
self
}
pub fn draw_stroke(mut self, stroke: CanvasStroke) -> Self {
self.draw_stroke = CanvasStroke::new(stroke.color, stroke.width.max(0.1));
self
}
pub fn colors(mut self, colors: CanvasColors) -> Self {
self.appearance = colors;
self
}
#[deprecated(note = "use `colors`")]
pub fn appearance(self, appearance: CanvasColors) -> Self {
self.colors(appearance)
}
pub fn child<W>(mut self, content: W) -> Self
where
W: Widget + 'static,
{
self.content = Some(SingleChild::new(content));
self
}
#[deprecated(note = "use `child`")]
pub fn content<W>(self, content: W) -> Self
where
W: Widget + 'static,
{
self.child(content)
}
pub fn content_bounds(mut self, bounds: Rect) -> Self {
self.content_bounds = Rect::new(
bounds.x(),
bounds.y(),
bounds.width().max(1.0),
bounds.height().max(1.0),
);
self
}
pub fn content_zoom(mut self, behavior: CanvasZoomBehavior) -> Self {
self.content_zoom = behavior;
self
}
pub fn widget<W>(self, bounds: Rect, widget: W) -> Self
where
W: Widget + 'static,
{
self.widget_with_zoom(bounds, CanvasZoomBehavior::Uniform, widget)
}
pub fn widget_with_zoom<W>(mut self, bounds: Rect, zoom: CanvasZoomBehavior, widget: W) -> Self
where
W: Widget + 'static,
{
self.widgets.push(CanvasWidgetEntry {
child: WidgetPod::new(widget),
bounds: Rect::new(
bounds.x(),
bounds.y(),
bounds.width().max(1.0),
bounds.height().max(1.0),
),
zoom,
});
self
}
pub fn viewport_state(&self) -> CanvasViewport {
self.viewport
}
pub fn shape_count(&self) -> usize {
self.shapes.len()
}
fn document_origin(&self) -> Point {
Point::ZERO
}
fn world_position(&self, bounds: Rect, position: Point) -> Point {
self.viewport
.screen_to_world(bounds, position, self.document_origin())
}
fn push_active_point(&mut self, point: Point) {
let Some(points) = &mut self.active_stroke else {
return;
};
if points
.last()
.is_none_or(|last| vector_length(point - *last) >= 1.5)
{
points.push(point);
}
}
fn finish_active_stroke(&mut self) {
let Some(points) = self.active_stroke.take() else {
return;
};
if let Some(shape) = CanvasShape::polyline(&points, self.draw_stroke) {
self.shapes.push(shape);
} else if let Some(point) = points.first().copied() {
self.shapes.push(CanvasShape::circle(
point,
self.draw_stroke.width.max(1.0),
Some(self.draw_stroke.color),
None,
));
}
}
fn handle_touch_gesture(&mut self, ctx: &mut EventCtx, pointer: &PointerEvent) -> bool {
match pointer.kind {
PointerEventKind::Down if ctx.bounds().contains(pointer.position) => {
self.active_touches
.insert(pointer.pointer_id, pointer.position);
if self.pinch.is_some() {
ctx.request_pointer_capture(pointer.pointer_id);
return true;
}
if self.active_touches.len() < 2 {
return false;
}
let mut touches = self.active_touches.iter();
let Some((&first_id, &first)) = touches.next() else {
return false;
};
let Some((&second_id, &second)) = touches.next() else {
return false;
};
let center = Point::new(
first.x + ((second.x - first.x) * 0.5),
first.y + ((second.y - first.y) * 0.5),
);
self.active_stroke = None;
self.drag = None;
self.pinch = Some(CanvasPinch {
pointers: [first_id, second_id],
last_center: center,
last_distance: vector_length(second - first).max(1.0),
});
ctx.request_pointer_capture(first_id);
ctx.request_pointer_capture(second_id);
Self::request_interaction_update(ctx);
true
}
PointerEventKind::Move => {
let Some(position) = self.active_touches.get_mut(&pointer.pointer_id) else {
return false;
};
*position = pointer.position;
let Some(pinch) = self.pinch else {
return false;
};
let Some(&first) = self.active_touches.get(&pinch.pointers[0]) else {
return false;
};
let Some(&second) = self.active_touches.get(&pinch.pointers[1]) else {
return false;
};
let center = Point::new(
first.x + ((second.x - first.x) * 0.5),
first.y + ((second.y - first.y) * 0.5),
);
let distance = vector_length(second - first).max(1.0);
self.viewport.pan += center - pinch.last_center;
self.viewport.zoom_around(
ctx.bounds(),
center,
distance / pinch.last_distance,
self.document_origin(),
);
if let Some(pinch) = &mut self.pinch {
pinch.last_center = center;
pinch.last_distance = distance;
}
Self::request_interaction_update(ctx);
true
}
PointerEventKind::Up | PointerEventKind::Cancel => {
if self.active_touches.remove(&pointer.pointer_id).is_none() {
return false;
}
let Some(pinch) = self.pinch else {
return false;
};
ctx.release_pointer_capture(pointer.pointer_id);
if !pinch.pointers.contains(&pointer.pointer_id) {
return true;
}
self.pinch = None;
if pointer.kind == PointerEventKind::Cancel {
for pointer_id in self.active_touches.keys().copied().collect::<Vec<_>>() {
ctx.release_pointer_capture(pointer_id);
}
self.active_touches.clear();
} else if let Some((&pointer_id, &position)) = self.active_touches.iter().next() {
for extra in self
.active_touches
.keys()
.copied()
.filter(|id| *id != pointer_id)
.collect::<Vec<_>>()
{
ctx.release_pointer_capture(extra);
}
self.active_touches.retain(|id, _| *id == pointer_id);
self.drag = Some(CanvasDrag::Pan {
pointer_id,
last_position: position,
});
ctx.request_pointer_capture(pointer_id);
}
Self::request_interaction_update(ctx);
true
}
_ => self.pinch.is_some(),
}
}
fn request_interaction_update(ctx: &mut EventCtx) {
ctx.request_transform();
ctx.request_paint();
ctx.request_semantics();
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(self.theme)
}
}
impl Widget for Canvas {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if ctx.phase() == EventPhase::Capture {
if let Event::Pointer(pointer) = event
&& pointer.pointer_kind == PointerKind::Touch
&& self.handle_touch_gesture(ctx, pointer)
{
ctx.set_handled();
}
return;
}
if let Event::Pointer(pointer) = event
&& pointer.pointer_kind == PointerKind::Touch
&& self.handle_touch_gesture(ctx, pointer)
{
ctx.set_handled();
return;
}
match event {
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Scroll
&& ctx.bounds().contains(pointer.position) =>
{
let delta = scroll_delta_to_offset(pointer.scroll_delta, pointer.delta);
if pointer.modifiers.shift {
self.viewport.rotate_around(
ctx.bounds(),
pointer.position,
delta.y * 0.01,
self.document_origin(),
);
} else {
self.viewport.zoom_around(
ctx.bounds(),
pointer.position,
(delta.y * 0.002).exp(),
self.document_origin(),
);
}
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& ctx.bounds().contains(pointer.position)
&& matches!(
pointer.button,
Some(PointerButton::Middle | PointerButton::Secondary)
) =>
{
self.drag = Some(CanvasDrag::Pan {
pointer_id: pointer.pointer_id,
last_position: pointer.position,
});
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary)
&& ctx.bounds().contains(pointer.position) =>
{
let point = self.world_position(ctx.bounds(), pointer.position);
self.active_stroke = Some(vec![point]);
self.drag = Some(CanvasDrag::Draw {
pointer_id: pointer.pointer_id,
});
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => match self.drag {
Some(CanvasDrag::Pan {
pointer_id,
mut last_position,
}) if pointer_id == pointer.pointer_id => {
let delta = pointer.position - last_position;
self.viewport.pan += delta;
last_position = pointer.position;
self.drag = Some(CanvasDrag::Pan {
pointer_id,
last_position,
});
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Some(CanvasDrag::Draw { pointer_id }) if pointer_id == pointer.pointer_id => {
let point = self.world_position(ctx.bounds(), pointer.position);
self.push_active_point(point);
Self::request_interaction_update(ctx);
ctx.set_handled();
}
_ => {}
},
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
|| pointer.kind == PointerEventKind::Cancel =>
{
let active_pointer = match self.drag {
Some(CanvasDrag::Pan { pointer_id, .. } | CanvasDrag::Draw { pointer_id }) => {
Some(pointer_id)
}
None => None,
};
if active_pointer == Some(pointer.pointer_id) {
if matches!(self.drag, Some(CanvasDrag::Draw { .. })) {
self.finish_active_stroke();
}
self.drag = None;
ctx.release_pointer_capture(pointer.pointer_id);
Self::request_interaction_update(ctx);
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
let zoom_step = self.resolved_theme().metrics.pixel_canvas_zoom_step;
match key.key.as_str() {
"=" | "+" => self.viewport.zoom_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
zoom_step,
self.document_origin(),
),
"-" => self.viewport.zoom_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
1.0 / zoom_step,
self.document_origin(),
),
"[" => self.viewport.rotate_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
-0.1,
self.document_origin(),
),
"]" => self.viewport.rotate_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
0.1,
self.document_origin(),
),
"ArrowLeft" => self.viewport.pan.x += 24.0,
"ArrowRight" => self.viewport.pan.x -= 24.0,
"ArrowUp" => self.viewport.pan.y += 24.0,
"ArrowDown" => self.viewport.pan.y -= 24.0,
_ => return,
}
Self::request_interaction_update(ctx);
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
if let Some(content) = &mut self.content {
content.measure(ctx, Constraints::tight(self.content_bounds.size));
}
for entry in &mut self.widgets {
entry
.child
.measure(ctx, Constraints::tight(entry.bounds.size));
}
constraints.clamp(Size::new(
if constraints.max.width.is_finite() {
constraints.max.width
} else {
self.desired_size.width
},
if constraints.max.height.is_finite() {
constraints.max.height
} else {
self.desired_size.height
},
))
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
let document_origin = self.document_origin();
if let Some(content) = &mut self.content {
let transform = self.content_zoom.transform(CanvasZoomContext {
viewport: self.viewport,
canvas_bounds: bounds,
document_origin,
content_bounds: self.content_bounds,
});
content.arrange_transformed(ctx, self.content_bounds, transform);
}
for entry in &mut self.widgets {
let transform = entry.zoom.transform(CanvasZoomContext {
viewport: self.viewport,
canvas_bounds: bounds,
document_origin,
content_bounds: entry.bounds,
});
entry
.child
.arrange_transformed(ctx, entry.bounds, transform);
}
}
fn paint(&self, ctx: &mut PaintCtx) {
let theme = self.resolved_theme();
let [background, grid, axis_x, axis_y] = self.appearance.resolve(&theme);
CanvasSurface::new(self.viewport)
.document_origin(self.document_origin())
.grid_spacing(theme.metrics.canvas_grid_step)
.grid_style(CanvasGridStyle::Lines)
.paint_background(ctx, ctx.bounds(), background, grid);
stroke_border(
ctx,
ctx.bounds(),
0.0,
physical_pixels(ctx, theme.metrics.border_width),
theme.surfaces.border,
);
ctx.push_clip_rect(ctx.bounds());
paint_canvas_axes(
ctx,
self.viewport,
ctx.bounds(),
self.document_origin(),
&theme,
axis_x,
axis_y,
);
let transform = self
.viewport
.transform(ctx.bounds(), self.document_origin());
for shape in &self.shapes {
paint_canvas_shape(ctx, shape, transform, self.viewport.zoom);
}
if let Some(points) = &self.active_stroke
&& let Some(shape) = CanvasShape::polyline(points, self.draw_stroke)
{
paint_canvas_shape(ctx, &shape, transform, self.viewport.zoom);
}
let mut widget_index = 0;
if self.content_zoom.is_uniform() {
ctx.with_transform(transform, |ctx| {
if let Some(content) = &self.content {
content.paint(ctx);
}
while let Some(entry) = self.widgets.get(widget_index) {
if !entry.zoom.is_uniform() {
break;
}
entry.child.paint(ctx);
widget_index += 1;
}
});
} else if let Some(content) = &self.content {
content.paint(ctx);
}
while widget_index < self.widgets.len() {
if self.widgets[widget_index].zoom.is_uniform() {
let start = widget_index;
while self
.widgets
.get(widget_index)
.is_some_and(|entry| entry.zoom.is_uniform())
{
widget_index += 1;
}
ctx.with_transform(transform, |ctx| {
for entry in &self.widgets[start..widget_index] {
entry.child.paint(ctx);
}
});
} else {
self.widgets[widget_index].child.paint(ctx);
widget_index += 1;
}
}
ctx.pop_clip();
draw_focus_ring(ctx, ctx.bounds(), &theme, self.focus_animation.get(ctx));
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Canvas, ctx.bounds());
node.name = Some(self.name.clone());
node.value = Some(SemanticsValue::Text(format!(
"zoom {:.0}%, rotation {:.0} deg",
self.viewport.zoom * 100.0,
self.viewport.rotation.to_degrees()
)));
node.state.focused = ctx.is_focused();
node.actions = vec![
SemanticsAction::Focus,
SemanticsAction::Custom("Pan".into()),
];
ctx.push(node);
if let Some(content) = &self.content {
content.semantics(ctx);
}
for entry in &self.widgets {
entry.child.semantics(ctx);
}
}
fn accepts_focus(&self) -> bool {
true
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
Self::request_interaction_update(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
if let Some(content) = &self.content {
content.visit_children(visitor);
}
for entry in &self.widgets {
visitor.visit(&entry.child);
}
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
if let Some(content) = &mut self.content {
content.visit_children_mut(visitor);
}
for entry in &mut self.widgets {
visitor.visit(&mut entry.child);
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
enum PixelCanvasDrag {
Pan {
pointer_id: u64,
last_position: Point,
},
Paint {
pointer_id: u64,
last_position: Point,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PixelCanvasHistoryCommand {
Undo,
Redo,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PixelCanvasViewportCommand {
Fit,
ActualSize,
ZoomIn,
ZoomOut,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PixelEdit {
index: usize,
before: PixelColor,
after: PixelColor,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PixelColor {
red: u8,
green: u8,
blue: u8,
alpha: u8,
}
impl PixelColor {
const TRANSPARENT: Self = Self {
red: 0,
green: 0,
blue: 0,
alpha: 0,
};
fn from_color(color: Color) -> Self {
let color = color.clamped();
Self {
red: channel_to_u8(color.red),
green: channel_to_u8(color.green),
blue: channel_to_u8(color.blue),
alpha: channel_to_u8(color.alpha),
}
}
fn to_color(self) -> Color {
Color::rgba(
self.red as f32 / 255.0,
self.green as f32 / 255.0,
self.blue as f32 / 255.0,
self.alpha as f32 / 255.0,
)
}
fn compose(self, source: Color, opacity: f32, blend_mode: PixelCanvasBlendMode) -> Self {
let destination = self.to_color();
let source = source.clamped();
let opacity = opacity.clamp(0.0, 1.0);
let source_alpha = (source.alpha * opacity).clamp(0.0, 1.0);
if source_alpha <= 0.0 {
return self;
}
let destination_alpha = destination.alpha.clamp(0.0, 1.0);
let blend_red = blend_channel(source.red, destination.red, destination_alpha, blend_mode);
let blend_green = blend_channel(
source.green,
destination.green,
destination_alpha,
blend_mode,
);
let blend_blue =
blend_channel(source.blue, destination.blue, destination_alpha, blend_mode);
let output_alpha = source_alpha + destination_alpha * (1.0 - source_alpha);
if output_alpha <= 0.0 {
return Self::TRANSPARENT;
}
let destination_weight = destination_alpha * (1.0 - source_alpha);
Self::from_color(Color::rgba(
((blend_red * source_alpha) + (destination.red * destination_weight)) / output_alpha,
((blend_green * source_alpha) + (destination.green * destination_weight))
/ output_alpha,
((blend_blue * source_alpha) + (destination.blue * destination_weight)) / output_alpha,
output_alpha,
))
}
fn erased(self, opacity: f32) -> Self {
let opacity = opacity.clamp(0.0, 1.0);
if opacity <= 0.0 {
return self;
}
let scale = 1.0 - opacity;
Self {
alpha: channel_to_u8((self.alpha as f32 / 255.0) * scale),
..self
}
}
}
fn blend_channel(
source: f32,
destination: f32,
destination_alpha: f32,
mode: PixelCanvasBlendMode,
) -> f32 {
if destination_alpha <= 0.0 {
return source.clamp(0.0, 1.0);
}
match mode {
PixelCanvasBlendMode::Normal => source,
PixelCanvasBlendMode::Multiply => source * destination,
PixelCanvasBlendMode::Screen => 1.0 - ((1.0 - source) * (1.0 - destination)),
PixelCanvasBlendMode::Overlay => {
if destination <= 0.5 {
2.0 * source * destination
} else {
1.0 - (2.0 * (1.0 - source) * (1.0 - destination))
}
}
}
.clamp(0.0, 1.0)
}
fn brush_shape_contains_pixel(
shape: PixelCanvasBrushShape,
size: isize,
start_x: isize,
start_y: isize,
px: isize,
py: isize,
) -> bool {
match shape {
PixelCanvasBrushShape::Square => true,
PixelCanvasBrushShape::Round => {
let size = size.max(1) as f32;
let center = (size - 1.0) * 0.5;
let local_x = (px - start_x) as f32 - center;
let local_y = (py - start_y) as f32 - center;
let radius = (size * 0.5 - 0.25).max(0.0);
(local_x * local_x) + (local_y * local_y) <= radius * radius
}
}
}
fn brush_stroke_spacing(brush_size: f32) -> f32 {
(brush_size.round().max(1.0) * 0.25).max(1.0)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PixelCanvasTool {
#[default]
Brush,
Eraser,
Fill,
Pan,
}
impl PixelCanvasTool {
pub const fn label(self) -> &'static str {
match self {
Self::Brush => "Brush",
Self::Eraser => "Eraser",
Self::Fill => "Fill",
Self::Pan => "Pan",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PixelCanvasBlendMode {
#[default]
Normal,
Multiply,
Screen,
Overlay,
}
impl PixelCanvasBlendMode {
pub const ALL: [Self; 4] = [Self::Normal, Self::Multiply, Self::Screen, Self::Overlay];
pub const fn label(self) -> &'static str {
match self {
Self::Normal => "Normal",
Self::Multiply => "Multiply",
Self::Screen => "Screen",
Self::Overlay => "Overlay",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PixelCanvasBrushShape {
Square,
#[default]
Round,
}
impl PixelCanvasBrushShape {
pub const ALL: [Self; 2] = [Self::Square, Self::Round];
pub const fn label(self) -> &'static str {
match self {
Self::Square => "Square",
Self::Round => "Round",
}
}
}
#[derive(Debug, Clone, PartialEq)]
struct PixelCanvasStateInner {
tool: PixelCanvasTool,
brush: Color,
brush_size: f32,
brush_opacity: f32,
brush_shape: PixelCanvasBrushShape,
blend_mode: PixelCanvasBlendMode,
display_visible: bool,
display_opacity: f32,
display_blend_mode: PixelCanvasBlendMode,
display_above_paper: bool,
paper_visible: bool,
paper_opacity: f32,
pending_undo: u32,
pending_redo: u32,
pending_fit_view: u32,
pending_actual_size: u32,
pending_zoom_delta: i32,
pending_export: u32,
pending_clear: u32,
export_revision: u64,
latest_export: Option<PixelCanvasExportSnapshot>,
editable: bool,
can_undo: bool,
can_redo: bool,
can_clear: bool,
viewport: CanvasViewport,
viewport_size: Size,
cursor_position: Option<Point>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PixelCanvasExportSnapshot {
revision: u64,
name: String,
width: usize,
height: usize,
rgba8: Arc<[u8]>,
}
impl PixelCanvasExportSnapshot {
fn new(revision: u64, name: String, width: usize, height: usize, rgba8: Vec<u8>) -> Self {
Self {
revision,
name,
width,
height,
rgba8: Arc::from(rgba8.into_boxed_slice()),
}
}
pub const fn revision(&self) -> u64 {
self.revision
}
pub fn name(&self) -> &str {
&self.name
}
pub const fn width(&self) -> usize {
self.width
}
pub const fn height(&self) -> usize {
self.height
}
pub fn rgba8(&self) -> &[u8] {
self.rgba8.as_ref()
}
pub fn byte_len(&self) -> usize {
self.rgba8.len()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PixelCanvasBrushSettings {
tool: PixelCanvasTool,
brush: Color,
brush_size: f32,
brush_opacity: f32,
brush_shape: PixelCanvasBrushShape,
blend_mode: PixelCanvasBlendMode,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PixelCanvasDisplaySettings {
visible: bool,
opacity: f32,
blend_mode: PixelCanvasBlendMode,
}
impl PixelCanvasDisplaySettings {
const DEFAULT: Self = Self {
visible: true,
opacity: 1.0,
blend_mode: PixelCanvasBlendMode::Normal,
};
fn requires_compositing(self) -> bool {
!self.visible || self.opacity < 0.999 || self.blend_mode != PixelCanvasBlendMode::Normal
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PixelCanvasPaperSettings {
visible: bool,
opacity: f32,
}
impl PixelCanvasPaperSettings {
const DEFAULT: Self = Self {
visible: true,
opacity: 1.0,
};
fn requires_compositing(self) -> bool {
!self.visible || self.opacity < 0.999
}
fn pixel(self, paper_color: Color) -> PixelColor {
if self.visible {
PixelColor::from_color(paper_color.with_alpha(self.opacity))
} else {
PixelColor::TRANSPARENT
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
enum PixelCanvasImageSource {
Raw,
Composited {
display: PixelCanvasDisplaySettings,
paper: PixelCanvasPaperSettings,
display_above_paper: bool,
paper_color: Color,
},
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PixelCanvasImageCacheKey {
pixel_revision: u64,
source: PixelCanvasImageSource,
}
#[derive(Debug, Clone)]
struct PixelCanvasImageCache {
key: PixelCanvasImageCacheKey,
image: RegisteredImage,
}
#[derive(Clone, Debug)]
pub struct PixelCanvasState {
inner: Arc<Mutex<PixelCanvasStateInner>>,
}
impl PixelCanvasState {
pub fn new() -> Self {
Self::default()
}
fn lock_inner(&self) -> MutexGuard<'_, PixelCanvasStateInner> {
self.inner
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
pub fn brush_color(&self) -> Color {
self.lock_inner().brush
}
pub fn tool(&self) -> PixelCanvasTool {
self.lock_inner().tool
}
pub fn set_tool(&self, tool: PixelCanvasTool) {
self.lock_inner().tool = tool;
}
pub fn request_undo(&self) {
let mut inner = self.lock_inner();
inner.pending_undo = inner.pending_undo.saturating_add(1);
}
pub fn request_redo(&self) {
let mut inner = self.lock_inner();
inner.pending_redo = inner.pending_redo.saturating_add(1);
}
pub fn request_fit_view(&self) {
let mut inner = self.lock_inner();
inner.pending_fit_view = inner.pending_fit_view.saturating_add(1);
}
pub fn request_actual_size_view(&self) {
let mut inner = self.lock_inner();
inner.pending_actual_size = inner.pending_actual_size.saturating_add(1);
}
pub fn request_zoom_in(&self) {
let mut inner = self.lock_inner();
inner.pending_zoom_delta = inner.pending_zoom_delta.saturating_add(1);
}
pub fn request_zoom_out(&self) {
let mut inner = self.lock_inner();
inner.pending_zoom_delta = inner.pending_zoom_delta.saturating_sub(1);
}
pub fn request_export_snapshot(&self) {
let mut inner = self.lock_inner();
inner.pending_export = inner.pending_export.saturating_add(1);
}
pub fn request_clear(&self) {
let mut inner = self.lock_inner();
inner.pending_clear = inner.pending_clear.saturating_add(1);
}
pub fn is_editable(&self) -> bool {
self.lock_inner().editable
}
pub fn set_editable(&self, editable: bool) -> bool {
let mut inner = self.lock_inner();
if inner.editable == editable {
return false;
}
inner.editable = editable;
if !editable {
inner.can_undo = false;
inner.can_redo = false;
inner.can_clear = false;
}
true
}
pub fn latest_export_snapshot(&self) -> Option<PixelCanvasExportSnapshot> {
self.lock_inner().latest_export.clone()
}
pub fn can_undo(&self) -> bool {
self.lock_inner().can_undo
}
pub fn can_redo(&self) -> bool {
self.lock_inner().can_redo
}
pub fn can_clear(&self) -> bool {
self.lock_inner().can_clear
}
pub fn viewport(&self) -> CanvasViewport {
self.lock_inner().viewport
}
pub fn viewport_size(&self) -> Size {
self.lock_inner().viewport_size
}
pub fn cursor_position(&self) -> Option<Point> {
self.lock_inner().cursor_position
}
pub fn set_brush_color(&self, color: Color) {
self.lock_inner().brush = color;
}
pub fn brush_size(&self) -> f32 {
self.lock_inner().brush_size
}
pub fn set_brush_size(&self, size: f32) {
self.lock_inner().brush_size = size.max(1.0);
}
pub fn brush_opacity(&self) -> f32 {
self.lock_inner().brush_opacity
}
pub fn set_brush_opacity(&self, opacity: f32) {
self.lock_inner().brush_opacity = opacity.clamp(0.0, 1.0);
}
pub fn brush_shape(&self) -> PixelCanvasBrushShape {
self.lock_inner().brush_shape
}
pub fn set_brush_shape(&self, brush_shape: PixelCanvasBrushShape) {
self.lock_inner().brush_shape = brush_shape;
}
pub fn blend_mode(&self) -> PixelCanvasBlendMode {
self.lock_inner().blend_mode
}
pub fn set_blend_mode(&self, blend_mode: PixelCanvasBlendMode) {
self.lock_inner().blend_mode = blend_mode;
}
pub fn display_visible(&self) -> bool {
self.lock_inner().display_visible
}
pub fn set_display_visible(&self, visible: bool) -> bool {
let mut inner = self.lock_inner();
if inner.display_visible == visible {
return false;
}
inner.display_visible = visible;
true
}
pub fn display_opacity(&self) -> f32 {
self.lock_inner().display_opacity
}
pub fn set_display_opacity(&self, opacity: f32) -> bool {
let opacity = opacity.clamp(0.0, 1.0);
let mut inner = self.lock_inner();
if (inner.display_opacity - opacity).abs() < f32::EPSILON {
return false;
}
inner.display_opacity = opacity;
true
}
pub fn display_blend_mode(&self) -> PixelCanvasBlendMode {
self.lock_inner().display_blend_mode
}
pub fn set_display_blend_mode(&self, blend_mode: PixelCanvasBlendMode) -> bool {
let mut inner = self.lock_inner();
if inner.display_blend_mode == blend_mode {
return false;
}
inner.display_blend_mode = blend_mode;
true
}
pub fn display_above_paper(&self) -> bool {
self.lock_inner().display_above_paper
}
pub fn set_display_above_paper(&self, above: bool) -> bool {
let mut inner = self.lock_inner();
if inner.display_above_paper == above {
return false;
}
inner.display_above_paper = above;
true
}
pub fn paper_visible(&self) -> bool {
self.lock_inner().paper_visible
}
pub fn set_paper_visible(&self, visible: bool) -> bool {
let mut inner = self.lock_inner();
if inner.paper_visible == visible {
return false;
}
inner.paper_visible = visible;
true
}
pub fn paper_opacity(&self) -> f32 {
self.lock_inner().paper_opacity
}
pub fn set_paper_opacity(&self, opacity: f32) -> bool {
let opacity = opacity.clamp(0.0, 1.0);
let mut inner = self.lock_inner();
if (inner.paper_opacity - opacity).abs() < f32::EPSILON {
return false;
}
inner.paper_opacity = opacity;
true
}
fn brush(&self) -> PixelCanvasBrushSettings {
let inner = self.lock_inner();
PixelCanvasBrushSettings {
tool: inner.tool,
brush: inner.brush,
brush_size: inner.brush_size,
brush_opacity: inner.brush_opacity,
brush_shape: inner.brush_shape,
blend_mode: inner.blend_mode,
}
}
fn display(&self) -> PixelCanvasDisplaySettings {
let inner = self.lock_inner();
PixelCanvasDisplaySettings {
visible: inner.display_visible,
opacity: inner.display_opacity,
blend_mode: inner.display_blend_mode,
}
}
fn paper(&self) -> PixelCanvasPaperSettings {
let inner = self.lock_inner();
PixelCanvasPaperSettings {
visible: inner.paper_visible,
opacity: inner.paper_opacity,
}
}
fn take_history_command(&self) -> Option<PixelCanvasHistoryCommand> {
let mut inner = self.lock_inner();
if inner.pending_undo > 0 {
inner.pending_undo -= 1;
return Some(PixelCanvasHistoryCommand::Undo);
}
if inner.pending_redo > 0 {
inner.pending_redo -= 1;
return Some(PixelCanvasHistoryCommand::Redo);
}
None
}
fn take_viewport_command(&self) -> Option<PixelCanvasViewportCommand> {
let mut inner = self.lock_inner();
if inner.pending_fit_view > 0 {
inner.pending_fit_view -= 1;
return Some(PixelCanvasViewportCommand::Fit);
}
if inner.pending_actual_size > 0 {
inner.pending_actual_size -= 1;
return Some(PixelCanvasViewportCommand::ActualSize);
}
if inner.pending_zoom_delta > 0 {
inner.pending_zoom_delta -= 1;
return Some(PixelCanvasViewportCommand::ZoomIn);
}
if inner.pending_zoom_delta < 0 {
inner.pending_zoom_delta += 1;
return Some(PixelCanvasViewportCommand::ZoomOut);
}
None
}
fn take_export_request(&self) -> bool {
let mut inner = self.lock_inner();
if inner.pending_export == 0 {
return false;
}
inner.pending_export = 0;
true
}
fn take_clear_request(&self) -> bool {
let mut inner = self.lock_inner();
if inner.pending_clear == 0 {
return false;
}
inner.pending_clear = 0;
true
}
fn publish_export_snapshot(&self, name: String, width: usize, height: usize, rgba8: Vec<u8>) {
let mut inner = self.lock_inner();
inner.export_revision = inner.export_revision.saturating_add(1);
inner.latest_export = Some(PixelCanvasExportSnapshot::new(
inner.export_revision,
name,
width,
height,
rgba8,
));
}
fn set_canvas_availability(&self, can_undo: bool, can_redo: bool, can_clear: bool) -> bool {
let mut inner = self.lock_inner();
if inner.can_undo == can_undo && inner.can_redo == can_redo && inner.can_clear == can_clear
{
return false;
}
inner.can_undo = can_undo;
inner.can_redo = can_redo;
inner.can_clear = can_clear;
true
}
fn set_viewport_state(&self, viewport: CanvasViewport, viewport_size: Size) -> bool {
let mut inner = self.lock_inner();
if inner.viewport == viewport && inner.viewport_size == viewport_size {
return false;
}
inner.viewport = viewport;
inner.viewport_size = viewport_size;
true
}
fn set_cursor_position(&self, cursor_position: Option<Point>) -> bool {
let mut inner = self.lock_inner();
if inner.cursor_position == cursor_position {
return false;
}
inner.cursor_position = cursor_position;
true
}
}
impl Default for PixelCanvasState {
fn default() -> Self {
let accent = DefaultTheme::default().palette.accent;
Self {
inner: Arc::new(Mutex::new(PixelCanvasStateInner {
tool: PixelCanvasTool::Brush,
brush: accent,
brush_size: 1.0,
brush_opacity: 1.0,
brush_shape: PixelCanvasBrushShape::Round,
blend_mode: PixelCanvasBlendMode::Normal,
display_visible: PixelCanvasDisplaySettings::DEFAULT.visible,
display_opacity: PixelCanvasDisplaySettings::DEFAULT.opacity,
display_blend_mode: PixelCanvasDisplaySettings::DEFAULT.blend_mode,
display_above_paper: true,
paper_visible: PixelCanvasPaperSettings::DEFAULT.visible,
paper_opacity: PixelCanvasPaperSettings::DEFAULT.opacity,
pending_undo: 0,
pending_redo: 0,
pending_fit_view: 0,
pending_actual_size: 0,
pending_zoom_delta: 0,
pending_export: 0,
pending_clear: 0,
export_revision: 0,
latest_export: None,
editable: true,
can_undo: false,
can_redo: false,
can_clear: false,
viewport: CanvasViewport::default(),
viewport_size: Size::ZERO,
cursor_position: None,
})),
}
}
}
pub struct PixelCanvas {
theme: DefaultTheme,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
paper_color: Option<Color>,
name: String,
width: usize,
height: usize,
pixels: Vec<PixelColor>,
pixel_revision: u64,
paint_image_cache: RefCell<Option<PixelCanvasImageCache>>,
viewport: CanvasViewport,
state: PixelCanvasState,
drag: Option<PixelCanvasDrag>,
active_edits: Vec<PixelEdit>,
undo_stack: Vec<Vec<PixelEdit>>,
redo_stack: Vec<Vec<PixelEdit>>,
has_visible_pixels: bool,
focus_animation: AnimatedScalar,
desired_size: Size,
fit_on_first_layout: bool,
initial_fit_applied: bool,
appearance: PixelCanvasColors,
}
impl PixelCanvas {
pub fn new(name: impl Into<String>, width: usize, height: usize) -> Self {
let width = width.max(1);
let height = height.max(1);
Self {
theme: DefaultTheme::default(),
theme_reader: None,
paper_color: None,
name: name.into(),
width,
height,
pixels: vec![PixelColor::TRANSPARENT; width * height],
pixel_revision: 0,
paint_image_cache: RefCell::new(None),
viewport: CanvasViewport::new().zoom(14.0),
state: PixelCanvasState::new(),
drag: None,
active_edits: Vec::new(),
undo_stack: Vec::new(),
redo_stack: Vec::new(),
has_visible_pixels: false,
focus_animation: AnimatedScalar::new(0.0),
desired_size: Size::new(520.0, 360.0),
fit_on_first_layout: false,
initial_fit_applied: false,
appearance: PixelCanvasColors::default(),
}
}
pub fn from_fn<F>(name: impl Into<String>, width: usize, height: usize, mut pixel: F) -> Self
where
F: FnMut(usize, usize) -> Color,
{
let mut canvas = Self::new(name, width, height);
for y in 0..canvas.height {
for x in 0..canvas.width {
let index = y * canvas.width + x;
canvas.pixels[index] = PixelColor::from_color(pixel(x, y));
}
}
canvas.has_visible_pixels = canvas.pixels.iter().any(|pixel| pixel.alpha > 0);
canvas
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = theme;
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn paper_color(mut self, color: Color) -> Self {
self.paper_color = Some(color);
self.paint_image_cache.borrow_mut().take();
self
}
pub fn colors(mut self, colors: PixelCanvasColors) -> Self {
self.appearance = colors;
self.paint_image_cache.borrow_mut().take();
self
}
#[deprecated(note = "use `colors`")]
pub fn appearance(self, appearance: PixelCanvasColors) -> Self {
self.colors(appearance)
}
pub fn desired_size(mut self, size: Size) -> Self {
self.desired_size = Size::new(size.width.max(1.0), size.height.max(1.0));
self
}
pub fn viewport(mut self, viewport: CanvasViewport) -> Self {
self.viewport = viewport;
self
}
pub fn fit_on_first_layout(mut self, fit_on_first_layout: bool) -> Self {
self.fit_on_first_layout = fit_on_first_layout;
self.initial_fit_applied = false;
self
}
pub fn state(mut self, state: PixelCanvasState) -> Self {
self.state = state;
self.publish_canvas_availability();
self.state.set_viewport_state(self.viewport, Size::ZERO);
self
}
pub fn brush_color(self, color: Color) -> Self {
self.state.set_brush_color(color);
self
}
pub fn brush_size(self, size: f32) -> Self {
self.state.set_brush_size(size);
self
}
pub fn with_pixels(mut self, pixels: Vec<Color>) -> Self {
if pixels.len() == self.pixels.len() {
self.pixels = pixels.into_iter().map(PixelColor::from_color).collect();
self.mark_pixels_changed();
self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
self.publish_canvas_availability();
}
self
}
pub fn set_pixel(&mut self, x: usize, y: usize, color: Color) -> bool {
let Some(index) = self.pixel_index(x, y) else {
return false;
};
let next = PixelColor::from_color(color);
if self.pixels[index] == next {
return false;
}
self.pixels[index] = next;
self.mark_pixels_changed();
if next.alpha > 0 {
self.has_visible_pixels = true;
} else if self.has_visible_pixels {
self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
}
self.publish_canvas_availability();
true
}
pub fn pixel_at(&self, x: usize, y: usize) -> Option<Color> {
self.pixel_index(x, y)
.map(|index| self.pixels[index].to_color())
}
pub const fn width(&self) -> usize {
self.width
}
pub const fn height(&self) -> usize {
self.height
}
pub fn viewport_state(&self) -> CanvasViewport {
self.viewport
}
fn pixel_index(&self, x: usize, y: usize) -> Option<usize> {
(x < self.width && y < self.height).then_some(y * self.width + x)
}
fn document_origin(&self) -> Point {
Point::new(self.width as f32 * 0.5, self.height as f32 * 0.5)
}
fn mark_pixels_changed(&mut self) {
self.pixel_revision = self.pixel_revision.wrapping_add(1);
if self.pixel_revision == 0 {
self.paint_image_cache.borrow_mut().take();
}
}
fn set_pixel_with_history(
&mut self,
x: usize,
y: usize,
color: Color,
opacity: f32,
blend_mode: PixelCanvasBlendMode,
edits: &mut Vec<PixelEdit>,
) -> bool {
let Some(index) = self.pixel_index(x, y) else {
return false;
};
let before = self.pixels[index];
let after = before.compose(color, opacity, blend_mode);
if before == after {
return false;
}
self.pixels[index] = after;
edits.push(PixelEdit {
index,
before,
after,
});
true
}
fn erase_pixel_with_history(
&mut self,
x: usize,
y: usize,
opacity: f32,
edits: &mut Vec<PixelEdit>,
) -> bool {
let Some(index) = self.pixel_index(x, y) else {
return false;
};
let before = self.pixels[index];
let after = before.erased(opacity);
if before == after {
return false;
}
self.pixels[index] = after;
edits.push(PixelEdit {
index,
before,
after,
});
true
}
fn paint_at_world(&mut self, world: Point, edits: &mut Vec<PixelEdit>) -> bool {
let x = world.x.floor() as isize;
let y = world.y.floor() as isize;
let brush = self.state.brush();
let color = match brush.tool {
PixelCanvasTool::Brush => brush.brush,
PixelCanvasTool::Eraser => PixelColor::TRANSPARENT.to_color(),
PixelCanvasTool::Fill | PixelCanvasTool::Pan => return false,
};
let size = brush.brush_size.round().max(1.0) as isize;
let half = size / 2;
let start_x = x - half;
let start_y = y - half;
let mut painted = false;
for py in start_y..start_y + size {
for px in start_x..start_x + size {
if px < 0 || py < 0 {
continue;
}
if !brush_shape_contains_pixel(brush.brush_shape, size, start_x, start_y, px, py) {
continue;
}
painted |= match brush.tool {
PixelCanvasTool::Brush => self.set_pixel_with_history(
px as usize,
py as usize,
color,
brush.brush_opacity,
brush.blend_mode,
edits,
),
PixelCanvasTool::Eraser => self.erase_pixel_with_history(
px as usize,
py as usize,
brush.brush_opacity,
edits,
),
PixelCanvasTool::Fill | PixelCanvasTool::Pan => false,
};
}
}
if painted {
self.mark_pixels_changed();
}
painted
}
fn paint_at_position(
&mut self,
bounds: Rect,
position: Point,
edits: &mut Vec<PixelEdit>,
) -> bool {
let world = self
.viewport
.screen_to_world(bounds, position, self.document_origin());
self.paint_at_world(world, edits)
}
fn paint_between_positions(
&mut self,
bounds: Rect,
start: Point,
end: Point,
edits: &mut Vec<PixelEdit>,
) -> bool {
let document_origin = self.document_origin();
let start = self
.viewport
.screen_to_world(bounds, start, document_origin);
let end = self.viewport.screen_to_world(bounds, end, document_origin);
let delta = end - start;
let distance = (delta.x * delta.x + delta.y * delta.y).sqrt();
if distance <= f32::EPSILON {
return false;
}
let spacing = brush_stroke_spacing(self.state.brush_size());
let steps = (distance / spacing).ceil().max(1.0) as usize;
let mut painted = false;
for step in 1..=steps {
let t = step as f32 / steps as f32;
painted |= self.paint_at_world(
Point::new(start.x + (delta.x * t), start.y + (delta.y * t)),
edits,
);
}
painted
}
fn fill_at_position(
&mut self,
bounds: Rect,
position: Point,
edits: &mut Vec<PixelEdit>,
) -> bool {
let world = self
.viewport
.screen_to_world(bounds, position, self.document_origin());
let x = world.x.floor() as isize;
let y = world.y.floor() as isize;
if x < 0 || y < 0 {
return false;
}
let Some(start) = self.pixel_index(x as usize, y as usize) else {
return false;
};
let brush = self.state.brush();
let target = self.pixels[start];
let replacement = target.compose(brush.brush, brush.brush_opacity, brush.blend_mode);
if target == replacement {
return false;
}
let mut stack = vec![start];
while let Some(index) = stack.pop() {
if self.pixels[index] != target {
continue;
}
self.pixels[index] = replacement;
edits.push(PixelEdit {
index,
before: target,
after: replacement,
});
let px = index % self.width;
let py = index / self.width;
if px > 0 {
stack.push(index - 1);
}
if px + 1 < self.width {
stack.push(index + 1);
}
if py > 0 {
stack.push(index - self.width);
}
if py + 1 < self.height {
stack.push(index + self.width);
}
}
self.mark_pixels_changed();
true
}
fn push_history(&mut self, edits: Vec<PixelEdit>) {
if edits.is_empty() {
return;
}
self.undo_stack.push(edits);
if self.undo_stack.len() > PIXEL_CANVAS_HISTORY_LIMIT {
self.undo_stack.remove(0);
}
self.redo_stack.clear();
self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
self.publish_canvas_availability();
}
fn undo(&mut self) -> bool {
if !self.state.is_editable() {
self.publish_canvas_availability();
return false;
}
let Some(edits) = self.undo_stack.pop() else {
self.publish_canvas_availability();
return false;
};
for edit in edits.iter().rev() {
self.pixels[edit.index] = edit.before;
}
self.mark_pixels_changed();
self.redo_stack.push(edits);
self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
self.publish_canvas_availability();
true
}
fn redo(&mut self) -> bool {
if !self.state.is_editable() {
self.publish_canvas_availability();
return false;
}
let Some(edits) = self.redo_stack.pop() else {
self.publish_canvas_availability();
return false;
};
for edit in &edits {
self.pixels[edit.index] = edit.after;
}
self.mark_pixels_changed();
self.undo_stack.push(edits);
self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
self.publish_canvas_availability();
true
}
fn publish_canvas_availability(&self) -> bool {
let editable = self.state.is_editable();
self.state.set_canvas_availability(
editable && !self.undo_stack.is_empty(),
editable && !self.redo_stack.is_empty(),
editable && self.has_visible_pixels,
)
}
fn publish_viewport_state(&self, bounds: Rect) -> bool {
self.state.set_viewport_state(self.viewport, bounds.size)
}
fn cursor_position_for_pointer(&self, bounds: Rect, position: Point) -> Option<Point> {
if !bounds.contains(position) {
return None;
}
let world = self
.viewport
.screen_to_world(bounds, position, self.document_origin());
let x = world.x.floor();
let y = world.y.floor();
(x >= 0.0 && y >= 0.0 && x < self.width as f32 && y < self.height as f32)
.then_some(Point::new(x, y))
}
fn publish_cursor_position(&self, bounds: Rect, position: Point) -> bool {
self.state
.set_cursor_position(self.cursor_position_for_pointer(bounds, position))
}
fn clear_cursor_position(&self) -> bool {
self.state.set_cursor_position(None)
}
fn clear_pixels(&mut self) -> bool {
if !self.state.is_editable() {
self.publish_canvas_availability();
return false;
}
let mut edits = Vec::new();
for (index, pixel) in self.pixels.iter_mut().enumerate() {
if *pixel == PixelColor::TRANSPARENT {
continue;
}
let before = *pixel;
*pixel = PixelColor::TRANSPARENT;
edits.push(PixelEdit {
index,
before,
after: PixelColor::TRANSPARENT,
});
}
if edits.is_empty() {
self.publish_canvas_availability();
return false;
}
self.has_visible_pixels = false;
self.mark_pixels_changed();
self.push_history(edits);
true
}
fn apply_pending_history_commands(&mut self) -> bool {
let mut changed = false;
while let Some(command) = self.state.take_history_command() {
changed |= match command {
PixelCanvasHistoryCommand::Undo => self.undo(),
PixelCanvasHistoryCommand::Redo => self.redo(),
};
}
changed
}
fn apply_pending_clear_requests(&mut self) -> bool {
if self.state.take_clear_request() {
self.clear_pixels()
} else {
false
}
}
fn fit_view_to_bounds(&mut self, bounds: Rect) -> bool {
if bounds.is_empty() {
return false;
}
let padding = self.resolved_theme().metrics.pixel_canvas_fit_padding;
let (sin, cos) = self.viewport.rotation.sin_cos();
let rotated_width = (self.width as f32 * cos.abs()) + (self.height as f32 * sin.abs());
let rotated_height = (self.width as f32 * sin.abs()) + (self.height as f32 * cos.abs());
let available_width = (bounds.width() - (padding * 2.0)).max(1.0);
let available_height = (bounds.height() - (padding * 2.0)).max(1.0);
let zoom = (available_width / rotated_width.max(1.0))
.min(available_height / rotated_height.max(1.0))
.max(0.01);
let next = CanvasViewport {
pan: Vector::ZERO,
zoom,
rotation: self.viewport.rotation,
};
if self.viewport == next {
return false;
}
self.viewport = next;
true
}
fn set_actual_size_view(&mut self) -> bool {
let next = CanvasViewport {
pan: Vector::ZERO,
zoom: 1.0,
rotation: self.viewport.rotation,
};
if self.viewport == next {
return false;
}
self.viewport = next;
true
}
fn zoom_view_around_center(&mut self, bounds: Rect, factor: f32) -> bool {
if bounds.is_empty() {
return false;
}
let previous = self.viewport;
self.viewport.zoom_around(
bounds,
CanvasViewport::center(bounds),
factor,
self.document_origin(),
);
self.viewport != previous
}
fn apply_pending_viewport_commands(&mut self, bounds: Rect) -> bool {
let mut changed = false;
let zoom_step = self.resolved_theme().metrics.pixel_canvas_zoom_step;
while let Some(command) = self.state.take_viewport_command() {
changed |= match command {
PixelCanvasViewportCommand::Fit => self.fit_view_to_bounds(bounds),
PixelCanvasViewportCommand::ActualSize => self.set_actual_size_view(),
PixelCanvasViewportCommand::ZoomIn => {
self.zoom_view_around_center(bounds, zoom_step)
}
PixelCanvasViewportCommand::ZoomOut => {
self.zoom_view_around_center(bounds, 1.0 / zoom_step)
}
};
}
changed
}
fn apply_initial_fit(&mut self, bounds: Rect) -> bool {
if !self.fit_on_first_layout || self.initial_fit_applied || bounds.is_empty() {
return false;
}
self.initial_fit_applied = true;
self.fit_view_to_bounds(bounds)
}
fn apply_pending_export_requests(&self) -> bool {
if !self.state.take_export_request() {
return false;
}
self.state.publish_export_snapshot(
self.name.clone(),
self.width,
self.height,
self.export_image_data(),
);
true
}
fn export_image_data(&self) -> Vec<u8> {
self.paint_image().bytes().to_vec()
}
fn paint_image(&self) -> RegisteredImage {
let theme = self.resolved_theme();
let display = self.state.display();
let paper = self.state.paper();
let display_above_paper = self.state.display_above_paper();
let paper_color = self.resolved_paper_color(&theme);
self.paint_image_for_source(Self::image_source(
display,
paper,
display_above_paper,
paper_color,
))
}
fn raw_paint_image(&self) -> RegisteredImage {
self.paint_image_for_source(PixelCanvasImageSource::Raw)
}
fn image_source(
display: PixelCanvasDisplaySettings,
paper: PixelCanvasPaperSettings,
display_above_paper: bool,
paper_color: Color,
) -> PixelCanvasImageSource {
if display.requires_compositing() || paper.requires_compositing() || !display_above_paper {
PixelCanvasImageSource::Composited {
display,
paper,
display_above_paper,
paper_color,
}
} else {
PixelCanvasImageSource::Raw
}
}
fn can_paint_with_image_opacity(
display: PixelCanvasDisplaySettings,
paper: PixelCanvasPaperSettings,
display_above_paper: bool,
) -> bool {
display_above_paper
&& display.visible
&& display.blend_mode == PixelCanvasBlendMode::Normal
&& paper.visible
&& paper.opacity >= 0.999
}
fn paint_image_for_source(&self, source: PixelCanvasImageSource) -> RegisteredImage {
let key = PixelCanvasImageCacheKey {
pixel_revision: self.pixel_revision,
source,
};
if let Some(cache) = self.paint_image_cache.borrow().as_ref()
&& cache.key == key
{
return cache.image.clone();
}
let data = match source {
PixelCanvasImageSource::Raw => self.image_data(),
PixelCanvasImageSource::Composited {
display,
paper,
display_above_paper,
paper_color,
} => self.display_image_data(display, paper, display_above_paper, paper_color),
};
let image = RegisteredImage::from_rgba8(self.width as u32, self.height as u32, data)
.expect("pixel canvas image data should match its dimensions")
.without_mipmaps();
*self.paint_image_cache.borrow_mut() = Some(PixelCanvasImageCache {
key,
image: image.clone(),
});
image
}
fn image_data(&self) -> Vec<u8> {
let mut data = Vec::with_capacity(self.pixels.len() * 4);
for pixel in &self.pixels {
data.extend_from_slice(&[pixel.red, pixel.green, pixel.blue, pixel.alpha]);
}
data
}
fn display_image_data(
&self,
display: PixelCanvasDisplaySettings,
paper: PixelCanvasPaperSettings,
display_above_paper: bool,
paper_color: Color,
) -> Vec<u8> {
let paper = paper.pixel(paper_color);
let mut data = Vec::with_capacity(self.pixels.len() * 4);
for pixel in &self.pixels {
let mut output = PixelColor::TRANSPARENT;
if display_above_paper {
output = output.compose(paper.to_color(), 1.0, PixelCanvasBlendMode::Normal);
if display.visible {
output = output.compose(pixel.to_color(), display.opacity, display.blend_mode);
}
} else {
if display.visible {
output = output.compose(pixel.to_color(), display.opacity, display.blend_mode);
}
output = output.compose(paper.to_color(), 1.0, PixelCanvasBlendMode::Normal);
}
data.extend_from_slice(&[output.red, output.green, output.blue, output.alpha]);
}
data
}
fn request_interaction_update(ctx: &mut EventCtx) {
ctx.request_paint();
ctx.request_semantics();
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(self.theme)
}
fn resolved_paper_color(&self, theme: &DefaultTheme) -> Color {
self.paper_color
.unwrap_or_else(|| self.appearance.resolve(theme)[1])
}
}
impl Widget for PixelCanvas {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
let history_changed = self.apply_pending_history_commands();
let viewport_changed = self.apply_pending_viewport_commands(ctx.bounds());
let clear_changed = self.apply_pending_clear_requests();
let export_changed = self.apply_pending_export_requests();
let availability_changed = self.publish_canvas_availability();
if viewport_changed {
self.publish_viewport_state(ctx.bounds());
}
if history_changed
|| viewport_changed
|| clear_changed
|| export_changed
|| availability_changed
{
Self::request_interaction_update(ctx);
}
match event {
Event::Pointer(pointer)
if matches!(
pointer.kind,
PointerEventKind::Move
| PointerEventKind::Down
| PointerEventKind::Scroll
| PointerEventKind::Up
) =>
{
if self.publish_cursor_position(ctx.bounds(), pointer.position) {
Self::request_interaction_update(ctx);
}
}
Event::Pointer(pointer)
if matches!(
pointer.kind,
PointerEventKind::Leave | PointerEventKind::Cancel
) && self.clear_cursor_position() =>
{
Self::request_interaction_update(ctx);
}
_ => {}
}
match event {
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Scroll
&& ctx.bounds().contains(pointer.position) =>
{
let delta = scroll_delta_to_offset(pointer.scroll_delta, pointer.delta);
if pointer.modifiers.shift {
self.viewport.rotate_around(
ctx.bounds(),
pointer.position,
delta.y * 0.01,
self.document_origin(),
);
} else {
self.viewport.zoom_around(
ctx.bounds(),
pointer.position,
(delta.y * 0.002).exp(),
self.document_origin(),
);
}
self.publish_viewport_state(ctx.bounds());
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& ctx.bounds().contains(pointer.position)
&& matches!(
pointer.button,
Some(PointerButton::Middle | PointerButton::Secondary)
) =>
{
self.drag = Some(PixelCanvasDrag::Pan {
pointer_id: pointer.pointer_id,
last_position: pointer.position,
});
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary)
&& ctx.bounds().contains(pointer.position) =>
{
let editable = self.state.is_editable();
match self.state.tool() {
PixelCanvasTool::Brush | PixelCanvasTool::Eraser if editable => {
let mut edits = Vec::new();
self.paint_at_position(ctx.bounds(), pointer.position, &mut edits);
self.active_edits = edits;
self.drag = Some(PixelCanvasDrag::Paint {
pointer_id: pointer.pointer_id,
last_position: pointer.position,
});
}
PixelCanvasTool::Fill if editable => {
let mut edits = Vec::new();
self.fill_at_position(ctx.bounds(), pointer.position, &mut edits);
self.push_history(edits);
}
PixelCanvasTool::Brush | PixelCanvasTool::Eraser | PixelCanvasTool::Fill => {}
PixelCanvasTool::Pan => {
self.drag = Some(PixelCanvasDrag::Pan {
pointer_id: pointer.pointer_id,
last_position: pointer.position,
});
}
}
ctx.request_focus();
if self.drag.is_some() {
ctx.request_pointer_capture(pointer.pointer_id);
}
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => match self.drag {
Some(PixelCanvasDrag::Pan {
pointer_id,
mut last_position,
}) if pointer_id == pointer.pointer_id => {
let delta = pointer.position - last_position;
self.viewport.pan += delta;
last_position = pointer.position;
self.drag = Some(PixelCanvasDrag::Pan {
pointer_id,
last_position,
});
self.publish_viewport_state(ctx.bounds());
Self::request_interaction_update(ctx);
ctx.set_handled();
}
Some(PixelCanvasDrag::Paint {
pointer_id,
last_position,
}) if pointer_id == pointer.pointer_id && self.state.is_editable() => {
let mut edits = std::mem::take(&mut self.active_edits);
self.paint_between_positions(
ctx.bounds(),
last_position,
pointer.position,
&mut edits,
);
self.active_edits = edits;
self.drag = Some(PixelCanvasDrag::Paint {
pointer_id,
last_position: pointer.position,
});
Self::request_interaction_update(ctx);
ctx.set_handled();
}
_ => {}
},
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
|| pointer.kind == PointerEventKind::Cancel =>
{
let active_pointer = match self.drag {
Some(
PixelCanvasDrag::Pan { pointer_id, .. }
| PixelCanvasDrag::Paint { pointer_id, .. },
) => Some(pointer_id),
None => None,
};
if active_pointer == Some(pointer.pointer_id) {
if let Some(PixelCanvasDrag::Paint { last_position, .. }) = self.drag {
let mut edits = std::mem::take(&mut self.active_edits);
if pointer.kind == PointerEventKind::Up && self.state.is_editable() {
self.paint_between_positions(
ctx.bounds(),
last_position,
pointer.position,
&mut edits,
);
}
self.push_history(edits);
}
self.drag = None;
ctx.release_pointer_capture(pointer.pointer_id);
Self::request_interaction_update(ctx);
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
let command_modifier = key.modifiers.control || key.modifiers.meta;
if command_modifier && matches!(key.key.as_str(), "z" | "Z") {
let changed = if key.modifiers.shift {
self.redo()
} else {
self.undo()
};
if changed {
Self::request_interaction_update(ctx);
}
ctx.set_handled();
return;
}
if command_modifier && matches!(key.key.as_str(), "y" | "Y") {
if self.redo() {
Self::request_interaction_update(ctx);
}
ctx.set_handled();
return;
}
let zoom_step = self.resolved_theme().metrics.pixel_canvas_zoom_step;
match key.key.as_str() {
"=" | "+" => self.viewport.zoom_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
zoom_step,
self.document_origin(),
),
"-" => self.viewport.zoom_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
1.0 / zoom_step,
self.document_origin(),
),
"[" => self.viewport.rotate_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
-0.1,
self.document_origin(),
),
"]" => self.viewport.rotate_around(
ctx.bounds(),
CanvasViewport::center(ctx.bounds()),
0.1,
self.document_origin(),
),
"ArrowLeft" => self.viewport.pan.x += 24.0,
"ArrowRight" => self.viewport.pan.x -= 24.0,
"ArrowUp" => self.viewport.pan.y += 24.0,
"ArrowDown" => self.viewport.pan.y -= 24.0,
_ => return,
}
self.publish_viewport_state(ctx.bounds());
Self::request_interaction_update(ctx);
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
if self.apply_pending_history_commands() {
ctx.request_paint();
ctx.request_semantics();
}
if self.apply_pending_clear_requests() {
ctx.request_paint();
ctx.request_semantics();
}
if self.apply_pending_export_requests() {
ctx.request_semantics();
}
if self.publish_canvas_availability() {
ctx.request_semantics();
}
constraints.clamp(Size::new(
if constraints.max.width.is_finite() {
constraints.max.width
} else {
self.desired_size.width
},
if constraints.max.height.is_finite() {
constraints.max.height
} else {
self.desired_size.height
},
))
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
let viewport_changed =
self.apply_initial_fit(bounds) || self.apply_pending_viewport_commands(bounds);
let state_changed = self.publish_viewport_state(bounds);
if viewport_changed || state_changed {
ctx.request_paint();
ctx.request_semantics();
}
}
fn paint(&self, ctx: &mut PaintCtx) {
let theme = self.resolved_theme();
let [background, _, document_edge, shadow_near, shadow_far, grid] =
self.appearance.resolve(&theme);
ctx.fill_bounds(background);
stroke_border(
ctx,
ctx.bounds(),
0.0,
physical_pixels(ctx, theme.metrics.border_width),
theme.surfaces.border,
);
ctx.push_clip_rect(ctx.bounds());
let transform = self
.viewport
.transform(ctx.bounds(), self.document_origin());
let image_bounds = Rect::new(0.0, 0.0, self.width as f32, self.height as f32);
paint_pixel_canvas_document_shadow(ctx, image_bounds, transform, shadow_near, shadow_far);
let paper_color = self.resolved_paper_color(&theme);
let display = self.state.display();
let paper = self.state.paper();
let display_above_paper = self.state.display_above_paper();
let image_handle = ctx.widget_image_handle(0);
let sampling = if self.viewport.zoom >= theme.metrics.pixel_canvas_nearest_sampling_zoom {
ImageSampling::Nearest
} else {
ImageSampling::Linear
};
if Self::can_paint_with_image_opacity(display, paper, display_above_paper) {
fill_transformed_rect(ctx, image_bounds, transform, paper_color);
ctx.register_image(image_handle, self.raw_paint_image());
ctx.draw_image_quad_source(
transformed_rect_points(image_bounds, transform),
ImageSource::new(image_handle)
.with_sampling(sampling)
.with_tint(Color::WHITE.with_alpha(display.opacity)),
);
} else {
let baked_image = display.requires_compositing()
|| paper.requires_compositing()
|| !display_above_paper;
if !baked_image {
fill_transformed_rect(ctx, image_bounds, transform, paper_color);
}
ctx.register_image(image_handle, self.paint_image());
ctx.draw_image_quad_source(
transformed_rect_points(image_bounds, transform),
ImageSource::new(image_handle).with_sampling(sampling),
);
}
if self.viewport.zoom >= theme.metrics.pixel_canvas_grid_zoom
&& let Some(range) = pixel_visible_range(
self.viewport,
ctx.bounds(),
self.document_origin(),
self.width,
self.height,
)
{
paint_pixel_grid(ctx, range, transform, grid);
}
ctx.stroke(
transformed_rect_path(image_bounds, transform),
document_edge,
StrokeStyle::new(1.0),
);
ctx.pop_clip();
draw_focus_ring(ctx, ctx.bounds(), &theme, self.focus_animation.get(ctx));
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Canvas, ctx.bounds());
node.name = Some(self.name.clone());
node.description = Some(format!("{} by {} pixel canvas", self.width, self.height));
let tool = self.state.tool();
let brush_size = self.state.brush_size();
let brush_opacity = self.state.brush_opacity();
let brush_shape = self.state.brush_shape();
let blend_mode = self.state.blend_mode();
let editable = self.state.is_editable();
let display = self.state.display();
let paper = self.state.paper();
node.value = Some(SemanticsValue::Text(format!(
"tool {}, zoom {:.0}%, rotation {:.0} deg, brush {:.0} px, shape {}, opacity {:.0}%, blend {}, paint layer {}, paint opacity {:.0}%, paint blend {}, paper layer {}, paper opacity {:.0}%, {}",
tool.label(),
self.viewport.zoom * 100.0,
self.viewport.rotation.to_degrees(),
brush_size,
brush_shape.label(),
brush_opacity * 100.0,
blend_mode.label(),
if display.visible { "visible" } else { "hidden" },
display.opacity * 100.0,
display.blend_mode.label(),
if paper.visible { "visible" } else { "hidden" },
paper.opacity * 100.0,
if editable { "editable" } else { "read only" }
)));
node.state.focused = ctx.is_focused();
node.actions = vec![
SemanticsAction::Focus,
SemanticsAction::Custom("Pan".into()),
];
if editable {
node.actions.push(SemanticsAction::Custom("Paint".into()));
}
if editable && self.state.can_undo() {
node.actions.push(SemanticsAction::Undo);
}
if editable && self.state.can_redo() {
node.actions.push(SemanticsAction::Redo);
}
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
true
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
Self::request_interaction_update(ctx);
}
}
fn fill_transformed_rect(ctx: &mut PaintCtx, rect: Rect, transform: Transform, color: Color) {
if transform.yx.abs() < AXIS_ALIGNED_EPSILON && transform.xy.abs() < AXIS_ALIGNED_EPSILON {
ctx.fill_rect(transform.transform_rect_bbox(rect), color);
} else {
ctx.fill(transformed_rect_path(rect, transform), color);
}
}
fn paint_pixel_canvas_document_shadow(
ctx: &mut PaintCtx,
rect: Rect,
transform: Transform,
shadow_near: Color,
shadow_far: Color,
) {
fill_transformed_rect(
ctx,
rect,
transform.then(Transform::translation(0.0, 7.0)),
shadow_far,
);
fill_transformed_rect(
ctx,
rect,
transform.then(Transform::translation(0.0, 3.0)),
shadow_near,
);
}
fn paint_canvas_ruler_divider(
ctx: &mut PaintCtx,
bounds: Rect,
axis: CanvasRulerAxis,
color: Color,
) {
match axis {
CanvasRulerAxis::Horizontal => {
stroke_line(
ctx,
Point::new(bounds.x(), bounds.max_y()),
Point::new(bounds.max_x(), bounds.max_y()),
color,
1.0,
);
}
CanvasRulerAxis::Vertical => {
stroke_line(
ctx,
Point::new(bounds.max_x(), bounds.y()),
Point::new(bounds.max_x(), bounds.max_y()),
color,
1.0,
);
}
}
}
fn paint_canvas_ruler_ticks(
ctx: &mut PaintCtx,
bounds: Rect,
axis: CanvasRulerAxis,
document_size: Size,
viewport: CanvasViewport,
viewport_size: Size,
theme: &DefaultTheme,
tick_color: Color,
text_style: TextStyle,
) {
let canvas_bounds = ruler_canvas_bounds(bounds, axis, viewport_size);
let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
let visible = ruler_visible_range(bounds, axis, document_size, viewport, canvas_bounds);
let major_step = ruler_major_step(
viewport.zoom,
theme.metrics.canvas_ruler_target_major_spacing,
);
let minor_step = (major_step / 5.0).max(1.0);
let start = (visible.0 / minor_step).floor() * minor_step;
let end = visible.1 + minor_step;
let mut value = start;
let mut count = 0;
while value <= end && count < CANVAS_RULER_MAX_TICKS {
if value >= 0.0 && value <= ruler_document_length(axis, document_size) {
let major = is_major_ruler_tick(value, major_step);
let position = ruler_tick_screen_position(
axis,
value,
document_size,
viewport,
canvas_bounds,
document_origin,
);
if ruler_position_in_bounds(position, bounds, axis) {
paint_canvas_ruler_tick(
ctx,
bounds,
axis,
position,
major,
tick_color,
theme.metrics.canvas_ruler_major_tick,
theme.metrics.canvas_ruler_minor_tick,
);
if major {
paint_canvas_ruler_label(
ctx,
bounds,
axis,
position,
value,
text_style.clone(),
theme.metrics.canvas_ruler_label_padding,
theme.metrics.canvas_ruler_label_max_width,
);
}
}
}
value += minor_step;
count += 1;
}
}
fn ruler_canvas_bounds(bounds: Rect, axis: CanvasRulerAxis, viewport_size: Size) -> Rect {
match axis {
CanvasRulerAxis::Horizontal => Rect::new(
bounds.x(),
bounds.y(),
bounds.width(),
viewport_size.height.max(bounds.height()),
),
CanvasRulerAxis::Vertical => Rect::new(
bounds.x(),
bounds.y(),
viewport_size.width.max(bounds.width()),
bounds.height(),
),
}
}
fn ruler_visible_range(
bounds: Rect,
axis: CanvasRulerAxis,
document_size: Size,
viewport: CanvasViewport,
canvas_bounds: Rect,
) -> (f32, f32) {
let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
let center = CanvasViewport::center(canvas_bounds);
let (start, end) = match axis {
CanvasRulerAxis::Horizontal => (
viewport
.screen_to_world(
canvas_bounds,
Point::new(bounds.x(), center.y),
document_origin,
)
.x,
viewport
.screen_to_world(
canvas_bounds,
Point::new(bounds.max_x(), center.y),
document_origin,
)
.x,
),
CanvasRulerAxis::Vertical => (
viewport
.screen_to_world(
canvas_bounds,
Point::new(center.x, bounds.y()),
document_origin,
)
.y,
viewport
.screen_to_world(
canvas_bounds,
Point::new(center.x, bounds.max_y()),
document_origin,
)
.y,
),
};
(start.min(end), start.max(end))
}
fn ruler_major_step(zoom: f32, target_major_spacing: f32) -> f32 {
let target_world = (target_major_spacing.max(1.0) / zoom.max(0.01)).max(1.0);
let magnitude = 10.0_f32.powf(target_world.log10().floor());
for multiplier in [1.0, 2.0, 5.0, 10.0] {
let step = multiplier * magnitude;
if step >= target_world {
return step;
}
}
10.0 * magnitude
}
fn ruler_document_length(axis: CanvasRulerAxis, document_size: Size) -> f32 {
match axis {
CanvasRulerAxis::Horizontal => document_size.width,
CanvasRulerAxis::Vertical => document_size.height,
}
}
fn is_major_ruler_tick(value: f32, major_step: f32) -> bool {
let nearest = (value / major_step).round() * major_step;
(value - nearest).abs() < 0.01
}
fn ruler_tick_screen_position(
axis: CanvasRulerAxis,
value: f32,
document_size: Size,
viewport: CanvasViewport,
canvas_bounds: Rect,
document_origin: Point,
) -> f32 {
match axis {
CanvasRulerAxis::Horizontal => {
viewport
.world_to_screen(
canvas_bounds,
Point::new(value, document_size.height * 0.5),
document_origin,
)
.x
}
CanvasRulerAxis::Vertical => {
viewport
.world_to_screen(
canvas_bounds,
Point::new(document_size.width * 0.5, value),
document_origin,
)
.y
}
}
}
fn ruler_position_in_bounds(position: f32, bounds: Rect, axis: CanvasRulerAxis) -> bool {
match axis {
CanvasRulerAxis::Horizontal => position >= bounds.x() && position <= bounds.max_x(),
CanvasRulerAxis::Vertical => position >= bounds.y() && position <= bounds.max_y(),
}
}
fn paint_canvas_ruler_tick(
ctx: &mut PaintCtx,
bounds: Rect,
axis: CanvasRulerAxis,
position: f32,
major: bool,
color: Color,
major_length: f32,
minor_length: f32,
) {
let length = if major { major_length } else { minor_length };
match axis {
CanvasRulerAxis::Horizontal => stroke_line(
ctx,
Point::new(position, bounds.max_y()),
Point::new(position, bounds.max_y() - length),
color,
1.0,
),
CanvasRulerAxis::Vertical => stroke_line(
ctx,
Point::new(bounds.max_x(), position),
Point::new(bounds.max_x() - length, position),
color,
1.0,
),
}
}
fn paint_canvas_ruler_label(
ctx: &mut PaintCtx,
bounds: Rect,
axis: CanvasRulerAxis,
position: f32,
value: f32,
mut style: TextStyle,
padding: sui_layout::Padding,
max_width: f32,
) {
style.features.enable(FontFeature::TABULAR_FIGURES);
let label = format!("{value:.0}");
let measurement = paint_text_measurement(ctx, &label, &style);
let available_height = (bounds.height() - padding.top - padding.bottom).max(0.0);
let slot = match axis {
CanvasRulerAxis::Horizontal => Rect::new(
position + padding.left,
bounds.y() + padding.top,
max_width.min((bounds.max_x() - position - padding.left).max(0.0)),
available_height,
),
CanvasRulerAxis::Vertical => {
let height = style
.line_height
.max(measurement.height)
.min(available_height);
let min_y = bounds.y() + padding.top;
let max_y = (bounds.max_y() - padding.bottom - height).max(min_y);
Rect::new(
bounds.x() + padding.left,
(position - (height * 0.5)).clamp(min_y, max_y),
max_width.min((bounds.width() - padding.left - padding.right).max(0.0)),
height,
)
}
};
if slot.width() <= 0.0 || slot.height() <= 0.0 {
return;
}
if measurement.width <= slot.width() {
let width = measurement.width.min(slot.width()).max(0.0);
paint_text(
ctx,
Rect::new(slot.x(), slot.y(), width, slot.height()),
&label,
&style,
TextAlign::Start,
);
}
}
fn paint_text_measurement(ctx: &PaintCtx, text: &str, style: &TextStyle) -> TextMeasurement {
ctx.measure_text(text.to_string(), style.clone())
.unwrap_or(TextMeasurement {
width: text.chars().count() as f32 * style.font_size * 0.58,
height: style.line_height,
bounds: Rect::new(
0.0,
0.0,
text.chars().count() as f32 * style.font_size * 0.58,
style.line_height,
),
ascent: style.font_size * 0.8,
descent: style.font_size * 0.2,
cap_height: Some(style.font_size),
})
}
fn stroke_line(ctx: &mut PaintCtx, from: Point, to: Point, color: Color, width: f32) {
let mut path = PathBuilder::new();
path.move_to(from).line_to(to);
ctx.stroke(path.build(), color, StrokeStyle::new(width));
}
fn scroll_delta_to_offset(scroll_delta: Option<ScrollDelta>, fallback: Vector) -> Vector {
match scroll_delta {
Some(ScrollDelta::Pixels(delta)) => delta,
Some(ScrollDelta::Lines(delta)) => Vector::new(delta.x * 24.0, delta.y * 24.0),
None => fallback,
}
}
fn vector_length(vector: Vector) -> f32 {
((vector.x * vector.x) + (vector.y * vector.y)).sqrt()
}
fn path_from_points(points: &[Point]) -> Option<Path> {
let first = points.first().copied()?;
let mut builder = PathBuilder::new();
builder.move_to(first);
for point in &points[1..] {
builder.line_to(*point);
}
Some(builder.build())
}
fn paint_canvas_shape(
ctx: &mut PaintCtx,
shape: &CanvasShape,
transform: Transform,
stroke_scale: f32,
) {
match shape {
CanvasShape::Path { path, fill, stroke } => {
let path = transform_path(path, transform);
if let Some(fill) = fill {
ctx.fill(path.clone(), *fill);
}
if let Some(stroke) = stroke {
ctx.stroke(
path,
stroke.color,
StrokeStyle::new((stroke.width * stroke_scale).max(0.5)),
);
}
}
}
}
fn paint_canvas_axes(
ctx: &mut PaintCtx,
viewport: CanvasViewport,
bounds: Rect,
document_origin: Point,
theme: &DefaultTheme,
axis_x_color: Color,
axis_y_color: Color,
) {
let overscan = theme.metrics.canvas_axis_overscan;
let visible =
canvas_visible_world_rect(viewport, bounds, document_origin).inflate(overscan, overscan);
let transform = viewport.transform(bounds, document_origin);
let mut x_axis = PathBuilder::new();
x_axis
.move_to(transform.transform_point(Point::new(visible.x(), 0.0)))
.line_to(transform.transform_point(Point::new(visible.max_x(), 0.0)));
ctx.stroke(x_axis.build(), axis_x_color, StrokeStyle::new(1.0));
let mut y_axis = PathBuilder::new();
y_axis
.move_to(transform.transform_point(Point::new(0.0, visible.y())))
.line_to(transform.transform_point(Point::new(0.0, visible.max_y())));
ctx.stroke(y_axis.build(), axis_y_color, StrokeStyle::new(1.0));
}
pub fn paint_canvas_grid(
ctx: &mut PaintCtx,
viewport: CanvasViewport,
bounds: Rect,
document_origin: Point,
base_spacing: f32,
style: CanvasGridStyle,
grid_color: Color,
) {
if style == CanvasGridStyle::None {
return;
}
let mut step = base_spacing.max(1.0);
while step * viewport.zoom < MIN_CANVAS_GRID_SCREEN_SPACING {
step *= 2.0;
}
let visible = canvas_visible_world_rect(viewport, bounds, document_origin).inflate(step, step);
let transform = viewport.transform(bounds, document_origin);
let min_x = (visible.x() / step).floor() as i32 - 1;
let max_x = (visible.max_x() / step).ceil() as i32 + 1;
let min_y = (visible.y() / step).floor() as i32 - 1;
let max_y = (visible.max_y() / step).ceil() as i32 + 1;
if style == CanvasGridStyle::Lines {
let mut builder = PathBuilder::new();
for x in min_x..=max_x {
let x = x as f32 * step;
builder
.move_to(transform.transform_point(Point::new(x, visible.y())))
.line_to(transform.transform_point(Point::new(x, visible.max_y())));
}
for y in min_y..=max_y {
let y = y as f32 * step;
builder
.move_to(transform.transform_point(Point::new(visible.x(), y)))
.line_to(transform.transform_point(Point::new(visible.max_x(), y)));
}
ctx.stroke(builder.build(), grid_color, StrokeStyle::new(1.0));
return;
}
let mark_size = if style == CanvasGridStyle::Dots {
1.25
} else {
2.5
};
let mut marks = 0usize;
for y in min_y..=max_y {
for x in min_x..=max_x {
if marks >= 4096 {
return;
}
let position = transform.transform_point(Point::new(x as f32 * step, y as f32 * step));
match style {
CanvasGridStyle::Dots => {
ctx.fill_rrect(
Rect::new(
position.x - mark_size,
position.y - mark_size,
mark_size * 2.0,
mark_size * 2.0,
),
[mark_size; 4],
grid_color,
);
}
CanvasGridStyle::Cross => {
let mut cross = PathBuilder::new();
cross
.move_to(Point::new(position.x - mark_size, position.y))
.line_to(Point::new(position.x + mark_size, position.y))
.move_to(Point::new(position.x, position.y - mark_size))
.line_to(Point::new(position.x, position.y + mark_size));
ctx.stroke(cross.build(), grid_color, StrokeStyle::new(1.0));
}
CanvasGridStyle::None | CanvasGridStyle::Lines => unreachable!(),
}
marks += 1;
}
}
}
fn canvas_visible_world_rect(
viewport: CanvasViewport,
bounds: Rect,
document_origin: Point,
) -> Rect {
let points = [
viewport.screen_to_world(bounds, bounds.origin, document_origin),
viewport.screen_to_world(
bounds,
Point::new(bounds.max_x(), bounds.y()),
document_origin,
),
viewport.screen_to_world(
bounds,
Point::new(bounds.x(), bounds.max_y()),
document_origin,
),
viewport.screen_to_world(
bounds,
Point::new(bounds.max_x(), bounds.max_y()),
document_origin,
),
];
let min_x = points
.iter()
.map(|point| point.x)
.fold(f32::INFINITY, f32::min);
let min_y = points
.iter()
.map(|point| point.y)
.fold(f32::INFINITY, f32::min);
let max_x = points
.iter()
.map(|point| point.x)
.fold(f32::NEG_INFINITY, f32::max);
let max_y = points
.iter()
.map(|point| point.y)
.fold(f32::NEG_INFINITY, f32::max);
Rect::from_points(Point::new(min_x, min_y), Point::new(max_x, max_y))
}
fn transform_path(path: &Path, transform: Transform) -> Path {
let mut builder = PathBuilder::new();
for element in path.elements() {
match *element {
PathElement::MoveTo(point) => {
builder.move_to(transform.transform_point(point));
}
PathElement::LineTo(point) => {
builder.line_to(transform.transform_point(point));
}
PathElement::QuadTo { ctrl, to } => {
builder.quad_to(
transform.transform_point(ctrl),
transform.transform_point(to),
);
}
PathElement::CubicTo { ctrl1, ctrl2, to } => {
builder.cubic_to(
transform.transform_point(ctrl1),
transform.transform_point(ctrl2),
transform.transform_point(to),
);
}
PathElement::Close => {
builder.close();
}
}
}
builder.build()
}
fn transformed_rect_path(rect: Rect, transform: Transform) -> Path {
let points = transformed_rect_points(rect, transform);
let mut builder = PathBuilder::new();
builder
.move_to(points[0])
.line_to(points[1])
.line_to(points[3])
.line_to(points[2])
.close();
builder.build()
}
fn transformed_rect_points(rect: Rect, transform: Transform) -> [Point; 4] {
[
transform.transform_point(rect.origin),
transform.transform_point(Point::new(rect.max_x(), rect.y())),
transform.transform_point(Point::new(rect.x(), rect.max_y())),
transform.transform_point(Point::new(rect.max_x(), rect.max_y())),
]
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PixelRenderRange {
start_x: usize,
end_x: usize,
start_y: usize,
end_y: usize,
}
fn pixel_visible_range(
viewport: CanvasViewport,
bounds: Rect,
document_origin: Point,
width: usize,
height: usize,
) -> Option<PixelRenderRange> {
let visible = canvas_visible_world_rect(viewport, bounds, document_origin)
.intersection(Rect::new(0.0, 0.0, width as f32, height as f32))?;
let start_x = visible.x().floor().max(0.0) as usize;
let start_y = visible.y().floor().max(0.0) as usize;
let end_x = visible.max_x().ceil().min(width as f32) as usize;
let end_y = visible.max_y().ceil().min(height as f32) as usize;
if start_x >= end_x || start_y >= end_y {
return None;
}
Some(PixelRenderRange {
start_x,
end_x,
start_y,
end_y,
})
}
fn paint_pixel_grid(
ctx: &mut PaintCtx,
range: PixelRenderRange,
transform: Transform,
color: Color,
) {
let mut builder = PathBuilder::new();
for x in range.start_x..=range.end_x {
let x = x as f32;
builder
.move_to(transform.transform_point(Point::new(x, range.start_y as f32)))
.line_to(transform.transform_point(Point::new(x, range.end_y as f32)));
}
for y in range.start_y..=range.end_y {
let y = y as f32;
builder
.move_to(transform.transform_point(Point::new(range.start_x as f32, y)))
.line_to(transform.transform_point(Point::new(range.end_x as f32, y)));
}
ctx.stroke(builder.build(), color, StrokeStyle::new(1.0));
}
fn channel_to_u8(channel: f32) -> u8 {
(channel.clamp(0.0, 1.0) * 255.0).round() as u8
}
#[cfg(test)]
mod tests {
use std::{cell::RefCell, rc::Rc};
use super::{
Canvas, CanvasColors, CanvasRuler, CanvasShape, CanvasStroke, CanvasViewport,
CanvasZoomBehavior, PixelCanvas, PixelCanvasBlendMode, PixelCanvasBrushShape,
PixelCanvasColors, PixelCanvasState, PixelCanvasTool, PixelColor,
};
use crate::{CanvasRulerAxis, DefaultTheme, ThemeTextToken};
use sui_core::{
Color, Event, KeyState, KeyboardEvent, Modifiers, Point, PointerButton, PointerButtons,
PointerEvent, PointerEventKind, PointerKind, Rect, ScrollDelta, SemanticsAction,
SemanticsNode, SemanticsRole, SemanticsValue, Size, Transform, Vector, WindowEvent,
};
use sui_layout::Constraints;
use sui_runtime::{
Application, EventCtx, MeasureCtx, PaintCtx, RenderOutput, Runtime, SemanticsCtx, Widget,
WindowBuilder,
};
use sui_scene::{Brush, ImageSampling, RegisteredImage, SceneCommand};
use sui_text::{FontFeature, FontRegistry, TextSystem};
const RGBA_CHANNEL_TOLERANCE: u8 = 1;
struct CanvasContentProbe {
name: &'static str,
pointer_positions: Rc<RefCell<Vec<Point>>>,
}
impl Widget for CanvasContentProbe {
fn event(&mut self, _ctx: &mut EventCtx, event: &Event) {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Down
{
self.pointer_positions.borrow_mut().push(pointer.position);
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(100.0, 60.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.fill_bounds(Color::rgba(0.8, 0.2, 0.1, 1.0));
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
node.name = Some(self.name.to_string());
ctx.push(node);
}
}
fn build_runtime<W>(root: W) -> (Runtime, sui_core::WindowId)
where
W: Widget + 'static,
{
let runtime = Application::new()
.window(WindowBuilder::new().title("Canvas widgets").root(root))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id)
}
fn render<W>(root: W) -> RenderOutput
where
W: Widget + 'static,
{
let (mut runtime, window_id) = build_runtime(root);
runtime.render(window_id).expect("render should succeed")
}
fn handle_ready_events(runtime: &mut Runtime) -> usize {
let ready = runtime.drain_ready_events();
let count = ready.len();
for (window_id, event) in ready {
runtime
.handle_event(window_id, event)
.expect("ready event should be handled");
}
count
}
fn primary_pointer(kind: PointerEventKind, position: Point, pressed: bool) -> Event {
let mut buttons = PointerButtons::NONE;
if pressed {
buttons.insert(PointerButton::Primary);
}
let mut pointer = PointerEvent::new(kind, position);
pointer.pointer_id = 1;
pointer.button = Some(PointerButton::Primary);
pointer.buttons = buttons;
Event::Pointer(pointer)
}
fn touch_pointer(
pointer_id: u64,
kind: PointerEventKind,
position: Point,
pressed: bool,
) -> Event {
let mut pointer = match primary_pointer(kind, position, pressed) {
Event::Pointer(pointer) => pointer,
_ => unreachable!(),
};
pointer.pointer_id = pointer_id;
pointer.pointer_kind = PointerKind::Touch;
Event::Pointer(pointer)
}
fn command_key(key: &str) -> Event {
let mut event = KeyboardEvent::new(key, KeyState::Pressed);
event.modifiers.control = true;
Event::Keyboard(event)
}
fn rendered_pixel_bytes(output: &RenderOutput) -> Vec<u8> {
rendered_pixel_image(output).bytes().to_vec()
}
fn rendered_pixel_image(output: &RenderOutput) -> &RegisteredImage {
let source = rendered_pixel_image_source(output);
output
.frame
.image_registry
.get(source.image)
.expect("pixel canvas image should be registered")
}
fn rendered_pixel_image_source(output: &RenderOutput) -> sui_scene::ImageSource {
let mut image_handle = None;
let mut image_source = None;
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } = command
{
image_handle = Some(source.image);
image_source = Some(source.clone());
}
});
let source = image_source.expect("pixel canvas should draw an image");
assert_eq!(
Some(source.image),
image_handle,
"captured image source should match the image handle"
);
source
}
fn pixel_canvas_zoom_percent(output: &RenderOutput) -> f32 {
let node = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Canvas && node.name.as_deref() == Some("Paint")
})
.expect("pixel canvas semantics should be present");
let value = match node.value.as_ref() {
Some(SemanticsValue::Text(value)) => value,
_ => panic!("pixel canvas should expose zoom in text semantics"),
};
let start = value.find("zoom ").expect("zoom label should be present") + "zoom ".len();
let end = value[start..]
.find('%')
.expect("zoom value should include percent")
+ start;
value[start..end]
.parse::<f32>()
.expect("zoom percent should parse")
}
fn solid_fill_colors(output: &RenderOutput) -> Vec<Color> {
let mut colors = Vec::new();
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::FillRect {
brush: Brush::Solid(color),
..
}
| SceneCommand::FillPath {
brush: Brush::Solid(color),
..
} = command
{
colors.push(*color);
}
});
colors
}
fn solid_stroke_colors(output: &RenderOutput) -> Vec<Color> {
let mut colors = Vec::new();
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::StrokeRect {
brush: Brush::Solid(color),
..
}
| SceneCommand::StrokePath {
brush: Brush::Solid(color),
..
} = command
{
colors.push(*color);
}
});
colors
}
fn contains_approx_color(colors: &[Color], expected: Color) -> bool {
const CHANNEL_TOLERANCE: f32 = 1.0 / 255.0;
colors.iter().any(|color| {
color.space == expected.space
&& (color.red - expected.red).abs() <= CHANNEL_TOLERANCE
&& (color.green - expected.green).abs() <= CHANNEL_TOLERANCE
&& (color.blue - expected.blue).abs() <= CHANNEL_TOLERANCE
&& (color.alpha - expected.alpha).abs() <= CHANNEL_TOLERANCE
})
}
fn numeric_text_runs(output: &RenderOutput) -> Vec<sui_text::TextRun> {
let mut runs = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::DrawText(text_run)
if text_run
.text
.chars()
.all(|character| character.is_ascii_digit()) =>
{
runs.push(text_run.clone());
}
SceneCommand::DrawShapedText(text) => {
if let Some(layout) = text.resolve(output.frame.text_layout_registry.as_ref())
&& layout
.text()
.chars()
.all(|character| character.is_ascii_digit())
{
runs.push(sui_text::TextRun {
rect: Rect::new(
text.origin.x,
text.origin.y,
layout.box_size().width,
layout.box_size().height,
),
text: layout.text().to_string(),
style: layout.style().clone(),
});
}
}
_ => {}
});
runs
}
fn optical_visual_center(measurement: sui_text::TextMeasurement) -> f32 {
let top = -measurement.cap_height.unwrap_or(measurement.ascent);
let bottom = measurement.descent * 0.5;
(top + bottom) * 0.5
}
fn rgba_channels_match(actual: &[u8], expected: [u8; 4]) -> bool {
actual.len() == 4
&& actual
.iter()
.zip(expected.iter())
.all(|(actual, expected)| actual.abs_diff(*expected) <= RGBA_CHANNEL_TOLERANCE)
}
fn assert_rgba_channels_near(actual: &[u8], expected: [u8; 4]) {
assert_eq!(
actual.len(),
4,
"expected exactly one RGBA pixel, got {} channels",
actual.len()
);
for channel in 0..4 {
assert!(
actual[channel].abs_diff(expected[channel]) <= RGBA_CHANNEL_TOLERANCE,
"channel {channel} differed by more than {RGBA_CHANNEL_TOLERANCE}: got {}, expected {}",
actual[channel],
expected[channel]
);
}
}
fn assert_rgba_buffers_near(actual: &[u8], expected: &[u8]) {
assert_eq!(
actual.len(),
expected.len(),
"RGBA buffer length mismatch: got {}, expected {}",
actual.len(),
expected.len()
);
assert_eq!(
actual.len() % 4,
0,
"RGBA buffer length must be divisible by 4"
);
for (pixel_index, (actual_pixel, expected_pixel)) in actual
.as_chunks::<4>()
.0
.iter()
.zip(expected.as_chunks::<4>().0.iter())
.enumerate()
{
for channel in 0..4 {
assert!(
actual_pixel[channel].abs_diff(expected_pixel[channel])
<= RGBA_CHANNEL_TOLERANCE,
"pixel {pixel_index} channel {channel} differed by more than {RGBA_CHANNEL_TOLERANCE}: got {}, expected {}",
actual_pixel[channel],
expected_pixel[channel]
);
}
}
}
fn alpha_matches(pixel: &[u8], expected: u8) -> bool {
pixel
.get(3)
.is_some_and(|alpha| alpha.abs_diff(expected) <= RGBA_CHANNEL_TOLERANCE)
}
fn pixel_matches_color(pixel: &[u8], color: PixelColor) -> bool {
rgba_channels_match(pixel, [color.red, color.green, color.blue, color.alpha])
}
#[test]
fn canvas_value_types_are_plain_data_that_paint_safely() {
let viewport = CanvasViewport::new().zoom(0.0);
assert_eq!(viewport.zoom, 0.0, "the builder stores what it is given");
let bounds = Rect::new(0.0, 0.0, 200.0, 100.0);
let world = viewport.screen_to_world(bounds, Point::new(150.0, 30.0), Point::ZERO);
assert!(world.x.is_finite() && world.y.is_finite());
let surface = super::CanvasSurface::default().grid_spacing(0.0);
assert_eq!(surface.grid_spacing, 0.0);
assert_eq!(surface.viewport, CanvasViewport::default());
}
#[test]
fn viewport_screen_world_mapping_round_trips_nonzero_bounds() {
let viewport = CanvasViewport::new()
.pan(Vector::new(24.0, -18.0))
.zoom(2.35)
.rotation(0.42);
let bounds = Rect::new(180.0, 96.0, 420.0, 260.0);
let document_origin = Point::new(16.0, 12.0);
let cursor = Point::new(412.0, 214.0);
let world = viewport.screen_to_world(bounds, cursor, document_origin);
let screen = viewport.world_to_screen(bounds, world, document_origin);
assert!((screen.x - cursor.x).abs() < 0.001);
assert!((screen.y - cursor.y).abs() < 0.001);
}
#[test]
fn canvas_ruler_exposes_semantics_and_draws_ticks() {
let theme = DefaultTheme::default();
let output = render(
crate::SizedBox::new()
.size(Size::new(420.0, theme.metrics.canvas_ruler_extent))
.child(
CanvasRuler::horizontal("Horizontal ruler", Size::new(1920.0, 1080.0))
.viewport(CanvasViewport::new().zoom(0.5), Size::new(420.0, 260.0)),
),
);
let ruler = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::GenericContainer
&& node.name.as_deref() == Some("Horizontal ruler")
})
.expect("ruler semantics should exist");
assert_eq!(
ruler.bounds,
Rect::new(0.0, 0.0, 420.0, theme.metrics.canvas_ruler_extent)
);
assert_eq!(
ruler.value,
Some(SemanticsValue::Text(
"horizontal ruler, 1920 px document axis".to_string(),
))
);
let mut stroke_count = 0;
let mut label_count = 0;
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::StrokePath { .. } => stroke_count += 1,
SceneCommand::DrawText(_) | SceneCommand::DrawShapedText(_) => label_count += 1,
_ => {}
});
assert!(stroke_count > 2);
assert!(label_count > 0);
}
#[test]
fn canvas_ruler_defaults_follow_theme_density_and_extent_override() {
let compact = DefaultTheme::compact();
let touch = DefaultTheme::touch();
let compact_output = render(crate::SizedBox::new().width(420.0).child(
CanvasRuler::horizontal("Compact ruler", Size::new(1920.0, 1080.0)).theme(compact),
));
let touch_output =
render(crate::SizedBox::new().width(420.0).child(
CanvasRuler::horizontal("Touch ruler", Size::new(1920.0, 1080.0)).theme(touch),
));
let override_output = render(
crate::SizedBox::new().width(420.0).child(
CanvasRuler::horizontal("Override ruler", Size::new(1920.0, 1080.0))
.theme(touch)
.extent(18.0),
),
);
let ruler_height = |output: &RenderOutput, name: &str| {
output
.semantics
.iter()
.find(|node| node.name.as_deref() == Some(name))
.expect("ruler semantics should exist")
.bounds
.height()
};
assert_eq!(
ruler_height(&compact_output, "Compact ruler"),
compact.metrics.canvas_ruler_extent
);
assert_eq!(
ruler_height(&touch_output, "Touch ruler"),
touch.metrics.canvas_ruler_extent
);
assert_eq!(ruler_height(&override_output, "Override ruler"), 18.0);
}
#[test]
fn canvas_ruler_numeric_labels_use_tabular_figures_and_optical_centering() {
let theme = DefaultTheme::default();
let output = render(
crate::SizedBox::new()
.size(Size::new(420.0, theme.metrics.canvas_ruler_extent))
.child(
CanvasRuler::horizontal("Horizontal ruler", Size::new(1920.0, 1080.0))
.viewport(
CanvasViewport::new().pan(Vector::new(750.0, 0.0)),
Size::new(420.0, 260.0),
),
),
);
let text = numeric_text_runs(&output)
.into_iter()
.next()
.expect("ruler should draw at least one numeric label");
let layout = TextSystem::new()
.shape_text_run(&text, &FontRegistry::new())
.expect("ruler label should shape");
let line = layout
.lines()
.first()
.expect("ruler label should contain one line");
let measurement = layout.measurement();
let actual_visual_center =
text.rect.y() + line.baseline + optical_visual_center(measurement);
let slot_center = theme.metrics.canvas_ruler_label_padding.top
+ (theme.metrics.canvas_ruler_extent
- theme.metrics.canvas_ruler_label_padding.top
- theme.metrics.canvas_ruler_label_padding.bottom)
* 0.5;
assert!(
text.style
.features
.iter()
.any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
);
assert!(
(text.rect.width() - measurement.width).abs() < 0.75,
"ruler label rect should use measured width: rect={:?}, measurement={measurement:?}",
text.rect
);
assert!(
(actual_visual_center - slot_center).abs() < 0.75,
"ruler label visual center {actual_visual_center} did not match slot center {slot_center}; text rect {:?}",
text.rect
);
}
#[test]
fn horizontal_canvas_ruler_preserves_tall_label_measurements() {
let mut theme = DefaultTheme::default();
theme.text.xs = ThemeTextToken {
size: 32.0,
line_height: 12.0,
};
theme.metrics.canvas_ruler_label_max_width = 120.0;
let extent = 96.0;
let output = render(
crate::SizedBox::new().size(Size::new(420.0, extent)).child(
CanvasRuler::horizontal("Tall horizontal ruler", Size::new(1920.0, 1080.0))
.theme(theme)
.extent(extent)
.viewport(
CanvasViewport::new().pan(Vector::new(750.0, 0.0)),
Size::new(420.0, 260.0),
),
),
);
let text = numeric_text_runs(&output)
.into_iter()
.next()
.expect("horizontal ruler should draw at least one numeric label");
let layout = TextSystem::new()
.shape_text_run(&text, &FontRegistry::new())
.expect("ruler label should shape");
let measurement = layout.measurement();
let line = layout
.lines()
.first()
.expect("ruler label should contain one line");
let slot_center = theme.metrics.canvas_ruler_label_padding.top
+ (extent
- theme.metrics.canvas_ruler_label_padding.top
- theme.metrics.canvas_ruler_label_padding.bottom)
* 0.5;
let actual_visual_center =
text.rect.y() + line.baseline + optical_visual_center(measurement);
assert_eq!(text.style.font_size, theme.text.xs.size);
assert_eq!(text.style.line_height, theme.text.xs.line_height);
assert!(
text.rect.height() >= measurement.height - 0.01,
"horizontal ruler label rect should preserve measured glyph height: rect={:?}, measurement={measurement:?}",
text.rect
);
assert!(
text.rect.height() > text.style.line_height,
"test should exercise a measurement taller than line-height: rect={:?}, style={:?}",
text.rect,
text.style
);
assert!(
(actual_visual_center - slot_center).abs() < 0.75,
"horizontal ruler tall label visual center {actual_visual_center} did not match slot center {slot_center}; text rect {:?}",
text.rect
);
}
#[test]
fn vertical_canvas_ruler_numeric_labels_center_on_tick_position() {
let theme = DefaultTheme::default();
let document_size = Size::new(1920.0, 1080.0);
let viewport = CanvasViewport::new();
let viewport_size = Size::new(260.0, 420.0);
let extent = 72.0;
let output = render(
crate::SizedBox::new().size(Size::new(extent, 420.0)).child(
CanvasRuler::vertical("Vertical ruler", document_size)
.extent(extent)
.viewport(viewport, viewport_size),
),
);
let bounds = Rect::new(0.0, 0.0, extent, 420.0);
let canvas_bounds =
super::ruler_canvas_bounds(bounds, CanvasRulerAxis::Vertical, viewport_size);
let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
let padding = theme.metrics.canvas_ruler_label_padding;
let text = numeric_text_runs(&output)
.into_iter()
.find(|run| {
let Ok(value) = run.text.parse::<f32>() else {
return false;
};
let tick_y = super::ruler_tick_screen_position(
CanvasRulerAxis::Vertical,
value,
document_size,
viewport,
canvas_bounds,
document_origin,
);
tick_y > bounds.y() + padding.top + run.style.line_height
&& tick_y < bounds.max_y() - padding.bottom - run.style.line_height
})
.expect("vertical ruler should draw an unclamped numeric label");
let value = text
.text
.parse::<f32>()
.expect("numeric ruler label should parse");
let expected_tick_y = super::ruler_tick_screen_position(
CanvasRulerAxis::Vertical,
value,
document_size,
viewport,
canvas_bounds,
document_origin,
);
let layout = TextSystem::new()
.shape_text_run(&text, &FontRegistry::new())
.expect("ruler label should shape");
let line = layout
.lines()
.first()
.expect("ruler label should contain one line");
let actual_visual_center =
text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
assert!(
text.style
.features
.iter()
.any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
);
assert!(
(actual_visual_center - expected_tick_y).abs() < 0.75,
"vertical ruler label visual center {actual_visual_center} did not match tick {expected_tick_y}; text rect {:?}",
text.rect
);
}
#[test]
fn vertical_canvas_ruler_preserves_tall_label_measurements() {
let mut theme = DefaultTheme::default();
theme.text.xs = ThemeTextToken {
size: 32.0,
line_height: 12.0,
};
theme.metrics.canvas_ruler_label_max_width = 120.0;
let document_size = Size::new(1920.0, 1080.0);
let viewport = CanvasViewport::new();
let viewport_size = Size::new(260.0, 420.0);
let extent = 96.0;
let output = render(
crate::SizedBox::new().size(Size::new(extent, 420.0)).child(
CanvasRuler::vertical("Tall vertical ruler", document_size)
.theme(theme)
.extent(extent)
.viewport(viewport, viewport_size),
),
);
let bounds = Rect::new(0.0, 0.0, extent, 420.0);
let canvas_bounds =
super::ruler_canvas_bounds(bounds, CanvasRulerAxis::Vertical, viewport_size);
let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
let padding = theme.metrics.canvas_ruler_label_padding;
let text_system = TextSystem::new();
let text = numeric_text_runs(&output)
.into_iter()
.find(|run| {
let Ok(value) = run.text.parse::<f32>() else {
return false;
};
let Ok(layout) = text_system.shape_text_run(run, &FontRegistry::new()) else {
return false;
};
let tick_y = super::ruler_tick_screen_position(
CanvasRulerAxis::Vertical,
value,
document_size,
viewport,
canvas_bounds,
document_origin,
);
let height = run.style.line_height.max(layout.measurement().height);
tick_y > bounds.y() + padding.top + height
&& tick_y < bounds.max_y() - padding.bottom - height
})
.expect("vertical ruler should draw an unclamped tall numeric label");
let value = text
.text
.parse::<f32>()
.expect("numeric ruler label should parse");
let expected_tick_y = super::ruler_tick_screen_position(
CanvasRulerAxis::Vertical,
value,
document_size,
viewport,
canvas_bounds,
document_origin,
);
let layout = text_system
.shape_text_run(&text, &FontRegistry::new())
.expect("ruler label should shape");
let measurement = layout.measurement();
let line = layout
.lines()
.first()
.expect("ruler label should contain one line");
let actual_visual_center =
text.rect.y() + line.baseline + optical_visual_center(measurement);
assert!(
text.rect.height() >= measurement.height - 0.01,
"vertical ruler label rect should preserve measured glyph height: rect={:?}, measurement={measurement:?}",
text.rect
);
assert!(
text.rect.height() > text.style.line_height,
"test should exercise a measurement taller than line-height: rect={:?}, style={:?}",
text.rect,
text.style
);
assert!(
(actual_visual_center - expected_tick_y).abs() < 0.75,
"vertical ruler tall label visual center {actual_visual_center} did not match tick {expected_tick_y}; text rect {:?}",
text.rect
);
}
#[test]
fn dotted_grid_uses_analytic_circles_at_stable_screen_size() {
struct GridProbe(CanvasViewport);
impl Widget for GridProbe {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(240.0, 160.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
super::paint_canvas_grid(
ctx,
self.0,
ctx.bounds(),
Point::ZERO,
24.0,
super::CanvasGridStyle::Dots,
Color::WHITE,
);
}
}
for zoom in [0.25, 1.0, 2.0] {
let viewport = CanvasViewport::new().zoom(zoom).pan(Vector::new(7.0, 11.0));
let output = render(GridProbe(viewport));
let bounds = Rect::from_origin_size(Point::ZERO, output.frame.viewport);
let origin = viewport
.transform(bounds, Point::ZERO)
.transform_point(Point::ZERO);
let mut dots = 0;
let mut found_origin = false;
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::FillRoundedRect {
rect, radii, brush, ..
} => {
assert_eq!(rect.size, Size::new(2.5, 2.5));
assert_eq!(*radii, [1.25; 4]);
assert_eq!(*brush, Brush::Solid(Color::WHITE));
let center = Point::new(rect.x() + 1.25, rect.y() + 1.25);
found_origin |= (center.x - origin.x).abs() < 0.001
&& (center.y - origin.y).abs() < 0.001;
dots += 1;
}
SceneCommand::FillPath { .. } | SceneCommand::StrokePath { .. } => {
panic!("grid dots must not create curve paths");
}
_ => {}
});
assert!((1..=4096).contains(&dots));
assert!(
found_origin,
"panning and zooming must preserve the grid origin"
);
}
}
#[test]
fn canvas_appearance_overrides_semantic_theme_defaults() {
let appearance = CanvasColors {
background: Some(Color::rgba(0.91, 0.83, 0.72, 1.0)),
grid: Some(Color::rgba(0.24, 0.33, 0.44, 0.40)),
axis_x: Some(Color::rgba(0.80, 0.20, 0.30, 0.70)),
axis_y: Some(Color::rgba(0.20, 0.60, 0.40, 0.70)),
};
let output = render(Canvas::new("Vector").colors(appearance));
let fills = solid_fill_colors(&output);
let strokes = solid_stroke_colors(&output);
assert!(fills.contains(&appearance.background.unwrap()));
assert!(strokes.contains(&appearance.grid.unwrap()));
assert!(strokes.contains(&appearance.axis_x.unwrap()));
assert!(strokes.contains(&appearance.axis_y.unwrap()));
}
#[test]
fn canvas_uniformly_scales_normal_widget_content_and_inverse_maps_input() {
let pointer_positions = Rc::new(RefCell::new(Vec::new()));
let canvas = Canvas::new("Widget canvas")
.child(CanvasContentProbe {
name: "canvas content probe",
pointer_positions: Rc::clone(&pointer_positions),
})
.content_bounds(Rect::new(-50.0, -30.0, 100.0, 60.0));
let (mut runtime, window_id) = build_runtime(canvas);
let first = runtime.render(window_id).expect("initial canvas render");
let canvas_bounds = first
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("canvas semantics")
.bounds;
let first_content = first
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("canvas content probe"))
.expect("content semantics");
let center = CanvasViewport::center(canvas_bounds);
assert_eq!(
first_content.bounds,
Rect::new(center.x - 50.0, center.y - 30.0, 100.0, 60.0)
);
let mut down = PointerEvent::new(PointerEventKind::Down, center);
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.expect("dispatch transformed pointer");
assert_eq!(&*pointer_positions.borrow(), &[Point::ZERO]);
let mut scroll = PointerEvent::new(PointerEventKind::Scroll, center);
scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, 100.0)));
runtime
.handle_event(window_id, Event::Pointer(scroll))
.expect("zoom canvas");
let zoomed = runtime.render(window_id).expect("zoomed canvas render");
let zoomed_content = zoomed
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("canvas content probe"))
.expect("zoomed content semantics");
let factor = (100.0_f32 * 0.002).exp();
assert!((zoomed_content.bounds.width() - (100.0 * factor)).abs() < 0.01);
assert!((zoomed_content.bounds.height() - (60.0 * factor)).abs() < 0.01);
assert!(
(zoomed_content.bounds.x() + (zoomed_content.bounds.width() * 0.5) - center.x).abs()
< 0.01
);
}
#[test]
fn canvas_touch_pinch_uniformly_scales_widget_content() {
let canvas = Canvas::new("Pinch canvas")
.child(CanvasContentProbe {
name: "pinch content",
pointer_positions: Rc::new(RefCell::new(Vec::new())),
})
.content_bounds(Rect::new(-50.0, -30.0, 100.0, 60.0));
let (mut runtime, window_id) = build_runtime(canvas);
let first = runtime.render(window_id).expect("initial canvas render");
let canvas_bounds = first
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("canvas semantics")
.bounds;
let center = CanvasViewport::center(canvas_bounds);
let first_touch = Point::new(center.x - 50.0, center.y);
let second_touch = Point::new(center.x + 50.0, center.y);
for event in [
touch_pointer(31, PointerEventKind::Down, first_touch, true),
touch_pointer(47, PointerEventKind::Down, second_touch, true),
touch_pointer(
31,
PointerEventKind::Move,
Point::new(center.x - 100.0, center.y),
true,
),
touch_pointer(
47,
PointerEventKind::Move,
Point::new(center.x + 100.0, center.y),
true,
),
] {
runtime
.handle_event(window_id, event)
.expect("dispatch pinch gesture");
}
let zoomed = runtime.render(window_id).expect("pinched canvas render");
let content = zoomed
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("pinch content"))
.expect("pinched content semantics");
assert!((content.bounds.width() - 200.0).abs() < 0.01);
assert!((content.bounds.height() - 120.0).abs() < 0.01);
assert!((content.bounds.x() + 100.0 - center.x).abs() < 0.01);
}
#[test]
fn canvas_rotation_transforms_widget_semantics_and_hit_testing() {
let pointer_positions = Rc::new(RefCell::new(Vec::new()));
let canvas = Canvas::new("Rotated canvas")
.viewport(CanvasViewport::new().rotation(std::f32::consts::FRAC_PI_2))
.child(CanvasContentProbe {
name: "rotated content",
pointer_positions: Rc::clone(&pointer_positions),
})
.content_bounds(Rect::new(-50.0, -20.0, 100.0, 40.0));
let (mut runtime, window_id) = build_runtime(canvas);
let output = runtime.render(window_id).expect("rotated canvas render");
let canvas_bounds = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("canvas semantics")
.bounds;
let content = output
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("rotated content"))
.expect("rotated semantics");
let center = CanvasViewport::center(canvas_bounds);
assert!((content.bounds.width() - 40.0).abs() < 0.01);
assert!((content.bounds.height() - 100.0).abs() < 0.01);
let mut down = PointerEvent::new(PointerEventKind::Down, center);
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.expect("dispatch rotated pointer");
assert!(pointer_positions.borrow()[0].x.abs() < 0.001);
assert!(pointer_positions.borrow()[0].y.abs() < 0.001);
}
#[test]
fn canvas_screen_space_content_keeps_visual_size_while_zooming() {
let canvas = Canvas::new("Screen-space canvas")
.child(CanvasContentProbe {
name: "canvas content probe",
pointer_positions: Rc::new(RefCell::new(Vec::new())),
})
.content_bounds(Rect::new(-50.0, -30.0, 100.0, 60.0))
.content_zoom(CanvasZoomBehavior::ScreenSpace);
let (mut runtime, window_id) = build_runtime(canvas);
let first = runtime.render(window_id).expect("initial canvas render");
let first_content = first
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("canvas content probe"))
.expect("content semantics")
.bounds;
let canvas_bounds = first
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("canvas semantics")
.bounds;
let mut scroll = PointerEvent::new(
PointerEventKind::Scroll,
CanvasViewport::center(canvas_bounds),
);
scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, 100.0)));
runtime
.handle_event(window_id, Event::Pointer(scroll))
.expect("zoom canvas");
let zoomed = runtime.render(window_id).expect("zoomed canvas render");
let zoomed_content = zoomed
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("canvas content probe"))
.expect("zoomed content semantics")
.bounds;
assert_eq!(zoomed_content.size, first_content.size);
}
#[test]
fn canvas_mixes_uniform_and_custom_widget_zoom_policies() {
let canvas = Canvas::new("Mixed widget canvas")
.widget(
Rect::new(-140.0, -30.0, 100.0, 60.0),
CanvasContentProbe {
name: "uniform item",
pointer_positions: Rc::new(RefCell::new(Vec::new())),
},
)
.widget_with_zoom(
Rect::new(40.0, -30.0, 100.0, 60.0),
CanvasZoomBehavior::custom(|context| {
let anchor = context.viewport.world_to_screen(
context.canvas_bounds,
context.content_bounds.origin,
context.document_origin,
);
Transform::translation(
anchor.x - context.content_bounds.x(),
anchor.y - context.content_bounds.y(),
)
}),
CanvasContentProbe {
name: "custom item",
pointer_positions: Rc::new(RefCell::new(Vec::new())),
},
);
let (mut runtime, window_id) = build_runtime(canvas);
let first = runtime.render(window_id).expect("initial canvas render");
let canvas_bounds = first
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("canvas semantics")
.bounds;
let mut scroll = PointerEvent::new(
PointerEventKind::Scroll,
CanvasViewport::center(canvas_bounds),
);
scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, 100.0)));
runtime
.handle_event(window_id, Event::Pointer(scroll))
.expect("zoom canvas");
let zoomed = runtime.render(window_id).expect("zoomed canvas render");
let bounds = |name: &str| {
zoomed
.semantics
.iter()
.find(|node| node.name.as_deref() == Some(name))
.expect("canvas widget semantics")
.bounds
};
assert!(bounds("uniform item").width() > 100.0);
assert_eq!(bounds("custom item").size, Size::new(100.0, 60.0));
}
#[test]
fn canvas_batches_consecutive_uniform_widget_transforms() {
let mut canvas = Canvas::new("Batched widget canvas");
for index in 0..3 {
canvas = canvas.widget(
Rect::new(index as f32 * 120.0, 20.0, 100.0, 60.0),
CanvasContentProbe {
name: "batched item",
pointer_positions: Rc::new(RefCell::new(Vec::new())),
},
);
}
let output = render(canvas);
let pushes = output
.frame
.scene
.commands()
.iter()
.filter(|command| matches!(command, SceneCommand::PushTransform { .. }))
.count();
let pops = output
.frame
.scene
.commands()
.iter()
.filter(|command| matches!(command, SceneCommand::PopTransform))
.count();
assert_eq!(pushes, 1);
assert_eq!(pops, 1);
}
#[test]
fn canvas_focus_ring_uses_theme_motion() {
let mut theme = DefaultTheme::default();
theme.palette.focus_ring = Color::rgba(0.91, 0.12, 0.55, 1.0);
let focus_duration = theme.motion.focus_duration();
let (mut runtime, window_id) = build_runtime(
crate::SizedBox::new()
.size(Size::new(160.0, 120.0))
.child(Canvas::new("Vector").theme(theme)),
);
let _ = runtime.render(window_id).expect("render should succeed");
runtime
.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(30.0, 30.0), true),
)
.expect("focus event should be handled");
runtime.tick(focus_duration * 0.5);
assert_eq!(handle_ready_events(&mut runtime), 0);
let mid_focus = runtime.render(window_id).expect("render should succeed");
assert!(
!contains_approx_color(&solid_stroke_colors(&mid_focus), theme.palette.focus_ring),
"canvas focus ring should not snap to the settled focus color"
);
runtime.tick(focus_duration + 0.01);
assert_eq!(handle_ready_events(&mut runtime), 0);
let settled_focus = runtime.render(window_id).expect("render should succeed");
let settled_strokes = solid_stroke_colors(&settled_focus);
assert!(
contains_approx_color(&settled_strokes, theme.palette.focus_ring),
"canvas focus ring should settle to the theme focus color; strokes={settled_strokes:?}"
);
}
#[test]
fn pixel_canvas_focus_ring_uses_theme_motion() {
let theme = DefaultTheme::default();
let focus_duration = theme.motion.focus_duration();
let (mut runtime, window_id) = build_runtime(
crate::SizedBox::new()
.size(Size::new(160.0, 120.0))
.child(PixelCanvas::new("Paint", 8, 8).theme(theme)),
);
let _ = runtime.render(window_id).expect("render should succeed");
runtime
.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(30.0, 30.0), true),
)
.expect("focus event should be handled");
runtime.tick(focus_duration * 0.5);
assert_eq!(handle_ready_events(&mut runtime), 0);
let mid_focus = runtime.render(window_id).expect("render should succeed");
assert!(
!contains_approx_color(&solid_stroke_colors(&mid_focus), theme.palette.focus_ring),
"pixel canvas focus ring should not snap to the settled focus color"
);
runtime.tick(focus_duration + 0.01);
assert_eq!(handle_ready_events(&mut runtime), 0);
let settled_focus = runtime.render(window_id).expect("render should succeed");
let settled_strokes = solid_stroke_colors(&settled_focus);
assert!(
contains_approx_color(&settled_strokes, theme.palette.focus_ring),
"pixel canvas focus ring should settle to the theme focus color; strokes={settled_strokes:?}"
);
}
#[test]
fn canvas_renders_shapes_inside_a_transform() {
let output = render(
Canvas::new("Vector")
.viewport(CanvasViewport::new().zoom(1.5).rotation(0.2))
.shape(CanvasShape::rect(
Rect::new(-20.0, -20.0, 40.0, 40.0),
Some(Color::rgba(0.2, 0.4, 0.8, 1.0)),
Some(CanvasStroke::new(Color::rgba(0.0, 0.0, 0.0, 1.0), 1.0)),
)),
);
let has_canvas = output.semantics.iter().any(|node| {
node.role == SemanticsRole::Canvas && node.name.as_deref() == Some("Vector")
});
assert!(has_canvas);
let mut path_count = 0;
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::FillPath { .. } | SceneCommand::StrokePath { .. } => path_count += 1,
_ => {}
});
assert!(path_count >= 1);
}
#[test]
fn canvas_primary_drag_adds_vector_stroke() -> sui_core::Result<()> {
let (mut runtime, window_id) = build_runtime(Canvas::new("Vector"));
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Move, Point::new(280.0, 190.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(280.0, 190.0), false),
)?;
let output = runtime.render(window_id)?;
let mut stroke_count = 0;
output.frame.scene.visit_commands(&mut |command| {
if matches!(command, SceneCommand::StrokePath { .. }) {
stroke_count += 1;
}
});
assert!(stroke_count >= 3);
Ok(())
}
#[test]
fn pixel_canvas_primary_drag_paints_pixel() -> sui_core::Result<()> {
let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8));
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
let output = runtime.render(window_id)?;
let mut image_handle = None;
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } = command
{
image_handle = Some(source.image);
}
});
let image = output
.frame
.image_registry
.get(image_handle.expect("pixel canvas should draw an image"))
.expect("pixel canvas image should be registered");
let accent = PixelColor::from_color(DefaultTheme::default().palette.accent);
let painted = image
.bytes()
.as_chunks::<4>()
.0
.iter()
.any(|pixel| pixel_matches_color(pixel, accent));
assert!(painted);
Ok(())
}
#[test]
fn pixel_canvas_fast_brush_drag_interpolates_sparse_pointer_samples() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
state.set_brush_size(1.0);
let (mut runtime, window_id) =
build_runtime(PixelCanvas::new("Paint", 8, 8).state(state.clone()));
let output = runtime.render(window_id)?;
let canvas = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("pixel canvas semantics present");
let document_origin = Point::new(4.0, 4.0);
let start =
state
.viewport()
.world_to_screen(canvas.bounds, Point::new(1.5, 4.5), document_origin);
let middle =
state
.viewport()
.world_to_screen(canvas.bounds, Point::new(4.5, 4.5), document_origin);
let end =
state
.viewport()
.world_to_screen(canvas.bounds, Point::new(6.5, 4.5), document_origin);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, start, true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Move, middle, true),
)?;
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, end, false))?;
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
for x in 1..=6 {
let index = ((4 * 8) + x) * 4;
assert_rgba_channels_near(&pixels[index..index + 4], [255, 0, 0, 255]);
}
Ok(())
}
#[test]
fn pixel_canvas_state_defaults_to_round_brush() {
let state = PixelCanvasState::new();
assert_eq!(state.brush_shape(), PixelCanvasBrushShape::Round);
assert_eq!(
PixelCanvasBrushShape::default(),
PixelCanvasBrushShape::Round
);
}
#[test]
fn pixel_canvas_square_brush_paints_full_stamp() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
state.set_brush_size(3.0);
state.set_brush_shape(PixelCanvasBrushShape::Square);
let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8).state(state));
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
let output = runtime.render(window_id)?;
let mut image_handle = None;
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } = command
{
image_handle = Some(source.image);
}
});
let image = output
.frame
.image_registry
.get(image_handle.expect("pixel canvas should draw an image"))
.expect("pixel canvas image should be registered");
let painted = image
.bytes()
.as_chunks::<4>()
.0
.iter()
.filter(|pixel| rgba_channels_match(*pixel, [255, 0, 0, 255]))
.count();
assert_eq!(painted, 9);
Ok(())
}
#[test]
fn pixel_canvas_blend_mode_composes_brush_with_existing_pixels() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_blend_mode(PixelCanvasBlendMode::Screen);
state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
state.set_brush_size(1.0);
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 1, 1)
.state(state)
.with_pixels(vec![Color::rgba(0.0, 0.0, 1.0, 1.0)]),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_channels_near(&pixels[0..4], [255, 0, 255, 255]);
Ok(())
}
#[test]
fn pixel_canvas_round_brush_uses_circular_stamp() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
state.set_brush_size(3.0);
let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8).state(state));
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
let painted = pixels
.as_chunks::<4>()
.0
.iter()
.filter(|pixel| rgba_channels_match(*pixel, [255, 0, 0, 255]))
.count();
assert_eq!(painted, 5);
Ok(())
}
#[test]
fn pixel_canvas_eraser_tool_clears_painted_pixels() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_tool(PixelCanvasTool::Eraser);
let pixels = vec![Color::rgba(0.0, 0.2, 1.0, 1.0); 64];
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 8, 8)
.state(state)
.with_pixels(pixels),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
let output = runtime.render(window_id)?;
let mut image_handle = None;
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } = command
{
image_handle = Some(source.image);
}
});
let image = output
.frame
.image_registry
.get(image_handle.expect("pixel canvas should draw an image"))
.expect("pixel canvas image should be registered");
let transparent = image
.bytes()
.as_chunks::<4>()
.0
.iter()
.filter(|pixel| alpha_matches(*pixel, 0))
.count();
assert_eq!(transparent, 1);
Ok(())
}
#[test]
fn pixel_canvas_fill_tool_flood_fills_matching_pixels() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_tool(PixelCanvasTool::Fill);
state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8).state(state));
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
let output = runtime.render(window_id)?;
let mut image_handle = None;
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } = command
{
image_handle = Some(source.image);
}
});
let image = output
.frame
.image_registry
.get(image_handle.expect("pixel canvas should draw an image"))
.expect("pixel canvas image should be registered");
let red = image
.bytes()
.as_chunks::<4>()
.0
.iter()
.filter(|pixel| rgba_channels_match(*pixel, [255, 0, 0, 255]))
.count();
assert_eq!(red, 64);
Ok(())
}
#[test]
fn pixel_canvas_keyboard_undo_redo_restores_pixel_edits() -> sui_core::Result<()> {
let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8));
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
let accent = PixelColor::from_color(DefaultTheme::default().palette.accent);
let painted = rendered_pixel_bytes(&runtime.render(window_id)?)
.as_chunks::<4>()
.0
.iter()
.any(|pixel| pixel_matches_color(pixel, accent));
assert!(painted);
runtime.handle_event(window_id, command_key("z"))?;
let painted_after_undo = rendered_pixel_bytes(&runtime.render(window_id)?)
.as_chunks::<4>()
.0
.iter()
.any(|pixel| !alpha_matches(pixel, 0));
assert!(!painted_after_undo);
runtime.handle_event(window_id, command_key("y"))?;
let painted_after_redo = rendered_pixel_bytes(&runtime.render(window_id)?)
.as_chunks::<4>()
.0
.iter()
.any(|pixel| pixel_matches_color(pixel, accent));
assert!(painted_after_redo);
Ok(())
}
#[test]
fn pixel_canvas_state_undo_request_is_consumed_during_measure() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
let (mut runtime, window_id) =
build_runtime(PixelCanvas::new("Paint", 8, 8).state(state.clone()));
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
assert!(state.can_undo());
state.request_undo();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let painted_after_undo = rendered_pixel_bytes(&runtime.render(window_id)?)
.as_chunks::<4>()
.0
.iter()
.any(|pixel| !alpha_matches(pixel, 0));
assert!(!painted_after_undo);
assert!(state.can_redo());
Ok(())
}
#[test]
fn pixel_canvas_state_clear_request_clears_pixels_and_supports_undo() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
let pixels = vec![Color::rgba(0.2, 0.4, 0.8, 1.0); 4];
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 2, 2)
.state(state.clone())
.with_pixels(pixels),
);
let _ = runtime.render(window_id)?;
state.request_clear();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let cleared = rendered_pixel_bytes(&runtime.render(window_id)?);
assert!(
cleared
.as_chunks::<4>()
.0
.iter()
.all(|pixel| alpha_matches(pixel, 0))
);
assert!(state.can_undo());
state.request_undo();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(522.0, 362.0))),
)?;
let restored = rendered_pixel_bytes(&runtime.render(window_id)?);
assert!(
restored
.as_chunks::<4>()
.0
.iter()
.all(|pixel| alpha_matches(pixel, 255))
);
assert!(state.can_redo());
Ok(())
}
#[test]
fn pixel_canvas_read_only_blocks_edit_commands_and_reports_state() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_editable(false);
state.set_tool(PixelCanvasTool::Fill);
state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
let pixels = vec![Color::rgba(0.2, 0.4, 0.8, 1.0); 4];
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 2, 2)
.state(state.clone())
.with_pixels(pixels),
);
let output = runtime.render(window_id)?;
let canvas = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("pixel canvas semantics present");
let value = match canvas.value.as_ref() {
Some(SemanticsValue::Text(value)) => value,
_ => panic!("pixel canvas should expose text value"),
};
assert!(value.contains("read only"));
assert!(
canvas
.actions
.contains(&SemanticsAction::Custom("Pan".into()))
);
assert!(
!canvas
.actions
.contains(&SemanticsAction::Custom("Paint".into()))
);
assert!(!state.can_clear());
let before = rendered_pixel_bytes(&output);
state.request_clear();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
)?;
let after = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_buffers_near(&after, &before);
assert!(!state.can_undo());
Ok(())
}
#[test]
fn pixel_canvas_display_visibility_affects_render_and_export() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_display_visible(false);
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 1, 1)
.state(state.clone())
.with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
);
let paper = PixelColor::from_color(DefaultTheme::default().surfaces.pixel_canvas_paper);
let expected = [paper.red, paper.green, paper.blue, paper.alpha];
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_channels_near(&pixels[0..4], expected);
state.request_export_snapshot();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let snapshot = state
.latest_export_snapshot()
.expect("hidden layer export should publish a snapshot");
assert_rgba_channels_near(&snapshot.rgba8()[0..4], expected);
Ok(())
}
#[test]
fn pixel_canvas_appearance_controls_paper_for_render_and_export() -> sui_core::Result<()> {
let paper_color = Color::rgba(0.80, 0.62, 0.36, 1.0);
let appearance = PixelCanvasColors {
paper: Some(paper_color),
..PixelCanvasColors::default()
};
let state = PixelCanvasState::new();
state.set_display_visible(false);
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 1, 1)
.colors(appearance)
.state(state.clone())
.with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
);
let paper = PixelColor::from_color(paper_color);
let expected = [paper.red, paper.green, paper.blue, paper.alpha];
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_channels_near(&pixels[0..4], expected);
state.request_export_snapshot();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let snapshot = state
.latest_export_snapshot()
.expect("hidden layer export should publish a snapshot");
assert_rgba_channels_near(&snapshot.rgba8()[0..4], expected);
Ok(())
}
#[test]
fn pixel_canvas_explicit_paper_color_overrides_theme_for_render_and_export()
-> sui_core::Result<()> {
let appearance = PixelCanvasColors {
paper: Some(Color::rgba(0.80, 0.62, 0.36, 1.0)),
..PixelCanvasColors::default()
};
let paper_color = Color::WHITE;
let state = PixelCanvasState::new();
state.set_display_visible(false);
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 1, 1)
.colors(appearance)
.paper_color(paper_color)
.state(state.clone())
.with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
);
let paper = PixelColor::from_color(paper_color);
let expected = [paper.red, paper.green, paper.blue, paper.alpha];
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_channels_near(&pixels[0..4], expected);
state.request_export_snapshot();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let snapshot = state
.latest_export_snapshot()
.expect("explicit paper export should publish a snapshot");
assert_rgba_channels_near(&snapshot.rgba8()[0..4], expected);
Ok(())
}
#[test]
fn pixel_canvas_display_opacity_and_blend_affect_rendered_image() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_display_opacity(0.5);
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 1, 1)
.state(state.clone())
.with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
);
let paper = PixelColor::from_color(DefaultTheme::default().surfaces.pixel_canvas_paper);
let half = paper.compose(
Color::rgba(1.0, 0.0, 0.0, 1.0),
0.5,
PixelCanvasBlendMode::Normal,
);
let output = runtime.render(window_id)?;
let source = rendered_pixel_image_source(&output);
assert_eq!(source.tint, Some(Color::WHITE.with_alpha(0.5)));
let pixels = rendered_pixel_bytes(&output);
assert_rgba_channels_near(&pixels[0..4], [255, 0, 0, 255]);
state.request_export_snapshot();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let snapshot = state
.latest_export_snapshot()
.expect("display opacity export should publish composited pixels");
assert_rgba_channels_near(
&snapshot.rgba8()[0..4],
[half.red, half.green, half.blue, half.alpha],
);
state.set_display_opacity(1.0);
state.set_display_blend_mode(PixelCanvasBlendMode::Multiply);
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let multiply = paper.compose(
Color::rgba(1.0, 0.0, 0.0, 1.0),
1.0,
PixelCanvasBlendMode::Multiply,
);
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_channels_near(
&pixels[0..4],
[multiply.red, multiply.green, multiply.blue, multiply.alpha],
);
Ok(())
}
#[test]
fn pixel_canvas_layer_opacity_reuses_registered_data_between_repaints() -> sui_core::Result<()>
{
let state = PixelCanvasState::new();
state.set_display_opacity(0.5);
let (mut runtime, window_id) = build_runtime(
PixelCanvas::new("Paint", 1, 1)
.state(state)
.with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
);
let first = runtime.render(window_id)?;
let second = runtime.render(window_id)?;
assert!(std::ptr::addr_eq(
rendered_pixel_image(&first).bytes().as_ptr(),
rendered_pixel_image(&second).bytes().as_ptr()
));
Ok(())
}
#[test]
fn pixel_canvas_paper_visibility_affects_render_and_export() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_paper_visible(false);
let (mut runtime, window_id) =
build_runtime(PixelCanvas::new("Paint", 1, 1).state(state.clone()));
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_channels_near(&pixels[0..4], [0, 0, 0, 0]);
state.request_export_snapshot();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let snapshot = state
.latest_export_snapshot()
.expect("hidden paper export should publish a snapshot");
assert_rgba_channels_near(&snapshot.rgba8()[0..4], [0, 0, 0, 0]);
Ok(())
}
#[test]
fn pixel_canvas_paper_opacity_affects_composited_background() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
state.set_paper_opacity(0.5);
let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 1, 1).state(state));
let paper = PixelColor::from_color(
DefaultTheme::default()
.surfaces
.pixel_canvas_paper
.with_alpha(0.5),
);
let expected = [paper.red, paper.green, paper.blue, paper.alpha];
let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
assert_rgba_channels_near(&pixels[0..4], expected);
Ok(())
}
#[test]
fn pixel_canvas_state_export_request_publishes_rgba_snapshot() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
let (mut runtime, window_id) = build_runtime(
PixelCanvas::from_fn("Export", 2, 2, |x, y| {
if x == 0 && y == 0 {
Color::rgba(1.0, 0.0, 0.0, 1.0)
} else {
Color::rgba(0.0, 0.0, 0.0, 0.0)
}
})
.state(state.clone()),
);
let _ = runtime.render(window_id)?;
assert!(state.latest_export_snapshot().is_none());
state.request_export_snapshot();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
)?;
let _ = runtime.render(window_id)?;
let snapshot = state
.latest_export_snapshot()
.expect("export request should publish a snapshot");
assert_eq!(snapshot.name(), "Export");
assert_eq!(snapshot.width(), 2);
assert_eq!(snapshot.height(), 2);
assert_eq!(snapshot.byte_len(), 16);
assert_rgba_channels_near(&snapshot.rgba8()[0..4], [255, 0, 0, 255]);
assert_eq!(snapshot.revision(), 1);
Ok(())
}
#[test]
fn pixel_canvas_state_tracks_cursor_document_position() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
let (mut runtime, window_id) =
build_runtime(PixelCanvas::new("Paint", 8, 8).state(state.clone()));
let output = runtime.render(window_id)?;
let canvas = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Canvas)
.expect("canvas semantics should exist");
let center = Point::new(
canvas.bounds.x() + canvas.bounds.width() * 0.5,
canvas.bounds.y() + canvas.bounds.height() * 0.5,
);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Move, center, false),
)?;
assert_eq!(state.cursor_position(), Some(Point::new(4.0, 4.0)));
runtime.handle_event(
window_id,
primary_pointer(
PointerEventKind::Move,
Point::new(canvas.bounds.max_x() + 12.0, canvas.bounds.max_y() + 12.0),
false,
),
)?;
assert_eq!(state.cursor_position(), None);
Ok(())
}
#[test]
fn pixel_canvas_state_view_requests_update_zoom_during_arrange() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
let canvas = PixelCanvas::new("Paint", 8, 8)
.viewport(
CanvasViewport::new()
.pan(Vector::new(40.0, 16.0))
.zoom(0.25),
)
.state(state.clone());
let (mut runtime, window_id) = build_runtime(canvas);
let _ = runtime.render(window_id)?;
state.request_actual_size_view();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(320.0, 240.0))),
)?;
let actual_size = runtime.render(window_id)?;
assert_eq!(pixel_canvas_zoom_percent(&actual_size), 100.0);
state.request_fit_view();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(400.0, 300.0))),
)?;
let fit = runtime.render(window_id)?;
assert!(pixel_canvas_zoom_percent(&fit) > 1000.0);
Ok(())
}
#[test]
fn pixel_canvas_state_zoom_requests_update_view_during_arrange() -> sui_core::Result<()> {
let state = PixelCanvasState::new();
let canvas = PixelCanvas::new("Paint", 8, 8)
.viewport(CanvasViewport::new().zoom(1.0))
.state(state.clone());
let (mut runtime, window_id) = build_runtime(canvas);
let _ = runtime.render(window_id)?;
state.request_zoom_in();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(320.0, 240.0))),
)?;
let zoomed_in = runtime.render(window_id)?;
assert_eq!(pixel_canvas_zoom_percent(&zoomed_in), 110.0);
state.request_zoom_out();
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(320.0, 240.0))),
)?;
let zoomed_out = runtime.render(window_id)?;
assert_eq!(pixel_canvas_zoom_percent(&zoomed_out), 100.0);
Ok(())
}
#[test]
fn pixel_canvas_can_fit_initial_view_on_first_layout() {
let state = PixelCanvasState::new();
let output = render(
PixelCanvas::new("Paint", 1920, 1080)
.state(state.clone())
.fit_on_first_layout(true),
);
assert_eq!(pixel_canvas_zoom_percent(&output), 25.0);
assert_eq!(state.viewport_size(), Size::new(520.0, 360.0));
let padding = DefaultTheme::default().metrics.pixel_canvas_fit_padding;
let expected_zoom = ((state.viewport_size().width - padding * 2.0) / 1920.0)
.min((state.viewport_size().height - padding * 2.0) / 1080.0);
assert!((state.viewport().zoom - expected_zoom).abs() < 0.001);
}
#[test]
fn pixel_canvas_draws_one_image_instead_of_per_pixel_rects() {
let output = render(
PixelCanvas::from_fn("Large paint", 1920, 1080, |x, y| {
Color::rgba(x as f32 / 1919.0, y as f32 / 1079.0, 0.5, 1.0)
})
.viewport(CanvasViewport::new().zoom(0.28)),
);
let mut image_handle = None;
let mut image_command_count = 0;
let mut fill_command_count = 0;
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } => {
image_handle = Some(source.image);
image_command_count += 1;
}
SceneCommand::FillPath { .. } | SceneCommand::FillRect { .. } => {
fill_command_count += 1;
}
_ => {}
});
assert_eq!(image_command_count, 1);
assert!(
fill_command_count <= 5,
"pixel canvas should only issue bounded workbench, shadow, and paper fills"
);
let mut sampling = None;
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } = command
{
sampling = Some(source.sampling);
}
});
assert_eq!(sampling, Some(ImageSampling::Linear));
let image = output
.frame
.image_registry
.get(image_handle.expect("pixel canvas should draw an image"))
.expect("pixel canvas image should be registered");
assert_eq!(image.width(), 1920);
assert_eq!(image.height(), 1080);
assert!(
!image.mipmaps_enabled(),
"mutable pixel canvases should not rebuild mipmaps for every brush update"
);
}
#[test]
fn pixel_canvas_uses_nearest_sampling_at_pixel_zoom() {
let output = render(PixelCanvas::new("Paint", 8, 8));
let mut sampling = None;
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::DrawImage { source, .. }
| SceneCommand::DrawImageQuad { source, .. } = command
{
sampling = Some(source.sampling);
}
});
assert_eq!(sampling, Some(ImageSampling::Nearest));
}
#[test]
fn shift_wheel_rotates_pixel_canvas() -> sui_core::Result<()> {
let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8));
let _ = runtime.render(window_id)?;
let mut scroll = PointerEvent::new(PointerEventKind::Scroll, Point::new(260.0, 180.0));
scroll.modifiers = Modifiers {
shift: true,
..Modifiers::NONE
};
scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, 24.0)));
runtime.handle_event(window_id, Event::Pointer(scroll))?;
let output = runtime.render(window_id)?;
let canvas = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Canvas && node.name.as_deref() == Some("Paint")
})
.expect("pixel canvas semantics present");
assert!(
canvas
.value
.as_ref()
.is_some_and(|value| format!("{value:?}").contains("rotation"))
);
Ok(())
}
#[test]
fn pixel_canvas_builder_accepts_resolution_pixels() {
let pixels = vec![Color::rgba(1.0, 0.0, 0.0, 1.0); 4];
let canvas = PixelCanvas::new("Paint", 2, 2)
.with_pixels(pixels)
.desired_size(Size::new(64.0, 64.0));
assert_eq!(canvas.width(), 2);
assert_eq!(canvas.height(), 2);
assert_eq!(canvas.pixel_at(1, 1), Some(Color::rgba(1.0, 0.0, 0.0, 1.0)));
}
}