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