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