layout: Make geom.rs logical geoemetry types more ergonomic (#32633)

Make using the logical geometry types more ergonomic by having them all
implement `Copy` (at most 4 64-bit numbers), similar to what `euclid`
does. In addition add an implementation of `Neg` for `LogicalVec` and
`LogicalSides` as it will be used in upcoming table implementation code.
This commit is contained in:
Martin Robinson 2024-06-28 10:20:50 +02:00 committed by GitHub
parent e9cf4d4971
commit adc0fc984d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 80 additions and 102 deletions

View file

@ -617,7 +617,7 @@ impl<'a> BuilderForBoxFragment<'a> {
let radii = inner_radii( let radii = inner_radii(
self.border_radius, self.border_radius,
(&self.fragment.border + &self.fragment.padding) (self.fragment.border + self.fragment.padding)
.to_physical(self.fragment.style.writing_mode) .to_physical(self.fragment.style.writing_mode)
.to_webrender(), .to_webrender(),
); );

View file

@ -266,6 +266,6 @@ where
inline: flow_relative_base_rect_size.inline - flow_relative_offsets.inline_end, inline: flow_relative_base_rect_size.inline - flow_relative_offsets.inline_end,
block: flow_relative_base_rect_size.block - flow_relative_offsets.block_end, block: flow_relative_base_rect_size.block - flow_relative_offsets.block_end,
}; };
let size = &end_corner_position - &start_corner; let size = end_corner_position - start_corner;
LogicalRect { start_corner, size } LogicalRect { start_corner, size }
} }

View file

@ -428,7 +428,7 @@ impl FlexContainer {
}, },
}; };
for (fragment, _) in &mut line.item_fragments { for (fragment, _) in &mut line.item_fragments {
fragment.content_rect.start_corner += &flow_relative_line_position fragment.content_rect.start_corner += flow_relative_line_position
} }
line.item_fragments line.item_fragments
}); });

View file

