Edit Typst source (supports rotation and scaling) and store it in the

files

Author: Xyndra

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

@@ -363,10 +363,12 @@ impl Engine {
     }
 
     /// Insert an SVG image as a VectorImage stroke.
+    /// If `typst_source` is provided, it will be stored with the image for later editing.
     pub fn insert_svg_image(
         &mut self,
         svg_data: String,
         pos: na::Vector2<f64>,
+        typst_source: Option<String>,
     ) -> WidgetFlags {
         let mut widget_flags = WidgetFlags::default();
 
@@ -376,7 +378,10 @@ impl Engine {
 
         // Create VectorImage from SVG
         match VectorImage::from_svg_str(&svg_data, pos, ImageSizeOption::RespectOriginalSize) {
-            Ok(vectorimage) => {
+            Ok(mut vectorimage) => {
+                // Store the Typst source if provided
+                vectorimage.typst_source = typst_source;
+
                 let stroke = Stroke::VectorImage(vectorimage);
                 let stroke_key = self.store.insert_stroke(stroke, None);
 
@@ -399,6 +404,81 @@ impl Engine {
         widget_flags
     }
 
+    /// Update an existing Typst stroke with new SVG data and source code.
+    pub fn update_typst_stroke(
+        &mut self,
+        stroke_key: StrokeKey,
+        svg_data: String,
+        typst_source: String,
+    ) -> WidgetFlags {
+        let mut widget_flags = WidgetFlags::default();
+
+        if let Some(Stroke::VectorImage(vectorimage)) = self.store.get_stroke_mut(stroke_key) {
+            // Store the old intrinsic size, cuboid size, and transform
+            let old_cuboid_size = vectorimage.rectangle.cuboid.half_extents * 2.0;
+            let old_transform = vectorimage.rectangle.transform.clone();
+
+            // Create new VectorImage to get the new intrinsic size
+            match VectorImage::from_svg_str(
+                &svg_data,
+                na::Vector2::zeros(),
+                ImageSizeOption::RespectOriginalSize,
+            ) {
+                Ok(mut new_vectorimage) => {
+                    let new_intrinsic_size = new_vectorimage.intrinsic_size;
+
+                    // Calculate width scale factor based on old cuboid width vs new intrinsic width
+                    let width_scale_factor = if new_intrinsic_size[0] > 0.0 {
+                        old_cuboid_size[0] / new_intrinsic_size[0]
+                    } else {
+                        1.0
+                    };
+
+                    // Apply the scale factor to both dimensions to maintain aspect ratio
+                    let new_cuboid_size = na::vector![
+                        new_intrinsic_size[0] * width_scale_factor,
+                        new_intrinsic_size[1] * width_scale_factor
+                    ];
+
+                    // Calculate height difference to adjust position
+                    let height_diff = new_cuboid_size[1] - old_cuboid_size[1];
+
+                    // Set the new cuboid size
+                    new_vectorimage.rectangle.cuboid = p2d::shape::Cuboid::new(new_cuboid_size * 0.5);
+
+                    // Restore the original transform and adjust for height change
+                    new_vectorimage.rectangle.transform = old_transform;
+                    // Adjust y position to make it look like text was written further
+                    new_vectorimage.rectangle.transform.append_translation_mut(na::vector![0.0, height_diff * 0.5]);
+
+                    // Store the Typst source
+                    new_vectorimage.typst_source = Some(typst_source);
+
+                    // Update the stroke
+                    *vectorimage = new_vectorimage;
+
+                    self.store.regenerate_rendering_for_stroke(
+                        stroke_key,
+                        self.camera.viewport(),
+                        self.camera.image_scale(),
+                    );
+
+                    widget_flags |= self.store.record(Instant::now());
+                    widget_flags.resize = true;
+                    widget_flags.redraw = true;
+                    widget_flags.store_modified = true;
+                }
+                Err(e) => {
+                    error!("Failed to update Typst stroke: {e:?}");
+                }
+            }
+        } else {
+            error!("Failed to update Typst stroke: stroke not found or not a VectorImage");
+        }
+
+        widget_flags
+    }
+
     /// Insert the stroke content.
     ///
     /// The data usually comes from the clipboard, drag-and-drop, ..

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

@@ -80,6 +80,7 @@ pub struct EngineViewMut<'a> {
     pub camera: &'a mut Camera,
     pub audioplayer: &'a mut Option<AudioPlayer>,
     pub animation: &'a mut Animation,
+    pub clicked_typst_stroke: &'a mut Option<(StrokeKey, String)>,
 }
 
 /// Constructs an `EngineViewMut` from an identifier containing an `Engine` instance.
@@ -88,6 +89,7 @@ macro_rules! engine_view_mut {
     ($engine:ident) => {
         $crate::engine::EngineViewMut {
             tasks_tx: $engine.tasks_tx.clone(),
+            clicked_typst_stroke: &mut $engine.clicked_typst_stroke,
             config: &mut $engine.config.write(),
             document: &mut $engine.document,
             store: &mut $engine.store,
@@ -206,6 +208,9 @@ pub struct Engine {
     #[cfg(feature = "ui")]
     #[serde(skip)]
     origin_indicator_rendernode: Option<gtk4::gsk::RenderNode>,
+    // Clicked Typst stroke for editing
+    #[serde(skip)]
+    clicked_typst_stroke: Option<(StrokeKey, String)>,
 }
 
 impl Default for Engine {
@@ -229,6 +234,7 @@ impl Default for Engine {
             origin_indicator_image: None,
             #[cfg(feature = "ui")]
             origin_indicator_rendernode: None,
+            clicked_typst_stroke: None,
         }
     }
 }
@@ -265,6 +271,11 @@ impl Engine {
         self.tasks_rx.take()
     }
 
+    /// Takes the clicked Typst stroke if any, clearing it from the engine.
+    pub fn take_clicked_typst_stroke(&mut self) -> Option<(StrokeKey, String)> {
+        self.clicked_typst_stroke.take()
+    }
+
     /// Whether pen sounds are enabled.
     pub fn pen_sounds(&self) -> bool {
         self.config.read().pen_sounds

crates/rnote-engine/src/pens/typewriter/penevents.rs

@@ -43,8 +43,19 @@ impl Typewriter {
                     .stroke_hitboxes_contain_coord(engine_view.camera.viewport(), element.pos)
                     .last()
                 {
+                    // Check if clicked on a Typst VectorImage
+                    if let Some(Stroke::VectorImage(vectorimage)) =
+                        engine_view.store.get_stroke_ref(stroke_key)
+                    {
+                        if let Some(ref typst_source) = vectorimage.typst_source {
+                            // Signal to UI that a Typst element was clicked for editing
+                            *engine_view.clicked_typst_stroke =
+                                Some((stroke_key, typst_source.clone()));
+                            // Don't change state, just let UI handle opening the dialog
+                        }
+                    }
                     // When clicked on a textstroke, we start modifying it
-                    if let Some(Stroke::TextStroke(textstroke)) =
+                    else if let Some(Stroke::TextStroke(textstroke)) =
                         engine_view.store.get_stroke_ref(stroke_key)
                     {
                         let cursor = if let Ok(new_cursor) =

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

@@ -31,6 +31,13 @@ pub struct VectorImage {
     pub intrinsic_size: na::Vector2<f64>,
     #[serde(rename = "rectangle")]
     pub rectangle: Rectangle,
+    /// Optional Typst source code, if this image was generated from Typst
+    #[serde(
+        rename = "typst_source",
+        skip_serializing_if = "Option::is_none",
+        default
+    )]
+    pub typst_source: Option<String>,
 }
 
 impl Default for VectorImage {
@@ -39,6 +46,7 @@ impl Default for VectorImage {
             svg_data: String::default(),
             intrinsic_size: na::Vector2::zeros(),
             rectangle: Rectangle::default(),
+            typst_source: None,
         }
     }
 }
@@ -201,6 +209,7 @@ impl VectorImage {
             svg_data,
             intrinsic_size,
             rectangle,
+            typst_source: None,
         })
     }
 

crates/rnote-ui/src/canvas/input.rs

@@ -1,5 +1,6 @@
 // Imports
 use super::RnCanvas;
+use glib::clone;
 use gtk4::{Native, gdk, glib, graphene, prelude::*};
 use rnote_compose::penevent::{KeyboardKey, ModifierKey, PenEvent, PenState, ShortcutKey};
 use rnote_compose::penpath::Element;
@@ -192,6 +193,33 @@ pub(crate) fn handle_pointer_controller_event(
                     );
                     widget_flags |= wf;
                     propagation = ep.into_glib();
+
+                    // Check if a Typst element was clicked for editing (only on Up to avoid multiple triggers)
+                    if let Some((stroke_key, typst_source)) =
+                        canvas.engine_mut().take_clicked_typst_stroke()
+                    {
+                        // Get the appwindow from the canvas root
+                        if let Some(root) = canvas.root() {
+                            if let Ok(appwindow) = root.downcast::<crate::RnAppWindow>() {
+                                // Open the Typst editor dialog with the existing source
+                                glib::spawn_future_local(clone!(
+                                    #[weak]
+                                    canvas,
+                                    #[weak]
+                                    appwindow,
+                                    async move {
+                                        crate::dialogs::typsteditor::dialog_typst_editor(
+                                            &appwindow,
+                                            &canvas,
+                                            Some(typst_source),
+                                            Some(stroke_key),
+                                        )
+                                        .await;
+                                    }
+                                ));
+                            }
+                        }
+                    }
                 }
                 PenState::Proximity => {
                     canvas.enable_drawing_cursor(false);
@@ -227,6 +255,7 @@ pub(crate) fn handle_pointer_controller_event(
     }
 
     canvas.emit_handle_widget_flags(widget_flags);
+
     (propagation, pen_state)
 }
 

crates/rnote-ui/src/dialogs/typsteditor.rs

@@ -9,7 +9,12 @@ use std::rc::Rc;
 use std::time::Duration;
 use tracing::{error, warn};
 
-pub(crate) async fn dialog_typst_editor(appwindow: &RnAppWindow, canvas: &RnCanvas) {
+pub(crate) async fn dialog_typst_editor(
+    appwindow: &RnAppWindow,
+    canvas: &RnCanvas,
+    initial_source: Option<String>,
+    editing_stroke_key: Option<rnote_engine::store::StrokeKey>,
+) {
     let builder = Builder::from_resource(
         (String::from(crate::config::APP_IDPATH) + "ui/dialogs/typsteditor.ui").as_str(),
     );
@@ -44,8 +49,12 @@ pub(crate) async fn dialog_typst_editor(appwindow: &RnAppWindow, canvas: &RnCanv
     let text_buffer = textview_source.buffer();
     let error_buffer = textview_error.buffer();
 
-    // Set default Typst content
-    text_buffer.set_text("#set page(width: auto, height: auto, margin: 2pt)\n\n= Hello Typst!\n\nThis is a *bold* text and _italic_ text.\n\n$ sum_(i=1)^n i = (n(n+1))/2 $");
+    // Set Typst content (either provided or default)
+    if let Some(source) = initial_source {
+        text_buffer.set_text(&source);
+    } else {
+        text_buffer.set_text("#set page(width: auto, height: auto, margin: 2pt)\n\n= Hello Typst!\n\nThis is a *bold* text and _italic_ text.\n\n$ sum_(i=1)^n i = (n(n+1))/2 $");
+    }
 
     // Shared state for compiled SVG and debounce timer
     let compiled_svg: Rc<RefCell<Option<String>>> = Rc::new(RefCell::new(None));
@@ -166,16 +175,31 @@ pub(crate) async fn dialog_typst_editor(appwindow: &RnAppWindow, canvas: &RnCanv
         canvas,
         #[weak]
         appwindow,
+        #[weak]
+        text_buffer,
         #[strong]
         compiled_svg,
         move |_| {
             if let Some(svg) = compiled_svg.borrow().as_ref() {
-                // Get the center of the current viewport as insertion position
-                let viewport = canvas.engine_ref().camera.viewport();
-                let pos = na::vector![viewport.center().x, viewport.center().y];
-
-                // Insert the SVG into the canvas
-                let widget_flags = canvas.engine_mut().insert_svg_image(svg.clone(), pos);
+                // Get the Typst source code
+                let source =
+                    text_buffer.text(&text_buffer.start_iter(), &text_buffer.end_iter(), false);
+
+                let widget_flags = if let Some(stroke_key) = editing_stroke_key {
+                    // Update existing stroke
+                    canvas.engine_mut().update_typst_stroke(
+                        stroke_key,
+                        svg.clone(),
+                        source.to_string(),
+                    )
+                } else {
+                    // Insert new stroke at center of viewport
+                    let viewport = canvas.engine_ref().camera.viewport();
+                    let pos = na::vector![viewport.center().x, viewport.center().y];
+                    canvas
+                        .engine_mut()
+                        .insert_svg_image(svg.clone(), pos, Some(source.to_string()))
+                };
                 appwindow.handle_widget_flags(widget_flags, &canvas);
 
                 dialog.close();

crates/rnote-ui/src/penssidebar/typewriterpage.rs

@@ -199,10 +199,15 @@ impl RnTypewriterPage {
                     return;
                 };
                 glib::spawn_future_local(clone!(
-                    #[weak] appwindow,
-                    #[weak] canvas,
+                    #[weak]
+                    appwindow,
+                    #[weak]
+                    canvas,
                     async move {
-                        crate::dialogs::typsteditor::dialog_typst_editor(&appwindow, &canvas).await;
+                        crate::dialogs::typsteditor::dialog_typst_editor(
+                            &appwindow, &canvas, None, None,
+                        )
+                        .await;
                     }
                 ));
             }