summaryrefslogtreecommitdiffstats
path: root/servo/components/style/properties/properties.mako.rs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--servo/components/style/properties/properties.mako.rs2958
1 files changed, 2958 insertions, 0 deletions
diff --git a/servo/components/style/properties/properties.mako.rs b/servo/components/style/properties/properties.mako.rs
new file mode 100644
index 0000000000..b08314d7d5
--- /dev/null
+++ b/servo/components/style/properties/properties.mako.rs
@@ -0,0 +1,2958 @@
+/* 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/. */
+
+// This file is a Mako template: http://www.makotemplates.org/
+
+// Please note that valid Rust syntax may be mangled by the Mako parser.
+// For example, Vec<&Foo> will be mangled as Vec&Foo>. To work around these issues, the code
+// can be escaped. In the above example, Vec<<&Foo> or Vec< &Foo> achieves the desired result of Vec<&Foo>.
+
+<%namespace name="helpers" file="/helpers.mako.rs" />
+
+use app_units::Au;
+use servo_arc::{Arc, UniqueArc};
+use std::{ops, ptr};
+use std::{fmt, mem};
+
+#[cfg(feature = "servo")] use euclid::SideOffsets2D;
+#[cfg(feature = "gecko")] use crate::gecko_bindings::structs::{self, nsCSSPropertyID};
+#[cfg(feature = "servo")] use crate::logical_geometry::LogicalMargin;
+#[cfg(feature = "servo")] use crate::computed_values;
+use crate::logical_geometry::WritingMode;
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
+use crate::computed_value_flags::*;
+use cssparser::Parser;
+use crate::media_queries::Device;
+use crate::parser::ParserContext;
+use crate::selector_parser::PseudoElement;
+use crate::stylist::Stylist;
+#[cfg(feature = "servo")] use servo_config::prefs;
+use style_traits::{CssWriter, KeywordsCollectFn, ParseError, SpecifiedValueInfo, StyleParseErrorKind, ToCss};
+use crate::stylesheets::{CssRuleType, CssRuleTypes, Origin};
+use crate::logical_geometry::{LogicalAxis, LogicalCorner, LogicalSide};
+use crate::use_counters::UseCounters;
+use crate::rule_tree::StrongRuleNode;
+use crate::str::CssStringWriter;
+use crate::values::{
+ computed,
+ resolved,
+ specified::{font::SystemFont, length::LineHeightBase},
+};
+use std::cell::Cell;
+use super::{
+ PropertyDeclarationId, PropertyId, NonCustomPropertyId,
+ NonCustomPropertyIdSet, PropertyFlags, SourcePropertyDeclaration,
+ LonghandIdSet, VariableDeclaration, CustomDeclaration,
+ WideKeywordDeclaration, NonCustomPropertyIterator,
+};
+
+<%!
+ from collections import defaultdict
+ from data import Method, PropertyRestrictions, Keyword, to_rust_ident, \
+ to_camel_case, RULE_VALUES, SYSTEM_FONT_LONGHANDS, PRIORITARY_PROPERTIES
+ import os.path
+%>
+
+/// Conversion with fewer impls than From/Into
+pub trait MaybeBoxed<Out> {
+ /// Convert
+ fn maybe_boxed(self) -> Out;
+}
+
+impl<T> MaybeBoxed<T> for T {
+ #[inline]
+ fn maybe_boxed(self) -> T { self }
+}
+
+impl<T> MaybeBoxed<Box<T>> for T {
+ #[inline]
+ fn maybe_boxed(self) -> Box<T> { Box::new(self) }
+}
+
+macro_rules! expanded {
+ ( $( $name: ident: $value: expr ),+ ) => {
+ expanded!( $( $name: $value, )+ )
+ };
+ ( $( $name: ident: $value: expr, )+ ) => {
+ Longhands {
+ $(
+ $name: MaybeBoxed::maybe_boxed($value),
+ )+
+ }
+ }
+}
+
+/// A module with all the code for longhand properties.
+#[allow(missing_docs)]
+pub mod longhands {
+ % for style_struct in data.style_structs:
+ include!("${repr(os.path.join(OUT_DIR, 'longhands/{}.rs'.format(style_struct.name_lower)))[1:-1]}");
+ % endfor
+}
+
+macro_rules! unwrap_or_initial {
+ ($prop: ident) => (unwrap_or_initial!($prop, $prop));
+ ($prop: ident, $expr: expr) =>
+ ($expr.unwrap_or_else(|| $prop::get_initial_specified_value()));
+}
+
+/// A module with code for all the shorthand css properties, and a few
+/// serialization helpers.
+#[allow(missing_docs)]
+pub mod shorthands {
+ use cssparser::Parser;
+ use crate::parser::{Parse, ParserContext};
+ use style_traits::{ParseError, StyleParseErrorKind};
+ use crate::values::specified;
+
+ % for style_struct in data.style_structs:
+ include!("${repr(os.path.join(OUT_DIR, 'shorthands/{}.rs'.format(style_struct.name_lower)))[1:-1]}");
+ % endfor
+
+ // We didn't define the 'all' shorthand using the regular helpers:shorthand
+ // mechanism, since it causes some very large types to be generated.
+ //
+ // Also, make sure logical properties appear before its physical
+ // counter-parts, in order to prevent bugs like:
+ //
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1410028
+ //
+ // FIXME(emilio): Adopt the resolution from:
+ //
+ // https://github.com/w3c/csswg-drafts/issues/1898
+ //
+ // when there is one, whatever that is.
+ <%
+ logical_longhands = []
+ other_longhands = []
+
+ for p in data.longhands:
+ if p.name in ['direction', 'unicode-bidi']:
+ continue;
+ if not p.enabled_in_content() and not p.experimental(engine):
+ continue;
+ if "Style" not in p.rule_types_allowed_names():
+ continue;
+ if p.logical:
+ logical_longhands.append(p.name)
+ else:
+ other_longhands.append(p.name)
+
+ data.declare_shorthand(
+ "all",
+ logical_longhands + other_longhands,
+ engines="gecko servo-2013 servo-2020",
+ spec="https://drafts.csswg.org/css-cascade-3/#all-shorthand"
+ )
+ ALL_SHORTHAND_LEN = len(logical_longhands) + len(other_longhands);
+ %>
+}
+
+<%
+ from itertools import groupby
+
+ # After this code, `data.longhands` is sorted in the following order:
+ # - first all keyword variants and all variants known to be Copy,
+ # - second all the other variants, such as all variants with the same field
+ # have consecutive discriminants.
+ # The variable `variants` contain the same entries as `data.longhands` in
+ # the same order, but must exist separately to the data source, because
+ # we then need to add three additional variants `WideKeywordDeclaration`,
+ # `VariableDeclaration` and `CustomDeclaration`.
+
+ variants = []
+ for property in data.longhands:
+ variants.append({
+ "name": property.camel_case,
+ "type": property.specified_type(),
+ "doc": "`" + property.name + "`",
+ "copy": property.specified_is_copy(),
+ })
+
+ groups = {}
+ keyfunc = lambda x: x["type"]
+ sortkeys = {}
+ for ty, group in groupby(sorted(variants, key=keyfunc), keyfunc):
+ group = list(group)
+ groups[ty] = group
+ for v in group:
+ if len(group) == 1:
+ sortkeys[v["name"]] = (not v["copy"], 1, v["name"], "")
+ else:
+ sortkeys[v["name"]] = (not v["copy"], len(group), ty, v["name"])
+ variants.sort(key=lambda x: sortkeys[x["name"]])
+
+ # It is extremely important to sort the `data.longhands` array here so
+ # that it is in the same order as `variants`, for `LonghandId` and
+ # `PropertyDeclarationId` to coincide.
+ data.longhands.sort(key=lambda x: sortkeys[x.camel_case])
+%>
+
+// WARNING: It is *really* important for the variants of `LonghandId`
+// and `PropertyDeclaration` to be defined in the exact same order,
+// with the exception of `CSSWideKeyword`, `WithVariables` and `Custom`,
+// which don't exist in `LonghandId`.
+
+<%
+ extra_variants = [
+ {
+ "name": "CSSWideKeyword",
+ "type": "WideKeywordDeclaration",
+ "doc": "A CSS-wide keyword.",
+ "copy": False,
+ },
+ {
+ "name": "WithVariables",
+ "type": "VariableDeclaration",
+ "doc": "An unparsed declaration.",
+ "copy": False,
+ },
+ {
+ "name": "Custom",
+ "type": "CustomDeclaration",
+ "doc": "A custom property declaration.",
+ "copy": False,
+ },
+ ]
+ for v in extra_variants:
+ variants.append(v)
+ groups[v["type"]] = [v]
+%>
+
+/// Servo's representation for a property declaration.
+#[derive(ToShmem)]
+#[repr(u16)]
+pub enum PropertyDeclaration {
+ % for variant in variants:
+ /// ${variant["doc"]}
+ ${variant["name"]}(${variant["type"]}),
+ % endfor
+}
+
+// There's one of these for each parsed declaration so it better be small.
+size_of_test!(PropertyDeclaration, 32);
+
+#[repr(C)]
+struct PropertyDeclarationVariantRepr<T> {
+ tag: u16,
+ value: T
+}
+
+impl Clone for PropertyDeclaration {
+ #[inline]
+ fn clone(&self) -> Self {
+ use self::PropertyDeclaration::*;
+
+ <%
+ [copy, others] = [list(g) for _, g in groupby(variants, key=lambda x: not x["copy"])]
+ %>
+
+ let self_tag = unsafe {
+ (*(self as *const _ as *const PropertyDeclarationVariantRepr<()>)).tag
+ };
+ if self_tag <= LonghandId::${copy[-1]["name"]} as u16 {
+ #[derive(Clone, Copy)]
+ #[repr(u16)]
+ enum CopyVariants {
+ % for v in copy:
+ _${v["name"]}(${v["type"]}),
+ % endfor
+ }
+
+ unsafe {
+ let mut out = mem::MaybeUninit::uninit();
+ ptr::write(
+ out.as_mut_ptr() as *mut CopyVariants,
+ *(self as *const _ as *const CopyVariants),
+ );
+ return out.assume_init();
+ }
+ }
+
+ // This function ensures that all properties not handled above
+ // do not have a specified value implements Copy. If you hit
+ // compile error here, you may want to add the type name into
+ // Longhand.specified_is_copy in data.py.
+ fn _static_assert_others_are_not_copy() {
+ struct Helper<T>(T);
+ trait AssertCopy { fn assert() {} }
+ trait AssertNotCopy { fn assert() {} }
+ impl<T: Copy> AssertCopy for Helper<T> {}
+ % for ty in sorted(set(x["type"] for x in others)):
+ impl AssertNotCopy for Helper<${ty}> {}
+ Helper::<${ty}>::assert();
+ % endfor
+ }
+
+ match *self {
+ ${" |\n".join("{}(..)".format(v["name"]) for v in copy)} => {
+ unsafe { debug_unreachable!() }
+ }
+ % for ty, vs in groupby(others, key=lambda x: x["type"]):
+ <%
+ vs = list(vs)
+ %>
+ % if len(vs) == 1:
+ ${vs[0]["name"]}(ref value) => {
+ ${vs[0]["name"]}(value.clone())
+ }
+ % else:
+ ${" |\n".join("{}(ref value)".format(v["name"]) for v in vs)} => {
+ unsafe {
+ let mut out = mem::MaybeUninit::uninit();
+ ptr::write(
+ out.as_mut_ptr() as *mut PropertyDeclarationVariantRepr<${ty}>,
+ PropertyDeclarationVariantRepr {
+ tag: *(self as *const _ as *const u16),
+ value: value.clone(),
+ },
+ );
+ out.assume_init()
+ }
+ }
+ % endif
+ % endfor
+ }
+ }
+}
+
+impl PartialEq for PropertyDeclaration {
+ #[inline]
+ fn eq(&self, other: &Self) -> bool {
+ use self::PropertyDeclaration::*;
+
+ unsafe {
+ let this_repr =
+ &*(self as *const _ as *const PropertyDeclarationVariantRepr<()>);
+ let other_repr =
+ &*(other as *const _ as *const PropertyDeclarationVariantRepr<()>);
+ if this_repr.tag != other_repr.tag {
+ return false;
+ }
+ match *self {
+ % for ty, vs in groupby(variants, key=lambda x: x["type"]):
+ ${" |\n".join("{}(ref this)".format(v["name"]) for v in vs)} => {
+ let other_repr =
+ &*(other as *const _ as *const PropertyDeclarationVariantRepr<${ty}>);
+ *this == other_repr.value
+ }
+ % endfor
+ }
+ }
+ }
+}
+
+impl MallocSizeOf for PropertyDeclaration {
+ #[inline]
+ fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+ use self::PropertyDeclaration::*;
+
+ match *self {
+ % for ty, vs in groupby(variants, key=lambda x: x["type"]):
+ ${" | ".join("{}(ref value)".format(v["name"]) for v in vs)} => {
+ value.size_of(ops)
+ }
+ % endfor
+ }
+ }
+}
+
+
+impl PropertyDeclaration {
+ /// Returns the given value for this declaration as a particular type.
+ /// It's the caller's responsibility to guarantee that the longhand id has the right specified
+ /// value representation.
+ pub(crate) unsafe fn unchecked_value_as<T>(&self) -> &T {
+ &(*(self as *const _ as *const PropertyDeclarationVariantRepr<T>)).value
+ }
+
+ /// Dumps the property declaration before crashing.
+ #[cold]
+ #[cfg(debug_assertions)]
+ pub(crate) fn debug_crash(&self, reason: &str) {
+ panic!("{}: {:?}", reason, self);
+ }
+ #[cfg(not(debug_assertions))]
+ #[inline(always)]
+ pub(crate) fn debug_crash(&self, _reason: &str) {}
+
+ /// Returns whether this is a variant of the Longhand(Value) type, rather
+ /// than one of the special variants in extra_variants.
+ fn is_longhand_value(&self) -> bool {
+ match *self {
+ % for v in extra_variants:
+ PropertyDeclaration::${v["name"]}(..) => false,
+ % endfor
+ _ => true,
+ }
+ }
+
+ /// Like the method on ToCss, but without the type parameter to avoid
+ /// accidentally monomorphizing this large function multiple times for
+ /// different writers.
+ pub fn to_css(&self, dest: &mut CssStringWriter) -> fmt::Result {
+ use self::PropertyDeclaration::*;
+
+ let mut dest = CssWriter::new(dest);
+ match *self {
+ % for ty, vs in groupby(variants, key=lambda x: x["type"]):
+ ${" | ".join("{}(ref value)".format(v["name"]) for v in vs)} => {
+ value.to_css(&mut dest)
+ }
+ % endfor
+ }
+ }
+
+ /// Returns the color value of a given property, for high-contrast-mode tweaks.
+ pub(super) fn color_value(&self) -> Option<<&crate::values::specified::Color> {
+ ${static_longhand_id_set("COLOR_PROPERTIES", lambda p: p.predefined_type == "Color")}
+ <%
+ # sanity check
+ assert data.longhands_by_name["background-color"].predefined_type == "Color"
+
+ color_specified_type = data.longhands_by_name["background-color"].specified_type()
+ %>
+ let id = self.id().as_longhand()?;
+ if !COLOR_PROPERTIES.contains(id) || !self.is_longhand_value() {
+ return None;
+ }
+ let repr = self as *const _ as *const PropertyDeclarationVariantRepr<${color_specified_type}>;
+ Some(unsafe { &(*repr).value })
+ }
+}
+
+/// A module with all the code related to animated properties.
+///
+/// This needs to be "included" by mako at least after all longhand modules,
+/// given they populate the global data.
+pub mod animated_properties {
+ <%include file="/helpers/animated_properties.mako.rs" />
+}
+
+/// A module to group various interesting property counts.
+pub mod property_counts {
+ /// The number of (non-alias) longhand properties.
+ pub const LONGHANDS: usize = ${len(data.longhands)};
+ /// The number of (non-alias) shorthand properties.
+ pub const SHORTHANDS: usize = ${len(data.shorthands)};
+ /// The number of aliases.
+ pub const ALIASES: usize = ${len(data.all_aliases())};
+ /// The number of counted unknown properties.
+ pub const COUNTED_UNKNOWN: usize = ${len(data.counted_unknown_properties)};
+ /// The number of (non-alias) longhands and shorthands.
+ pub const LONGHANDS_AND_SHORTHANDS: usize = LONGHANDS + SHORTHANDS;
+ /// The number of non-custom properties.
+ pub const NON_CUSTOM: usize = LONGHANDS_AND_SHORTHANDS + ALIASES;
+ /// The number of prioritary properties that we have.
+ pub const PRIORITARY: usize = ${len(PRIORITARY_PROPERTIES)};
+ /// The max number of longhands that a shorthand other than "all" expands to.
+ pub const MAX_SHORTHAND_EXPANDED: usize =
+ ${max(len(s.sub_properties) for s in data.shorthands_except_all())};
+ /// The max amount of longhands that the `all` shorthand will ever contain.
+ pub const ALL_SHORTHAND_EXPANDED: usize = ${ALL_SHORTHAND_LEN};
+ /// The number of animatable properties.
+ pub const ANIMATABLE: usize = ${sum(1 for prop in data.longhands if prop.animatable)};
+}
+
+% if engine == "gecko":
+#[allow(dead_code)]
+unsafe fn static_assert_nscsspropertyid() {
+ % for i, property in enumerate(data.longhands + data.shorthands + data.all_aliases()):
+ std::mem::transmute::<[u8; ${i}], [u8; ${property.nscsspropertyid()} as usize]>([0; ${i}]); // ${property.name}
+ % endfor
+}
+% endif
+
+impl NonCustomPropertyId {
+ /// Get the property name.
+ #[inline]
+ pub fn name(self) -> &'static str {
+ static MAP: [&'static str; property_counts::NON_CUSTOM] = [
+ % for property in data.longhands + data.shorthands + data.all_aliases():
+ "${property.name}",
+ % endfor
+ ];
+ MAP[self.0 as usize]
+ }
+
+ /// Returns whether this property is animatable.
+ #[inline]
+ pub fn is_animatable(self) -> bool {
+ ${static_non_custom_property_id_set("ANIMATABLE", lambda p: p.animatable)}
+ ANIMATABLE.contains(self)
+ }
+
+ /// Whether this property is enabled for all content right now.
+ #[inline]
+ pub(super) fn enabled_for_all_content(self) -> bool {
+ ${static_non_custom_property_id_set(
+ "EXPERIMENTAL",
+ lambda p: p.experimental(engine)
+ )}
+
+ ${static_non_custom_property_id_set(
+ "ALWAYS_ENABLED",
+ lambda p: (not p.experimental(engine)) and p.enabled_in_content()
+ )}
+
+ let passes_pref_check = || {
+ % if engine == "gecko":
+ unsafe { structs::nsCSSProps_gPropertyEnabled[self.0 as usize] }
+ % else:
+ static PREF_NAME: [Option< &str>; ${
+ len(data.longhands) + len(data.shorthands) + len(data.all_aliases())
+ }] = [
+ % for property in data.longhands + data.shorthands + data.all_aliases():
+ <%
+ attrs = {"servo-2013": "servo_2013_pref", "servo-2020": "servo_2020_pref"}
+ pref = getattr(property, attrs[engine])
+ %>
+ % if pref:
+ Some("${pref}"),
+ % else:
+ None,
+ % endif
+ % endfor
+ ];
+ let pref = match PREF_NAME[self.0 as usize] {
+ None => return true,
+ Some(pref) => pref,
+ };
+
+ prefs::pref_map().get(pref).as_bool().unwrap_or(false)
+ % endif
+ };
+
+ if ALWAYS_ENABLED.contains(self) {
+ return true
+ }
+
+ if EXPERIMENTAL.contains(self) && passes_pref_check() {
+ return true
+ }
+
+ false
+ }
+
+ /// Returns whether a given rule allows a given property.
+ #[inline]
+ pub fn allowed_in_rule(self, rule_types: CssRuleTypes) -> bool {
+ debug_assert!(
+ rule_types.contains(CssRuleType::Keyframe) ||
+ rule_types.contains(CssRuleType::Page) ||
+ rule_types.contains(CssRuleType::Style),
+ "Declarations are only expected inside a keyframe, page, or style rule."
+ );
+
+ static MAP: [u32; property_counts::NON_CUSTOM] = [
+ % for property in data.longhands + data.shorthands + data.all_aliases():
+ % for name in RULE_VALUES:
+ % if property.rule_types_allowed & RULE_VALUES[name] != 0:
+ CssRuleType::${name}.bit() |
+ % endif
+ % endfor
+ 0,
+ % endfor
+ ];
+ MAP[self.0 as usize] & rule_types.bits() != 0
+ }
+
+ pub(super) fn allowed_in(self, context: &ParserContext) -> bool {
+ if !self.allowed_in_rule(context.rule_types()) {
+ return false;
+ }
+
+ self.allowed_in_ignoring_rule_type(context)
+ }
+
+
+ pub(super) fn allowed_in_ignoring_rule_type(self, context: &ParserContext) -> bool {
+ // The semantics of these are kinda hard to reason about, what follows
+ // is a description of the different combinations that can happen with
+ // these three sets.
+ //
+ // Experimental properties are generally controlled by prefs, but an
+ // experimental property explicitly enabled in certain context (UA or
+ // chrome sheets) is always usable in the context regardless of the
+ // pref value.
+ //
+ // Non-experimental properties are either normal properties which are
+ // usable everywhere, or internal-only properties which are only usable
+ // in certain context they are explicitly enabled in.
+ if self.enabled_for_all_content() {
+ return true;
+ }
+
+ ${static_non_custom_property_id_set(
+ "ENABLED_IN_UA_SHEETS",
+ lambda p: p.explicitly_enabled_in_ua_sheets()
+ )}
+ ${static_non_custom_property_id_set(
+ "ENABLED_IN_CHROME",
+ lambda p: p.explicitly_enabled_in_chrome()
+ )}
+
+ if context.stylesheet_origin == Origin::UserAgent &&
+ ENABLED_IN_UA_SHEETS.contains(self)
+ {
+ return true
+ }
+
+ if context.chrome_rules_enabled() && ENABLED_IN_CHROME.contains(self) {
+ return true
+ }
+
+ false
+ }
+
+ /// The supported types of this property. The return value should be
+ /// style_traits::CssType when it can become a bitflags type.
+ pub(super) fn supported_types(&self) -> u8 {
+ const SUPPORTED_TYPES: [u8; ${len(data.longhands) + len(data.shorthands)}] = [
+ % for prop in data.longhands:
+ <${prop.specified_type()} as SpecifiedValueInfo>::SUPPORTED_TYPES,
+ % endfor
+ % for prop in data.shorthands:
+ % if prop.name == "all":
+ 0, // 'all' accepts no value other than CSS-wide keywords
+ % else:
+ <shorthands::${prop.ident}::Longhands as SpecifiedValueInfo>::SUPPORTED_TYPES,
+ % endif
+ % endfor
+ ];
+ SUPPORTED_TYPES[self.0 as usize]
+ }
+
+ /// See PropertyId::collect_property_completion_keywords.
+ pub(super) fn collect_property_completion_keywords(&self, f: KeywordsCollectFn) {
+ fn do_nothing(_: KeywordsCollectFn) {}
+ const COLLECT_FUNCTIONS: [fn(KeywordsCollectFn);
+ ${len(data.longhands) + len(data.shorthands)}] = [
+ % for prop in data.longhands:
+ <${prop.specified_type()} as SpecifiedValueInfo>::collect_completion_keywords,
+ % endfor
+ % for prop in data.shorthands:
+ % if prop.name == "all":
+ do_nothing, // 'all' accepts no value other than CSS-wide keywords
+ % else:
+ <shorthands::${prop.ident}::Longhands as SpecifiedValueInfo>::
+ collect_completion_keywords,
+ % endif
+ % endfor
+ ];
+ COLLECT_FUNCTIONS[self.0 as usize](f);
+ }
+}
+
+<%def name="static_non_custom_property_id_set(name, is_member)">
+static ${name}: NonCustomPropertyIdSet = NonCustomPropertyIdSet {
+ <%
+ storage = [0] * int((len(data.longhands) + len(data.shorthands) + len(data.all_aliases()) - 1 + 32) / 32)
+ for i, property in enumerate(data.longhands + data.shorthands + data.all_aliases()):
+ if is_member(property):
+ storage[int(i / 32)] |= 1 << (i % 32)
+ %>
+ storage: [${", ".join("0x%x" % word for word in storage)}]
+};
+</%def>
+
+<%def name="static_longhand_id_set(name, is_member)">
+static ${name}: LonghandIdSet = LonghandIdSet {
+ <%
+ storage = [0] * int((len(data.longhands) - 1 + 32) / 32)
+ for i, property in enumerate(data.longhands):
+ if is_member(property):
+ storage[int(i / 32)] |= 1 << (i % 32)
+ %>
+ storage: [${", ".join("0x%x" % word for word in storage)}]
+};
+</%def>
+
+<%
+ logical_groups = defaultdict(list)
+ for prop in data.longhands:
+ if prop.logical_group:
+ logical_groups[prop.logical_group].append(prop)
+
+ for group, props in logical_groups.items():
+ logical_count = sum(1 for p in props if p.logical)
+ if logical_count * 2 != len(props):
+ raise RuntimeError("Logical group {} has ".format(group) +
+ "unbalanced logical / physical properties")
+
+ FIRST_LINE_RESTRICTIONS = PropertyRestrictions.first_line(data)
+ FIRST_LETTER_RESTRICTIONS = PropertyRestrictions.first_letter(data)
+ MARKER_RESTRICTIONS = PropertyRestrictions.marker(data)
+ PLACEHOLDER_RESTRICTIONS = PropertyRestrictions.placeholder(data)
+ CUE_RESTRICTIONS = PropertyRestrictions.cue(data)
+
+ def restriction_flags(property):
+ name = property.name
+ flags = []
+ if name in FIRST_LINE_RESTRICTIONS:
+ flags.append("APPLIES_TO_FIRST_LINE")
+ if name in FIRST_LETTER_RESTRICTIONS:
+ flags.append("APPLIES_TO_FIRST_LETTER")
+ if name in PLACEHOLDER_RESTRICTIONS:
+ flags.append("APPLIES_TO_PLACEHOLDER")
+ if name in MARKER_RESTRICTIONS:
+ flags.append("APPLIES_TO_MARKER")
+ if name in CUE_RESTRICTIONS:
+ flags.append("APPLIES_TO_CUE")
+ return flags
+
+%>
+
+/// A group for properties which may override each other via logical resolution.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[repr(u8)]
+pub enum LogicalGroupId {
+ % for i, group in enumerate(logical_groups.keys()):
+ /// ${group}
+ ${to_camel_case(group)} = ${i},
+ % endfor
+}
+
+impl LogicalGroupId {
+ /// Return the list of physical mapped properties for a given logical group.
+ fn physical_properties(self) -> &'static [LonghandId] {
+ static PROPS: [[LonghandId; 4]; ${len(logical_groups)}] = [
+ % for group, props in logical_groups.items():
+ [
+ <% physical_props = [p for p in props if p.logical][0].all_physical_mapped_properties(data) %>
+ % for phys in physical_props:
+ LonghandId::${phys.camel_case},
+ % endfor
+ % for i in range(len(physical_props), 4):
+ LonghandId::${physical_props[0].camel_case},
+ % endfor
+ ],
+ % endfor
+ ];
+ &PROPS[self as usize]
+ }
+}
+
+/// A set of logical groups.
+#[derive(Clone, Copy, Debug, Default, MallocSizeOf, PartialEq)]
+pub struct LogicalGroupSet {
+ storage: [u32; (${len(logical_groups)} - 1 + 32) / 32]
+}
+
+impl LogicalGroupSet {
+ /// Creates an empty `NonCustomPropertyIdSet`.
+ pub fn new() -> Self {
+ Self {
+ storage: Default::default(),
+ }
+ }
+
+ /// Return whether the given group is in the set
+ #[inline]
+ pub fn contains(&self, g: LogicalGroupId) -> bool {
+ let bit = g as usize;
+ (self.storage[bit / 32] & (1 << (bit % 32))) != 0
+ }
+
+ /// Insert a group the set.
+ #[inline]
+ pub fn insert(&mut self, g: LogicalGroupId) {
+ let bit = g as usize;
+ self.storage[bit / 32] |= 1 << (bit % 32);
+ }
+}
+
+
+#[repr(u8)]
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum PrioritaryPropertyId {
+ % for p in data.longhands:
+ % if p.is_prioritary():
+ ${p.camel_case},
+ % endif
+ % endfor
+}
+
+impl PrioritaryPropertyId {
+ #[inline]
+ pub fn to_longhand(self) -> LonghandId {
+ static PRIORITARY_TO_LONGHAND: [LonghandId; property_counts::PRIORITARY] = [
+ % for p in data.longhands:
+ % if p.is_prioritary():
+ LonghandId::${p.camel_case},
+ % endif
+ % endfor
+ ];
+ PRIORITARY_TO_LONGHAND[self as usize]
+ }
+ #[inline]
+ pub fn from_longhand(l: LonghandId) -> Option<Self> {
+ static LONGHAND_TO_PRIORITARY: [Option<PrioritaryPropertyId>; ${len(data.longhands)}] = [
+ % for p in data.longhands:
+ % if p.is_prioritary():
+ Some(PrioritaryPropertyId::${p.camel_case}),
+ % else:
+ None,
+ % endif
+ % endfor
+ ];
+ LONGHAND_TO_PRIORITARY[l as usize]
+ }
+}
+
+impl LonghandIdSet {
+ /// The set of non-inherited longhands.
+ #[inline]
+ pub(super) fn reset() -> &'static Self {
+ ${static_longhand_id_set("RESET", lambda p: not p.style_struct.inherited)}
+ &RESET
+ }
+
+ #[inline]
+ pub(super) fn discrete_animatable() -> &'static Self {
+ ${static_longhand_id_set("DISCRETE_ANIMATABLE", lambda p: p.animation_value_type == "discrete")}
+ &DISCRETE_ANIMATABLE
+ }
+
+ #[inline]
+ pub(super) fn logical() -> &'static Self {
+ ${static_longhand_id_set("LOGICAL", lambda p: p.logical)}
+ &LOGICAL
+ }
+
+ /// Returns the set of longhands that are ignored when document colors are
+ /// disabled.
+ #[inline]
+ pub(super) fn ignored_when_colors_disabled() -> &'static Self {
+ ${static_longhand_id_set(
+ "IGNORED_WHEN_COLORS_DISABLED",
+ lambda p: p.ignored_when_colors_disabled
+ )}
+ &IGNORED_WHEN_COLORS_DISABLED
+ }
+
+ /// Only a few properties are allowed to depend on the visited state of
+ /// links. When cascading visited styles, we can save time by only
+ /// processing these properties.
+ pub(super) fn visited_dependent() -> &'static Self {
+ ${static_longhand_id_set("VISITED_DEPENDENT", lambda p: p.is_visited_dependent())}
+ debug_assert!(Self::late_group().contains_all(&VISITED_DEPENDENT));
+ &VISITED_DEPENDENT
+ }
+
+ #[inline]
+ pub(super) fn prioritary_properties() -> &'static Self {
+ ${static_longhand_id_set("PRIORITARY_PROPERTIES", lambda p: p.is_prioritary())}
+ &PRIORITARY_PROPERTIES
+ }
+
+ #[inline]
+ pub(super) fn late_group_only_inherited() -> &'static Self {
+ ${static_longhand_id_set("LATE_GROUP_ONLY_INHERITED", lambda p: p.style_struct.inherited and not p.is_prioritary())}
+ &LATE_GROUP_ONLY_INHERITED
+ }
+
+ #[inline]
+ pub(super) fn late_group() -> &'static Self {
+ ${static_longhand_id_set("LATE_GROUP", lambda p: not p.is_prioritary())}
+ &LATE_GROUP
+ }
+
+ /// Returns the set of properties that are declared as having no effect on
+ /// Gecko <scrollbar> elements or their descendant scrollbar parts.
+ #[cfg(debug_assertions)]
+ #[cfg(feature = "gecko")]
+ #[inline]
+ pub fn has_no_effect_on_gecko_scrollbars() -> &'static Self {
+ // data.py asserts that has_no_effect_on_gecko_scrollbars is True or
+ // False for properties that are inherited and Gecko pref controlled,
+ // and is None for all other properties.
+ ${static_longhand_id_set(
+ "HAS_NO_EFFECT_ON_SCROLLBARS",
+ lambda p: p.has_effect_on_gecko_scrollbars is False
+ )}
+ &HAS_NO_EFFECT_ON_SCROLLBARS
+ }
+
+ /// Returns the set of border properties for the purpose of disabling native
+ /// appearance.
+ #[inline]
+ pub fn border_background_properties() -> &'static Self {
+ ${static_longhand_id_set(
+ "BORDER_BACKGROUND_PROPERTIES",
+ lambda p: (p.logical_group and p.logical_group.startswith("border")) or \
+ p.name in ["background-color", "background-image"]
+ )}
+ &BORDER_BACKGROUND_PROPERTIES
+ }
+}
+
+/// An identifier for a given longhand property.
+#[derive(Clone, Copy, Eq, Hash, MallocSizeOf, PartialEq, ToComputedValue, ToResolvedValue, ToShmem)]
+#[repr(u16)]
+pub enum LonghandId {
+ % for i, property in enumerate(data.longhands):
+ /// ${property.name}
+ ${property.camel_case} = ${i},
+ % endfor
+}
+
+enum LogicalMappingKind {
+ Side(LogicalSide),
+ Corner(LogicalCorner),
+ Axis(LogicalAxis),
+}
+
+struct LogicalMappingData {
+ group: LogicalGroupId,
+ kind: LogicalMappingKind,
+}
+
+impl LogicalMappingData {
+ fn to_physical(&self, wm: WritingMode) -> LonghandId {
+ let index = match self.kind {
+ LogicalMappingKind::Side(s) => s.to_physical(wm) as usize,
+ LogicalMappingKind::Corner(c) => c.to_physical(wm) as usize,
+ LogicalMappingKind::Axis(a) => a.to_physical(wm) as usize,
+ };
+ self.group.physical_properties()[index]
+ }
+}
+
+impl LonghandId {
+ /// Returns an iterator over all the shorthands that include this longhand.
+ pub fn shorthands(self) -> NonCustomPropertyIterator<ShorthandId> {
+ // first generate longhand to shorthands lookup map
+ //
+ // NOTE(emilio): This currently doesn't exclude the "all" shorthand. It
+ // could potentially do so, which would speed up serialization
+ // algorithms and what not, I guess.
+ <%
+ from functools import cmp_to_key
+ longhand_to_shorthand_map = {}
+ num_sub_properties = {}
+ for shorthand in data.shorthands:
+ num_sub_properties[shorthand.camel_case] = len(shorthand.sub_properties)
+ for sub_property in shorthand.sub_properties:
+ if sub_property.ident not in longhand_to_shorthand_map:
+ longhand_to_shorthand_map[sub_property.ident] = []
+
+ longhand_to_shorthand_map[sub_property.ident].append(shorthand.camel_case)
+
+ def cmp(a, b):
+ return (a > b) - (a < b)
+
+ def preferred_order(x, y):
+ # Since we want properties in order from most subproperties to least,
+ # reverse the arguments to cmp from the expected order.
+ result = cmp(num_sub_properties.get(y, 0), num_sub_properties.get(x, 0))
+ if result:
+ return result
+ # Fall back to lexicographic comparison.
+ return cmp(x, y)
+
+ # Sort the lists of shorthand properties according to preferred order:
+ # https://drafts.csswg.org/cssom/#concept-shorthands-preferred-order
+ for shorthand_list in longhand_to_shorthand_map.values():
+ shorthand_list.sort(key=cmp_to_key(preferred_order))
+ %>
+
+ // based on lookup results for each longhand, create result arrays
+ static MAP: [&'static [ShorthandId]; property_counts::LONGHANDS] = [
+ % for property in data.longhands:
+ &[
+ % for shorthand in longhand_to_shorthand_map.get(property.ident, []):
+ ShorthandId::${shorthand},
+ % endfor
+ ],
+ % endfor
+ ];
+
+ NonCustomPropertyIterator {
+ filter: NonCustomPropertyId::from(self).enabled_for_all_content(),
+ iter: MAP[self as usize].iter(),
+ }
+ }
+
+ pub(super) fn parse_value<'i, 't>(
+ self,
+ context: &ParserContext,
+ input: &mut Parser<'i, 't>,
+ ) -> Result<PropertyDeclaration, ParseError<'i>> {
+ type ParsePropertyFn = for<'i, 't> fn(
+ context: &ParserContext,
+ input: &mut Parser<'i, 't>,
+ ) -> Result<PropertyDeclaration, ParseError<'i>>;
+ static PARSE_PROPERTY: [ParsePropertyFn; ${len(data.longhands)}] = [
+ % for property in data.longhands:
+ longhands::${property.ident}::parse_declared,
+ % endfor
+ ];
+ (PARSE_PROPERTY[self as usize])(context, input)
+ }
+
+ /// Return the relevant data to map a particular logical property into physical.
+ fn logical_mapping_data(self) -> Option<<&'static LogicalMappingData> {
+ const LOGICAL_MAPPING_DATA: [Option<LogicalMappingData>; ${len(data.longhands)}] = [
+ % for prop in data.longhands:
+ % if prop.logical:
+ Some(LogicalMappingData {
+ group: LogicalGroupId::${to_camel_case(prop.logical_group)},
+ kind: ${prop.logical_mapping_kind(data)}
+ }),
+ % else:
+ None,
+ % endif
+ % endfor
+ ];
+ LOGICAL_MAPPING_DATA[self as usize].as_ref()
+ }
+
+ /// If this is a logical property, return the corresponding physical one in the given
+ /// writing mode. Otherwise, return unchanged.
+ #[inline]
+ pub fn to_physical(self, wm: WritingMode) -> Self {
+ let Some(data) = self.logical_mapping_data() else { return self };
+ data.to_physical(wm)
+ }
+
+ /// Return the logical group of this longhand property.
+ pub fn logical_group(self) -> Option<LogicalGroupId> {
+ const LOGICAL_GROUP_IDS: [Option<LogicalGroupId>; ${len(data.longhands)}] = [
+ % for prop in data.longhands:
+ % if prop.logical_group:
+ Some(LogicalGroupId::${to_camel_case(prop.logical_group)}),
+ % else:
+ None,
+ % endif
+ % endfor
+ ];
+ LOGICAL_GROUP_IDS[self as usize]
+ }
+
+ /// Returns PropertyFlags for given longhand property.
+ #[inline(always)]
+ pub fn flags(self) -> PropertyFlags {
+ // TODO(emilio): This can be simplified further as Rust gains more
+ // constant expression support.
+ const FLAGS: [u16; ${len(data.longhands)}] = [
+ % for property in data.longhands:
+ % for flag in property.flags + restriction_flags(property):
+ PropertyFlags::${flag}.bits() |
+ % endfor
+ 0,
+ % endfor
+ ];
+ PropertyFlags::from_bits_retain(FLAGS[self as usize])
+ }
+}
+
+/// An identifier for a given shorthand property.
+#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq, ToComputedValue, ToResolvedValue, ToShmem)]
+#[repr(u16)]
+pub enum ShorthandId {
+ % for i, property in enumerate(data.shorthands):
+ /// ${property.name}
+ ${property.camel_case} = ${i},
+ % endfor
+}
+
+impl ShorthandId {
+ /// Get the longhand ids that form this shorthand.
+ pub fn longhands(self) -> NonCustomPropertyIterator<LonghandId> {
+ static MAP: [&'static [LonghandId]; property_counts::SHORTHANDS] = [
+ % for property in data.shorthands:
+ &[
+ % for sub in property.sub_properties:
+ LonghandId::${sub.camel_case},
+ % endfor
+ ],
+ % endfor
+ ];
+ NonCustomPropertyIterator {
+ filter: NonCustomPropertyId::from(self).enabled_for_all_content(),
+ iter: MAP[self as usize].iter(),
+ }
+ }
+
+ /// Try to serialize the given declarations as this shorthand.
+ ///
+ /// Returns an error if writing to the stream fails, or if the declarations
+ /// do not map to a shorthand.
+ pub fn longhands_to_css(
+ self,
+ declarations: &[&PropertyDeclaration],
+ dest: &mut CssStringWriter,
+ ) -> fmt::Result {
+ type LonghandsToCssFn = for<'a, 'b> fn(&'a [&'b PropertyDeclaration], &mut CssStringWriter) -> fmt::Result;
+ fn all_to_css(_: &[&PropertyDeclaration], _: &mut CssStringWriter) -> fmt::Result {
+ // No need to try to serialize the declarations as the 'all'
+ // shorthand, since it only accepts CSS-wide keywords (and variable
+ // references), which will be handled in
+ // get_shorthand_appendable_value.
+ Ok(())
+ }
+
+ static LONGHANDS_TO_CSS: [LonghandsToCssFn; ${len(data.shorthands)}] = [
+ % for shorthand in data.shorthands:
+ % if shorthand.ident == "all":
+ all_to_css,
+ % else:
+ shorthands::${shorthand.ident}::to_css,
+ % endif
+ % endfor
+ ];
+
+ LONGHANDS_TO_CSS[self as usize](declarations, dest)
+ }
+
+ /// Returns PropertyFlags for the given shorthand property.
+ #[inline]
+ pub fn flags(self) -> PropertyFlags {
+ const FLAGS: [u16; ${len(data.shorthands)}] = [
+ % for property in data.shorthands:
+ % for flag in property.flags:
+ PropertyFlags::${flag}.bits() |
+ % endfor
+ 0,
+ % endfor
+ ];
+ PropertyFlags::from_bits_retain(FLAGS[self as usize])
+ }
+
+ /// Returns the order in which this property appears relative to other
+ /// shorthands in idl-name-sorting order.
+ #[inline]
+ pub fn idl_name_sort_order(self) -> u32 {
+ <%
+ from data import to_idl_name
+ ordered = {}
+ sorted_shorthands = sorted(data.shorthands, key=lambda p: to_idl_name(p.ident))
+ for order, shorthand in enumerate(sorted_shorthands):
+ ordered[shorthand.ident] = order
+ %>
+ static IDL_NAME_SORT_ORDER: [u32; ${len(data.shorthands)}] = [
+ % for property in data.shorthands:
+ ${ordered[property.ident]},
+ % endfor
+ ];
+ IDL_NAME_SORT_ORDER[self as usize]
+ }
+
+ pub(super) fn parse_into<'i, 't>(
+ self,
+ declarations: &mut SourcePropertyDeclaration,
+ context: &ParserContext,
+ input: &mut Parser<'i, 't>,
+ ) -> Result<(), ParseError<'i>> {
+ type ParseIntoFn = for<'i, 't> fn(
+ declarations: &mut SourcePropertyDeclaration,
+ context: &ParserContext,
+ input: &mut Parser<'i, 't>,
+ ) -> Result<(), ParseError<'i>>;
+
+ fn parse_all<'i, 't>(
+ _: &mut SourcePropertyDeclaration,
+ _: &ParserContext,
+ input: &mut Parser<'i, 't>
+ ) -> Result<(), ParseError<'i>> {
+ // 'all' accepts no value other than CSS-wide keywords
+ Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
+ }
+
+ static PARSE_INTO: [ParseIntoFn; ${len(data.shorthands)}] = [
+ % for shorthand in data.shorthands:
+ % if shorthand.ident == "all":
+ parse_all,
+ % else:
+ shorthands::${shorthand.ident}::parse_into,
+ % endif
+ % endfor
+ ];
+
+ (PARSE_INTO[self as usize])(declarations, context, input)
+ }
+}
+
+/// The counted unknown property list which is used for css use counters.
+///
+/// FIXME: This should be just #[repr(u8)], but can't be because of ABI issues,
+/// see https://bugs.llvm.org/show_bug.cgi?id=44228.
+#[derive(Clone, Copy, Debug, Eq, FromPrimitive, Hash, PartialEq)]
+#[repr(u32)]
+pub enum CountedUnknownProperty {
+ % for prop in data.counted_unknown_properties:
+ /// ${prop.name}
+ ${prop.camel_case},
+ % endfor
+}
+
+impl CountedUnknownProperty {
+ /// Parse the counted unknown property, for testing purposes only.
+ pub fn parse_for_testing(property_name: &str) -> Option<Self> {
+ ascii_case_insensitive_phf_map! {
+ unknown_ids -> CountedUnknownProperty = {
+ % for property in data.counted_unknown_properties:
+ "${property.name}" => CountedUnknownProperty::${property.camel_case},
+ % endfor
+ }
+ }
+ unknown_ids::get(property_name).cloned()
+ }
+
+ /// Returns the underlying index, used for use counter.
+ #[inline]
+ pub fn bit(self) -> usize {
+ self as usize
+ }
+}
+
+impl PropertyId {
+ /// Returns a given property from the given name, _regardless of whether it
+ /// is enabled or not_, or Err(()) for unknown properties.
+ pub(super) fn parse_unchecked(
+ property_name: &str,
+ use_counters: Option< &UseCounters>,
+ ) -> Result<Self, ()> {
+ // A special id for css use counters. ShorthandAlias is not used in the Servo build.
+ // That's why we need to allow dead_code.
+ pub enum StaticId {
+ NonCustom(NonCustomPropertyId),
+ CountedUnknown(CountedUnknownProperty),
+ }
+ ascii_case_insensitive_phf_map! {
+ static_ids -> StaticId = {
+ % for i, property in enumerate(data.longhands + data.shorthands + data.all_aliases()):
+ "${property.name}" => StaticId::NonCustom(NonCustomPropertyId(${i})),
+ % endfor
+ % for property in data.counted_unknown_properties:
+ "${property.name}" => {
+ StaticId::CountedUnknown(CountedUnknownProperty::${property.camel_case})
+ },
+ % endfor
+ }
+ }
+
+ if let Some(id) = static_ids::get(property_name) {
+ return Ok(match *id {
+ StaticId::NonCustom(id) => PropertyId::NonCustom(id),
+ StaticId::CountedUnknown(unknown_prop) => {
+ if let Some(counters) = use_counters {
+ counters.counted_unknown_properties.record(unknown_prop);
+ }
+ // Always return Err(()) because these aren't valid custom property names.
+ return Err(());
+ }
+ });
+ }
+
+ let name = crate::custom_properties::parse_name(property_name)?;
+ Ok(PropertyId::Custom(crate::custom_properties::Name::from(name)))
+ }
+}
+
+impl PropertyDeclaration {
+ /// Given a property declaration, return the property declaration id.
+ #[inline]
+ pub fn id(&self) -> PropertyDeclarationId {
+ match *self {
+ PropertyDeclaration::Custom(ref declaration) => {
+ return PropertyDeclarationId::Custom(&declaration.name)
+ }
+ PropertyDeclaration::CSSWideKeyword(ref declaration) => {
+ return PropertyDeclarationId::Longhand(declaration.id);
+ }
+ PropertyDeclaration::WithVariables(ref declaration) => {
+ return PropertyDeclarationId::Longhand(declaration.id);
+ }
+ _ => {}
+ }
+ // This is just fine because PropertyDeclaration and LonghandId
+ // have corresponding discriminants.
+ let id = unsafe { *(self as *const _ as *const LonghandId) };
+ debug_assert_eq!(id, match *self {
+ % for property in data.longhands:
+ PropertyDeclaration::${property.camel_case}(..) => LonghandId::${property.camel_case},
+ % endfor
+ _ => id,
+ });
+ PropertyDeclarationId::Longhand(id)
+ }
+
+ /// Given a declaration, convert it into a declaration for a corresponding
+ /// physical property.
+ #[inline]
+ pub fn to_physical(&self, wm: WritingMode) -> Self {
+ match *self {
+ PropertyDeclaration::WithVariables(VariableDeclaration {
+ id,
+ ref value,
+ }) => {
+ return PropertyDeclaration::WithVariables(VariableDeclaration {
+ id: id.to_physical(wm),
+ value: value.clone(),
+ })
+ }
+ PropertyDeclaration::CSSWideKeyword(WideKeywordDeclaration {
+ id,
+ keyword,
+ }) => {
+ return PropertyDeclaration::CSSWideKeyword(WideKeywordDeclaration {
+ id: id.to_physical(wm),
+ keyword,
+ })
+ }
+ PropertyDeclaration::Custom(..) => return self.clone(),
+ % for prop in data.longhands:
+ PropertyDeclaration::${prop.camel_case}(..) => {},
+ % endfor
+ }
+
+ let mut ret = self.clone();
+
+ % for prop in data.longhands:
+ % for physical_property in prop.all_physical_mapped_properties(data):
+ % if physical_property.specified_type() != prop.specified_type():
+ <% raise "Logical property %s should share specified value with physical property %s" % \
+ (prop.name, physical_property.name) %>
+ % endif
+ % endfor
+ % endfor
+
+ unsafe {
+ let longhand_id = *(&mut ret as *mut _ as *mut LonghandId);
+
+ debug_assert_eq!(
+ PropertyDeclarationId::Longhand(longhand_id),
+ ret.id()
+ );
+
+ // This is just fine because PropertyDeclaration and LonghandId
+ // have corresponding discriminants.
+ *(&mut ret as *mut _ as *mut LonghandId) = longhand_id.to_physical(wm);
+
+ debug_assert_eq!(
+ PropertyDeclarationId::Longhand(longhand_id.to_physical(wm)),
+ ret.id()
+ );
+ }
+
+ ret
+ }
+
+ /// Returns whether or not the property is set by a system font
+ pub fn get_system(&self) -> Option<SystemFont> {
+ match *self {
+ % if engine == "gecko":
+ % for prop in SYSTEM_FONT_LONGHANDS:
+ PropertyDeclaration::${to_camel_case(prop)}(ref prop) => {
+ prop.get_system()
+ }
+ % endfor
+ % endif
+ _ => None,
+ }
+ }
+}
+
+#[cfg(feature = "gecko")]
+pub use super::gecko::style_structs;
+
+/// The module where all the style structs are defined.
+#[cfg(feature = "servo")]
+pub mod style_structs {
+ use fxhash::FxHasher;
+ use super::longhands;
+ use std::hash::{Hash, Hasher};
+ use crate::logical_geometry::WritingMode;
+ use crate::media_queries::Device;
+ use crate::values::computed::NonNegativeLength;
+
+ % for style_struct in data.active_style_structs():
+ % if style_struct.name == "Font":
+ #[derive(Clone, Debug, MallocSizeOf)]
+ #[cfg_attr(feature = "servo", derive(Serialize, Deserialize))]
+ % else:
+ #[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+ % endif
+ /// The ${style_struct.name} style struct.
+ pub struct ${style_struct.name} {
+ % for longhand in style_struct.longhands:
+ % if not longhand.logical:
+ /// The ${longhand.name} computed value.
+ pub ${longhand.ident}: longhands::${longhand.ident}::computed_value::T,
+ % endif
+ % endfor
+ % if style_struct.name == "InheritedText":
+ /// The "used" text-decorations that apply to this box.
+ ///
+ /// FIXME(emilio): This is technically a box-tree concept, and
+ /// would be nice to move away from style.
+ pub text_decorations_in_effect: crate::values::computed::text::TextDecorationsInEffect,
+ % endif
+ % if style_struct.name == "Font":
+ /// The font hash, used for font caching.
+ pub hash: u64,
+ % endif
+ % if style_struct.name == "Box":
+ /// The display value specified by the CSS stylesheets (without any style adjustments),
+ /// which is needed for hypothetical layout boxes.
+ pub original_display: longhands::display::computed_value::T,
+ % endif
+ }
+ % if style_struct.name == "Font":
+ impl PartialEq for Font {
+ fn eq(&self, other: &Font) -> bool {
+ self.hash == other.hash
+ % for longhand in style_struct.longhands:
+ && self.${longhand.ident} == other.${longhand.ident}
+ % endfor
+ }
+ }
+ % endif
+
+ impl ${style_struct.name} {
+ % for longhand in style_struct.longhands:
+ % if not longhand.logical:
+ % if longhand.ident == "display":
+ /// Set `display`.
+ ///
+ /// We need to keep track of the original display for hypothetical boxes,
+ /// so we need to special-case this.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn set_display(&mut self, v: longhands::display::computed_value::T) {
+ self.display = v;
+ self.original_display = v;
+ }
+ % else:
+ /// Set ${longhand.name}.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn set_${longhand.ident}(&mut self, v: longhands::${longhand.ident}::computed_value::T) {
+ self.${longhand.ident} = v;
+ }
+ % endif
+ % if longhand.ident == "display":
+ /// Set `display` from other struct.
+ ///
+ /// Same as `set_display` above.
+ /// Thus, we need to special-case this.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn copy_display_from(&mut self, other: &Self) {
+ self.display = other.display.clone();
+ self.original_display = other.display.clone();
+ }
+ % else:
+ /// Set ${longhand.name} from other struct.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn copy_${longhand.ident}_from(&mut self, other: &Self) {
+ self.${longhand.ident} = other.${longhand.ident}.clone();
+ }
+ % endif
+ /// Reset ${longhand.name} from the initial struct.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn reset_${longhand.ident}(&mut self, other: &Self) {
+ self.copy_${longhand.ident}_from(other)
+ }
+
+ /// Get the computed value for ${longhand.name}.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn clone_${longhand.ident}(&self) -> longhands::${longhand.ident}::computed_value::T {
+ self.${longhand.ident}.clone()
+ }
+ % endif
+ % if longhand.need_index:
+ /// If this longhand is indexed, get the number of elements.
+ #[allow(non_snake_case)]
+ pub fn ${longhand.ident}_count(&self) -> usize {
+ self.${longhand.ident}.0.len()
+ }
+
+ /// If this longhand is indexed, get the element at given
+ /// index.
+ #[allow(non_snake_case)]
+ pub fn ${longhand.ident}_at(&self, index: usize)
+ -> longhands::${longhand.ident}::computed_value::SingleComputedValue {
+ self.${longhand.ident}.0[index].clone()
+ }
+ % endif
+ % endfor
+ % if style_struct.name == "Border":
+ % for side in ["top", "right", "bottom", "left"]:
+ /// Whether the border-${side} property has nonzero width.
+ #[allow(non_snake_case)]
+ pub fn border_${side}_has_nonzero_width(&self) -> bool {
+ use crate::Zero;
+ !self.border_${side}_width.is_zero()
+ }
+ % endfor
+ % elif style_struct.name == "Font":
+ /// Computes a font hash in order to be able to cache fonts
+ /// effectively in GFX and layout.
+ pub fn compute_font_hash(&mut self) {
+ // Corresponds to the fields in
+ // `gfx::font_template::FontTemplateDescriptor`.
+ let mut hasher: FxHasher = Default::default();
+ self.font_weight.hash(&mut hasher);
+ self.font_stretch.hash(&mut hasher);
+ self.font_style.hash(&mut hasher);
+ self.font_family.hash(&mut hasher);
+ self.hash = hasher.finish()
+ }
+
+ /// (Servo does not handle MathML, so this just calls copy_font_size_from)
+ pub fn inherit_font_size_from(&mut self, parent: &Self,
+ _: Option<NonNegativeLength>,
+ _: &Device) {
+ self.copy_font_size_from(parent);
+ }
+ /// (Servo does not handle MathML, so this just calls set_font_size)
+ pub fn apply_font_size(&mut self,
+ v: longhands::font_size::computed_value::T,
+ _: &Self,
+ _: &Device) -> Option<NonNegativeLength> {
+ self.set_font_size(v);
+ None
+ }
+ /// (Servo does not handle MathML, so this does nothing)
+ pub fn apply_unconstrained_font_size(&mut self, _: NonNegativeLength) {
+ }
+
+ % elif style_struct.name == "Outline":
+ /// Whether the outline-width property is non-zero.
+ #[inline]
+ pub fn outline_has_nonzero_width(&self) -> bool {
+ use crate::Zero;
+ !self.outline_width.is_zero()
+ }
+ % elif style_struct.name == "Box":
+ /// Sets the display property, but without touching original_display,
+ /// except when the adjustment comes from root or item display fixups.
+ pub fn set_adjusted_display(
+ &mut self,
+ dpy: longhands::display::computed_value::T,
+ is_item_or_root: bool
+ ) {
+ self.display = dpy;
+ if is_item_or_root {
+ self.original_display = dpy;
+ }
+ }
+ % endif
+ }
+
+ % endfor
+}
+
+% for style_struct in data.active_style_structs():
+ impl style_structs::${style_struct.name} {
+ % for longhand in style_struct.longhands:
+ % if longhand.need_index:
+ /// Iterate over the values of ${longhand.name}.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn ${longhand.ident}_iter(&self) -> ${longhand.camel_case}Iter {
+ ${longhand.camel_case}Iter {
+ style_struct: self,
+ current: 0,
+ max: self.${longhand.ident}_count(),
+ }
+ }
+
+ /// Get a value mod `index` for the property ${longhand.name}.
+ #[allow(non_snake_case)]
+ #[inline]
+ pub fn ${longhand.ident}_mod(&self, index: usize)
+ -> longhands::${longhand.ident}::computed_value::SingleComputedValue {
+ self.${longhand.ident}_at(index % self.${longhand.ident}_count())
+ }
+
+ /// Clone the computed value for the property.
+ #[allow(non_snake_case)]
+ #[inline]
+ #[cfg(feature = "gecko")]
+ pub fn clone_${longhand.ident}(
+ &self,
+ ) -> longhands::${longhand.ident}::computed_value::T {
+ longhands::${longhand.ident}::computed_value::List(
+ self.${longhand.ident}_iter().collect()
+ )
+ }
+ % endif
+ % endfor
+
+ % if style_struct.name == "UI":
+ /// Returns whether there is any animation specified with
+ /// animation-name other than `none`.
+ pub fn specifies_animations(&self) -> bool {
+ self.animation_name_iter().any(|name| !name.is_none())
+ }
+
+ /// Returns whether there are any transitions specified.
+ #[cfg(feature = "servo")]
+ pub fn specifies_transitions(&self) -> bool {
+ (0..self.transition_property_count()).any(|index| {
+ let combined_duration =
+ self.transition_duration_mod(index).seconds().max(0.) +
+ self.transition_delay_mod(index).seconds();
+ combined_duration > 0.
+ })
+ }
+
+ /// Returns whether there is any named progress timeline specified with
+ /// scroll-timeline-name other than `none`.
+ pub fn specifies_scroll_timelines(&self) -> bool {
+ self.scroll_timeline_name_iter().any(|name| !name.is_none())
+ }
+
+ /// Returns whether there is any named progress timeline specified with
+ /// view-timeline-name other than `none`.
+ pub fn specifies_view_timelines(&self) -> bool {
+ self.view_timeline_name_iter().any(|name| !name.is_none())
+ }
+
+ /// Returns true if animation properties are equal between styles, but without
+ /// considering keyframe data and animation-timeline.
+ #[cfg(feature = "servo")]
+ pub fn animations_equals(&self, other: &Self) -> bool {
+ self.animation_name_iter().eq(other.animation_name_iter()) &&
+ self.animation_delay_iter().eq(other.animation_delay_iter()) &&
+ self.animation_direction_iter().eq(other.animation_direction_iter()) &&
+ self.animation_duration_iter().eq(other.animation_duration_iter()) &&
+ self.animation_fill_mode_iter().eq(other.animation_fill_mode_iter()) &&
+ self.animation_iteration_count_iter().eq(other.animation_iteration_count_iter()) &&
+ self.animation_play_state_iter().eq(other.animation_play_state_iter()) &&
+ self.animation_timing_function_iter().eq(other.animation_timing_function_iter())
+ }
+
+ % elif style_struct.name == "Column":
+ /// Whether this is a multicol style.
+ #[cfg(feature = "servo")]
+ pub fn is_multicol(&self) -> bool {
+ !self.column_width.is_auto() || !self.column_count.is_auto()
+ }
+ % endif
+ }
+
+ % for longhand in style_struct.longhands:
+ % if longhand.need_index:
+ /// An iterator over the values of the ${longhand.name} properties.
+ pub struct ${longhand.camel_case}Iter<'a> {
+ style_struct: &'a style_structs::${style_struct.name},
+ current: usize,
+ max: usize,
+ }
+
+ impl<'a> Iterator for ${longhand.camel_case}Iter<'a> {
+ type Item = longhands::${longhand.ident}::computed_value::SingleComputedValue;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.current += 1;
+ if self.current <= self.max {
+ Some(self.style_struct.${longhand.ident}_at(self.current - 1))
+ } else {
+ None
+ }
+ }
+ }
+ % endif
+ % endfor
+% endfor
+
+
+#[cfg(feature = "gecko")]
+pub use super::gecko::{ComputedValues, ComputedValuesInner};
+
+#[cfg(feature = "servo")]
+#[cfg_attr(feature = "servo", derive(Clone, Debug))]
+/// Actual data of ComputedValues, to match up with Gecko
+pub struct ComputedValuesInner {
+ % for style_struct in data.active_style_structs():
+ ${style_struct.ident}: Arc<style_structs::${style_struct.name}>,
+ % endfor
+ custom_properties: crate::custom_properties::ComputedCustomProperties,
+
+ /// The writing mode of this computed values struct.
+ pub writing_mode: WritingMode,
+
+ /// The effective zoom value.
+ pub effective_zoom: Zoom,
+
+ /// A set of flags we use to store misc information regarding this style.
+ pub flags: ComputedValueFlags,
+
+ /// The rule node representing the ordered list of rules matched for this
+ /// node. Can be None for default values and text nodes. This is
+ /// essentially an optimization to avoid referencing the root rule node.
+ pub rules: Option<StrongRuleNode>,
+
+ /// The element's computed values if visited, only computed if there's a
+ /// relevant link for this element. A element's "relevant link" is the
+ /// element being matched if it is a link or the nearest ancestor link.
+ visited_style: Option<Arc<ComputedValues>>,
+}
+
+/// The struct that Servo uses to represent computed values.
+///
+/// This struct contains an immutable atomically-reference-counted pointer to
+/// every kind of style struct.
+///
+/// When needed, the structs may be copied in order to get mutated.
+#[cfg(feature = "servo")]
+#[cfg_attr(feature = "servo", derive(Clone, Debug))]
+pub struct ComputedValues {
+ /// The actual computed values
+ ///
+ /// In Gecko the outer ComputedValues is actually a ComputedStyle, whereas
+ /// ComputedValuesInner is the core set of computed values.
+ ///
+ /// We maintain this distinction in servo to reduce the amount of special
+ /// casing.
+ inner: ComputedValuesInner,
+
+ /// The pseudo-element that we're using.
+ pseudo: Option<PseudoElement>,
+}
+
+impl ComputedValues {
+ /// Returns the pseudo-element that this style represents.
+ #[cfg(feature = "servo")]
+ pub fn pseudo(&self) -> Option<<&PseudoElement> {
+ self.pseudo.as_ref()
+ }
+
+ /// Returns true if this is the style for a pseudo-element.
+ #[cfg(feature = "servo")]
+ pub fn is_pseudo_style(&self) -> bool {
+ self.pseudo().is_some()
+ }
+
+ /// Returns whether this style's display value is equal to contents.
+ pub fn is_display_contents(&self) -> bool {
+ self.clone_display().is_contents()
+ }
+
+ /// Gets a reference to the rule node. Panic if no rule node exists.
+ pub fn rules(&self) -> &StrongRuleNode {
+ self.rules.as_ref().unwrap()
+ }
+
+ /// Returns the visited rules, if applicable.
+ pub fn visited_rules(&self) -> Option<<&StrongRuleNode> {
+ self.visited_style().and_then(|s| s.rules.as_ref())
+ }
+
+ /// Gets a reference to the custom properties map (if one exists).
+ pub fn custom_properties(&self) -> &crate::custom_properties::ComputedCustomProperties {
+ &self.custom_properties
+ }
+
+ /// Returns whether we have the same custom properties as another style.
+ pub fn custom_properties_equal(&self, other: &Self) -> bool {
+ self.custom_properties() == other.custom_properties()
+ }
+
+% for prop in data.longhands:
+% if not prop.logical:
+ /// Gets the computed value of a given property.
+ #[inline(always)]
+ #[allow(non_snake_case)]
+ pub fn clone_${prop.ident}(
+ &self,
+ ) -> longhands::${prop.ident}::computed_value::T {
+ self.get_${prop.style_struct.ident.strip("_")}().clone_${prop.ident}()
+ }
+% endif
+% endfor
+
+ /// Writes the (resolved or computed) value of the given longhand as a string in `dest`.
+ ///
+ /// TODO(emilio): We should move all the special resolution from
+ /// nsComputedDOMStyle to ToResolvedValue instead.
+ pub fn computed_or_resolved_value(
+ &self,
+ property_id: LonghandId,
+ context: Option<<&resolved::Context>,
+ dest: &mut CssStringWriter,
+ ) -> fmt::Result {
+ use crate::values::resolved::ToResolvedValue;
+ let mut dest = CssWriter::new(dest);
+ let property_id = property_id.to_physical(self.writing_mode);
+ match property_id {
+ % for specified_type, props in groupby(data.longhands, key=lambda x: x.specified_type()):
+ <% props = list(props) %>
+ ${" |\n".join("LonghandId::{}".format(p.camel_case) for p in props)} => {
+ let value = match property_id {
+ % for prop in props:
+ % if not prop.logical:
+ LonghandId::${prop.camel_case} => self.clone_${prop.ident}(),
+ % endif
+ % endfor
+ _ => unsafe { debug_unreachable!() },
+ };
+ if let Some(c) = context {
+ value.to_resolved_value(c).to_css(&mut dest)
+ } else {
+ value.to_css(&mut dest)
+ }
+ }
+ % endfor
+ }
+ }
+
+ /// Returns the given longhand's resolved value as a property declaration.
+ pub fn computed_or_resolved_declaration(
+ &self,
+ property_id: LonghandId,
+ context: Option<<&resolved::Context>,
+ ) -> PropertyDeclaration {
+ use crate::values::resolved::ToResolvedValue;
+ use crate::values::computed::ToComputedValue;
+ let physical_property_id = property_id.to_physical(self.writing_mode);
+ match physical_property_id {
+ % for specified_type, props in groupby(data.longhands, key=lambda x: x.specified_type()):
+ <% props = list(props) %>
+ ${" |\n".join("LonghandId::{}".format(p.camel_case) for p in props)} => {
+ let mut computed_value = match physical_property_id {
+ % for prop in props:
+ % if not prop.logical:
+ LonghandId::${prop.camel_case} => self.clone_${prop.ident}(),
+ % endif
+ % endfor
+ _ => unsafe { debug_unreachable!() },
+ };
+ if let Some(c) = context {
+ let resolved = computed_value.to_resolved_value(c);
+ computed_value = ToResolvedValue::from_resolved_value(resolved);
+ }
+ let specified = ToComputedValue::from_computed_value(&computed_value);
+ % if props[0].boxed:
+ let specified = Box::new(specified);
+ % endif
+ % if len(props) == 1:
+ PropertyDeclaration::${props[0].camel_case}(specified)
+ % else:
+ unsafe {
+ let mut out = mem::MaybeUninit::uninit();
+ ptr::write(
+ out.as_mut_ptr() as *mut PropertyDeclarationVariantRepr<${specified_type}>,
+ PropertyDeclarationVariantRepr {
+ tag: property_id as u16,
+ value: specified,
+ },
+ );
+ out.assume_init()
+ }
+ % endif
+ }
+ % endfor
+ }
+ }
+
+ /// Resolves the currentColor keyword.
+ ///
+ /// Any color value from computed values (except for the 'color' property
+ /// itself) should go through this method.
+ ///
+ /// Usage example:
+ /// let top_color =
+ /// style.resolve_color(style.get_border().clone_border_top_color());
+ #[inline]
+ pub fn resolve_color(&self, color: computed::Color) -> crate::color::AbsoluteColor {
+ let current_color = self.get_inherited_text().clone_color();
+ color.resolve_to_absolute(&current_color)
+ }
+
+ /// Returns which longhand properties have different values in the two
+ /// ComputedValues.
+ #[cfg(feature = "gecko_debug")]
+ pub fn differing_properties(&self, other: &ComputedValues) -> LonghandIdSet {
+ let mut set = LonghandIdSet::new();
+ % for prop in data.longhands:
+ % if not prop.logical:
+ if self.clone_${prop.ident}() != other.clone_${prop.ident}() {
+ set.insert(LonghandId::${prop.camel_case});
+ }
+ % endif
+ % endfor
+ set
+ }
+
+ /// Create a `TransitionPropertyIterator` for this styles transition properties.
+ pub fn transition_properties<'a>(
+ &'a self
+ ) -> animated_properties::TransitionPropertyIterator<'a> {
+ animated_properties::TransitionPropertyIterator::from_style(self)
+ }
+}
+
+#[cfg(feature = "servo")]
+impl ComputedValues {
+ /// Create a new refcounted `ComputedValues`
+ pub fn new(
+ pseudo: Option<<&PseudoElement>,
+ custom_properties: crate::custom_properties::ComputedCustomProperties,
+ writing_mode: WritingMode,
+ effective_zoom: computed::Zoom,
+ flags: ComputedValueFlags,
+ rules: Option<StrongRuleNode>,
+ visited_style: Option<Arc<ComputedValues>>,
+ % for style_struct in data.active_style_structs():
+ ${style_struct.ident}: Arc<style_structs::${style_struct.name}>,
+ % endfor
+ ) -> Arc<Self> {
+ Arc::new(Self {
+ inner: ComputedValuesInner {
+ custom_properties,
+ writing_mode,
+ rules,
+ visited_style,
+ effective_zoom,
+ flags,
+ % for style_struct in data.active_style_structs():
+ ${style_struct.ident},
+ % endfor
+ },
+ pseudo: pseudo.cloned(),
+ })
+ }
+
+ /// Get the initial computed values.
+ pub fn initial_values() -> &'static Self { &*INITIAL_SERVO_VALUES }
+
+ /// Serializes the computed value of this property as a string.
+ pub fn computed_value_to_string(&self, property: PropertyDeclarationId) -> String {
+ match property {
+ PropertyDeclarationId::Longhand(id) => {
+ let mut s = String::new();
+ self.get_longhand_property_value(
+ id,
+ &mut CssWriter::new(&mut s)
+ ).unwrap();
+ s
+ }
+ PropertyDeclarationId::Custom(name) => {
+ // FIXME(bug 1869476): This should use a stylist to determine
+ // whether the name corresponds to an inherited custom property
+ // and then choose the inherited/non_inherited map accordingly.
+ let p = &self.custom_properties;
+ let value = p
+ .inherited
+ .as_ref()
+ .and_then(|map| map.get(name))
+ .or_else(|| p.non_inherited.as_ref().and_then(|map| map.get(name)));
+ value.map_or(String::new(), |value| value.to_css_string())
+ }
+ }
+ }
+}
+
+#[cfg(feature = "servo")]
+impl ops::Deref for ComputedValues {
+ type Target = ComputedValuesInner;
+ fn deref(&self) -> &ComputedValuesInner {
+ &self.inner
+ }
+}
+
+#[cfg(feature = "servo")]
+impl ops::DerefMut for ComputedValues {
+ fn deref_mut(&mut self) -> &mut ComputedValuesInner {
+ &mut self.inner
+ }
+}
+
+#[cfg(feature = "servo")]
+impl ComputedValuesInner {
+ /// Returns the visited style, if any.
+ pub fn visited_style(&self) -> Option<<&ComputedValues> {
+ self.visited_style.as_deref()
+ }
+
+ % for style_struct in data.active_style_structs():
+ /// Clone the ${style_struct.name} struct.
+ #[inline]
+ pub fn clone_${style_struct.name_lower}(&self) -> Arc<style_structs::${style_struct.name}> {
+ self.${style_struct.ident}.clone()
+ }
+
+ /// Get a immutable reference to the ${style_struct.name} struct.
+ #[inline]
+ pub fn get_${style_struct.name_lower}(&self) -> &style_structs::${style_struct.name} {
+ &self.${style_struct.ident}
+ }
+
+ /// Get a mutable reference to the ${style_struct.name} struct.
+ #[inline]
+ pub fn mutate_${style_struct.name_lower}(&mut self) -> &mut style_structs::${style_struct.name} {
+ Arc::make_mut(&mut self.${style_struct.ident})
+ }
+ % endfor
+
+ /// Gets a reference to the rule node. Panic if no rule node exists.
+ pub fn rules(&self) -> &StrongRuleNode {
+ self.rules.as_ref().unwrap()
+ }
+
+ #[inline]
+ /// Returns whether the "content" property for the given style is completely
+ /// ineffective, and would yield an empty `::before` or `::after`
+ /// pseudo-element.
+ pub fn ineffective_content_property(&self) -> bool {
+ use crate::values::generics::counters::Content;
+ match self.get_counters().content {
+ Content::Normal | Content::None => true,
+ Content::Items(ref items) => items.is_empty(),
+ }
+ }
+
+ /// Whether the current style or any of its ancestors is multicolumn.
+ #[inline]
+ pub fn can_be_fragmented(&self) -> bool {
+ self.flags.contains(ComputedValueFlags::CAN_BE_FRAGMENTED)
+ }
+
+ /// Whether the current style is multicolumn.
+ #[inline]
+ pub fn is_multicol(&self) -> bool {
+ self.get_column().is_multicol()
+ }
+
+ /// Get the logical computed inline size.
+ #[inline]
+ pub fn content_inline_size(&self) -> &computed::Size {
+ let position_style = self.get_position();
+ if self.writing_mode.is_vertical() {
+ &position_style.height
+ } else {
+ &position_style.width
+ }
+ }
+
+ /// Get the logical computed block size.
+ #[inline]
+ pub fn content_block_size(&self) -> &computed::Size {
+ let position_style = self.get_position();
+ if self.writing_mode.is_vertical() { &position_style.width } else { &position_style.height }
+ }
+
+ /// Get the logical computed min inline size.
+ #[inline]
+ pub fn min_inline_size(&self) -> &computed::Size {
+ let position_style = self.get_position();
+ if self.writing_mode.is_vertical() { &position_style.min_height } else { &position_style.min_width }
+ }
+
+ /// Get the logical computed min block size.
+ #[inline]
+ pub fn min_block_size(&self) -> &computed::Size {
+ let position_style = self.get_position();
+ if self.writing_mode.is_vertical() { &position_style.min_width } else { &position_style.min_height }
+ }
+
+ /// Get the logical computed max inline size.
+ #[inline]
+ pub fn max_inline_size(&self) -> &computed::MaxSize {
+ let position_style = self.get_position();
+ if self.writing_mode.is_vertical() { &position_style.max_height } else { &position_style.max_width }
+ }
+
+ /// Get the logical computed max block size.
+ #[inline]
+ pub fn max_block_size(&self) -> &computed::MaxSize {
+ let position_style = self.get_position();
+ if self.writing_mode.is_vertical() { &position_style.max_width } else { &position_style.max_height }
+ }
+
+ /// Get the logical computed padding for this writing mode.
+ #[inline]
+ pub fn logical_padding(&self) -> LogicalMargin<<&computed::LengthPercentage> {
+ let padding_style = self.get_padding();
+ LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
+ &padding_style.padding_top.0,
+ &padding_style.padding_right.0,
+ &padding_style.padding_bottom.0,
+ &padding_style.padding_left.0,
+ ))
+ }
+
+ /// Get the logical border width
+ #[inline]
+ pub fn border_width_for_writing_mode(&self, writing_mode: WritingMode) -> LogicalMargin<Au> {
+ let border_style = self.get_border();
+ LogicalMargin::from_physical(writing_mode, SideOffsets2D::new(
+ Au::from(border_style.border_top_width),
+ Au::from(border_style.border_right_width),
+ Au::from(border_style.border_bottom_width),
+ Au::from(border_style.border_left_width),
+ ))
+ }
+
+ /// Gets the logical computed border widths for this style.
+ #[inline]
+ pub fn logical_border_width(&self) -> LogicalMargin<Au> {
+ self.border_width_for_writing_mode(self.writing_mode)
+ }
+
+ /// Gets the logical computed margin from this style.
+ #[inline]
+ pub fn logical_margin(&self) -> LogicalMargin<<&computed::LengthPercentageOrAuto> {
+ let margin_style = self.get_margin();
+ LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
+ &margin_style.margin_top,
+ &margin_style.margin_right,
+ &margin_style.margin_bottom,
+ &margin_style.margin_left,
+ ))
+ }
+
+ /// Gets the logical position from this style.
+ #[inline]
+ pub fn logical_position(&self) -> LogicalMargin<<&computed::LengthPercentageOrAuto> {
+ // FIXME(SimonSapin): should be the writing mode of the containing block, maybe?
+ let position_style = self.get_position();
+ LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
+ &position_style.top,
+ &position_style.right,
+ &position_style.bottom,
+ &position_style.left,
+ ))
+ }
+
+ /// Return true if the effects force the transform style to be Flat
+ pub fn overrides_transform_style(&self) -> bool {
+ use crate::computed_values::mix_blend_mode::T as MixBlendMode;
+
+ let effects = self.get_effects();
+ // TODO(gw): Add clip-path, isolation, mask-image, mask-border-source when supported.
+ effects.opacity < 1.0 ||
+ !effects.filter.0.is_empty() ||
+ !effects.clip.is_auto() ||
+ effects.mix_blend_mode != MixBlendMode::Normal
+ }
+
+ /// <https://drafts.csswg.org/css-transforms/#grouping-property-values>
+ pub fn get_used_transform_style(&self) -> computed_values::transform_style::T {
+ use crate::computed_values::transform_style::T as TransformStyle;
+
+ let box_ = self.get_box();
+
+ if self.overrides_transform_style() {
+ TransformStyle::Flat
+ } else {
+ // Return the computed value if not overridden by the above exceptions
+ box_.transform_style
+ }
+ }
+
+ /// Whether given this transform value, the compositor would require a
+ /// layer.
+ pub fn transform_requires_layer(&self) -> bool {
+ use crate::values::generics::transform::TransformOperation;
+ // Check if the transform matrix is 2D or 3D
+ for transform in &*self.get_box().transform.0 {
+ match *transform {
+ TransformOperation::Perspective(..) => {
+ return true;
+ }
+ TransformOperation::Matrix3D(m) => {
+ // See http://dev.w3.org/csswg/css-transforms/#2d-matrix
+ if m.m31 != 0.0 || m.m32 != 0.0 ||
+ m.m13 != 0.0 || m.m23 != 0.0 ||
+ m.m43 != 0.0 || m.m14 != 0.0 ||
+ m.m24 != 0.0 || m.m34 != 0.0 ||
+ m.m33 != 1.0 || m.m44 != 1.0 {
+ return true;
+ }
+ }
+ TransformOperation::Translate3D(_, _, z) |
+ TransformOperation::TranslateZ(z) => {
+ if z.px() != 0. {
+ return true;
+ }
+ }
+ _ => {}
+ }
+ }
+
+ // Neither perspective nor transform present
+ false
+ }
+}
+
+/// A reference to a style struct of the parent, or our own style struct.
+pub enum StyleStructRef<'a, T: 'static> {
+ /// A borrowed struct from the parent, for example, for inheriting style.
+ Borrowed(&'a T),
+ /// An owned struct, that we've already mutated.
+ Owned(UniqueArc<T>),
+ /// Temporarily vacated, will panic if accessed
+ Vacated,
+}
+
+impl<'a, T: 'a> StyleStructRef<'a, T>
+where
+ T: Clone,
+{
+ /// Ensure a mutable reference of this value exists, either cloning the
+ /// borrowed value, or returning the owned one.
+ pub fn mutate(&mut self) -> &mut T {
+ if let StyleStructRef::Borrowed(v) = *self {
+ *self = StyleStructRef::Owned(UniqueArc::new(v.clone()));
+ }
+
+ match *self {
+ StyleStructRef::Owned(ref mut v) => v,
+ StyleStructRef::Borrowed(..) => unreachable!(),
+ StyleStructRef::Vacated => panic!("Accessed vacated style struct")
+ }
+ }
+
+ /// Whether this is pointer-equal to the struct we're going to copy the
+ /// value from.
+ ///
+ /// This is used to avoid allocations when people write stuff like `font:
+ /// inherit` or such `all: initial`.
+ #[inline]
+ pub fn ptr_eq(&self, struct_to_copy_from: &T) -> bool {
+ match *self {
+ StyleStructRef::Owned(..) => false,
+ StyleStructRef::Borrowed(s) => {
+ s as *const T == struct_to_copy_from as *const T
+ }
+ StyleStructRef::Vacated => panic!("Accessed vacated style struct")
+ }
+ }
+
+ /// Extract a unique Arc from this struct, vacating it.
+ ///
+ /// The vacated state is a transient one, please put the Arc back
+ /// when done via `put()`. This function is to be used to separate
+ /// the struct being mutated from the computed context
+ pub fn take(&mut self) -> UniqueArc<T> {
+ use std::mem::replace;
+ let inner = replace(self, StyleStructRef::Vacated);
+
+ match inner {
+ StyleStructRef::Owned(arc) => arc,
+ StyleStructRef::Borrowed(s) => UniqueArc::new(s.clone()),
+ StyleStructRef::Vacated => panic!("Accessed vacated style struct"),
+ }
+ }
+
+ /// Replace vacated ref with an arc
+ pub fn put(&mut self, arc: UniqueArc<T>) {
+ debug_assert!(matches!(*self, StyleStructRef::Vacated));
+ *self = StyleStructRef::Owned(arc);
+ }
+
+ /// Get a mutable reference to the owned struct, or `None` if the struct
+ /// hasn't been mutated.
+ pub fn get_if_mutated(&mut self) -> Option<<&mut T> {
+ match *self {
+ StyleStructRef::Owned(ref mut v) => Some(v),
+ StyleStructRef::Borrowed(..) => None,
+ StyleStructRef::Vacated => panic!("Accessed vacated style struct")
+ }
+ }
+
+ /// Returns an `Arc` to the internal struct, constructing one if
+ /// appropriate.
+ pub fn build(self) -> Arc<T> {
+ match self {
+ StyleStructRef::Owned(v) => v.shareable(),
+ // SAFETY: We know all style structs are arc-allocated.
+ StyleStructRef::Borrowed(v) => unsafe { Arc::from_raw_addrefed(v) },
+ StyleStructRef::Vacated => panic!("Accessed vacated style struct")
+ }
+ }
+}
+
+impl<'a, T: 'a> ops::Deref for StyleStructRef<'a, T> {
+ type Target = T;
+
+ fn deref(&self) -> &T {
+ match *self {
+ StyleStructRef::Owned(ref v) => &**v,
+ StyleStructRef::Borrowed(v) => v,
+ StyleStructRef::Vacated => panic!("Accessed vacated style struct")
+ }
+ }
+}
+
+/// A type used to compute a struct with minimal overhead.
+///
+/// This allows holding references to the parent/default computed values without
+/// actually cloning them, until we either build the style, or mutate the
+/// inherited value.
+pub struct StyleBuilder<'a> {
+ /// The device we're using to compute style.
+ ///
+ /// This provides access to viewport unit ratios, etc.
+ pub device: &'a Device,
+
+ /// The stylist we're using to compute style except for media queries.
+ /// device is used in media queries instead.
+ pub stylist: Option<<&'a Stylist>,
+
+ /// The style we're inheriting from.
+ ///
+ /// This is effectively
+ /// `parent_style.unwrap_or(device.default_computed_values())`.
+ inherited_style: &'a ComputedValues,
+
+ /// The style we're getting reset structs from.
+ reset_style: &'a ComputedValues,
+
+ /// The rule node representing the ordered list of rules matched for this
+ /// node.
+ pub rules: Option<StrongRuleNode>,
+
+ /// The computed custom properties.
+ pub custom_properties: crate::custom_properties::ComputedCustomProperties,
+
+ /// Non-custom properties that are considered invalid at compute time
+ /// due to cyclic dependencies with custom properties.
+ /// e.g. `--foo: 1em; font-size: var(--foo)` where `--foo` is registered.
+ pub invalid_non_custom_properties: LonghandIdSet,
+
+ /// The pseudo-element this style will represent.
+ pub pseudo: Option<<&'a PseudoElement>,
+
+ /// Whether we have mutated any reset structs since the the last time
+ /// `clear_modified_reset` was called. This is used to tell whether the
+ /// `StyleAdjuster` did any work.
+ modified_reset: bool,
+
+ /// Whether this is the style for the root element.
+ pub is_root_element: bool,
+
+ /// The writing mode flags.
+ ///
+ /// TODO(emilio): Make private.
+ pub writing_mode: WritingMode,
+
+ /// The effective zoom.
+ pub effective_zoom: computed::Zoom,
+
+ /// Flags for the computed value.
+ pub flags: Cell<ComputedValueFlags>,
+
+ /// The element's style if visited, only computed if there's a relevant link
+ /// for this element. A element's "relevant link" is the element being
+ /// matched if it is a link or the nearest ancestor link.
+ pub visited_style: Option<Arc<ComputedValues>>,
+ % for style_struct in data.active_style_structs():
+ ${style_struct.ident}: StyleStructRef<'a, style_structs::${style_struct.name}>,
+ % endfor
+}
+
+impl<'a> StyleBuilder<'a> {
+ /// Trivially construct a `StyleBuilder`.
+ pub fn new(
+ device: &'a Device,
+ stylist: Option<<&'a Stylist>,
+ parent_style: Option<<&'a ComputedValues>,
+ pseudo: Option<<&'a PseudoElement>,
+ rules: Option<StrongRuleNode>,
+ is_root_element: bool,
+ ) -> Self {
+ let reset_style = device.default_computed_values();
+ let inherited_style = parent_style.unwrap_or(reset_style);
+
+ let flags = inherited_style.flags.inherited();
+ StyleBuilder {
+ device,
+ stylist,
+ inherited_style,
+ reset_style,
+ pseudo,
+ rules,
+ modified_reset: false,
+ is_root_element,
+ custom_properties: crate::custom_properties::ComputedCustomProperties::default(),
+ invalid_non_custom_properties: LonghandIdSet::default(),
+ writing_mode: inherited_style.writing_mode,
+ effective_zoom: inherited_style.effective_zoom,
+ flags: Cell::new(flags),
+ visited_style: None,
+ % for style_struct in data.active_style_structs():
+ % if style_struct.inherited:
+ ${style_struct.ident}: StyleStructRef::Borrowed(inherited_style.get_${style_struct.name_lower}()),
+ % else:
+ ${style_struct.ident}: StyleStructRef::Borrowed(reset_style.get_${style_struct.name_lower}()),
+ % endif
+ % endfor
+ }
+ }
+
+ /// NOTE(emilio): This is done so we can compute relative units with respect
+ /// to the parent style, but all the early properties / writing-mode / etc
+ /// are already set to the right ones on the kid.
+ ///
+ /// Do _not_ actually call this to construct a style, this should mostly be
+ /// used for animations.
+ pub fn for_animation(
+ device: &'a Device,
+ stylist: Option<<&'a Stylist>,
+ style_to_derive_from: &'a ComputedValues,
+ parent_style: Option<<&'a ComputedValues>,
+ ) -> Self {
+ let reset_style = device.default_computed_values();
+ let inherited_style = parent_style.unwrap_or(reset_style);
+ StyleBuilder {
+ device,
+ stylist,
+ inherited_style,
+ reset_style,
+ pseudo: None,
+ modified_reset: false,
+ is_root_element: false,
+ rules: None,
+ custom_properties: style_to_derive_from.custom_properties().clone(),
+ invalid_non_custom_properties: LonghandIdSet::default(),
+ writing_mode: style_to_derive_from.writing_mode,
+ effective_zoom: style_to_derive_from.effective_zoom,
+ flags: Cell::new(style_to_derive_from.flags),
+ visited_style: None,
+ % for style_struct in data.active_style_structs():
+ ${style_struct.ident}: StyleStructRef::Borrowed(
+ style_to_derive_from.get_${style_struct.name_lower}()
+ ),
+ % endfor
+ }
+ }
+
+ /// Copy the reset properties from `style`.
+ pub fn copy_reset_from(&mut self, style: &'a ComputedValues) {
+ % for style_struct in data.active_style_structs():
+ % if not style_struct.inherited:
+ self.${style_struct.ident} =
+ StyleStructRef::Borrowed(style.get_${style_struct.name_lower}());
+ % endif
+ % endfor
+ }
+
+ % for property in data.longhands:
+ % if not property.logical:
+ % if not property.style_struct.inherited:
+ /// Inherit `${property.ident}` from our parent style.
+ #[allow(non_snake_case)]
+ pub fn inherit_${property.ident}(&mut self) {
+ let inherited_struct =
+ self.inherited_style.get_${property.style_struct.name_lower}();
+
+ self.modified_reset = true;
+ self.add_flags(ComputedValueFlags::INHERITS_RESET_STYLE);
+
+ % if property.ident == "content":
+ self.add_flags(ComputedValueFlags::CONTENT_DEPENDS_ON_INHERITED_STYLE);
+ % endif
+
+ % if property.ident == "display":
+ self.add_flags(ComputedValueFlags::DISPLAY_DEPENDS_ON_INHERITED_STYLE);
+ % endif
+
+ if self.${property.style_struct.ident}.ptr_eq(inherited_struct) {
+ return;
+ }
+
+ self.${property.style_struct.ident}.mutate()
+ .copy_${property.ident}_from(inherited_struct);
+ }
+ % else:
+ /// Reset `${property.ident}` to the initial value.
+ #[allow(non_snake_case)]
+ pub fn reset_${property.ident}(&mut self) {
+ let reset_struct =
+ self.reset_style.get_${property.style_struct.name_lower}();
+
+ if self.${property.style_struct.ident}.ptr_eq(reset_struct) {
+ return;
+ }
+
+ self.${property.style_struct.ident}.mutate()
+ .reset_${property.ident}(reset_struct);
+ }
+ % endif
+
+ % if not property.is_vector or property.simple_vector_bindings or engine in ["servo-2013", "servo-2020"]:
+ /// Set the `${property.ident}` to the computed value `value`.
+ #[allow(non_snake_case)]
+ pub fn set_${property.ident}(
+ &mut self,
+ value: longhands::${property.ident}::computed_value::T
+ ) {
+ % if not property.style_struct.inherited:
+ self.modified_reset = true;
+ % endif
+
+ self.${property.style_struct.ident}.mutate()
+ .set_${property.ident}(
+ value,
+ % if property.logical:
+ self.writing_mode,
+ % endif
+ );
+ }
+ % endif
+ % endif
+ % endfor
+ <% del property %>
+
+ /// Inherits style from the parent element, accounting for the default
+ /// computed values that need to be provided as well.
+ pub fn for_inheritance(
+ device: &'a Device,
+ stylist: Option<<&'a Stylist>,
+ parent: Option<<&'a ComputedValues>,
+ pseudo: Option<<&'a PseudoElement>,
+ ) -> Self {
+ // Rebuild the visited style from the parent, ensuring that it will also
+ // not have rules. This matches the unvisited style that will be
+ // produced by this builder. This assumes that the caller doesn't need
+ // to adjust or process visited style, so we can just build visited
+ // style here for simplicity.
+ let visited_style = parent.and_then(|parent| {
+ parent.visited_style().map(|style| {
+ Self::for_inheritance(
+ device,
+ stylist,
+ Some(style),
+ pseudo,
+ ).build()
+ })
+ });
+ let custom_properties = if let Some(p) = parent { p.custom_properties().clone() } else { crate::custom_properties::ComputedCustomProperties::default() };
+ let mut ret = Self::new(
+ device,
+ stylist,
+ parent,
+ pseudo,
+ /* rules = */ None,
+ /* is_root_element = */ false,
+ );
+ ret.custom_properties = custom_properties;
+ ret.visited_style = visited_style;
+ ret
+ }
+
+ /// Returns whether we have a visited style.
+ pub fn has_visited_style(&self) -> bool {
+ self.visited_style.is_some()
+ }
+
+ /// Returns whether we're a pseudo-elements style.
+ pub fn is_pseudo_element(&self) -> bool {
+ self.pseudo.map_or(false, |p| !p.is_anon_box())
+ }
+
+ /// Returns the style we're getting reset properties from.
+ pub fn default_style(&self) -> &'a ComputedValues {
+ self.reset_style
+ }
+
+ % for style_struct in data.active_style_structs():
+ /// Gets an immutable view of the current `${style_struct.name}` style.
+ pub fn get_${style_struct.name_lower}(&self) -> &style_structs::${style_struct.name} {
+ &self.${style_struct.ident}
+ }
+
+ /// Gets a mutable view of the current `${style_struct.name}` style.
+ pub fn mutate_${style_struct.name_lower}(&mut self) -> &mut style_structs::${style_struct.name} {
+ % if not style_struct.inherited:
+ self.modified_reset = true;
+ % endif
+ self.${style_struct.ident}.mutate()
+ }
+
+ /// Gets a mutable view of the current `${style_struct.name}` style.
+ pub fn take_${style_struct.name_lower}(&mut self) -> UniqueArc<style_structs::${style_struct.name}> {
+ % if not style_struct.inherited:
+ self.modified_reset = true;
+ % endif
+ self.${style_struct.ident}.take()
+ }
+
+ /// Gets a mutable view of the current `${style_struct.name}` style.
+ pub fn put_${style_struct.name_lower}(&mut self, s: UniqueArc<style_structs::${style_struct.name}>) {
+ self.${style_struct.ident}.put(s)
+ }
+
+ /// Gets a mutable view of the current `${style_struct.name}` style,
+ /// only if it's been mutated before.
+ pub fn get_${style_struct.name_lower}_if_mutated(&mut self)
+ -> Option<<&mut style_structs::${style_struct.name}> {
+ self.${style_struct.ident}.get_if_mutated()
+ }
+
+ /// Reset the current `${style_struct.name}` style to its default value.
+ pub fn reset_${style_struct.name_lower}_struct(&mut self) {
+ self.${style_struct.ident} =
+ StyleStructRef::Borrowed(self.reset_style.get_${style_struct.name_lower}());
+ }
+ % endfor
+ <% del style_struct %>
+
+ /// Returns whether this computed style represents a floated object.
+ pub fn is_floating(&self) -> bool {
+ self.get_box().clone_float().is_floating()
+ }
+
+ /// Returns whether this computed style represents an absolutely-positioned
+ /// object.
+ pub fn is_absolutely_positioned(&self) -> bool {
+ self.get_box().clone_position().is_absolutely_positioned()
+ }
+
+ /// Whether this style has a top-layer style.
+ #[cfg(feature = "servo")]
+ pub fn in_top_layer(&self) -> bool {
+ matches!(self.get_box().clone__servo_top_layer(),
+ longhands::_servo_top_layer::computed_value::T::Top)
+ }
+
+ /// Whether this style has a top-layer style.
+ #[cfg(feature = "gecko")]
+ pub fn in_top_layer(&self) -> bool {
+ matches!(self.get_box().clone__moz_top_layer(),
+ longhands::_moz_top_layer::computed_value::T::Top)
+ }
+
+ /// Clears the "have any reset structs been modified" flag.
+ pub fn clear_modified_reset(&mut self) {
+ self.modified_reset = false;
+ }
+
+ /// Returns whether we have mutated any reset structs since the the last
+ /// time `clear_modified_reset` was called.
+ pub fn modified_reset(&self) -> bool {
+ self.modified_reset
+ }
+
+ /// Return the current flags.
+ #[inline]
+ pub fn flags(&self) -> ComputedValueFlags {
+ self.flags.get()
+ }
+
+ /// Add a flag to the current builder.
+ #[inline]
+ pub fn add_flags(&self, flag: ComputedValueFlags) {
+ let flags = self.flags() | flag;
+ self.flags.set(flags);
+ }
+
+ /// Removes a flag to the current builder.
+ #[inline]
+ pub fn remove_flags(&self, flag: ComputedValueFlags) {
+ let flags = self.flags() & !flag;
+ self.flags.set(flags);
+ }
+
+ /// Turns this `StyleBuilder` into a proper `ComputedValues` instance.
+ pub fn build(self) -> Arc<ComputedValues> {
+ ComputedValues::new(
+ self.pseudo,
+ self.custom_properties,
+ self.writing_mode,
+ self.effective_zoom,
+ self.flags.get(),
+ self.rules,
+ self.visited_style,
+ % for style_struct in data.active_style_structs():
+ self.${style_struct.ident}.build(),
+ % endfor
+ )
+ }
+
+ /// Get the custom properties map if necessary.
+ pub fn custom_properties(&self) -> &crate::custom_properties::ComputedCustomProperties {
+ &self.custom_properties
+ }
+
+
+ /// Get the inherited custom properties map.
+ pub fn inherited_custom_properties(&self) -> &crate::custom_properties::ComputedCustomProperties {
+ &self.inherited_style.custom_properties
+ }
+
+ /// Access to various information about our inherited styles. We don't
+ /// expose an inherited ComputedValues directly, because in the
+ /// ::first-line case some of the inherited information needs to come from
+ /// one ComputedValues instance and some from a different one.
+
+ /// Inherited writing-mode.
+ pub fn inherited_writing_mode(&self) -> &WritingMode {
+ &self.inherited_style.writing_mode
+ }
+
+ /// The effective zoom value that we should multiply absolute lengths by.
+ pub fn effective_zoom(&self) -> computed::Zoom {
+ self.effective_zoom
+ }
+
+ /// The zoom specified on this element.
+ pub fn specified_zoom(&self) -> computed::Zoom {
+ self.get_box().clone_zoom()
+ }
+
+ /// Inherited zoom.
+ pub fn inherited_effective_zoom(&self) -> computed::Zoom {
+ self.inherited_style.effective_zoom
+ }
+
+ /// The computed value flags of our parent.
+ #[inline]
+ pub fn get_parent_flags(&self) -> ComputedValueFlags {
+ self.inherited_style.flags
+ }
+
+ /// Calculate the line height, given the currently resolved line-height and font.
+ pub fn calc_line_height(
+ &self,
+ device: &Device,
+ line_height_base: LineHeightBase,
+ writing_mode: WritingMode,
+ ) -> computed::NonNegativeLength {
+ use crate::computed_value_flags::ComputedValueFlags;
+ let (font, flag) = match line_height_base {
+ LineHeightBase::CurrentStyle => (
+ self.get_font(),
+ ComputedValueFlags::DEPENDS_ON_SELF_FONT_METRICS,
+ ),
+ LineHeightBase::InheritedStyle => (
+ self.get_parent_font(),
+ ComputedValueFlags::DEPENDS_ON_INHERITED_FONT_METRICS,
+ ),
+ };
+ let line_height = font.clone_line_height();
+ if matches!(line_height, computed::LineHeight::Normal) {
+ self.add_flags(flag);
+ }
+ device.calc_line_height(&font, writing_mode, None)
+ }
+
+ /// And access to inherited style structs.
+ % for style_struct in data.active_style_structs():
+ /// Gets our inherited `${style_struct.name}`. We don't name these
+ /// accessors `inherited_${style_struct.name_lower}` because we already
+ /// have things like "box" vs "inherited_box" as struct names. Do the
+ /// next-best thing and call them `parent_${style_struct.name_lower}`
+ /// instead.
+ pub fn get_parent_${style_struct.name_lower}(&self) -> &style_structs::${style_struct.name} {
+ self.inherited_style.get_${style_struct.name_lower}()
+ }
+ % endfor
+}
+
+#[cfg(feature = "servo")]
+pub use self::lazy_static_module::INITIAL_SERVO_VALUES;
+
+// Use a module to work around #[cfg] on lazy_static! not being applied to every generated item.
+#[cfg(feature = "servo")]
+#[allow(missing_docs)]
+mod lazy_static_module {
+ use crate::logical_geometry::WritingMode;
+ use crate::computed_value_flags::ComputedValueFlags;
+ use servo_arc::Arc;
+ use super::{ComputedValues, ComputedValuesInner, longhands, style_structs};
+
+ lazy_static! {
+ /// The initial values for all style structs as defined by the specification.
+ pub static ref INITIAL_SERVO_VALUES: ComputedValues = ComputedValues {
+ inner: ComputedValuesInner {
+ % for style_struct in data.active_style_structs():
+ ${style_struct.ident}: Arc::new(style_structs::${style_struct.name} {
+ % for longhand in style_struct.longhands:
+ % if not longhand.logical:
+ ${longhand.ident}: longhands::${longhand.ident}::get_initial_value(),
+ % endif
+ % endfor
+ % if style_struct.name == "InheritedText":
+ text_decorations_in_effect:
+ crate::values::computed::text::TextDecorationsInEffect::default(),
+ % endif
+ % if style_struct.name == "Font":
+ hash: 0,
+ % endif
+ % if style_struct.name == "Box":
+ original_display: longhands::display::get_initial_value(),
+ % endif
+ }),
+ % endfor
+ custom_properties,
+ writing_mode: WritingMode::empty(),
+ rules: None,
+ visited_style: None,
+ flags: ComputedValueFlags::empty(),
+ },
+ pseudo: None,
+ };
+ }
+}
+
+/// A per-longhand function that performs the CSS cascade for that longhand.
+pub type CascadePropertyFn =
+ unsafe extern "Rust" fn(
+ declaration: &PropertyDeclaration,
+ context: &mut computed::Context,
+ );
+
+/// A per-longhand array of functions to perform the CSS cascade on each of
+/// them, effectively doing virtual dispatch.
+pub static CASCADE_PROPERTY: [CascadePropertyFn; ${len(data.longhands)}] = [
+ % for property in data.longhands:
+ longhands::${property.ident}::cascade_property,
+ % endfor
+];
+
+/// See StyleAdjuster::adjust_for_border_width.
+pub fn adjust_border_width(style: &mut StyleBuilder) {
+ % for side in ["top", "right", "bottom", "left"]:
+ // Like calling to_computed_value, which wouldn't type check.
+ if style.get_border().clone_border_${side}_style().none_or_hidden() &&
+ style.get_border().border_${side}_has_nonzero_width() {
+ style.set_border_${side}_width(Au(0));
+ }
+ % endfor
+}
+
+/// An identifier for a given alias property.
+#[derive(Clone, Copy, Eq, PartialEq, MallocSizeOf)]
+#[repr(u16)]
+pub enum AliasId {
+ % for i, property in enumerate(data.all_aliases()):
+ /// ${property.name}
+ ${property.camel_case} = ${i},
+ % endfor
+}
+
+impl fmt::Debug for AliasId {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let name = NonCustomPropertyId::from(*self).name();
+ formatter.write_str(name)
+ }
+}
+
+impl AliasId {
+ /// Returns the property we're aliasing, as a longhand or a shorthand.
+ #[inline]
+ pub fn aliased_property(self) -> NonCustomPropertyId {
+ static MAP: [NonCustomPropertyId; ${len(data.all_aliases())}] = [
+ % for alias in data.all_aliases():
+ % if alias.original.type() == "longhand":
+ NonCustomPropertyId::from_longhand(LonghandId::${alias.original.camel_case}),
+ % else:
+ <% assert alias.original.type() == "shorthand" %>
+ NonCustomPropertyId::from_shorthand(ShorthandId::${alias.original.camel_case}),
+ % endif
+ % endfor
+ ];
+ MAP[self as usize]
+ }
+}
+
+/// Call the given macro with tokens like this for each longhand and shorthand properties
+/// that is enabled in content:
+///
+/// ```
+/// [CamelCaseName, SetCamelCaseName, PropertyId::Longhand(LonghandId::CamelCaseName)],
+/// ```
+///
+/// NOTE(emilio): Callers are responsible to deal with prefs.
+#[macro_export]
+macro_rules! css_properties_accessors {
+ ($macro_name: ident) => {
+ $macro_name! {
+ % for kind, props in [("Longhand", data.longhands), ("Shorthand", data.shorthands)]:
+ % for property in props:
+ % if property.enabled_in_content():
+ % for prop in [property] + property.aliases:
+ % if '-' in prop.name:
+ [${prop.ident.capitalize()}, Set${prop.ident.capitalize()},
+ PropertyId::${kind}(${kind}Id::${property.camel_case})],
+ % endif
+ [${prop.camel_case}, Set${prop.camel_case},
+ PropertyId::${kind}(${kind}Id::${property.camel_case})],
+ % endfor
+ % endif
+ % endfor
+ % endfor
+ }
+ }
+}
+
+/// Call the given macro with tokens like this for each longhand properties:
+///
+/// ```
+/// { snake_case_ident }
+/// ```
+#[macro_export]
+macro_rules! longhand_properties_idents {
+ ($macro_name: ident) => {
+ $macro_name! {
+ % for property in data.longhands:
+ { ${property.ident} }
+ % endfor
+ }
+ }
+}
+
+// Large pages generate tens of thousands of ComputedValues.
+size_of_test!(ComputedValues, 240);
+// FFI relies on this.
+size_of_test!(Option<Arc<ComputedValues>>, 8);
+
+// There are two reasons for this test to fail:
+//
+// * Your changes made a specified value type for a given property go
+// over the threshold. In that case, you should try to shrink it again
+// or, if not possible, mark the property as boxed in the property
+// definition.
+//
+// * Your changes made a specified value type smaller, so that it no
+// longer needs to be boxed. In this case you just need to remove
+// boxed=True from the property definition. Nice job!
+#[cfg(target_pointer_width = "64")]
+#[allow(dead_code)] // https://github.com/rust-lang/rust/issues/96952
+const BOX_THRESHOLD: usize = 24;
+% for longhand in data.longhands:
+#[cfg(target_pointer_width = "64")]
+% if longhand.boxed:
+const_assert!(std::mem::size_of::<longhands::${longhand.ident}::SpecifiedValue>() > BOX_THRESHOLD);
+% else:
+const_assert!(std::mem::size_of::<longhands::${longhand.ident}::SpecifiedValue>() <= BOX_THRESHOLD);
+% endif
+% endfor
+
+% if engine in ["servo-2013", "servo-2020"]:
+% for effect_name in ["repaint", "reflow_out_of_flow", "reflow", "rebuild_and_reflow_inline", "rebuild_and_reflow"]:
+ macro_rules! restyle_damage_${effect_name} {
+ ($old: ident, $new: ident, $damage: ident, [ $($effect:expr),* ]) => ({
+ if
+ % for style_struct in data.active_style_structs():
+ % for longhand in style_struct.longhands:
+ % if effect_name in longhand.servo_restyle_damage.split() and not longhand.logical:
+ $old.get_${style_struct.name_lower}().${longhand.ident} !=
+ $new.get_${style_struct.name_lower}().${longhand.ident} ||
+ % endif
+ % endfor
+ % endfor
+
+ false {
+ $damage.insert($($effect)|*);
+ true
+ } else {
+ false
+ }
+ })
+ }
+% endfor
+% endif