@ -897,7 +897,7 @@ impl FloatBox {
// or non-replaced. // or non-replaced.
let pbm = style.padding_border_margin(containing_block); let pbm = style.padding_border_margin(containing_block);
let margin = pbm.margin.auto_is(Au::zero); let margin = pbm.margin.auto_is(Au::zero);
let pbm_sums = &(&pbm.padding + &pbm.border) + &margin.clone(); let pbm_sums = pbm.padding + pbm.border + margin;
let (content_size, children); let (content_size, children);
match self.contents { match self.contents {
@ -1208,10 +1208,10 @@ impl SequentialLayoutState {
block_start_of_containing_block_in_bfc + block_offset_from_containing_block_top, block_start_of_containing_block_in_bfc + block_offset_from_containing_block_top,
); );
let pbm_sums = &(&box_fragment.padding + &box_fragment.border) + &box_fragment.margin; let pbm_sums = box_fragment.padding + box_fragment.border + box_fragment.margin;
let content_rect = box_fragment.content_rect.clone(); let content_rect = &box_fragment.content_rect;
let margin_box_start_corner = self.floats.add_float(&PlacementInfo { let margin_box_start_corner = self.floats.add_float(&PlacementInfo {
size: &content_rect.size + &pbm_sums.sum(), size: content_rect.size + pbm_sums.sum(),
side: FloatSide::from_style(&box_fragment.style).expect("Float box wasn't floated!"), side: FloatSide::from_style(&box_fragment.style).expect("Float box wasn't floated!"),
clear: box_fragment.style.get_box().clear, clear: box_fragment.style.get_box().clear,
}); });
@ -1219,7 +1219,7 @@ impl SequentialLayoutState {
// This is the position of the float in the float-containing block formatting context. We add the // This is the position of the float in the float-containing block formatting context. We add the
// existing start corner here because we may have already gotten some relative positioning offset. // existing start corner here because we may have already gotten some relative positioning offset.
let new_position_in_bfc = let new_position_in_bfc =
&(&margin_box_start_corner + &pbm_sums.start_offset()) + &content_rect.start_corner; margin_box_start_corner + pbm_sums.start_offset() + content_rect.start_corner;
// This is the position of the float relative to the containing block start. // This is the position of the float relative to the containing block start.
let new_position_in_containing_block = LogicalVec2 { let new_position_in_containing_block = LogicalVec2 {

View file

@ -223,10 +223,10 @@ impl TextRunLineItem {
// The block start of the TextRun is often zero (meaning it has the same font metrics as the // The block start of the TextRun is often zero (meaning it has the same font metrics as the
// inline box's strut), but for children of the inline formatting context root or for // inline box's strut), but for children of the inline formatting context root or for
// fallback fonts that use baseline relatve alignment, it might be different. // fallback fonts that use baseline relatve alignment, it might be different.
let start_corner = &LogicalVec2 { let start_corner = LogicalVec2 {
inline: state.inline_position, inline: state.inline_position,
block: (state.baseline_offset - self.font_metrics.ascent).into(), block: (state.baseline_offset - self.font_metrics.ascent).into(),
} - &state.parent_offset; } - state.parent_offset;
let rect = LogicalRect { let rect = LogicalRect {
start_corner, start_corner,
@ -283,8 +283,8 @@ impl InlineBoxLineItem {
state: &mut LineItemLayoutState, state: &mut LineItemLayoutState,
) -> Option<BoxFragment> { ) -> Option<BoxFragment> {
let style = self.style.clone(); let style = self.style.clone();
let mut padding = self.pbm.padding.clone(); let mut padding = self.pbm.padding;
let mut border = self.pbm.border.clone(); let mut border = self.pbm.border;
let mut margin = self.pbm.margin.auto_is(Au::zero); let mut margin = self.pbm.margin.auto_is(Au::zero);
if !self.is_first_fragment { if !self.is_first_fragment {
@ -297,7 +297,7 @@ impl InlineBoxLineItem {
border.inline_end = Au::zero(); border.inline_end = Au::zero();
margin.inline_end = Au::zero(); margin.inline_end = Au::zero();
} }
let pbm_sums = &(&padding + &border) + &margin; let pbm_sums = padding + border + margin;
state.inline_position += pbm_sums.inline_start.into(); state.inline_position += pbm_sums.inline_start.into();
let space_above_baseline = self.calculate_space_above_baseline(); let space_above_baseline = self.calculate_space_above_baseline();
@ -335,7 +335,7 @@ impl InlineBoxLineItem {
border.inline_end = Au::zero(); border.inline_end = Au::zero();
margin.inline_end = Au::zero(); margin.inline_end = Au::zero();
} }
let pbm_sums = &(&padding + &border) + &margin.clone(); let pbm_sums = padding + border + margin;
// If the inline box didn't have any content at all, don't add a Fragment for it. // If the inline box didn't have any content at all, don't add a Fragment for it.
let box_has_padding_border_or_margin = pbm_sums.inline_sum() > Au::zero(); let box_has_padding_border_or_margin = pbm_sums.inline_sum() > Au::zero();
@ -361,13 +361,13 @@ impl InlineBoxLineItem {
}; };
// Make `content_rect` relative to the parent Fragment. // Make `content_rect` relative to the parent Fragment.
content_rect.start_corner = &content_rect.start_corner - &state.parent_offset; content_rect.start_corner -= state.parent_offset;
// Relative adjustment should not affect the rest of line layout, so we can // Relative adjustment should not affect the rest of line layout, so we can
// do it right before creating the Fragment. // do it right before creating the Fragment.
if style.clone_position().is_relative() { if style.clone_position().is_relative() {
content_rect.start_corner += content_rect.start_corner +=
&relative_adjustement(&style, state.ifc_containing_block).into(); relative_adjustement(&style, state.ifc_containing_block).into();
} }
let mut fragment = BoxFragment::new( let mut fragment = BoxFragment::new(
@ -466,12 +466,11 @@ impl AtomicLineItem {
self.calculate_block_start(state.line_metrics).into(); self.calculate_block_start(state.line_metrics).into();
// Make the final result relative to the parent box. // Make the final result relative to the parent box.
self.fragment.content_rect.start_corner = self.fragment.content_rect.start_corner -= state.parent_offset.into();
&self.fragment.content_rect.start_corner - &state.parent_offset.into();
if self.fragment.style.clone_position().is_relative() { if self.fragment.style.clone_position().is_relative() {
self.fragment.content_rect.start_corner += self.fragment.content_rect.start_corner +=
&relative_adjustement(&self.fragment.style, state.ifc_containing_block); relative_adjustement(&self.fragment.style, state.ifc_containing_block);
} }
state.inline_position += self.size.inline.into(); state.inline_position += self.size.inline.into();
@ -571,8 +570,7 @@ impl FloatLineItem {
inline: state.parent_offset.inline, inline: state.parent_offset.inline,
block: state.line_metrics.block_offset + state.parent_offset.block, block: state.line_metrics.block_offset + state.parent_offset.block,
}; };
self.fragment.content_rect.start_corner = self.fragment.content_rect.start_corner -= distance_from_parent_to_ifc.into();
&self.fragment.content_rect.start_corner - &distance_from_parent_to_ifc.into();
self.fragment self.fragment
} }
} }

View file

@ -1206,7 +1206,7 @@ impl<'a, 'b> InlineFormattingContextState<'a, 'b> {
); );
let mut placement_rect = placement.place(); let mut placement_rect = placement.place();
placement_rect.start_corner = &placement_rect.start_corner - &ifc_offset_in_float_container; placement_rect.start_corner -= ifc_offset_in_float_container;
placement_rect.into() placement_rect.into()
} }
@ -2026,7 +2026,7 @@ impl IndependentFormattingContext {
let style = self.style(); let style = self.style();
let pbm = style.padding_border_margin(ifc.containing_block); let pbm = style.padding_border_margin(ifc.containing_block);
let margin = pbm.margin.auto_is(Au::zero); let margin = pbm.margin.auto_is(Au::zero);
let pbm_sums = &(&pbm.padding + &pbm.border) + &margin.clone(); let pbm_sums = pbm.padding + pbm.border + margin;
let mut child_positioning_context = None; let mut child_positioning_context = None;
// We need to know the inline size of the atomic before deciding whether to do the line break. // We need to know the inline size of the atomic before deciding whether to do the line break.
@ -2156,7 +2156,7 @@ impl IndependentFormattingContext {
ifc.process_soft_wrap_opportunity(); ifc.process_soft_wrap_opportunity();
} }
let size = &pbm_sums.sum() + &fragment.content_rect.size; let size = pbm_sums.sum() + fragment.content_rect.size;
let baseline_offset = self let baseline_offset = self
.pick_baseline(&fragment.baselines) .pick_baseline(&fragment.baselines)
.map(|baseline| pbm_sums.block_start + baseline) .map(|baseline| pbm_sums.block_start + baseline)
@ -2171,7 +2171,7 @@ impl IndependentFormattingContext {
); );
ifc.push_line_item_to_unbreakable_segment(LineItem::Atomic(AtomicLineItem { ifc.push_line_item_to_unbreakable_segment(LineItem::Atomic(AtomicLineItem {
fragment, fragment,
size: size.into(), size,
positioning_context: child_positioning_context, positioning_context: child_positioning_context,
baseline_offset_in_parent, baseline_offset_in_parent,
baseline_offset_in_item: baseline_offset, baseline_offset_in_item: baseline_offset,
@ -2402,7 +2402,7 @@ impl<'a> ContentSizesComputation<'a> {
.percentages_relative_to(zero) .percentages_relative_to(zero)
.auto_is(Length::zero); .auto_is(Length::zero);
let pbm = &(&margin + &padding) + &border; let pbm = margin + padding + border;
if inline_box.is_first_fragment { if inline_box.is_first_fragment {
self.add_length(pbm.inline_start); self.add_length(pbm.inline_start);
} }

View file

@ -1086,7 +1086,7 @@ impl NonReplacedFormattingContext {
&collapsed_margin_block_start, &collapsed_margin_block_start,
containing_block, containing_block,
&pbm, &pbm,
&content_size + &pbm.padding_border_sums.into(), content_size + pbm.padding_border_sums.into(),
&self.style, &self.style,
); );
} else { } else {
@ -1102,12 +1102,10 @@ impl NonReplacedFormattingContext {
}); });
// Create a PlacementAmongFloats using the minimum size in all dimensions as the object size. // Create a PlacementAmongFloats using the minimum size in all dimensions as the object size.
let minimum_size_of_block = &LogicalVec2 { let minimum_size_of_block = LogicalVec2 {
inline: min_box_size.inline, inline: min_box_size.inline.into(),
block: block_size.auto_is(|| min_box_size.block), block: block_size.auto_is(|| min_box_size.block).into(),
} } + pbm.padding_border_sums;
.into() +
&pbm.padding_border_sums;
let mut placement = PlacementAmongFloats::new( let mut placement = PlacementAmongFloats::new(
&sequential_layout_state.floats, &sequential_layout_state.floats,
ceiling, ceiling,
@ -1291,7 +1289,7 @@ fn layout_in_flow_replaced_block_level(
// than defined by section 10.3.3. CSS 2 does not define when a UA may put said // than defined by section 10.3.3. CSS 2 does not define when a UA may put said
// element next to the float or by how much said element may become narrower." // element next to the float or by how much said element may become narrower."
let collapsed_margin_block_start = CollapsedMargin::new(margin_block_start); let collapsed_margin_block_start = CollapsedMargin::new(margin_block_start);
let size = &content_size + &pbm.padding_border_sums.clone(); let size = content_size + pbm.padding_border_sums;
( (
clearance, clearance,
(margin_inline_start, margin_inline_end), (margin_inline_start, margin_inline_end),

View file

@ -4,7 +4,7 @@
use std::convert::From; use std::convert::From;
use std::fmt; use std::fmt;
use std::ops::{Add, AddAssign, Sub, SubAssign}; use std::ops::{Add, AddAssign, Neg, Sub, SubAssign};
use app_units::Au; use app_units::Au;
use serde::Serialize; use serde::Serialize;
@ -32,13 +32,13 @@ pub struct LogicalVec2<T> {
pub block: T, pub block: T,
} }
#[derive(Clone, Serialize)] #[derive(Clone, Copy, Serialize)]
pub struct LogicalRect<T> { pub struct LogicalRect<T> {
pub start_corner: LogicalVec2<T>, pub start_corner: LogicalVec2<T>,
pub size: LogicalVec2<T>, pub size: LogicalVec2<T>,
} }
#[derive(Clone, Debug, Serialize)] #[derive(Clone, Copy, Debug, Serialize)]
pub struct LogicalSides<T> { pub struct LogicalSides<T> {
pub inline_start: T, pub inline_start: T,
pub inline_end: T, pub inline_end: T,
@ -79,13 +79,9 @@ impl<T: Clone> LogicalVec2<T> {
} }
} }
impl<T> Add<&'_ LogicalVec2<T>> for &'_ LogicalVec2<T> impl<T: Add<Output = T> + Copy> Add<LogicalVec2<T>> for LogicalVec2<T> {
where
T: Add<Output = T> + Copy,
{
type Output = LogicalVec2<T>; type Output = LogicalVec2<T>;
fn add(self, other: Self) -> Self::Output {
fn add(self, other: &'_ LogicalVec2<T>) -> Self::Output {
LogicalVec2 { LogicalVec2 {
inline: self.inline + other.inline, inline: self.inline + other.inline,
block: self.block + other.block, block: self.block + other.block,
@ -93,13 +89,9 @@ where
} }
} }
impl<T> Sub<&'_ LogicalVec2<T>> for &'_ LogicalVec2<T> impl<T: Sub<Output = T> + Copy> Sub<LogicalVec2<T>> for LogicalVec2<T> {
where
T: Sub<Output = T> + Copy,
{
type Output = LogicalVec2<T>; type Output = LogicalVec2<T>;
fn sub(self, other: Self) -> Self::Output {
fn sub(self, other: &'_ LogicalVec2<T>) -> Self::Output {
LogicalVec2 { LogicalVec2 {
inline: self.inline - other.inline, inline: self.inline - other.inline,
block: self.block - other.block, block: self.block - other.block,
@ -107,41 +99,27 @@ where
} }
} }
impl<T> AddAssign<&'_ LogicalVec2<T>> for LogicalVec2<T> impl<T: AddAssign<T> + Copy> AddAssign<LogicalVec2<T>> for LogicalVec2<T> {
where fn add_assign(&mut self, other: LogicalVec2<T>) {
T: AddAssign<T> + Copy,
{
fn add_assign(&mut self, other: &'_ LogicalVec2<T>) {
self.inline += other.inline; self.inline += other.inline;
self.block += other.block; self.block += other.block;
} }
} }
impl<T> AddAssign<LogicalVec2<T>> for LogicalVec2<T> impl<T: SubAssign<T> + Copy> SubAssign<LogicalVec2<T>> for LogicalVec2<T> {
where fn sub_assign(&mut self, other: LogicalVec2<T>) {
T: AddAssign<T> + Copy,
{
fn add_assign(&mut self, other: LogicalVec2<T>) {
self.add_assign(&other);
}
}
impl<T> SubAssign<&'_ LogicalVec2<T>> for LogicalVec2<T>
where
T: SubAssign<T> + Copy,
{
fn sub_assign(&mut self, other: &'_ LogicalVec2<T>) {
self.inline -= other.inline; self.inline -= other.inline;
self.block -= other.block; self.block -= other.block;
} }
} }
impl<T> SubAssign<LogicalVec2<T>> for LogicalVec2<T> impl<T: Neg<Output = T> + Copy> Neg for LogicalVec2<T> {
where type Output = LogicalVec2<T>;
T: SubAssign<T> + Copy, fn neg(self) -> Self::Output {
{ Self {
fn sub_assign(&mut self, other: LogicalVec2<T>) { inline: -self.inline,
self.sub_assign(&other); block: -self.block,
}
} }
} }
@ -352,10 +330,7 @@ impl<T> LogicalSides<T> {
} }
} }
impl<T> LogicalSides<T> impl<T: Copy> LogicalSides<T> {
where
T: Copy,
{
pub fn start_offset(&self) -> LogicalVec2<T> { pub fn start_offset(&self) -> LogicalVec2<T> {
LogicalVec2 { LogicalVec2 {
inline: self.inline_start, inline: self.inline_start,
@ -382,13 +357,10 @@ impl<T: Clone> LogicalSides<AutoOr<T>> {
} }
} }
impl<T> Add<&'_ LogicalSides<T>> for &'_ LogicalSides<T> impl<T: Add<Output = T> + Copy> Add<LogicalSides<T>> for LogicalSides<T> {
where
T: Add<Output = T> + Copy,
{
type Output = LogicalSides<T>; type Output = LogicalSides<T>;
fn add(self, other: &'_ LogicalSides<T>) -> Self::Output { fn add(self, other: Self) -> Self::Output {
LogicalSides { LogicalSides {
inline_start: self.inline_start + other.inline_start, inline_start: self.inline_start + other.inline_start,
inline_end: self.inline_end + other.inline_end, inline_end: self.inline_end + other.inline_end,
@ -398,6 +370,18 @@ where
} }
} }
impl<T: Neg<Output = T> + Copy> Neg for LogicalSides<T> {
type Output = LogicalSides<T>;
fn neg(self) -> Self::Output {
Self {
inline_start: -self.inline_start,
inline_end: -self.inline_end,
block_start: -self.block_start,
block_end: -self.block_end,
}
}
}
impl<T: Zero> LogicalSides<T> { impl<T: Zero> LogicalSides<T> {
pub(crate) fn zero() -> LogicalSides<T> { pub(crate) fn zero() -> LogicalSides<T> {
LogicalSides { LogicalSides {

View file

@ -240,8 +240,7 @@ impl PositioningContext {
self.append(new_context); self.append(new_context);
if style.clone_position() == Position::Relative { if style.clone_position() == Position::Relative {
new_fragment.content_rect.start_corner += new_fragment.content_rect.start_corner += relative_adjustement(style, containing_block);
&relative_adjustement(style, containing_block);
} }
new_fragment new_fragment
@ -690,7 +689,7 @@ impl HoistedAbsolutelyPositionedBox {
block_end: block_axis.margin_end, block_end: block_axis.margin_end,
}; };
let pb = &pbm.padding + &pbm.border; let pb = pbm.padding + pbm.border;
let inline_start = match inline_axis.anchor { let inline_start = match inline_axis.anchor {
Anchor::Start(start) => start + pb.inline_start + margin.inline_start, Anchor::Start(start) => start + pb.inline_start + margin.inline_start,
Anchor::End(end) => { Anchor::End(end) => {

View file

@ -1079,8 +1079,8 @@ impl<'a> TableLayout<'a> {
Some(CellLayout { Some(CellLayout {
layout, layout,
padding: padding.clone(), padding,
border: border.clone(), border,
positioning_context, positioning_context,
}) })
}) })
@ -1666,8 +1666,7 @@ impl<'a> TableLayout<'a> {
cell.rowspan, cell.rowspan,
cell.colspan, cell.colspan,
); );
row_relative_cell_rect.start_corner = row_relative_cell_rect.start_corner -= row_rect.start_corner;
&row_relative_cell_rect.start_corner - &row_rect.start_corner;
let mut fragment = cell.create_fragment( let mut fragment = cell.create_fragment(
layout, layout,
row_relative_cell_rect, row_relative_cell_rect,
@ -1710,7 +1709,7 @@ impl<'a> TableLayout<'a> {
}) })
} }
if let Some(row) = row { if let Some(row) = row {
let mut rect = row_rect.clone(); let mut rect = *row_rect;
rect.start_corner = LogicalVec2::zero(); rect.start_corner = LogicalVec2::zero();
fragment.add_extra_background(ExtraBackground { fragment.add_extra_background(ExtraBackground {
style: row.style.clone(), style: row.style.clone(),
@ -1989,12 +1988,12 @@ impl TableAndTrackDimensions {
inline: column_dimensions.first().map_or_else(Au::zero, |v| v.0), inline: column_dimensions.first().map_or_else(Au::zero, |v| v.0),
block: row_dimensions.first().map_or_else(Au::zero, |v| v.0), block: row_dimensions.first().map_or_else(Au::zero, |v| v.0),
}; };
let table_size = &LogicalVec2 { let table_size = LogicalVec2 {
inline: column_dimensions inline: column_dimensions
.last() .last()
.map_or(fallback_inline_size, |v| v.1), .map_or(fallback_inline_size, |v| v.1),
block: row_dimensions.last().map_or(fallback_block_size, |v| v.1), block: row_dimensions.last().map_or(fallback_block_size, |v| v.1),
} - &table_start_corner; } - table_start_corner;
let table_cells_rect = LogicalRect { let table_cells_rect = LogicalRect {
start_corner: table_start_corner, start_corner: table_start_corner,
size: table_size, size: table_size,
@ -2017,7 +2016,7 @@ impl TableAndTrackDimensions {
} }
fn get_row_rect(&self, row_index: usize) -> LogicalRect<Au> { fn get_row_rect(&self, row_index: usize) -> LogicalRect<Au> {
let mut row_rect = self.table_cells_rect.clone(); let mut row_rect = self.table_cells_rect;
let row_dimensions = self.row_dimensions[row_index]; let row_dimensions = self.row_dimensions[row_index];
row_rect.start_corner.block = row_dimensions.0; row_rect.start_corner.block = row_dimensions.0;
row_rect.size.block = row_dimensions.1 - row_dimensions.0; row_rect.size.block = row_dimensions.1 - row_dimensions.0;
@ -2025,7 +2024,7 @@ impl TableAndTrackDimensions {
} }
fn get_column_rect(&self, column_index: usize) -> LogicalRect<Au> { fn get_column_rect(&self, column_index: usize) -> LogicalRect<Au> {
let mut row_rect = self.table_cells_rect.clone(); let mut row_rect = self.table_cells_rect;
let column_dimensions = self.column_dimensions[column_index]; let column_dimensions = self.column_dimensions[column_index];
row_rect.start_corner.inline = column_dimensions.0; row_rect.start_corner.inline = column_dimensions.0;
row_rect.size.inline = column_dimensions.1 - column_dimensions.0; row_rect.size.inline = column_dimensions.1 - column_dimensions.0;
@ -2037,7 +2036,7 @@ impl TableAndTrackDimensions {
return LogicalRect::zero(); return LogicalRect::zero();
} }
let mut row_group_rect = self.table_cells_rect.clone(); let mut row_group_rect = self.table_cells_rect;
let block_start = self.row_dimensions[row_group.track_range.start].0; let block_start = self.row_dimensions[row_group.track_range.start].0;
let block_end = self.row_dimensions[row_group.track_range.end - 1].1; let block_end = self.row_dimensions[row_group.track_range.end - 1].1;
row_group_rect.start_corner.block = block_start; row_group_rect.start_corner.block = block_start;
@ -2050,7 +2049,7 @@ impl TableAndTrackDimensions {
return LogicalRect::zero(); return LogicalRect::zero();
} }
let mut column_group_rect = self.table_cells_rect.clone(); let mut column_group_rect = self.table_cells_rect;
let inline_start = self.column_dimensions[column_group.track_range.start].0; let inline_start = self.column_dimensions[column_group.track_range.start].0;
let inline_end = self.column_dimensions[column_group.track_range.end - 1].1; let inline_end = self.column_dimensions[column_group.track_range.end - 1].1;
column_group_rect.start_corner.inline = inline_start; column_group_rect.start_corner.inline = inline_start;
@ -2068,10 +2067,10 @@ impl TableAndTrackDimensions {
inline: self.column_dimensions[coordinates.x].0, inline: self.column_dimensions[coordinates.x].0,
block: self.row_dimensions[coordinates.y].0, block: self.row_dimensions[coordinates.y].0,
}; };
let size = &LogicalVec2 { let size = LogicalVec2 {
inline: self.column_dimensions[coordinates.x + colspan - 1].1, inline: self.column_dimensions[coordinates.x + colspan - 1].1,
block: self.row_dimensions[coordinates.y + rowspan - 1].1, block: self.row_dimensions[coordinates.y + rowspan - 1].1,
} - &start_corner; } - start_corner;
LogicalRect { start_corner, size } LogicalRect { start_corner, size }
} }
} }
@ -2213,7 +2212,7 @@ impl TableSlotCell {
// This must be scoped to this function because it conflicts with euclid's Zero. // This must be scoped to this function because it conflicts with euclid's Zero.
use style::Zero as StyleZero; use style::Zero as StyleZero;
let cell_content_rect = cell_rect.deflate(&(&layout.padding + &layout.border)); let cell_content_rect = cell_rect.deflate(&(layout.padding + layout.border));
let content_block_size = layout.layout.content_block_size; let content_block_size = layout.layout.content_block_size;
let vertical_align_offset = match self.effective_vertical_align() { let vertical_align_offset = match self.effective_vertical_align() {
VerticalAlignKeyword::Top => Au::zero(), VerticalAlignKeyword::Top => Au::zero(),
@ -2237,7 +2236,7 @@ impl TableSlotCell {
} }
// Create an `AnonymousFragment` to move the cell contents to the cell baseline. // Create an `AnonymousFragment` to move the cell contents to the cell baseline.
let mut vertical_align_fragment_rect = cell_content_rect.clone(); let mut vertical_align_fragment_rect = cell_content_rect;
vertical_align_fragment_rect.start_corner = LogicalVec2 { vertical_align_fragment_rect.start_corner = LogicalVec2 {
inline: Au::zero(), inline: Au::zero(),
block: vertical_align_offset, block: vertical_align_offset,
@ -2317,7 +2316,7 @@ fn get_outer_sizes_from_style(
) -> (LogicalVec2<Au>, LogicalVec2<Au>, LogicalVec2<Au>) { ) -> (LogicalVec2<Au>, LogicalVec2<Au>, LogicalVec2<Au>) {
let box_sizing = style.get_position().box_sizing; let box_sizing = style.get_position().box_sizing;
let outer_size = |size: LogicalVec2<Au>| match box_sizing { let outer_size = |size: LogicalVec2<Au>| match box_sizing {
BoxSizing::ContentBox => &size + padding_border_sums, BoxSizing::ContentBox => size + *padding_border_sums,
BoxSizing::BorderBox => LogicalVec2 { BoxSizing::BorderBox => LogicalVec2 {
inline: size.inline.max(padding_border_sums.inline), inline: size.inline.max(padding_border_sums.inline),
block: size.block.max(padding_border_sums.block), block: size.block.max(padding_border_sums.block),