Add support for pasting multiline/HTML/RTF text (#10)

* Fix pasting multiline text and ensure each line becomes a proper paragraph

* Add RTF/HTML paste support

* Fix clippy lints

* Fix more clippy lints

* Fix platform-specific clippy lints

Author: roblillack

Cargo.lock

@@ -9,8 +9,8 @@ repository.workspace = true
 [dependencies]
 piki-core = { version = "0.2.0", path = "../core" }
 fltk = { version = "1.5.20", features = ["use-wayland"] }
+fltk-sys = "1.5.20"
 pulldown-cmark = "0.13.0"
-tdoc = { version = "0.8.0" }
 clap = { version = "4.5", features = ["derive"] }
 walkdir = "2.5"
 regex = "1.10"
@@ -19,6 +19,10 @@ serde = { version = "1.0", features = ["derive"] }
 toml = "0.9"
 unicode-segmentation = "1.10"
 chrono = "0.4.42"
+arboard = "3.4"
+tdoc = "0.8.1"
+objc = "0.2"
+rtf-parser = "0.4"
 
 [dev-dependencies]
 insta = "1.34"

gui/Cargo.toml

@@ -0,0 +1,138 @@
+use std::io::Cursor;
+
+use tdoc::{Document, html, markdown};
+
+use crate::rtf;
+
+#[derive(Debug)]
+pub enum ClipboardDocumentError {
+    Empty,
+    ClipboardUnavailable(String),
+    Parse(String),
+}
+
+/// Read the system clipboard and convert it into a `tdoc::Document`.
+/// Accepts an optional plain-text fallback (typically provided by FLTK on platforms
+/// where arboard isn't available) along with additional format notes supplied by the caller.
+pub fn read_document_from_system(
+    fallback_plain: Option<&str>,
+    platform_formats: &[String],
+    platform_rtf: Option<&[u8]>,
+) -> Result<Document, ClipboardDocumentError> {
+    let mut diagnostics = platform_formats.to_vec();
+
+    #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
+    {
+        let result = match read_with_arboard(&mut diagnostics, platform_rtf) {
+            Ok(doc) => Ok(doc),
+            Err(err) => {
+                if let Some(text) = fallback_plain {
+                    diagnostics.push(format!(
+                        "fallback:text/plain ({} bytes from FLTK)",
+                        text.len()
+                    ));
+                    match document_from_plaintext(text) {
+                        Ok(doc) => Ok(doc),
+                        Err(parse_err) => Err(parse_err),
+                    }
+                } else {
+                    Err(err)
+                }
+            }
+        };
+        log_formats(&diagnostics);
+        result
+    }
+
+    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
+    {
+        let result = fallback_plain
+            .map(|text| {
+                diagnostics.push(format!(
+                    "fallback:text/plain ({} bytes from FLTK)",
+                    text.len()
+                ));
+                document_from_plaintext(text)
+            })
+            .unwrap_or(Err(ClipboardDocumentError::Empty));
+        log_formats(&diagnostics);
+        return result;
+    }
+}
+
+#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
+fn read_with_arboard(
+    diagnostics: &mut Vec<String>,
+    platform_rtf: Option<&[u8]>,
+) -> Result<Document, ClipboardDocumentError> {
+    use arboard::Clipboard;
+
+    let mut clipboard = Clipboard::new()
+        .map_err(|err| ClipboardDocumentError::ClipboardUnavailable(err.to_string()))?;
+
+    match clipboard.get().html() {
+        Ok(html) if !html.trim().is_empty() => {
+            diagnostics.push(format!("arboard:text/html ({} bytes)", html.len()));
+            if let Ok(doc) = document_from_html(&html) {
+                return Ok(doc);
+            } else {
+                diagnostics.push("arboard:text/html parse failed".to_string());
+            }
+        }
+        Ok(_) => {
+            diagnostics.push("arboard:text/html (empty payload)".to_string());
+        }
+        Err(arboard::Error::ContentNotAvailable) => {
+            diagnostics.push("arboard:text/html unavailable".to_string());
+        }
+        Err(err) => {
+            diagnostics.push(format!("arboard:text/html error ({err})"));
+        }
+    }
+
+    if let Some(rtf_bytes) = platform_rtf {
+        diagnostics.push(format!("platform:public.rtf ({} bytes)", rtf_bytes.len()));
+        match rtf::parse_rtf_document(rtf_bytes) {
+            Ok(doc) => return Ok(doc),
+            Err(err) => diagnostics.push(format!("platform:public.rtf parse failed ({err})")),
+        }
+    }
+
+    let text = clipboard.get_text().map_err(|err| match err {
+        arboard::Error::ContentNotAvailable => ClipboardDocumentError::Empty,
+        other => ClipboardDocumentError::ClipboardUnavailable(other.to_string()),
+    })?;
+
+    diagnostics.push(format!("arboard:text/plain ({} bytes)", text.len()));
+
+    document_from_plaintext(&text)
+}
+
+fn document_from_plaintext(text: &str) -> Result<Document, ClipboardDocumentError> {
+    if text.trim().is_empty() {
+        return Err(ClipboardDocumentError::Empty);
+    }
+
+    markdown::parse(Cursor::new(text.as_bytes()))
+        .map_err(|err| ClipboardDocumentError::Parse(err.to_string()))
+}
+
+fn document_from_html(html_content: &str) -> Result<Document, ClipboardDocumentError> {
+    if html_content.trim().is_empty() {
+        return Err(ClipboardDocumentError::Empty);
+    }
+
+    html::parse(Cursor::new(html_content.as_bytes()))
+        .map_err(|err| ClipboardDocumentError::Parse(err.to_string()))
+}
+
+fn log_formats(formats: &[String]) {
+    if formats.is_empty() {
+        eprintln!("[piki] Clipboard formats during paste: (none detected)");
+    } else {
+        eprintln!(
+            "[piki] Clipboard formats during paste: {}",
+            formats.join(", ")
+        );
+    }
+}

gui/src/clipboard.rs

@@ -1,14 +1,26 @@
 // FLTK integration for StructuredRichDisplay widget
+#![allow(unexpected_cfgs)]
 
+use crate::clipboard;
 use crate::fltk_draw_context::FltkDrawContext;
 use crate::responsive_scrollbar::ResponsiveScrollbar;
 use crate::richtext::structured_document::{BlockType, InlineContent};
 use crate::richtext::structured_rich_display::StructuredRichDisplay;
 use fltk::{app::MouseWheel, enums::*, prelude::*};
 use std::cell::RefCell;
+use std::ffi::CStr;
+#[cfg(target_os = "macos")]
+use std::ffi::CString;
 use std::rc::Rc;
 use std::time::Instant;
 
+#[cfg(target_os = "macos")]
+use objc::rc::autoreleasepool;
+#[cfg(target_os = "macos")]
+use objc::runtime::Object;
+#[cfg(target_os = "macos")]
+use objc::{class, msg_send, sel, sel_impl};
+
 type Callback<T> = Rc<RefCell<Option<Box<dyn Fn(T) + 'static>>>>;
 type MutCallback<T> = Rc<RefCell<Option<Box<dyn FnMut(T) + 'static>>>>;
 type MutCallback0 = Rc<RefCell<Option<Box<dyn FnMut() + 'static>>>>;
@@ -1811,14 +1823,45 @@ impl FltkStructuredRichDisplay {
                     }
                     Event::Paste => {
                         if edit_mode {
-                            let pasted = fltk::app::event_text();
-                            if !pasted.is_empty() {
+                            let fallback_text = fltk::app::event_text();
+                            let (platform_formats, platform_rtf) = inspect_platform_clipboard();
+                            let fallback_ref = if fallback_text.is_empty() {
+                                None
+                            } else {
+                                Some(fallback_text.as_str())
+                            };
+
+                            let mut applied = false;
+
+                            if let Ok(doc) = clipboard::read_document_from_system(
+                                fallback_ref,
+                                &platform_formats,
+                                platform_rtf.as_deref(),
+                            ) {
                                 let mut disp = display.borrow_mut();
-                                let _ = disp.editor_mut().paste(&pasted);
-                                if let Some(cb) = &mut *change_cb.borrow_mut() {
-                                    (cb)();
+                                if disp.editor_mut().insert_document(&doc).is_ok() {
+                                    if let Some(cb) = &mut *change_cb.borrow_mut() {
+                                        (cb)();
+                                    }
+                                    w.redraw();
+                                    applied = true;
+                                }
+                            }
+
+                            if !applied {
+                                let fallback_ref = if fallback_text.is_empty() {
+                                    None
+                                } else {
+                                    Some(fallback_text.as_str())
+                                };
+                                if let Some(text) = fallback_ref {
+                                    let mut disp = display.borrow_mut();
+                                    let _ = disp.editor_mut().paste(text);
+                                    if let Some(cb) = &mut *change_cb.borrow_mut() {
+                                        (cb)();
+                                    }
+                                    w.redraw();
                                 }
-                                w.redraw();
                             }
                             true
                         } else {
@@ -1949,3 +1992,134 @@ impl FltkStructuredRichDisplay {
         blocks.get(idx).map(|b| b.block_type.clone())
     }
 }
+
+fn inspect_platform_clipboard() -> (Vec<String>, Option<Vec<u8>>) {
+    let mut formats = Vec::new();
+    #[cfg_attr(not(target_os = "macos"), allow(unused_mut))]
+    let mut rtf_payload = None;
+
+    unsafe {
+        let raw = fltk_sys::fl::Fl_event_clipboard_type();
+        if !raw.is_null() {
+            let fmt = CStr::from_ptr(raw as *const std::os::raw::c_char)
+                .to_string_lossy()
+                .into_owned();
+            formats.push(describe_platform_format("fltk", &fmt));
+            if rtf_payload.is_none() && fmt.eq_ignore_ascii_case("public.rtf") {
+                // FLTK doesn't expose raw data, rely on macOS helper below.
+            }
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let (mut mac_formats, mac_rtf) = macos_pasteboard_formats_and_rtf();
+        formats.append(&mut mac_formats);
+        if rtf_payload.is_none() {
+            rtf_payload = mac_rtf;
+        }
+    }
+
+    (formats, rtf_payload)
+}
+
+fn is_supported_type(name: &str) -> bool {
+    let lower = name.to_ascii_lowercase();
+    matches!(
+        lower.as_str(),
+        "text/plain"
+            | "public.utf8-plain-text"
+            | "public.utf16-plain-text"
+            | "public.html"
+            | "text/html"
+            | "public.rtf"
+            | "apple web archive pasteboard type"
+            | "apple html pasteboard type"
+            | "nspasteboardtypehtml"
+            | "nspasteboardtypestring"
+    )
+}
+
+fn describe_platform_format(source: &str, format_name: &str) -> String {
+    let status = if is_supported_type(format_name) {
+        "supported"
+    } else {
+        "unsupported"
+    };
+    format!("{source}:{format_name} ({status})")
+}
+
+#[cfg(target_os = "macos")]
+fn macos_pasteboard_formats_and_rtf() -> (Vec<String>, Option<Vec<u8>>) {
+    use std::collections::HashSet;
+    autoreleasepool(|| unsafe {
+        let mut formats = Vec::new();
+        let mut seen = HashSet::new();
+        let mut rtf_payload = None;
+        let pasteboard: *mut Object = msg_send![class!(NSPasteboard), generalPasteboard];
+        if pasteboard.is_null() {
+            return (formats, rtf_payload);
+        }
+        let items: *mut Object = msg_send![pasteboard, pasteboardItems];
+        if items.is_null() {
+            return (formats, rtf_payload);
+        }
+        let item_count: usize = msg_send![items, count];
+        for i in 0..item_count {
+            let item: *mut Object = msg_send![items, objectAtIndex: i];
+            if item.is_null() {
+                continue;
+            }
+            let types: *mut Object = msg_send![item, types];
+            if types.is_null() {
+                continue;
+            }
+            let type_count: usize = msg_send![types, count];
+            for j in 0..type_count {
+                let ty: *mut Object = msg_send![types, objectAtIndex: j];
+                if ty.is_null() {
+                    continue;
+                }
+                let utf8: *const std::os::raw::c_char = msg_send![ty, UTF8String];
+                if utf8.is_null() {
+                    continue;
+                }
+                let value = CStr::from_ptr(utf8).to_string_lossy().into_owned();
+                if seen.insert(value.clone()) {
+                    formats.push(describe_platform_format("macos", &value));
+                }
+                if rtf_payload.is_none() && value.eq_ignore_ascii_case("public.rtf") {
+                    rtf_payload = read_pasteboard_data(item, "public.rtf");
+                }
+            }
+        }
+        (formats, rtf_payload)
+    })
+}
+
+#[cfg(target_os = "macos")]
+#[allow(unsafe_op_in_unsafe_fn)]
+unsafe fn read_pasteboard_data(item: *mut Object, type_name: &str) -> Option<Vec<u8>> {
+    let ns_type = nsstring_from_str(type_name);
+    if ns_type.is_null() {
+        return None;
+    }
+    let data: *mut Object = msg_send![item, dataForType: ns_type];
+    if data.is_null() {
+        return None;
+    }
+    let length: usize = msg_send![data, length];
+    let bytes: *const u8 = msg_send![data, bytes];
+    if bytes.is_null() || length == 0 {
+        return None;
+    }
+    let slice = std::slice::from_raw_parts(bytes, length);
+    Some(slice.to_vec())
+}
+
+#[cfg(target_os = "macos")]
+#[allow(unsafe_op_in_unsafe_fn)]
+unsafe fn nsstring_from_str(value: &str) -> *mut Object {
+    let c_string = CString::new(value).unwrap();
+    msg_send![class!(NSString), stringWithUTF8String: c_string.as_ptr()]
+}

gui/src/fltk_structured_rich_display.rs

@@ -1,4 +1,5 @@
 // Library exports for piki
+pub mod clipboard;
 pub mod content;
 pub mod context_menu;
 pub mod draw_context;
@@ -9,5 +10,6 @@ pub mod link_handler;
 pub mod page_ui;
 pub mod responsive_scrollbar;
 pub mod richtext;
+pub mod rtf;
 pub mod theme;
 pub mod ui_adapters;