blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/values/computed/resolution.rs

@@ -0,0 +1,76 @@
+/* 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/. */
+
+//! Resolution values:
+//!
+//! https://drafts.csswg.org/css-values/#resolution
+
+use crate::derives::*;
+use crate::typed_om::{NumericType, NumericValue, ToTyped, TypedValue, UnitValue};
+use crate::values::CSSFloat;
+use std::{
+    fmt::{self, Write},
+    ops::AddAssign,
+};
+use style_traits::{CssString, CssWriter, ToCss};
+use thin_vec::ThinVec;
+
+/// A computed `<resolution>`.
+#[repr(C)]
+#[derive(
+    Animate,
+    Copy,
+    Clone,
+    Debug,
+    Deserialize,
+    MallocSizeOf,
+    PartialEq,
+    PartialOrd,
+    Serialize,
+    ToAnimatedZero,
+    ToResolvedValue,
+    ToShmem,
+)]
+pub struct Resolution(CSSFloat);
+
+impl Resolution {
+    /// Returns this resolution value as dppx.
+    #[inline]
+    pub fn dppx(&self) -> CSSFloat {
+        self.0
+    }
+
+    /// Return a computed `resolution` value from a dppx float value.
+    #[inline]
+    pub fn from_dppx(dppx: CSSFloat) -> Self {
+        Resolution(dppx)
+    }
+}
+
+impl ToCss for Resolution {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        self.dppx().to_css(dest)?;
+        dest.write_str("dppx")
+    }
+}
+
+impl ToTyped for Resolution {
+    fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        dest.push(TypedValue::Numeric(NumericValue::Unit(UnitValue {
+            numeric_type: NumericType::resolution(),
+            value: self.dppx(),
+            unit: CssString::from("dppx"),
+        })));
+        Ok(())
+    }
+}
+
+impl AddAssign for Resolution {
+    fn add_assign(&mut self, rhs: Self) {
+        self.0 += rhs.0
+    }
+}

package/vendor/stylo/values/computed/svg.rs

@@ -0,0 +1,66 @@
+/* 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/. */
+
+//! Computed types for SVG properties.
+
+use crate::values::computed::color::Color;
+use crate::values::computed::url::ComputedUrl;
+use crate::values::computed::{LengthPercentage, NonNegativeLengthPercentage, Opacity};
+use crate::values::generics::svg as generic;
+use crate::Zero;
+
+pub use crate::values::specified::{DProperty, MozContextProperties, SVGPaintOrder, VectorEffect};
+
+/// Computed SVG Paint value
+pub type SVGPaint = generic::GenericSVGPaint<Color, ComputedUrl>;
+
+/// Computed SVG Paint Kind value
+pub type SVGPaintKind = generic::GenericSVGPaintKind<Color, ComputedUrl>;
+
+impl SVGPaint {
+    /// Opaque black color
+    pub const BLACK: Self = Self {
+        kind: generic::SVGPaintKind::Color(Color::BLACK),
+        fallback: generic::SVGPaintFallback::Unset,
+    };
+}
+
+/// <length> | <percentage> | <number> | context-value
+pub type SVGLength = generic::GenericSVGLength<LengthPercentage>;
+
+impl SVGLength {
+    /// `0px`
+    pub fn zero() -> Self {
+        generic::SVGLength::LengthPercentage(LengthPercentage::zero())
+    }
+}
+
+/// An non-negative wrapper of SVGLength.
+pub type SVGWidth = generic::GenericSVGLength<NonNegativeLengthPercentage>;
+
+impl SVGWidth {
+    /// `1px`.
+    pub fn one() -> Self {
+        use crate::values::generics::NonNegative;
+        generic::SVGLength::LengthPercentage(NonNegative(LengthPercentage::one()))
+    }
+}
+
+/// [ <length> | <percentage> | <number> ]# | context-value
+pub type SVGStrokeDashArray = generic::GenericSVGStrokeDashArray<NonNegativeLengthPercentage>;
+
+impl Default for SVGStrokeDashArray {
+    fn default() -> Self {
+        generic::SVGStrokeDashArray::Values(Default::default())
+    }
+}
+
+/// <opacity-value> | context-fill-opacity | context-stroke-opacity
+pub type SVGOpacity = generic::GenericSVGOpacity<Opacity>;
+
+impl Default for SVGOpacity {
+    fn default() -> Self {
+        generic::SVGOpacity::Opacity(1.)
+    }
+}

package/vendor/stylo/values/computed/table.rs

@@ -0,0 +1,7 @@
+/* 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/. */
+
+//! Computed types for CSS values related to tables.
+
+pub use super::specified::table::CaptionSide;

package/vendor/stylo/values/computed/text.rs

