fix: printing, formatting

Author: flxzt

src/render.rs

@@ -175,12 +175,8 @@ impl Renderer {
             let rtree =
                 usvg::Tree::from_data(svg.svg_data.as_bytes(), &self.usvg_options.to_ref())?;
 
-            resvg::render(
-                &rtree,
-                usvg::FitTo::Zoom(zoom as f32),
-                pixmap.as_mut(),
-            )
-            .ok_or_else(|| anyhow::Error::msg("resvg::render failed in gen_image_resvg."))?;
+            resvg::render(&rtree, usvg::FitTo::Zoom(zoom as f32), pixmap.as_mut())
+                .ok_or_else(|| anyhow::Error::msg("resvg::render failed in gen_image_resvg."))?;
         }
 
         let bytes = pixmap.data();
@@ -268,6 +264,34 @@ pub fn rendernode_to_texture(
     Ok(None)
 }
 
+pub fn draw_svgs_to_cairo_context(
+    zoom: f64,
+    svgs: &[Svg],
+    cx: &cairo::Context,
+) -> Result<(), anyhow::Error> {
+    for svg in svgs {
+        let stream =
+            gio::MemoryInputStream::from_bytes(&glib::Bytes::from(svg.svg_data.as_bytes()));
+
+        let librsvg_handle = librsvg::Loader::new()
+            .read_stream::<gio::MemoryInputStream, gio::File, gio::Cancellable>(
+                &stream, None, None,
+            )?;
+
+        let librsvg_renderer = librsvg::CairoRenderer::new(&librsvg_handle);
+        librsvg_renderer.render_document(
+            &cx,
+            &cairo::Rectangle {
+                x: (svg.bounds.mins[0].floor() * zoom),
+                y: (svg.bounds.mins[1].floor() * zoom),
+                width: ((svg.bounds.extents()[0]).ceil() * zoom),
+                height: ((svg.bounds.extents()[1]).ceil() * zoom),
+            },
+        )?;
+    }
+
+    Ok(())
+}
 #[allow(dead_code)]
 fn gen_caironode_librsvg(zoom: f64, svg: &Svg) -> Result<gsk::CairoNode, anyhow::Error> {
     if svg.bounds.extents()[0] < 0.0 || svg.bounds.extents()[1] < 0.0 {
@@ -288,20 +312,7 @@ fn gen_caironode_librsvg(zoom: f64, svg: &Svg) -> Result<gsk::CairoNode, anyhow:
         .draw_context()
         .context("failed to get cairo draw_context() from new_caironode")?;
 
-    let stream = gio::MemoryInputStream::from_bytes(&glib::Bytes::from(svg.svg_data.as_bytes()));
-
-    let librsvg_handle = librsvg::Loader::new()
-        .read_stream::<gio::MemoryInputStream, gio::File, gio::Cancellable>(&stream, None, None)?;
-
-    let librsvg_renderer = librsvg::CairoRenderer::new(&librsvg_handle);
-    librsvg_renderer.render_document(
-        &cx,
-        &cairo::Rectangle {
-            x: (svg.bounds.mins[0].floor() * zoom),
-            y: (svg.bounds.mins[1].floor() * zoom),
-            width: ((svg.bounds.extents()[0]).ceil() * zoom),
-            height: ((svg.bounds.extents()[1]).ceil() * zoom),
-        },
-    )?;
+    draw_svgs_to_cairo_context(zoom, &vec![svg.to_owned()], &cx)?;
+
     Ok(new_caironode)
 }

src/strokes/bitmapimage.rs

@@ -1,6 +1,6 @@
 use std::io;
 
-use crate::{compose, render, geometry};
+use crate::{compose, geometry, render};
 use anyhow::Context;
 use image::{io::Reader, GenericImageView};
 use serde::{Deserialize, Serialize};

src/strokes/vectorimage.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use crate::{compose, render, geometry};
+use crate::{compose, geometry, render};
 
 use anyhow::Context;
 use serde::{Deserialize, Serialize};

src/ui/actions.rs

@@ -9,7 +9,7 @@ use crate::{
 };
 use gtk4::{
     gdk, gio, glib, glib::clone, prelude::*, ArrowType, CornerType, PackType, PositionType,
-    PrintOperation, PrintOperationAction, Snapshot, Unit,
+    PrintOperation, PrintOperationAction, Unit,
 };
 
 /* Actions follow this principle:
@@ -558,77 +558,54 @@ pub fn setup_actions(appwindow: &RnoteAppWindow) {
             .allow_async(true)
             .build();
 
-/*         print_op.connect_begin_print(clone!(@weak appwindow => move |print_op, print_cx| {
-            print_op.set_n_pages(appwindow.canvas().sheet().calc_n_pages());
-        })); */
-
-        print_op.connect_draw_page(clone!(@weak appwindow => move |_print_op, print_cx, page_nr| {
-            let cx = match print_cx.cairo_context() {
-                None => {
-                    log::error!("failed to get cairo context in print_op.connect_draw_page().");
-                    return;
-                }
-                Some(cx) => { cx }
-            };
-
-            let (margin_top, margin_bottom, margin_left, margin_right) = print_cx.hard_margins().unwrap_or( (0.0, 0.0, 0.0, 0.0) );
-
-            let width_scale = (print_cx.width() + margin_left + margin_right) / f64::from(appwindow.canvas().sheet().format().width());
-            let height_scale = (print_cx.height() + margin_top + margin_bottom) / f64::from(appwindow.canvas().sheet().format().height());
-            let print_zoom = width_scale.min(height_scale);
-            let y_offset = - (f64::from(page_nr * appwindow.canvas().sheet().format().height()) * print_zoom);
-
-            let snapshot = Snapshot::new();
-
-            let format_bounds_scaled = p2d::bounding_volume::AABB::new(
-                na::point![0.0, 0.0],
-                na::point![f64::from(appwindow.canvas().sheet().format().width()) * print_zoom,f64::from(appwindow.canvas().sheet().format().height()) * print_zoom]
-            );
-            let sheet_bounds= p2d::bounding_volume::AABB::new(
-                na::point![0.0, 0.0],
-                na::point![
-                    f64::from(appwindow.canvas().sheet().width()),
-                    f64::from(appwindow.canvas().sheet().height())
-                ]
-            );
-
+            let sheet_bounds= appwindow.canvas().sheet().bounds();
             match appwindow.canvas().sheet().gen_svg() {
                 Ok(svg_data) => {
                     let svg = render::Svg {
                         bounds: sheet_bounds,
                         svg_data,
                     };
+                    print_op.connect_draw_page(clone!(@weak appwindow => move |_print_op, print_cx, page_nr| {
+                        let cx = match print_cx.cairo_context() {
+                            None => {
+                                log::error!("failed to get cairo context in print_op.connect_draw_page().");
+                                return;
+                            }
+                            Some(cx) => { cx }
+                        };
+
+                        let (margin_top, margin_bottom, margin_left, margin_right) = print_cx.hard_margins().unwrap_or( (0.0, 0.0, 0.0, 0.0) );
+
+                        let width_scale = (print_cx.width() + margin_left + margin_right) / f64::from(appwindow.canvas().sheet().format().width());
+                        let height_scale = (print_cx.height() + margin_top + margin_bottom) / f64::from(appwindow.canvas().sheet().format().height());
+                        let print_zoom = width_scale.min(height_scale);
+                        let y_offset = - (f64::from(page_nr * appwindow.canvas().sheet().format().height()) * print_zoom);
+
+                        let format_bounds_scaled = p2d::bounding_volume::AABB::new(
+                            na::point![0.0, 0.0],
+                            na::point![f64::from(appwindow.canvas().sheet().format().width()) * print_zoom,f64::from(appwindow.canvas().sheet().format().height()) * print_zoom]
+                        );
+
+                        cx.rectangle(
+                            format_bounds_scaled.mins[0],
+                            format_bounds_scaled.mins[1],
+                            format_bounds_scaled.extents()[0],
+                            format_bounds_scaled.extents()[1]
+                        );
+                        cx.clip();
+                        cx.translate(0.0, y_offset);
+
+                        if let Err(e) = render::draw_svgs_to_cairo_context(print_zoom, &vec![svg.clone()], &cx) {
+                            log::error!("render::draw_svgs_to_cairo_context() failed in draw_page() callback while printing page: {}, {}", page_nr, e);
 
-                    match appwindow.canvas().sheet().strokes_state().borrow().renderer.read().unwrap().gen_image(print_zoom, &vec![svg], sheet_bounds) {
-                        Ok(image) => {
-                            snapshot.append_node(&render::image_to_rendernode(&image, print_zoom));
                         }
-                        Err(e) => {
-                            log::error!("renderer.gen_rendernode() failed in draw_page() callback while printing page: {}, {}", page_nr, e);
-                        }
-                    }
-                },
+                }));
+            },
                 Err(e) => {
-                    log::error!("gen_svg() failed in draw_page() callback while printing page: {}, {}", page_nr, e);
+                    log::error!("gen_svg() failed in print-sheet action with Err {}", e);
                 }
             }
 
-            cx.rectangle(
-                format_bounds_scaled.mins[0],
-                format_bounds_scaled.mins[1],
-                format_bounds_scaled.extents()[0],
-                format_bounds_scaled.extents()[1]
-            );
-            cx.clip();
-            cx.translate(0.0, y_offset);
-
-            if let Some(node) = snapshot.to_node() {
-                node.draw(&cx);
-            } else {
-                log::error!("snapshot.to_node() for created snapshot while printing page: {}", page_nr);
-            };
-        }));
-
         if let Err(e) = print_op.run(PrintOperationAction::PrintDialog, Some(&appwindow)){
             log::error!("print_op.run() failed with Err, {}", e);
         };