blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/values/resolved/animation.rs

@@ -0,0 +1,33 @@
+/* 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/. */
+
+//! Resolved animation values.
+
+use super::{Context, ToResolvedValue};
+
+use crate::values::computed::time::Time;
+use crate::values::computed::AnimationDuration;
+
+impl ToResolvedValue for AnimationDuration {
+    type ResolvedValue = Self;
+
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        match self {
+            // For backwards-compatibility with Level 1, when the computed value of
+            // animation-timeline is auto (i.e. only one list value, and that value being auto),
+            // the resolved value of auto for animation-duration is 0s whenever its used value
+            // would also be 0s.
+            // https://drafts.csswg.org/css-animations-2/#animation-duration
+            Self::Auto if context.style.get_ui().has_initial_animation_timeline() => {
+                Self::Time(Time::from_seconds(0.0f32))
+            },
+            _ => self,
+        }
+    }
+
+    #[inline]
+    fn from_resolved_value(value: Self::ResolvedValue) -> Self {
+        value
+    }
+}

package/vendor/stylo/values/resolved/color.rs

@@ -0,0 +1,53 @@
+/* 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/. */
+
+//! Resolved color values.
+
+use super::{Context, ToResolvedValue};
+
+use crate::properties::{PropertyId, ShorthandId};
+use crate::values::computed::color as computed;
+use crate::values::generics::color as generics;
+
+impl ToResolvedValue for computed::Color {
+    // A resolved color value is (almost always) a rgba color, with currentcolor resolved.
+    type ResolvedValue = Self;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        if context.for_property == PropertyId::NonCustom(ShorthandId::TextDecoration.into())
+            && matches!(self, Self::CurrentColor)
+        {
+            return self;
+        }
+        generics::Color::Absolute(context.style.resolve_color(&self))
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        resolved
+    }
+}
+
+impl ToResolvedValue for computed::CaretColor {
+    // A resolved caret-color value is an rgba color, with auto resolving to
+    // currentcolor.
+    type ResolvedValue = computed::Color;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        let color = match self.0 {
+            generics::ColorOrAuto::Color(color) => color,
+            generics::ColorOrAuto::Auto => generics::Color::currentcolor(),
+        };
+        color.to_resolved_value(context)
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        generics::CaretColor(generics::ColorOrAuto::Color(
+            computed::Color::from_resolved_value(resolved),
+        ))
+    }
+}

package/vendor/stylo/values/resolved/counters.rs

@@ -0,0 +1,45 @@
+/* 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/. */
+
+//! Resolved values for counter properties
+
+use super::{Context, ToResolvedValue};
+use crate::values::computed;
+#[cfg(feature = "gecko")]
+use selectors::parser::PseudoElement;
+
+/// https://drafts.csswg.org/css-content/#content-property
+///
+/// We implement this at resolved value time because otherwise it causes us to allocate a bunch of
+/// useless initial structs for all ::before / ::after, which is a bit unfortunate.
+///
+/// Though these should be temporary, mostly, so if this causes complexity in
+/// other places, it should be fine to move to `StyleAdjuster`.
+///
+/// See https://github.com/w3c/csswg-drafts/issues/4632 for where some related
+/// issues are being discussed.
+impl ToResolvedValue for computed::Content {
+    type ResolvedValue = Self;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self {
+        let (is_before_or_after, is_marker) = match context.style.pseudo() {
+            Some(ref pseudo) => (pseudo.is_before_or_after(), pseudo.is_marker()),
+            None => (false, false),
+        };
+        match self {
+            Self::Normal if is_before_or_after => Self::None,
+            // For now, make `content: none` resolve to `normal` for pseudos
+            // other than ::before, ::after and ::marker, as we don't respect it.
+            // https://github.com/w3c/csswg-drafts/issues/6124
+            Self::None if !is_before_or_after && !is_marker => Self::Normal,
+            other => other,
+        }
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self) -> Self {
+        resolved
+    }
+}

package/vendor/stylo/values/resolved/mod.rs

