Migrate to new Rectangle functions

21 files changed, 106 insertions, 105 deletions

diff --git a/src/handlers/xdg_shell.rs b/src/handlers/xdg_shell.rs
index df8cb456..f9b41567 100644
--- a/src/handlers/xdg_shell.rs
+++ b/src/handlers/xdg_shell.rs
@@ -1050,7 +1050,7 @@ impl State {
 
         // The target geometry for the positioner should be relative to its parent's geometry, so
         // we will compute that here.
-        let mut target = Rectangle::from_loc_and_size((0, 0), output_geo.size);
+        let mut target = Rectangle::from_size(output_geo.size);
         target.loc -= layer_geo.loc;
         target.loc -= get_popup_toplevel_coords(popup);
 
diff --git a/src/layout/floating.rs b/src/layout/floating.rs
index 1453415c..3705f9ef 100644
--- a/src/layout/floating.rs
+++ b/src/layout/floating.rs
@@ -330,7 +330,7 @@ impl<W: LayoutElement> FloatingSpace<W> {
         let (tile, offset) = self.tiles_with_offsets().next()?;
 
         let tile_size = tile.tile_size();
-        let tile_rect = Rectangle::from_loc_and_size(offset, tile_size);
+        let tile_rect = Rectangle::new(offset, tile_size);
 
         self.working_area.intersection(tile_rect)
     }
@@ -1105,7 +1105,7 @@ impl<W: LayoutElement> FloatingSpace<W> {
         pos: Point<f64, Logical>,
         size: Size<f64, Logical>,
     ) -> Point<f64, Logical> {
-        let mut rect = Rectangle::from_loc_and_size(pos, size);
+        let mut rect = Rectangle::new(pos, size);
         clamp_preferring_top_left_in_area(self.working_area, &mut rect);
         rect.loc
     }
diff --git a/src/layout/focus_ring.rs b/src/layout/focus_ring.rs
index 7cd73760..b6c65b3f 100644
--- a/src/layout/focus_ring.rs
+++ b/src/layout/focus_ring.rs
@@ -94,7 +94,7 @@ impl FocusRing {
             in_: GradientInterpolation::default(),
         });
 
