Source code
Revision control
Copy as Markdown
Other Tools
/* 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
//! 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")
}
#[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"),
];
//
// 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"),
];
if element.is_html_element() {
let local_name = element.local_name();
return SPECIAL_HTML_ELEMENTS
.iter()
.any(|name| &**name == local_name);
}
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);
}
//
// 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 }
}
///
/// 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
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.
/// 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').
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")]
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);
}
}
///
/// 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:
///
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.
///
#[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.
/// "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 => {},
// 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)
},
// 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
///
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:
///
///
/// 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,
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
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:
///
#[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'.
///
#[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.
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();
}
}