blitz-pdf 0.1.5 → 0.1.6

package/vendor/blitz-paint/src/render/form_controls.rs

@@ -0,0 +1,103 @@
+use super::ElementCx;
+use crate::color::{Color, ToColorColor as _};
+use anyrender::PaintScene;
+use blitz_dom::local_name;
+use kurbo::{Affine, BezPath, Cap, Circle, Join, Point, RoundedRect, Stroke, Vec2};
+use peniko::Fill;
+use style::dom::TElement as _;
+
+impl ElementCx<'_, '_> {
+    pub(super) fn draw_input(&self, scene: &mut impl PaintScene) {
+        if self.node.local_name() != "input" {
+            return;
+        }
+        let Some(checked) = self.element.checkbox_input_checked() else {
+            return;
+        };
+
+        let type_attr = self.node.attr(local_name!("type"));
+        let disabled = self.node.attr(local_name!("disabled")).is_some();
+
+        // TODO this should be coming from css accent-color, but I couldn't find how to retrieve it
+        let accent_color = if disabled {
+            Color::from_rgba8(209, 209, 209, 255)
+        } else {
+            self.style.clone_color().as_srgb_color()
+        };
+
+        let width = self.frame.border_box.width();
+        let height = self.frame.border_box.height();
+        let min_dimension = width.min(height);
+        let scale = (min_dimension - 4.0).max(0.0) / 16.0;
+
+        let frame = self.frame.border_box.to_rounded_rect(scale * 2.0);
+
+        match type_attr {
+            Some("checkbox") => {
+                draw_checkbox(scene, checked, frame, self.transform, accent_color, scale);
+            }
+            Some("radio") => {
+                let center = frame.center();
+                draw_radio_button(scene, checked, center, self.transform, accent_color, scale);
+            }
+            _ => {}
+        }
+    }
+}
+
+fn draw_checkbox(
+    scene: &mut impl PaintScene,
+    checked: bool,
+    frame: RoundedRect,
+    transform: Affine,
+    accent_color: Color,
+    scale: f64,
+) {
+    if checked {
+        scene.fill(Fill::NonZero, transform, accent_color, None, &frame);
+        //Tick code derived from masonry
+        let mut path = BezPath::new();
+        path.move_to((2.0, 9.0));
+        path.line_to((6.0, 13.0));
+        path.line_to((14.0, 2.0));
+
+        path.apply_affine(Affine::translate(Vec2 { x: 2.0, y: 1.0 }).then_scale(scale));
+
+        let style = Stroke {
+            width: 2.0 * scale,
+            join: Join::Round,
+            miter_limit: 10.0,
+            start_cap: Cap::Round,
+            end_cap: Cap::Round,
+            dash_pattern: Default::default(),
+            dash_offset: 0.0,
+        };
+
+        scene.stroke(&style, transform, Color::WHITE, None, &path);
+    } else {
+        scene.fill(Fill::NonZero, transform, Color::WHITE, None, &frame);
+        scene.stroke(&Stroke::default(), transform, accent_color, None, &frame);
+    }
+}
+
+fn draw_radio_button(
+    scene: &mut impl PaintScene,
+    checked: bool,
+    center: Point,
+    transform: Affine,
+    accent_color: Color,
+    scale: f64,
+) {
+    let outer_ring = Circle::new(center, 8.0 * scale);
+    let gap = Circle::new(center, 6.0 * scale);
+    let inner_circle = Circle::new(center, 4.0 * scale);
+    if checked {
+        scene.fill(Fill::NonZero, transform, accent_color, None, &outer_ring);
+        scene.fill(Fill::NonZero, transform, Color::WHITE, None, &gap);
+        scene.fill(Fill::NonZero, transform, accent_color, None, &inner_circle);
+    } else {
+        const GRAY: Color = color::palette::css::GRAY;
+        scene.fill(Fill::NonZero, transform, GRAY, None, &outer_ring);
+        scene.fill(Fill::NonZero, transform, Color::WHITE, None, &gap);
+    }
+}

package/vendor/blitz-paint/src/render/mask.rs

