Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove border collapse argument from compute_border_and_padding

Browse source
This commit is contained in:
Keith Yeung 2017-08-25 23:41:55 -07:00
parent 3c42792efa
commit 1df72ba935
6 changed files with 12 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

5
components/layout/block.rs
View file

@ -51,7 +51,7 @@ use servo_geometry::max_rect;
use std::cmp::{max, min};
use std::fmt;
use std::sync::Arc;
use style::computed_values::{border_collapse, box_sizing, display, float, overflow_x};
use style::computed_values::{box_sizing, display, float, overflow_x};
use style::computed_values::{position, text_align};
use style::context::SharedStyleContext;
use style::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize, WritingMode};
@ -2268,8 +2268,7 @@ impl ISizeConstraintSolution {
pub trait ISizeAndMarginsComputer {
/// Instructs the fragment to compute its border and padding.
fn compute_border_and_padding(&self, block: &mut BlockFlow, containing_block_inline_size: Au) {
block.fragment.compute_border_and_padding(containing_block_inline_size,
border_collapse::T::separate);
block.fragment.compute_border_and_padding(containing_block_inline_size);
}
/// Compute the inputs for the ISize constraint equation.

4
components/layout/flex.rs
View file

@ -21,7 +21,6 @@ use model::{IntrinsicISizes, MaybeAuto, SizeConstraint};
use std::cmp::{max, min};
use std::ops::Range;
use style::computed_values::{align_content, align_self, flex_direction, flex_wrap, justify_content};
use style::computed_values::border_collapse;
use style::logical_geometry::{Direction, LogicalSize};
use style::properties::ComputedValues;
use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW};
@ -160,8 +159,7 @@ impl FlexItem {
Some(containing_length));
// These methods compute auto margins to zero length, which is exactly what we want.
block.fragment.compute_border_and_padding(containing_length,
border_collapse::T::separate);
block.fragment.compute_border_and_padding(containing_length);
block.fragment.compute_inline_direction_margins(containing_length);
block.fragment.compute_block_direction_margins(containing_length);

8
components/layout/fragment.rs
View file

@ -1305,14 +1305,10 @@ impl Fragment {
/// Computes the border and padding in both inline and block directions from the containing
/// block inline-size and the style. After this call, the `border_padding` field will be
/// correct.
///
/// TODO(pcwalton): Remove `border_collapse`; we can figure it out from our style and specific
/// fragment info.
pub fn compute_border_and_padding(&mut self,
containing_block_inline_size: Au,
border_collapse: border_collapse::T) {
containing_block_inline_size: Au) {
// Compute border.
let border = match border_collapse {
let border = match self.style.get_inheritedtable().border_collapse {
border_collapse::T::separate => self.border_width(),
border_collapse::T::collapse => LogicalMargin::zero(self.style.writing_mode),
};

3
components/layout/inline.rs
View file

@ -1399,8 +1399,7 @@ impl Flow for InlineFlow {
{
let this = &mut *self;
for fragment in this.fragments.fragments.iter_mut() {
let border_collapse = fragment.style.get_inheritedtable().border_collapse;
fragment.compute_border_and_padding(inline_size, border_collapse);
fragment.compute_border_and_padding(inline_size);
fragment.compute_block_direction_margins(inline_size);
fragment.compute_inline_direction_margins(inline_size);
fragment.assign_replaced_inline_size_if_necessary(inline_size, container_block_size);

3
components/layout/table.rs
View file

@ -545,8 +545,7 @@ pub struct InternalTable {
impl ISizeAndMarginsComputer for InternalTable {
fn compute_border_and_padding(&self, block: &mut BlockFlow, containing_block_inline_size: Au) {
block.fragment.compute_border_and_padding(containing_block_inline_size,
self.border_collapse)
block.fragment.compute_border_and_padding(containing_block_inline_size)
}
/// Compute the used value of inline-size, taking care of min-inline-size and max-inline-size.

22
components/layout/table_wrapper.rs
View file

@ -27,7 +27,7 @@ use model::MaybeAuto;
use std::cmp::{max, min};
use std::fmt;
use std::ops::Add;
use style::computed_values::{border_collapse, position, table_layout};
use style::computed_values::{position, table_layout};
use style::context::SharedStyleContext;
use style::logical_geometry::{LogicalRect, LogicalSize};
use style::properties::ComputedValues;
@ -96,7 +96,6 @@ impl TableWrapperFlow {
// tables are separated into table flows and table wrapper flows.
fn compute_border_and_padding_of_table(&mut self) {
let available_inline_size = self.block_flow.base.block_container_inline_size;
let border_collapse = self.block_flow.fragment.style.get_inheritedtable().border_collapse;
for kid in self.block_flow.base.child_iter_mut() {
if !kid.is_table() {
continue
@ -104,8 +103,7 @@ impl TableWrapperFlow {
let kid_table = kid.as_mut_table();
let kid_block_flow = &mut kid_table.block_flow;
kid_block_flow.fragment.compute_border_and_padding(available_inline_size,
border_collapse);
kid_block_flow.fragment.compute_border_and_padding(available_inline_size);
kid_block_flow.fragment.compute_block_direction_margins(available_inline_size);
kid_block_flow.fragment.compute_inline_direction_margins(available_inline_size);
return
@ -232,12 +230,10 @@ impl TableWrapperFlow {
// Delegate to the appropriate inline size computer to find the constraint inputs and write
// the constraint solutions in.
let border_collapse = self.block_flow.fragment.style.get_inheritedtable().border_collapse;
if self.block_flow.base.flags.is_float() {
let inline_size_computer = FloatedTable {
minimum_width_of_all_columns: minimum_width_of_all_columns,
preferred_width_of_all_columns: preferred_width_of_all_columns,
border_collapse: border_collapse,
table_border_padding: border_padding,
};
let input =
@ -258,7 +254,6 @@ impl TableWrapperFlow {
let inline_size_computer = AbsoluteTable {
minimum_width_of_all_columns: minimum_width_of_all_columns,
preferred_width_of_all_columns: preferred_width_of_all_columns,
border_collapse: border_collapse,
table_border_padding: border_padding,
};
let input =
@ -278,7 +273,6 @@ impl TableWrapperFlow {
let inline_size_computer = Table {
minimum_width_of_all_columns: minimum_width_of_all_columns,
preferred_width_of_all_columns: preferred_width_of_all_columns,
border_collapse: border_collapse,
table_border_padding: border_padding,
};
let input =
@ -786,14 +780,12 @@ fn initial_computed_inline_size(block: &mut BlockFlow,
struct Table {
minimum_width_of_all_columns: Au,
preferred_width_of_all_columns: Au,
border_collapse: border_collapse::T,
table_border_padding: Au,
}
impl ISizeAndMarginsComputer for Table {
fn compute_border_and_padding(&self, block: &mut BlockFlow, containing_block_inline_size: Au) {
block.fragment.compute_border_and_padding(containing_block_inline_size,
self.border_collapse)
block.fragment.compute_border_and_padding(containing_block_inline_size)
}
fn initial_computed_inline_size(&self,
@ -821,14 +813,12 @@ impl ISizeAndMarginsComputer for Table {
struct FloatedTable {
minimum_width_of_all_columns: Au,
preferred_width_of_all_columns: Au,
border_collapse: border_collapse::T,
table_border_padding: Au,
}
impl ISizeAndMarginsComputer for FloatedTable {
fn compute_border_and_padding(&self, block: &mut BlockFlow, containing_block_inline_size: Au) {
block.fragment.compute_border_and_padding(containing_block_inline_size,
self.border_collapse)
block.fragment.compute_border_and_padding(containing_block_inline_size)
}
fn initial_computed_inline_size(&self,
@ -858,14 +848,12 @@ impl ISizeAndMarginsComputer for FloatedTable {
struct AbsoluteTable {
minimum_width_of_all_columns: Au,
preferred_width_of_all_columns: Au,
border_collapse: border_collapse::T,
table_border_padding: Au,
}
impl ISizeAndMarginsComputer for AbsoluteTable {
fn compute_border_and_padding(&self, block: &mut BlockFlow, containing_block_inline_size: Au) {
block.fragment.compute_border_and_padding(containing_block_inline_size,
self.border_collapse)
block.fragment.compute_border_and_padding(containing_block_inline_size)
}
fn initial_computed_inline_size(&self,