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