summaryrefslogtreecommitdiffstats
path: root/servo/components/style/style_adjuster.rs
diff options
context:
space:
mode:
Diffstat (limited to 'servo/components/style/style_adjuster.rs')
-rw-r--r--servo/components/style/style_adjuster.rs1009
1 files changed, 1009 insertions, 0 deletions
diff --git a/servo/components/style/style_adjuster.rs b/servo/components/style/style_adjuster.rs
new file mode 100644
index 0000000000..a993d79d6a
--- /dev/null
+++ b/servo/components/style/style_adjuster.rs
@@ -0,0 +1,1009 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! A struct to encapsulate all the style fixups and flags propagations
+//! a computed style needs in order for it to adhere to the CSS spec.
+
+use crate::computed_value_flags::ComputedValueFlags;
+use crate::dom::TElement;
+use crate::properties::longhands::contain::computed_value::T as Contain;
+use crate::properties::longhands::container_type::computed_value::T as ContainerType;
+use crate::properties::longhands::content_visibility::computed_value::T as ContentVisibility;
+use crate::properties::longhands::display::computed_value::T as Display;
+use crate::properties::longhands::float::computed_value::T as Float;
+use crate::properties::longhands::overflow_x::computed_value::T as Overflow;
+use crate::properties::longhands::position::computed_value::T as Position;
+use crate::properties::{self, ComputedValues, StyleBuilder};
+
+/// A struct that implements all the adjustment methods.
+///
+/// NOTE(emilio): If new adjustments are introduced that depend on reset
+/// properties of the parent, you may need tweaking the
+/// `ChildCascadeRequirement` code in `matching.rs`.
+///
+/// NOTE(emilio): Also, if new adjustments are introduced that break the
+/// following invariant:
+///
+/// Given same tag name, namespace, rules and parent style, two elements would
+/// end up with exactly the same style.
+///
+/// Then you need to adjust the lookup_by_rules conditions in the sharing cache.
+pub struct StyleAdjuster<'a, 'b: 'a> {
+ style: &'a mut StyleBuilder<'b>,
+}
+
+#[cfg(feature = "gecko")]
+fn is_topmost_svg_svg_element<E>(e: E) -> bool
+where
+ E: TElement,
+{
+ debug_assert!(e.is_svg_element());
+ if e.local_name() != &*atom!("svg") {
+ return false;
+ }
+
+ let parent = match e.traversal_parent() {
+ Some(n) => n,
+ None => return true,
+ };
+
+ if !parent.is_svg_element() {
+ return true;
+ }
+
+ parent.local_name() == &*atom!("foreignObject")
+}
+
+// https://drafts.csswg.org/css-display/#unbox
+#[cfg(feature = "gecko")]
+fn is_effective_display_none_for_display_contents<E>(element: E) -> bool
+where
+ E: TElement,
+{
+ use crate::Atom;
+
+ const SPECIAL_HTML_ELEMENTS: [Atom; 16] = [
+ atom!("br"),
+ atom!("wbr"),
+ atom!("meter"),
+ atom!("progress"),
+ atom!("canvas"),
+ atom!("embed"),
+ atom!("object"),
+ atom!("audio"),
+ atom!("iframe"),
+ atom!("img"),
+ atom!("video"),
+ atom!("frame"),
+ atom!("frameset"),
+ atom!("input"),
+ atom!("textarea"),
+ atom!("select"),
+ ];
+
+ // https://drafts.csswg.org/css-display/#unbox-svg
+ //
+ // There's a note about "Unknown elements", but there's not a good way to
+ // know what that means, or to get that information from here, and no other
+ // UA implements this either.
+ const SPECIAL_SVG_ELEMENTS: [Atom; 6] = [
+ atom!("svg"),
+ atom!("a"),
+ atom!("g"),
+ atom!("use"),
+ atom!("tspan"),
+ atom!("textPath"),
+ ];
+
+ // https://drafts.csswg.org/css-display/#unbox-html
+ if element.is_html_element() {
+ let local_name = element.local_name();
+ return SPECIAL_HTML_ELEMENTS
+ .iter()
+ .any(|name| &**name == local_name);
+ }
+
+ // https://drafts.csswg.org/css-display/#unbox-svg
+ if element.is_svg_element() {
+ if is_topmost_svg_svg_element(element) {
+ return true;
+ }
+ let local_name = element.local_name();
+ return !SPECIAL_SVG_ELEMENTS
+ .iter()
+ .any(|name| &**name == local_name);
+ }
+
+ // https://drafts.csswg.org/css-display/#unbox-mathml
+ //
+ // We always treat XUL as display: none. We don't use display:
+ // contents in XUL anyway, so should be fine to be consistent with
+ // MathML unless there's a use case for it.
+ if element.is_mathml_element() || element.is_xul_element() {
+ return true;
+ }
+
+ false
+}
+
+impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
+ /// Trivially constructs a new StyleAdjuster.
+ #[inline]
+ pub fn new(style: &'a mut StyleBuilder<'b>) -> Self {
+ StyleAdjuster { style }
+ }
+
+ /// <https://fullscreen.spec.whatwg.org/#new-stacking-layer>
+ ///
+ /// Any position value other than 'absolute' and 'fixed' are
+ /// computed to 'absolute' if the element is in a top layer.
+ ///
+ fn adjust_for_top_layer(&mut self) {
+ if !self.style.in_top_layer() {
+ return;
+ }
+ if !self.style.is_absolutely_positioned() {
+ self.style.mutate_box().set_position(Position::Absolute);
+ }
+ if self.style.get_box().clone_display().is_contents() {
+ self.style.mutate_box().set_display(Display::Block);
+ }
+ }
+
+ /// -webkit-box with line-clamp and vertical orientation gets turned into
+ /// flow-root at computed-value time.
+ ///
+ /// This makes the element not be a flex container, with all that it
+ /// implies, but it should be safe. It matches blink, see
+ /// https://bugzilla.mozilla.org/show_bug.cgi?id=1786147#c10
+ fn adjust_for_webkit_line_clamp(&mut self) {
+ use crate::properties::longhands::_moz_box_orient::computed_value::T as BoxOrient;
+ use crate::values::specified::box_::{DisplayInside, DisplayOutside};
+ let box_style = self.style.get_box();
+ if box_style.clone__webkit_line_clamp().is_none() {
+ return;
+ }
+ let disp = box_style.clone_display();
+ if disp.inside() != DisplayInside::WebkitBox {
+ return;
+ }
+ if self.style.get_xul().clone__moz_box_orient() != BoxOrient::Vertical {
+ return;
+ }
+ let new_display = if disp.outside() == DisplayOutside::Block {
+ Display::FlowRoot
+ } else {
+ debug_assert_eq!(disp.outside(), DisplayOutside::Inline);
+ Display::InlineBlock
+ };
+ self.style
+ .mutate_box()
+ .set_adjusted_display(new_display, false);
+ }
+
+ /// CSS 2.1 section 9.7:
+ ///
+ /// If 'position' has the value 'absolute' or 'fixed', [...] the computed
+ /// value of 'float' is 'none'.
+ ///
+ fn adjust_for_position(&mut self) {
+ if self.style.is_absolutely_positioned() && self.style.is_floating() {
+ self.style.mutate_box().set_float(Float::None);
+ }
+ }
+
+ /// Whether we should skip any item-based display property blockification on
+ /// this element.
+ fn skip_item_display_fixup<E>(&self, element: Option<E>) -> bool
+ where
+ E: TElement,
+ {
+ if let Some(pseudo) = self.style.pseudo {
+ return pseudo.skip_item_display_fixup();
+ }
+
+ element.map_or(false, |e| e.skip_item_display_fixup())
+ }
+
+ /// Apply the blockification rules based on the table in CSS 2.2 section 9.7.
+ /// <https://drafts.csswg.org/css2/visuren.html#dis-pos-flo>
+ /// A ::marker pseudo-element with 'list-style-position:outside' needs to
+ /// have its 'display' blockified, unless the ::marker is for an inline
+ /// list-item (for which 'list-style-position:outside' behaves as 'inside').
+ /// https://drafts.csswg.org/css-lists-3/#list-style-position-property
+ fn blockify_if_necessary<E>(&mut self, layout_parent_style: &ComputedValues, element: Option<E>)
+ where
+ E: TElement,
+ {
+ let mut blockify = false;
+ macro_rules! blockify_if {
+ ($if_what:expr) => {
+ if !blockify {
+ blockify = $if_what;
+ }
+ };
+ }
+
+ blockify_if!(self.style.is_root_element);
+ if !self.skip_item_display_fixup(element) {
+ let parent_display = layout_parent_style.get_box().clone_display();
+ blockify_if!(parent_display.is_item_container());
+ }
+
+ let is_item_or_root = blockify;
+
+ blockify_if!(self.style.is_floating());
+ blockify_if!(self.style.is_absolutely_positioned());
+
+ if !blockify {
+ return;
+ }
+
+ let display = self.style.get_box().clone_display();
+ let blockified_display = display.equivalent_block_display(self.style.is_root_element);
+ if display != blockified_display {
+ self.style
+ .mutate_box()
+ .set_adjusted_display(blockified_display, is_item_or_root);
+ }
+ }
+
+ /// Compute a few common flags for both text and element's style.
+ fn set_bits(&mut self) {
+ let box_style = self.style.get_box();
+ let display = box_style.clone_display();
+
+ if !display.is_contents() {
+ if !self
+ .style
+ .get_text()
+ .clone_text_decoration_line()
+ .is_empty()
+ {
+ self.style
+ .add_flags(ComputedValueFlags::HAS_TEXT_DECORATION_LINES);
+ }
+
+ if self.style.get_effects().clone_opacity() == 0. {
+ self.style
+ .add_flags(ComputedValueFlags::IS_IN_OPACITY_ZERO_SUBTREE);
+ }
+ }
+
+ if self.style.is_pseudo_element() {
+ self.style
+ .add_flags(ComputedValueFlags::IS_IN_PSEUDO_ELEMENT_SUBTREE);
+ }
+
+ if self.style.is_root_element {
+ self.style
+ .add_flags(ComputedValueFlags::IS_ROOT_ELEMENT_STYLE);
+ }
+
+ if box_style
+ .clone_effective_containment()
+ .contains(Contain::STYLE)
+ {
+ self.style
+ .add_flags(ComputedValueFlags::SELF_OR_ANCESTOR_HAS_CONTAIN_STYLE);
+ }
+
+ if box_style.clone_container_type().is_size_container_type() {
+ self.style
+ .add_flags(ComputedValueFlags::SELF_OR_ANCESTOR_HAS_SIZE_CONTAINER_TYPE);
+ }
+
+ #[cfg(feature = "servo-layout-2013")]
+ {
+ if self.style.get_parent_column().is_multicol() {
+ self.style.add_flags(ComputedValueFlags::CAN_BE_FRAGMENTED);
+ }
+ }
+ }
+
+ /// Adjust the style for text style.
+ ///
+ /// The adjustments here are a subset of the adjustments generally, because
+ /// text only inherits properties.
+ ///
+ /// Note that this, for Gecko, comes through Servo_ComputedValues_Inherit.
+ #[cfg(feature = "gecko")]
+ pub fn adjust_for_text(&mut self) {
+ debug_assert!(!self.style.is_root_element);
+ self.adjust_for_text_combine_upright();
+ self.adjust_for_text_in_ruby();
+ self.set_bits();
+ }
+
+ /// Change writing mode of the text frame for text-combine-upright.
+ ///
+ /// It is safe to look at our own style because we are looking at inherited
+ /// properties, and text is just plain inheritance.
+ ///
+ /// TODO(emilio): we should (Gecko too) revise these adjustments in presence
+ /// of display: contents.
+ ///
+ /// FIXME(emilio): How does this play with logical properties? Doesn't
+ /// mutating writing-mode change the potential physical sides chosen?
+ #[cfg(feature = "gecko")]
+ fn adjust_for_text_combine_upright(&mut self) {
+ use crate::computed_values::text_combine_upright::T as TextCombineUpright;
+ use crate::computed_values::writing_mode::T as WritingMode;
+ use crate::logical_geometry;
+
+ let writing_mode = self.style.get_inherited_box().clone_writing_mode();
+ let text_combine_upright = self.style.get_inherited_text().clone_text_combine_upright();
+
+ if matches!(
+ writing_mode,
+ WritingMode::VerticalRl | WritingMode::VerticalLr
+ ) && text_combine_upright == TextCombineUpright::All
+ {
+ self.style.add_flags(ComputedValueFlags::IS_TEXT_COMBINED);
+ self.style
+ .mutate_inherited_box()
+ .set_writing_mode(WritingMode::HorizontalTb);
+ self.style.writing_mode =
+ logical_geometry::WritingMode::new(self.style.get_inherited_box());
+ }
+ }
+
+ /// Unconditionally propagates the line break suppression flag to text, and
+ /// additionally it applies it if it is in any ruby box.
+ ///
+ /// This is necessary because its parent may not itself have the flag set
+ /// (e.g. ruby or ruby containers), thus we may not inherit the flag from
+ /// them.
+ #[cfg(feature = "gecko")]
+ fn adjust_for_text_in_ruby(&mut self) {
+ let parent_display = self.style.get_parent_box().clone_display();
+ if parent_display.is_ruby_type() ||
+ self.style
+ .get_parent_flags()
+ .contains(ComputedValueFlags::SHOULD_SUPPRESS_LINEBREAK)
+ {
+ self.style
+ .add_flags(ComputedValueFlags::SHOULD_SUPPRESS_LINEBREAK);
+ }
+ }
+
+ /// <https://drafts.csswg.org/css-writing-modes-3/#block-flow:>
+ ///
+ /// If a box has a different writing-mode value than its containing
+ /// block:
+ ///
+ /// - If the box has a specified display of inline, its display
+ /// computes to inline-block. [CSS21]
+ ///
+ /// This matches the adjustment that Gecko does, not exactly following
+ /// the spec. See also:
+ ///
+ /// <https://lists.w3.org/Archives/Public/www-style/2017Mar/0045.html>
+ /// <https://github.com/servo/servo/issues/15754>
+ fn adjust_for_writing_mode(&mut self, layout_parent_style: &ComputedValues) {
+ let our_writing_mode = self.style.get_inherited_box().clone_writing_mode();
+ let parent_writing_mode = layout_parent_style.get_inherited_box().clone_writing_mode();
+
+ if our_writing_mode != parent_writing_mode &&
+ self.style.get_box().clone_display() == Display::Inline
+ {
+ // TODO(emilio): Figure out if we can just set the adjusted display
+ // on Gecko too and unify this code path.
+ if cfg!(feature = "servo") {
+ self.style
+ .mutate_box()
+ .set_adjusted_display(Display::InlineBlock, false);
+ } else {
+ self.style.mutate_box().set_display(Display::InlineBlock);
+ }
+ }
+ }
+
+ /// This implements an out-of-date spec. The new spec moves the handling of
+ /// this to layout, which Gecko implements but Servo doesn't.
+ ///
+ /// See https://github.com/servo/servo/issues/15229
+ #[cfg(feature = "servo")]
+ fn adjust_for_alignment(&mut self, layout_parent_style: &ComputedValues) {
+ use crate::computed_values::align_items::T as AlignItems;
+ use crate::computed_values::align_self::T as AlignSelf;
+
+ if self.style.get_position().clone_align_self() == AlignSelf::Auto &&
+ !self.style.is_absolutely_positioned()
+ {
+ let self_align = match layout_parent_style.get_position().clone_align_items() {
+ AlignItems::Stretch => AlignSelf::Stretch,
+ AlignItems::Baseline => AlignSelf::Baseline,
+ AlignItems::FlexStart => AlignSelf::FlexStart,
+ AlignItems::FlexEnd => AlignSelf::FlexEnd,
+ AlignItems::Center => AlignSelf::Center,
+ };
+ self.style.mutate_position().set_align_self(self_align);
+ }
+ }
+
+ /// The initial value of border-*-width may be changed at computed value
+ /// time.
+ ///
+ /// This is moved to properties.rs for convenience.
+ fn adjust_for_border_width(&mut self) {
+ properties::adjust_border_width(self.style);
+ }
+
+ /// column-rule-style: none causes a computed column-rule-width of zero
+ /// at computed value time.
+ fn adjust_for_column_rule_width(&mut self) {
+ let column_style = self.style.get_column();
+ if !column_style.clone_column_rule_style().none_or_hidden() {
+ return;
+ }
+ if !column_style.column_rule_has_nonzero_width() {
+ return;
+ }
+ self.style
+ .mutate_column()
+ .set_column_rule_width(crate::Zero::zero());
+ }
+
+ /// outline-style: none causes a computed outline-width of zero at computed
+ /// value time.
+ fn adjust_for_outline_width(&mut self) {
+ let outline = self.style.get_outline();
+ if !outline.clone_outline_style().none_or_hidden() {
+ return;
+ }
+ if !outline.outline_has_nonzero_width() {
+ return;
+ }
+ self.style
+ .mutate_outline()
+ .set_outline_width(crate::Zero::zero());
+ }
+
+ /// CSS overflow-x and overflow-y require some fixup as well in some cases.
+ /// https://drafts.csswg.org/css-overflow-3/#overflow-properties
+ /// "Computed value: as specified, except with `visible`/`clip` computing to
+ /// `auto`/`hidden` (respectively) if one of `overflow-x` or `overflow-y` is
+ /// neither `visible` nor `clip`."
+ fn adjust_for_overflow(&mut self) {
+ let overflow_x = self.style.get_box().clone_overflow_x();
+ let overflow_y = self.style.get_box().clone_overflow_y();
+ if overflow_x == overflow_y {
+ return; // optimization for the common case
+ }
+
+ if overflow_x.is_scrollable() != overflow_y.is_scrollable() {
+ let box_style = self.style.mutate_box();
+ box_style.set_overflow_x(overflow_x.to_scrollable());
+ box_style.set_overflow_y(overflow_y.to_scrollable());
+ }
+ }
+
+ fn adjust_for_contain(&mut self) {
+ let box_style = self.style.get_box();
+ let container_type = box_style.clone_container_type();
+ let content_visibility = box_style.clone_content_visibility();
+ if container_type == ContainerType::Normal &&
+ content_visibility == ContentVisibility::Visible
+ {
+ debug_assert_eq!(
+ box_style.clone_contain(),
+ box_style.clone_effective_containment()
+ );
+ return;
+ }
+ let old_contain = box_style.clone_contain();
+ let mut new_contain = old_contain;
+ match content_visibility {
+ ContentVisibility::Visible => {},
+ // `content-visibility:auto` also applies size containment when content
+ // is not relevant (and therefore skipped). This is checked in
+ // nsIFrame::GetContainSizeAxes.
+ ContentVisibility::Auto => {
+ new_contain.insert(Contain::LAYOUT | Contain::PAINT | Contain::STYLE)
+ },
+ ContentVisibility::Hidden => new_contain
+ .insert(Contain::LAYOUT | Contain::PAINT | Contain::SIZE | Contain::STYLE),
+ }
+ match container_type {
+ ContainerType::Normal => {},
+ // https://drafts.csswg.org/css-contain-3/#valdef-container-type-inline-size:
+ // Applies layout containment, style containment, and inline-size
+ // containment to the principal box.
+ ContainerType::InlineSize => {
+ new_contain.insert(Contain::LAYOUT | Contain::STYLE | Contain::INLINE_SIZE)
+ },
+ // https://drafts.csswg.org/css-contain-3/#valdef-container-type-size:
+ // Applies layout containment, style containment, and size
+ // containment to the principal box.
+ ContainerType::Size => {
+ new_contain.insert(Contain::LAYOUT | Contain::STYLE | Contain::SIZE)
+ },
+ }
+ if new_contain == old_contain {
+ debug_assert_eq!(
+ box_style.clone_contain(),
+ box_style.clone_effective_containment()
+ );
+ return;
+ }
+ self.style
+ .mutate_box()
+ .set_effective_containment(new_contain);
+ }
+
+ /// content-visibility: auto should force contain-intrinsic-size to gain
+ /// an auto value
+ ///
+ /// <https://github.com/w3c/csswg-drafts/issues/8407>
+ fn adjust_for_contain_intrinsic_size(&mut self) {
+ let content_visibility = self.style.get_box().clone_content_visibility();
+ if content_visibility != ContentVisibility::Auto {
+ return;
+ }
+
+ let pos = self.style.get_position();
+ let new_width = pos.clone_contain_intrinsic_width().add_auto_if_needed();
+ let new_height = pos.clone_contain_intrinsic_height().add_auto_if_needed();
+ if new_width.is_none() && new_height.is_none() {
+ return;
+ }
+
+ let pos = self.style.mutate_position();
+ if let Some(width) = new_width {
+ pos.set_contain_intrinsic_width(width);
+ }
+ if let Some(height) = new_height {
+ pos.set_contain_intrinsic_height(height);
+ }
+ }
+
+ /// Handles the relevant sections in:
+ ///
+ /// https://drafts.csswg.org/css-display/#unbox-html
+ ///
+ /// And forbidding display: contents in pseudo-elements, at least for now.
+ #[cfg(feature = "gecko")]
+ fn adjust_for_prohibited_display_contents<E>(&mut self, element: Option<E>)
+ where
+ E: TElement,
+ {
+ if self.style.get_box().clone_display() != Display::Contents {
+ return;
+ }
+
+ // FIXME(emilio): ::before and ::after should support display: contents,
+ // see bug 1418138.
+ if self.style.pseudo.is_some() {
+ self.style.mutate_box().set_display(Display::Inline);
+ return;
+ }
+
+ let element = match element {
+ Some(e) => e,
+ None => return,
+ };
+
+ if is_effective_display_none_for_display_contents(element) {
+ self.style.mutate_box().set_display(Display::None);
+ }
+ }
+
+ /// <textarea>'s editor root needs to inherit the overflow value from its
+ /// parent, but we need to make sure it's still scrollable.
+ #[cfg(feature = "gecko")]
+ fn adjust_for_text_control_editing_root(&mut self) {
+ use crate::selector_parser::PseudoElement;
+
+ if self.style.pseudo != Some(&PseudoElement::MozTextControlEditingRoot) {
+ return;
+ }
+
+ let box_style = self.style.get_box();
+ let overflow_x = box_style.clone_overflow_x();
+ let overflow_y = box_style.clone_overflow_y();
+
+ // If at least one is scrollable we'll adjust the other one in
+ // adjust_for_overflow if needed.
+ if overflow_x.is_scrollable() || overflow_y.is_scrollable() {
+ return;
+ }
+
+ let box_style = self.style.mutate_box();
+ box_style.set_overflow_x(Overflow::Auto);
+ box_style.set_overflow_y(Overflow::Auto);
+ }
+
+ /// If a <fieldset> has grid/flex display type, we need to inherit
+ /// this type into its ::-moz-fieldset-content anonymous box.
+ ///
+ /// NOTE(emilio): We don't need to handle the display change for this case
+ /// in matching.rs because anonymous box restyling works separately to the
+ /// normal cascading process.
+ #[cfg(feature = "gecko")]
+ fn adjust_for_fieldset_content(&mut self, layout_parent_style: &ComputedValues) {
+ use crate::selector_parser::PseudoElement;
+
+ if self.style.pseudo != Some(&PseudoElement::FieldsetContent) {
+ return;
+ }
+
+ // TODO We actually want style from parent rather than layout
+ // parent, so that this fixup doesn't happen incorrectly when
+ // when <fieldset> has "display: contents".
+ let parent_display = layout_parent_style.get_box().clone_display();
+ let new_display = match parent_display {
+ Display::Flex | Display::InlineFlex => Some(Display::Flex),
+ Display::Grid | Display::InlineGrid => Some(Display::Grid),
+ _ => None,
+ };
+ if let Some(new_display) = new_display {
+ self.style.mutate_box().set_display(new_display);
+ }
+ }
+
+ /// -moz-center, -moz-left and -moz-right are used for HTML's alignment.
+ ///
+ /// This is covering the <div align="right"><table>...</table></div> case.
+ ///
+ /// In this case, we don't want to inherit the text alignment into the
+ /// table.
+ #[cfg(feature = "gecko")]
+ fn adjust_for_table_text_align(&mut self) {
+ use crate::properties::longhands::text_align::computed_value::T as TextAlign;
+ if self.style.get_box().clone_display() != Display::Table {
+ return;
+ }
+
+ match self.style.get_inherited_text().clone_text_align() {
+ TextAlign::MozLeft | TextAlign::MozCenter | TextAlign::MozRight => {},
+ _ => return,
+ }
+
+ self.style
+ .mutate_inherited_text()
+ .set_text_align(TextAlign::Start)
+ }
+
+ /// Computes the used text decoration for Servo.
+ ///
+ /// FIXME(emilio): This is a layout tree concept, should move away from
+ /// style, since otherwise we're going to have the same subtle bugs WebKit
+ /// and Blink have with this very same thing.
+ #[cfg(feature = "servo")]
+ fn adjust_for_text_decorations_in_effect(&mut self) {
+ use crate::values::computed::text::TextDecorationsInEffect;
+
+ let decorations_in_effect = TextDecorationsInEffect::from_style(&self.style);
+ if self.style.get_inherited_text().text_decorations_in_effect != decorations_in_effect {
+ self.style
+ .mutate_inherited_text()
+ .text_decorations_in_effect = decorations_in_effect;
+ }
+ }
+
+ #[cfg(feature = "gecko")]
+ fn should_suppress_linebreak<E>(
+ &self,
+ layout_parent_style: &ComputedValues,
+ element: Option<E>,
+ ) -> bool
+ where
+ E: TElement,
+ {
+ // Line break suppression should only be propagated to in-flow children.
+ if self.style.is_floating() || self.style.is_absolutely_positioned() {
+ return false;
+ }
+ let parent_display = layout_parent_style.get_box().clone_display();
+ if layout_parent_style
+ .flags
+ .contains(ComputedValueFlags::SHOULD_SUPPRESS_LINEBREAK)
+ {
+ // Line break suppression is propagated to any children of
+ // line participants.
+ if parent_display.is_line_participant() {
+ return true;
+ }
+ }
+ match self.style.get_box().clone_display() {
+ // Ruby base and text are always non-breakable.
+ Display::RubyBase | Display::RubyText => true,
+ // Ruby base container and text container are breakable.
+ // Non-HTML elements may not form ruby base / text container because
+ // they may not respect ruby-internal display values, so we can't
+ // make them escaped from line break suppression.
+ // Note that, when certain HTML tags, e.g. form controls, have ruby
+ // level container display type, they could also escape from the
+ // line break suppression flag while they shouldn't. However, it is
+ // generally fine as far as they can't break the line inside them.
+ Display::RubyBaseContainer | Display::RubyTextContainer
+ if element.map_or(true, |e| e.is_html_element()) =>
+ {
+ false
+ },
+ // Anything else is non-breakable if and only if its layout parent
+ // has a ruby display type, because any of the ruby boxes can be
+ // anonymous.
+ _ => parent_display.is_ruby_type(),
+ }
+ }
+
+ /// Do ruby-related style adjustments, which include:
+ /// * propagate the line break suppression flag,
+ /// * inlinify block descendants,
+ /// * suppress border and padding for ruby level containers,
+ /// * correct unicode-bidi.
+ #[cfg(feature = "gecko")]
+ fn adjust_for_ruby<E>(&mut self, layout_parent_style: &ComputedValues, element: Option<E>)
+ where
+ E: TElement,
+ {
+ use crate::properties::longhands::unicode_bidi::computed_value::T as UnicodeBidi;
+
+ let self_display = self.style.get_box().clone_display();
+ // Check whether line break should be suppressed for this element.
+ if self.should_suppress_linebreak(layout_parent_style, element) {
+ self.style
+ .add_flags(ComputedValueFlags::SHOULD_SUPPRESS_LINEBREAK);
+ // Inlinify the display type if allowed.
+ if !self.skip_item_display_fixup(element) {
+ let inline_display = self_display.inlinify();
+ if self_display != inline_display {
+ self.style
+ .mutate_box()
+ .set_adjusted_display(inline_display, false);
+ }
+ }
+ }
+ // Suppress border and padding for ruby level containers.
+ // This is actually not part of the spec. It is currently unspecified
+ // how border and padding should be handled for ruby level container,
+ // and suppressing them here make it easier for layout to handle.
+ if self_display.is_ruby_level_container() {
+ self.style.reset_border_struct();
+ self.style.reset_padding_struct();
+ }
+
+ // Force bidi isolation on all internal ruby boxes and ruby container
+ // per spec https://drafts.csswg.org/css-ruby-1/#bidi
+ if self_display.is_ruby_type() {
+ let new_value = match self.style.get_text().clone_unicode_bidi() {
+ UnicodeBidi::Normal | UnicodeBidi::Embed => Some(UnicodeBidi::Isolate),
+ UnicodeBidi::BidiOverride => Some(UnicodeBidi::IsolateOverride),
+ _ => None,
+ };
+ if let Some(new_value) = new_value {
+ self.style.mutate_text().set_unicode_bidi(new_value);
+ }
+ }
+ }
+
+ /// Computes the RELEVANT_LINK_VISITED flag based on the parent style and on
+ /// whether we're a relevant link.
+ ///
+ /// NOTE(emilio): We don't do this for text styles, which is... dubious, but
+ /// Gecko doesn't seem to do it either. It's extremely easy to do if needed
+ /// though.
+ ///
+ /// FIXME(emilio): This isn't technically a style adjustment thingie, could
+ /// it move somewhere else?
+ fn adjust_for_visited<E>(&mut self, element: Option<E>)
+ where
+ E: TElement,
+ {
+ if !self.style.has_visited_style() {
+ return;
+ }
+
+ let is_link_element = self.style.pseudo.is_none() && element.map_or(false, |e| e.is_link());
+
+ if !is_link_element {
+ return;
+ }
+
+ if element.unwrap().is_visited_link() {
+ self.style
+ .add_flags(ComputedValueFlags::IS_RELEVANT_LINK_VISITED);
+ } else {
+ // Need to remove to handle unvisited link inside visited.
+ self.style
+ .remove_flags(ComputedValueFlags::IS_RELEVANT_LINK_VISITED);
+ }
+ }
+
+ /// Resolves "justify-items: legacy" based on the inherited style if needed
+ /// to comply with:
+ ///
+ /// <https://drafts.csswg.org/css-align/#valdef-justify-items-legacy>
+ #[cfg(feature = "gecko")]
+ fn adjust_for_justify_items(&mut self) {
+ use crate::values::specified::align;
+ let justify_items = self.style.get_position().clone_justify_items();
+ if justify_items.specified.0 != align::AlignFlags::LEGACY {
+ return;
+ }
+
+ let parent_justify_items = self.style.get_parent_position().clone_justify_items();
+
+ if !parent_justify_items
+ .computed
+ .0
+ .contains(align::AlignFlags::LEGACY)
+ {
+ return;
+ }
+
+ if parent_justify_items.computed == justify_items.computed {
+ return;
+ }
+
+ self.style
+ .mutate_position()
+ .set_computed_justify_items(parent_justify_items.computed);
+ }
+
+ /// If '-webkit-appearance' is 'menulist' on a <select> element then
+ /// the computed value of 'line-height' is 'normal'.
+ ///
+ /// https://github.com/w3c/csswg-drafts/issues/3257
+ #[cfg(feature = "gecko")]
+ fn adjust_for_appearance<E>(&mut self, element: Option<E>)
+ where
+ E: TElement,
+ {
+ use crate::properties::longhands::appearance::computed_value::T as Appearance;
+ use crate::properties::longhands::line_height::computed_value::T as LineHeight;
+
+ let box_ = self.style.get_box();
+ let appearance = match box_.clone_appearance() {
+ Appearance::Auto => box_.clone__moz_default_appearance(),
+ a => a,
+ };
+
+ if appearance == Appearance::Menulist {
+ if self.style.get_font().clone_line_height() == LineHeight::normal() {
+ return;
+ }
+ if self.style.pseudo.is_some() {
+ return;
+ }
+ let is_html_select_element = element.map_or(false, |e| {
+ e.is_html_element() && e.local_name() == &*atom!("select")
+ });
+ if !is_html_select_element {
+ return;
+ }
+ self.style
+ .mutate_font()
+ .set_line_height(LineHeight::normal());
+ }
+ }
+
+ /// A legacy ::marker (i.e. no 'content') without an author-specified 'font-family'
+ /// and 'list-style-type:disc|circle|square|disclosure-closed|disclosure-open'
+ /// is assigned 'font-family:-moz-bullet-font'. (This is for <ul><li> etc.)
+ /// We don't want synthesized italic/bold for this font, so turn that off too.
+ /// Likewise for 'letter/word-spacing' -- unless the author specified it then reset
+ /// them to their initial value because traditionally we never added such spacing
+ /// between a legacy bullet and the list item's content, so we keep that behavior
+ /// for web-compat reasons.
+ /// We intentionally don't check 'list-style-image' below since we want it to use
+ /// the same font as its fallback ('list-style-type') in case it fails to load.
+ #[cfg(feature = "gecko")]
+ fn adjust_for_marker_pseudo(&mut self) {
+ use crate::values::computed::counters::Content;
+ use crate::values::computed::font::{FontFamily, FontSynthesis};
+ use crate::values::computed::text::{LetterSpacing, WordSpacing};
+
+ let is_legacy_marker = self.style.pseudo.map_or(false, |p| p.is_marker()) &&
+ self.style.get_list().clone_list_style_type().is_bullet() &&
+ self.style.get_counters().clone_content() == Content::Normal;
+ if !is_legacy_marker {
+ return;
+ }
+ let flags = self.style.flags.get();
+ if !flags.contains(ComputedValueFlags::HAS_AUTHOR_SPECIFIED_FONT_FAMILY) {
+ self.style
+ .mutate_font()
+ .set_font_family(FontFamily::moz_bullet().clone());
+
+ // FIXME(mats): We can remove this if support for font-synthesis is added to @font-face rules.
+ // Then we can add it to the @font-face rule in html.css instead.
+ // https://github.com/w3c/csswg-drafts/issues/6081
+ if !flags.contains(ComputedValueFlags::HAS_AUTHOR_SPECIFIED_FONT_SYNTHESIS_WEIGHT) {
+ self.style
+ .mutate_font()
+ .set_font_synthesis_weight(FontSynthesis::None);
+ }
+ if !flags.contains(ComputedValueFlags::HAS_AUTHOR_SPECIFIED_FONT_SYNTHESIS_STYLE) {
+ self.style
+ .mutate_font()
+ .set_font_synthesis_style(FontSynthesis::None);
+ }
+ }
+ if !flags.contains(ComputedValueFlags::HAS_AUTHOR_SPECIFIED_LETTER_SPACING) {
+ self.style
+ .mutate_inherited_text()
+ .set_letter_spacing(LetterSpacing::normal());
+ }
+ if !flags.contains(ComputedValueFlags::HAS_AUTHOR_SPECIFIED_WORD_SPACING) {
+ self.style
+ .mutate_inherited_text()
+ .set_word_spacing(WordSpacing::normal());
+ }
+ }
+
+ /// Adjusts the style to account for various fixups that don't fit naturally
+ /// into the cascade.
+ ///
+ /// When comparing to Gecko, this is similar to the work done by
+ /// `ComputedStyle::ApplyStyleFixups`, plus some parts of
+ /// `nsStyleSet::GetContext`.
+ pub fn adjust<E>(&mut self, layout_parent_style: &ComputedValues, element: Option<E>)
+ where
+ E: TElement,
+ {
+ if cfg!(debug_assertions) {
+ if element.map_or(false, |e| e.is_pseudo_element()) {
+ // It'd be nice to assert `self.style.pseudo == Some(&pseudo)`,
+ // but we do resolve ::-moz-list pseudos on ::before / ::after
+ // content, sigh.
+ debug_assert!(self.style.pseudo.is_some(), "Someone really messed up");
+ }
+ }
+ // FIXME(emilio): The apply_declarations callsite in Servo's
+ // animation, and the font stuff for Gecko
+ // (Stylist::compute_for_declarations) should pass an element to
+ // cascade(), then we can make this assertion hold everywhere.
+ // debug_assert!(
+ // element.is_some() || self.style.pseudo.is_some(),
+ // "Should always have an element around for non-pseudo styles"
+ // );
+
+ self.adjust_for_visited(element);
+ #[cfg(feature = "gecko")]
+ {
+ self.adjust_for_prohibited_display_contents(element);
+ self.adjust_for_fieldset_content(layout_parent_style);
+ // NOTE: It's important that this happens before
+ // adjust_for_overflow.
+ self.adjust_for_text_control_editing_root();
+ }
+ self.adjust_for_top_layer();
+ self.blockify_if_necessary(layout_parent_style, element);
+ self.adjust_for_webkit_line_clamp();
+ self.adjust_for_position();
+ self.adjust_for_overflow();
+ self.adjust_for_contain();
+ self.adjust_for_contain_intrinsic_size();
+ #[cfg(feature = "gecko")]
+ {
+ self.adjust_for_table_text_align();
+ self.adjust_for_justify_items();
+ }
+ #[cfg(feature = "servo")]
+ {
+ self.adjust_for_alignment(layout_parent_style);
+ }
+ self.adjust_for_border_width();
+ self.adjust_for_column_rule_width();
+ self.adjust_for_outline_width();
+ self.adjust_for_writing_mode(layout_parent_style);
+ #[cfg(feature = "gecko")]
+ {
+ self.adjust_for_ruby(layout_parent_style, element);
+ }
+ #[cfg(feature = "servo")]
+ {
+ self.adjust_for_text_decorations_in_effect();
+ }
+ #[cfg(feature = "gecko")]
+ {
+ self.adjust_for_appearance(element);
+ self.adjust_for_marker_pseudo();
+ }
+ self.set_bits();
+ }
+}