Skip to main content

sui_widgets/
canvas.rs

1use std::{cell::RefCell, rc::Rc};
2
3use sui_core::{
4    Color, Event, KeyState, Path, PathBuilder, PathElement, Point, PointerButton, PointerEventKind,
5    Rect, ScrollDelta, SemanticsAction, SemanticsNode, SemanticsRole, SemanticsValue, Size,
6    Transform, Vector, WakeEvent,
7};
8use sui_layout::Constraints;
9use sui_runtime::{ArrangeCtx, EventCtx, MeasureCtx, PaintCtx, SemanticsCtx, Widget};
10use sui_scene::{ImageSampling, ImageSource, RegisteredImage, StrokeStyle};
11use sui_text::{FontFeature, TextMeasurement, TextStyle};
12
13use crate::{DefaultTheme, animation::MotionScalar, text_align::paint_aligned_text};
14
15const AXIS_ALIGNED_EPSILON: f32 = 0.0001;
16const PIXEL_CANVAS_HISTORY_LIMIT: usize = 32;
17const CANVAS_RULER_MAX_TICKS: usize = 400;
18
19type AnimatedScalar = MotionScalar;
20
21fn set_focus_animation_target(
22    animation: &mut AnimatedScalar,
23    target: f32,
24    theme: &DefaultTheme,
25    ctx: &mut EventCtx,
26) {
27    animation.set_target_event(
28        target,
29        theme.motion.focus_duration(),
30        theme.motion.focus_easing(),
31        ctx,
32    );
33}
34
35fn draw_focus_ring(ctx: &mut PaintCtx, bounds: Rect, theme: &DefaultTheme, progress: f32) {
36    if progress <= AnimatedScalar::EPSILON || bounds.is_empty() {
37        return;
38    }
39
40    let metrics = theme.metrics;
41    let outset = physical_pixels(ctx, metrics.focus_ring_outset);
42    ctx.stroke(
43        Path::rounded_rect(
44            bounds.inflate(outset, outset),
45            metrics.corner_radius + outset,
46        ),
47        theme
48            .palette
49            .focus_ring
50            .with_alpha(theme.palette.focus_ring.alpha * progress),
51        StrokeStyle::new(physical_pixels(ctx, metrics.focus_ring_width)),
52    );
53}
54
55fn physical_pixels(ctx: &PaintCtx, value: f32) -> f32 {
56    if value <= 0.0 {
57        return 0.0;
58    }
59
60    ctx.dpi().physical_pixels_to_logical(value)
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq)]
64pub enum CanvasRulerAxis {
65    Horizontal,
66    Vertical,
67}
68
69#[derive(Debug, Clone, Copy, PartialEq)]
70pub struct CanvasViewport {
71    pub pan: Vector,
72    pub zoom: f32,
73    pub rotation: f32,
74}
75
76impl Default for CanvasViewport {
77    fn default() -> Self {
78        Self {
79            pan: Vector::ZERO,
80            zoom: 1.0,
81            rotation: 0.0,
82        }
83    }
84}
85
86impl CanvasViewport {
87    pub fn new() -> Self {
88        Self::default()
89    }
90
91    pub fn pan(mut self, pan: Vector) -> Self {
92        self.pan = pan;
93        self
94    }
95
96    pub fn zoom(mut self, zoom: f32) -> Self {
97        self.zoom = zoom.max(0.01);
98        self
99    }
100
101    pub fn rotation(mut self, rotation: f32) -> Self {
102        self.rotation = rotation;
103        self
104    }
105
106    fn center(bounds: Rect) -> Point {
107        Point::new(
108            bounds.x() + (bounds.width() * 0.5),
109            bounds.y() + (bounds.height() * 0.5),
110        )
111    }
112
113    fn transform(self, bounds: Rect, document_origin: Point) -> Transform {
114        let center = Self::center(bounds) + self.pan;
115        Transform::translation(-document_origin.x, -document_origin.y)
116            .then(Transform::scale(self.zoom, self.zoom))
117            .then(Transform::rotation(self.rotation))
118            .then(Transform::translation(center.x, center.y))
119    }
120
121    fn screen_to_world(self, bounds: Rect, point: Point, document_origin: Point) -> Point {
122        let center = Self::center(bounds) + self.pan;
123        let relative = point - center;
124        let (sin, cos) = (-self.rotation).sin_cos();
125        let rotated = Vector::new(
126            (relative.x * cos) + (relative.y * -sin),
127            (relative.x * sin) + (relative.y * cos),
128        );
129        Point::new(
130            document_origin.x + (rotated.x / self.zoom),
131            document_origin.y + (rotated.y / self.zoom),
132        )
133    }
134
135    fn world_to_screen(self, bounds: Rect, point: Point, document_origin: Point) -> Point {
136        self.transform(bounds, document_origin)
137            .transform_point(point)
138    }
139
140    fn zoom_around(&mut self, bounds: Rect, anchor: Point, factor: f32, document_origin: Point) {
141        let before = self.screen_to_world(bounds, anchor, document_origin);
142        self.zoom = (self.zoom * factor.max(0.01)).max(0.01);
143        let after = self.world_to_screen(bounds, before, document_origin);
144        self.pan += anchor - after;
145    }
146
147    fn rotate_around(&mut self, bounds: Rect, anchor: Point, radians: f32, document_origin: Point) {
148        let before = self.screen_to_world(bounds, anchor, document_origin);
149        self.rotation += radians;
150        let after = self.world_to_screen(bounds, before, document_origin);
151        self.pan += anchor - after;
152    }
153}
154
155pub struct CanvasRuler {
156    theme: DefaultTheme,
157    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
158    axis: CanvasRulerAxis,
159    name: String,
160    document_size: Size,
161    viewport: CanvasViewport,
162    viewport_size: Size,
163    viewport_reader: Option<Box<dyn Fn() -> (CanvasViewport, Size)>>,
164    extent: Option<f32>,
165}
166
167impl CanvasRuler {
168    pub fn new(axis: CanvasRulerAxis, name: impl Into<String>, document_size: Size) -> Self {
169        Self {
170            theme: DefaultTheme::default(),
171            theme_reader: None,
172            axis,
173            name: name.into(),
174            document_size: Size::new(document_size.width.max(1.0), document_size.height.max(1.0)),
175            viewport: CanvasViewport::default(),
176            viewport_size: Size::ZERO,
177            viewport_reader: None,
178            extent: None,
179        }
180    }
181
182    pub fn horizontal(name: impl Into<String>, document_size: Size) -> Self {
183        Self::new(CanvasRulerAxis::Horizontal, name, document_size)
184    }
185
186    pub fn vertical(name: impl Into<String>, document_size: Size) -> Self {
187        Self::new(CanvasRulerAxis::Vertical, name, document_size)
188    }
189
190    pub fn theme(mut self, theme: DefaultTheme) -> Self {
191        self.theme = theme;
192        self.theme_reader = None;
193        self
194    }
195
196    pub fn theme_when<F>(mut self, theme: F) -> Self
197    where
198        F: Fn() -> DefaultTheme + 'static,
199    {
200        self.theme_reader = Some(Box::new(theme));
201        self
202    }
203
204    pub fn viewport(mut self, viewport: CanvasViewport, viewport_size: Size) -> Self {
205        self.viewport = viewport;
206        self.viewport_size = viewport_size;
207        self.viewport_reader = None;
208        self
209    }
210
211    pub fn viewport_when<F>(mut self, reader: F) -> Self
212    where
213        F: Fn() -> (CanvasViewport, Size) + 'static,
214    {
215        self.viewport_reader = Some(Box::new(reader));
216        self
217    }
218
219    pub fn extent(mut self, extent: f32) -> Self {
220        self.extent = Some(extent.max(0.0));
221        self
222    }
223
224    fn viewport_snapshot(&self) -> (CanvasViewport, Size) {
225        self.viewport_reader
226            .as_ref()
227            .map(|reader| reader())
228            .unwrap_or((self.viewport, self.viewport_size))
229    }
230
231    fn document_axis_length(&self) -> f32 {
232        match self.axis {
233            CanvasRulerAxis::Horizontal => self.document_size.width,
234            CanvasRulerAxis::Vertical => self.document_size.height,
235        }
236    }
237
238    fn axis_label(&self) -> &'static str {
239        match self.axis {
240            CanvasRulerAxis::Horizontal => "horizontal",
241            CanvasRulerAxis::Vertical => "vertical",
242        }
243    }
244
245    fn resolved_theme(&self) -> DefaultTheme {
246        self.theme_reader
247            .as_ref()
248            .map(|theme| theme())
249            .unwrap_or(self.theme)
250    }
251
252    fn resolved_extent(&self, theme: &DefaultTheme) -> f32 {
253        self.extent
254            .unwrap_or(theme.metrics.canvas_ruler_extent)
255            .max(0.0)
256    }
257}
258
259impl Widget for CanvasRuler {
260    fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
261        let theme = self.resolved_theme();
262        let extent = self.resolved_extent(&theme);
263        let natural = match self.axis {
264            CanvasRulerAxis::Horizontal => Size::new(
265                if constraints.max.width.is_finite() {
266                    constraints.max.width
267                } else {
268                    320.0
269                },
270                extent,
271            ),
272            CanvasRulerAxis::Vertical => Size::new(
273                extent,
274                if constraints.max.height.is_finite() {
275                    constraints.max.height
276                } else {
277                    240.0
278                },
279            ),
280        };
281
282        constraints.clamp(natural)
283    }
284
285    fn paint(&self, ctx: &mut PaintCtx) {
286        let theme = self.resolved_theme();
287        let bounds = ctx.bounds();
288        let (viewport, viewport_size) = self.viewport_snapshot();
289        let text_style = TextStyle {
290            font_size: theme.text.xs.size,
291            line_height: theme.text.xs.line_height,
292            color: theme.surfaces.canvas_ruler_text,
293            ..theme.body_text_style()
294        };
295
296        ctx.fill_rect(bounds, theme.surfaces.canvas_ruler);
297        paint_canvas_ruler_divider(ctx, bounds, self.axis, theme.surfaces.canvas_ruler_border);
298        ctx.push_clip_rect(bounds);
299        paint_canvas_ruler_ticks(
300            ctx,
301            bounds,
302            self.axis,
303            self.document_size,
304            viewport,
305            viewport_size,
306            &theme,
307            text_style,
308        );
309        ctx.pop_clip();
310    }
311
312    fn semantics(&self, ctx: &mut SemanticsCtx) {
313        let mut node = SemanticsNode::new(
314            ctx.widget_id(),
315            SemanticsRole::GenericContainer,
316            ctx.bounds(),
317        );
318        node.name = Some(self.name.clone());
319        node.value = Some(SemanticsValue::Text(format!(
320            "{} ruler, {:.0} px document axis",
321            self.axis_label(),
322            self.document_axis_length()
323        )));
324        ctx.push(node);
325    }
326}
327
328#[derive(Debug, Clone, Copy, PartialEq)]
329pub struct CanvasStroke {
330    pub color: Color,
331    pub width: f32,
332}
333
334impl CanvasStroke {
335    pub const fn new(color: Color, width: f32) -> Self {
336        Self { color, width }
337    }
338}
339
340#[derive(Debug, Clone, PartialEq)]
341pub enum CanvasShape {
342    Path {
343        path: Path,
344        fill: Option<Color>,
345        stroke: Option<CanvasStroke>,
346    },
347}
348
349impl CanvasShape {
350    pub fn path(path: Path) -> Self {
351        let accent = DefaultTheme::default().palette.accent;
352        Self::Path {
353            path,
354            fill: None,
355            stroke: Some(CanvasStroke::new(accent, 2.0)),
356        }
357    }
358
359    pub fn rect(rect: Rect, fill: Option<Color>, stroke: Option<CanvasStroke>) -> Self {
360        Self::Path {
361            path: Path::rect(rect),
362            fill,
363            stroke,
364        }
365    }
366
367    pub fn circle(
368        center: Point,
369        radius: f32,
370        fill: Option<Color>,
371        stroke: Option<CanvasStroke>,
372    ) -> Self {
373        Self::Path {
374            path: Path::circle(center, radius),
375            fill,
376            stroke,
377        }
378    }
379
380    pub fn polyline(points: &[Point], stroke: CanvasStroke) -> Option<Self> {
381        path_from_points(points).map(|path| Self::Path {
382            path,
383            fill: None,
384            stroke: Some(stroke),
385        })
386    }
387}
388
389#[derive(Debug, Clone, Copy, PartialEq)]
390enum CanvasDrag {
391    Pan {
392        pointer_id: u64,
393        last_position: Point,
394    },
395    Draw {
396        pointer_id: u64,
397    },
398}
399
400pub struct Canvas {
401    theme: DefaultTheme,
402    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
403    name: String,
404    viewport: CanvasViewport,
405    shapes: Vec<CanvasShape>,
406    active_stroke: Option<Vec<Point>>,
407    drag: Option<CanvasDrag>,
408    draw_stroke: CanvasStroke,
409    focus_animation: AnimatedScalar,
410    desired_size: Size,
411}
412
413impl Canvas {
414    pub fn new(name: impl Into<String>) -> Self {
415        let theme = DefaultTheme::default();
416        Self {
417            theme,
418            theme_reader: None,
419            name: name.into(),
420            viewport: CanvasViewport::default(),
421            shapes: Vec::new(),
422            active_stroke: None,
423            drag: None,
424            draw_stroke: CanvasStroke::new(theme.palette.accent, 2.5),
425            focus_animation: AnimatedScalar::new(0.0),
426            desired_size: Size::new(520.0, 360.0),
427        }
428    }
429
430    pub fn theme(mut self, theme: DefaultTheme) -> Self {
431        self.theme = theme;
432        self.theme_reader = None;
433        self
434    }
435
436    pub fn theme_when<F>(mut self, theme: F) -> Self
437    where
438        F: Fn() -> DefaultTheme + 'static,
439    {
440        self.theme_reader = Some(Box::new(theme));
441        self
442    }
443
444    pub fn viewport(mut self, viewport: CanvasViewport) -> Self {
445        self.viewport = viewport;
446        self
447    }
448
449    pub fn desired_size(mut self, size: Size) -> Self {
450        self.desired_size = Size::new(size.width.max(1.0), size.height.max(1.0));
451        self
452    }
453
454    pub fn shape(mut self, shape: CanvasShape) -> Self {
455        self.shapes.push(shape);
456        self
457    }
458
459    pub fn shapes<I>(mut self, shapes: I) -> Self
460    where
461        I: IntoIterator<Item = CanvasShape>,
462    {
463        self.shapes.extend(shapes);
464        self
465    }
466
467    pub fn draw_stroke(mut self, stroke: CanvasStroke) -> Self {
468        self.draw_stroke = CanvasStroke::new(stroke.color, stroke.width.max(0.1));
469        self
470    }
471
472    pub fn viewport_state(&self) -> CanvasViewport {
473        self.viewport
474    }
475
476    pub fn shape_count(&self) -> usize {
477        self.shapes.len()
478    }
479
480    fn document_origin(&self) -> Point {
481        Point::ZERO
482    }
483
484    fn world_position(&self, bounds: Rect, position: Point) -> Point {
485        self.viewport
486            .screen_to_world(bounds, position, self.document_origin())
487    }
488
489    fn push_active_point(&mut self, point: Point) {
490        let Some(points) = &mut self.active_stroke else {
491            return;
492        };
493        if points
494            .last()
495            .is_none_or(|last| vector_length(point - *last) >= 1.5)
496        {
497            points.push(point);
498        }
499    }
500
501    fn finish_active_stroke(&mut self) {
502        let Some(points) = self.active_stroke.take() else {
503            return;
504        };
505        if let Some(shape) = CanvasShape::polyline(&points, self.draw_stroke) {
506            self.shapes.push(shape);
507        } else if let Some(point) = points.first().copied() {
508            self.shapes.push(CanvasShape::circle(
509                point,
510                self.draw_stroke.width.max(1.0),
511                Some(self.draw_stroke.color),
512                None,
513            ));
514        }
515    }
516
517    fn request_interaction_update(ctx: &mut EventCtx) {
518        ctx.request_paint();
519        ctx.request_semantics();
520    }
521
522    fn resolved_theme(&self) -> DefaultTheme {
523        self.theme_reader
524            .as_ref()
525            .map(|theme| theme())
526            .unwrap_or(self.theme)
527    }
528}
529
530impl Widget for Canvas {
531    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
532        match event {
533            Event::Pointer(pointer)
534                if pointer.kind == PointerEventKind::Scroll
535                    && ctx.bounds().contains(pointer.position) =>
536            {
537                let delta = scroll_delta_to_offset(pointer.scroll_delta, pointer.delta);
538                if pointer.modifiers.shift {
539                    self.viewport.rotate_around(
540                        ctx.bounds(),
541                        pointer.position,
542                        delta.y * 0.01,
543                        self.document_origin(),
544                    );
545                } else {
546                    self.viewport.zoom_around(
547                        ctx.bounds(),
548                        pointer.position,
549                        (delta.y * 0.002).exp(),
550                        self.document_origin(),
551                    );
552                }
553                Self::request_interaction_update(ctx);
554                ctx.set_handled();
555            }
556            Event::Pointer(pointer)
557                if pointer.kind == PointerEventKind::Down
558                    && ctx.bounds().contains(pointer.position)
559                    && matches!(
560                        pointer.button,
561                        Some(PointerButton::Middle | PointerButton::Secondary)
562                    ) =>
563            {
564                self.drag = Some(CanvasDrag::Pan {
565                    pointer_id: pointer.pointer_id,
566                    last_position: pointer.position,
567                });
568                ctx.request_focus();
569                ctx.request_pointer_capture(pointer.pointer_id);
570                Self::request_interaction_update(ctx);
571                ctx.set_handled();
572            }
573            Event::Pointer(pointer)
574                if pointer.kind == PointerEventKind::Down
575                    && pointer.button == Some(PointerButton::Primary)
576                    && ctx.bounds().contains(pointer.position) =>
577            {
578                let point = self.world_position(ctx.bounds(), pointer.position);
579                self.active_stroke = Some(vec![point]);
580                self.drag = Some(CanvasDrag::Draw {
581                    pointer_id: pointer.pointer_id,
582                });
583                ctx.request_focus();
584                ctx.request_pointer_capture(pointer.pointer_id);
585                Self::request_interaction_update(ctx);
586                ctx.set_handled();
587            }
588            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => match self.drag {
589                Some(CanvasDrag::Pan {
590                    pointer_id,
591                    mut last_position,
592                }) if pointer_id == pointer.pointer_id => {
593                    let delta = pointer.position - last_position;
594                    self.viewport.pan += delta;
595                    last_position = pointer.position;
596                    self.drag = Some(CanvasDrag::Pan {
597                        pointer_id,
598                        last_position,
599                    });
600                    Self::request_interaction_update(ctx);
601                    ctx.set_handled();
602                }
603                Some(CanvasDrag::Draw { pointer_id }) if pointer_id == pointer.pointer_id => {
604                    let point = self.world_position(ctx.bounds(), pointer.position);
605                    self.push_active_point(point);
606                    Self::request_interaction_update(ctx);
607                    ctx.set_handled();
608                }
609                _ => {}
610            },
611            Event::Pointer(pointer)
612                if pointer.kind == PointerEventKind::Up
613                    || pointer.kind == PointerEventKind::Cancel =>
614            {
615                let active_pointer = match self.drag {
616                    Some(CanvasDrag::Pan { pointer_id, .. } | CanvasDrag::Draw { pointer_id }) => {
617                        Some(pointer_id)
618                    }
619                    None => None,
620                };
621                if active_pointer == Some(pointer.pointer_id) {
622                    if matches!(self.drag, Some(CanvasDrag::Draw { .. })) {
623                        self.finish_active_stroke();
624                    }
625                    self.drag = None;
626                    ctx.release_pointer_capture(pointer.pointer_id);
627                    Self::request_interaction_update(ctx);
628                    ctx.set_handled();
629                }
630            }
631            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
632                let zoom_step = self.resolved_theme().metrics.pixel_canvas_zoom_step;
633                match key.key.as_str() {
634                    "=" | "+" => self.viewport.zoom_around(
635                        ctx.bounds(),
636                        CanvasViewport::center(ctx.bounds()),
637                        zoom_step,
638                        self.document_origin(),
639                    ),
640                    "-" => self.viewport.zoom_around(
641                        ctx.bounds(),
642                        CanvasViewport::center(ctx.bounds()),
643                        1.0 / zoom_step,
644                        self.document_origin(),
645                    ),
646                    "[" => self.viewport.rotate_around(
647                        ctx.bounds(),
648                        CanvasViewport::center(ctx.bounds()),
649                        -0.1,
650                        self.document_origin(),
651                    ),
652                    "]" => self.viewport.rotate_around(
653                        ctx.bounds(),
654                        CanvasViewport::center(ctx.bounds()),
655                        0.1,
656                        self.document_origin(),
657                    ),
658                    "ArrowLeft" => self.viewport.pan.x += 24.0,
659                    "ArrowRight" => self.viewport.pan.x -= 24.0,
660                    "ArrowUp" => self.viewport.pan.y += 24.0,
661                    "ArrowDown" => self.viewport.pan.y -= 24.0,
662                    _ => return,
663                }
664                Self::request_interaction_update(ctx);
665                ctx.set_handled();
666            }
667            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
668                if self.focus_animation.advance(*time) {
669                    ctx.request_animation_frame();
670                }
671                ctx.request_paint();
672            }
673            _ => {}
674        }
675    }
676
677    fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
678        constraints.clamp(Size::new(
679            if constraints.max.width.is_finite() {
680                constraints.max.width
681            } else {
682                self.desired_size.width
683            },
684            if constraints.max.height.is_finite() {
685                constraints.max.height
686            } else {
687                self.desired_size.height
688            },
689        ))
690    }
691
692    fn paint(&self, ctx: &mut PaintCtx) {
693        let theme = self.resolved_theme();
694        ctx.fill_bounds(theme.surfaces.canvas);
695        ctx.stroke_bounds(
696            theme.surfaces.border,
697            StrokeStyle::new(theme.metrics.border_width),
698        );
699        ctx.push_clip_rect(ctx.bounds());
700        paint_canvas_grid(
701            ctx,
702            self.viewport,
703            ctx.bounds(),
704            self.document_origin(),
705            &theme,
706        );
707        paint_canvas_axes(
708            ctx,
709            self.viewport,
710            ctx.bounds(),
711            self.document_origin(),
712            &theme,
713        );
714        let transform = self
715            .viewport
716            .transform(ctx.bounds(), self.document_origin());
717        for shape in &self.shapes {
718            paint_canvas_shape(ctx, shape, transform, self.viewport.zoom);
719        }
720        if let Some(points) = &self.active_stroke
721            && let Some(shape) = CanvasShape::polyline(points, self.draw_stroke)
722        {
723            paint_canvas_shape(ctx, &shape, transform, self.viewport.zoom);
724        }
725        ctx.pop_clip();
726        draw_focus_ring(ctx, ctx.bounds(), &theme, self.focus_animation.value);
727    }
728
729    fn semantics(&self, ctx: &mut SemanticsCtx) {
730        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Canvas, ctx.bounds());
731        node.name = Some(self.name.clone());
732        node.value = Some(SemanticsValue::Text(format!(
733            "zoom {:.0}%, rotation {:.0} deg",
734            self.viewport.zoom * 100.0,
735            self.viewport.rotation.to_degrees()
736        )));
737        node.state.focused = ctx.is_focused();
738        node.actions = vec![
739            SemanticsAction::Focus,
740            SemanticsAction::Custom("Pan".into()),
741        ];
742        ctx.push(node);
743    }
744
745    fn accepts_focus(&self) -> bool {
746        true
747    }
748
749    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
750        let theme = self.resolved_theme();
751        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
752        Self::request_interaction_update(ctx);
753    }
754}
755
756#[derive(Debug, Clone, Copy, PartialEq)]
757enum PixelCanvasDrag {
758    Pan {
759        pointer_id: u64,
760        last_position: Point,
761    },
762    Paint {
763        pointer_id: u64,
764        last_position: Point,
765    },
766}
767
768#[derive(Debug, Clone, Copy, PartialEq, Eq)]
769enum PixelCanvasHistoryCommand {
770    Undo,
771    Redo,
772}
773
774#[derive(Debug, Clone, Copy, PartialEq, Eq)]
775enum PixelCanvasViewportCommand {
776    Fit,
777    ActualSize,
778    ZoomIn,
779    ZoomOut,
780}
781
782#[derive(Debug, Clone, Copy, PartialEq, Eq)]
783struct PixelEdit {
784    index: usize,
785    before: PixelColor,
786    after: PixelColor,
787}
788
789#[derive(Debug, Clone, Copy, PartialEq, Eq)]
790struct PixelColor {
791    red: u8,
792    green: u8,
793    blue: u8,
794    alpha: u8,
795}
796
797impl PixelColor {
798    const TRANSPARENT: Self = Self {
799        red: 0,
800        green: 0,
801        blue: 0,
802        alpha: 0,
803    };
804
805    fn from_color(color: Color) -> Self {
806        let color = color.clamped();
807        Self {
808            red: channel_to_u8(color.red),
809            green: channel_to_u8(color.green),
810            blue: channel_to_u8(color.blue),
811            alpha: channel_to_u8(color.alpha),
812        }
813    }
814
815    fn to_color(self) -> Color {
816        Color::rgba(
817            self.red as f32 / 255.0,
818            self.green as f32 / 255.0,
819            self.blue as f32 / 255.0,
820            self.alpha as f32 / 255.0,
821        )
822    }
823
824    fn compose(self, source: Color, opacity: f32, blend_mode: PixelCanvasBlendMode) -> Self {
825        let destination = self.to_color();
826        let source = source.clamped();
827        let opacity = opacity.clamp(0.0, 1.0);
828        let source_alpha = (source.alpha * opacity).clamp(0.0, 1.0);
829        if source_alpha <= 0.0 {
830            return self;
831        }
832
833        let destination_alpha = destination.alpha.clamp(0.0, 1.0);
834        let blend_red = blend_channel(source.red, destination.red, destination_alpha, blend_mode);
835        let blend_green = blend_channel(
836            source.green,
837            destination.green,
838            destination_alpha,
839            blend_mode,
840        );
841        let blend_blue =
842            blend_channel(source.blue, destination.blue, destination_alpha, blend_mode);
843        let output_alpha = source_alpha + destination_alpha * (1.0 - source_alpha);
844        if output_alpha <= 0.0 {
845            return Self::TRANSPARENT;
846        }
847
848        let destination_weight = destination_alpha * (1.0 - source_alpha);
849        Self::from_color(Color::rgba(
850            ((blend_red * source_alpha) + (destination.red * destination_weight)) / output_alpha,
851            ((blend_green * source_alpha) + (destination.green * destination_weight))
852                / output_alpha,
853            ((blend_blue * source_alpha) + (destination.blue * destination_weight)) / output_alpha,
854            output_alpha,
855        ))
856    }
857
858    fn erased(self, opacity: f32) -> Self {
859        let opacity = opacity.clamp(0.0, 1.0);
860        if opacity <= 0.0 {
861            return self;
862        }
863        let scale = 1.0 - opacity;
864        Self {
865            alpha: channel_to_u8((self.alpha as f32 / 255.0) * scale),
866            ..self
867        }
868    }
869}
870
871fn blend_channel(
872    source: f32,
873    destination: f32,
874    destination_alpha: f32,
875    mode: PixelCanvasBlendMode,
876) -> f32 {
877    if destination_alpha <= 0.0 {
878        return source.clamp(0.0, 1.0);
879    }
880
881    match mode {
882        PixelCanvasBlendMode::Normal => source,
883        PixelCanvasBlendMode::Multiply => source * destination,
884        PixelCanvasBlendMode::Screen => 1.0 - ((1.0 - source) * (1.0 - destination)),
885        PixelCanvasBlendMode::Overlay => {
886            if destination <= 0.5 {
887                2.0 * source * destination
888            } else {
889                1.0 - (2.0 * (1.0 - source) * (1.0 - destination))
890            }
891        }
892    }
893    .clamp(0.0, 1.0)
894}
895
896fn brush_shape_contains_pixel(
897    shape: PixelCanvasBrushShape,
898    size: isize,
899    start_x: isize,
900    start_y: isize,
901    px: isize,
902    py: isize,
903) -> bool {
904    match shape {
905        PixelCanvasBrushShape::Square => true,
906        PixelCanvasBrushShape::Round => {
907            let size = size.max(1) as f32;
908            let center = (size - 1.0) * 0.5;
909            let local_x = (px - start_x) as f32 - center;
910            let local_y = (py - start_y) as f32 - center;
911            let radius = (size * 0.5 - 0.25).max(0.0);
912            (local_x * local_x) + (local_y * local_y) <= radius * radius
913        }
914    }
915}
916
917fn brush_stroke_spacing(brush_size: f32) -> f32 {
918    (brush_size.round().max(1.0) * 0.25).max(1.0)
919}
920
921#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
922pub enum PixelCanvasTool {
923    #[default]
924    Brush,
925    Eraser,
926    Fill,
927    Pan,
928}
929
930impl PixelCanvasTool {
931    pub const fn label(self) -> &'static str {
932        match self {
933            Self::Brush => "Brush",
934            Self::Eraser => "Eraser",
935            Self::Fill => "Fill",
936            Self::Pan => "Pan",
937        }
938    }
939}
940
941#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
942pub enum PixelCanvasBlendMode {
943    #[default]
944    Normal,
945    Multiply,
946    Screen,
947    Overlay,
948}
949
950impl PixelCanvasBlendMode {
951    pub const ALL: [Self; 4] = [Self::Normal, Self::Multiply, Self::Screen, Self::Overlay];
952
953    pub const fn label(self) -> &'static str {
954        match self {
955            Self::Normal => "Normal",
956            Self::Multiply => "Multiply",
957            Self::Screen => "Screen",
958            Self::Overlay => "Overlay",
959        }
960    }
961}
962
963#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
964pub enum PixelCanvasBrushShape {
965    Square,
966    #[default]
967    Round,
968}
969
970impl PixelCanvasBrushShape {
971    pub const ALL: [Self; 2] = [Self::Square, Self::Round];
972
973    pub const fn label(self) -> &'static str {
974        match self {
975            Self::Square => "Square",
976            Self::Round => "Round",
977        }
978    }
979}
980
981#[derive(Debug, Clone, PartialEq)]
982struct PixelCanvasStateInner {
983    tool: PixelCanvasTool,
984    brush: Color,
985    brush_size: f32,
986    brush_opacity: f32,
987    brush_shape: PixelCanvasBrushShape,
988    blend_mode: PixelCanvasBlendMode,
989    display_visible: bool,
990    display_opacity: f32,
991    display_blend_mode: PixelCanvasBlendMode,
992    display_above_paper: bool,
993    paper_visible: bool,
994    paper_opacity: f32,
995    pending_undo: u32,
996    pending_redo: u32,
997    pending_fit_view: u32,
998    pending_actual_size: u32,
999    pending_zoom_delta: i32,
1000    pending_export: u32,
1001    pending_clear: u32,
1002    export_revision: u64,
1003    latest_export: Option<PixelCanvasExportSnapshot>,
1004    editable: bool,
1005    can_undo: bool,
1006    can_redo: bool,
1007    can_clear: bool,
1008    viewport: CanvasViewport,
1009    viewport_size: Size,
1010    cursor_position: Option<Point>,
1011}
1012
1013#[derive(Debug, Clone, PartialEq)]
1014pub struct PixelCanvasExportSnapshot {
1015    revision: u64,
1016    name: String,
1017    width: usize,
1018    height: usize,
1019    rgba8: Rc<[u8]>,
1020}
1021
1022impl PixelCanvasExportSnapshot {
1023    fn new(revision: u64, name: String, width: usize, height: usize, rgba8: Vec<u8>) -> Self {
1024        Self {
1025            revision,
1026            name,
1027            width,
1028            height,
1029            rgba8: Rc::from(rgba8.into_boxed_slice()),
1030        }
1031    }
1032
1033    pub const fn revision(&self) -> u64 {
1034        self.revision
1035    }
1036
1037    pub fn name(&self) -> &str {
1038        &self.name
1039    }
1040
1041    pub const fn width(&self) -> usize {
1042        self.width
1043    }
1044
1045    pub const fn height(&self) -> usize {
1046        self.height
1047    }
1048
1049    pub fn rgba8(&self) -> &[u8] {
1050        self.rgba8.as_ref()
1051    }
1052
1053    pub fn byte_len(&self) -> usize {
1054        self.rgba8.len()
1055    }
1056}
1057
1058#[derive(Debug, Clone, Copy, PartialEq)]
1059struct PixelCanvasBrushSettings {
1060    tool: PixelCanvasTool,
1061    brush: Color,
1062    brush_size: f32,
1063    brush_opacity: f32,
1064    brush_shape: PixelCanvasBrushShape,
1065    blend_mode: PixelCanvasBlendMode,
1066}
1067
1068#[derive(Debug, Clone, Copy, PartialEq)]
1069struct PixelCanvasDisplaySettings {
1070    visible: bool,
1071    opacity: f32,
1072    blend_mode: PixelCanvasBlendMode,
1073}
1074
1075impl PixelCanvasDisplaySettings {
1076    const DEFAULT: Self = Self {
1077        visible: true,
1078        opacity: 1.0,
1079        blend_mode: PixelCanvasBlendMode::Normal,
1080    };
1081
1082    fn requires_compositing(self) -> bool {
1083        !self.visible || self.opacity < 0.999 || self.blend_mode != PixelCanvasBlendMode::Normal
1084    }
1085}
1086
1087#[derive(Debug, Clone, Copy, PartialEq)]
1088struct PixelCanvasPaperSettings {
1089    visible: bool,
1090    opacity: f32,
1091}
1092
1093impl PixelCanvasPaperSettings {
1094    const DEFAULT: Self = Self {
1095        visible: true,
1096        opacity: 1.0,
1097    };
1098
1099    fn requires_compositing(self) -> bool {
1100        !self.visible || self.opacity < 0.999
1101    }
1102
1103    fn pixel(self, paper_color: Color) -> PixelColor {
1104        if self.visible {
1105            PixelColor::from_color(paper_color.with_alpha(self.opacity))
1106        } else {
1107            PixelColor::TRANSPARENT
1108        }
1109    }
1110}
1111
1112#[derive(Debug, Clone, Copy, PartialEq)]
1113enum PixelCanvasImageSource {
1114    Raw,
1115    Composited {
1116        display: PixelCanvasDisplaySettings,
1117        paper: PixelCanvasPaperSettings,
1118        display_above_paper: bool,
1119        paper_color: Color,
1120    },
1121}
1122
1123#[derive(Debug, Clone, Copy, PartialEq)]
1124struct PixelCanvasImageCacheKey {
1125    pixel_revision: u64,
1126    source: PixelCanvasImageSource,
1127}
1128
1129#[derive(Debug, Clone)]
1130struct PixelCanvasImageCache {
1131    key: PixelCanvasImageCacheKey,
1132    image: RegisteredImage,
1133}
1134
1135#[derive(Clone, Debug)]
1136pub struct PixelCanvasState {
1137    inner: Rc<RefCell<PixelCanvasStateInner>>,
1138}
1139
1140impl PixelCanvasState {
1141    pub fn new() -> Self {
1142        Self::default()
1143    }
1144
1145    pub fn brush_color(&self) -> Color {
1146        self.inner.borrow().brush
1147    }
1148
1149    pub fn tool(&self) -> PixelCanvasTool {
1150        self.inner.borrow().tool
1151    }
1152
1153    pub fn set_tool(&self, tool: PixelCanvasTool) {
1154        self.inner.borrow_mut().tool = tool;
1155    }
1156
1157    pub fn request_undo(&self) {
1158        let mut inner = self.inner.borrow_mut();
1159        inner.pending_undo = inner.pending_undo.saturating_add(1);
1160    }
1161
1162    pub fn request_redo(&self) {
1163        let mut inner = self.inner.borrow_mut();
1164        inner.pending_redo = inner.pending_redo.saturating_add(1);
1165    }
1166
1167    pub fn request_fit_view(&self) {
1168        let mut inner = self.inner.borrow_mut();
1169        inner.pending_fit_view = inner.pending_fit_view.saturating_add(1);
1170    }
1171
1172    pub fn request_actual_size_view(&self) {
1173        let mut inner = self.inner.borrow_mut();
1174        inner.pending_actual_size = inner.pending_actual_size.saturating_add(1);
1175    }
1176
1177    pub fn request_zoom_in(&self) {
1178        let mut inner = self.inner.borrow_mut();
1179        inner.pending_zoom_delta = inner.pending_zoom_delta.saturating_add(1);
1180    }
1181
1182    pub fn request_zoom_out(&self) {
1183        let mut inner = self.inner.borrow_mut();
1184        inner.pending_zoom_delta = inner.pending_zoom_delta.saturating_sub(1);
1185    }
1186
1187    pub fn request_export_snapshot(&self) {
1188        let mut inner = self.inner.borrow_mut();
1189        inner.pending_export = inner.pending_export.saturating_add(1);
1190    }
1191
1192    pub fn request_clear(&self) {
1193        let mut inner = self.inner.borrow_mut();
1194        inner.pending_clear = inner.pending_clear.saturating_add(1);
1195    }
1196
1197    pub fn is_editable(&self) -> bool {
1198        self.inner.borrow().editable
1199    }
1200
1201    pub fn set_editable(&self, editable: bool) -> bool {
1202        let mut inner = self.inner.borrow_mut();
1203        if inner.editable == editable {
1204            return false;
1205        }
1206        inner.editable = editable;
1207        if !editable {
1208            inner.can_undo = false;
1209            inner.can_redo = false;
1210            inner.can_clear = false;
1211        }
1212        true
1213    }
1214
1215    pub fn latest_export_snapshot(&self) -> Option<PixelCanvasExportSnapshot> {
1216        self.inner.borrow().latest_export.clone()
1217    }
1218
1219    pub fn can_undo(&self) -> bool {
1220        self.inner.borrow().can_undo
1221    }
1222
1223    pub fn can_redo(&self) -> bool {
1224        self.inner.borrow().can_redo
1225    }
1226
1227    pub fn can_clear(&self) -> bool {
1228        self.inner.borrow().can_clear
1229    }
1230
1231    pub fn viewport(&self) -> CanvasViewport {
1232        self.inner.borrow().viewport
1233    }
1234
1235    pub fn viewport_size(&self) -> Size {
1236        self.inner.borrow().viewport_size
1237    }
1238
1239    pub fn cursor_position(&self) -> Option<Point> {
1240        self.inner.borrow().cursor_position
1241    }
1242
1243    pub fn set_brush_color(&self, color: Color) {
1244        self.inner.borrow_mut().brush = color;
1245    }
1246
1247    pub fn brush_size(&self) -> f32 {
1248        self.inner.borrow().brush_size
1249    }
1250
1251    pub fn set_brush_size(&self, size: f32) {
1252        self.inner.borrow_mut().brush_size = size.max(1.0);
1253    }
1254
1255    pub fn brush_opacity(&self) -> f32 {
1256        self.inner.borrow().brush_opacity
1257    }
1258
1259    pub fn set_brush_opacity(&self, opacity: f32) {
1260        self.inner.borrow_mut().brush_opacity = opacity.clamp(0.0, 1.0);
1261    }
1262
1263    pub fn brush_shape(&self) -> PixelCanvasBrushShape {
1264        self.inner.borrow().brush_shape
1265    }
1266
1267    pub fn set_brush_shape(&self, brush_shape: PixelCanvasBrushShape) {
1268        self.inner.borrow_mut().brush_shape = brush_shape;
1269    }
1270
1271    pub fn blend_mode(&self) -> PixelCanvasBlendMode {
1272        self.inner.borrow().blend_mode
1273    }
1274
1275    pub fn set_blend_mode(&self, blend_mode: PixelCanvasBlendMode) {
1276        self.inner.borrow_mut().blend_mode = blend_mode;
1277    }
1278
1279    pub fn display_visible(&self) -> bool {
1280        self.inner.borrow().display_visible
1281    }
1282
1283    pub fn set_display_visible(&self, visible: bool) -> bool {
1284        let mut inner = self.inner.borrow_mut();
1285        if inner.display_visible == visible {
1286            return false;
1287        }
1288        inner.display_visible = visible;
1289        true
1290    }
1291
1292    pub fn display_opacity(&self) -> f32 {
1293        self.inner.borrow().display_opacity
1294    }
1295
1296    pub fn set_display_opacity(&self, opacity: f32) -> bool {
1297        let opacity = opacity.clamp(0.0, 1.0);
1298        let mut inner = self.inner.borrow_mut();
1299        if (inner.display_opacity - opacity).abs() < f32::EPSILON {
1300            return false;
1301        }
1302        inner.display_opacity = opacity;
1303        true
1304    }
1305
1306    pub fn display_blend_mode(&self) -> PixelCanvasBlendMode {
1307        self.inner.borrow().display_blend_mode
1308    }
1309
1310    pub fn set_display_blend_mode(&self, blend_mode: PixelCanvasBlendMode) -> bool {
1311        let mut inner = self.inner.borrow_mut();
1312        if inner.display_blend_mode == blend_mode {
1313            return false;
1314        }
1315        inner.display_blend_mode = blend_mode;
1316        true
1317    }
1318
1319    pub fn display_above_paper(&self) -> bool {
1320        self.inner.borrow().display_above_paper
1321    }
1322
1323    pub fn set_display_above_paper(&self, above: bool) -> bool {
1324        let mut inner = self.inner.borrow_mut();
1325        if inner.display_above_paper == above {
1326            return false;
1327        }
1328        inner.display_above_paper = above;
1329        true
1330    }
1331
1332    pub fn paper_visible(&self) -> bool {
1333        self.inner.borrow().paper_visible
1334    }
1335
1336    pub fn set_paper_visible(&self, visible: bool) -> bool {
1337        let mut inner = self.inner.borrow_mut();
1338        if inner.paper_visible == visible {
1339            return false;
1340        }
1341        inner.paper_visible = visible;
1342        true
1343    }
1344
1345    pub fn paper_opacity(&self) -> f32 {
1346        self.inner.borrow().paper_opacity
1347    }
1348
1349    pub fn set_paper_opacity(&self, opacity: f32) -> bool {
1350        let opacity = opacity.clamp(0.0, 1.0);
1351        let mut inner = self.inner.borrow_mut();
1352        if (inner.paper_opacity - opacity).abs() < f32::EPSILON {
1353            return false;
1354        }
1355        inner.paper_opacity = opacity;
1356        true
1357    }
1358
1359    fn brush(&self) -> PixelCanvasBrushSettings {
1360        let inner = self.inner.borrow();
1361        PixelCanvasBrushSettings {
1362            tool: inner.tool,
1363            brush: inner.brush,
1364            brush_size: inner.brush_size,
1365            brush_opacity: inner.brush_opacity,
1366            brush_shape: inner.brush_shape,
1367            blend_mode: inner.blend_mode,
1368        }
1369    }
1370
1371    fn display(&self) -> PixelCanvasDisplaySettings {
1372        let inner = self.inner.borrow();
1373        PixelCanvasDisplaySettings {
1374            visible: inner.display_visible,
1375            opacity: inner.display_opacity,
1376            blend_mode: inner.display_blend_mode,
1377        }
1378    }
1379
1380    fn paper(&self) -> PixelCanvasPaperSettings {
1381        let inner = self.inner.borrow();
1382        PixelCanvasPaperSettings {
1383            visible: inner.paper_visible,
1384            opacity: inner.paper_opacity,
1385        }
1386    }
1387
1388    fn take_history_command(&self) -> Option<PixelCanvasHistoryCommand> {
1389        let mut inner = self.inner.borrow_mut();
1390        if inner.pending_undo > 0 {
1391            inner.pending_undo -= 1;
1392            return Some(PixelCanvasHistoryCommand::Undo);
1393        }
1394        if inner.pending_redo > 0 {
1395            inner.pending_redo -= 1;
1396            return Some(PixelCanvasHistoryCommand::Redo);
1397        }
1398        None
1399    }
1400
1401    fn take_viewport_command(&self) -> Option<PixelCanvasViewportCommand> {
1402        let mut inner = self.inner.borrow_mut();
1403        if inner.pending_fit_view > 0 {
1404            inner.pending_fit_view -= 1;
1405            return Some(PixelCanvasViewportCommand::Fit);
1406        }
1407        if inner.pending_actual_size > 0 {
1408            inner.pending_actual_size -= 1;
1409            return Some(PixelCanvasViewportCommand::ActualSize);
1410        }
1411        if inner.pending_zoom_delta > 0 {
1412            inner.pending_zoom_delta -= 1;
1413            return Some(PixelCanvasViewportCommand::ZoomIn);
1414        }
1415        if inner.pending_zoom_delta < 0 {
1416            inner.pending_zoom_delta += 1;
1417            return Some(PixelCanvasViewportCommand::ZoomOut);
1418        }
1419        None
1420    }
1421
1422    fn take_export_request(&self) -> bool {
1423        let mut inner = self.inner.borrow_mut();
1424        if inner.pending_export == 0 {
1425            return false;
1426        }
1427        inner.pending_export = 0;
1428        true
1429    }
1430
1431    fn take_clear_request(&self) -> bool {
1432        let mut inner = self.inner.borrow_mut();
1433        if inner.pending_clear == 0 {
1434            return false;
1435        }
1436        inner.pending_clear = 0;
1437        true
1438    }
1439
1440    fn publish_export_snapshot(&self, name: String, width: usize, height: usize, rgba8: Vec<u8>) {
1441        let mut inner = self.inner.borrow_mut();
1442        inner.export_revision = inner.export_revision.saturating_add(1);
1443        inner.latest_export = Some(PixelCanvasExportSnapshot::new(
1444            inner.export_revision,
1445            name,
1446            width,
1447            height,
1448            rgba8,
1449        ));
1450    }
1451
1452    fn set_canvas_availability(&self, can_undo: bool, can_redo: bool, can_clear: bool) -> bool {
1453        let mut inner = self.inner.borrow_mut();
1454        if inner.can_undo == can_undo && inner.can_redo == can_redo && inner.can_clear == can_clear
1455        {
1456            return false;
1457        }
1458        inner.can_undo = can_undo;
1459        inner.can_redo = can_redo;
1460        inner.can_clear = can_clear;
1461        true
1462    }
1463
1464    fn set_viewport_state(&self, viewport: CanvasViewport, viewport_size: Size) -> bool {
1465        let mut inner = self.inner.borrow_mut();
1466        if inner.viewport == viewport && inner.viewport_size == viewport_size {
1467            return false;
1468        }
1469        inner.viewport = viewport;
1470        inner.viewport_size = viewport_size;
1471        true
1472    }
1473
1474    fn set_cursor_position(&self, cursor_position: Option<Point>) -> bool {
1475        let mut inner = self.inner.borrow_mut();
1476        if inner.cursor_position == cursor_position {
1477            return false;
1478        }
1479        inner.cursor_position = cursor_position;
1480        true
1481    }
1482}
1483
1484impl Default for PixelCanvasState {
1485    fn default() -> Self {
1486        let accent = DefaultTheme::default().palette.accent;
1487        Self {
1488            inner: Rc::new(RefCell::new(PixelCanvasStateInner {
1489                tool: PixelCanvasTool::Brush,
1490                brush: accent,
1491                brush_size: 1.0,
1492                brush_opacity: 1.0,
1493                brush_shape: PixelCanvasBrushShape::Round,
1494                blend_mode: PixelCanvasBlendMode::Normal,
1495                display_visible: PixelCanvasDisplaySettings::DEFAULT.visible,
1496                display_opacity: PixelCanvasDisplaySettings::DEFAULT.opacity,
1497                display_blend_mode: PixelCanvasDisplaySettings::DEFAULT.blend_mode,
1498                display_above_paper: true,
1499                paper_visible: PixelCanvasPaperSettings::DEFAULT.visible,
1500                paper_opacity: PixelCanvasPaperSettings::DEFAULT.opacity,
1501                pending_undo: 0,
1502                pending_redo: 0,
1503                pending_fit_view: 0,
1504                pending_actual_size: 0,
1505                pending_zoom_delta: 0,
1506                pending_export: 0,
1507                pending_clear: 0,
1508                export_revision: 0,
1509                latest_export: None,
1510                editable: true,
1511                can_undo: false,
1512                can_redo: false,
1513                can_clear: false,
1514                viewport: CanvasViewport::default(),
1515                viewport_size: Size::ZERO,
1516                cursor_position: None,
1517            })),
1518        }
1519    }
1520}
1521
1522pub struct PixelCanvas {
1523    theme: DefaultTheme,
1524    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
1525    paper_color: Option<Color>,
1526    name: String,
1527    width: usize,
1528    height: usize,
1529    pixels: Vec<PixelColor>,
1530    pixel_revision: u64,
1531    paint_image_cache: RefCell<Option<PixelCanvasImageCache>>,
1532    viewport: CanvasViewport,
1533    state: PixelCanvasState,
1534    drag: Option<PixelCanvasDrag>,
1535    active_edits: Vec<PixelEdit>,
1536    undo_stack: Vec<Vec<PixelEdit>>,
1537    redo_stack: Vec<Vec<PixelEdit>>,
1538    has_visible_pixels: bool,
1539    focus_animation: AnimatedScalar,
1540    desired_size: Size,
1541    fit_on_first_layout: bool,
1542    initial_fit_applied: bool,
1543}
1544
1545impl PixelCanvas {
1546    pub fn new(name: impl Into<String>, width: usize, height: usize) -> Self {
1547        let width = width.max(1);
1548        let height = height.max(1);
1549        Self {
1550            theme: DefaultTheme::default(),
1551            theme_reader: None,
1552            paper_color: None,
1553            name: name.into(),
1554            width,
1555            height,
1556            pixels: vec![PixelColor::TRANSPARENT; width * height],
1557            pixel_revision: 0,
1558            paint_image_cache: RefCell::new(None),
1559            viewport: CanvasViewport::new().zoom(14.0),
1560            state: PixelCanvasState::new(),
1561            drag: None,
1562            active_edits: Vec::new(),
1563            undo_stack: Vec::new(),
1564            redo_stack: Vec::new(),
1565            has_visible_pixels: false,
1566            focus_animation: AnimatedScalar::new(0.0),
1567            desired_size: Size::new(520.0, 360.0),
1568            fit_on_first_layout: false,
1569            initial_fit_applied: false,
1570        }
1571    }
1572
1573    pub fn from_fn<F>(name: impl Into<String>, width: usize, height: usize, mut pixel: F) -> Self
1574    where
1575        F: FnMut(usize, usize) -> Color,
1576    {
1577        let mut canvas = Self::new(name, width, height);
1578        for y in 0..canvas.height {
1579            for x in 0..canvas.width {
1580                let index = y * canvas.width + x;
1581                canvas.pixels[index] = PixelColor::from_color(pixel(x, y));
1582            }
1583        }
1584        canvas.has_visible_pixels = canvas.pixels.iter().any(|pixel| pixel.alpha > 0);
1585        canvas
1586    }
1587
1588    pub fn theme(mut self, theme: DefaultTheme) -> Self {
1589        self.theme = theme;
1590        self.theme_reader = None;
1591        self
1592    }
1593
1594    pub fn theme_when<F>(mut self, theme: F) -> Self
1595    where
1596        F: Fn() -> DefaultTheme + 'static,
1597    {
1598        self.theme_reader = Some(Box::new(theme));
1599        self
1600    }
1601
1602    pub fn paper_color(mut self, color: Color) -> Self {
1603        self.paper_color = Some(color);
1604        self.paint_image_cache.borrow_mut().take();
1605        self
1606    }
1607
1608    pub fn desired_size(mut self, size: Size) -> Self {
1609        self.desired_size = Size::new(size.width.max(1.0), size.height.max(1.0));
1610        self
1611    }
1612
1613    pub fn viewport(mut self, viewport: CanvasViewport) -> Self {
1614        self.viewport = viewport;
1615        self
1616    }
1617
1618    pub fn fit_on_first_layout(mut self) -> Self {
1619        self.fit_on_first_layout = true;
1620        self.initial_fit_applied = false;
1621        self
1622    }
1623
1624    pub fn state(mut self, state: PixelCanvasState) -> Self {
1625        self.state = state;
1626        self.publish_canvas_availability();
1627        self.state.set_viewport_state(self.viewport, Size::ZERO);
1628        self
1629    }
1630
1631    pub fn brush_color(self, color: Color) -> Self {
1632        self.state.set_brush_color(color);
1633        self
1634    }
1635
1636    pub fn brush_size(self, size: f32) -> Self {
1637        self.state.set_brush_size(size);
1638        self
1639    }
1640
1641    pub fn with_pixels(mut self, pixels: Vec<Color>) -> Self {
1642        if pixels.len() == self.pixels.len() {
1643            self.pixels = pixels.into_iter().map(PixelColor::from_color).collect();
1644            self.mark_pixels_changed();
1645            self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
1646            self.publish_canvas_availability();
1647        }
1648        self
1649    }
1650
1651    pub fn set_pixel(&mut self, x: usize, y: usize, color: Color) -> bool {
1652        let Some(index) = self.pixel_index(x, y) else {
1653            return false;
1654        };
1655        let next = PixelColor::from_color(color);
1656        if self.pixels[index] == next {
1657            return false;
1658        }
1659        self.pixels[index] = next;
1660        self.mark_pixels_changed();
1661        if next.alpha > 0 {
1662            self.has_visible_pixels = true;
1663        } else if self.has_visible_pixels {
1664            self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
1665        }
1666        self.publish_canvas_availability();
1667        true
1668    }
1669
1670    pub fn pixel_at(&self, x: usize, y: usize) -> Option<Color> {
1671        self.pixel_index(x, y)
1672            .map(|index| self.pixels[index].to_color())
1673    }
1674
1675    pub const fn width(&self) -> usize {
1676        self.width
1677    }
1678
1679    pub const fn height(&self) -> usize {
1680        self.height
1681    }
1682
1683    pub fn viewport_state(&self) -> CanvasViewport {
1684        self.viewport
1685    }
1686
1687    fn pixel_index(&self, x: usize, y: usize) -> Option<usize> {
1688        (x < self.width && y < self.height).then_some(y * self.width + x)
1689    }
1690
1691    fn document_origin(&self) -> Point {
1692        Point::new(self.width as f32 * 0.5, self.height as f32 * 0.5)
1693    }
1694
1695    fn mark_pixels_changed(&mut self) {
1696        self.pixel_revision = self.pixel_revision.wrapping_add(1);
1697        if self.pixel_revision == 0 {
1698            self.paint_image_cache.borrow_mut().take();
1699        }
1700    }
1701
1702    fn set_pixel_with_history(
1703        &mut self,
1704        x: usize,
1705        y: usize,
1706        color: Color,
1707        opacity: f32,
1708        blend_mode: PixelCanvasBlendMode,
1709        edits: &mut Vec<PixelEdit>,
1710    ) -> bool {
1711        let Some(index) = self.pixel_index(x, y) else {
1712            return false;
1713        };
1714        let before = self.pixels[index];
1715        let after = before.compose(color, opacity, blend_mode);
1716        if before == after {
1717            return false;
1718        }
1719        self.pixels[index] = after;
1720        edits.push(PixelEdit {
1721            index,
1722            before,
1723            after,
1724        });
1725        true
1726    }
1727
1728    fn erase_pixel_with_history(
1729        &mut self,
1730        x: usize,
1731        y: usize,
1732        opacity: f32,
1733        edits: &mut Vec<PixelEdit>,
1734    ) -> bool {
1735        let Some(index) = self.pixel_index(x, y) else {
1736            return false;
1737        };
1738        let before = self.pixels[index];
1739        let after = before.erased(opacity);
1740        if before == after {
1741            return false;
1742        }
1743        self.pixels[index] = after;
1744        edits.push(PixelEdit {
1745            index,
1746            before,
1747            after,
1748        });
1749        true
1750    }
1751
1752    fn paint_at_world(&mut self, world: Point, edits: &mut Vec<PixelEdit>) -> bool {
1753        let x = world.x.floor() as isize;
1754        let y = world.y.floor() as isize;
1755        let brush = self.state.brush();
1756        let color = match brush.tool {
1757            PixelCanvasTool::Brush => brush.brush,
1758            PixelCanvasTool::Eraser => PixelColor::TRANSPARENT.to_color(),
1759            PixelCanvasTool::Fill | PixelCanvasTool::Pan => return false,
1760        };
1761        let size = brush.brush_size.round().max(1.0) as isize;
1762        let half = size / 2;
1763        let start_x = x - half;
1764        let start_y = y - half;
1765        let mut painted = false;
1766        for py in start_y..start_y + size {
1767            for px in start_x..start_x + size {
1768                if px < 0 || py < 0 {
1769                    continue;
1770                }
1771                if !brush_shape_contains_pixel(brush.brush_shape, size, start_x, start_y, px, py) {
1772                    continue;
1773                }
1774                painted |= match brush.tool {
1775                    PixelCanvasTool::Brush => self.set_pixel_with_history(
1776                        px as usize,
1777                        py as usize,
1778                        color,
1779                        brush.brush_opacity,
1780                        brush.blend_mode,
1781                        edits,
1782                    ),
1783                    PixelCanvasTool::Eraser => self.erase_pixel_with_history(
1784                        px as usize,
1785                        py as usize,
1786                        brush.brush_opacity,
1787                        edits,
1788                    ),
1789                    PixelCanvasTool::Fill | PixelCanvasTool::Pan => false,
1790                };
1791            }
1792        }
1793        if painted {
1794            self.mark_pixels_changed();
1795        }
1796        painted
1797    }
1798
1799    fn paint_at_position(
1800        &mut self,
1801        bounds: Rect,
1802        position: Point,
1803        edits: &mut Vec<PixelEdit>,
1804    ) -> bool {
1805        let world = self
1806            .viewport
1807            .screen_to_world(bounds, position, self.document_origin());
1808        self.paint_at_world(world, edits)
1809    }
1810
1811    fn paint_between_positions(
1812        &mut self,
1813        bounds: Rect,
1814        start: Point,
1815        end: Point,
1816        edits: &mut Vec<PixelEdit>,
1817    ) -> bool {
1818        let document_origin = self.document_origin();
1819        let start = self
1820            .viewport
1821            .screen_to_world(bounds, start, document_origin);
1822        let end = self.viewport.screen_to_world(bounds, end, document_origin);
1823        let delta = end - start;
1824        let distance = (delta.x * delta.x + delta.y * delta.y).sqrt();
1825        if distance <= f32::EPSILON {
1826            return false;
1827        }
1828
1829        let spacing = brush_stroke_spacing(self.state.brush_size());
1830        let steps = (distance / spacing).ceil().max(1.0) as usize;
1831        let mut painted = false;
1832        for step in 1..=steps {
1833            let t = step as f32 / steps as f32;
1834            painted |= self.paint_at_world(
1835                Point::new(start.x + (delta.x * t), start.y + (delta.y * t)),
1836                edits,
1837            );
1838        }
1839        painted
1840    }
1841
1842    fn fill_at_position(
1843        &mut self,
1844        bounds: Rect,
1845        position: Point,
1846        edits: &mut Vec<PixelEdit>,
1847    ) -> bool {
1848        let world = self
1849            .viewport
1850            .screen_to_world(bounds, position, self.document_origin());
1851        let x = world.x.floor() as isize;
1852        let y = world.y.floor() as isize;
1853        if x < 0 || y < 0 {
1854            return false;
1855        }
1856        let Some(start) = self.pixel_index(x as usize, y as usize) else {
1857            return false;
1858        };
1859        let brush = self.state.brush();
1860        let target = self.pixels[start];
1861        let replacement = target.compose(brush.brush, brush.brush_opacity, brush.blend_mode);
1862        if target == replacement {
1863            return false;
1864        }
1865
1866        let mut stack = vec![start];
1867        while let Some(index) = stack.pop() {
1868            if self.pixels[index] != target {
1869                continue;
1870            }
1871            self.pixels[index] = replacement;
1872            edits.push(PixelEdit {
1873                index,
1874                before: target,
1875                after: replacement,
1876            });
1877            let px = index % self.width;
1878            let py = index / self.width;
1879            if px > 0 {
1880                stack.push(index - 1);
1881            }
1882            if px + 1 < self.width {
1883                stack.push(index + 1);
1884            }
1885            if py > 0 {
1886                stack.push(index - self.width);
1887            }
1888            if py + 1 < self.height {
1889                stack.push(index + self.width);
1890            }
1891        }
1892        self.mark_pixels_changed();
1893        true
1894    }
1895
1896    fn push_history(&mut self, edits: Vec<PixelEdit>) {
1897        if edits.is_empty() {
1898            return;
1899        }
1900        self.undo_stack.push(edits);
1901        if self.undo_stack.len() > PIXEL_CANVAS_HISTORY_LIMIT {
1902            self.undo_stack.remove(0);
1903        }
1904        self.redo_stack.clear();
1905        self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
1906        self.publish_canvas_availability();
1907    }
1908
1909    fn undo(&mut self) -> bool {
1910        if !self.state.is_editable() {
1911            self.publish_canvas_availability();
1912            return false;
1913        }
1914        let Some(edits) = self.undo_stack.pop() else {
1915            self.publish_canvas_availability();
1916            return false;
1917        };
1918        for edit in edits.iter().rev() {
1919            self.pixels[edit.index] = edit.before;
1920        }
1921        self.mark_pixels_changed();
1922        self.redo_stack.push(edits);
1923        self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
1924        self.publish_canvas_availability();
1925        true
1926    }
1927
1928    fn redo(&mut self) -> bool {
1929        if !self.state.is_editable() {
1930            self.publish_canvas_availability();
1931            return false;
1932        }
1933        let Some(edits) = self.redo_stack.pop() else {
1934            self.publish_canvas_availability();
1935            return false;
1936        };
1937        for edit in &edits {
1938            self.pixels[edit.index] = edit.after;
1939        }
1940        self.mark_pixels_changed();
1941        self.undo_stack.push(edits);
1942        self.has_visible_pixels = self.pixels.iter().any(|pixel| pixel.alpha > 0);
1943        self.publish_canvas_availability();
1944        true
1945    }
1946
1947    fn publish_canvas_availability(&self) -> bool {
1948        let editable = self.state.is_editable();
1949        self.state.set_canvas_availability(
1950            editable && !self.undo_stack.is_empty(),
1951            editable && !self.redo_stack.is_empty(),
1952            editable && self.has_visible_pixels,
1953        )
1954    }
1955
1956    fn publish_viewport_state(&self, bounds: Rect) -> bool {
1957        self.state.set_viewport_state(self.viewport, bounds.size)
1958    }
1959
1960    fn cursor_position_for_pointer(&self, bounds: Rect, position: Point) -> Option<Point> {
1961        if !bounds.contains(position) {
1962            return None;
1963        }
1964        let world = self
1965            .viewport
1966            .screen_to_world(bounds, position, self.document_origin());
1967        let x = world.x.floor();
1968        let y = world.y.floor();
1969        (x >= 0.0 && y >= 0.0 && x < self.width as f32 && y < self.height as f32)
1970            .then_some(Point::new(x, y))
1971    }
1972
1973    fn publish_cursor_position(&self, bounds: Rect, position: Point) -> bool {
1974        self.state
1975            .set_cursor_position(self.cursor_position_for_pointer(bounds, position))
1976    }
1977
1978    fn clear_cursor_position(&self) -> bool {
1979        self.state.set_cursor_position(None)
1980    }
1981
1982    fn clear_pixels(&mut self) -> bool {
1983        if !self.state.is_editable() {
1984            self.publish_canvas_availability();
1985            return false;
1986        }
1987        let mut edits = Vec::new();
1988        for (index, pixel) in self.pixels.iter_mut().enumerate() {
1989            if *pixel == PixelColor::TRANSPARENT {
1990                continue;
1991            }
1992            let before = *pixel;
1993            *pixel = PixelColor::TRANSPARENT;
1994            edits.push(PixelEdit {
1995                index,
1996                before,
1997                after: PixelColor::TRANSPARENT,
1998            });
1999        }
2000        if edits.is_empty() {
2001            self.publish_canvas_availability();
2002            return false;
2003        }
2004        self.has_visible_pixels = false;
2005        self.mark_pixels_changed();
2006        self.push_history(edits);
2007        true
2008    }
2009
2010    fn apply_pending_history_commands(&mut self) -> bool {
2011        let mut changed = false;
2012        while let Some(command) = self.state.take_history_command() {
2013            changed |= match command {
2014                PixelCanvasHistoryCommand::Undo => self.undo(),
2015                PixelCanvasHistoryCommand::Redo => self.redo(),
2016            };
2017        }
2018        changed
2019    }
2020
2021    fn apply_pending_clear_requests(&mut self) -> bool {
2022        if self.state.take_clear_request() {
2023            self.clear_pixels()
2024        } else {
2025            false
2026        }
2027    }
2028
2029    fn fit_view_to_bounds(&mut self, bounds: Rect) -> bool {
2030        if bounds.is_empty() {
2031            return false;
2032        }
2033        let padding = self.resolved_theme().metrics.pixel_canvas_fit_padding;
2034        let (sin, cos) = self.viewport.rotation.sin_cos();
2035        let rotated_width = (self.width as f32 * cos.abs()) + (self.height as f32 * sin.abs());
2036        let rotated_height = (self.width as f32 * sin.abs()) + (self.height as f32 * cos.abs());
2037        let available_width = (bounds.width() - (padding * 2.0)).max(1.0);
2038        let available_height = (bounds.height() - (padding * 2.0)).max(1.0);
2039        let zoom = (available_width / rotated_width.max(1.0))
2040            .min(available_height / rotated_height.max(1.0))
2041            .max(0.01);
2042        let next = CanvasViewport {
2043            pan: Vector::ZERO,
2044            zoom,
2045            rotation: self.viewport.rotation,
2046        };
2047        if self.viewport == next {
2048            return false;
2049        }
2050        self.viewport = next;
2051        true
2052    }
2053
2054    fn set_actual_size_view(&mut self) -> bool {
2055        let next = CanvasViewport {
2056            pan: Vector::ZERO,
2057            zoom: 1.0,
2058            rotation: self.viewport.rotation,
2059        };
2060        if self.viewport == next {
2061            return false;
2062        }
2063        self.viewport = next;
2064        true
2065    }
2066
2067    fn zoom_view_around_center(&mut self, bounds: Rect, factor: f32) -> bool {
2068        if bounds.is_empty() {
2069            return false;
2070        }
2071        let previous = self.viewport;
2072        self.viewport.zoom_around(
2073            bounds,
2074            CanvasViewport::center(bounds),
2075            factor,
2076            self.document_origin(),
2077        );
2078        self.viewport != previous
2079    }
2080
2081    fn apply_pending_viewport_commands(&mut self, bounds: Rect) -> bool {
2082        let mut changed = false;
2083        let zoom_step = self.resolved_theme().metrics.pixel_canvas_zoom_step;
2084        while let Some(command) = self.state.take_viewport_command() {
2085            changed |= match command {
2086                PixelCanvasViewportCommand::Fit => self.fit_view_to_bounds(bounds),
2087                PixelCanvasViewportCommand::ActualSize => self.set_actual_size_view(),
2088                PixelCanvasViewportCommand::ZoomIn => {
2089                    self.zoom_view_around_center(bounds, zoom_step)
2090                }
2091                PixelCanvasViewportCommand::ZoomOut => {
2092                    self.zoom_view_around_center(bounds, 1.0 / zoom_step)
2093                }
2094            };
2095        }
2096        changed
2097    }
2098
2099    fn apply_initial_fit(&mut self, bounds: Rect) -> bool {
2100        if !self.fit_on_first_layout || self.initial_fit_applied || bounds.is_empty() {
2101            return false;
2102        }
2103        self.initial_fit_applied = true;
2104        self.fit_view_to_bounds(bounds)
2105    }
2106
2107    fn apply_pending_export_requests(&self) -> bool {
2108        if !self.state.take_export_request() {
2109            return false;
2110        }
2111
2112        self.state.publish_export_snapshot(
2113            self.name.clone(),
2114            self.width,
2115            self.height,
2116            self.export_image_data(),
2117        );
2118        true
2119    }
2120
2121    fn export_image_data(&self) -> Vec<u8> {
2122        self.paint_image().bytes().to_vec()
2123    }
2124
2125    fn paint_image(&self) -> RegisteredImage {
2126        let theme = self.resolved_theme();
2127        let display = self.state.display();
2128        let paper = self.state.paper();
2129        let display_above_paper = self.state.display_above_paper();
2130        let paper_color = self.resolved_paper_color(&theme);
2131        self.paint_image_for_source(Self::image_source(
2132            display,
2133            paper,
2134            display_above_paper,
2135            paper_color,
2136        ))
2137    }
2138
2139    fn raw_paint_image(&self) -> RegisteredImage {
2140        self.paint_image_for_source(PixelCanvasImageSource::Raw)
2141    }
2142
2143    fn image_source(
2144        display: PixelCanvasDisplaySettings,
2145        paper: PixelCanvasPaperSettings,
2146        display_above_paper: bool,
2147        paper_color: Color,
2148    ) -> PixelCanvasImageSource {
2149        if display.requires_compositing() || paper.requires_compositing() || !display_above_paper {
2150            PixelCanvasImageSource::Composited {
2151                display,
2152                paper,
2153                display_above_paper,
2154                paper_color,
2155            }
2156        } else {
2157            PixelCanvasImageSource::Raw
2158        }
2159    }
2160
2161    fn can_paint_with_image_opacity(
2162        display: PixelCanvasDisplaySettings,
2163        paper: PixelCanvasPaperSettings,
2164        display_above_paper: bool,
2165    ) -> bool {
2166        display_above_paper
2167            && display.visible
2168            && display.blend_mode == PixelCanvasBlendMode::Normal
2169            && paper.visible
2170            && paper.opacity >= 0.999
2171    }
2172
2173    fn paint_image_for_source(&self, source: PixelCanvasImageSource) -> RegisteredImage {
2174        let key = PixelCanvasImageCacheKey {
2175            pixel_revision: self.pixel_revision,
2176            source,
2177        };
2178
2179        if let Some(cache) = self.paint_image_cache.borrow().as_ref()
2180            && cache.key == key
2181        {
2182            return cache.image.clone();
2183        }
2184
2185        let data = match source {
2186            PixelCanvasImageSource::Raw => self.image_data(),
2187            PixelCanvasImageSource::Composited {
2188                display,
2189                paper,
2190                display_above_paper,
2191                paper_color,
2192            } => self.display_image_data(display, paper, display_above_paper, paper_color),
2193        };
2194        let image = RegisteredImage::from_rgba8(self.width as u32, self.height as u32, data)
2195            .expect("pixel canvas image data should match its dimensions")
2196            .without_mipmaps();
2197        *self.paint_image_cache.borrow_mut() = Some(PixelCanvasImageCache {
2198            key,
2199            image: image.clone(),
2200        });
2201        image
2202    }
2203
2204    fn image_data(&self) -> Vec<u8> {
2205        let mut data = Vec::with_capacity(self.pixels.len() * 4);
2206        for pixel in &self.pixels {
2207            data.extend_from_slice(&[pixel.red, pixel.green, pixel.blue, pixel.alpha]);
2208        }
2209        data
2210    }
2211
2212    fn display_image_data(
2213        &self,
2214        display: PixelCanvasDisplaySettings,
2215        paper: PixelCanvasPaperSettings,
2216        display_above_paper: bool,
2217        paper_color: Color,
2218    ) -> Vec<u8> {
2219        let paper = paper.pixel(paper_color);
2220        let mut data = Vec::with_capacity(self.pixels.len() * 4);
2221        for pixel in &self.pixels {
2222            let mut output = PixelColor::TRANSPARENT;
2223            if display_above_paper {
2224                output = output.compose(paper.to_color(), 1.0, PixelCanvasBlendMode::Normal);
2225                if display.visible {
2226                    output = output.compose(pixel.to_color(), display.opacity, display.blend_mode);
2227                }
2228            } else {
2229                if display.visible {
2230                    output = output.compose(pixel.to_color(), display.opacity, display.blend_mode);
2231                }
2232                output = output.compose(paper.to_color(), 1.0, PixelCanvasBlendMode::Normal);
2233            }
2234            data.extend_from_slice(&[output.red, output.green, output.blue, output.alpha]);
2235        }
2236        data
2237    }
2238
2239    fn request_interaction_update(ctx: &mut EventCtx) {
2240        ctx.request_paint();
2241        ctx.request_semantics();
2242    }
2243
2244    fn resolved_theme(&self) -> DefaultTheme {
2245        self.theme_reader
2246            .as_ref()
2247            .map(|theme| theme())
2248            .unwrap_or(self.theme)
2249    }
2250
2251    fn resolved_paper_color(&self, theme: &DefaultTheme) -> Color {
2252        self.paper_color
2253            .unwrap_or(theme.surfaces.pixel_canvas_paper)
2254    }
2255}
2256
2257impl Widget for PixelCanvas {
2258    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
2259        let history_changed = self.apply_pending_history_commands();
2260        let viewport_changed = self.apply_pending_viewport_commands(ctx.bounds());
2261        let clear_changed = self.apply_pending_clear_requests();
2262        let export_changed = self.apply_pending_export_requests();
2263        let availability_changed = self.publish_canvas_availability();
2264        if viewport_changed {
2265            self.publish_viewport_state(ctx.bounds());
2266        }
2267        if history_changed
2268            || viewport_changed
2269            || clear_changed
2270            || export_changed
2271            || availability_changed
2272        {
2273            Self::request_interaction_update(ctx);
2274        }
2275        match event {
2276            Event::Pointer(pointer)
2277                if matches!(
2278                    pointer.kind,
2279                    PointerEventKind::Move
2280                        | PointerEventKind::Down
2281                        | PointerEventKind::Scroll
2282                        | PointerEventKind::Up
2283                ) =>
2284            {
2285                if self.publish_cursor_position(ctx.bounds(), pointer.position) {
2286                    Self::request_interaction_update(ctx);
2287                }
2288            }
2289            Event::Pointer(pointer)
2290                if matches!(
2291                    pointer.kind,
2292                    PointerEventKind::Leave | PointerEventKind::Cancel
2293                ) && self.clear_cursor_position() =>
2294            {
2295                Self::request_interaction_update(ctx);
2296            }
2297            _ => {}
2298        }
2299
2300        match event {
2301            Event::Pointer(pointer)
2302                if pointer.kind == PointerEventKind::Scroll
2303                    && ctx.bounds().contains(pointer.position) =>
2304            {
2305                let delta = scroll_delta_to_offset(pointer.scroll_delta, pointer.delta);
2306                if pointer.modifiers.shift {
2307                    self.viewport.rotate_around(
2308                        ctx.bounds(),
2309                        pointer.position,
2310                        delta.y * 0.01,
2311                        self.document_origin(),
2312                    );
2313                } else {
2314                    self.viewport.zoom_around(
2315                        ctx.bounds(),
2316                        pointer.position,
2317                        (delta.y * 0.002).exp(),
2318                        self.document_origin(),
2319                    );
2320                }
2321                self.publish_viewport_state(ctx.bounds());
2322                Self::request_interaction_update(ctx);
2323                ctx.set_handled();
2324            }
2325            Event::Pointer(pointer)
2326                if pointer.kind == PointerEventKind::Down
2327                    && ctx.bounds().contains(pointer.position)
2328                    && matches!(
2329                        pointer.button,
2330                        Some(PointerButton::Middle | PointerButton::Secondary)
2331                    ) =>
2332            {
2333                self.drag = Some(PixelCanvasDrag::Pan {
2334                    pointer_id: pointer.pointer_id,
2335                    last_position: pointer.position,
2336                });
2337                ctx.request_focus();
2338                ctx.request_pointer_capture(pointer.pointer_id);
2339                Self::request_interaction_update(ctx);
2340                ctx.set_handled();
2341            }
2342            Event::Pointer(pointer)
2343                if pointer.kind == PointerEventKind::Down
2344                    && pointer.button == Some(PointerButton::Primary)
2345                    && ctx.bounds().contains(pointer.position) =>
2346            {
2347                let editable = self.state.is_editable();
2348                match self.state.tool() {
2349                    PixelCanvasTool::Brush | PixelCanvasTool::Eraser if editable => {
2350                        let mut edits = Vec::new();
2351                        self.paint_at_position(ctx.bounds(), pointer.position, &mut edits);
2352                        self.active_edits = edits;
2353                        self.drag = Some(PixelCanvasDrag::Paint {
2354                            pointer_id: pointer.pointer_id,
2355                            last_position: pointer.position,
2356                        });
2357                    }
2358                    PixelCanvasTool::Fill if editable => {
2359                        let mut edits = Vec::new();
2360                        self.fill_at_position(ctx.bounds(), pointer.position, &mut edits);
2361                        self.push_history(edits);
2362                    }
2363                    PixelCanvasTool::Brush | PixelCanvasTool::Eraser | PixelCanvasTool::Fill => {}
2364                    PixelCanvasTool::Pan => {
2365                        self.drag = Some(PixelCanvasDrag::Pan {
2366                            pointer_id: pointer.pointer_id,
2367                            last_position: pointer.position,
2368                        });
2369                    }
2370                }
2371                ctx.request_focus();
2372                if self.drag.is_some() {
2373                    ctx.request_pointer_capture(pointer.pointer_id);
2374                }
2375                Self::request_interaction_update(ctx);
2376                ctx.set_handled();
2377            }
2378            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => match self.drag {
2379                Some(PixelCanvasDrag::Pan {
2380                    pointer_id,
2381                    mut last_position,
2382                }) if pointer_id == pointer.pointer_id => {
2383                    let delta = pointer.position - last_position;
2384                    self.viewport.pan += delta;
2385                    last_position = pointer.position;
2386                    self.drag = Some(PixelCanvasDrag::Pan {
2387                        pointer_id,
2388                        last_position,
2389                    });
2390                    self.publish_viewport_state(ctx.bounds());
2391                    Self::request_interaction_update(ctx);
2392                    ctx.set_handled();
2393                }
2394                Some(PixelCanvasDrag::Paint {
2395                    pointer_id,
2396                    last_position,
2397                }) if pointer_id == pointer.pointer_id && self.state.is_editable() => {
2398                    let mut edits = std::mem::take(&mut self.active_edits);
2399                    self.paint_between_positions(
2400                        ctx.bounds(),
2401                        last_position,
2402                        pointer.position,
2403                        &mut edits,
2404                    );
2405                    self.active_edits = edits;
2406                    self.drag = Some(PixelCanvasDrag::Paint {
2407                        pointer_id,
2408                        last_position: pointer.position,
2409                    });
2410                    Self::request_interaction_update(ctx);
2411                    ctx.set_handled();
2412                }
2413                _ => {}
2414            },
2415            Event::Pointer(pointer)
2416                if pointer.kind == PointerEventKind::Up
2417                    || pointer.kind == PointerEventKind::Cancel =>
2418            {
2419                let active_pointer = match self.drag {
2420                    Some(
2421                        PixelCanvasDrag::Pan { pointer_id, .. }
2422                        | PixelCanvasDrag::Paint { pointer_id, .. },
2423                    ) => Some(pointer_id),
2424                    None => None,
2425                };
2426                if active_pointer == Some(pointer.pointer_id) {
2427                    if let Some(PixelCanvasDrag::Paint { last_position, .. }) = self.drag {
2428                        let mut edits = std::mem::take(&mut self.active_edits);
2429                        if pointer.kind == PointerEventKind::Up && self.state.is_editable() {
2430                            self.paint_between_positions(
2431                                ctx.bounds(),
2432                                last_position,
2433                                pointer.position,
2434                                &mut edits,
2435                            );
2436                        }
2437                        self.push_history(edits);
2438                    }
2439                    self.drag = None;
2440                    ctx.release_pointer_capture(pointer.pointer_id);
2441                    Self::request_interaction_update(ctx);
2442                    ctx.set_handled();
2443                }
2444            }
2445            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
2446                let command_modifier = key.modifiers.control || key.modifiers.meta;
2447                if command_modifier && matches!(key.key.as_str(), "z" | "Z") {
2448                    let changed = if key.modifiers.shift {
2449                        self.redo()
2450                    } else {
2451                        self.undo()
2452                    };
2453                    if changed {
2454                        Self::request_interaction_update(ctx);
2455                    }
2456                    ctx.set_handled();
2457                    return;
2458                }
2459                if command_modifier && matches!(key.key.as_str(), "y" | "Y") {
2460                    if self.redo() {
2461                        Self::request_interaction_update(ctx);
2462                    }
2463                    ctx.set_handled();
2464                    return;
2465                }
2466                let zoom_step = self.resolved_theme().metrics.pixel_canvas_zoom_step;
2467                match key.key.as_str() {
2468                    "=" | "+" => self.viewport.zoom_around(
2469                        ctx.bounds(),
2470                        CanvasViewport::center(ctx.bounds()),
2471                        zoom_step,
2472                        self.document_origin(),
2473                    ),
2474                    "-" => self.viewport.zoom_around(
2475                        ctx.bounds(),
2476                        CanvasViewport::center(ctx.bounds()),
2477                        1.0 / zoom_step,
2478                        self.document_origin(),
2479                    ),
2480                    "[" => self.viewport.rotate_around(
2481                        ctx.bounds(),
2482                        CanvasViewport::center(ctx.bounds()),
2483                        -0.1,
2484                        self.document_origin(),
2485                    ),
2486                    "]" => self.viewport.rotate_around(
2487                        ctx.bounds(),
2488                        CanvasViewport::center(ctx.bounds()),
2489                        0.1,
2490                        self.document_origin(),
2491                    ),
2492                    "ArrowLeft" => self.viewport.pan.x += 24.0,
2493                    "ArrowRight" => self.viewport.pan.x -= 24.0,
2494                    "ArrowUp" => self.viewport.pan.y += 24.0,
2495                    "ArrowDown" => self.viewport.pan.y -= 24.0,
2496                    _ => return,
2497                }
2498                self.publish_viewport_state(ctx.bounds());
2499                Self::request_interaction_update(ctx);
2500                ctx.set_handled();
2501            }
2502            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
2503                if self.focus_animation.advance(*time) {
2504                    ctx.request_animation_frame();
2505                }
2506                ctx.request_paint();
2507            }
2508            _ => {}
2509        }
2510    }
2511
2512    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
2513        if self.apply_pending_history_commands() {
2514            ctx.request_paint();
2515            ctx.request_semantics();
2516        }
2517        if self.apply_pending_clear_requests() {
2518            ctx.request_paint();
2519            ctx.request_semantics();
2520        }
2521        if self.apply_pending_export_requests() {
2522            ctx.request_semantics();
2523        }
2524        if self.publish_canvas_availability() {
2525            ctx.request_semantics();
2526        }
2527
2528        constraints.clamp(Size::new(
2529            if constraints.max.width.is_finite() {
2530                constraints.max.width
2531            } else {
2532                self.desired_size.width
2533            },
2534            if constraints.max.height.is_finite() {
2535                constraints.max.height
2536            } else {
2537                self.desired_size.height
2538            },
2539        ))
2540    }
2541
2542    fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
2543        let viewport_changed =
2544            self.apply_initial_fit(bounds) || self.apply_pending_viewport_commands(bounds);
2545        let state_changed = self.publish_viewport_state(bounds);
2546        if viewport_changed || state_changed {
2547            ctx.request_paint();
2548            ctx.request_semantics();
2549        }
2550    }
2551
2552    fn paint(&self, ctx: &mut PaintCtx) {
2553        let theme = self.resolved_theme();
2554        ctx.fill_bounds(theme.surfaces.canvas);
2555        ctx.stroke_bounds(
2556            theme.surfaces.border,
2557            StrokeStyle::new(theme.metrics.border_width),
2558        );
2559        ctx.push_clip_rect(ctx.bounds());
2560        let transform = self
2561            .viewport
2562            .transform(ctx.bounds(), self.document_origin());
2563        let image_bounds = Rect::new(0.0, 0.0, self.width as f32, self.height as f32);
2564        paint_pixel_canvas_document_shadow(ctx, image_bounds, transform, &theme);
2565        let paper_color = self.resolved_paper_color(&theme);
2566        let display = self.state.display();
2567        let paper = self.state.paper();
2568        let display_above_paper = self.state.display_above_paper();
2569        let image_handle = ctx.widget_image_handle(0);
2570        let sampling = if self.viewport.zoom >= theme.metrics.pixel_canvas_nearest_sampling_zoom {
2571            ImageSampling::Nearest
2572        } else {
2573            ImageSampling::Linear
2574        };
2575        if Self::can_paint_with_image_opacity(display, paper, display_above_paper) {
2576            fill_transformed_rect(ctx, image_bounds, transform, paper_color);
2577            ctx.register_image(image_handle, self.raw_paint_image());
2578            ctx.draw_image_quad_source(
2579                transformed_rect_points(image_bounds, transform),
2580                ImageSource::new(image_handle)
2581                    .with_sampling(sampling)
2582                    .with_tint(Color::WHITE.with_alpha(display.opacity)),
2583            );
2584        } else {
2585            let baked_image = display.requires_compositing()
2586                || paper.requires_compositing()
2587                || !display_above_paper;
2588            if !baked_image {
2589                fill_transformed_rect(ctx, image_bounds, transform, paper_color);
2590            }
2591            ctx.register_image(image_handle, self.paint_image());
2592            ctx.draw_image_quad_source(
2593                transformed_rect_points(image_bounds, transform),
2594                ImageSource::new(image_handle).with_sampling(sampling),
2595            );
2596        }
2597        if self.viewport.zoom >= theme.metrics.pixel_canvas_grid_zoom
2598            && let Some(range) = pixel_visible_range(
2599                self.viewport,
2600                ctx.bounds(),
2601                self.document_origin(),
2602                self.width,
2603                self.height,
2604            )
2605        {
2606            paint_pixel_grid(ctx, range, transform, theme.surfaces.pixel_canvas_grid);
2607        }
2608        ctx.stroke(
2609            transformed_rect_path(image_bounds, transform),
2610            theme.surfaces.pixel_canvas_document_edge,
2611            StrokeStyle::new(1.0),
2612        );
2613        ctx.pop_clip();
2614        draw_focus_ring(ctx, ctx.bounds(), &theme, self.focus_animation.value);
2615    }
2616
2617    fn semantics(&self, ctx: &mut SemanticsCtx) {
2618        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Canvas, ctx.bounds());
2619        node.name = Some(self.name.clone());
2620        node.description = Some(format!("{} by {} pixel canvas", self.width, self.height));
2621        let tool = self.state.tool();
2622        let brush_size = self.state.brush_size();
2623        let brush_opacity = self.state.brush_opacity();
2624        let brush_shape = self.state.brush_shape();
2625        let blend_mode = self.state.blend_mode();
2626        let editable = self.state.is_editable();
2627        let display = self.state.display();
2628        let paper = self.state.paper();
2629        node.value = Some(SemanticsValue::Text(format!(
2630            "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}%, {}",
2631            tool.label(),
2632            self.viewport.zoom * 100.0,
2633            self.viewport.rotation.to_degrees(),
2634            brush_size,
2635            brush_shape.label(),
2636            brush_opacity * 100.0,
2637            blend_mode.label(),
2638            if display.visible { "visible" } else { "hidden" },
2639            display.opacity * 100.0,
2640            display.blend_mode.label(),
2641            if paper.visible { "visible" } else { "hidden" },
2642            paper.opacity * 100.0,
2643            if editable { "editable" } else { "read only" }
2644        )));
2645        node.state.focused = ctx.is_focused();
2646        node.actions = vec![
2647            SemanticsAction::Focus,
2648            SemanticsAction::Custom("Pan".into()),
2649        ];
2650        if editable {
2651            node.actions.push(SemanticsAction::Custom("Paint".into()));
2652        }
2653        if editable && self.state.can_undo() {
2654            node.actions.push(SemanticsAction::Undo);
2655        }
2656        if editable && self.state.can_redo() {
2657            node.actions.push(SemanticsAction::Redo);
2658        }
2659        ctx.push(node);
2660    }
2661
2662    fn accepts_focus(&self) -> bool {
2663        true
2664    }
2665
2666    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
2667        let theme = self.resolved_theme();
2668        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
2669        Self::request_interaction_update(ctx);
2670    }
2671}
2672
2673fn fill_transformed_rect(ctx: &mut PaintCtx, rect: Rect, transform: Transform, color: Color) {
2674    if transform.yx.abs() < AXIS_ALIGNED_EPSILON && transform.xy.abs() < AXIS_ALIGNED_EPSILON {
2675        ctx.fill_rect(transform.transform_rect_bbox(rect), color);
2676    } else {
2677        ctx.fill(transformed_rect_path(rect, transform), color);
2678    }
2679}
2680
2681fn paint_pixel_canvas_document_shadow(
2682    ctx: &mut PaintCtx,
2683    rect: Rect,
2684    transform: Transform,
2685    theme: &DefaultTheme,
2686) {
2687    fill_transformed_rect(
2688        ctx,
2689        rect,
2690        transform.then(Transform::translation(0.0, 7.0)),
2691        theme.surfaces.pixel_canvas_shadow_far,
2692    );
2693    fill_transformed_rect(
2694        ctx,
2695        rect,
2696        transform.then(Transform::translation(0.0, 3.0)),
2697        theme.surfaces.pixel_canvas_shadow_near,
2698    );
2699}
2700
2701fn paint_canvas_ruler_divider(
2702    ctx: &mut PaintCtx,
2703    bounds: Rect,
2704    axis: CanvasRulerAxis,
2705    color: Color,
2706) {
2707    match axis {
2708        CanvasRulerAxis::Horizontal => {
2709            stroke_line(
2710                ctx,
2711                Point::new(bounds.x(), bounds.max_y()),
2712                Point::new(bounds.max_x(), bounds.max_y()),
2713                color,
2714                1.0,
2715            );
2716        }
2717        CanvasRulerAxis::Vertical => {
2718            stroke_line(
2719                ctx,
2720                Point::new(bounds.max_x(), bounds.y()),
2721                Point::new(bounds.max_x(), bounds.max_y()),
2722                color,
2723                1.0,
2724            );
2725        }
2726    }
2727}
2728
2729fn paint_canvas_ruler_ticks(
2730    ctx: &mut PaintCtx,
2731    bounds: Rect,
2732    axis: CanvasRulerAxis,
2733    document_size: Size,
2734    viewport: CanvasViewport,
2735    viewport_size: Size,
2736    theme: &DefaultTheme,
2737    text_style: TextStyle,
2738) {
2739    let canvas_bounds = ruler_canvas_bounds(bounds, axis, viewport_size);
2740    let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
2741    let visible = ruler_visible_range(bounds, axis, document_size, viewport, canvas_bounds);
2742    let major_step = ruler_major_step(
2743        viewport.zoom,
2744        theme.metrics.canvas_ruler_target_major_spacing,
2745    );
2746    let minor_step = (major_step / 5.0).max(1.0);
2747    let start = (visible.0 / minor_step).floor() * minor_step;
2748    let end = visible.1 + minor_step;
2749    let mut value = start;
2750    let mut count = 0;
2751
2752    while value <= end && count < CANVAS_RULER_MAX_TICKS {
2753        if value >= 0.0 && value <= ruler_document_length(axis, document_size) {
2754            let major = is_major_ruler_tick(value, major_step);
2755            let position = ruler_tick_screen_position(
2756                axis,
2757                value,
2758                document_size,
2759                viewport,
2760                canvas_bounds,
2761                document_origin,
2762            );
2763            if ruler_position_in_bounds(position, bounds, axis) {
2764                paint_canvas_ruler_tick(
2765                    ctx,
2766                    bounds,
2767                    axis,
2768                    position,
2769                    major,
2770                    theme.surfaces.canvas_ruler_tick,
2771                    theme.metrics.canvas_ruler_major_tick,
2772                    theme.metrics.canvas_ruler_minor_tick,
2773                );
2774                if major {
2775                    paint_canvas_ruler_label(
2776                        ctx,
2777                        bounds,
2778                        axis,
2779                        position,
2780                        value,
2781                        text_style.clone(),
2782                        theme.metrics.canvas_ruler_label_padding,
2783                        theme.metrics.canvas_ruler_label_max_width,
2784                    );
2785                }
2786            }
2787        }
2788
2789        value += minor_step;
2790        count += 1;
2791    }
2792}
2793
2794fn ruler_canvas_bounds(bounds: Rect, axis: CanvasRulerAxis, viewport_size: Size) -> Rect {
2795    match axis {
2796        CanvasRulerAxis::Horizontal => Rect::new(
2797            bounds.x(),
2798            bounds.y(),
2799            bounds.width(),
2800            viewport_size.height.max(bounds.height()),
2801        ),
2802        CanvasRulerAxis::Vertical => Rect::new(
2803            bounds.x(),
2804            bounds.y(),
2805            viewport_size.width.max(bounds.width()),
2806            bounds.height(),
2807        ),
2808    }
2809}
2810
2811fn ruler_visible_range(
2812    bounds: Rect,
2813    axis: CanvasRulerAxis,
2814    document_size: Size,
2815    viewport: CanvasViewport,
2816    canvas_bounds: Rect,
2817) -> (f32, f32) {
2818    let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
2819    let center = CanvasViewport::center(canvas_bounds);
2820    let (start, end) = match axis {
2821        CanvasRulerAxis::Horizontal => (
2822            viewport
2823                .screen_to_world(
2824                    canvas_bounds,
2825                    Point::new(bounds.x(), center.y),
2826                    document_origin,
2827                )
2828                .x,
2829            viewport
2830                .screen_to_world(
2831                    canvas_bounds,
2832                    Point::new(bounds.max_x(), center.y),
2833                    document_origin,
2834                )
2835                .x,
2836        ),
2837        CanvasRulerAxis::Vertical => (
2838            viewport
2839                .screen_to_world(
2840                    canvas_bounds,
2841                    Point::new(center.x, bounds.y()),
2842                    document_origin,
2843                )
2844                .y,
2845            viewport
2846                .screen_to_world(
2847                    canvas_bounds,
2848                    Point::new(center.x, bounds.max_y()),
2849                    document_origin,
2850                )
2851                .y,
2852        ),
2853    };
2854
2855    (start.min(end), start.max(end))
2856}
2857
2858fn ruler_major_step(zoom: f32, target_major_spacing: f32) -> f32 {
2859    let target_world = (target_major_spacing.max(1.0) / zoom.max(0.01)).max(1.0);
2860    let magnitude = 10.0_f32.powf(target_world.log10().floor());
2861    for multiplier in [1.0, 2.0, 5.0, 10.0] {
2862        let step = multiplier * magnitude;
2863        if step >= target_world {
2864            return step;
2865        }
2866    }
2867    10.0 * magnitude
2868}
2869
2870fn ruler_document_length(axis: CanvasRulerAxis, document_size: Size) -> f32 {
2871    match axis {
2872        CanvasRulerAxis::Horizontal => document_size.width,
2873        CanvasRulerAxis::Vertical => document_size.height,
2874    }
2875}
2876
2877fn is_major_ruler_tick(value: f32, major_step: f32) -> bool {
2878    let nearest = (value / major_step).round() * major_step;
2879    (value - nearest).abs() < 0.01
2880}
2881
2882fn ruler_tick_screen_position(
2883    axis: CanvasRulerAxis,
2884    value: f32,
2885    document_size: Size,
2886    viewport: CanvasViewport,
2887    canvas_bounds: Rect,
2888    document_origin: Point,
2889) -> f32 {
2890    match axis {
2891        CanvasRulerAxis::Horizontal => {
2892            viewport
2893                .world_to_screen(
2894                    canvas_bounds,
2895                    Point::new(value, document_size.height * 0.5),
2896                    document_origin,
2897                )
2898                .x
2899        }
2900        CanvasRulerAxis::Vertical => {
2901            viewport
2902                .world_to_screen(
2903                    canvas_bounds,
2904                    Point::new(document_size.width * 0.5, value),
2905                    document_origin,
2906                )
2907                .y
2908        }
2909    }
2910}
2911
2912fn ruler_position_in_bounds(position: f32, bounds: Rect, axis: CanvasRulerAxis) -> bool {
2913    match axis {
2914        CanvasRulerAxis::Horizontal => position >= bounds.x() && position <= bounds.max_x(),
2915        CanvasRulerAxis::Vertical => position >= bounds.y() && position <= bounds.max_y(),
2916    }
2917}
2918
2919fn paint_canvas_ruler_tick(
2920    ctx: &mut PaintCtx,
2921    bounds: Rect,
2922    axis: CanvasRulerAxis,
2923    position: f32,
2924    major: bool,
2925    color: Color,
2926    major_length: f32,
2927    minor_length: f32,
2928) {
2929    let length = if major { major_length } else { minor_length };
2930    match axis {
2931        CanvasRulerAxis::Horizontal => stroke_line(
2932            ctx,
2933            Point::new(position, bounds.max_y()),
2934            Point::new(position, bounds.max_y() - length),
2935            color,
2936            1.0,
2937        ),
2938        CanvasRulerAxis::Vertical => stroke_line(
2939            ctx,
2940            Point::new(bounds.max_x(), position),
2941            Point::new(bounds.max_x() - length, position),
2942            color,
2943            1.0,
2944        ),
2945    }
2946}
2947
2948fn paint_canvas_ruler_label(
2949    ctx: &mut PaintCtx,
2950    bounds: Rect,
2951    axis: CanvasRulerAxis,
2952    position: f32,
2953    value: f32,
2954    mut style: TextStyle,
2955    padding: sui_layout::Padding,
2956    max_width: f32,
2957) {
2958    style.features.enable(FontFeature::TABULAR_FIGURES);
2959
2960    let label = format!("{value:.0}");
2961    let measurement = paint_text_measurement(ctx, &label, &style);
2962    let available_height = (bounds.height() - padding.top - padding.bottom).max(0.0);
2963    let slot = match axis {
2964        CanvasRulerAxis::Horizontal => Rect::new(
2965            position + padding.left,
2966            bounds.y() + padding.top,
2967            max_width.min((bounds.max_x() - position - padding.left).max(0.0)),
2968            available_height,
2969        ),
2970        CanvasRulerAxis::Vertical => {
2971            let height = style
2972                .line_height
2973                .max(measurement.height)
2974                .min(available_height);
2975            let min_y = bounds.y() + padding.top;
2976            let max_y = (bounds.max_y() - padding.bottom - height).max(min_y);
2977            Rect::new(
2978                bounds.x() + padding.left,
2979                (position - (height * 0.5)).clamp(min_y, max_y),
2980                max_width.min((bounds.width() - padding.left - padding.right).max(0.0)),
2981                height,
2982            )
2983        }
2984    };
2985
2986    if slot.width() <= 0.0 || slot.height() <= 0.0 {
2987        return;
2988    }
2989
2990    if measurement.width <= slot.width() {
2991        let width = measurement.width.min(slot.width()).max(0.0);
2992        paint_aligned_text(
2993            ctx,
2994            Rect::new(slot.x(), slot.y(), width, slot.height()),
2995            &label,
2996            &style,
2997            style.line_height,
2998            0.0,
2999        );
3000    }
3001}
3002
3003fn paint_text_measurement(ctx: &PaintCtx, text: &str, style: &TextStyle) -> TextMeasurement {
3004    ctx.measure_text(text.to_string(), style.clone())
3005        .unwrap_or(TextMeasurement {
3006            width: text.chars().count() as f32 * style.font_size * 0.58,
3007            height: style.line_height,
3008            bounds: Rect::new(
3009                0.0,
3010                0.0,
3011                text.chars().count() as f32 * style.font_size * 0.58,
3012                style.line_height,
3013            ),
3014            ascent: style.font_size * 0.8,
3015            descent: style.font_size * 0.2,
3016            cap_height: Some(style.font_size),
3017        })
3018}
3019
3020fn stroke_line(ctx: &mut PaintCtx, from: Point, to: Point, color: Color, width: f32) {
3021    let mut path = PathBuilder::new();
3022    path.move_to(from).line_to(to);
3023    ctx.stroke(path.build(), color, StrokeStyle::new(width));
3024}
3025
3026fn scroll_delta_to_offset(scroll_delta: Option<ScrollDelta>, fallback: Vector) -> Vector {
3027    match scroll_delta {
3028        Some(ScrollDelta::Pixels(delta)) => delta,
3029        Some(ScrollDelta::Lines(delta)) => Vector::new(delta.x * 24.0, delta.y * 24.0),
3030        None => fallback,
3031    }
3032}
3033
3034fn vector_length(vector: Vector) -> f32 {
3035    ((vector.x * vector.x) + (vector.y * vector.y)).sqrt()
3036}
3037
3038fn path_from_points(points: &[Point]) -> Option<Path> {
3039    let first = points.first().copied()?;
3040    let mut builder = PathBuilder::new();
3041    builder.move_to(first);
3042    for point in &points[1..] {
3043        builder.line_to(*point);
3044    }
3045    Some(builder.build())
3046}
3047
3048fn paint_canvas_shape(
3049    ctx: &mut PaintCtx,
3050    shape: &CanvasShape,
3051    transform: Transform,
3052    stroke_scale: f32,
3053) {
3054    match shape {
3055        CanvasShape::Path { path, fill, stroke } => {
3056            let path = transform_path(path, transform);
3057            if let Some(fill) = fill {
3058                ctx.fill(path.clone(), *fill);
3059            }
3060            if let Some(stroke) = stroke {
3061                ctx.stroke(
3062                    path,
3063                    stroke.color,
3064                    StrokeStyle::new((stroke.width * stroke_scale).max(0.5)),
3065                );
3066            }
3067        }
3068    }
3069}
3070
3071fn paint_canvas_axes(
3072    ctx: &mut PaintCtx,
3073    viewport: CanvasViewport,
3074    bounds: Rect,
3075    document_origin: Point,
3076    theme: &DefaultTheme,
3077) {
3078    let overscan = theme.metrics.canvas_axis_overscan;
3079    let visible =
3080        canvas_visible_world_rect(viewport, bounds, document_origin).inflate(overscan, overscan);
3081    let transform = viewport.transform(bounds, document_origin);
3082    let mut x_axis = PathBuilder::new();
3083    x_axis
3084        .move_to(transform.transform_point(Point::new(visible.x(), 0.0)))
3085        .line_to(transform.transform_point(Point::new(visible.max_x(), 0.0)));
3086    ctx.stroke(
3087        x_axis.build(),
3088        theme.surfaces.canvas_axis_x,
3089        StrokeStyle::new(1.0),
3090    );
3091
3092    let mut y_axis = PathBuilder::new();
3093    y_axis
3094        .move_to(transform.transform_point(Point::new(0.0, visible.y())))
3095        .line_to(transform.transform_point(Point::new(0.0, visible.max_y())));
3096    ctx.stroke(
3097        y_axis.build(),
3098        theme.surfaces.canvas_axis_y,
3099        StrokeStyle::new(1.0),
3100    );
3101}
3102
3103fn paint_canvas_grid(
3104    ctx: &mut PaintCtx,
3105    viewport: CanvasViewport,
3106    bounds: Rect,
3107    document_origin: Point,
3108    theme: &DefaultTheme,
3109) {
3110    let overscan = theme.metrics.canvas_axis_overscan;
3111    let visible =
3112        canvas_visible_world_rect(viewport, bounds, document_origin).inflate(overscan, overscan);
3113    let transform = viewport.transform(bounds, document_origin);
3114    let step = theme.metrics.canvas_grid_step.max(1.0);
3115    let min_x = (visible.x() / step).floor() as i32 - 1;
3116    let max_x = (visible.max_x() / step).ceil() as i32 + 1;
3117    let min_y = (visible.y() / step).floor() as i32 - 1;
3118    let max_y = (visible.max_y() / step).ceil() as i32 + 1;
3119    let mut builder = PathBuilder::new();
3120    for x in min_x..=max_x {
3121        let x = x as f32 * step;
3122        builder
3123            .move_to(transform.transform_point(Point::new(x, visible.y())))
3124            .line_to(transform.transform_point(Point::new(x, visible.max_y())));
3125    }
3126    for y in min_y..=max_y {
3127        let y = y as f32 * step;
3128        builder
3129            .move_to(transform.transform_point(Point::new(visible.x(), y)))
3130            .line_to(transform.transform_point(Point::new(visible.max_x(), y)));
3131    }
3132    ctx.stroke(
3133        builder.build(),
3134        theme.surfaces.canvas_grid,
3135        StrokeStyle::new(1.0),
3136    );
3137}
3138
3139fn canvas_visible_world_rect(
3140    viewport: CanvasViewport,
3141    bounds: Rect,
3142    document_origin: Point,
3143) -> Rect {
3144    let points = [
3145        viewport.screen_to_world(bounds, bounds.origin, document_origin),
3146        viewport.screen_to_world(
3147            bounds,
3148            Point::new(bounds.max_x(), bounds.y()),
3149            document_origin,
3150        ),
3151        viewport.screen_to_world(
3152            bounds,
3153            Point::new(bounds.x(), bounds.max_y()),
3154            document_origin,
3155        ),
3156        viewport.screen_to_world(
3157            bounds,
3158            Point::new(bounds.max_x(), bounds.max_y()),
3159            document_origin,
3160        ),
3161    ];
3162    let min_x = points
3163        .iter()
3164        .map(|point| point.x)
3165        .fold(f32::INFINITY, f32::min);
3166    let min_y = points
3167        .iter()
3168        .map(|point| point.y)
3169        .fold(f32::INFINITY, f32::min);
3170    let max_x = points
3171        .iter()
3172        .map(|point| point.x)
3173        .fold(f32::NEG_INFINITY, f32::max);
3174    let max_y = points
3175        .iter()
3176        .map(|point| point.y)
3177        .fold(f32::NEG_INFINITY, f32::max);
3178    Rect::from_points(Point::new(min_x, min_y), Point::new(max_x, max_y))
3179}
3180
3181fn transform_path(path: &Path, transform: Transform) -> Path {
3182    let mut builder = PathBuilder::new();
3183    for element in path.elements() {
3184        match *element {
3185            PathElement::MoveTo(point) => {
3186                builder.move_to(transform.transform_point(point));
3187            }
3188            PathElement::LineTo(point) => {
3189                builder.line_to(transform.transform_point(point));
3190            }
3191            PathElement::QuadTo { ctrl, to } => {
3192                builder.quad_to(
3193                    transform.transform_point(ctrl),
3194                    transform.transform_point(to),
3195                );
3196            }
3197            PathElement::CubicTo { ctrl1, ctrl2, to } => {
3198                builder.cubic_to(
3199                    transform.transform_point(ctrl1),
3200                    transform.transform_point(ctrl2),
3201                    transform.transform_point(to),
3202                );
3203            }
3204            PathElement::Close => {
3205                builder.close();
3206            }
3207        }
3208    }
3209    builder.build()
3210}
3211
3212fn transformed_rect_path(rect: Rect, transform: Transform) -> Path {
3213    let points = transformed_rect_points(rect, transform);
3214    let mut builder = PathBuilder::new();
3215    builder
3216        .move_to(points[0])
3217        .line_to(points[1])
3218        .line_to(points[3])
3219        .line_to(points[2])
3220        .close();
3221    builder.build()
3222}
3223
3224fn transformed_rect_points(rect: Rect, transform: Transform) -> [Point; 4] {
3225    [
3226        transform.transform_point(rect.origin),
3227        transform.transform_point(Point::new(rect.max_x(), rect.y())),
3228        transform.transform_point(Point::new(rect.x(), rect.max_y())),
3229        transform.transform_point(Point::new(rect.max_x(), rect.max_y())),
3230    ]
3231}
3232
3233#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3234struct PixelRenderRange {
3235    start_x: usize,
3236    end_x: usize,
3237    start_y: usize,
3238    end_y: usize,
3239}
3240
3241fn pixel_visible_range(
3242    viewport: CanvasViewport,
3243    bounds: Rect,
3244    document_origin: Point,
3245    width: usize,
3246    height: usize,
3247) -> Option<PixelRenderRange> {
3248    let visible = canvas_visible_world_rect(viewport, bounds, document_origin)
3249        .intersection(Rect::new(0.0, 0.0, width as f32, height as f32))?;
3250    let start_x = visible.x().floor().max(0.0) as usize;
3251    let start_y = visible.y().floor().max(0.0) as usize;
3252    let end_x = visible.max_x().ceil().min(width as f32) as usize;
3253    let end_y = visible.max_y().ceil().min(height as f32) as usize;
3254    if start_x >= end_x || start_y >= end_y {
3255        return None;
3256    }
3257
3258    Some(PixelRenderRange {
3259        start_x,
3260        end_x,
3261        start_y,
3262        end_y,
3263    })
3264}
3265
3266fn paint_pixel_grid(
3267    ctx: &mut PaintCtx,
3268    range: PixelRenderRange,
3269    transform: Transform,
3270    color: Color,
3271) {
3272    let mut builder = PathBuilder::new();
3273    for x in range.start_x..=range.end_x {
3274        let x = x as f32;
3275        builder
3276            .move_to(transform.transform_point(Point::new(x, range.start_y as f32)))
3277            .line_to(transform.transform_point(Point::new(x, range.end_y as f32)));
3278    }
3279    for y in range.start_y..=range.end_y {
3280        let y = y as f32;
3281        builder
3282            .move_to(transform.transform_point(Point::new(range.start_x as f32, y)))
3283            .line_to(transform.transform_point(Point::new(range.end_x as f32, y)));
3284    }
3285    ctx.stroke(builder.build(), color, StrokeStyle::new(1.0));
3286}
3287
3288fn channel_to_u8(channel: f32) -> u8 {
3289    (channel.clamp(0.0, 1.0) * 255.0).round() as u8
3290}
3291
3292#[cfg(test)]
3293mod tests {
3294    use super::{
3295        Canvas, CanvasRuler, CanvasShape, CanvasStroke, CanvasViewport, PixelCanvas,
3296        PixelCanvasBlendMode, PixelCanvasBrushShape, PixelCanvasState, PixelCanvasTool, PixelColor,
3297    };
3298    use crate::{CanvasRulerAxis, DefaultTheme, ThemeTextToken};
3299    use sui_core::{
3300        Color, Event, KeyState, KeyboardEvent, Modifiers, Point, PointerButton, PointerButtons,
3301        PointerEvent, PointerEventKind, Rect, ScrollDelta, SemanticsAction, SemanticsRole,
3302        SemanticsValue, Size, Vector, WindowEvent,
3303    };
3304    use sui_runtime::{Application, RenderOutput, Runtime, Widget, WindowBuilder};
3305    use sui_scene::{Brush, ImageSampling, RegisteredImage, SceneCommand};
3306    use sui_text::{FontFeature, FontRegistry, TextSystem};
3307
3308    const RGBA_CHANNEL_TOLERANCE: u8 = 1;
3309
3310    fn build_runtime<W>(root: W) -> (Runtime, sui_core::WindowId)
3311    where
3312        W: Widget + 'static,
3313    {
3314        let runtime = Application::new()
3315            .window(WindowBuilder::new().title("Canvas widgets").root(root))
3316            .build()
3317            .unwrap();
3318        let window_id = runtime.window_ids()[0];
3319        (runtime, window_id)
3320    }
3321
3322    fn render<W>(root: W) -> RenderOutput
3323    where
3324        W: Widget + 'static,
3325    {
3326        let (mut runtime, window_id) = build_runtime(root);
3327        runtime.render(window_id).expect("render should succeed")
3328    }
3329
3330    fn handle_ready_events(runtime: &mut Runtime) -> usize {
3331        let ready = runtime.drain_ready_events();
3332        let count = ready.len();
3333        for (window_id, event) in ready {
3334            runtime
3335                .handle_event(window_id, event)
3336                .expect("ready event should be handled");
3337        }
3338        count
3339    }
3340
3341    fn primary_pointer(kind: PointerEventKind, position: Point, pressed: bool) -> Event {
3342        let mut buttons = PointerButtons::NONE;
3343        if pressed {
3344            buttons.insert(PointerButton::Primary);
3345        }
3346        let mut pointer = PointerEvent::new(kind, position);
3347        pointer.pointer_id = 1;
3348        pointer.button = Some(PointerButton::Primary);
3349        pointer.buttons = buttons;
3350        Event::Pointer(pointer)
3351    }
3352
3353    fn command_key(key: &str) -> Event {
3354        let mut event = KeyboardEvent::new(key, KeyState::Pressed);
3355        event.modifiers.control = true;
3356        Event::Keyboard(event)
3357    }
3358
3359    fn rendered_pixel_bytes(output: &RenderOutput) -> Vec<u8> {
3360        rendered_pixel_image(output).bytes().to_vec()
3361    }
3362
3363    fn rendered_pixel_image(output: &RenderOutput) -> &RegisteredImage {
3364        let source = rendered_pixel_image_source(output);
3365        output
3366            .frame
3367            .image_registry
3368            .get(source.image)
3369            .expect("pixel canvas image should be registered")
3370    }
3371
3372    fn rendered_pixel_image_source(output: &RenderOutput) -> sui_scene::ImageSource {
3373        let mut image_handle = None;
3374        let mut image_source = None;
3375        output.frame.scene.visit_commands(&mut |command| {
3376            if let SceneCommand::DrawImage { source, .. }
3377            | SceneCommand::DrawImageQuad { source, .. } = command
3378            {
3379                image_handle = Some(source.image);
3380                image_source = Some(source.clone());
3381            }
3382        });
3383        let source = image_source.expect("pixel canvas should draw an image");
3384        assert_eq!(
3385            Some(source.image),
3386            image_handle,
3387            "captured image source should match the image handle"
3388        );
3389        source
3390    }
3391
3392    fn pixel_canvas_zoom_percent(output: &RenderOutput) -> f32 {
3393        let node = output
3394            .semantics
3395            .iter()
3396            .find(|node| {
3397                node.role == SemanticsRole::Canvas && node.name.as_deref() == Some("Paint")
3398            })
3399            .expect("pixel canvas semantics should be present");
3400        let value = match node.value.as_ref() {
3401            Some(SemanticsValue::Text(value)) => value,
3402            _ => panic!("pixel canvas should expose zoom in text semantics"),
3403        };
3404        let start = value.find("zoom ").expect("zoom label should be present") + "zoom ".len();
3405        let end = value[start..]
3406            .find('%')
3407            .expect("zoom value should include percent")
3408            + start;
3409        value[start..end]
3410            .parse::<f32>()
3411            .expect("zoom percent should parse")
3412    }
3413
3414    fn solid_fill_colors(output: &RenderOutput) -> Vec<Color> {
3415        let mut colors = Vec::new();
3416        output.frame.scene.visit_commands(&mut |command| {
3417            if let SceneCommand::FillRect {
3418                brush: Brush::Solid(color),
3419                ..
3420            }
3421            | SceneCommand::FillPath {
3422                brush: Brush::Solid(color),
3423                ..
3424            } = command
3425            {
3426                colors.push(*color);
3427            }
3428        });
3429        colors
3430    }
3431
3432    fn solid_stroke_colors(output: &RenderOutput) -> Vec<Color> {
3433        let mut colors = Vec::new();
3434        output.frame.scene.visit_commands(&mut |command| {
3435            if let SceneCommand::StrokeRect {
3436                brush: Brush::Solid(color),
3437                ..
3438            }
3439            | SceneCommand::StrokePath {
3440                brush: Brush::Solid(color),
3441                ..
3442            } = command
3443            {
3444                colors.push(*color);
3445            }
3446        });
3447        colors
3448    }
3449
3450    fn contains_approx_color(colors: &[Color], expected: Color) -> bool {
3451        const CHANNEL_TOLERANCE: f32 = 1.0 / 255.0;
3452
3453        colors.iter().any(|color| {
3454            color.space == expected.space
3455                && (color.red - expected.red).abs() <= CHANNEL_TOLERANCE
3456                && (color.green - expected.green).abs() <= CHANNEL_TOLERANCE
3457                && (color.blue - expected.blue).abs() <= CHANNEL_TOLERANCE
3458                && (color.alpha - expected.alpha).abs() <= CHANNEL_TOLERANCE
3459        })
3460    }
3461
3462    fn numeric_text_runs(output: &RenderOutput) -> Vec<sui_text::TextRun> {
3463        let mut runs = Vec::new();
3464        output
3465            .frame
3466            .scene
3467            .visit_commands(&mut |command| match command {
3468                SceneCommand::DrawText(text_run)
3469                    if text_run
3470                        .text
3471                        .chars()
3472                        .all(|character| character.is_ascii_digit()) =>
3473                {
3474                    runs.push(text_run.clone());
3475                }
3476                SceneCommand::DrawShapedText(text) => {
3477                    if let Some(layout) = text.resolve(output.frame.text_layout_registry.as_ref())
3478                        && layout
3479                            .text()
3480                            .chars()
3481                            .all(|character| character.is_ascii_digit())
3482                    {
3483                        runs.push(sui_text::TextRun {
3484                            rect: Rect::new(
3485                                text.origin.x,
3486                                text.origin.y,
3487                                layout.box_size().width,
3488                                layout.box_size().height,
3489                            ),
3490                            text: layout.text().to_string(),
3491                            style: layout.style().clone(),
3492                        });
3493                    }
3494                }
3495                _ => {}
3496            });
3497
3498        runs
3499    }
3500
3501    fn optical_visual_center(measurement: sui_text::TextMeasurement) -> f32 {
3502        let top = -measurement.cap_height.unwrap_or(measurement.ascent);
3503        let bottom = measurement.descent * 0.5;
3504
3505        (top + bottom) * 0.5
3506    }
3507
3508    fn rgba_channels_match(actual: &[u8], expected: [u8; 4]) -> bool {
3509        actual.len() == 4
3510            && actual
3511                .iter()
3512                .zip(expected.iter())
3513                .all(|(actual, expected)| actual.abs_diff(*expected) <= RGBA_CHANNEL_TOLERANCE)
3514    }
3515
3516    fn assert_rgba_channels_near(actual: &[u8], expected: [u8; 4]) {
3517        assert_eq!(
3518            actual.len(),
3519            4,
3520            "expected exactly one RGBA pixel, got {} channels",
3521            actual.len()
3522        );
3523        for channel in 0..4 {
3524            assert!(
3525                actual[channel].abs_diff(expected[channel]) <= RGBA_CHANNEL_TOLERANCE,
3526                "channel {channel} differed by more than {RGBA_CHANNEL_TOLERANCE}: got {}, expected {}",
3527                actual[channel],
3528                expected[channel]
3529            );
3530        }
3531    }
3532
3533    fn assert_rgba_buffers_near(actual: &[u8], expected: &[u8]) {
3534        assert_eq!(
3535            actual.len(),
3536            expected.len(),
3537            "RGBA buffer length mismatch: got {}, expected {}",
3538            actual.len(),
3539            expected.len()
3540        );
3541        assert_eq!(
3542            actual.len() % 4,
3543            0,
3544            "RGBA buffer length must be divisible by 4"
3545        );
3546
3547        for (pixel_index, (actual_pixel, expected_pixel)) in actual
3548            .chunks_exact(4)
3549            .zip(expected.chunks_exact(4))
3550            .enumerate()
3551        {
3552            for channel in 0..4 {
3553                assert!(
3554                    actual_pixel[channel].abs_diff(expected_pixel[channel])
3555                        <= RGBA_CHANNEL_TOLERANCE,
3556                    "pixel {pixel_index} channel {channel} differed by more than {RGBA_CHANNEL_TOLERANCE}: got {}, expected {}",
3557                    actual_pixel[channel],
3558                    expected_pixel[channel]
3559                );
3560            }
3561        }
3562    }
3563
3564    fn alpha_matches(pixel: &[u8], expected: u8) -> bool {
3565        pixel
3566            .get(3)
3567            .is_some_and(|alpha| alpha.abs_diff(expected) <= RGBA_CHANNEL_TOLERANCE)
3568    }
3569
3570    fn pixel_matches_color(pixel: &[u8], color: PixelColor) -> bool {
3571        rgba_channels_match(pixel, [color.red, color.green, color.blue, color.alpha])
3572    }
3573
3574    #[test]
3575    fn viewport_screen_world_mapping_round_trips_nonzero_bounds() {
3576        let viewport = CanvasViewport::new()
3577            .pan(Vector::new(24.0, -18.0))
3578            .zoom(2.35)
3579            .rotation(0.42);
3580        let bounds = Rect::new(180.0, 96.0, 420.0, 260.0);
3581        let document_origin = Point::new(16.0, 12.0);
3582        let cursor = Point::new(412.0, 214.0);
3583
3584        let world = viewport.screen_to_world(bounds, cursor, document_origin);
3585        let screen = viewport.world_to_screen(bounds, world, document_origin);
3586
3587        assert!((screen.x - cursor.x).abs() < 0.001);
3588        assert!((screen.y - cursor.y).abs() < 0.001);
3589    }
3590
3591    #[test]
3592    fn canvas_ruler_exposes_semantics_and_draws_ticks() {
3593        let theme = DefaultTheme::default();
3594        let output = render(
3595            crate::SizedBox::new()
3596                .size(Size::new(420.0, theme.metrics.canvas_ruler_extent))
3597                .with_child(
3598                    CanvasRuler::horizontal("Horizontal ruler", Size::new(1920.0, 1080.0))
3599                        .viewport(CanvasViewport::new().zoom(0.5), Size::new(420.0, 260.0)),
3600                ),
3601        );
3602
3603        let ruler = output
3604            .semantics
3605            .iter()
3606            .find(|node| {
3607                node.role == SemanticsRole::GenericContainer
3608                    && node.name.as_deref() == Some("Horizontal ruler")
3609            })
3610            .expect("ruler semantics should exist");
3611        assert_eq!(
3612            ruler.bounds,
3613            Rect::new(0.0, 0.0, 420.0, theme.metrics.canvas_ruler_extent)
3614        );
3615        assert_eq!(
3616            ruler.value,
3617            Some(SemanticsValue::Text(
3618                "horizontal ruler, 1920 px document axis".to_string(),
3619            ))
3620        );
3621
3622        let mut stroke_count = 0;
3623        let mut label_count = 0;
3624        output
3625            .frame
3626            .scene
3627            .visit_commands(&mut |command| match command {
3628                SceneCommand::StrokePath { .. } => stroke_count += 1,
3629                SceneCommand::DrawText(_) | SceneCommand::DrawShapedText(_) => label_count += 1,
3630                _ => {}
3631            });
3632
3633        assert!(stroke_count > 2);
3634        assert!(label_count > 0);
3635    }
3636
3637    #[test]
3638    fn canvas_ruler_defaults_follow_theme_density_and_extent_override() {
3639        let compact = DefaultTheme::compact();
3640        let touch = DefaultTheme::touch();
3641
3642        let compact_output = render(crate::SizedBox::new().width(420.0).with_child(
3643            CanvasRuler::horizontal("Compact ruler", Size::new(1920.0, 1080.0)).theme(compact),
3644        ));
3645        let touch_output = render(crate::SizedBox::new().width(420.0).with_child(
3646            CanvasRuler::horizontal("Touch ruler", Size::new(1920.0, 1080.0)).theme(touch),
3647        ));
3648        let override_output = render(
3649            crate::SizedBox::new().width(420.0).with_child(
3650                CanvasRuler::horizontal("Override ruler", Size::new(1920.0, 1080.0))
3651                    .theme(touch)
3652                    .extent(18.0),
3653            ),
3654        );
3655
3656        let ruler_height = |output: &RenderOutput, name: &str| {
3657            output
3658                .semantics
3659                .iter()
3660                .find(|node| node.name.as_deref() == Some(name))
3661                .expect("ruler semantics should exist")
3662                .bounds
3663                .height()
3664        };
3665
3666        assert_eq!(
3667            ruler_height(&compact_output, "Compact ruler"),
3668            compact.metrics.canvas_ruler_extent
3669        );
3670        assert_eq!(
3671            ruler_height(&touch_output, "Touch ruler"),
3672            touch.metrics.canvas_ruler_extent
3673        );
3674        assert_eq!(ruler_height(&override_output, "Override ruler"), 18.0);
3675    }
3676
3677    #[test]
3678    fn canvas_ruler_numeric_labels_use_tabular_figures_and_optical_centering() {
3679        let theme = DefaultTheme::default();
3680        let output = render(
3681            crate::SizedBox::new()
3682                .size(Size::new(420.0, theme.metrics.canvas_ruler_extent))
3683                .with_child(
3684                    CanvasRuler::horizontal("Horizontal ruler", Size::new(1920.0, 1080.0))
3685                        .viewport(
3686                            CanvasViewport::new().pan(Vector::new(750.0, 0.0)),
3687                            Size::new(420.0, 260.0),
3688                        ),
3689                ),
3690        );
3691        let text = numeric_text_runs(&output)
3692            .into_iter()
3693            .next()
3694            .expect("ruler should draw at least one numeric label");
3695        let layout = TextSystem::new()
3696            .shape_text_run(&text, &FontRegistry::new())
3697            .expect("ruler label should shape");
3698        let line = layout
3699            .lines()
3700            .first()
3701            .expect("ruler label should contain one line");
3702        let measurement = layout.measurement();
3703        let actual_visual_center =
3704            text.rect.y() + line.baseline + optical_visual_center(measurement);
3705        let slot_center = theme.metrics.canvas_ruler_label_padding.top
3706            + (theme.metrics.canvas_ruler_extent
3707                - theme.metrics.canvas_ruler_label_padding.top
3708                - theme.metrics.canvas_ruler_label_padding.bottom)
3709                * 0.5;
3710
3711        assert!(
3712            text.style
3713                .features
3714                .iter()
3715                .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
3716        );
3717        assert!(
3718            (text.rect.width() - measurement.width).abs() < 0.75,
3719            "ruler label rect should use measured width: rect={:?}, measurement={measurement:?}",
3720            text.rect
3721        );
3722        assert!(
3723            (actual_visual_center - slot_center).abs() < 0.75,
3724            "ruler label visual center {actual_visual_center} did not match slot center {slot_center}; text rect {:?}",
3725            text.rect
3726        );
3727    }
3728
3729    #[test]
3730    fn horizontal_canvas_ruler_preserves_tall_label_measurements() {
3731        let mut theme = DefaultTheme::default();
3732        theme.text.xs = ThemeTextToken {
3733            size: 32.0,
3734            line_height: 12.0,
3735        };
3736        theme.metrics.canvas_ruler_label_max_width = 120.0;
3737
3738        let extent = 96.0;
3739        let output = render(
3740            crate::SizedBox::new()
3741                .size(Size::new(420.0, extent))
3742                .with_child(
3743                    CanvasRuler::horizontal("Tall horizontal ruler", Size::new(1920.0, 1080.0))
3744                        .theme(theme)
3745                        .extent(extent)
3746                        .viewport(
3747                            CanvasViewport::new().pan(Vector::new(750.0, 0.0)),
3748                            Size::new(420.0, 260.0),
3749                        ),
3750                ),
3751        );
3752        let text = numeric_text_runs(&output)
3753            .into_iter()
3754            .next()
3755            .expect("horizontal ruler should draw at least one numeric label");
3756        let layout = TextSystem::new()
3757            .shape_text_run(&text, &FontRegistry::new())
3758            .expect("ruler label should shape");
3759        let measurement = layout.measurement();
3760        let line = layout
3761            .lines()
3762            .first()
3763            .expect("ruler label should contain one line");
3764        let slot_center = theme.metrics.canvas_ruler_label_padding.top
3765            + (extent
3766                - theme.metrics.canvas_ruler_label_padding.top
3767                - theme.metrics.canvas_ruler_label_padding.bottom)
3768                * 0.5;
3769        let actual_visual_center =
3770            text.rect.y() + line.baseline + optical_visual_center(measurement);
3771
3772        assert_eq!(text.style.font_size, theme.text.xs.size);
3773        assert_eq!(text.style.line_height, theme.text.xs.line_height);
3774        assert!(
3775            text.rect.height() >= measurement.height - 0.01,
3776            "horizontal ruler label rect should preserve measured glyph height: rect={:?}, measurement={measurement:?}",
3777            text.rect
3778        );
3779        assert!(
3780            text.rect.height() > text.style.line_height,
3781            "test should exercise a measurement taller than line-height: rect={:?}, style={:?}",
3782            text.rect,
3783            text.style
3784        );
3785        assert!(
3786            (actual_visual_center - slot_center).abs() < 0.75,
3787            "horizontal ruler tall label visual center {actual_visual_center} did not match slot center {slot_center}; text rect {:?}",
3788            text.rect
3789        );
3790    }
3791
3792    #[test]
3793    fn vertical_canvas_ruler_numeric_labels_center_on_tick_position() {
3794        let theme = DefaultTheme::default();
3795        let document_size = Size::new(1920.0, 1080.0);
3796        let viewport = CanvasViewport::new();
3797        let viewport_size = Size::new(260.0, 420.0);
3798        let extent = 72.0;
3799        let output = render(
3800            crate::SizedBox::new()
3801                .size(Size::new(extent, 420.0))
3802                .with_child(
3803                    CanvasRuler::vertical("Vertical ruler", document_size)
3804                        .extent(extent)
3805                        .viewport(viewport, viewport_size),
3806                ),
3807        );
3808        let bounds = Rect::new(0.0, 0.0, extent, 420.0);
3809        let canvas_bounds =
3810            super::ruler_canvas_bounds(bounds, CanvasRulerAxis::Vertical, viewport_size);
3811        let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
3812        let padding = theme.metrics.canvas_ruler_label_padding;
3813        let text = numeric_text_runs(&output)
3814            .into_iter()
3815            .find(|run| {
3816                let Ok(value) = run.text.parse::<f32>() else {
3817                    return false;
3818                };
3819                let tick_y = super::ruler_tick_screen_position(
3820                    CanvasRulerAxis::Vertical,
3821                    value,
3822                    document_size,
3823                    viewport,
3824                    canvas_bounds,
3825                    document_origin,
3826                );
3827
3828                tick_y > bounds.y() + padding.top + run.style.line_height
3829                    && tick_y < bounds.max_y() - padding.bottom - run.style.line_height
3830            })
3831            .expect("vertical ruler should draw an unclamped numeric label");
3832        let value = text
3833            .text
3834            .parse::<f32>()
3835            .expect("numeric ruler label should parse");
3836        let expected_tick_y = super::ruler_tick_screen_position(
3837            CanvasRulerAxis::Vertical,
3838            value,
3839            document_size,
3840            viewport,
3841            canvas_bounds,
3842            document_origin,
3843        );
3844        let layout = TextSystem::new()
3845            .shape_text_run(&text, &FontRegistry::new())
3846            .expect("ruler label should shape");
3847        let line = layout
3848            .lines()
3849            .first()
3850            .expect("ruler label should contain one line");
3851        let actual_visual_center =
3852            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
3853
3854        assert!(
3855            text.style
3856                .features
3857                .iter()
3858                .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
3859        );
3860        assert!(
3861            (actual_visual_center - expected_tick_y).abs() < 0.75,
3862            "vertical ruler label visual center {actual_visual_center} did not match tick {expected_tick_y}; text rect {:?}",
3863            text.rect
3864        );
3865    }
3866
3867    #[test]
3868    fn vertical_canvas_ruler_preserves_tall_label_measurements() {
3869        let mut theme = DefaultTheme::default();
3870        theme.text.xs = ThemeTextToken {
3871            size: 32.0,
3872            line_height: 12.0,
3873        };
3874        theme.metrics.canvas_ruler_label_max_width = 120.0;
3875
3876        let document_size = Size::new(1920.0, 1080.0);
3877        let viewport = CanvasViewport::new();
3878        let viewport_size = Size::new(260.0, 420.0);
3879        let extent = 96.0;
3880        let output = render(
3881            crate::SizedBox::new()
3882                .size(Size::new(extent, 420.0))
3883                .with_child(
3884                    CanvasRuler::vertical("Tall vertical ruler", document_size)
3885                        .theme(theme)
3886                        .extent(extent)
3887                        .viewport(viewport, viewport_size),
3888                ),
3889        );
3890        let bounds = Rect::new(0.0, 0.0, extent, 420.0);
3891        let canvas_bounds =
3892            super::ruler_canvas_bounds(bounds, CanvasRulerAxis::Vertical, viewport_size);
3893        let document_origin = Point::new(document_size.width * 0.5, document_size.height * 0.5);
3894        let padding = theme.metrics.canvas_ruler_label_padding;
3895        let text_system = TextSystem::new();
3896        let text = numeric_text_runs(&output)
3897            .into_iter()
3898            .find(|run| {
3899                let Ok(value) = run.text.parse::<f32>() else {
3900                    return false;
3901                };
3902                let Ok(layout) = text_system.shape_text_run(run, &FontRegistry::new()) else {
3903                    return false;
3904                };
3905                let tick_y = super::ruler_tick_screen_position(
3906                    CanvasRulerAxis::Vertical,
3907                    value,
3908                    document_size,
3909                    viewport,
3910                    canvas_bounds,
3911                    document_origin,
3912                );
3913                let height = run.style.line_height.max(layout.measurement().height);
3914
3915                tick_y > bounds.y() + padding.top + height
3916                    && tick_y < bounds.max_y() - padding.bottom - height
3917            })
3918            .expect("vertical ruler should draw an unclamped tall numeric label");
3919        let value = text
3920            .text
3921            .parse::<f32>()
3922            .expect("numeric ruler label should parse");
3923        let expected_tick_y = super::ruler_tick_screen_position(
3924            CanvasRulerAxis::Vertical,
3925            value,
3926            document_size,
3927            viewport,
3928            canvas_bounds,
3929            document_origin,
3930        );
3931        let layout = text_system
3932            .shape_text_run(&text, &FontRegistry::new())
3933            .expect("ruler label should shape");
3934        let measurement = layout.measurement();
3935        let line = layout
3936            .lines()
3937            .first()
3938            .expect("ruler label should contain one line");
3939        let actual_visual_center =
3940            text.rect.y() + line.baseline + optical_visual_center(measurement);
3941
3942        assert!(
3943            text.rect.height() >= measurement.height - 0.01,
3944            "vertical ruler label rect should preserve measured glyph height: rect={:?}, measurement={measurement:?}",
3945            text.rect
3946        );
3947        assert!(
3948            text.rect.height() > text.style.line_height,
3949            "test should exercise a measurement taller than line-height: rect={:?}, style={:?}",
3950            text.rect,
3951            text.style
3952        );
3953        assert!(
3954            (actual_visual_center - expected_tick_y).abs() < 0.75,
3955            "vertical ruler tall label visual center {actual_visual_center} did not match tick {expected_tick_y}; text rect {:?}",
3956            text.rect
3957        );
3958    }
3959
3960    #[test]
3961    fn canvas_surface_tokens_drive_default_canvas_paint() {
3962        let mut theme = DefaultTheme::default();
3963        theme.surfaces.canvas = Color::rgba(0.91, 0.83, 0.72, 1.0);
3964        theme.surfaces.canvas_grid = Color::rgba(0.24, 0.33, 0.44, 0.40);
3965        theme.surfaces.canvas_axis_x = Color::rgba(0.80, 0.20, 0.30, 0.70);
3966        theme.surfaces.canvas_axis_y = Color::rgba(0.20, 0.60, 0.40, 0.70);
3967
3968        let output = render(Canvas::new("Vector").theme(theme));
3969        let fills = solid_fill_colors(&output);
3970        let strokes = solid_stroke_colors(&output);
3971
3972        assert!(fills.contains(&theme.surfaces.canvas));
3973        assert!(strokes.contains(&theme.surfaces.canvas_grid));
3974        assert!(strokes.contains(&theme.surfaces.canvas_axis_x));
3975        assert!(strokes.contains(&theme.surfaces.canvas_axis_y));
3976    }
3977
3978    #[test]
3979    fn canvas_focus_ring_uses_theme_motion() {
3980        let theme = DefaultTheme::default();
3981        let focus_duration = theme.motion.focus_duration();
3982        let (mut runtime, window_id) = build_runtime(
3983            crate::SizedBox::new()
3984                .size(Size::new(160.0, 120.0))
3985                .with_child(Canvas::new("Vector").theme(theme)),
3986        );
3987
3988        let _ = runtime.render(window_id).expect("render should succeed");
3989        runtime
3990            .handle_event(
3991                window_id,
3992                primary_pointer(PointerEventKind::Down, Point::new(30.0, 30.0), true),
3993            )
3994            .expect("focus event should be handled");
3995
3996        runtime.tick(focus_duration * 0.5);
3997        assert!(handle_ready_events(&mut runtime) >= 1);
3998        let mid_focus = runtime.render(window_id).expect("render should succeed");
3999        assert!(
4000            !contains_approx_color(&solid_stroke_colors(&mid_focus), theme.palette.focus_ring),
4001            "canvas focus ring should not snap to the settled focus color"
4002        );
4003
4004        runtime.tick(focus_duration + 0.01);
4005        assert!(handle_ready_events(&mut runtime) >= 1);
4006        let settled_focus = runtime.render(window_id).expect("render should succeed");
4007        let settled_strokes = solid_stroke_colors(&settled_focus);
4008        assert!(
4009            contains_approx_color(&settled_strokes, theme.palette.focus_ring),
4010            "canvas focus ring should settle to the theme focus color; strokes={settled_strokes:?}"
4011        );
4012    }
4013
4014    #[test]
4015    fn pixel_canvas_focus_ring_uses_theme_motion() {
4016        let theme = DefaultTheme::default();
4017        let focus_duration = theme.motion.focus_duration();
4018        let (mut runtime, window_id) = build_runtime(
4019            crate::SizedBox::new()
4020                .size(Size::new(160.0, 120.0))
4021                .with_child(PixelCanvas::new("Paint", 8, 8).theme(theme)),
4022        );
4023
4024        let _ = runtime.render(window_id).expect("render should succeed");
4025        runtime
4026            .handle_event(
4027                window_id,
4028                primary_pointer(PointerEventKind::Down, Point::new(30.0, 30.0), true),
4029            )
4030            .expect("focus event should be handled");
4031
4032        runtime.tick(focus_duration * 0.5);
4033        assert!(handle_ready_events(&mut runtime) >= 1);
4034        let mid_focus = runtime.render(window_id).expect("render should succeed");
4035        assert!(
4036            !contains_approx_color(&solid_stroke_colors(&mid_focus), theme.palette.focus_ring),
4037            "pixel canvas focus ring should not snap to the settled focus color"
4038        );
4039
4040        runtime.tick(focus_duration + 0.01);
4041        assert!(handle_ready_events(&mut runtime) >= 1);
4042        let settled_focus = runtime.render(window_id).expect("render should succeed");
4043        let settled_strokes = solid_stroke_colors(&settled_focus);
4044        assert!(
4045            contains_approx_color(&settled_strokes, theme.palette.focus_ring),
4046            "pixel canvas focus ring should settle to the theme focus color; strokes={settled_strokes:?}"
4047        );
4048    }
4049
4050    #[test]
4051    fn canvas_renders_shapes_inside_a_transform() {
4052        let output = render(
4053            Canvas::new("Vector")
4054                .viewport(CanvasViewport::new().zoom(1.5).rotation(0.2))
4055                .shape(CanvasShape::rect(
4056                    Rect::new(-20.0, -20.0, 40.0, 40.0),
4057                    Some(Color::rgba(0.2, 0.4, 0.8, 1.0)),
4058                    Some(CanvasStroke::new(Color::rgba(0.0, 0.0, 0.0, 1.0), 1.0)),
4059                )),
4060        );
4061
4062        let has_canvas = output.semantics.iter().any(|node| {
4063            node.role == SemanticsRole::Canvas && node.name.as_deref() == Some("Vector")
4064        });
4065        assert!(has_canvas);
4066        let mut path_count = 0;
4067        output
4068            .frame
4069            .scene
4070            .visit_commands(&mut |command| match command {
4071                SceneCommand::FillPath { .. } | SceneCommand::StrokePath { .. } => path_count += 1,
4072                _ => {}
4073            });
4074        assert!(path_count >= 1);
4075    }
4076
4077    #[test]
4078    fn canvas_primary_drag_adds_vector_stroke() -> sui_core::Result<()> {
4079        let (mut runtime, window_id) = build_runtime(Canvas::new("Vector"));
4080
4081        let _ = runtime.render(window_id)?;
4082        runtime.handle_event(
4083            window_id,
4084            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4085        )?;
4086        runtime.handle_event(
4087            window_id,
4088            primary_pointer(PointerEventKind::Move, Point::new(280.0, 190.0), true),
4089        )?;
4090        runtime.handle_event(
4091            window_id,
4092            primary_pointer(PointerEventKind::Up, Point::new(280.0, 190.0), false),
4093        )?;
4094        let output = runtime.render(window_id)?;
4095
4096        let mut stroke_count = 0;
4097        output.frame.scene.visit_commands(&mut |command| {
4098            if matches!(command, SceneCommand::StrokePath { .. }) {
4099                stroke_count += 1;
4100            }
4101        });
4102        assert!(stroke_count >= 3);
4103        Ok(())
4104    }
4105
4106    #[test]
4107    fn pixel_canvas_primary_drag_paints_pixel() -> sui_core::Result<()> {
4108        let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8));
4109
4110        let _ = runtime.render(window_id)?;
4111        runtime.handle_event(
4112            window_id,
4113            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4114        )?;
4115        runtime.handle_event(
4116            window_id,
4117            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4118        )?;
4119        let output = runtime.render(window_id)?;
4120
4121        let mut image_handle = None;
4122        output.frame.scene.visit_commands(&mut |command| {
4123            if let SceneCommand::DrawImage { source, .. }
4124            | SceneCommand::DrawImageQuad { source, .. } = command
4125            {
4126                image_handle = Some(source.image);
4127            }
4128        });
4129        let image = output
4130            .frame
4131            .image_registry
4132            .get(image_handle.expect("pixel canvas should draw an image"))
4133            .expect("pixel canvas image should be registered");
4134        let accent = PixelColor::from_color(DefaultTheme::default().palette.accent);
4135        let painted = image
4136            .bytes()
4137            .chunks_exact(4)
4138            .any(|pixel| pixel_matches_color(pixel, accent));
4139        assert!(painted);
4140        Ok(())
4141    }
4142
4143    #[test]
4144    fn pixel_canvas_fast_brush_drag_interpolates_sparse_pointer_samples() -> sui_core::Result<()> {
4145        let state = PixelCanvasState::new();
4146        state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
4147        state.set_brush_size(1.0);
4148        let (mut runtime, window_id) =
4149            build_runtime(PixelCanvas::new("Paint", 8, 8).state(state.clone()));
4150
4151        let output = runtime.render(window_id)?;
4152        let canvas = output
4153            .semantics
4154            .iter()
4155            .find(|node| node.role == SemanticsRole::Canvas)
4156            .expect("pixel canvas semantics present");
4157        let document_origin = Point::new(4.0, 4.0);
4158        let start =
4159            state
4160                .viewport()
4161                .world_to_screen(canvas.bounds, Point::new(1.5, 4.5), document_origin);
4162        let middle =
4163            state
4164                .viewport()
4165                .world_to_screen(canvas.bounds, Point::new(4.5, 4.5), document_origin);
4166        let end =
4167            state
4168                .viewport()
4169                .world_to_screen(canvas.bounds, Point::new(6.5, 4.5), document_origin);
4170
4171        runtime.handle_event(
4172            window_id,
4173            primary_pointer(PointerEventKind::Down, start, true),
4174        )?;
4175        runtime.handle_event(
4176            window_id,
4177            primary_pointer(PointerEventKind::Move, middle, true),
4178        )?;
4179        runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, end, false))?;
4180
4181        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4182        for x in 1..=6 {
4183            let index = ((4 * 8) + x) * 4;
4184            assert_rgba_channels_near(&pixels[index..index + 4], [255, 0, 0, 255]);
4185        }
4186        Ok(())
4187    }
4188
4189    #[test]
4190    fn pixel_canvas_state_defaults_to_round_brush() {
4191        let state = PixelCanvasState::new();
4192        assert_eq!(state.brush_shape(), PixelCanvasBrushShape::Round);
4193        assert_eq!(
4194            PixelCanvasBrushShape::default(),
4195            PixelCanvasBrushShape::Round
4196        );
4197    }
4198
4199    #[test]
4200    fn pixel_canvas_square_brush_paints_full_stamp() -> sui_core::Result<()> {
4201        let state = PixelCanvasState::new();
4202        state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
4203        state.set_brush_size(3.0);
4204        state.set_brush_shape(PixelCanvasBrushShape::Square);
4205        let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8).state(state));
4206
4207        let _ = runtime.render(window_id)?;
4208        runtime.handle_event(
4209            window_id,
4210            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4211        )?;
4212        runtime.handle_event(
4213            window_id,
4214            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4215        )?;
4216        let output = runtime.render(window_id)?;
4217
4218        let mut image_handle = None;
4219        output.frame.scene.visit_commands(&mut |command| {
4220            if let SceneCommand::DrawImage { source, .. }
4221            | SceneCommand::DrawImageQuad { source, .. } = command
4222            {
4223                image_handle = Some(source.image);
4224            }
4225        });
4226        let image = output
4227            .frame
4228            .image_registry
4229            .get(image_handle.expect("pixel canvas should draw an image"))
4230            .expect("pixel canvas image should be registered");
4231        let painted = image
4232            .bytes()
4233            .chunks_exact(4)
4234            .filter(|pixel| rgba_channels_match(pixel, [255, 0, 0, 255]))
4235            .count();
4236        assert_eq!(painted, 9);
4237        Ok(())
4238    }
4239
4240    #[test]
4241    fn pixel_canvas_blend_mode_composes_brush_with_existing_pixels() -> sui_core::Result<()> {
4242        let state = PixelCanvasState::new();
4243        state.set_blend_mode(PixelCanvasBlendMode::Screen);
4244        state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
4245        state.set_brush_size(1.0);
4246        let (mut runtime, window_id) = build_runtime(
4247            PixelCanvas::new("Paint", 1, 1)
4248                .state(state)
4249                .with_pixels(vec![Color::rgba(0.0, 0.0, 1.0, 1.0)]),
4250        );
4251
4252        let _ = runtime.render(window_id)?;
4253        runtime.handle_event(
4254            window_id,
4255            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4256        )?;
4257        runtime.handle_event(
4258            window_id,
4259            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4260        )?;
4261        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4262
4263        assert_rgba_channels_near(&pixels[0..4], [255, 0, 255, 255]);
4264        Ok(())
4265    }
4266
4267    #[test]
4268    fn pixel_canvas_round_brush_uses_circular_stamp() -> sui_core::Result<()> {
4269        let state = PixelCanvasState::new();
4270        state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
4271        state.set_brush_size(3.0);
4272        let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8).state(state));
4273
4274        let _ = runtime.render(window_id)?;
4275        runtime.handle_event(
4276            window_id,
4277            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4278        )?;
4279        runtime.handle_event(
4280            window_id,
4281            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4282        )?;
4283        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4284        let painted = pixels
4285            .chunks_exact(4)
4286            .filter(|pixel| rgba_channels_match(pixel, [255, 0, 0, 255]))
4287            .count();
4288
4289        assert_eq!(painted, 5);
4290        Ok(())
4291    }
4292
4293    #[test]
4294    fn pixel_canvas_eraser_tool_clears_painted_pixels() -> sui_core::Result<()> {
4295        let state = PixelCanvasState::new();
4296        state.set_tool(PixelCanvasTool::Eraser);
4297        let pixels = vec![Color::rgba(0.0, 0.2, 1.0, 1.0); 64];
4298        let (mut runtime, window_id) = build_runtime(
4299            PixelCanvas::new("Paint", 8, 8)
4300                .state(state)
4301                .with_pixels(pixels),
4302        );
4303
4304        let _ = runtime.render(window_id)?;
4305        runtime.handle_event(
4306            window_id,
4307            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4308        )?;
4309        runtime.handle_event(
4310            window_id,
4311            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4312        )?;
4313        let output = runtime.render(window_id)?;
4314
4315        let mut image_handle = None;
4316        output.frame.scene.visit_commands(&mut |command| {
4317            if let SceneCommand::DrawImage { source, .. }
4318            | SceneCommand::DrawImageQuad { source, .. } = command
4319            {
4320                image_handle = Some(source.image);
4321            }
4322        });
4323        let image = output
4324            .frame
4325            .image_registry
4326            .get(image_handle.expect("pixel canvas should draw an image"))
4327            .expect("pixel canvas image should be registered");
4328        let transparent = image
4329            .bytes()
4330            .chunks_exact(4)
4331            .filter(|pixel| alpha_matches(pixel, 0))
4332            .count();
4333        assert_eq!(transparent, 1);
4334        Ok(())
4335    }
4336
4337    #[test]
4338    fn pixel_canvas_fill_tool_flood_fills_matching_pixels() -> sui_core::Result<()> {
4339        let state = PixelCanvasState::new();
4340        state.set_tool(PixelCanvasTool::Fill);
4341        state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
4342        let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8).state(state));
4343
4344        let _ = runtime.render(window_id)?;
4345        runtime.handle_event(
4346            window_id,
4347            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4348        )?;
4349        let output = runtime.render(window_id)?;
4350
4351        let mut image_handle = None;
4352        output.frame.scene.visit_commands(&mut |command| {
4353            if let SceneCommand::DrawImage { source, .. }
4354            | SceneCommand::DrawImageQuad { source, .. } = command
4355            {
4356                image_handle = Some(source.image);
4357            }
4358        });
4359        let image = output
4360            .frame
4361            .image_registry
4362            .get(image_handle.expect("pixel canvas should draw an image"))
4363            .expect("pixel canvas image should be registered");
4364        let red = image
4365            .bytes()
4366            .chunks_exact(4)
4367            .filter(|pixel| rgba_channels_match(pixel, [255, 0, 0, 255]))
4368            .count();
4369        assert_eq!(red, 64);
4370        Ok(())
4371    }
4372
4373    #[test]
4374    fn pixel_canvas_keyboard_undo_redo_restores_pixel_edits() -> sui_core::Result<()> {
4375        let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8));
4376
4377        let _ = runtime.render(window_id)?;
4378        runtime.handle_event(
4379            window_id,
4380            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4381        )?;
4382        runtime.handle_event(
4383            window_id,
4384            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4385        )?;
4386        let accent = PixelColor::from_color(DefaultTheme::default().palette.accent);
4387        let painted = rendered_pixel_bytes(&runtime.render(window_id)?)
4388            .chunks_exact(4)
4389            .any(|pixel| pixel_matches_color(pixel, accent));
4390        assert!(painted);
4391
4392        runtime.handle_event(window_id, command_key("z"))?;
4393        let painted_after_undo = rendered_pixel_bytes(&runtime.render(window_id)?)
4394            .chunks_exact(4)
4395            .any(|pixel| !alpha_matches(pixel, 0));
4396        assert!(!painted_after_undo);
4397
4398        runtime.handle_event(window_id, command_key("y"))?;
4399        let painted_after_redo = rendered_pixel_bytes(&runtime.render(window_id)?)
4400            .chunks_exact(4)
4401            .any(|pixel| pixel_matches_color(pixel, accent));
4402        assert!(painted_after_redo);
4403        Ok(())
4404    }
4405
4406    #[test]
4407    fn pixel_canvas_state_undo_request_is_consumed_during_measure() -> sui_core::Result<()> {
4408        let state = PixelCanvasState::new();
4409        let (mut runtime, window_id) =
4410            build_runtime(PixelCanvas::new("Paint", 8, 8).state(state.clone()));
4411
4412        let _ = runtime.render(window_id)?;
4413        runtime.handle_event(
4414            window_id,
4415            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4416        )?;
4417        runtime.handle_event(
4418            window_id,
4419            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4420        )?;
4421        assert!(state.can_undo());
4422
4423        state.request_undo();
4424        runtime.handle_event(
4425            window_id,
4426            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4427        )?;
4428        let painted_after_undo = rendered_pixel_bytes(&runtime.render(window_id)?)
4429            .chunks_exact(4)
4430            .any(|pixel| !alpha_matches(pixel, 0));
4431        assert!(!painted_after_undo);
4432        assert!(state.can_redo());
4433        Ok(())
4434    }
4435
4436    #[test]
4437    fn pixel_canvas_state_clear_request_clears_pixels_and_supports_undo() -> sui_core::Result<()> {
4438        let state = PixelCanvasState::new();
4439        let pixels = vec![Color::rgba(0.2, 0.4, 0.8, 1.0); 4];
4440        let (mut runtime, window_id) = build_runtime(
4441            PixelCanvas::new("Paint", 2, 2)
4442                .state(state.clone())
4443                .with_pixels(pixels),
4444        );
4445
4446        let _ = runtime.render(window_id)?;
4447        state.request_clear();
4448        runtime.handle_event(
4449            window_id,
4450            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4451        )?;
4452        let cleared = rendered_pixel_bytes(&runtime.render(window_id)?);
4453        assert!(cleared.chunks_exact(4).all(|pixel| alpha_matches(pixel, 0)));
4454        assert!(state.can_undo());
4455
4456        state.request_undo();
4457        runtime.handle_event(
4458            window_id,
4459            Event::Window(WindowEvent::Resized(Size::new(522.0, 362.0))),
4460        )?;
4461        let restored = rendered_pixel_bytes(&runtime.render(window_id)?);
4462        assert!(
4463            restored
4464                .chunks_exact(4)
4465                .all(|pixel| alpha_matches(pixel, 255))
4466        );
4467        assert!(state.can_redo());
4468        Ok(())
4469    }
4470
4471    #[test]
4472    fn pixel_canvas_read_only_blocks_edit_commands_and_reports_state() -> sui_core::Result<()> {
4473        let state = PixelCanvasState::new();
4474        state.set_editable(false);
4475        state.set_tool(PixelCanvasTool::Fill);
4476        state.set_brush_color(Color::rgba(1.0, 0.0, 0.0, 1.0));
4477        let pixels = vec![Color::rgba(0.2, 0.4, 0.8, 1.0); 4];
4478        let (mut runtime, window_id) = build_runtime(
4479            PixelCanvas::new("Paint", 2, 2)
4480                .state(state.clone())
4481                .with_pixels(pixels),
4482        );
4483
4484        let output = runtime.render(window_id)?;
4485        let canvas = output
4486            .semantics
4487            .iter()
4488            .find(|node| node.role == SemanticsRole::Canvas)
4489            .expect("pixel canvas semantics present");
4490        let value = match canvas.value.as_ref() {
4491            Some(SemanticsValue::Text(value)) => value,
4492            _ => panic!("pixel canvas should expose text value"),
4493        };
4494        assert!(value.contains("read only"));
4495        assert!(
4496            canvas
4497                .actions
4498                .contains(&SemanticsAction::Custom("Pan".into()))
4499        );
4500        assert!(
4501            !canvas
4502                .actions
4503                .contains(&SemanticsAction::Custom("Paint".into()))
4504        );
4505        assert!(!state.can_clear());
4506
4507        let before = rendered_pixel_bytes(&output);
4508        state.request_clear();
4509        runtime.handle_event(
4510            window_id,
4511            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4512        )?;
4513        runtime.handle_event(
4514            window_id,
4515            primary_pointer(PointerEventKind::Down, Point::new(260.0, 180.0), true),
4516        )?;
4517        runtime.handle_event(
4518            window_id,
4519            primary_pointer(PointerEventKind::Up, Point::new(260.0, 180.0), false),
4520        )?;
4521
4522        let after = rendered_pixel_bytes(&runtime.render(window_id)?);
4523        assert_rgba_buffers_near(&after, &before);
4524        assert!(!state.can_undo());
4525        Ok(())
4526    }
4527
4528    #[test]
4529    fn pixel_canvas_display_visibility_affects_render_and_export() -> sui_core::Result<()> {
4530        let state = PixelCanvasState::new();
4531        state.set_display_visible(false);
4532        let (mut runtime, window_id) = build_runtime(
4533            PixelCanvas::new("Paint", 1, 1)
4534                .state(state.clone())
4535                .with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
4536        );
4537        let paper = PixelColor::from_color(DefaultTheme::default().surfaces.pixel_canvas_paper);
4538        let expected = [paper.red, paper.green, paper.blue, paper.alpha];
4539
4540        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4541        assert_rgba_channels_near(&pixels[0..4], expected);
4542
4543        state.request_export_snapshot();
4544        runtime.handle_event(
4545            window_id,
4546            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4547        )?;
4548        let snapshot = state
4549            .latest_export_snapshot()
4550            .expect("hidden layer export should publish a snapshot");
4551        assert_rgba_channels_near(&snapshot.rgba8()[0..4], expected);
4552        Ok(())
4553    }
4554
4555    #[test]
4556    fn pixel_canvas_uses_theme_paper_for_render_and_export() -> sui_core::Result<()> {
4557        let mut theme = DefaultTheme::default();
4558        theme.surfaces.pixel_canvas_paper = Color::rgba(0.80, 0.62, 0.36, 1.0);
4559        let state = PixelCanvasState::new();
4560        state.set_display_visible(false);
4561        let (mut runtime, window_id) = build_runtime(
4562            PixelCanvas::new("Paint", 1, 1)
4563                .theme(theme)
4564                .state(state.clone())
4565                .with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
4566        );
4567        let paper = PixelColor::from_color(theme.surfaces.pixel_canvas_paper);
4568        let expected = [paper.red, paper.green, paper.blue, paper.alpha];
4569
4570        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4571        assert_rgba_channels_near(&pixels[0..4], expected);
4572
4573        state.request_export_snapshot();
4574        runtime.handle_event(
4575            window_id,
4576            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4577        )?;
4578        let snapshot = state
4579            .latest_export_snapshot()
4580            .expect("hidden layer export should publish a snapshot");
4581        assert_rgba_channels_near(&snapshot.rgba8()[0..4], expected);
4582        Ok(())
4583    }
4584
4585    #[test]
4586    fn pixel_canvas_explicit_paper_color_overrides_theme_for_render_and_export()
4587    -> sui_core::Result<()> {
4588        let mut theme = DefaultTheme::default();
4589        theme.surfaces.pixel_canvas_paper = Color::rgba(0.80, 0.62, 0.36, 1.0);
4590        let paper_color = Color::WHITE;
4591        let state = PixelCanvasState::new();
4592        state.set_display_visible(false);
4593        let (mut runtime, window_id) = build_runtime(
4594            PixelCanvas::new("Paint", 1, 1)
4595                .theme(theme)
4596                .paper_color(paper_color)
4597                .state(state.clone())
4598                .with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
4599        );
4600        let paper = PixelColor::from_color(paper_color);
4601        let expected = [paper.red, paper.green, paper.blue, paper.alpha];
4602
4603        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4604        assert_rgba_channels_near(&pixels[0..4], expected);
4605
4606        state.request_export_snapshot();
4607        runtime.handle_event(
4608            window_id,
4609            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4610        )?;
4611        let snapshot = state
4612            .latest_export_snapshot()
4613            .expect("explicit paper export should publish a snapshot");
4614        assert_rgba_channels_near(&snapshot.rgba8()[0..4], expected);
4615        Ok(())
4616    }
4617
4618    #[test]
4619    fn pixel_canvas_display_opacity_and_blend_affect_rendered_image() -> sui_core::Result<()> {
4620        let state = PixelCanvasState::new();
4621        state.set_display_opacity(0.5);
4622        let (mut runtime, window_id) = build_runtime(
4623            PixelCanvas::new("Paint", 1, 1)
4624                .state(state.clone())
4625                .with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
4626        );
4627        let paper = PixelColor::from_color(DefaultTheme::default().surfaces.pixel_canvas_paper);
4628        let half = paper.compose(
4629            Color::rgba(1.0, 0.0, 0.0, 1.0),
4630            0.5,
4631            PixelCanvasBlendMode::Normal,
4632        );
4633
4634        let output = runtime.render(window_id)?;
4635        let source = rendered_pixel_image_source(&output);
4636        assert_eq!(source.tint, Some(Color::WHITE.with_alpha(0.5)));
4637        let pixels = rendered_pixel_bytes(&output);
4638        assert_rgba_channels_near(&pixels[0..4], [255, 0, 0, 255]);
4639
4640        state.request_export_snapshot();
4641        runtime.handle_event(
4642            window_id,
4643            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4644        )?;
4645        let snapshot = state
4646            .latest_export_snapshot()
4647            .expect("display opacity export should publish composited pixels");
4648        assert_rgba_channels_near(
4649            &snapshot.rgba8()[0..4],
4650            [half.red, half.green, half.blue, half.alpha],
4651        );
4652
4653        state.set_display_opacity(1.0);
4654        state.set_display_blend_mode(PixelCanvasBlendMode::Multiply);
4655        runtime.handle_event(
4656            window_id,
4657            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4658        )?;
4659        let multiply = paper.compose(
4660            Color::rgba(1.0, 0.0, 0.0, 1.0),
4661            1.0,
4662            PixelCanvasBlendMode::Multiply,
4663        );
4664        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4665        assert_rgba_channels_near(
4666            &pixels[0..4],
4667            [multiply.red, multiply.green, multiply.blue, multiply.alpha],
4668        );
4669        Ok(())
4670    }
4671
4672    #[test]
4673    fn pixel_canvas_layer_opacity_reuses_registered_data_between_repaints() -> sui_core::Result<()>
4674    {
4675        let state = PixelCanvasState::new();
4676        state.set_display_opacity(0.5);
4677        let (mut runtime, window_id) = build_runtime(
4678            PixelCanvas::new("Paint", 1, 1)
4679                .state(state)
4680                .with_pixels(vec![Color::rgba(1.0, 0.0, 0.0, 1.0)]),
4681        );
4682
4683        let first = runtime.render(window_id)?;
4684        let second = runtime.render(window_id)?;
4685
4686        assert!(std::ptr::addr_eq(
4687            rendered_pixel_image(&first).bytes().as_ptr(),
4688            rendered_pixel_image(&second).bytes().as_ptr()
4689        ));
4690        Ok(())
4691    }
4692
4693    #[test]
4694    fn pixel_canvas_paper_visibility_affects_render_and_export() -> sui_core::Result<()> {
4695        let state = PixelCanvasState::new();
4696        state.set_paper_visible(false);
4697        let (mut runtime, window_id) =
4698            build_runtime(PixelCanvas::new("Paint", 1, 1).state(state.clone()));
4699
4700        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4701        assert_rgba_channels_near(&pixels[0..4], [0, 0, 0, 0]);
4702
4703        state.request_export_snapshot();
4704        runtime.handle_event(
4705            window_id,
4706            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4707        )?;
4708        let snapshot = state
4709            .latest_export_snapshot()
4710            .expect("hidden paper export should publish a snapshot");
4711        assert_rgba_channels_near(&snapshot.rgba8()[0..4], [0, 0, 0, 0]);
4712        Ok(())
4713    }
4714
4715    #[test]
4716    fn pixel_canvas_paper_opacity_affects_composited_background() -> sui_core::Result<()> {
4717        let state = PixelCanvasState::new();
4718        state.set_paper_opacity(0.5);
4719        let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 1, 1).state(state));
4720        let paper = PixelColor::from_color(
4721            DefaultTheme::default()
4722                .surfaces
4723                .pixel_canvas_paper
4724                .with_alpha(0.5),
4725        );
4726        let expected = [paper.red, paper.green, paper.blue, paper.alpha];
4727
4728        let pixels = rendered_pixel_bytes(&runtime.render(window_id)?);
4729        assert_rgba_channels_near(&pixels[0..4], expected);
4730        Ok(())
4731    }
4732
4733    #[test]
4734    fn pixel_canvas_state_export_request_publishes_rgba_snapshot() -> sui_core::Result<()> {
4735        let state = PixelCanvasState::new();
4736        let (mut runtime, window_id) = build_runtime(
4737            PixelCanvas::from_fn("Export", 2, 2, |x, y| {
4738                if x == 0 && y == 0 {
4739                    Color::rgba(1.0, 0.0, 0.0, 1.0)
4740                } else {
4741                    Color::rgba(0.0, 0.0, 0.0, 0.0)
4742                }
4743            })
4744            .state(state.clone()),
4745        );
4746
4747        let _ = runtime.render(window_id)?;
4748        assert!(state.latest_export_snapshot().is_none());
4749
4750        state.request_export_snapshot();
4751        runtime.handle_event(
4752            window_id,
4753            Event::Window(WindowEvent::Resized(Size::new(521.0, 361.0))),
4754        )?;
4755        let _ = runtime.render(window_id)?;
4756
4757        let snapshot = state
4758            .latest_export_snapshot()
4759            .expect("export request should publish a snapshot");
4760        assert_eq!(snapshot.name(), "Export");
4761        assert_eq!(snapshot.width(), 2);
4762        assert_eq!(snapshot.height(), 2);
4763        assert_eq!(snapshot.byte_len(), 16);
4764        assert_rgba_channels_near(&snapshot.rgba8()[0..4], [255, 0, 0, 255]);
4765        assert_eq!(snapshot.revision(), 1);
4766        Ok(())
4767    }
4768
4769    #[test]
4770    fn pixel_canvas_state_tracks_cursor_document_position() -> sui_core::Result<()> {
4771        let state = PixelCanvasState::new();
4772        let (mut runtime, window_id) =
4773            build_runtime(PixelCanvas::new("Paint", 8, 8).state(state.clone()));
4774        let output = runtime.render(window_id)?;
4775        let canvas = output
4776            .semantics
4777            .iter()
4778            .find(|node| node.role == SemanticsRole::Canvas)
4779            .expect("canvas semantics should exist");
4780        let center = Point::new(
4781            canvas.bounds.x() + canvas.bounds.width() * 0.5,
4782            canvas.bounds.y() + canvas.bounds.height() * 0.5,
4783        );
4784
4785        runtime.handle_event(
4786            window_id,
4787            primary_pointer(PointerEventKind::Move, center, false),
4788        )?;
4789        assert_eq!(state.cursor_position(), Some(Point::new(4.0, 4.0)));
4790
4791        runtime.handle_event(
4792            window_id,
4793            primary_pointer(
4794                PointerEventKind::Move,
4795                Point::new(canvas.bounds.max_x() + 12.0, canvas.bounds.max_y() + 12.0),
4796                false,
4797            ),
4798        )?;
4799        assert_eq!(state.cursor_position(), None);
4800        Ok(())
4801    }
4802
4803    #[test]
4804    fn pixel_canvas_state_view_requests_update_zoom_during_arrange() -> sui_core::Result<()> {
4805        let state = PixelCanvasState::new();
4806        let canvas = PixelCanvas::new("Paint", 8, 8)
4807            .viewport(
4808                CanvasViewport::new()
4809                    .pan(Vector::new(40.0, 16.0))
4810                    .zoom(0.25),
4811            )
4812            .state(state.clone());
4813        let (mut runtime, window_id) = build_runtime(canvas);
4814
4815        let _ = runtime.render(window_id)?;
4816        state.request_actual_size_view();
4817        runtime.handle_event(
4818            window_id,
4819            Event::Window(WindowEvent::Resized(Size::new(320.0, 240.0))),
4820        )?;
4821        let actual_size = runtime.render(window_id)?;
4822        assert_eq!(pixel_canvas_zoom_percent(&actual_size), 100.0);
4823
4824        state.request_fit_view();
4825        runtime.handle_event(
4826            window_id,
4827            Event::Window(WindowEvent::Resized(Size::new(400.0, 300.0))),
4828        )?;
4829        let fit = runtime.render(window_id)?;
4830        assert!(pixel_canvas_zoom_percent(&fit) > 1000.0);
4831        Ok(())
4832    }
4833
4834    #[test]
4835    fn pixel_canvas_state_zoom_requests_update_view_during_arrange() -> sui_core::Result<()> {
4836        let state = PixelCanvasState::new();
4837        let canvas = PixelCanvas::new("Paint", 8, 8)
4838            .viewport(CanvasViewport::new().zoom(1.0))
4839            .state(state.clone());
4840        let (mut runtime, window_id) = build_runtime(canvas);
4841
4842        let _ = runtime.render(window_id)?;
4843        state.request_zoom_in();
4844        runtime.handle_event(
4845            window_id,
4846            Event::Window(WindowEvent::Resized(Size::new(320.0, 240.0))),
4847        )?;
4848        let zoomed_in = runtime.render(window_id)?;
4849        assert_eq!(pixel_canvas_zoom_percent(&zoomed_in), 110.0);
4850
4851        state.request_zoom_out();
4852        runtime.handle_event(
4853            window_id,
4854            Event::Window(WindowEvent::Resized(Size::new(320.0, 240.0))),
4855        )?;
4856        let zoomed_out = runtime.render(window_id)?;
4857        assert_eq!(pixel_canvas_zoom_percent(&zoomed_out), 100.0);
4858        Ok(())
4859    }
4860
4861    #[test]
4862    fn pixel_canvas_can_fit_initial_view_on_first_layout() {
4863        let state = PixelCanvasState::new();
4864        let output = render(
4865            PixelCanvas::new("Paint", 1920, 1080)
4866                .state(state.clone())
4867                .fit_on_first_layout(),
4868        );
4869
4870        assert_eq!(pixel_canvas_zoom_percent(&output), 25.0);
4871        assert_eq!(state.viewport_size(), Size::new(520.0, 360.0));
4872        let padding = DefaultTheme::default().metrics.pixel_canvas_fit_padding;
4873        let expected_zoom = ((state.viewport_size().width - padding * 2.0) / 1920.0)
4874            .min((state.viewport_size().height - padding * 2.0) / 1080.0);
4875        assert!((state.viewport().zoom - expected_zoom).abs() < 0.001);
4876    }
4877
4878    #[test]
4879    fn pixel_canvas_draws_one_image_instead_of_per_pixel_rects() {
4880        let output = render(
4881            PixelCanvas::from_fn("Large paint", 1920, 1080, |x, y| {
4882                Color::rgba(x as f32 / 1919.0, y as f32 / 1079.0, 0.5, 1.0)
4883            })
4884            .viewport(CanvasViewport::new().zoom(0.28)),
4885        );
4886
4887        let mut image_handle = None;
4888        let mut image_command_count = 0;
4889        let mut fill_command_count = 0;
4890        output
4891            .frame
4892            .scene
4893            .visit_commands(&mut |command| match command {
4894                SceneCommand::DrawImage { source, .. }
4895                | SceneCommand::DrawImageQuad { source, .. } => {
4896                    image_handle = Some(source.image);
4897                    image_command_count += 1;
4898                }
4899                SceneCommand::FillPath { .. } | SceneCommand::FillRect { .. } => {
4900                    fill_command_count += 1;
4901                }
4902                _ => {}
4903            });
4904
4905        assert_eq!(image_command_count, 1);
4906        assert!(
4907            fill_command_count <= 5,
4908            "pixel canvas should only issue bounded workbench, shadow, and paper fills"
4909        );
4910        let mut sampling = None;
4911        output.frame.scene.visit_commands(&mut |command| {
4912            if let SceneCommand::DrawImage { source, .. }
4913            | SceneCommand::DrawImageQuad { source, .. } = command
4914            {
4915                sampling = Some(source.sampling);
4916            }
4917        });
4918        assert_eq!(sampling, Some(ImageSampling::Linear));
4919        let image = output
4920            .frame
4921            .image_registry
4922            .get(image_handle.expect("pixel canvas should draw an image"))
4923            .expect("pixel canvas image should be registered");
4924        assert_eq!(image.width(), 1920);
4925        assert_eq!(image.height(), 1080);
4926        assert!(
4927            !image.mipmaps_enabled(),
4928            "mutable pixel canvases should not rebuild mipmaps for every brush update"
4929        );
4930    }
4931
4932    #[test]
4933    fn pixel_canvas_uses_nearest_sampling_at_pixel_zoom() {
4934        let output = render(PixelCanvas::new("Paint", 8, 8));
4935
4936        let mut sampling = None;
4937        output.frame.scene.visit_commands(&mut |command| {
4938            if let SceneCommand::DrawImage { source, .. }
4939            | SceneCommand::DrawImageQuad { source, .. } = command
4940            {
4941                sampling = Some(source.sampling);
4942            }
4943        });
4944
4945        assert_eq!(sampling, Some(ImageSampling::Nearest));
4946    }
4947
4948    #[test]
4949    fn shift_wheel_rotates_pixel_canvas() -> sui_core::Result<()> {
4950        let (mut runtime, window_id) = build_runtime(PixelCanvas::new("Paint", 8, 8));
4951        let _ = runtime.render(window_id)?;
4952
4953        let mut scroll = PointerEvent::new(PointerEventKind::Scroll, Point::new(260.0, 180.0));
4954        scroll.modifiers = Modifiers {
4955            shift: true,
4956            ..Modifiers::NONE
4957        };
4958        scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, 24.0)));
4959        runtime.handle_event(window_id, Event::Pointer(scroll))?;
4960        let output = runtime.render(window_id)?;
4961        let canvas = output
4962            .semantics
4963            .iter()
4964            .find(|node| {
4965                node.role == SemanticsRole::Canvas && node.name.as_deref() == Some("Paint")
4966            })
4967            .expect("pixel canvas semantics present");
4968
4969        assert!(
4970            canvas
4971                .value
4972                .as_ref()
4973                .is_some_and(|value| format!("{value:?}").contains("rotation"))
4974        );
4975        Ok(())
4976    }
4977
4978    #[test]
4979    fn pixel_canvas_builder_accepts_resolution_pixels() {
4980        let pixels = vec![Color::rgba(1.0, 0.0, 0.0, 1.0); 4];
4981        let canvas = PixelCanvas::new("Paint", 2, 2)
4982            .with_pixels(pixels)
4983            .desired_size(Size::new(64.0, 64.0));
4984
4985        assert_eq!(canvas.width(), 2);
4986        assert_eq!(canvas.height(), 2);
4987        assert_eq!(canvas.pixel_at(1, 1), Some(Color::rgba(1.0, 0.0, 0.0, 1.0)));
4988    }
4989}