blitz-pdf 0.1.2 → 0.1.4

package/vendor/blitz-dom/src/stylo_device.rs

@@ -0,0 +1,88 @@
+//! Management of the Stylo [`Device`]: constructing it from shell state and
+//! coalescing changes to it (viewport resizes, zoom, color-scheme and media
+//! type changes) so that the stylist device is rebuilt at most once per
+//! [`resolve`](crate::BaseDocument::resolve), no matter how many changes
+//! occurred since the last resolve.
+
+use std::sync::{Arc, Mutex};
+
+use bitflags::bitflags;
+use blitz_traits::shell::{ColorScheme, Viewport};
+use parley::FontContext;
+use selectors::matching::QuirksMode;
+use style::device::Device;
+use style::media_queries::MediaType;
+use style::properties::ComputedValues;
+use style::properties::style_structs::Font;
+use style::queries::values::PrefersColorScheme;
+use style::servo::media_features::PointerCapabilities;
+
+use crate::font_metrics::BlitzFontMetricsProvider;
+
+bitflags! {
+    /// The set of changes to the [`Device`] that have accumulated since the
+    /// stylist device was last rebuilt. Only the *latest* values matter (they
+    /// live on [`BaseDocument`](crate::BaseDocument)); these flags record
+    /// which kinds of change occurred so that the flush can do the right
+    /// amount of invalidation work.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+    pub(crate) struct DeviceChanges: u8 {
+        /// The CSS pixel viewport size changed (window resize, zoom, or hidpi
+        /// scale change).
+        const VIEWPORT_SIZE = 0b0000_0001;
+        /// The total scale factor (hidpi scale * zoom) changed. Requires
+        /// invalidating cached inline layouts (text is shaped at a specific
+        /// scale) and a redraw.
+        const SCALE = 0b0000_0010;
+        /// The preferred color scheme changed.
+        const COLOR_SCHEME = 0b0000_0100;
+        /// The media type (e.g. screen/print) changed.
+        const MEDIA_TYPE = 0b0000_1000;
+    }
+}
+
+impl DeviceChanges {
+    /// Compute the [`DeviceChanges`] implied by moving from viewport `old` to
+    /// viewport `new`.
+    pub(crate) fn from_viewports(old: &Viewport, new: &Viewport) -> Self {
+        let mut changes = Self::empty();
+        if old.logical_size() != new.logical_size() {
+            changes |= Self::VIEWPORT_SIZE;
+        }
+        if old.scale_f64() != new.scale_f64() {
+            changes |= Self::SCALE;
+        }
+        if old.color_scheme != new.color_scheme {
+            changes |= Self::COLOR_SCHEME;
+        }
+        changes
+    }
+}
+
+pub(crate) fn make_device(
+    viewport: &Viewport,
+    layout_viewport: Option<(f32, f32)>,
+    media_type: MediaType,
+    font_ctx: Arc<Mutex<FontContext>>,
+) -> Device {
+    let (width, height) = layout_viewport.unwrap_or_else(|| viewport.logical_size());
+    let viewport_size = euclid::Size2D::new(width, height);
+    let device_size = euclid::Size2D::new(width, height) * viewport.scale();
+    let device_pixel_ratio = euclid::Scale::new(viewport.scale());
+
+    Device::new(
+        media_type,
+        QuirksMode::NoQuirks,
+        viewport_size,
+        device_size,
+        device_pixel_ratio,
+        Box::new(BlitzFontMetricsProvider { font_ctx }),
+        ComputedValues::initial_values_with_font_override(Font::initial_values()),
+        match viewport.color_scheme {
+            ColorScheme::Light => PrefersColorScheme::Light,
+            ColorScheme::Dark => PrefersColorScheme::Dark,
+        },
+        PointerCapabilities::default(),
+        PointerCapabilities::default(),
+    )
+}

package/vendor/blitz-dom/src/stylo_to_cursor_icon.rs

