Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 05:30:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

Pass SharedStyleContext to compute_used_inline_size.

Browse source
This commit is contained in:
Ms2ger 2016-06-20 19:55:48 +02:00
parent 018bebe90d
commit 9731a001db
6 changed files with 25 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

26
components/layout/block.rs
View file

@ -590,56 +590,56 @@ impl BlockFlow {
/// Compute the actual inline size and position for this block. /// Compute the actual inline size and position for this block.
pub fn compute_used_inline_size(&mut self, pub fn compute_used_inline_size(&mut self,
layout_context: &LayoutContext, shared_context: &SharedStyleContext,
containing_block_inline_size: Au) { containing_block_inline_size: Au) {
let block_type = self.block_type(); let block_type = self.block_type();
match block_type { match block_type {
BlockType::AbsoluteReplaced => { BlockType::AbsoluteReplaced => {
let inline_size_computer = AbsoluteReplaced; let inline_size_computer = AbsoluteReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
BlockType::AbsoluteNonReplaced => { BlockType::AbsoluteNonReplaced => {
let inline_size_computer = AbsoluteNonReplaced; let inline_size_computer = AbsoluteNonReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
BlockType::FloatReplaced => { BlockType::FloatReplaced => {
let inline_size_computer = FloatReplaced; let inline_size_computer = FloatReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
BlockType::FloatNonReplaced => { BlockType::FloatNonReplaced => {
let inline_size_computer = FloatNonReplaced; let inline_size_computer = FloatNonReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
BlockType::InlineBlockReplaced => { BlockType::InlineBlockReplaced => {
let inline_size_computer = InlineBlockReplaced; let inline_size_computer = InlineBlockReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
BlockType::InlineBlockNonReplaced => { BlockType::InlineBlockNonReplaced => {
let inline_size_computer = InlineBlockNonReplaced; let inline_size_computer = InlineBlockNonReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
BlockType::Replaced => { BlockType::Replaced => {
let inline_size_computer = BlockReplaced; let inline_size_computer = BlockReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
BlockType::NonReplaced => { BlockType::NonReplaced => {
let inline_size_computer = BlockNonReplaced; let inline_size_computer = BlockNonReplaced;
inline_size_computer.compute_used_inline_size(self, inline_size_computer.compute_used_inline_size(self,
layout_context, shared_context,
containing_block_inline_size); containing_block_inline_size);
} }
} }
@ -1297,7 +1297,7 @@ impl BlockFlow {
/// This is run in the `AssignISizes` traversal. /// This is run in the `AssignISizes` traversal.
fn propagate_and_compute_used_inline_size(&mut self, layout_context: &LayoutContext) { fn propagate_and_compute_used_inline_size(&mut self, layout_context: &LayoutContext) {
let containing_block_inline_size = self.base.block_container_inline_size; let containing_block_inline_size = self.base.block_container_inline_size;
self.compute_used_inline_size(layout_context, containing_block_inline_size); self.compute_used_inline_size(layout_context.shared_context(), containing_block_inline_size);
if self.base.flags.is_float() { if self.base.flags.is_float() {
self.float.as_mut().unwrap().containing_inline_size = containing_block_inline_size self.float.as_mut().unwrap().containing_inline_size = containing_block_inline_size
} }
@ -2403,14 +2403,14 @@ pub trait ISizeAndMarginsComputer {
/// CSS Section 10.4: Minimum and Maximum inline-sizes /// CSS Section 10.4: Minimum and Maximum inline-sizes
fn compute_used_inline_size(&self, fn compute_used_inline_size(&self,
block: &mut BlockFlow, block: &mut BlockFlow,
layout_context: &LayoutContext, shared_context: &SharedStyleContext,
parent_flow_inline_size: Au) { parent_flow_inline_size: Au) {
let mut input = self.compute_inline_size_constraint_inputs(block, let mut input = self.compute_inline_size_constraint_inputs(block,
parent_flow_inline_size, parent_flow_inline_size,
layout_context.shared_context()); shared_context);
let containing_block_inline_size = let containing_block_inline_size =
self.containing_block_inline_size(block, parent_flow_inline_size, layout_context.shared_context()); self.containing_block_inline_size(block, parent_flow_inline_size, shared_context);
let mut solution = self.solve_inline_size_constraints(block, &input); let mut solution = self.solve_inline_size_constraints(block, &input);

3
components/layout/flex.rs
View file

@ -25,6 +25,7 @@ use script_layout_interface::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW};
use std::cmp::max; use std::cmp::max;
use std::sync::Arc; use std::sync::Arc;
use style::computed_values::flex_direction; use style::computed_values::flex_direction;
use style::context::StyleContext;
use style::logical_geometry::LogicalSize; use style::logical_geometry::LogicalSize;
use style::properties::{ComputedValues, ServoComputedValues}; use style::properties::{ComputedValues, ServoComputedValues};
use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone}; use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
@ -413,7 +414,7 @@ impl Flow for FlexFlow {
// Our inline-size was set to the inline-size of the containing block by the flow's parent. // Our inline-size was set to the inline-size of the containing block by the flow's parent.
// Now compute the real value. // Now compute the real value.
let containing_block_inline_size = self.block_flow.base.block_container_inline_size; let containing_block_inline_size = self.block_flow.base.block_container_inline_size;
self.block_flow.compute_used_inline_size(layout_context, containing_block_inline_size); self.block_flow.compute_used_inline_size(layout_context.shared_context(), containing_block_inline_size);
if self.block_flow.base.flags.is_float() { if self.block_flow.base.flags.is_float() {
self.block_flow.float.as_mut().unwrap().containing_inline_size = containing_block_inline_size self.block_flow.float.as_mut().unwrap().containing_inline_size = containing_block_inline_size
} }

7
components/layout/table.rs
View file

@ -28,6 +28,7 @@ use style::computed_values::{border_collapse, border_spacing, table_layout};
use style::context::StyleContext; use style::context::StyleContext;
use style::logical_geometry::LogicalSize; use style::logical_geometry::LogicalSize;
use style::properties::{ComputedValues, ServoComputedValues}; use style::properties::{ComputedValues, ServoComputedValues};
use style::servo::SharedStyleContext;
use style::values::CSSFloat; use style::values::CSSFloat;
use style::values::computed::LengthOrPercentageOrAuto; use style::values::computed::LengthOrPercentageOrAuto;
use table_row::TableRowFlow; use table_row::TableRowFlow;
@ -348,7 +349,7 @@ impl Flow for TableFlow {
border_collapse: self.block_flow.fragment.style.get_inheritedtable().border_collapse, border_collapse: self.block_flow.fragment.style.get_inheritedtable().border_collapse,
}; };
inline_size_computer.compute_used_inline_size(&mut self.block_flow, inline_size_computer.compute_used_inline_size(&mut self.block_flow,
layout_context, layout_context.shared_context(),
containing_block_inline_size); containing_block_inline_size);
let inline_start_content_edge = self.block_flow.fragment.border_padding.inline_start; let inline_start_content_edge = self.block_flow.fragment.border_padding.inline_start;
@ -518,11 +519,11 @@ impl ISizeAndMarginsComputer for InternalTable {
/// CSS Section 10.4: Minimum and Maximum inline-sizes /// CSS Section 10.4: Minimum and Maximum inline-sizes
fn compute_used_inline_size(&self, fn compute_used_inline_size(&self,
block: &mut BlockFlow, block: &mut BlockFlow,
layout_context: &LayoutContext, shared_context: &SharedStyleContext,
parent_flow_inline_size: Au) { parent_flow_inline_size: Au) {
let mut input = self.compute_inline_size_constraint_inputs(block, let mut input = self.compute_inline_size_constraint_inputs(block,
parent_flow_inline_size, parent_flow_inline_size,
layout_context.shared_context()); shared_context);
// Tables are always at least as wide as their minimum inline size. // Tables are always at least as wide as their minimum inline size.
let minimum_inline_size = let minimum_inline_size =

3
components/layout/table_cell.rs
View file

@ -23,6 +23,7 @@ use script_layout_interface::wrapper_traits::ThreadSafeLayoutNode;
use std::fmt; use std::fmt;
use std::sync::Arc; use std::sync::Arc;
use style::computed_values::{border_collapse, border_top_style, vertical_align}; use style::computed_values::{border_collapse, border_top_style, vertical_align};
use style::context::StyleContext;
use style::logical_geometry::{LogicalMargin, LogicalRect, LogicalSize, WritingMode}; use style::logical_geometry::{LogicalMargin, LogicalRect, LogicalSize, WritingMode};
use style::properties::{ComputedValues, ServoComputedValues}; use style::properties::{ComputedValues, ServoComputedValues};
use table::InternalTable; use table::InternalTable;
@ -174,7 +175,7 @@ impl Flow for TableCellFlow {
border_collapse: self.block_flow.fragment.style.get_inheritedtable().border_collapse, border_collapse: self.block_flow.fragment.style.get_inheritedtable().border_collapse,
}; };
inline_size_computer.compute_used_inline_size(&mut self.block_flow, inline_size_computer.compute_used_inline_size(&mut self.block_flow,
layout_context, layout_context.shared_context(),
containing_block_inline_size); containing_block_inline_size);
let inline_start_content_edge = let inline_start_content_edge =

3
components/layout/table_row.rs
View file

@ -25,6 +25,7 @@ use std::fmt;
use std::iter::{Enumerate, IntoIterator, Peekable}; use std::iter::{Enumerate, IntoIterator, Peekable};
use std::sync::Arc; use std::sync::Arc;
use style::computed_values::{border_collapse, border_spacing, border_top_style}; use style::computed_values::{border_collapse, border_spacing, border_top_style};
use style::context::StyleContext;
use style::logical_geometry::{LogicalSize, PhysicalSide, WritingMode}; use style::logical_geometry::{LogicalSize, PhysicalSide, WritingMode};
use style::properties::{ComputedValues, ServoComputedValues}; use style::properties::{ComputedValues, ServoComputedValues};
use style::values::computed::LengthOrPercentageOrAuto; use style::values::computed::LengthOrPercentageOrAuto;
@ -327,7 +328,7 @@ impl Flow for TableRowFlow {
border_collapse: self.block_flow.fragment.style.get_inheritedtable().border_collapse, border_collapse: self.block_flow.fragment.style.get_inheritedtable().border_collapse,
}; };
inline_size_computer.compute_used_inline_size(&mut self.block_flow, inline_size_computer.compute_used_inline_size(&mut self.block_flow,
layout_context, layout_context.shared_context(),
containing_block_inline_size); containing_block_inline_size);
// Spread out the completed inline sizes among columns with spans > 1. // Spread out the completed inline sizes among columns with spans > 1.

3
components/layout/table_rowgroup.rs
View file

@ -21,6 +21,7 @@ use std::fmt;
use std::iter::{IntoIterator, Iterator, Peekable}; use std::iter::{IntoIterator, Iterator, Peekable};
use std::sync::Arc; use std::sync::Arc;
use style::computed_values::{border_collapse, border_spacing}; use style::computed_values::{border_collapse, border_spacing};
use style::context::StyleContext;
use style::logical_geometry::{LogicalSize, WritingMode}; use style::logical_geometry::{LogicalSize, WritingMode};
use style::properties::{ComputedValues, ServoComputedValues}; use style::properties::{ComputedValues, ServoComputedValues};
use table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize, InternalTable, TableLikeFlow}; use table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize, InternalTable, TableLikeFlow};
@ -154,7 +155,7 @@ impl Flow for TableRowGroupFlow {
border_collapse: border_collapse, border_collapse: border_collapse,
}; };
inline_size_computer.compute_used_inline_size(&mut self.block_flow, inline_size_computer.compute_used_inline_size(&mut self.block_flow,
layout_context, layout_context.shared_context(),
containing_block_inline_size); containing_block_inline_size);
let column_computed_inline_sizes = &self.column_computed_inline_sizes; let column_computed_inline_sizes = &self.column_computed_inline_sizes;