add writer

Author: Doublonmousse

Cargo.lock

@@ -57,6 +57,7 @@ usvg = { workspace = true }
 xmlwriter = { workspace = true }
 # the long-term plan is to remove the gtk4 dependency entirely after switching to another renderer.
 gtk4 = { workspace = true, optional = true }
+writer_inkml = {workspace = true}
 
 [dev-dependencies]
 approx = { workspace = true }

crates/rnote-engine/Cargo.toml

@@ -174,4 +174,15 @@ impl StrokeContent {
 
         Ok(())
     }
+
+    pub fn to_inkml(&self, current_dpi: f64) -> Result<Vec<u8>, std::io::Error> {
+        writer_inkml::writer(
+            self.strokes
+                .iter()
+                .map(|stroke| stroke.into_inkml(current_dpi))
+                .filter(|x| x.is_some())
+                .map(|x| x.unwrap())
+                .collect(),
+        )
+    }
 }

crates/rnote-engine/src/engine/strokecontent.rs

@@ -11,6 +11,7 @@ use crate::snap::SnapCorner;
 use crate::store::StrokeKey;
 use crate::strokes::Content;
 use crate::{Camera, DrawableOnDoc, Engine, WidgetFlags};
+use core::str;
 use futures::channel::oneshot;
 use kurbo::Shape;
 use p2d::bounding_volume::{Aabb, BoundingSphere, BoundingVolume};
@@ -23,6 +24,7 @@ use rnote_compose::penpath::Element;
 use rnote_compose::style::indicators;
 use rnote_compose::{Color, color};
 use std::time::Instant;
+use tracing::debug;
 use tracing::error;
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -171,6 +173,8 @@ impl PenBehaviour for Selector {
             None
         };
 
+        let dpi = engine_view.document.config.format.dpi();
+
         rayon::spawn(move || {
             let result = move || {
                 if let Some(stroke_content) = stroke_content {
@@ -186,6 +190,20 @@ impl PenBehaviour for Selector {
                         serde_json::to_string(&stroke_content)?.into_bytes(),
                         StrokeContent::MIME_TYPE.to_string(),
                     ));
+
+                    // add inkml content
+                    let inkml_contents = stroke_content.to_inkml(dpi);
+                    match inkml_contents {
+                        Ok(inkml_bytes) => {
+                            println!("generated inkml :  {:?}", str::from_utf8(&inkml_bytes));
+                            clipboard_content.push((
+                                inkml_bytes,
+                                "application/x.windows.InkML Format".to_string(),
+                            ));
+                        }
+                        _ => (),
+                    }
+
                     if let Some(stroke_content_svg) = stroke_content_svg {
                         // Add generated Svg
                         clipboard_content.push((

crates/rnote-engine/src/pens/selector/mod.rs

@@ -14,6 +14,7 @@ use rnote_compose::ext::AabbExt;
 use rnote_compose::penpath::Element;
 use rnote_compose::shapes::{Rectangle, Shapeable};
 use rnote_compose::style::smooth::SmoothOptions;
+use rnote_compose::style::PressureCurve;
 use rnote_compose::transform::Transform;
 use rnote_compose::transform::Transformable;
 use rnote_compose::{Color, PenPath, Style};
@@ -672,4 +673,63 @@ impl Stroke {
             }
         }
     }
+
+    /// converts a stroke into the input format used by the inkml writer
+    pub fn into_inkml(
+        &self,
+        current_dpi: f64,
+    ) -> Option<(writer_inkml::FormattedStroke, writer_inkml::Brush)> {
+        let pixel_to_cm_factor = 2.54 / current_dpi;
+        match self {
+            Stroke::BrushStroke(brushstroke) => {
+                // remark : style is not preserved here, we will always get a smooth
+                // version
+                let fill_color = brushstroke.style.stroke_color().unwrap_or_default();
+                let elements = brushstroke.path.clone().into_elements();
+                let ignore_pressure = match &brushstroke.style {
+                    Style::Smooth(smooth_options) => match smooth_options.pressure_curve {
+                        PressureCurve::Const => false,
+                        _ => true,
+                    },
+                    Style::Rough(_) => false,
+                    Style::Textured(_) => false,
+                };
+                tracing::debug!("formatting strokes");
+                Some((
+                    writer_inkml::FormattedStroke {
+                        x: elements
+                            .iter()
+                            .map(|element| pixel_to_cm_factor * element.pos.x)
+                            .collect(), // need the scale !
+                        y: elements
+                            .iter()
+                            .map(|element| pixel_to_cm_factor * element.pos.y)
+                            .collect(),
+                        f: elements
+                            .iter()
+                            .map(|element| pixel_to_cm_factor * element.pressure)
+                            .collect(),
+                    },
+                    writer_inkml::Brush::init(
+                        String::from(""),
+                        (
+                            (fill_color.r * 255.0) as u8,
+                            (fill_color.g * 255.0) as u8,
+                            (fill_color.b * 255.0) as u8,
+                        ),
+                        ignore_pressure,
+                        ((1.0 - fill_color.a) * 255.0) as u8,
+                        brushstroke.style.stroke_width() * pixel_to_cm_factor,
+                    ),
+                ))
+            }
+            Stroke::ShapeStroke(_) => {
+                // could be done : relatively easy to do for lines, the rest would have to be discretized
+                None
+            }
+            Stroke::TextStroke(_) => None,
+            Stroke::VectorImage(_) => None,
+            Stroke::BitmapImage(_) => None,
+        }
+    }
 }

crates/rnote-engine/src/strokes/stroke.rs

@@ -17,6 +17,7 @@ use rnote_compose::SplitOrder;
 use rnote_compose::penevent::ShortcutKey;
 use rnote_engine::engine::StrokeContent;
 use rnote_engine::ext::GraphenePointExt;
+use rnote_engine::pens::PenStyle;
 use rnote_engine::strokes::resize::{ImageSizeOption, Resize};
 use rnote_engine::strokes::BrushStroke;
 use rnote_engine::strokes::Stroke;