@@ -0,0 +1,316 @@
+/* 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/. */
+
+//! Resolved values. These are almost always computed values, but in some cases
+//! there are used values.
+
+#[cfg(feature = "gecko")]
+use crate::device::Device;
+use crate::properties::{ComputedValues, LonghandId, PropertyId};
+use crate::ArcSlice;
+use app_units::Au;
+use servo_arc::Arc;
+use smallvec::SmallVec;
+
+mod animation;
+mod color;
+mod counters;
+
+use crate::values::computed::{self, Length};
+
+/// Element-specific information needed to resolve property values.
+#[cfg(feature = "gecko")]
+pub struct ResolvedElementInfo<'a> {
+    /// Element we're resolving line-height against.
+    pub element: crate::gecko::wrapper::GeckoElement<'a>,
+}
+
+/// Information needed to resolve a given value.
+pub struct Context<'a> {
+    /// The style we're resolving for. This is useful to resolve currentColor.
+    pub style: &'a ComputedValues,
+    /// The device / document we're resolving style for. Useful to do font metrics stuff needed for
+    /// line-height.
+    #[cfg(feature = "gecko")]
+    pub device: &'a Device,
+    /// The element-specific information to resolve the value.
+    #[cfg(feature = "gecko")]
+    pub element_info: ResolvedElementInfo<'a>,
+    /// The property we're resolving the value for over-all (might be a shorthand, or a custom property).
+    pub for_property: PropertyId,
+    /// The current (physical) longhand we're resolving the value for. Guaranteed to be `Some()`
+    /// inside `ToResolvedValue` implementations.
+    pub current_longhand: Option<LonghandId>,
+}
+
+/// A trait to represent the conversion between resolved and resolved values.
+///
+/// This trait is derivable with `#[derive(ToResolvedValue)]`.
+///
+/// The deriving code assumes that if the type isn't generic, then the trait can
+/// be implemented as simple move. This means that a manual implementation with
+/// `ResolvedValue = Self` is bogus if it returns anything else than a clone.
+pub trait ToResolvedValue {
+    /// The resolved value type we're going to be converted to.
+    type ResolvedValue;
+
+    /// Convert a resolved value to a resolved value.
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue;
+
+    /// Convert a resolved value to resolved value form.
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self;
+}
+
+macro_rules! trivial_to_resolved_value {
+    ($ty:ty) => {
+        impl $crate::values::resolved::ToResolvedValue for $ty {
+            type ResolvedValue = Self;
+
+            #[inline]
+            fn to_resolved_value(self, _: &Context) -> Self {
+                self
+            }
+
+            #[inline]
+            fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+                resolved
+            }
+        }
+    };
+}
+
+trivial_to_resolved_value!(());
+trivial_to_resolved_value!(bool);
+trivial_to_resolved_value!(f32);
+trivial_to_resolved_value!(u8);
+trivial_to_resolved_value!(i8);
+trivial_to_resolved_value!(u16);
+trivial_to_resolved_value!(i16);
+trivial_to_resolved_value!(u32);
+trivial_to_resolved_value!(i32);
+trivial_to_resolved_value!(usize);
+trivial_to_resolved_value!(String);
+trivial_to_resolved_value!(Box<str>);
+trivial_to_resolved_value!(crate::OwnedStr);
+trivial_to_resolved_value!(crate::color::AbsoluteColor);
+trivial_to_resolved_value!(crate::values::generics::color::ColorMixFlags);
+trivial_to_resolved_value!(crate::Atom);
+trivial_to_resolved_value!(crate::values::AtomIdent);
+trivial_to_resolved_value!(crate::custom_properties::VariableValue);
+trivial_to_resolved_value!(crate::stylesheets::UrlExtraData);
+trivial_to_resolved_value!(computed::url::ComputedUrl);
+#[cfg(feature = "servo")]
+trivial_to_resolved_value!(crate::Namespace);
+#[cfg(feature = "servo")]
+trivial_to_resolved_value!(crate::Prefix);
+trivial_to_resolved_value!(style_traits::values::specified::AllowedNumericType);
+trivial_to_resolved_value!(computed::TimingFunction);
+
+impl ToResolvedValue for Au {
+    type ResolvedValue = Length;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        Length::new(self.to_f32_px()).to_resolved_value(context)
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        Au::from_f32_px(Length::from_resolved_value(resolved).px())
+    }
+}
+
+impl<A, B> ToResolvedValue for (A, B)
+where
+    A: ToResolvedValue,
+    B: ToResolvedValue,
+{
+    type ResolvedValue = (
+        <A as ToResolvedValue>::ResolvedValue,
+        <B as ToResolvedValue>::ResolvedValue,
+    );
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        (
+            self.0.to_resolved_value(context),
+            self.1.to_resolved_value(context),
+        )
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        (
+            A::from_resolved_value(resolved.0),
+            B::from_resolved_value(resolved.1),
+        )
+    }
+}
+
+impl<T> ToResolvedValue for Option<T>
+where
+    T: ToResolvedValue,
+{
+    type ResolvedValue = Option<<T as ToResolvedValue>::ResolvedValue>;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        self.map(|item| item.to_resolved_value(context))
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        resolved.map(T::from_resolved_value)
+    }
+}
+
+impl<T> ToResolvedValue for SmallVec<[T; 1]>
+where
+    T: ToResolvedValue,
+{
+    type ResolvedValue = SmallVec<[<T as ToResolvedValue>::ResolvedValue; 1]>;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        self.into_iter()
+            .map(|item| item.to_resolved_value(context))
+            .collect()
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        resolved.into_iter().map(T::from_resolved_value).collect()
+    }
+}
+
+impl<T> ToResolvedValue for Vec<T>
+where
+    T: ToResolvedValue,
+{
+    type ResolvedValue = Vec<<T as ToResolvedValue>::ResolvedValue>;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        self.into_iter()
+            .map(|item| item.to_resolved_value(context))
+            .collect()
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        resolved.into_iter().map(T::from_resolved_value).collect()
+    }
+}
+
+impl<T> ToResolvedValue for thin_vec::ThinVec<T>
+where
+    T: ToResolvedValue,
+{
+    type ResolvedValue = thin_vec::ThinVec<<T as ToResolvedValue>::ResolvedValue>;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        self.into_iter()
+            .map(|item| item.to_resolved_value(context))
+            .collect()
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        resolved.into_iter().map(T::from_resolved_value).collect()
+    }
+}
+
+impl<T> ToResolvedValue for Box<T>
+where
+    T: ToResolvedValue,
+{
+    type ResolvedValue = Box<<T as ToResolvedValue>::ResolvedValue>;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        Box::new(T::to_resolved_value(*self, context))
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        Box::new(T::from_resolved_value(*resolved))
+    }
+}
+
+impl<T> ToResolvedValue for Box<[T]>
+where
+    T: ToResolvedValue,
+{
+    type ResolvedValue = Box<[<T as ToResolvedValue>::ResolvedValue]>;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        Vec::from(self)
+            .to_resolved_value(context)
+            .into_boxed_slice()
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        Vec::from_resolved_value(Vec::from(resolved)).into_boxed_slice()
+    }
+}
+
+impl<T> ToResolvedValue for crate::OwnedSlice<T>
+where
+    T: ToResolvedValue,
+{
+    type ResolvedValue = crate::OwnedSlice<<T as ToResolvedValue>::ResolvedValue>;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self::ResolvedValue {
+        self.into_box().to_resolved_value(context).into()
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self::ResolvedValue) -> Self {
+        Self::from(Box::from_resolved_value(resolved.into_box()))
+    }
+}
+
+// NOTE(emilio): This is implementable more generically, but it's unlikely what
+// you want there, as it forces you to have an extra allocation.
+//
+// We could do that if needed, ideally with specialization for the case where
+// ResolvedValue = T. But we don't need it for now.
+impl<T> ToResolvedValue for Arc<T>
+where
+    T: ToResolvedValue<ResolvedValue = T>,
+{
+    type ResolvedValue = Self;
+
+    #[inline]
+    fn to_resolved_value(self, _: &Context) -> Self {
+        self
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self) -> Self {
+        resolved
+    }
+}
+
+// Same caveat as above applies.
+impl<T> ToResolvedValue for ArcSlice<T>
+where
+    T: ToResolvedValue<ResolvedValue = T>,
+{
+    type ResolvedValue = Self;
+
+    #[inline]
+    fn to_resolved_value(self, _: &Context) -> Self {
+        self
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self) -> Self {
+        resolved
+    }
+}