Use a vector for ItemRenderer::translate (#1700)

This simplifes call sites and implementations.

internal/backends/qt/qt_window.rs

@@ -19,7 +19,9 @@ use i_slint_core::items::{
     PointerEventButton, RenderingResult, TextOverflow, TextWrap, WindowItem,
 };
 use i_slint_core::layout::Orientation;
-use i_slint_core::lengths::{LogicalLength, LogicalPoint, LogicalRect, LogicalSize, ScaleFactor};
+use i_slint_core::lengths::{
+    LogicalLength, LogicalPoint, LogicalRect, LogicalSize, LogicalVector, ScaleFactor,
+};
 use i_slint_core::window::{WindowAdapter, WindowAdapterSealed, WindowInner};
 use i_slint_core::{ImageInner, PathData, Property, SharedString};
 use items::{ImageFit, TextHorizontalAlignment, TextVerticalAlignment};
@@ -940,9 +942,9 @@ impl ItemRenderer for QtItemRenderer<'_> {
         Some(&mut self.painter)
     }
 
-    fn translate(&mut self, x: LogicalLength, y: LogicalLength) {
-        let x: f32 = x.get();
-        let y: f32 = y.get();
+    fn translate(&mut self, distance: LogicalVector) {
+        let x: f32 = distance.x;
+        let y: f32 = distance.y;
         let painter: &mut QPainterPtr = &mut self.painter;
         cpp! { unsafe [painter as "QPainterPtr*", x as "float", y as "float"] {
             (*painter)->translate(x, y);

internal/backends/winit/renderer/femtovg/itemrenderer.rs

@@ -6,7 +6,7 @@ use std::pin::Pin;
 use std::rc::Rc;
 
 use euclid::approxeq::ApproxEq;
-use i_slint_core::graphics::euclid::{self, Vector2D};
+use i_slint_core::graphics::euclid::{self};
 use i_slint_core::graphics::rendering_metrics_collector::RenderingMetrics;
 use i_slint_core::graphics::{Image, IntRect, Point, Size};
 use i_slint_core::item_rendering::{ItemCache, ItemRenderer};
@@ -15,8 +15,8 @@ use i_slint_core::items::{
     RenderingResult,
 };
 use i_slint_core::lengths::{
-    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalRect, LogicalSize, PointLengths,
-    RectLengths, ScaleFactor,
+    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalRect, LogicalSize, LogicalVector,
+    PointLengths, RectLengths, ScaleFactor,
 };
 use i_slint_core::window::WindowInner;
 use i_slint_core::{Brush, Color, ImageInner, Property, SharedString};
@@ -882,12 +882,11 @@ impl<'a> ItemRenderer for GLItemRenderer<'a> {
         None
     }
 
-    fn translate(&mut self, x: LogicalLength, y: LogicalLength) {
-        self.canvas
-            .borrow_mut()
-            .translate((x * self.scale_factor).get(), (y * self.scale_factor).get());
+    fn translate(&mut self, distance: LogicalVector) {
+        let physical_distance = distance * self.scale_factor;
+        self.canvas.borrow_mut().translate(physical_distance.x, physical_distance.y);
         let clip = &mut self.state.last_mut().unwrap().scissor;
-        *clip = clip.translate(Vector2D::from_lengths(-x, -y))
+        *clip = clip.translate(-distance)
     }
 
     fn rotate(&mut self, angle_in_degrees: f32) {

internal/backends/winit/renderer/skia/itemrenderer.rs

@@ -8,8 +8,8 @@ use i_slint_core::graphics::euclid;
 use i_slint_core::item_rendering::{ItemCache, ItemRenderer};
 use i_slint_core::items::{ImageFit, ImageRendering, ItemRc, Layer, Opacity, RenderingResult};
 use i_slint_core::lengths::{
-    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalRect, LogicalSize, RectLengths,
-    ScaleFactor,
+    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalRect, LogicalSize, LogicalVector,
+    RectLengths, ScaleFactor,
 };
 use i_slint_core::window::WindowInner;
 use i_slint_core::{items, Brush, Color, Property};
@@ -647,11 +647,9 @@ impl<'a> ItemRenderer for SkiaRenderer<'a> {
         from_skia_rect(&self.canvas.local_clip_bounds().unwrap_or_default()) / self.scale_factor
     }
 
-    fn translate(&mut self, x: LogicalLength, y: LogicalLength) {
-        self.canvas.translate(skia_safe::Vector::from((
-            (x * self.scale_factor).get(),
-            (y * self.scale_factor).get(),
-        )));
+    fn translate(&mut self, distance: LogicalVector) {
+        let distance = distance * self.scale_factor;
+        self.canvas.translate(skia_safe::Vector::from((distance.x, distance.y)));
     }
 
     fn rotate(&mut self, angle_in_degrees: f32) {

internal/core/item_rendering.rs

@@ -12,7 +12,7 @@ use crate::item_tree::{
     ItemRc, ItemVisitor, ItemVisitorResult, ItemVisitorVTable, VisitChildrenResult,
 };
 use crate::lengths::{
-    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalPx, LogicalRect, PointLengths,
+    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalPx, LogicalRect, LogicalVector,
 };
 use crate::Coord;
 use alloc::boxed::Box;
@@ -175,7 +175,7 @@ pub fn render_item_children(
             let (do_draw, item_geometry) = renderer.filter_item(item);
 
             let item_origin = item_geometry.origin;
-            renderer.translate(item_origin.x_length(), item_origin.y_length());
+            renderer.translate(item_origin.to_vector());
 
             // Don't render items that are clipped, with the exception of the Clip or Flickable since
             // they themselves clip their content.
@@ -214,7 +214,7 @@ pub fn render_component_items(
     origin: LogicalPoint,
 ) {
     renderer.save_state();
-    renderer.translate(origin.x_length(), origin.y_length());
+    renderer.translate(origin.to_vector());
 
     render_item_children(renderer, component, -1);
 
@@ -319,7 +319,7 @@ pub trait ItemRenderer {
     /// Get the current clip bounding box in the current transformed coordinate.
     fn get_current_clip(&self) -> LogicalRect;
 
-    fn translate(&mut self, x: LogicalLength, y: LogicalLength);
+    fn translate(&mut self, distance: LogicalVector);
     fn rotate(&mut self, angle_in_degrees: f32);
     /// Apply the opacity (between 0 and 1) for all following items until the next call to restore_state.
     fn apply_opacity(&mut self, opacity: f32);
@@ -525,8 +525,8 @@ impl<'a, T: ItemRenderer> ItemRenderer for PartialRenderer<'a, T> {
         self.actual_renderer.get_current_clip()
     }
 
-    fn translate(&mut self, x: LogicalLength, y: LogicalLength) {
-        self.actual_renderer.translate(x, y)
+    fn translate(&mut self, distance: LogicalVector) {
+        self.actual_renderer.translate(distance)
     }
 
     fn rotate(&mut self, angle_in_degrees: f32) {

internal/core/items.rs

@@ -28,7 +28,7 @@ use crate::input::{
 use crate::item_rendering::CachedRenderingData;
 pub use crate::item_tree::ItemRc;
 use crate::layout::{LayoutInfo, Orientation};
-use crate::lengths::LogicalLength;
+use crate::lengths::{LogicalLength, LogicalVector};
 #[cfg(feature = "rtti")]
 use crate::rtti::*;
 use crate::window::{WindowAdapter, WindowAdapterRc, WindowInner};
@@ -983,11 +983,13 @@ impl Item for Rotate {
         backend: &mut ItemRendererRef,
         _self_rc: &ItemRc,
     ) -> RenderingResult {
-        let origin_x = self.logical_rotation_origin_x();
-        let origin_y = self.logical_rotation_origin_y();
-        (*backend).translate(origin_x, origin_y);
+        let origin = LogicalVector::from_lengths(
+            self.logical_rotation_origin_x(),
+            self.logical_rotation_origin_y(),
+        );
+        (*backend).translate(origin);
         (*backend).rotate(self.rotation_angle());
-        (*backend).translate(-origin_x, -origin_y);
+        (*backend).translate(-origin);
         RenderingResult::ContinueRenderingChildren
     }
 }

internal/core/lengths.rs

@@ -13,6 +13,7 @@ pub type LogicalLength = euclid::Length<Coord, LogicalPx>;
 pub type LogicalRect = euclid::Rect<Coord, LogicalPx>;
 pub type LogicalPoint = euclid::Point2D<Coord, LogicalPx>;
 pub type LogicalSize = euclid::Size2D<Coord, LogicalPx>;
+pub type LogicalVector = euclid::Vector2D<Coord, LogicalPx>;
 
 pub type ScaleFactor = euclid::Scale<f32, LogicalPx, PhysicalPx>;
 
@@ -48,6 +49,16 @@ impl<T: Copy, U> PointLengths for euclid::Point2D<T, U> {
     }
 }
 
+impl<T: Copy, U> PointLengths for euclid::Vector2D<T, U> {
+    type LengthType = euclid::Length<T, U>;
+    fn x_length(&self) -> Self::LengthType {
+        euclid::Length::new(self.x)
+    }
+    fn y_length(&self) -> Self::LengthType {
+        euclid::Length::new(self.y)
+    }
+}
+
 pub trait RectLengths {
     type SizeType;
     type LengthType;

internal/core/software_renderer.rs

@@ -13,8 +13,8 @@ use crate::graphics::{IntRect, PixelFormat, SharedImageBuffer};
 use crate::item_rendering::ItemRenderer;
 use crate::items::{ImageFit, ItemRc};
 use crate::lengths::{
-    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalRect, LogicalSize, PhysicalPx,
-    PointLengths, RectLengths, ScaleFactor, SizeLengths,
+    LogicalItemGeometry, LogicalLength, LogicalPoint, LogicalRect, LogicalSize, LogicalVector,
+    PhysicalPx, PointLengths, RectLengths, ScaleFactor, SizeLengths,
 };
 use crate::renderer::Renderer;
 use crate::textlayout::{FontMetrics as _, TextParagraphLayout};
@@ -1254,10 +1254,9 @@ impl<'a, T: ProcessScene> crate::item_rendering::ItemRenderer for SceneBuilder<'
         self.current_state.clip
     }
 
-    fn translate(&mut self, x: LogicalLength, y: LogicalLength) {
-        let translation_vec = LogicalSize::from_lengths(x, y).to_vector();
-        self.current_state.offset += translation_vec;
-        self.current_state.clip = self.current_state.clip.translate(-translation_vec)
+    fn translate(&mut self, distance: LogicalVector) {
+        self.current_state.offset += distance;
+        self.current_state.clip = self.current_state.clip.translate(-distance)
     }
 
     fn rotate(&mut self, _angle_in_degrees: f32) {