From bdf1d179bae0541f53259dc28e5b4bbadaeef47c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Mon, 26 Sep 2016 12:10:48 +0200 Subject: layout: Use the fragment's writing mode when computing sizes relevant to that fragment. Otherwise we might mix writing modes. Not totally sure this change is correct in the case we're mixing them, we might need to just not checking that operation. --- components/layout/fragment.rs | 20 ++++++++++++++------ components/layout/model.rs | 13 ++++++++----- 2 files changed, 22 insertions(+), 11 deletions(-) (limited to 'components/layout') diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs index f7f46d2fdcc..db5fd265690 100644 --- a/components/layout/fragment.rs +++ b/components/layout/fragment.rs @@ -1155,8 +1155,14 @@ impl Fragment { match self.inline_context { None => style_border_width, Some(ref inline_fragment_context) => { + // NOTE: We can have nodes with different writing mode inside + // the inline fragment context, so we need to overwrite the + // writing mode to compute the child logical sizes. + let writing_mode = self.style.writing_mode; + inline_fragment_context.nodes.iter().fold(style_border_width, |accumulator, node| { - let mut this_border_width = node.style.logical_border_width(); + let mut this_border_width = + node.style.border_width_for_writing_mode(writing_mode); if !node.flags.contains(FIRST_FRAGMENT_OF_ELEMENT) { this_border_width.inline_start = Au(0) } @@ -1289,7 +1295,7 @@ impl Fragment { SpecificFragmentInfo::TableRow | SpecificFragmentInfo::TableWrapper | SpecificFragmentInfo::InlineBlock(_) => LogicalMargin::zero(self.style.writing_mode), - _ => model::padding_from_style(self.style(), containing_block_inline_size), + _ => model::padding_from_style(self.style(), containing_block_inline_size, self.style().writing_mode), }; // Compute padding from the inline fragment context. @@ -1301,9 +1307,10 @@ impl Fragment { LogicalMargin::zero(self.style.writing_mode) } (_, &Some(ref inline_fragment_context)) => { - let zero_padding = LogicalMargin::zero(self.style.writing_mode); + let writing_mode = self.style.writing_mode; + let zero_padding = LogicalMargin::zero(writing_mode); inline_fragment_context.nodes.iter().fold(zero_padding, |accumulator, node| { - let mut padding = model::padding_from_style(&*node.style, Au(0)); + let mut padding = model::padding_from_style(&*node.style, Au(0), writing_mode); if !node.flags.contains(FIRST_FRAGMENT_OF_ELEMENT) { padding.inline_start = Au(0) } @@ -1529,11 +1536,12 @@ impl Fragment { // Take borders and padding for parent inline fragments into account, if necessary. if self.is_primary_fragment() { + let writing_mode = self.style.writing_mode; if let Some(ref context) = self.inline_context { for node in &context.nodes { let mut border_width = node.style.logical_border_width(); - let mut padding = model::padding_from_style(&*node.style, Au(0)); - let mut margin = model::specified_margin_from_style(&*node.style); + let mut padding = model::padding_from_style(&*node.style, Au(0), writing_mode); + let mut margin = model::specified_margin_from_style(&*node.style, writing_mode); if !node.flags.contains(FIRST_FRAGMENT_OF_ELEMENT) { border_width.inline_start = Au(0); padding.inline_start = Au(0); diff --git a/components/layout/model.rs b/components/layout/model.rs index a336c7ecf93..823ca6469d3 100644 --- a/components/layout/model.rs +++ b/components/layout/model.rs @@ -12,7 +12,7 @@ use fragment::Fragment; use std::cmp::{max, min}; use std::fmt; use style::computed_values::transform::ComputedMatrix; -use style::logical_geometry::LogicalMargin; +use style::logical_geometry::{LogicalMargin, WritingMode}; use style::properties::ServoComputedValues; use style::values::computed::{BorderRadiusSize, LengthOrPercentageOrAuto}; use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrNone}; @@ -463,10 +463,12 @@ pub fn specified_border_radius(radius: BorderRadiusSize, containing_length: Au) } #[inline] -pub fn padding_from_style(style: &ServoComputedValues, containing_block_inline_size: Au) +pub fn padding_from_style(style: &ServoComputedValues, + containing_block_inline_size: Au, + writing_mode: WritingMode) -> LogicalMargin { let padding_style = style.get_padding(); - LogicalMargin::from_physical(style.writing_mode, SideOffsets2D::new( + LogicalMargin::from_physical(writing_mode, SideOffsets2D::new( specified(padding_style.padding_top, containing_block_inline_size), specified(padding_style.padding_right, containing_block_inline_size), specified(padding_style.padding_bottom, containing_block_inline_size), @@ -478,9 +480,10 @@ pub fn padding_from_style(style: &ServoComputedValues, containing_block_inline_s /// /// This is used when calculating intrinsic inline sizes. #[inline] -pub fn specified_margin_from_style(style: &ServoComputedValues) -> LogicalMargin { +pub fn specified_margin_from_style(style: &ServoComputedValues, + writing_mode: WritingMode) -> LogicalMargin { let margin_style = style.get_margin(); - LogicalMargin::from_physical(style.writing_mode, SideOffsets2D::new( + 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(), -- cgit v1.2.3