blitz-pdf 0.1.4 → 0.1.6

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

@@ -0,0 +1,168 @@
+use anyrender::PaintScene;
+use blitz_dom::{BaseDocument, NodeId};
+use kurbo::{Affine, Rect, Vec2};
+
+use crate::color::Color;
+
+/// Renders a layout debugging overlay which visualises the content size, padding and border
+/// of the node with a transparent overlay.
+pub(crate) fn render_debug_overlay(
+    scene: &mut impl PaintScene,
+    dom: &BaseDocument,
+    node_id: NodeId,
+    scale: f64,
+    initial_x: f64,
+    initial_y: f64,
+) {
+    // Non-atomic inline elements have no layout box of their own: they are laid
+    // out as style spans within an inline root's text layout and may fragment
+    // across multiple line boxes. Highlight each fragment's content box.
+    if let Some(rects) = dom.as_ref().inline_fragment_rects(node_id) {
+        let fill_color = Color::from_rgba8(66, 144, 245, 128); // blue
+        for r in rects {
+            let rect = Rect::new(0.0, 0.0, r.width * scale, r.height * scale);
+            let translation = Vec2::new(r.x * scale + initial_x, r.y * scale + initial_y);
+            scene.fill(
+                peniko::Fill::NonZero,
+                Affine::translate(translation),
+                fill_color,
+                None,
+                &rect,
+            );
+        }
+        return;
+    }
+
+    let viewport_scroll = dom.as_ref().viewport_scroll();
+    let mut node = &dom.as_ref().tree()[node_id];
+
+    let taffy::Layout {
+        size,
+        border,
+        padding,
+        margin,
+        ..
+    } = *node.final_layout();
+    let taffy::Size { width, height } = size;
+
+    let padding_border = padding + border;
+    let scaled_pb = padding_border.map(|v| f64::from(v) * scale);
+    let scaled_padding = padding.map(|v| f64::from(v) * scale);
+    let scaled_border = border.map(|v| f64::from(v) * scale);
+    let scaled_margin = margin.map(|v| f64::from(v) * scale);
+
+    let content_width = width - padding_border.left - padding_border.right;
+    let content_height = height - padding_border.top - padding_border.bottom;
+
+    let taffy::Point { x, y } = node.final_layout().location;
+
+    let mut abs_x = x;
+    let mut abs_y = y;
+    // A fixed box whose containing block is the root element does not scroll
+    // with it (nor with the viewport).
+    let mut fixed_to_viewport = false;
+    while let Some(parent_id) = node.containing_block() {
+        let child_is_fixed = node.taffy_position() == taffy::Position::Fixed;
+        node = &dom.as_ref().tree()[parent_id];
+        fixed_to_viewport = child_is_fixed && node.containing_block().is_none();
+        let taffy::Point { x, y } = node.final_layout().location;
+        abs_x += x;
+        abs_y += y;
+        if !fixed_to_viewport {
+            abs_x -= node.scroll_offset().x as f32;
+            abs_y -= node.scroll_offset().y as f32;
+        }
+    }
+
+    if !fixed_to_viewport {
+        abs_x -= viewport_scroll.x as f32;
+        abs_y -= viewport_scroll.y as f32;
+    }
+
+    // Note: initial_x/initial_y are already in physical (scaled) pixels so they must be added after scaling
+    // the other values
+    let abs_x = f64::from(abs_x) * scale + initial_x;
+    let abs_y = f64::from(abs_y) * scale + initial_y;
+    let width = f64::from(width) * scale;
+    let height = f64::from(height) * scale;
+    let content_width = f64::from(content_width) * scale;
+    let content_height = f64::from(content_height) * scale;
+
+    // Fill content box blue
+    let base_translation = Vec2::new(abs_x, abs_y);
+    let transform = Affine::translate(base_translation + Vec2::new(scaled_pb.left, scaled_pb.top));
+    let rect = Rect::new(0.0, 0.0, content_width, content_height);
+    let fill_color = Color::from_rgba8(66, 144, 245, 128); // blue
+    scene.fill(peniko::Fill::NonZero, transform, fill_color, None, &rect);
+
+    let padding_color = Color::from_rgba8(81, 144, 66, 128); // green
+    draw_cutout_rect(
+        scene,
+        base_translation + Vec2::new(scaled_border.left, scaled_border.top),
+        Vec2::new(
+            content_width + scaled_padding.left + scaled_padding.right,
+            content_height + scaled_padding.top + scaled_padding.bottom,
+        ),
+        scaled_padding.map(f64::from),
+        padding_color,
+    );
+
+    let border_color = Color::from_rgba8(245, 66, 66, 128); // red
+    draw_cutout_rect(
+        scene,
+        base_translation,
+        Vec2::new(width, height),
+        scaled_border.map(f64::from),
+        border_color,
+    );
+
+    let margin_color = Color::from_rgba8(249, 204, 157, 128); // orange
+    draw_cutout_rect(
+        scene,
+        base_translation - Vec2::new(scaled_margin.left, scaled_margin.top),
+        Vec2::new(
+            width + scaled_margin.left + scaled_margin.right,
+            height + scaled_margin.top + scaled_margin.bottom,
+        ),
+        scaled_margin.map(f64::from),
+        margin_color,
+    );
+}
+
+fn draw_cutout_rect(
+    scene: &mut impl PaintScene,
+    base_translation: Vec2,
+    size: Vec2,
+    edge_widths: taffy::Rect<f64>,
+    color: Color,
+) {
+    let mut fill = |pos: Vec2, width: f64, height: f64| {
+        scene.fill(
+            peniko::Fill::NonZero,
+            Affine::translate(pos),
+            color,
+            None,
+            &Rect::new(0.0, 0.0, width, height),
+        );
+    };
+
+    let right = size.x - edge_widths.right;
+    let bottom = size.y - edge_widths.bottom;
+    let inner_h = size.y - edge_widths.top - edge_widths.bottom;
+    let inner_w = size.x - edge_widths.left - edge_widths.right;
+
+    let bt = base_translation;
+    let ew = edge_widths;
+
+    // Corners
+    fill(bt, ew.left, ew.top); // top-left
+    fill(bt + Vec2::new(0.0, bottom), ew.left, ew.bottom); // bottom-left
+    fill(bt + Vec2::new(right, 0.0), ew.right, ew.top); // top-right
+    fill(bt + Vec2::new(right, bottom), ew.right, ew.bottom); // bottom-right
+
+    // Sides
+    fill(bt + Vec2::new(0.0, ew.top), ew.left, inner_h); // left
+    fill(bt + Vec2::new(right, ew.top), ew.right, inner_h); // right
+    fill(bt + Vec2::new(ew.left, 0.0), inner_w, ew.top); // top
+    fill(bt + Vec2::new(ew.left, bottom), inner_w, ew.bottom); // bottom
+}

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