@@ -0,0 +1,199 @@
+/* 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/. */
+
+//! Computed types for text properties.
+
+use crate::derives::*;
+#[cfg(feature = "gecko")]
+use crate::gecko_bindings::bindings;
+use crate::typed_om::{KeywordValue, ToTyped, TypedValue};
+use crate::values::animated::text::TextDecorationInset as AnimatedTextDecorationInset;
+use crate::values::animated::{Context as AnimatedContext, ToAnimatedValue};
+use crate::values::computed::length::{CSSPixelLength, LengthPercentage};
+use crate::values::generics::text::{
+    GenericHyphenateLimitChars, GenericInitialLetter, GenericTextDecorationInset,
+    GenericTextDecorationLength, GenericTextIndent,
+};
+use crate::values::generics::NumberOrAuto;
+use crate::values::specified::text as specified;
+use crate::values::specified::text::{TextEmphasisFillMode, TextEmphasisShapeKeyword};
+use crate::values::{CSSFloat, CSSInteger, ComputeSquaredDistance};
+use crate::Zero;
+use std::fmt::{self, Write};
+use style_traits::{CssString, CssWriter, ToCss};
+use thin_vec::ThinVec;
+
+pub use crate::values::specified::text::{
+    HyphenateCharacter, LineBreak, MozControlCharacterVisibility, OverflowWrap, RubyPosition,
+    TextAlignLast, TextAutospace, TextBoxEdge, TextBoxTrim, TextDecorationLine,
+    TextDecorationSkipInk, TextEmphasisPosition, TextJustify, TextOverflow, TextTransform,
+    TextUnderlinePosition, WordBreak,
+};
+
+/// A computed value for the `initial-letter` property.
+pub type InitialLetter = GenericInitialLetter<CSSFloat, CSSInteger>;
+
+/// Implements type for `text-decoration-thickness` property.
+pub type TextDecorationLength = GenericTextDecorationLength<LengthPercentage>;
+
+/// Implements type for `text-decoration-inset` property.
+pub type TextDecorationInset = GenericTextDecorationInset<LengthPercentage>;
+
+impl ToAnimatedValue for TextDecorationInset {
+    type AnimatedValue = AnimatedTextDecorationInset;
+
+    fn to_animated_value(self, context: &AnimatedContext) -> Self::AnimatedValue {
+        match self {
+            Self::Auto => {
+                let font_size_px = context
+                    .style
+                    .get_font()
+                    .clone_font_size()
+                    .computed_size()
+                    .px();
+                #[cfg(feature = "gecko")]
+                let auto_length = unsafe { bindings::Gecko_CalcAutoDecorationInset(font_size_px) };
+                #[cfg(feature = "servo")]
+                let auto_length = {
+                    // Use an inset factor of 1/12.5, so we get 2px of inset (resulting in 4px
+                    // gap between adjacent lines) at font-size 25px.
+                    let auto_inset_factor = 1.0 / 12.5;
+
+                    // Use the em size multiplied by auto_inset_factor, with a minimum of one
+                    // CSS pixel to ensure that at least some separation occurs.
+                    (font_size_px * auto_inset_factor).max(1.0)
+                };
+                let auto_length = CSSPixelLength::new(auto_length);
+                Self::AnimatedValue {
+                    start: LengthPercentage::new_length(auto_length),
+                    end: LengthPercentage::new_length(auto_length),
+                    is_auto: true,
+                }
+            },
+            Self::LengthPercentage { start, end } => Self::AnimatedValue {
+                start: start.to_animated_value(context),
+                end: end.to_animated_value(context),
+                is_auto: false,
+            },
+        }
+    }
+
+    #[inline]
+    fn from_animated_value(value: Self::AnimatedValue) -> Self {
+        if value.is_auto {
+            Self::Auto
+        } else {
+            Self::LengthPercentage {
+                start: value.start,
+                end: value.end,
+            }
+        }
+    }
+}
+
+/// The computed value of `text-align`.
+pub type TextAlign = specified::TextAlignKeyword;
+
+/// The computed value of `text-indent`.
+pub type TextIndent = GenericTextIndent<LengthPercentage>;
+
+/// A computed value for the `hyphenate-character` property.
+pub type HyphenateLimitChars = GenericHyphenateLimitChars<CSSInteger>;
+
+impl HyphenateLimitChars {
+    /// Return the `auto` value, which has all three component values as `auto`.
+    #[inline]
+    pub fn auto() -> Self {
+        Self {
+            total_word_length: NumberOrAuto::Auto,
+            pre_hyphen_length: NumberOrAuto::Auto,
+            post_hyphen_length: NumberOrAuto::Auto,
+        }
+    }
+}
+
+/// A computed value for the `letter-spacing` property.
+#[repr(transparent)]
+#[derive(
+    Animate,
+    Clone,
+    ComputeSquaredDistance,
+    Copy,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    ToAnimatedValue,
+    ToAnimatedZero,
+    ToResolvedValue,
+)]
+pub struct GenericLetterSpacing<L>(pub L);
+/// This is generic just to make the #[derive()] code do the right thing for lengths.
+pub type LetterSpacing = GenericLetterSpacing<LengthPercentage>;
+
+impl LetterSpacing {
+    /// Return the `normal` computed value, which is just zero.
+    #[inline]
+    pub fn normal() -> Self {
+        Self(LengthPercentage::zero())
+    }
+}
+
+impl ToCss for LetterSpacing {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        // https://drafts.csswg.org/css-text/#propdef-letter-spacing
+        //
+        // For legacy reasons, a computed letter-spacing of zero yields a
+        // resolved value (getComputedStyle() return value) of normal.
+        if self.0.is_zero() {
+            return dest.write_str("normal");
+        }
+        self.0.to_css(dest)
+    }
+}
+
+impl ToTyped for LetterSpacing {
+    // Note: The specification does not currently define how letter spacing
+    // should be reified into Typed OM. The current behavior follows existing
+    // WPT coverage (letter-spacing.html). Syncing spec with UA/WPT behavior
+    // tracked in https://github.com/w3c/csswg-drafts/issues/13907
+    fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        if !self.0.has_percentage() && self.0.is_zero() {
+            dest.push(TypedValue::Keyword(KeywordValue(CssString::from("normal"))));
+            return Ok(());
+        }
+        self.0.to_typed(dest)
+    }
+}
+
+/// A computed value for the `word-spacing` property.
+pub type WordSpacing = LengthPercentage;
+
+impl WordSpacing {
+    /// Return the `normal` computed value, which is just zero.
+    #[inline]
+    pub fn normal() -> Self {
+        LengthPercentage::zero()
+    }
+}
+
+/// Computed value for the text-emphasis-style property
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToCss, ToResolvedValue, ToTyped)]
+#[allow(missing_docs)]
+#[repr(C, u8)]
+#[typed(todo_derive_fields)]
+pub enum TextEmphasisStyle {
+    /// [ <fill> || <shape> ]
+    Keyword {
+        #[css(skip_if = "TextEmphasisFillMode::is_filled")]
+        fill: TextEmphasisFillMode,
+        shape: TextEmphasisShapeKeyword,
+    },
+    /// `none`
+    None,
+    /// `<string>` (of which only the first grapheme cluster will be used).
+    String(crate::OwnedStr),
+}