@@ -0,0 +1,49 @@
+use cursor_icon::CursorIcon;
+use style::values::computed::ui::CursorKind as StyloCursorKind;
+
+pub(crate) fn stylo_to_cursor_icon(cursor: StyloCursorKind) -> Option<CursorIcon> {
+    match cursor {
+        // Auto needs special handling so this function should only really be called with
+        // non-Auto values. But better to return a default than panic if it is.
+        StyloCursorKind::Auto => {
+            #[cfg(feature = "tracing")]
+            tracing::warn!("stylo_to_cursor_icon was called with CursorKind::Auto");
+            Some(CursorIcon::Default)
+        }
+        StyloCursorKind::None => None,
+        StyloCursorKind::Default => Some(CursorIcon::Default),
+        StyloCursorKind::Pointer => Some(CursorIcon::Pointer),
+        StyloCursorKind::ContextMenu => Some(CursorIcon::ContextMenu),
+        StyloCursorKind::Help => Some(CursorIcon::Help),
+        StyloCursorKind::Progress => Some(CursorIcon::Progress),
+        StyloCursorKind::Wait => Some(CursorIcon::Wait),
+        StyloCursorKind::Cell => Some(CursorIcon::Cell),
+        StyloCursorKind::Crosshair => Some(CursorIcon::Crosshair),
+        StyloCursorKind::Text => Some(CursorIcon::Text),
+        StyloCursorKind::VerticalText => Some(CursorIcon::VerticalText),
+        StyloCursorKind::Alias => Some(CursorIcon::Alias),
+        StyloCursorKind::Copy => Some(CursorIcon::Copy),
+        StyloCursorKind::Move => Some(CursorIcon::Move),
+        StyloCursorKind::NoDrop => Some(CursorIcon::NoDrop),
+        StyloCursorKind::NotAllowed => Some(CursorIcon::NotAllowed),
+        StyloCursorKind::Grab => Some(CursorIcon::Grab),
+        StyloCursorKind::Grabbing => Some(CursorIcon::Grabbing),
+        StyloCursorKind::EResize => Some(CursorIcon::EResize),
+        StyloCursorKind::NResize => Some(CursorIcon::NResize),
+        StyloCursorKind::NeResize => Some(CursorIcon::NeResize),
+        StyloCursorKind::NwResize => Some(CursorIcon::NwResize),
+        StyloCursorKind::SResize => Some(CursorIcon::SResize),
+        StyloCursorKind::SeResize => Some(CursorIcon::SeResize),
+        StyloCursorKind::SwResize => Some(CursorIcon::SwResize),
+        StyloCursorKind::WResize => Some(CursorIcon::WResize),
+        StyloCursorKind::EwResize => Some(CursorIcon::EwResize),
+        StyloCursorKind::NsResize => Some(CursorIcon::NsResize),
+        StyloCursorKind::NeswResize => Some(CursorIcon::NeswResize),
+        StyloCursorKind::NwseResize => Some(CursorIcon::NwseResize),
+        StyloCursorKind::ColResize => Some(CursorIcon::ColResize),
+        StyloCursorKind::RowResize => Some(CursorIcon::RowResize),
+        StyloCursorKind::AllScroll => Some(CursorIcon::AllScroll),
+        StyloCursorKind::ZoomIn => Some(CursorIcon::ZoomIn),
+        StyloCursorKind::ZoomOut => Some(CursorIcon::ZoomOut),
+    }
+}

package/vendor/blitz-dom/src/stylo_to_kurbo.rs

@@ -0,0 +1,129 @@
+use euclid::default::Rect;
+use kurbo::{Affine, Vec2};
+use style::{
+    properties::generated::style_structs::Box as BoxStyleStruct,
+    values::{
+        computed::{CSSPixelLength, Rotate},
+        generics::transform::{Scale, Translate},
+    },
+};
+
+// 6. Current Transformation Matrix
+//
+// The transformation matrix is computed from the transform, transform-origin, translate, rotate, scale, and offset properties as follows:
+//
+//   - Start with the identity matrix.
+//   - Translate by the computed X, Y, and Z values of transform-origin.
+//   - Translate by the computed X, Y, and Z values of translate.
+//   - Rotate by the computed <angle> about the specified axis of rotate.
+//   - Scale by the computed X, Y, and Z values of scale.
+//   - Translate and rotate by the transform specified by offset.
+//   - Multiply by each of the transform functions in transform from left to right.
+//   - Translate by the negated computed X, Y and Z values of transform-origin.
+//
+// <https://drafts.csswg.org/css-transforms-2/#ctm>
+pub fn resolve_2d_transform(
+    box_styles: &BoxStyleStruct,
+    reference_box: Rect<CSSPixelLength>,
+) -> Option<Affine> {
+    let translate = match &box_styles.translate {
+        Translate::None => None,
+        Translate::Translate(x, y, _z) => Some(Vec2 {
+            x: x.resolve(reference_box.width()).px() as f64,
+            y: y.resolve(reference_box.height()).px() as f64,
+        }),
+    };
+
+    let rotate = match &box_styles.rotate {
+        Rotate::None => None,
+        Rotate::Rotate(angle) => Some(angle.radians64()),
+        // A rotation about the z axis stays in the plane; the sign of the
+        // axis component decides the direction, its magnitude cancels out.
+        Rotate::Rotate3D(x, y, z, angle) if *x == 0.0 && *y == 0.0 && *z != 0.0 => {
+            Some(angle.radians64() * z.signum() as f64)
+        }
+        // TODO: support 3D transforms
+        Rotate::Rotate3D(_, _, _, _) => None,
+    };
+
+    let scale_transform = match &box_styles.scale {
+        Scale::None => None,
+        Scale::Scale(x, y, _z) => Some(Vec2 {
+            x: *x as f64,
+            y: *y as f64,
+        }),
+    };
+
+    let transform = if box_styles.transform.0.is_empty() {
+        None
+    } else {
+        box_styles
+            .transform
+            .to_transform_3d_matrix(Some(&reference_box))
+            .ok()
+            // The `has_3d` flag means a 3d function appeared in the list, not that the
+            // matrix needs 3d: `translate3d(x, y, 0)` sets it while resolving to a
+            // plain 2d translation.
+            //
+            // TODO: support 3D transforms. Outside a 3d rendering context the spec
+            // still applies the transform as a painting effect -- its own example
+            // paints `rotateY(50deg)` narrower -- so dropping one is wrong. `is_2d()`
+            // is closer than the flag, not the rule.
+            // See: https://drafts.csswg.org/css-transforms-2/#3d-transform-rendering
+            .filter(|(t, _has_3d)| t.is_2d())
+            .map(|(t, _)| {
+                // See: https://drafts.csswg.org/css-transforms-2/#two-dimensional-subset
+                // And https://docs.rs/kurbo/latest/kurbo/struct.Affine.html#method.new
+                Affine::new([t.m11, t.m12, t.m21, t.m22, t.m41, t.m42].map(|v| v as f64))
+            })
+    };
+
+    // TODO: support the "offset" property
+    // <https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/offset>
+
+    if translate.is_none() && rotate.is_none() && scale_transform.is_none() && transform.is_none() {
+        return None;
+    }
+
+    // Apply the transform origin by:
+    //   - Translating by the origin offset
+    //   - Applying our transform
+    //   - Translating by the inverse of the origin offset
+    let transform_origin = &box_styles.transform_origin;
+    let origin_translation = Affine::translate(Vec2 {
+        x: transform_origin
+            .horizontal
+            .resolve(reference_box.width())
+            .px() as f64,
+        y: transform_origin
+            .vertical
+            .resolve(reference_box.height())
+            .px() as f64,
+    });
+
+    let mut resolved = Affine::IDENTITY;
+
+    if let Some(translation) = translate {
+        resolved *= Affine::translate(translation)
+    }
+
+    if let Some(rotation) = rotate {
+        resolved *= Affine::rotate(rotation)
+    }
+
+    if let Some(scale_transform) = scale_transform {
+        resolved *= Affine::scale_non_uniform(scale_transform.x, scale_transform.y)
+    }
+
+    if let Some(transform) = transform {
+        resolved *= transform;
+    }
+
+    resolved = origin_translation * resolved * origin_translation.inverse();
+
+    if resolved != Affine::IDENTITY {
+        Some(resolved)
+    } else {
+        None
+    }
+}