@@ -0,0 +1,144 @@
+//! Rendering for the CSS `mask` properties (`mask-image`, `mask-position`,
+//! `mask-size`, `mask-repeat`, `mask-clip`, `mask-origin`).
+//!
+//! Masks are applied by:
+//!
+//!  1. Pushing an isolation layer (clipped to the mask painting area) before the
+//!     element is painted
+//!  2. Painting the element (and its descendants) as normal
+//!  3. Pushing a `Compose::DestIn` layer and drawing the mask image layers into it,
+//!     which multiplies the alpha of the already-painted element by the alpha of
+//!     the mask
+//!  4. Popping both layers
+//!
+//! The mask image layers themselves are positioned/sized/repeated using the same
+//! code as `background-image` layers (see `background.rs`), as the `mask-*` and
+//! `background-*` properties share computed value types.
+use crate::render::background::get_cyclic;
+
+use super::ElementCx;
+use super::background::ImageLayerStyles;
+use anyrender::PaintScene;
+use peniko::{BlendMode, Compose, Fill, Mix};
+use style::properties::generated::longhands::mask_composite::single_value::computed_value::T as StyloMaskComposite;
+use style::values::generics::image::GenericImage;
+
+#[cfg(feature = "tracing")]
+use tracing::warn;
+
+/// An opacity just below 1.0, used to force the renderer to allocate an isolated
+/// buffer for the mask isolation layer. Renderers (e.g. vello_cpu) may optimize
+/// layers with `Mix::Normal`/`Compose::SrcOver` and an opacity of exactly 1.0 into
+/// plain non-isolated clip layers, in which case the `Compose::DestIn` mask
+/// compositing would erase the backdrop behind the element rather than just the
+/// element's own content.
+const ALMOST_OPAQUE: f32 = 1.0 - f32::EPSILON;
+
+impl ElementCx<'_, '_> {
+    /// Whether the element has any CSS `mask-image` layers
+    pub(super) fn has_css_mask(&self) -> bool {
+        self.style
+            .get_svg()
+            .mask_image
+            .0
+            .iter()
+            .any(|image| !matches!(image, GenericImage::None))
+    }
+
+    /// If the element has a CSS mask, push an isolation layer for the masked content
+    /// to be drawn into. Returns whether a layer was pushed, which should later be
+    /// passed to [`maybe_pop_css_mask_layer`](Self::maybe_pop_css_mask_layer).
+    pub(super) fn maybe_push_css_mask_layer(&self, scene: &mut impl PaintScene) -> bool {
+        if !self.has_css_mask() {
+            return false;
+        }
+
+        // Content outside of the mask painting area (at largest the border box) has
+        // a mask alpha of 0, so we can clip the isolation layer to the border box.
+        scene.push_layer(
+            Fill::NonZero,
+            Mix::Normal,
+            ALMOST_OPAQUE,
+            self.transform,
+            &self.frame.border_box_path(),
+            None,
+            None,
+        );
+        true
+    }
+
+    /// Apply the CSS mask to the content drawn since the corresponding
+    /// [`maybe_push_css_mask_layer`](Self::maybe_push_css_mask_layer) by drawing the
+    /// mask image layers with `Compose::DestIn`, then pop the isolation layer.
+    pub(super) fn maybe_pop_css_mask_layer(&self, scene: &mut impl PaintScene, layer_pushed: bool) {
+        if !layer_pushed {
+            return;
+        }
+
+        scene.push_layer(
+            Fill::NonZero,
+            BlendMode::new(Mix::Normal, Compose::DestIn),
+            1.0,
+            self.transform,
+            &self.frame.border_box_path(),
+            None,
+            None,
+        );
+        self.draw_css_mask(scene);
+        scene.pop_layer(); // Mask (DestIn) layer
+        scene.pop_layer(); // Isolation layer
+    }
+
+    /// Draw the mask image layers (analogous to `draw_background` for `background-image`)
+    fn draw_css_mask(&self, scene: &mut impl PaintScene) {
+        let svg_styles = self.style.get_svg();
+        let image_data = &self.element.mask_images;
+        let layer_count = svg_styles.mask_image.0.len();
+
+        for idx in (0..layer_count).rev() {
+            let layer = ImageLayerStyles::from_svg(svg_styles, image_data, idx);
+            let mask_clip_path = self.box_path(layer.clip);
+
+            // TODO: support `mask-mode: luminance` (luminance masks are currently
+            // rendered as alpha masks).
+            #[cfg(feature = "tracing")]
+            {
+                use style::properties::generated::longhands::mask_mode::single_value::computed_value::T as StyloMaskMode;
+                let mask_mode = &svg_styles.mask_mode.0;
+                if matches!(get_cyclic(&mask_mode, idx), StyloMaskMode::Luminance) {
+                    warn!("mask-mode: luminance is not supported (falling back to alpha)");
+                }
+            }
+
+            // Each mask layer is composited with the (already drawn) layers below it
+            // using the Porter-Duff operator given by its `mask-composite` value. The
+            // bottommost layer has no layers below it and is always drawn with SrcOver.
+            let compose = if idx == layer_count - 1 {
+                Compose::SrcOver
+            } else {
+                let composite_list = &svg_styles.mask_composite.0;
+                match get_cyclic(composite_list, idx) {
+                    StyloMaskComposite::Add => Compose::SrcOver,
+                    StyloMaskComposite::Subtract => Compose::SrcOut,
+                    StyloMaskComposite::Intersect => Compose::SrcIn,
+                    StyloMaskComposite::Exclude => Compose::Xor,
+                }
+            };
+
+            // The layer is pushed unconditionally (even for `mask-image: none` layers,
+            // which draw nothing) as compositing a transparent black layer with e.g.
+            // `intersect` clears the mask built up so far.
+            scene.push_layer(
+                Fill::NonZero,
+                BlendMode::new(Mix::Normal, compose),
+                1.0,
+                self.transform,
+                &mask_clip_path,
+                None,
+                None,
+            );
+            self.draw_image_layer(scene, &layer);
+            scene.pop_layer();
+        }
+    }
+}