-        let full_rect = Rectangle::from_loc_and_size((-width, -width), self.full_size);
+        let full_rect = Rectangle::new(Point::from((-width, -width)), self.full_size);
         let gradient_area = match gradient.relative_to {
             GradientRelativeTo::Window => full_rect,
             GradientRelativeTo::WorkspaceView => view_rect,
@@ -178,12 +178,12 @@ impl FocusRing {
             for (border, (loc, size)) in zip(&mut self.borders, zip(self.locations, self.sizes)) {
                 border.update(
                     size,
-                    Rectangle::from_loc_and_size(gradient_area.loc - loc, gradient_area.size),
+                    Rectangle::new(gradient_area.loc - loc, gradient_area.size),
                     gradient.in_,
                     gradient.from,
                     gradient.to,
                     ((gradient.angle as f32) - 90.).to_radians(),
-                    Rectangle::from_loc_and_size(full_rect.loc - loc, full_rect.size),
+                    Rectangle::new(full_rect.loc - loc, full_rect.size),
                     rounded_corner_border_width,
                     radius,
                     scale as f32,
@@ -196,15 +196,12 @@ impl FocusRing {
 
             self.borders[0].update(
                 self.sizes[0],
-                Rectangle::from_loc_and_size(
-                    gradient_area.loc - self.locations[0],
-                    gradient_area.size,
-                ),
+                Rectangle::new(gradient_area.loc - self.locations[0], gradient_area.size),
                 gradient.in_,
                 gradient.from,
                 gradient.to,
                 ((gradient.angle as f32) - 90.).to_radians(),
-                Rectangle::from_loc_and_size(full_rect.loc - self.locations[0], full_rect.size),
+                Rectangle::new(full_rect.loc - self.locations[0], full_rect.size),
                 rounded_corner_border_width,
                 radius,
                 scale as f32,
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 081a5f35..4923282b 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -1289,7 +1289,7 @@ impl<W: LayoutElement> Layout<W> {
                 // window geometry.
                 let width = move_.tile.window_size().w;
                 let height = output_size(&move_.output).h;
-                let mut target = Rectangle::from_loc_and_size((0., 0.), (width, height));
+                let mut target = Rectangle::from_size(Size::from((width, height)));
                 // FIXME: ideally this shouldn't include the tile render offset, but the code
                 // duplication would be a bit annoying for this edge case.
                 target.loc.y -= move_.tile_render_location().y;
@@ -2405,10 +2405,8 @@ impl<W: LayoutElement> Layout<W> {
         if let Some(InteractiveMoveState::Moving(move_)) = &mut self.interactive_move {
             if output.map_or(true, |output| move_.output == *output) {
                 let pos_within_output = move_.tile_render_location();
-                let view_rect = Rectangle::from_loc_and_size(
-                    pos_within_output.upscale(-1.),
-                    output_size(&move_.output),
-                );
+                let view_rect =
+                    Rectangle::new(pos_within_output.upscale(-1.), output_size(&move_.output));
                 move_.tile.update(true, view_rect);
             }
         }
@@ -4121,7 +4119,7 @@ mod tests {
                 id,
                 parent_id: None,
                 is_floating: false,
-                bbox: Rectangle::from_loc_and_size((0, 0), (100, 200)),
+                bbox: Rectangle::from_size(Size::from((100, 200))),
                 min_max_size: Default::default(),
             }
         }
@@ -4295,7 +4293,7 @@ mod tests {
         any::<(i16, i16, u16, u16)>().prop_map(|(x, y, w, h)| {
             let loc: Point<i32, _> = Point::from((x.into(), y.into()));
             let size: Size<i32, _> = Size::from((w.max(1).into(), h.max(1).into()));
-            Rectangle::from_loc_and_size(loc, size)
+            Rectangle::new(loc, size)
         })
     }
 
@@ -6078,7 +6076,7 @@ mod tests {
 
         Op::AddWindow {
             params: TestWindowParams {
-                bbox: Rectangle::from_loc_and_size((0, 0), (1280, 200)),
+                bbox: Rectangle::from_size(Size::from((1280, 200))),
                 ..TestWindowParams::new(1)
             },
         }
diff --git a/src/layout/monitor.rs b/src/layout/monitor.rs
index 13079319..2de3c760 100644
--- a/src/layout/monitor.rs
+++ b/src/layout/monitor.rs
@@ -7,7 +7,7 @@ use smithay::backend::renderer::element::utils::{
     CropRenderElement, Relocate, RelocateRenderElement,
 };
 use smithay::output::Output;
-use smithay::utils::{Logical, Point, Rectangle};
+use smithay::utils::{Logical, Point, Rectangle, Size};
 
 use super::scrolling::{Column, ColumnWidth};
 use super::tile::Tile;
@@ -871,7 +871,7 @@ impl<W: LayoutElement> Monitor<W> {
             let offset = switch.target_idx() - self.active_workspace_idx as f64;
             let offset = offset * size.h;
 
-            let clip_rect = Rectangle::from_loc_and_size((0., -offset), size);
+            let clip_rect = Rectangle::new(Point::from((0., -offset)), size);
             rect = rect.intersection(clip_rect)?;
         }
 
@@ -930,7 +930,7 @@ impl<W: LayoutElement> Monitor<W> {
         let size = output_size(&self.output);
         let (ws, bounds) = self
             .workspaces_with_render_positions()
-            .map(|(ws, offset)| (ws, Rectangle::from_loc_and_size(offset, size)))
+            .map(|(ws, offset)| (ws, Rectangle::new(offset, size)))
             .find(|(_, bounds)| bounds.contains(pos_within_output))?;
         Some((ws, bounds.loc))
     }
@@ -983,9 +983,15 @@ impl<W: LayoutElement> Monitor<W> {
         //
         // FIXME: use proper bounds after fixing the Crop element.
         let crop_bounds = if self.workspace_switch.is_some() {
-            Rectangle::from_loc_and_size((-i32::MAX / 2, 0), (i32::MAX, height))
+            Rectangle::new(
+                Point::from((-i32::MAX / 2, 0)),
+                Size::from((i32::MAX, height)),
+            )
         } else {
-            Rectangle::from_loc_and_size((-i32::MAX / 2, -i32::MAX / 2), (i32::MAX, i32::MAX))
+            Rectangle::new(
+                Point::from((-i32::MAX / 2, -i32::MAX / 2)),
+                Size::from((i32::MAX, i32::MAX)),
+            )
         };
 
         self.workspaces_with_render_positions()
diff --git a/src/layout/opening_window.rs b/src/layout/opening_window.rs
index 0a3d4973..f64aef88 100644
--- a/src/layout/opening_window.rs
+++ b/src/layout/opening_window.rs
@@ -72,7 +72,7 @@ impl OpenAnimation {
         let texture_size = geo.size.to_f64().to_logical(scale);
 
         if Shaders::get(renderer).program(ProgramType::Open).is_some() {
-            let mut area = Rectangle::from_loc_and_size(location + offset, texture_size);
+            let mut area = Rectangle::new(location + offset, texture_size);
 
             // Expand the area a bit to allow for more varied effects.
             let mut target_size = area.size.upscale(1.5);
diff --git a/src/layout/scrolling.rs b/src/layout/scrolling.rs
index bdafdb71..89975736 100644
--- a/src/layout/scrolling.rs
+++ b/src/layout/scrolling.rs
@@ -335,13 +335,13 @@ impl<W: LayoutElement> ScrollingSpace<W> {
             let is_active = is_active && col_idx == active_idx;
             let col_off = Point::from((col_x, 0.));
             let col_pos = view_pos - col_off - col.render_offset();
-            let view_rect = Rectangle::from_loc_and_size(col_pos, view_size);
+            let view_rect = Rectangle::new(col_pos, view_size);
             col.update_render_elements(is_active, view_rect);
         }
 
         if let Some(insert_hint) = &self.insert_hint {
             if let Some(area) = self.insert_hint_area(insert_hint) {
-                let view_rect = Rectangle::from_loc_and_size(area.loc.upscale(-1.), view_size);
+                let view_rect = Rectangle::new(area.loc.upscale(-1.), view_size);
                 self.insert_hint_element.update_render_elements(
                     area.size,
                     view_rect,
@@ -1919,7 +1919,7 @@ impl<W: LayoutElement> ScrollingSpace<W> {
                     if column_index == 0 && !self.columns.is_empty() {
                         loc.x -= size.w + self.options.gaps;
                     }
-                    Rectangle::from_loc_and_size(loc, size)
+                    Rectangle::new(loc, size)
                 } else if column_index > self.columns.len() {
                     error!("insert hint column index is out of range");
                     return None;
@@ -1930,7 +1930,7 @@ impl<W: LayoutElement> ScrollingSpace<W> {
                         self.column_x(column_index) - size.w / 2. - self.options.gaps / 2.,
                         self.working_area.loc.y + self.options.gaps,
                     ));
-                    Rectangle::from_loc_and_size(loc, size)
+                    Rectangle::new(loc, size)
                 }
             }
             InsertPosition::InColumn(column_index, tile_index) => {
@@ -1963,7 +1963,7 @@ impl<W: LayoutElement> ScrollingSpace<W> {
 
                 let size = Size::from((self.data[column_index].width, height));
                 let loc = Point::from((self.column_x(column_index), y));
-                Rectangle::from_loc_and_size(loc, size)
+                Rectangle::new(loc, size)
             }
             InsertPosition::Floating => return None,
         };
@@ -2010,9 +2010,9 @@ impl<W: LayoutElement> ScrollingSpace<W> {
 
         let tile_pos = view_off + tile_off;
         let tile_size = tile.tile_size();
-        let tile_rect = Rectangle::from_loc_and_size(tile_pos, tile_size);
+        let tile_rect = Rectangle::new(tile_pos, tile_size);
 
-        let view = Rectangle::from_loc_and_size((0., 0.), self.view_size);
+        let view = Rectangle::from_size(self.view_size);
         view.intersection(tile_rect)
     }
 
@@ -2256,7 +2256,7 @@ impl<W: LayoutElement> ScrollingSpace<W> {
         }
 
         // Draw the closing windows on top of the other windows.
-        let view_rect = Rectangle::from_loc_and_size((self.view_pos(), 0.), self.view_size);
+        let view_rect = Rectangle::new(Point::from((self.view_pos(), 0.)), self.view_size);
         for closing in self.closing_windows.iter().rev() {
             let elem = closing.render(renderer.as_gles_renderer(), view_rect, scale, target);
             rv.push(elem.into());
@@ -3731,7 +3731,7 @@ impl<W: LayoutElement> Column<W> {
                 let width = tile.window_size().w;
                 let height = self.view_size.h;
 
-                let mut target = Rectangle::from_loc_and_size((0., 0.), (width, height));
+                let mut target = Rectangle::from_size(Size::from((width, height)));
                 target.loc.y -= pos.y;
                 target.loc.y -= tile.window_loc().y;
 
@@ -4028,7 +4028,7 @@ mod tests {
             bottom: FloatOrInt(1.),
         };
 
-        let parent_area = Rectangle::from_loc_and_size((0., 0.), (1280., 720.));
+        let parent_area = Rectangle::from_size(Size::from((1280., 720.)));
         let area = compute_working_area(parent_area, 1., struts);
 
         assert_eq!(round_logical_in_physical(1., area.loc.x), area.loc.x);
@@ -4044,7 +4044,7 @@ mod tests {
             bottom: FloatOrInt(0.),
         };
 
-        let parent_area = Rectangle::from_loc_and_size((0., 0.), (1280., 720.));
+        let parent_area = Rectangle::from_size(Size::from((1280., 720.)));
         compute_working_area(parent_area, 1., struts);
     }
 }
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index 96936d26..163dd673 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -318,7 +318,7 @@ impl<W: LayoutElement> Tile<W> {
             self.animated_window_size(),
             is_active,
             !draw_border_with_background,
-            Rectangle::from_loc_and_size(
+            Rectangle::new(
                 view_rect.loc - Point::from((border_width, border_width)),
                 view_rect.size,
             ),
@@ -590,7 +590,7 @@ impl<W: LayoutElement> Tile<W> {
     }
 
     pub fn is_in_activation_region(&self, point: Point<f64, Logical>) -> bool {
-        let activation_region = Rectangle::from_loc_and_size((0., 0.), self.tile_size());
+        let activation_region = Rectangle::from_size(self.tile_size());
         activation_region.contains(point)
     }
 
@@ -711,7 +711,7 @@ impl<W: LayoutElement> Tile<W> {
         let window_size = self.window_size().to_f64();
         let animated_window_size = self.animated_window_size();
         let window_render_loc = location + window_loc;
-        let area = Rectangle::from_loc_and_size(window_render_loc, animated_window_size);
+        let area = Rectangle::new(window_render_loc, animated_window_size);
 
         let rules = self.window.rules();
         let clip_to_geometry = !self.is_fullscreen && rules.clip_to_geometry == Some(true);
@@ -810,7 +810,7 @@ impl<W: LayoutElement> Tile<W> {
                 .window
                 .render(renderer, window_render_loc, scale, alpha, target);
 
-            let geo = Rectangle::from_loc_and_size(window_render_loc, window_size);
+            let geo = Rectangle::new(window_render_loc, window_size);
             let radius = radius.fit_to(window_size.w as f32, window_size.h as f32);
 
             let clip_shader = ClippedSurfaceRenderElement::shader(renderer).cloned();
@@ -852,12 +852,12 @@ impl<W: LayoutElement> Tile<W> {
                     if radius != CornerRadius::default() && has_border_shader {
                         return BorderRenderElement::new(
                             geo.size,
-                            Rectangle::from_loc_and_size((0., 0.), geo.size),
+                            Rectangle::from_size(geo.size),
                             GradientInterpolation::default(),
                             Color::from_color32f(elem.color()),
                             Color::from_color32f(elem.color()),
                             0.,
-                            Rectangle::from_loc_and_size((0., 0.), geo.size),
+                            Rectangle::from_size(geo.size),
                             0.,
                             radius,
                             scale.x as f32,
diff --git a/src/layout/workspace.rs b/src/layout/workspace.rs
index 25a03987..b11b46ac 100644
--- a/src/layout/workspace.rs
+++ b/src/layout/workspace.rs
@@ -260,7 +260,7 @@ impl<W: LayoutElement> Workspace<W> {
             Rc::new(Options::clone(&base_options).adjusted_for_scale(scale.fractional_scale()));
 
         let view_size = Size::from((1280., 720.));
-        let working_area = Rectangle::from_loc_and_size((0., 0.), (1280., 720.));
+        let working_area = Rectangle::from_size(Size::from((1280., 720.)));
 
         let scrolling = ScrollingSpace::new(
             view_size,
@@ -337,7 +337,7 @@ impl<W: LayoutElement> Workspace<W> {
         self.scrolling
             .update_render_elements(is_active && !self.floating_is_active.get());
 
-        let view_rect = Rectangle::from_loc_and_size((0., 0.), self.view_size);
+        let view_rect = Rectangle::from_size(self.view_size);
         self.floating
             .update_render_elements(is_active && self.floating_is_active.get(), view_rect);
     }
@@ -1332,7 +1332,7 @@ impl<W: LayoutElement> Workspace<W> {
 
         let floating_focus_ring = focus_ring && self.floating_is_active();
         let floating = self.is_floating_visible().then(|| {
-            let view_rect = Rectangle::from_loc_and_size((0., 0.), self.view_size);
+            let view_rect = Rectangle::from_size(self.view_size);
             let floating = self.floating.render_elements(
                 renderer,
                 view_rect,
@@ -1364,7 +1364,7 @@ impl<W: LayoutElement> Workspace<W> {
         for (tile, tile_pos) in self.tiles_with_render_positions_mut(false) {
             if tile.window().id() == window {
                 let view_pos = Point::from((-tile_pos.x, -tile_pos.y));
-                let view_rect = Rectangle::from_loc_and_size(view_pos, view_size);
+                let view_rect = Rectangle::new(view_pos, view_size);
                 tile.update(false, view_rect);
                 tile.store_unmap_snapshot_if_empty(renderer, output_scale);
                 return;
diff --git a/src/niri.rs b/src/niri.rs
index 198e079e..8ac85270 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -2169,7 +2169,7 @@ impl Niri {
                 .map(|pos| Point::from((pos.x, pos.y)))
                 .filter(|pos| {
                     // Ensure that the requested position does not overlap any existing output.
-                    let target_geom = Rectangle::from_loc_and_size(*pos, size);
+                    let target_geom = Rectangle::new(*pos, size);
 
                     let overlap = self
                         .global_space
@@ -2651,9 +2651,9 @@ impl Niri {
     pub fn output_left(&self) -> Option<Output> {
         let active = self.layout.active_output()?;
         let active_geo = self.global_space.output_geometry(active).unwrap();
-        let extended_geo = Rectangle::from_loc_and_size(
-            (i32::MIN / 2, active_geo.loc.y),
-            (i32::MAX, active_geo.size.h),
+        let extended_geo = Rectangle::new(
+            Point::from((i32::MIN / 2, active_geo.loc.y)),
+            Size::from((i32::MAX, active_geo.size.h)),
         );
 
         self.global_space
@@ -2668,9 +2668,9 @@ impl Niri {
     pub fn output_right(&self) -> Option<Output> {
         let active = self.layout.active_output()?;
         let active_geo = self.global_space.output_geometry(active).unwrap();
-        let extended_geo = Rectangle::from_loc_and_size(
-            (i32::MIN / 2, active_geo.loc.y),
-            (i32::MAX, active_geo.size.h),
+        let extended_geo = Rectangle::new(
+            Point::from((i32::MIN / 2, active_geo.loc.y)),
+            Size::from((i32::MAX, active_geo.size.h)),
         );
 
         self.global_space
@@ -2685,9 +2685,9 @@ impl Niri {
     pub fn output_up(&self) -> Option<Output> {
         let active = self.layout.active_output()?;
         let active_geo = self.global_space.output_geometry(active).unwrap();
-        let extended_geo = Rectangle::from_loc_and_size(
-            (active_geo.loc.x, i32::MIN / 2),
-            (active_geo.size.w, i32::MAX),
+        let extended_geo = Rectangle::new(
+            Point::from((active_geo.loc.x, i32::MIN / 2)),
+            Size::from((active_geo.size.w, i32::MAX)),
         );
 
         self.global_space
@@ -2746,9 +2746,9 @@ impl Niri {
     pub fn output_down(&self) -> Option<Output> {
         let active = self.layout.active_output()?;
         let active_geo = self.global_space.output_geometry(active).unwrap();
-        let extended_geo = Rectangle::from_loc_and_size(
-            (active_geo.loc.x, i32::MIN / 2),
-            (active_geo.size.w, i32::MAX),
+        let extended_geo = Rectangle::new(
+            Point::from((active_geo.loc.x, i32::MIN / 2)),
+            Size::from((active_geo.size.w, i32::MAX)),
         );
 
         self.global_space
diff --git a/src/protocols/screencopy.rs b/src/protocols/screencopy.rs
index 1a301e7a..6ca1485e 100644
--- a/src/protocols/screencopy.rs
+++ b/src/protocols/screencopy.rs
@@ -206,9 +206,9 @@ where
                 let output_transform = output.current_transform();
                 let output_physical_size =
                     output_transform.transform_size(output.current_mode().unwrap().size);
-                let output_rect = Rectangle::from_loc_and_size((0, 0), output_physical_size);
+                let output_rect = Rectangle::from_size(output_physical_size);
 
-                let rect = Rectangle::from_loc_and_size((x, y), (width, height));
+                let rect = Rectangle::new(Point::from((x, y)), Size::from((width, height)));
 
                 let output_scale = output.current_scale().fractional_scale();
                 let physical_rect = rect.to_physical_precise_round(output_scale);
diff --git a/src/render_helpers/clipped_surface.rs b/src/render_helpers/clipped_surface.rs
index f8d4e3aa..34f6c5b4 100644
--- a/src/render_helpers/clipped_surface.rs
+++ b/src/render_helpers/clipped_surface.rs
@@ -6,7 +6,7 @@ use smithay::backend::renderer::gles::{
     GlesError, GlesFrame, GlesRenderer, GlesTexProgram, Uniform,
 };
 use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
-use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size, Transform};
+use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
 
 use super::damage::ExtraDamage;
 use super::renderer::{AsGlesFrame as _, NiriRenderer};
@@ -117,21 +117,21 @@ impl<R: NiriRenderer> ClippedSurfaceRenderElement<R> {
         let bottom_left = corner_radius.bottom_left as f64;
 
         [
-            Rectangle::from_loc_and_size(geo.loc, (top_left, top_left)),
-            Rectangle::from_loc_and_size(
-                (geo.loc.x + geo.size.w - top_right, geo.loc.y),
-                (top_right, top_right),
+            Rectangle::new(geo.loc, Size::from((top_left, top_left))),
+            Rectangle::new(
+                Point::from((geo.loc.x + geo.size.w - top_right, geo.loc.y)),
+                Size::from((top_right, top_right)),
             ),
-            Rectangle::from_loc_and_size(
-                (
+            Rectangle::new(
+                Point::from((
                     geo.loc.x + geo.size.w - bottom_right,
                     geo.loc.y + geo.size.h - bottom_right,
-                ),
-                (bottom_right, bottom_right),
+                )),
+                Size::from((bottom_right, bottom_right)),
             ),
-            Rectangle::from_loc_and_size(
-                (geo.loc.x, geo.loc.y + geo.size.h - bottom_left),
-                (bottom_left, bottom_left),
+            Rectangle::new(
+                Point::from((geo.loc.x, geo.loc.y + geo.size.h - bottom_left)),
+                Size::from((bottom_left, bottom_left)),
             ),
         ]
     }
diff --git a/src/render_helpers/damage.rs b/src/render_helpers/damage.rs
index e05ee649..328851e8 100644
--- a/src/render_helpers/damage.rs
+++ b/src/render_helpers/damage.rs
@@ -54,7 +54,7 @@ impl Element for ExtraDamage {
     }
 
     fn src(&self) -> Rectangle<f64, Buffer> {
-        Rectangle::from_loc_and_size((0., 0.), (1., 1.))
+        Rectangle::from_size(Size::from((1., 1.)))
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
diff --git a/src/render_helpers/mod.rs b/src/render_helpers/mod.rs
index 32a571c9..98ccf19e 100644
--- a/src/render_helpers/mod.rs
+++ b/src/render_helpers/mod.rs
@@ -216,7 +216,7 @@ pub fn render_and_download(
 
     let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
     let mapping = renderer
-        .copy_framebuffer(Rectangle::from_loc_and_size((0, 0), buffer_size), fourcc)
+        .copy_framebuffer(Rectangle::from_size(buffer_size), fourcc)
         .context("error copying framebuffer")?;
     Ok(mapping)
 }
@@ -300,7 +300,7 @@ fn render_elements(
     elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
 ) -> anyhow::Result<SyncPoint> {
     let transform = transform.invert();
-    let output_rect = Rectangle::from_loc_and_size((0, 0), transform.transform_size(size));
+    let output_rect = Rectangle::from_size(transform.transform_size(size));
 
     let mut frame = renderer
         .render(size, transform)
diff --git a/src/render_helpers/resize.rs b/src/render_helpers/resize.rs
index 8eed17e5..f8cbadda 100644
--- a/src/render_helpers/resize.rs
+++ b/src/render_helpers/resize.rs
@@ -43,7 +43,7 @@ impl ResizeRenderElement {
         let tex_next_geo_scaled = tex_next_geo.to_f64().upscale(scale_next);
         let combined_geo = tex_prev_geo_scaled.merge(tex_next_geo_scaled).to_i32_up();
 
-        let area = Rectangle::from_loc_and_size(
+        let area = Rectangle::new(
             area.loc + combined_geo.loc.to_logical(scale),
             combined_geo.size.to_logical(scale),
         );
diff --git a/src/render_helpers/shader_element.rs b/src/render_helpers/shader_element.rs
index e683154e..4f5163d9 100644
--- a/src/render_helpers/shader_element.rs
+++ b/src/render_helpers/shader_element.rs
@@ -193,7 +193,7 @@ impl ShaderRenderElement {
             program,
             id: Id::new(),
             commit_counter: CommitCounter::default(),
-            area: Rectangle::from_loc_and_size((0., 0.), size),
+            area: Rectangle::from_size(size),
             opaque_regions: opaque_regions.unwrap_or_default(),
             scale,
             alpha,
@@ -255,7 +255,7 @@ impl Element for ShaderRenderElement {
     }
 
     fn src(&self) -> Rectangle<f64, Buffer> {
-        Rectangle::from_loc_and_size((0., 0.), (1., 1.))
+        Rectangle::from_size(Size::from((1., 1.)))
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
@@ -314,7 +314,7 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
                     (dest_size.to_point() - rect_constrained_loc).to_size(),
                 );
 
-                let rect = Rectangle::from_loc_and_size(rect_constrained_loc, rect_clamped_size);
+                let rect = Rectangle::new(rect_constrained_loc, rect_clamped_size);
                 [
                     rect.loc.x as f32,
                     rect.loc.y as f32,
@@ -334,7 +334,7 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
                     (dest_size.to_point() - rect_constrained_loc).to_size(),
                 );
 
-                let rect = Rectangle::from_loc_and_size(rect_constrained_loc, rect_clamped_size);
+                let rect = Rectangle::new(rect_constrained_loc, rect_clamped_size);
                 // Add the 4 f32s per damage rectangle for each of the 6 vertices.
                 (0..6).flat_map(move |_| {
                     [
diff --git a/src/render_helpers/solid_color.rs b/src/render_helpers/solid_color.rs
index cdda19c8..5dfb5843 100644
--- a/src/render_helpers/solid_color.rs
+++ b/src/render_helpers/solid_color.rs
@@ -85,7 +85,7 @@ impl SolidColorRenderElement {
         alpha: f32,
         kind: Kind,
     ) -> Self {
-        let geo = Rectangle::from_loc_and_size(location, buffer.size());
+        let geo = Rectangle::new(location.into(), buffer.size());
         let color = buffer.color * alpha;
         Self::new(buffer.id.clone(), geo, buffer.commit, color, kind)
     }
@@ -125,7 +125,7 @@ impl Element for SolidColorRenderElement {
     }
 
     fn src(&self) -> Rectangle<f64, Buffer> {
-        Rectangle::from_loc_and_size((0., 0.), (1., 1.))
+        Rectangle::from_size(Size::from((1., 1.)))
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
@@ -134,8 +134,7 @@ impl Element for SolidColorRenderElement {
 
     fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         if self.color.is_opaque() {
-            let rect = Rectangle::from_loc_and_size((0., 0.), self.geometry.size)
-                .to_physical_precise_down(scale);
+            let rect = Rectangle::from_size(self.geometry.size).to_physical_precise_down(scale);
             OpaqueRegions::from_slice(&[rect])
         } else {
             OpaqueRegions::default()
diff --git a/src/render_helpers/texture.rs b/src/render_helpers/texture.rs
index b7b45c65..8273c6f6 100644
--- a/src/render_helpers/texture.rs
+++ b/src/render_helpers/texture.rs
@@ -157,7 +157,7 @@ impl<T: Texture> Element for TextureRenderElement<T> {
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
-        let logical_geo = Rectangle::from_loc_and_size(self.location, self.logical_size());
+        let logical_geo = Rectangle::new(self.location, self.logical_size());
         logical_geo.to_physical_precise_round(scale)
     }
 
@@ -174,9 +174,7 @@ impl<T: Texture> Element for TextureRenderElement<T> {
                     &self.buffer.logical_size(),
                 )
             })
-            .unwrap_or_else(|| {
-                Rectangle::from_loc_and_size((0, 0), self.buffer.texture.size()).to_f64()
-            })
+            .unwrap_or_else(|| Rectangle::from_size(self.buffer.texture.size()).to_f64())
     }
 
     fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
diff --git a/src/ui/screenshot_ui.rs b/src/ui/screenshot_ui.rs
index f7d1bd1a..4f2dba3e 100644
--- a/src/ui/screenshot_ui.rs
+++ b/src/ui/screenshot_ui.rs
@@ -127,9 +127,9 @@ impl ScreenshotUi {
                 let size = output_transform.transform_size(output_mode.size);
                 (
                     output,
-                    Rectangle::from_loc_and_size(
-                        (size.w / 4, size.h / 4),
-                        (size.w / 2, size.h / 2),
+                    Rectangle::new(
+                        Point::from((size.w / 4, size.h / 4)),
+                        Size::from((size.w / 2, size.h / 2)),
                     ),
                 )
             }
@@ -268,10 +268,10 @@ impl ScreenshotUi {
 
             if output == selection_output {
                 // Check if the selection is still valid. If not, reset it back to default.
-                if !Rectangle::from_loc_and_size((0, 0), size).contains_rect(rect) {
-                    rect = Rectangle::from_loc_and_size(
-                        (size.w / 4, size.h / 4),
-                        (size.w / 2, size.h / 2),
+                if !Rectangle::from_size(size).contains_rect(rect) {
+                    rect = Rectangle::new(
+                        Point::from((size.w / 4, size.h / 4)),
+