package/vendor/stylo/values/computed/time.rs

@@ -0,0 +1,83 @@
+/* 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/. */
+
+//! Computed time values.
+
+use crate::derives::*;
+use crate::typed_om::{NumericType, NumericValue, ToTyped, TypedValue, UnitValue};
+use crate::values::CSSFloat;
+use crate::Zero;
+use std::fmt::{self, Write};
+use std::ops::AddAssign;
+use style_traits::{CssString, CssWriter, ToCss};
+use thin_vec::ThinVec;
+
+/// A computed `<time>` value.
+#[derive(
+    Animate,
+    Clone,
+    Copy,
+    Debug,
+    Deserialize,
+    MallocSizeOf,
+    PartialEq,
+    PartialOrd,
+    Serialize,
+    ToAnimatedZero,
+    ToResolvedValue,
+)]
+#[repr(C)]
+pub struct Time {
+    seconds: CSSFloat,
+}
+
+impl Time {
+    /// Creates a time value from a seconds amount.
+    pub fn from_seconds(seconds: CSSFloat) -> Self {
+        Time { seconds }
+    }
+
+    /// Returns the amount of seconds this time represents.
+    #[inline]
+    pub fn seconds(&self) -> CSSFloat {
+        self.seconds
+    }
+}
+
+impl ToCss for Time {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        self.seconds().to_css(dest)?;
+        dest.write_char('s')
+    }
+}
+
+impl ToTyped for Time {
+    fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        dest.push(TypedValue::Numeric(NumericValue::Unit(UnitValue {
+            numeric_type: NumericType::time(),
+            value: self.seconds(),
+            unit: CssString::from("s"),
+        })));
+        Ok(())
+    }
+}
+
+impl Zero for Time {
+    fn zero() -> Self {
+        Self::from_seconds(0.0)
+    }
+
+    fn is_zero(&self) -> bool {
+        self.seconds == 0.
+    }
+}
+
+impl AddAssign for Time {
+    fn add_assign(&mut self, rhs: Self) {
+        self.seconds += rhs.seconds
+    }
+}