@@ -0,0 +1,40 @@
+use blitz_dom::util::ToColorColor as _;
+use style::color::AbsoluteColor;
+pub(crate) use style::computed_values::filter::single_value::T as StyloFilter;
+
+use anyrender::filters::{Filter, FilterEffect};
+
+pub(crate) fn convert_filters(filters: &[StyloFilter]) -> Option<Filter> {
+    if filters.is_empty() {
+        return None;
+    }
+
+    Some(Filter::linear_list(
+        filters.iter().filter_map(convert_single_filter),
+    ))
+}
+
+pub(crate) fn convert_single_filter(filter: &StyloFilter) -> Option<FilterEffect> {
+    Some(match filter {
+        StyloFilter::Blur(radius) => FilterEffect::blur(radius.px()),
+        StyloFilter::Brightness(amount) => FilterEffect::brightness(amount.0),
+        StyloFilter::Contrast(amount) => FilterEffect::contrast(amount.0),
+        StyloFilter::Grayscale(amount) => FilterEffect::grayscale(amount.0),
+        StyloFilter::HueRotate(angle) => FilterEffect::hue_rotate(angle.radians()),
+        StyloFilter::Invert(amount) => FilterEffect::invert(amount.0),
+        StyloFilter::Opacity(amount) => FilterEffect::opacity(amount.0),
+        StyloFilter::Saturate(amount) => FilterEffect::saturate(amount.0),
+        StyloFilter::Sepia(amount) => FilterEffect::sepia(amount.0),
+        StyloFilter::DropShadow(shadow) => FilterEffect::drop_shadow(
+            shadow.horizontal.px(),
+            shadow.vertical.px(),
+            shadow.blur.px(),
+            // TODO: pass in correct currentColor
+            shadow
+                .color
+                .resolve_to_absolute(&AbsoluteColor::BLACK)
+                .as_color_color(),
+        ),
+        StyloFilter::Url(_) => return None,
+    })
+}