blitz-pdf 0.1.4 → 0.1.6

package/vendor/blitz-paint/src/kurbo_css/mod.rs

@@ -0,0 +1,77 @@
+//! A rounded rect closer to the browser
+//! Implemented in such a way that splits the border into 4 parts at the midway of each radius
+//!
+//! This object is meant to be updated only when the data changes - BezPaths are expensive!
+//!
+//! Can I just say, this is a lot of work for a border
+//! HTML/css is annoyingly wild
+
+use kurbo::{Insets, Vec2};
+
+mod css_box;
+mod non_uniform_radii;
+
+pub use css_box::CssBox;
+pub use non_uniform_radii::NonUniformRoundedRectRadii;
+
+#[derive(Debug, Clone, Copy)]
+pub enum Edge {
+    Top,
+    Right,
+    Bottom,
+    Left,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum Corner {
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(clippy::enum_variant_names, reason = "Use CSS standard terminology")]
+pub(crate) enum CssBoxKind {
+    OutlineBox,
+    BorderBox,
+    PaddingBox,
+    ContentBox,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum Direction {
+    Clockwise,
+    Anticlockwise,
+}
+
+fn add_insets(a: Insets, b: Insets) -> Insets {
+    Insets {
+        x0: a.x0 + b.x0,
+        y0: a.y0 + b.y0,
+        x1: a.x1 + b.x1,
+        y1: a.y1 + b.y1,
+    }
+}
+
+#[inline(always)]
+fn get_corner_insets(insets: Insets, corner: Corner) -> Vec2 {
+    match corner {
+        Corner::TopLeft => Vec2 {
+            x: insets.x0,
+            y: insets.y0,
+        },
+        Corner::TopRight => Vec2 {
+            x: insets.x1,
+            y: insets.y0,
+        },
+        Corner::BottomLeft => Vec2 {
+            x: insets.x0,
+            y: insets.y1,
+        },
+        Corner::BottomRight => Vec2 {
+            x: insets.x1,
+            y: insets.y1,
+        },
+    }
+}

package/vendor/blitz-paint/src/kurbo_css/non_uniform_radii.rs

@@ -0,0 +1,60 @@
+use kurbo::Vec2;
+use std::ops::{Mul, MulAssign};
+
+/// Radii for each corner of a non-uniform rounded rectangle.
+///
+/// The use of `top` as in `top_left` assumes a y-down coordinate space. Piet
+/// (and Druid by extension) uses a y-down coordinate space, but Kurbo also
+/// supports a y-up coordinate space, in which case `top_left` would actually
+/// refer to the bottom-left corner, and vice versa. Top may not always
+/// actually be the top, but `top` corners will always have a smaller y-value
+/// than `bottom` corners.
+#[derive(Clone, Copy, Default, Debug, PartialEq)]
+// #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+// #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct NonUniformRoundedRectRadii {
+    /// The radii of the top-left corner.
+    pub top_left: Vec2,
+    /// The radii of the top-right corner.
+    pub top_right: Vec2,
+    /// The radii of the bottom-right corner.
+    pub bottom_right: Vec2,
+    /// The radii of the bottom-left corner.
+    pub bottom_left: Vec2,
+}
+
+impl NonUniformRoundedRectRadii {
+    pub fn average(&self) -> f64 {
+        (self.top_left.x
+            + self.top_left.y
+            + self.top_right.x
+            + self.top_right.y
+            + self.bottom_left.x
+            + self.bottom_left.y
+            + self.bottom_right.x
+            + self.bottom_right.y)
+            / 8.0
+    }
+}
+
+impl Mul<f64> for NonUniformRoundedRectRadii {
+    type Output = Self;
+
+    fn mul(self, rhs: f64) -> Self::Output {
+        Self {
+            top_left: self.top_left * rhs,
+            top_right: self.top_right * rhs,
+            bottom_right: self.bottom_right * rhs,
+            bottom_left: self.bottom_left * rhs,
+        }
+    }
+}
+
+impl MulAssign<f64> for NonUniformRoundedRectRadii {
+    fn mul_assign(&mut self, rhs: f64) {
+        self.top_left *= rhs;
+        self.top_right *= rhs;
+        self.bottom_left *= rhs;
+        self.bottom_right *= rhs;
+    }
+}

package/vendor/blitz-paint/src/layers.rs

@@ -0,0 +1,95 @@
+use anyrender::{Filter, PaintScene};
+use kurbo::{Affine, Shape};
+use peniko::{Fill, Mix};
+use std::{cell::Cell, sync::Arc};
+
+const LAYER_LIMIT: u32 = 1024;
+
+#[derive(Default)]
+pub(crate) struct LayerManager {
+    layers_used: Cell<u32>,
+    layer_depth: Cell<u32>,
+    layers_wanted: Cell<u32>,
+
+    #[allow(unused)] // Only used for debugging. Enabled as required.
+    layer_depth_used: Cell<u32>,
+}
+
+impl LayerManager {
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn maybe_with_layer<S: PaintScene, F: FnOnce(&mut S)>(
+        &self,
+        scene: &mut S,
+        condition: bool,
+        opacity: f32,
+        transform: Affine,
+        shape: &impl Shape,
+        filter: Option<Arc<Filter>>,
+        backdrop_filter: Option<Arc<Filter>>,
+        paint_layer: F,
+    ) {
+        let layer_used = self.maybe_push_layer(
+            scene,
+            condition,
+            opacity,
+            transform,
+            shape,
+            filter,
+            backdrop_filter,
+        );
+        paint_layer(scene);
+        self.maybe_pop_layer(scene, layer_used);
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn maybe_push_layer(
+        &self,
+        scene: &mut impl PaintScene,
+        condition: bool,
+        opacity: f32,
+        transform: Affine,
+        shape: &impl Shape,
+        filter: Option<Arc<Filter>>,
+        backdrop_filter: Option<Arc<Filter>>,
+    ) -> bool {
+        if !condition {
+            return false;
+        }
+        self.layers_wanted.update(|x| x + 1);
+
+        // Check if clips are above limit
+        let layers_available = self.layers_used.get() <= LAYER_LIMIT;
+        if !layers_available {
+            return false;
+        }
+
+        // Actually push the layer
+        if opacity == 1.0 && filter.is_none() && backdrop_filter.is_none() {
+            scene.push_clip_layer(Fill::NonZero, transform, shape);
+        } else {
+            scene.push_layer(
+                Fill::NonZero,
+                Mix::Normal,
+                opacity,
+                transform,
+                shape,
+                filter,
+                backdrop_filter,
+            );
+        };
+
+        // Update accounting
+        self.layers_used.update(|x| x + 1);
+        self.layer_depth.update(|x| x + 1);
+        self.layer_depth.update(|x| x.max(self.layer_depth.get()));
+
+        true
+    }
+
+    pub(crate) fn maybe_pop_layer(&self, scene: &mut impl PaintScene, condition: bool) {
+        if condition {
+            scene.pop_layer();
+            self.layer_depth.update(|x| x - 1);
+        }
+    }
+}

package/vendor/blitz-paint/src/lib.rs

@@ -0,0 +1,190 @@
+//! Paint a [`blitz_dom::BaseDocument`] by pushing [`anyrender`] drawing commands into
+//! an impl [`anyrender::PaintScene`].
+
+#![allow(clippy::collapsible_if)]
+
+mod color;
+mod debug_overlay;
+mod filters;
+mod gradient;
+mod kurbo_css;
+mod layers;
+mod render;
+mod sizing;
+mod text;
+
+use std::{cell::RefCell, collections::HashMap};
+
+use anyrender::{PaintScene, Scene};
+use blitz_dom::{BaseDocument, NodeId, util::Color};
+use render::BlitzDomPainter;
+
+const FONT_EMBOLDEN_ENABLED: bool = cfg!(any(
+    feature = "font-embolden",
+    all(feature = "apple-font-embolden", target_os = "macos"),
+    all(feature = "apple-font-embolden", target_os = "ios"),
+));
+
+/// The default color for text selection highlights
+const SELECTION_COLOR: Color = Color::from_rgb8(180, 213, 255);
+
+/// Pre-computed `Scene`s for each CustomWidget, keyed by `(document id, node id)`
+type CustomWidgetSceneMap = HashMap<(usize, NodeId), Scene>;
+
+/// Receives each text layout immediately before its glyphs are painted, in paint
+/// order. Vector exporters can retain Unicode and cluster mappings without
+/// attempting to identify source text from glyph shapes or DOM traversal order.
+pub trait TextObserver {
+    fn observe(&mut self, layout: &parley::Layout<blitz_dom::node::TextBrush>, text: &str);
+}
+
+/// Paint a [`blitz_dom::BaseDocument`] by pushing drawing commands into
+/// an impl [`anyrender::PaintScene`].
+///
+/// This function assumes that the styles and layout in the [`BaseDocument`] are already
+/// resolved. Please ensure that this is the case before trying to paint.
+///
+/// The implementation of [`PaintScene`] is responsible for handling the commands that are pushed into it.
+/// Generally this will involve executing them to draw a rasterized image/texture. But in some cases it may choose to
+/// transform them to a vector format (e.g. SVG/PDF) or serialize them in raw form for later use.
+pub fn paint_scene(
+    scene: &mut impl PaintScene,
+    doc: &mut BaseDocument,
+    scale: f64,
+    width: u32,
+    height: u32,
+    x_offset: u32,
+    y_offset: u32,
+) {
+    paint_scene_impl(scene, doc, scale, width, height, x_offset, y_offset, None);
+}
+
+/// Paint with source text notifications. The observer is also forwarded to
+/// subdocuments. Existing raster backends can continue using [`paint_scene`].
+#[allow(clippy::too_many_arguments)]
+pub fn paint_scene_with_text(
+    scene: &mut impl PaintScene,
+    doc: &mut BaseDocument,
+    scale: f64,
+    width: u32,
+    height: u32,
+    x_offset: u32,
+    y_offset: u32,
+    observer: &RefCell<dyn TextObserver>,
+) {
+    paint_scene_impl(
+        scene,
+        doc,
+        scale,
+        width,
+        height,
+        x_offset,
+        y_offset,
+        Some(observer),
+    );
+}
+
+#[allow(clippy::too_many_arguments)]
+fn paint_scene_impl(
+    scene: &mut impl PaintScene,
+    doc: &mut BaseDocument,
+    scale: f64,
+    width: u32,
+    height: u32,
+    x_offset: u32,
+    y_offset: u32,
+    observer: Option<&RefCell<dyn TextObserver>>,
+) {
+    // Run `.paint()` on every custom widget in the document (and all subdocuments) ahead of time.
+    // This helps us avoid borrow-checker issues as we recurse down the tree (`.paint()` require `&mut self`).
+    //
+    // TODO: Take widget and sub-document visibility into account
+    #[allow(unused_mut)]
+    let mut custom_widget_scenes: CustomWidgetSceneMap = HashMap::new();
+    #[cfg(feature = "custom-widget")]
+    build_custom_widget_scenes(&mut custom_widget_scenes, doc, scene, scale);
+
+    let generator = BlitzDomPainter::new(
+        doc,
+        scale,
+        width,
+        height,
+        x_offset as f64,
+        y_offset as f64,
+        &custom_widget_scenes,
+        observer,
+    );
+    generator.paint_scene(scene);
+
+    // println!(
+    //     "Rendered using {} clips (depth: {}) (wanted: {})",
+    //     CLIPS_USED.load(atomic::Ordering::SeqCst),
+    //     CLIP_DEPTH_USED.load(atomic::Ordering::SeqCst),
+    //     CLIPS_WANTED.load(atomic::Ordering::SeqCst)
+    // );
+}
+
+#[cfg(feature = "custom-widget")]
+fn build_custom_widget_scenes(
+    custom_widget_scenes: &mut CustomWidgetSceneMap,
+    doc: &mut BaseDocument,
+    render_ctx: &mut impl anyrender::RenderContext,
+    scale: f64,
+) {
+    let doc_id = doc.id();
+
+    // Process scenes for every custom widget in the document
+    let custom_widget_node_ids = doc.custom_widget_node_ids();
+    for node_id in custom_widget_node_ids.into_iter() {
+        if let Some(scene) = process_custom_widget_node(doc, render_ctx, node_id, scale) {
+            custom_widget_scenes.insert((doc_id, node_id), scene);
+        }
+    }
+
+    // Recurse into sub documents
+    let sub_document_node_ids = doc.sub_document_node_ids();
+    for node_id in sub_document_node_ids.into_iter() {
+        if let Some(sub_doc) = doc.get_node_mut(node_id).and_then(|node| node.subdoc_mut()) {
+            let mut inner = sub_doc.inner_mut();
+            build_custom_widget_scenes(custom_widget_scenes, &mut inner, render_ctx, scale);
+        }
+    }
+}
+
+#[cfg(feature = "custom-widget")]
+fn process_custom_widget_node(
+    doc: &mut BaseDocument,
+    render_ctx: &mut impl anyrender::RenderContext,
+    node_id: NodeId,
+    scale: f64,
+) -> Option<Scene> {
+    use blitz_dom::node::{CustomWidgetStatus, ProxyRenderContext};
+
+    let node = doc.get_node_mut(node_id)?;
+    let width = (node.final_layout().size.width as f64 * scale) as u32;
+    let height = (node.final_layout().size.height as f64 * scale) as u32;
+
+    if width == 0 || height == 0 {
+        return None;
+    }
+
+    let style = (*node.stylo_element_data().primary_styles()?).clone();
+    let element = node.data.downcast_element_mut()?;
+    let widget_data = element.custom_widget_data_mut()?;
+
+    let mut render_ctx = ProxyRenderContext {
+        inner: render_ctx,
+        resource_ids: &mut widget_data.active_resource_ids,
+    };
+
+    if widget_data.status == CustomWidgetStatus::Suspended {
+        widget_data.widget.can_create_surfaces(&mut render_ctx);
+        widget_data.status = CustomWidgetStatus::Active;
+    }
+
+    let widget_scene = widget_data
+        .widget
+        .paint(&mut render_ctx, &style, width, height, scale);
+
+    Some(widget_scene)
+}