mirror of
https://github.com/servo/servo.git
synced 2025-08-03 04:30:10 +01:00
Rustfmt layout crate
This commit is contained in:
parent
577830de90
commit
349047b096
37 changed files with 7177 additions and 4832 deletions
|
@ -126,21 +126,22 @@ impl MarginCollapseInfo {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn finish_and_compute_collapsible_margins(mut self,
|
||||
fragment: &Fragment,
|
||||
containing_block_size: Option<Au>,
|
||||
can_collapse_block_end_margin_with_kids: bool,
|
||||
mut may_collapse_through: bool)
|
||||
-> (CollapsibleMargins, Au) {
|
||||
pub fn finish_and_compute_collapsible_margins(
|
||||
mut self,
|
||||
fragment: &Fragment,
|
||||
containing_block_size: Option<Au>,
|
||||
can_collapse_block_end_margin_with_kids: bool,
|
||||
mut may_collapse_through: bool,
|
||||
) -> (CollapsibleMargins, Au) {
|
||||
let state = match self.state {
|
||||
MarginCollapseState::AccumulatingCollapsibleTopMargin => {
|
||||
may_collapse_through = may_collapse_through &&
|
||||
match fragment.style().content_block_size() {
|
||||
may_collapse_through =
|
||||
may_collapse_through && match fragment.style().content_block_size() {
|
||||
LengthOrPercentageOrAuto::Auto => true,
|
||||
LengthOrPercentageOrAuto::Length(l) => l.px() == 0.,
|
||||
LengthOrPercentageOrAuto::Percentage(v) => {
|
||||
v.0 == 0. || containing_block_size.is_none()
|
||||
}
|
||||
},
|
||||
LengthOrPercentageOrAuto::Calc(_) => false,
|
||||
};
|
||||
|
||||
|
@ -156,14 +157,14 @@ impl MarginCollapseInfo {
|
|||
// If the fragment has non-zero min-block-size, margins may not
|
||||
// collapse through it.
|
||||
FinalMarginState::BottomMarginCollapses
|
||||
}
|
||||
},
|
||||
}
|
||||
} else {
|
||||
// If the fragment has an explicitly specified block-size, margins may not
|
||||
// collapse through it.
|
||||
FinalMarginState::BottomMarginCollapses
|
||||
}
|
||||
}
|
||||
},
|
||||
MarginCollapseState::AccumulatingMarginIn => FinalMarginState::BottomMarginCollapses,
|
||||
};
|
||||
|
||||
|
@ -174,27 +175,41 @@ impl MarginCollapseInfo {
|
|||
match state {
|
||||
FinalMarginState::MarginsCollapseThrough => {
|
||||
let advance = self.block_start_margin.collapse();
|
||||
self.margin_in.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(CollapsibleMargins::Collapse(self.block_start_margin, self.margin_in),
|
||||
advance)
|
||||
}
|
||||
self.margin_in
|
||||
.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(
|
||||
CollapsibleMargins::Collapse(self.block_start_margin, self.margin_in),
|
||||
advance,
|
||||
)
|
||||
},
|
||||
FinalMarginState::BottomMarginCollapses => {
|
||||
let advance = self.margin_in.collapse();
|
||||
self.margin_in.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(CollapsibleMargins::Collapse(self.block_start_margin, self.margin_in),
|
||||
advance)
|
||||
}
|
||||
self.margin_in
|
||||
.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(
|
||||
CollapsibleMargins::Collapse(self.block_start_margin, self.margin_in),
|
||||
advance,
|
||||
)
|
||||
},
|
||||
}
|
||||
} else {
|
||||
match state {
|
||||
FinalMarginState::MarginsCollapseThrough => {
|
||||
self.block_start_margin.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(CollapsibleMargins::CollapseThrough(self.block_start_margin), Au(0))
|
||||
}
|
||||
self.block_start_margin
|
||||
.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(
|
||||
CollapsibleMargins::CollapseThrough(self.block_start_margin),
|
||||
Au(0),
|
||||
)
|
||||
},
|
||||
FinalMarginState::BottomMarginCollapses => {
|
||||
self.margin_in.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(CollapsibleMargins::Collapse(self.block_start_margin, self.margin_in), Au(0))
|
||||
}
|
||||
self.margin_in
|
||||
.union(AdjoiningMargins::from_margin(block_end_margin));
|
||||
(
|
||||
CollapsibleMargins::Collapse(self.block_start_margin, self.margin_in),
|
||||
Au(0),
|
||||
)
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -206,7 +221,7 @@ impl MarginCollapseInfo {
|
|||
// needs to be positioned relative to our *border box*, not our margin box. See
|
||||
// `tests/ref/float_under_top_margin_a.html`.
|
||||
Au(0)
|
||||
}
|
||||
},
|
||||
MarginCollapseState::AccumulatingMarginIn => self.margin_in.collapse(),
|
||||
}
|
||||
}
|
||||
|
@ -214,78 +229,99 @@ impl MarginCollapseInfo {
|
|||
/// Adds the child's potentially collapsible block-start margin to the current margin state and
|
||||
/// advances the Y offset by the appropriate amount to handle that margin. Returns the amount
|
||||
/// that should be added to the Y offset during block layout.
|
||||
pub fn advance_block_start_margin(&mut self,
|
||||
child_collapsible_margins: &CollapsibleMargins,
|
||||
can_collapse_block_start_margin: bool)
|
||||
-> Au {
|
||||
pub fn advance_block_start_margin(
|
||||
&mut self,
|
||||
child_collapsible_margins: &CollapsibleMargins,
|
||||
can_collapse_block_start_margin: bool,
|
||||
) -> Au {
|
||||
if !can_collapse_block_start_margin {
|
||||
self.state = MarginCollapseState::AccumulatingMarginIn
|
||||
}
|
||||
|
||||
match (self.state, *child_collapsible_margins) {
|
||||
(MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::None(block_start, _)) => {
|
||||
(
|
||||
MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::None(block_start, _),
|
||||
) => {
|
||||
self.state = MarginCollapseState::AccumulatingMarginIn;
|
||||
block_start
|
||||
}
|
||||
(MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::Collapse(block_start, _)) => {
|
||||
},
|
||||
(
|
||||
MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::Collapse(block_start, _),
|
||||
) => {
|
||||
self.block_start_margin.union(block_start);
|
||||
self.state = MarginCollapseState::AccumulatingMarginIn;
|
||||
Au(0)
|
||||
}
|
||||
(MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::None(block_start, _)) => {
|
||||
},
|
||||
(
|
||||
MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::None(block_start, _),
|
||||
) => {
|
||||
let previous_margin_value = self.margin_in.collapse();
|
||||
self.margin_in = AdjoiningMargins::new();
|
||||
previous_margin_value + block_start
|
||||
}
|
||||
(MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::Collapse(block_start, _)) => {
|
||||
},
|
||||
(
|
||||
MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::Collapse(block_start, _),
|
||||
) => {
|
||||
self.margin_in.union(block_start);
|
||||
let margin_value = self.margin_in.collapse();
|
||||
self.margin_in = AdjoiningMargins::new();
|
||||
margin_value
|
||||
}
|
||||
},
|
||||
(_, CollapsibleMargins::CollapseThrough(_)) => {
|
||||
// For now, we ignore this; this will be handled by `advance_block_end_margin`
|
||||
// below.
|
||||
Au(0)
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Adds the child's potentially collapsible block-end margin to the current margin state and
|
||||
/// advances the Y offset by the appropriate amount to handle that margin. Returns the amount
|
||||
/// that should be added to the Y offset during block layout.
|
||||
pub fn advance_block_end_margin(&mut self, child_collapsible_margins: &CollapsibleMargins)
|
||||
-> Au {
|
||||
pub fn advance_block_end_margin(
|
||||
&mut self,
|
||||
child_collapsible_margins: &CollapsibleMargins,
|
||||
) -> Au {
|
||||
match (self.state, *child_collapsible_margins) {
|
||||
(MarginCollapseState::AccumulatingCollapsibleTopMargin, CollapsibleMargins::None(..)) |
|
||||
(MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::Collapse(..)) => {
|
||||
(
|
||||
MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::None(..),
|
||||
) |
|
||||
(
|
||||
MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::Collapse(..),
|
||||
) => {
|
||||
// Can't happen because the state will have been replaced with
|
||||
// `MarginCollapseState::AccumulatingMarginIn` above.
|
||||
panic!("should not be accumulating collapsible block_start margins anymore!")
|
||||
}
|
||||
(MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::CollapseThrough(margin)) => {
|
||||
},
|
||||
(
|
||||
MarginCollapseState::AccumulatingCollapsibleTopMargin,
|
||||
CollapsibleMargins::CollapseThrough(margin),
|
||||
) => {
|
||||
self.block_start_margin.union(margin);
|
||||
Au(0)
|
||||
}
|
||||
(MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::None(_, block_end)) => {
|
||||
},
|
||||
(MarginCollapseState::AccumulatingMarginIn, CollapsibleMargins::None(_, block_end)) => {
|
||||
assert_eq!(self.margin_in.most_positive, Au(0));
|
||||
assert_eq!(self.margin_in.most_negative, Au(0));
|
||||
block_end
|
||||
}
|
||||
(MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::Collapse(_, block_end)) |
|
||||
(MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::CollapseThrough(block_end)) => {
|
||||
},
|
||||
(
|
||||
MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::Collapse(_, block_end),
|
||||
) |
|
||||
(
|
||||
MarginCollapseState::AccumulatingMarginIn,
|
||||
CollapsibleMargins::CollapseThrough(block_end),
|
||||
) => {
|
||||
self.margin_in.union(block_end);
|
||||
Au(0)
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -309,7 +345,11 @@ pub struct IntrinsicISizes {
|
|||
|
||||
impl fmt::Debug for IntrinsicISizes {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "min={:?}, pref={:?}", self.minimum_inline_size, self.preferred_inline_size)
|
||||
write!(
|
||||
f,
|
||||
"min={:?}, pref={:?}",
|
||||
self.minimum_inline_size, self.preferred_inline_size
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -345,9 +385,9 @@ impl IntrinsicISizesContribution {
|
|||
pub fn finish(self) -> IntrinsicISizes {
|
||||
IntrinsicISizes {
|
||||
minimum_inline_size: self.content_intrinsic_sizes.minimum_inline_size +
|
||||
self.surrounding_size,
|
||||
self.surrounding_size,
|
||||
preferred_inline_size: self.content_intrinsic_sizes.preferred_inline_size +
|
||||
self.surrounding_size,
|
||||
self.surrounding_size,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -358,8 +398,10 @@ impl IntrinsicISizesContribution {
|
|||
/// FIXME(pcwalton): This is incorrect when the inline fragment contains forced line breaks
|
||||
/// (e.g. `<br>` or `white-space: pre`).
|
||||
pub fn union_inline(&mut self, sizes: &IntrinsicISizes) {
|
||||
self.content_intrinsic_sizes.minimum_inline_size =
|
||||
max(self.content_intrinsic_sizes.minimum_inline_size, sizes.minimum_inline_size);
|
||||
self.content_intrinsic_sizes.minimum_inline_size = max(
|
||||
self.content_intrinsic_sizes.minimum_inline_size,
|
||||
sizes.minimum_inline_size,
|
||||
);
|
||||
self.content_intrinsic_sizes.preferred_inline_size =
|
||||
self.content_intrinsic_sizes.preferred_inline_size + sizes.preferred_inline_size
|
||||
}
|
||||
|
@ -382,10 +424,14 @@ impl IntrinsicISizesContribution {
|
|||
///
|
||||
/// This is used when contributing the intrinsic sizes for individual fragments.
|
||||
pub fn union_block(&mut self, sizes: &IntrinsicISizes) {
|
||||
self.content_intrinsic_sizes.minimum_inline_size =
|
||||
max(self.content_intrinsic_sizes.minimum_inline_size, sizes.minimum_inline_size);
|
||||
self.content_intrinsic_sizes.preferred_inline_size =
|
||||
max(self.content_intrinsic_sizes.preferred_inline_size, sizes.preferred_inline_size)
|
||||
self.content_intrinsic_sizes.minimum_inline_size = max(
|
||||
self.content_intrinsic_sizes.minimum_inline_size,
|
||||
sizes.minimum_inline_size,
|
||||
);
|
||||
self.content_intrinsic_sizes.preferred_inline_size = max(
|
||||
self.content_intrinsic_sizes.preferred_inline_size,
|
||||
sizes.preferred_inline_size,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -398,17 +444,16 @@ pub enum MaybeAuto {
|
|||
|
||||
impl MaybeAuto {
|
||||
#[inline]
|
||||
pub fn from_style(length: LengthOrPercentageOrAuto, containing_length: Au)
|
||||
-> MaybeAuto {
|
||||
pub fn from_style(length: LengthOrPercentageOrAuto, containing_length: Au) -> MaybeAuto {
|
||||
match length {
|
||||
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
|
||||
LengthOrPercentageOrAuto::Percentage(percent) => {
|
||||
MaybeAuto::Specified(containing_length.scale_by(percent.0))
|
||||
}
|
||||
},
|
||||
LengthOrPercentageOrAuto::Calc(calc) => {
|
||||
MaybeAuto::from_option(calc.to_used_value(Some(containing_length)))
|
||||
}
|
||||
LengthOrPercentageOrAuto::Length(length) => MaybeAuto::Specified(Au::from(length))
|
||||
},
|
||||
LengthOrPercentageOrAuto::Length(length) => MaybeAuto::Specified(Au::from(length)),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -442,7 +487,10 @@ impl MaybeAuto {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
pub fn map<F>(&self, mapper: F) -> MaybeAuto where F: FnOnce(Au) -> Au {
|
||||
pub fn map<F>(&self, mapper: F) -> MaybeAuto
|
||||
where
|
||||
F: FnOnce(Au) -> Au,
|
||||
{
|
||||
match *self {
|
||||
MaybeAuto::Auto => MaybeAuto::Auto,
|
||||
MaybeAuto::Specified(value) => MaybeAuto::Specified(mapper(value)),
|
||||
|
@ -453,15 +501,17 @@ impl MaybeAuto {
|
|||
/// Receive an optional container size and return used value for width or height.
|
||||
///
|
||||
/// `style_length`: content size as given in the CSS.
|
||||
pub fn style_length(style_length: LengthOrPercentageOrAuto,
|
||||
container_size: Option<Au>) -> MaybeAuto {
|
||||
pub fn style_length(
|
||||
style_length: LengthOrPercentageOrAuto,
|
||||
container_size: Option<Au>,
|
||||
) -> MaybeAuto {
|
||||
match container_size {
|
||||
Some(length) => MaybeAuto::from_style(style_length, length),
|
||||
None => if let LengthOrPercentageOrAuto::Length(length) = style_length {
|
||||
MaybeAuto::Specified(Au::from(length))
|
||||
} else {
|
||||
MaybeAuto::Auto
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -475,25 +525,37 @@ pub fn style_length(style_length: LengthOrPercentageOrAuto,
|
|||
/// [1]: https://drafts.csswg.org/css-backgrounds-3/#border-radius
|
||||
pub fn specified_border_radius(
|
||||
radius: BorderCornerRadius,
|
||||
containing_size: Size2D<Au>)
|
||||
-> Size2D<Au>
|
||||
{
|
||||
containing_size: Size2D<Au>,
|
||||
) -> Size2D<Au> {
|
||||
let w = radius.0.width().to_used_value(containing_size.width);
|
||||
let h = radius.0.height().to_used_value(containing_size.height);
|
||||
Size2D::new(w, h)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn padding_from_style(style: &ComputedValues,
|
||||
containing_block_inline_size: Au,
|
||||
writing_mode: WritingMode)
|
||||
-> LogicalMargin<Au> {
|
||||
pub fn padding_from_style(
|
||||
style: &ComputedValues,
|
||||
containing_block_inline_size: Au,
|
||||
writing_mode: WritingMode,
|
||||
) -> LogicalMargin<Au> {
|
||||
let padding_style = style.get_padding();
|
||||
LogicalMargin::from_physical(writing_mode, SideOffsets2D::new(
|
||||
padding_style.padding_top.to_used_value(containing_block_inline_size),
|
||||
padding_style.padding_right.to_used_value(containing_block_inline_size),
|
||||
padding_style.padding_bottom.to_used_value(containing_block_inline_size),
|
||||
padding_style.padding_left.to_used_value(containing_block_inline_size)))
|
||||
LogicalMargin::from_physical(
|
||||
writing_mode,
|
||||
SideOffsets2D::new(
|
||||
padding_style
|
||||
.padding_top
|
||||
.to_used_value(containing_block_inline_size),
|
||||
padding_style
|
||||
.padding_right
|
||||
.to_used_value(containing_block_inline_size),
|
||||
padding_style
|
||||
.padding_bottom
|
||||
.to_used_value(containing_block_inline_size),
|
||||
padding_style
|
||||
.padding_left
|
||||
.to_used_value(containing_block_inline_size),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
/// Returns the explicitly-specified margin lengths from the given style. Percentage and auto
|
||||
|
@ -501,14 +563,20 @@ pub fn padding_from_style(style: &ComputedValues,
|
|||
///
|
||||
/// This is used when calculating intrinsic inline sizes.
|
||||
#[inline]
|
||||
pub fn specified_margin_from_style(style: &ComputedValues,
|
||||
writing_mode: WritingMode) -> LogicalMargin<Au> {
|
||||
pub fn specified_margin_from_style(
|
||||
style: &ComputedValues,
|
||||
writing_mode: WritingMode,
|
||||
) -> LogicalMargin<Au> {
|
||||
let margin_style = style.get_margin();
|
||||
LogicalMargin::from_physical(writing_mode, SideOffsets2D::new(
|
||||
MaybeAuto::from_style(margin_style.margin_top, Au(0)).specified_or_zero(),
|
||||
MaybeAuto::from_style(margin_style.margin_right, Au(0)).specified_or_zero(),
|
||||
MaybeAuto::from_style(margin_style.margin_bottom, Au(0)).specified_or_zero(),
|
||||
MaybeAuto::from_style(margin_style.margin_left, Au(0)).specified_or_zero()))
|
||||
LogicalMargin::from_physical(
|
||||
writing_mode,
|
||||
SideOffsets2D::new(
|
||||
MaybeAuto::from_style(margin_style.margin_top, Au(0)).specified_or_zero(),
|
||||
MaybeAuto::from_style(margin_style.margin_right, Au(0)).specified_or_zero(),
|
||||
MaybeAuto::from_style(margin_style.margin_bottom, Au(0)).specified_or_zero(),
|
||||
MaybeAuto::from_style(margin_style.margin_left, Au(0)).specified_or_zero(),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
/// A min-size and max-size constraint. The constructor has a optional `border`
|
||||
|
@ -523,17 +591,19 @@ pub struct SizeConstraint {
|
|||
|
||||
impl SizeConstraint {
|
||||
/// Create a `SizeConstraint` for an axis.
|
||||
pub fn new(container_size: Option<Au>,
|
||||
min_size: LengthOrPercentage,
|
||||
max_size: LengthOrPercentageOrNone,
|
||||
border: Option<Au>) -> SizeConstraint {
|
||||
pub fn new(
|
||||
container_size: Option<Au>,
|
||||
min_size: LengthOrPercentage,
|
||||
max_size: LengthOrPercentageOrNone,
|
||||
border: Option<Au>,
|
||||
) -> SizeConstraint {
|
||||
let mut min_size = match container_size {
|
||||
Some(container_size) => min_size.to_used_value(container_size),
|
||||
None => if let LengthOrPercentage::Length(length) = min_size {
|
||||
Au::from(length)
|
||||
} else {
|
||||
Au(0)
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
let mut max_size = match container_size {
|
||||
|
@ -542,7 +612,7 @@ impl SizeConstraint {
|
|||
Some(Au::from(length))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
},
|
||||
};
|
||||
// Make sure max size is not smaller than min size.
|
||||
max_size = max_size.map(|x| max(x, min_size));
|
||||
|
@ -554,7 +624,7 @@ impl SizeConstraint {
|
|||
|
||||
SizeConstraint {
|
||||
min_size: min_size,
|
||||
max_size: max_size
|
||||
max_size: max_size,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -565,7 +635,7 @@ impl SizeConstraint {
|
|||
} else {
|
||||
match self.max_size {
|
||||
Some(max_size) if max_size < other => max_size,
|
||||
_ => other
|
||||
_ => other,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue