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