wip

src/mupdf_ffi.rs

@@ -4,13 +4,14 @@
 use mupdf_sys::{
     fz_clone_context, fz_color_params, fz_colorspace, fz_context, fz_device, fz_document,
     fz_drop_context, fz_drop_device, fz_drop_document, fz_drop_page, fz_drop_path, fz_drop_text,
-    fz_error_type_FZ_ERROR_GENERIC, fz_matrix, fz_page, fz_path, fz_rect, fz_stroke_state, fz_text,
+    fz_error_type_FZ_ERROR_GENERIC, fz_matrix, fz_page, fz_path, fz_path_walker, fz_point, fz_rect,
+    fz_stroke_state, fz_text, fz_transform_point, fz_transform_point_xy, fz_walk_path,
     mupdf_document_page_count, mupdf_drop_error, mupdf_error_t, mupdf_load_page,
     mupdf_new_base_context, mupdf_new_derived_device, mupdf_open_document, mupdf_run_page,
 };
 use std::{
     cell::Cell,
-    ffi::{CStr, CString, c_int},
+    ffi::{CStr, CString, c_int, c_void},
     fmt,
     marker::PhantomData,
     mem::ManuallyDrop,
@@ -542,11 +543,158 @@ struct DeviceStruct<T> {
     value: Box<T>,
 }
 
+pub(crate) trait PathWalker<'ctx> {
+    fn move_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32);
+    fn line_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32);
+    fn curve_to(
+        &mut self,
+        ctx: ContextRef<'ctx>,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    );
+    fn close_path(&mut self, ctx: ContextRef<'ctx>);
+    fn rect_to(&mut self, ctx: ContextRef<'ctx>, x1: f32, y1: f32, x2: f32, y2: f32) {
+        self.move_to(ctx, x1, y1);
+        self.move_to(ctx, x2, y1);
+        self.move_to(ctx, x2, y2);
+        self.move_to(ctx, x1, y2);
+        self.close_path(ctx);
+    }
+}
+
+impl<'ctx, T: ?Sized + PathWalker<'ctx>> PathWalker<'ctx> for &'_ mut T {
+    fn move_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32) {
+        T::move_to(self, ctx, x, y);
+    }
+
+    fn line_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32) {
+        T::line_to(self, ctx, x, y);
+    }
+
+    fn curve_to(
+        &mut self,
+        ctx: ContextRef<'ctx>,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    ) {
+        T::curve_to(self, ctx, x1, y1, x2, y2, x3, y3);
+    }
+
+    fn close_path(&mut self, ctx: ContextRef<'ctx>) {
+        T::close_path(self, ctx);
+    }
+
+    fn rect_to(&mut self, ctx: ContextRef<'ctx>, x1: f32, y1: f32, x2: f32, y2: f32) {
+        T::rect_to(self, ctx, x1, y1, x2, y2);
+    }
+}
+
 pub(crate) struct Path<'ctx> {
     ptr: *mut fz_path,
     ctx: ContextRef<'ctx>,
 }
 
+impl<'ctx> Path<'ctx> {
+    pub(crate) fn walk<W: PathWalker<'ctx>>(&self, mut walker: W) {
+        unsafe {
+            fz_walk_path(
+                self.ctx.0.as_ptr(),
+                self.ptr,
+                const {
+                    &fz_path_walker {
+                        moveto: Some(Self::move_to_fn::<W>),
+                        lineto: Some(Self::line_to_fn::<W>),
+                        curveto: Some(Self::curve_to_fn::<W>),
+                        closepath: Some(Self::close_path_fn::<W>),
+                        quadto: None,
+                        curvetov: None,
+                        curvetoy: None,
+                        rectto: Some(Self::rect_to_fn::<W>),
+                    }
+                },
+                (&raw mut walker).cast(),
+            );
+        }
+    }
+    unsafe extern "C" fn move_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x: f32,
+        y: f32,
+    ) {
+        let Some(ctx) = NonNull::new(ctx) else {
+            return;
+        };
+        let ctx = ContextRef(ctx, PhantomData);
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.move_to(ctx, x, y);
+    }
+    unsafe extern "C" fn line_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x: f32,
+        y: f32,
+    ) {
+        let Some(ctx) = NonNull::new(ctx) else {
+            return;
+        };
+        let ctx = ContextRef(ctx, PhantomData);
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.line_to(ctx, x, y);
+    }
+    unsafe extern "C" fn curve_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    ) {
+        let Some(ctx) = NonNull::new(ctx) else {
+            return;
+        };
+        let ctx = ContextRef(ctx, PhantomData);
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.curve_to(ctx, x1, y1, x2, y2, x3, y3);
+    }
+    unsafe extern "C" fn close_path_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+    ) {
+        let Some(ctx) = NonNull::new(ctx) else {
+            return;
+        };
+        let ctx = ContextRef(ctx, PhantomData);
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.close_path(ctx);
+    }
+    unsafe extern "C" fn rect_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+    ) {
+        let Some(ctx) = NonNull::new(ctx) else {
+            return;
+        };
+        let ctx = ContextRef(ctx, PhantomData);
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.rect_to(ctx, x1, y1, x2, y2);
+    }
+}
+
 impl<'ctx> Drop for Path<'ctx> {
     fn drop(&mut self) {
         unsafe {
@@ -567,3 +715,11 @@ impl<'ctx> Drop for Text<'ctx> {
         }
     }
 }
+
+pub(crate) fn transform_point(point: fz_point, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_point(point, m) }
+}
+
+pub(crate) fn transform_point_xy(x: f32, y: f32, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_point_xy(x, y, m) }
+}