Add the stub legalizer code to the C API

partitionfinder/src/capi.rs

@@ -1,13 +1,28 @@
 // partitionfinder/capi.rs
 
 use env_logger;
-use euclid::Transform2D;
+use euclid::{Point2D, Transform2D};
+use legalizer::Legalizer;
 use partitioner::Partitioner;
 use tessellator::{QuadTessLevels, Tessellator};
 use std::mem;
 use std::slice;
 use {AntialiasingMode, BQuad, ControlPoints, EdgeInstance, Endpoint, Subpath, Vertex};
 
+#[derive(Clone, Copy)]
+#[repr(C)]
+pub struct Point2DF32 {
+    pub x: f32,
+    pub y: f32,
+}
+
+impl Point2DF32 {
+    #[inline]
+    pub fn to_point2d(&self) -> Point2D<f32> {
+        Point2D::new(self.x, self.y)
+    }
+}
+
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub struct Matrix2DF32 {
@@ -19,6 +34,86 @@ pub struct Matrix2DF32 {
     pub m12: f32,
 }
 
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_new() -> *mut Legalizer {
+    let mut legalizer = Box::new(Legalizer::new());
+    let legalizer_ptr: *mut Legalizer = &mut *legalizer;
+    mem::forget(legalizer);
+    legalizer_ptr
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_destroy(legalizer: *mut Legalizer) {
+    drop(mem::transmute::<*mut Legalizer, Box<Legalizer>>(legalizer))
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_endpoints(legalizer: *const Legalizer,
+                                            out_endpoint_count: *mut u32)
+                                            -> *const Endpoint {
+    let endpoints = (*legalizer).endpoints();
+    if !out_endpoint_count.is_null() {
+        *out_endpoint_count = endpoints.len() as u32
+    }
+    endpoints.as_ptr()
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_control_points(legalizer: *const Legalizer,
+                                                 out_control_points_count: *mut u32)
+                                                 -> *const ControlPoints {
+    let control_points = (*legalizer).control_points();
+    if !out_control_points_count.is_null() {
+        *out_control_points_count = control_points.len() as u32
+    }
+    control_points.as_ptr()
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_subpaths(legalizer: *const Legalizer,
+                                           out_subpaths_count: *mut u32)
+                                           -> *const Subpath {
+    let subpaths = (*legalizer).subpaths();
+    if !out_subpaths_count.is_null() {
+        *out_subpaths_count = subpaths.len() as u32
+    }
+    subpaths.as_ptr()
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_move_to(legalizer: *mut Legalizer,
+                                          position: *const Point2DF32) {
+    (*legalizer).move_to(&(*position).to_point2d())
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_close_path(legalizer: *mut Legalizer) {
+    (*legalizer).close_path()
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_line_to(legalizer: *mut Legalizer,
+                                          endpoint: *const Point2DF32) {
+    (*legalizer).line_to(&(*endpoint).to_point2d())
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_quadratic_curve_to(legalizer: *mut Legalizer,
+                                                     control_point: *const Point2DF32,
+                                                     endpoint: *const Point2DF32) {
+    (*legalizer).quadratic_curve_to(&(*control_point).to_point2d(), &(*endpoint).to_point2d())
+}
+
+#[no_mangle]
+pub unsafe extern fn pf_legalizer_bezier_curve_to(legalizer: *mut Legalizer,
+                                                  point1: *const Point2DF32,
+                                                  point2: *const Point2DF32,
+                                                  endpoint: *const Point2DF32) {
+    (*legalizer).bezier_curve_to(&(*point1).to_point2d(),
+                                 &(*point2).to_point2d(),
+                                 &(*endpoint).to_point2d())
+}
+
 #[no_mangle]
 pub unsafe extern fn pf_partitioner_new() -> *mut Partitioner<'static> {
     let mut partitioner = Box::new(Partitioner::new());

partitionfinder/src/partitionfinder.h

@@ -84,6 +84,10 @@ struct pf_subpath {
 
 typedef struct pf_subpath pf_subpath_t;
 
+struct pf_legalizer;
+
+typedef struct pf_legalizer pf_legalizer_t;
+
 struct pf_partitioner;
 
 typedef struct pf_partitioner pf_partitioner_t;
@@ -92,6 +96,34 @@ struct pf_tessellator;
 
 typedef struct pf_tessellator pf_tessellator_t;
 
+pf_legalizer_t *pf_legalizer_new();
+
+void pf_legalizer_destroy(Legalizer *legalizer);
+
+const pf_endpoint_t *pf_legalizer_endpoints(const Legalizer *legalizer,
+                                            uint32_t *out_endpoint_count);
+
+const pf_control_points_t *pf_legalizer_control_points(const Legalizer *legalizer,
+                                                       uitn32_t *out_control_points_count);
+
+const pf_subpath_t *pf_legalizer_subpaths(const Legalizer *legalizer,
+                                          uint32_t *out_subpaths_count);
+
+void pf_legalizer_move_to(Legalizer *legalizer, const pf_point2d_f32_t *position);
+
+void pf_legalizer_close_path(Legalizer *legalizer);
+
+void pf_legalizer_line_to(Legalizer *legalizer, const pf_point2d_f32_t *endpoint);
+
+void pf_legalizer_quadratic_curve_to(Legalizer *legalizer,
+                                     const pf_point2d_f32_t *control_point,
+                                     const pf_point2d_f32_t *endpoint);
+
+void pf_legalizer_bezier_curve_to(Legalizer *legalizer,
+                                  const pf_point2d_f32_t *point1,
+                                  const pf_point2d_f32_t *point2,
+                                  const pf_point2d_f32_t *endpoint);
+
 pf_partitioner_t *pf_partitioner_new();
 
 void pf_partitioner_destroy(pf_partitioner_t *partitioner);