Move to_{html,xhtml,xml,text,json} methods from Page to TextPage

examples/extract_images.rs

@@ -1,23 +1,21 @@
 use std::io::Write;
 
+use mupdf::{Document, ImageFormat, TextPageFlags};
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let filename: String = std::env::args()
-        .collect::<Vec<_>>()
-        .get(1)
-        .expect("missing filename")
-        .to_owned();
-    let document = mupdf::document::Document::open(&filename)?;
+    let filename: String = std::env::args().nth(1).expect("missing filename");
+    let document = Document::open(&filename)?;
 
     let mut image_num: u32 = 0;
 
     for page in document.pages()? {
-        let text_page = page?.to_text_page(mupdf::text_page::TextPageOptions::PRESERVE_IMAGES)?;
+        let text_page = page?.to_text_page(TextPageFlags::PRESERVE_IMAGES)?;
 
         for block in text_page.blocks() {
             if let Some(image) = block.image() {
                 let pixmap = image.to_pixmap()?;
                 let mut bytes: Vec<u8> = vec![];
-                pixmap.write_to(&mut bytes, mupdf::pixmap::ImageFormat::PNG)?;
+                pixmap.write_to(&mut bytes, ImageFormat::PNG)?;
 
                 let mut output_file = std::fs::File::create(format!("output_{}.png", image_num))?;
                 output_file.write_all(&bytes)?;

examples/extract_stext.rs

@@ -1,33 +1,23 @@
-use std::io;
+use mupdf::{page::StextPage, Document, TextPageFlags};
 
-fn main() {
-    // cargo run --example extract_stext
-    let mut path_to_doc = String::new();
-    println!("Enter a path to document: ");
-    io::stdin()
-        .read_line(&mut path_to_doc)
-        .expect("Failed to read line");
-    let doc = mupdf::document::Document::open(path_to_doc.trim()).unwrap();
-    let page = doc.load_page(0).unwrap();
-    match page.stext_page_as_json_from_page(1.0) {
-        Ok(stext_json) => {
-            let stext_page: serde_json::Result<mupdf::page::StextPage> =
-                serde_json::from_str(stext_json.as_str());
-            match stext_page {
-                Ok(res) => {
-                    for block in res.blocks {
-                        if block.r#type.eq("text") {
-                            for line in block.lines {
-                                println!("{:?}", &line.text);
-                            }
-                        }
-                    }
-                }
-                Err(err) => {
-                    println!("stext_page parsing error: {:?}", &err);
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let filename: String = std::env::args().nth(1).expect("missing filename");
+    let document = Document::open(&filename)?;
+
+    for page in document.pages()? {
+        let text_page = page?.to_text_page(TextPageFlags::empty())?;
+
+        let json = text_page.to_json(1.0)?;
+        let stext_page: StextPage = serde_json::from_str(json.as_str())?;
+
+        for block in stext_page.blocks {
+            if block.r#type == "text" {
+                for line in block.lines {
+                    println!("{:?}", &line.text);
                 }
             }
         }
-        Err(_err) => {}
     }
+
+    Ok(())
 }

examples/extract_text.rs

@@ -1,13 +1,11 @@
+use mupdf::{Document, TextPageFlags};
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let filename: String = std::env::args()
-        .collect::<Vec<_>>()
-        .get(1)
-        .expect("missing filename")
-        .to_owned();
-    let document = mupdf::document::Document::open(&filename)?;
+    let filename: String = std::env::args().nth(1).expect("missing filename");
+    let document = Document::open(&filename)?;
 
     for page in document.pages()? {
-        let text_page = page?.to_text_page(mupdf::text_page::TextPageOptions::empty())?;
+        let text_page = page?.to_text_page(TextPageFlags::empty())?;
 
         for block in text_page.blocks() {
             for line in block.lines() {

mupdf-sys/wrapper.c

@@ -774,14 +774,12 @@ fz_buffer *mupdf_page_to_svg(fz_context *ctx, fz_page *page, fz_matrix ctm, fz_c
     return buf;
 }
 
-fz_stext_page *mupdf_page_to_text_page(fz_context *ctx, fz_page *page, int flags, mupdf_error_t **errptr)
+fz_stext_page *mupdf_new_stext_page_from_page(fz_context *ctx, fz_page *page, const fz_stext_options *options, mupdf_error_t **errptr)
 {
     fz_stext_page *text_page = NULL;
-    fz_stext_options opts = {0};
-    opts.flags = flags;
     fz_try(ctx)
     {
-        text_page = fz_new_stext_page_from_page(ctx, page, &opts);
+        text_page = fz_new_stext_page_from_page(ctx, page, options);
     }
     fz_catch(ctx)
     {
@@ -859,148 +857,77 @@ void mupdf_run_page_widgets(fz_context *ctx, fz_page *page, fz_device *device, f
     }
 }
 
-fz_buffer *mupdf_page_to_html(fz_context *ctx, fz_page *page, mupdf_error_t **errptr)
+fz_output *mupdf_new_output_with_buffer(fz_context *ctx, fz_buffer *buf, mupdf_error_t **errptr) {
+	fz_output* output;
+	fz_try(ctx)
+	{
+		output = fz_new_output_with_buffer(ctx, buf);
+	}
+	fz_catch(ctx)
+	{
+        mupdf_save_error(ctx, errptr);
+	}
+	return output;
+}
+
+void mupdf_print_stext_page_as_html(fz_context *ctx, fz_output *out, fz_stext_page *page, int id, mupdf_error_t **errptr)
 {
-    fz_buffer *buf = NULL;
-    fz_output *out = NULL;
-    fz_stext_page *text = NULL;
-    fz_var(text);
-    fz_var(buf);
-    fz_var(out);
-    fz_try(ctx)
-    {
-        text = fz_new_stext_page_from_page(ctx, page, NULL);
-        buf = fz_new_buffer(ctx, 8192);
-        out = fz_new_output_with_buffer(ctx, buf);
-        fz_print_stext_header_as_html(ctx, out);
-        fz_print_stext_page_as_html(ctx, out, text, page->number);
-        fz_print_stext_trailer_as_html(ctx, out);
-        fz_close_output(ctx, out);
-    }
-    fz_always(ctx)
+	fz_try(ctx)
     {
-        fz_drop_output(ctx, out);
-        fz_drop_stext_page(ctx, text);
+        fz_print_stext_page_as_html(ctx, out, page, id);
     }
     fz_catch(ctx)
     {
         mupdf_save_error(ctx, errptr);
     }
-    return buf;
 }
 
-fz_buffer *mupdf_stext_page_as_json_from_page(fz_context *ctx, fz_page *page, float scale, mupdf_error_t **errptr)
+void mupdf_print_stext_page_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_page *page, int id, mupdf_error_t **errptr)
 {
-    fz_buffer *buf = NULL;
-    fz_output *out = NULL;
-    fz_stext_page *stext_page = NULL;
-    fz_var(stext_page);
-    fz_var(buf);
-    fz_var(out);
-    fz_try(ctx)
-    {
-        stext_page = fz_new_stext_page_from_page(ctx, page, NULL);
-        buf = fz_new_buffer(ctx, 8192);
-        out = fz_new_output_with_buffer(ctx, buf);
-        fz_print_stext_page_as_json(ctx, out, stext_page, scale);
-        fz_close_output(ctx, out);
-    }
-    fz_always(ctx)
+	fz_try(ctx)
     {
-        fz_drop_output(ctx, out);
-        fz_drop_stext_page(ctx, stext_page);
+        fz_print_stext_page_as_xhtml(ctx, out, page, id);
     }
     fz_catch(ctx)
     {
         mupdf_save_error(ctx, errptr);
     }
-    return buf;
 }
 
-fz_buffer *mupdf_page_to_xhtml(fz_context *ctx, fz_page *page, mupdf_error_t **errptr)
+void mupdf_print_stext_page_as_xml(fz_context *ctx, fz_output *out, fz_stext_page *page, int id, mupdf_error_t **errptr)
 {
-    fz_buffer *buf = NULL;
-    fz_output *out = NULL;
-    fz_stext_page *text = NULL;
-    fz_var(text);
-    fz_var(buf);
-    fz_var(out);
-    fz_try(ctx)
-    {
-        text = fz_new_stext_page_from_page(ctx, page, NULL);
-        buf = fz_new_buffer(ctx, 8192);
-        out = fz_new_output_with_buffer(ctx, buf);
-        fz_print_stext_header_as_xhtml(ctx, out);
-        fz_print_stext_page_as_xhtml(ctx, out, text, page->number);
-        fz_print_stext_trailer_as_xhtml(ctx, out);
-        fz_close_output(ctx, out);
-    }
-    fz_always(ctx)
+	fz_try(ctx)
     {
-        fz_drop_output(ctx, out);
-        fz_drop_stext_page(ctx, text);
+        fz_print_stext_page_as_xml(ctx, out, page, id);
     }
     fz_catch(ctx)
     {
         mupdf_save_error(ctx, errptr);
     }
-    return buf;
 }
 
-fz_buffer *mupdf_page_to_xml(fz_context *ctx, fz_page *page, mupdf_error_t **errptr)
+void mupdf_print_stext_page_as_text(fz_context *ctx, fz_output *out, fz_stext_page *page, mupdf_error_t **errptr)
 {
-    fz_buffer *buf = NULL;
-    fz_output *out = NULL;
-    fz_stext_page *text = NULL;
-    fz_var(text);
-    fz_var(buf);
-    fz_var(out);
-    fz_try(ctx)
-    {
-        text = fz_new_stext_page_from_page(ctx, page, NULL);
-        buf = fz_new_buffer(ctx, 8192);
-        out = fz_new_output_with_buffer(ctx, buf);
-        fz_print_stext_page_as_xml(ctx, out, text, page->number);
-        fz_close_output(ctx, out);
-    }
-    fz_always(ctx)
+	fz_try(ctx)
     {
-        fz_drop_output(ctx, out);
-        fz_drop_stext_page(ctx, text);
+        fz_print_stext_page_as_text(ctx, out, page);
     }
     fz_catch(ctx)
     {
         mupdf_save_error(ctx, errptr);
     }
-    return buf;
 }
 
-fz_buffer *mupdf_page_to_text(fz_context *ctx, fz_page *page, mupdf_error_t **errptr)
+void mupdf_print_stext_page_as_json(fz_context *ctx, fz_output *out, fz_stext_page *page, float scale, mupdf_error_t **errptr)
 {
-    fz_buffer *buf = NULL;
-    fz_output *out = NULL;
-    fz_stext_page *text = NULL;
-    fz_var(text);
-    fz_var(buf);
-    fz_var(out);
     fz_try(ctx)
     {
-        text = fz_new_stext_page_from_page(ctx, page, NULL);
-        buf = fz_new_buffer(ctx, 8192);
-        out = fz_new_output_with_buffer(ctx, buf);
-        fz_print_stext_page_as_text(ctx, out, text);
-        fz_close_output(ctx, out);
-    }
-    fz_always(ctx)
-    {
-        fz_drop_output(ctx, out);
-        fz_drop_stext_page(ctx, text);
+        fz_print_stext_page_as_json(ctx, out, page, scale);
     }
     fz_catch(ctx)
     {
         mupdf_save_error(ctx, errptr);
     }
-    return buf;
 }
 
 fz_link *mupdf_load_links(fz_context *ctx, fz_page *page, mupdf_error_t **errptr)
@@ -1017,30 +944,6 @@ fz_link *mupdf_load_links(fz_context *ctx, fz_page *page, mupdf_error_t **errptr
     return link;
 }
 
-fz_buffer *mupdf_stext_page_to_text(fz_context *ctx, fz_stext_page *page, mupdf_error_t **errptr)
-{
-    fz_buffer *buf = NULL;
-    fz_output *out = NULL;
-    fz_var(buf);
-    fz_var(out);
-    fz_try(ctx)
-    {
-        buf = fz_new_buffer(ctx, 8192);
-        out = fz_new_output_with_buffer(ctx, buf);
-        fz_print_stext_page_as_text(ctx, out, page);
-        fz_close_output(ctx, out);
-    }
-    fz_always(ctx)
-    {
-        fz_drop_output(ctx, out);
-    }
-    fz_catch(ctx)
-    {
-        mupdf_save_error(ctx, errptr);
-    }
-    return buf;
-}
-
 fz_separations *mupdf_page_separations(fz_context *ctx, fz_page *page, mupdf_error_t **errptr)
 {
     fz_separations *seps = NULL;

src/device.rs

@@ -6,8 +6,8 @@ use mupdf_sys::*;
 use num_enum::TryFromPrimitive;
 
 use crate::{
-    context, ColorParams, Colorspace, DisplayList, Error, IRect, Image, Matrix, Path, Pixmap, Rect,
-    Shade, StrokeState, Text, TextPage, TextPageOptions,
+    context, ColorParams, Colorspace, DisplayList, Error, FFIWrapper, IRect, Image, Matrix, Path,
+    Pixmap, Rect, Shade, StrokeState, Text, TextPage, TextPageFlags,
 };
 
 mod native;
@@ -206,11 +206,11 @@ impl Device {
         })
     }
 
-    pub fn from_text_page(page: &TextPage, opts: TextPageOptions) -> Result<Self, Error> {
+    pub fn from_text_page(page: &TextPage, opts: TextPageFlags) -> Result<Self, Error> {
         unsafe {
             ffi_try!(mupdf_new_stext_device(
                 context(),
-                page.inner,
+                page.as_ptr().cast_mut(),
                 opts.bits() as _
             ))
         }

src/display_list.rs

@@ -1,10 +1,10 @@
-use std::ffi::CString;
+use std::{ffi::CString, ptr::NonNull};
 
 use mupdf_sys::*;
 
 use crate::{
     array::FzArray, context, rust_vec_from_ffi_ptr, Colorspace, Cookie, Device, Error, Image,
-    Matrix, Pixmap, Quad, Rect, TextPage, TextPageOptions,
+    Matrix, Pixmap, Quad, Rect, TextPage, TextPageFlags,
 };
 
 #[derive(Debug)]
@@ -40,15 +40,18 @@ impl DisplayList {
         .map(|inner| unsafe { Pixmap::from_raw(inner) })
     }
 
-    pub fn to_text_page(&self, opts: TextPageOptions) -> Result<TextPage, Error> {
-        unsafe {
+    pub fn to_text_page(&self, opts: TextPageFlags) -> Result<TextPage, Error> {
+        let inner = unsafe {
             ffi_try!(mupdf_display_list_to_text_page(
                 context(),
                 self.inner,
                 opts.bits() as _
-            ))
-        }
-        .map(|inner| unsafe { TextPage::from_raw(inner) })
+            ))?
+        };
+
+        let inner = unsafe { NonNull::new_unchecked(inner) };
+
+        Ok(TextPage { inner })
     }
 
     pub fn to_image(&self, width: f32, height: f32) -> Result<Image, Error> {