merge annot changes manually

(pr #243)

Author: s3bk

examples/src/bin/add_annot.rs

@@ -0,0 +1,100 @@
+extern crate pdf;
+
+
+use std::env::args;
+use std::ops::Deref;
+
+use pdf::content::{FormXObject, Op, serialize_ops};
+use pdf::error::PdfError;
+use pdf::file::{FileOptions, Log};
+use pdf::font::{Font, FontData, TFont};
+use pdf::object::*;
+use pdf::primitive::{Dictionary, Name, PdfString, Primitive};
+
+fn run() -> Result<(), PdfError> {
+    let path = args().nth(1).expect("no file given");
+    println!("read: {}", path);
+
+    let mut old_file = FileOptions::cached().open(&path)?;
+    let mut old_page: PageRc = old_file.get_page(0).unwrap();
+
+    let old_annots = old_page.annotations.load(&old_file.resolver()).expect("can't load annotations");
+    let mut annots: Vec<_> = (*old_annots).clone();
+    // let mut new_annots = annots.deref().clone();
+    // for annot in &new_annots {
+        // dbg!(&annot.subtype);
+        // dbg!(&annot.rect);
+        // dbg!(&annot.color);
+        // dbg!(&annot.transparency);
+        // dbg!(&annot.ink_list);
+        // dbg!(&annot.line);
+        // dbg!(&annot.creation_date);
+        // dbg!(&annot.uuid);
+        // dbg!(&annot.border_style);
+        // dbg!(&annot.popup);
+        // dbg!(&annot.other);
+    // }
+
+    let mut bs = Dictionary::new();
+    bs.insert(Name::from("S"), PdfString::from("/S"));
+    bs.insert(Name::from("W"), PdfString::from("3"));
+    let new_annot = Annot {
+        subtype: Name::from("Line"),
+        // rect: Some(Rectangle {
+        //     left: 89.774,
+        //     bottom: 726.55,
+        //     right: 300.961,
+        //     top: 742.55,
+        // }),
+        rect: Some(Rectangle { left: 10., bottom: 10., right: 200., top: 200. }),
+        contents: None,
+        page: Some(old_page.clone()),
+        border: None,
+        annotation_name: None,
+        date: None,
+        annot_flags: 4,
+        appearance_streams: None,
+        appearance_state: None,
+        color: Some(Primitive::Array(
+            vec![Primitive::Integer(1), Primitive::Integer(0), Primitive::Integer(0)]
+            )),
+        ink_list: None,
+        line: Some(vec![10., 100., 20., 200.]),
+        // creation_date: None,
+        // uuid: None,
+        // border_style: Some(bs),
+        // border_style: None,
+        // popup: None,
+        other: Dictionary::new(),
+        // transparency: Some(1.0),
+        // transparency: None,
+    };
+
+    let annot_ref = old_file.create(new_annot)?;
+    annots.push(MaybeRef::Indirect(annot_ref));
+
+
+    match old_annots {
+        MaybeRef::Direct(_) => {
+            // need to update the whole page
+            let mut new_page: Page = (*old_page).clone();
+
+            let lazy_annots = Lazy::from(old_file.create(annots).unwrap());
+            new_page.annotations = lazy_annots;
+            PageRc::update(new_page, &old_page, &mut old_file).unwrap();
+        }
+        MaybeRef::Indirect(r) => {
+            // can just update the annot reference
+            old_file.update_ref(&r, annots).unwrap();
+        }
+    }
+    old_file.save_to("out.pdf")?;
+
+    Ok(())
+}
+
+fn main() {
+    if let Err(e) = run() {
+        println!("{e}");
+    }
+}

pdf/src/object/mod.rs

@@ -111,6 +111,9 @@ pub trait Updater {
     fn update<T: ObjectWrite>(&mut self, old: PlainRef, obj: T) -> Result<RcRef<T>>;
     fn promise<T: Object>(&mut self) -> PromisedRef<T>;
     fn fulfill<T: ObjectWrite>(&mut self, promise: PromisedRef<T>, obj: T) -> Result<RcRef<T>>;
+    fn update_ref<T: ObjectWrite>(&mut self, old: &RcRef<T>, obj: T) -> Result<RcRef<T>> {
+        self.update(old.get_ref().inner, obj)
+    }
 }
 
 pub struct NoUpdate;

pdf/src/object/stream.rs

@@ -177,7 +177,10 @@ impl<I: ObjectWrite> Stream<I> {
 }
 impl<I: ObjectWrite> ObjectWrite for Stream<I> {
     fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
-        self.to_pdf_stream(update).map(Primitive::Stream)
+        match self.inner_data {
+            StreamData::Original(_, id) => Ok(Primitive::Reference(id)),
+            _ => self.to_pdf_stream(update).map(Primitive::Stream),
+        }
     }
 }
 impl<I: DeepClone> DeepClone for Stream<I> {

pdf/src/object/types.rs

@@ -68,8 +68,11 @@ impl PageRc {
     pub fn create(page: Page, update: &mut impl Updater) -> Result<PageRc> {
         Ok(PageRc(update.create(PagesNode::Leaf(page))?))
     }
-    pub fn get_ref(&self) -> Ref<PagesNode> {
-        self.0.get_ref()
+    pub fn update(page: Page, old_page: &PageRc, update: &mut impl Updater) -> Result<PageRc> {
+        update.update(old_page.get_ref(), PagesNode::Leaf(page)).map(PageRc)
+    }
+    pub fn get_ref(&self) -> PlainRef {
+        self.0.inner
     }
 }
 impl Object for PageRc {
@@ -979,6 +982,9 @@ pub struct Annot {
     #[pdf(key="InkList")]
     pub ink_list: Option<Primitive>,
 
+    #[pdf(key="L")]
+    pub line: Option<Vec<f32>>,
+
     #[pdf(other)]
     pub other: Dictionary,
 }

pdf/src/primitive.rs

@@ -268,7 +268,10 @@ impl Object for PdfStream {
 }
 impl ObjectWrite for PdfStream {
     fn to_primitive(&self, update: &mut impl Updater) -> Result<Primitive> {
-        Ok(self.clone().into())
+        match self.inner {
+            StreamInner::InFile { id, .. } => Ok(Primitive::Reference(id)),
+            StreamInner::Pending { .. } => Ok(self.clone().into()),
+        }
     }
 }
 impl PdfStream {
@@ -277,14 +280,16 @@ impl PdfStream {
 
         writeln!(out, "stream")?;
         match self.inner {
-            StreamInner::InFile { .. } => {
-                unimplemented!()
+            StreamInner::InFile { id, .. } => {
+                Primitive::Reference(id).serialize(out)?;
             }
             StreamInner::Pending { ref data } => {
+                self.info.serialize(out)?;
+                writeln!(out, "stream")?;
                 out.write_all(data)?;
+                writeln!(out, "\nendstream")?;
             }
         }
-        writeln!(out, "\nendstream")?;
         Ok(())
     }
     pub fn raw_data(&self, resolve: &impl Resolve) -> Result<Arc<[u8]>> {