Skip to main content

sui_widgets/
canvas.rs

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