From 99792b5c4634d439ebaf681ac7955a74ef18b319 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 13 Jan 2015 08:23:20 -0800
Subject: [PATCH] Support cubic Bezier curves

---
 src/azure-c.cpp | 18 ++++++++++++++++++
 src/azure-c.h   |  5 +++++
 src/azure.rs    |  7 +++++++
 src/azure_hl.rs | 41 +++++++++++++++++++++++++++++++++++++++--
 4 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/src/azure-c.cpp b/src/azure-c.cpp
index c68827f..daf3520 100644
--- a/src/azure-c.cpp
+++ b/src/azure-c.cpp
@@ -668,6 +668,24 @@ extern "C" void AzPathBuilderArc(AzPathBuilderRef aPathBuilder,
     gfxPathBuilder->Arc(*gfxOrigin, aRadius, aStartAngle, aEndAngle, aAntiClockwise);
 }
 
+extern "C" void
+AzPathBuilderBezierTo(AzPathBuilderRef aPathBuilder,
+                      const AzPoint *aControlPoint1,
+                      const AzPoint *aControlPoint2,
+                      const AzPoint *aControlPoint3) {
+    gfx::PathBuilder *gfxPathBuilder = static_cast<gfx::PathBuilder*>(aPathBuilder);
+    const gfx::Point *gfxControlPoint1 = reinterpret_cast<const gfx::Point*>(aControlPoint1);
+    const gfx::Point *gfxControlPoint2 = reinterpret_cast<const gfx::Point*>(aControlPoint2);
+    const gfx::Point *gfxControlPoint3 = reinterpret_cast<const gfx::Point*>(aControlPoint3);
+    gfxPathBuilder->BezierTo(*gfxControlPoint1, *gfxControlPoint2, *gfxControlPoint3);
+}
+
+extern "C" void
+AzPathBuilderClose(AzPathBuilderRef aPathBuilder) {
+    gfx::PathBuilder *gfxPathBuilder = static_cast<gfx::PathBuilder*>(aPathBuilder);
+    gfxPathBuilder->Close();
+}
+
 extern "C" AzPathRef
 AzPathBuilderFinish(AzPathBuilderRef aPathBuilder) {
     gfx::PathBuilder *gfxPathBuilder = static_cast<gfx::PathBuilder*>(aPathBuilder);
diff --git a/src/azure-c.h b/src/azure-c.h
index 36e9661..8802a28 100644
--- a/src/azure-c.h
+++ b/src/azure-c.h
@@ -453,6 +453,11 @@ void AzPathBuilderArc(AzPathBuilderRef aPathBuilder,
                       AzFloat aStartAngle,
                       AzFloat aEndAngle,
                       bool aAntiClockwise);
+void AzPathBuilderBezierTo(AzPathBuilderRef aPathBuilder,
+                           const AzPoint *aControlPoint1,
+                           const AzPoint *aControlPoint2,
+                           const AzPoint *aControlPoint3);
+void AzPathBuilderClose(AzPathBuilderRef aPathBuilder);
 AzPathRef AzPathBuilderFinish(AzPathBuilderRef aPathBuilder);
 
 AzLinearGradientPatternRef AzCreateLinearGradientPattern(const AzPoint *aBegin,
diff --git a/src/azure.rs b/src/azure.rs
index f2187c6..afd7207 100644
--- a/src/azure.rs
+++ b/src/azure.rs
@@ -588,6 +588,13 @@ pub fn AzPathBuilderArc(aPathBuilder: AzPathBuilderRef,
                         aEndAngle: AzFloat,
                         aAntiClockwise: bool);
 
+pub fn AzPathBuilderBezierTo(aPathBuilder: AzPathBuilderRef,
+                             aControlPoint1: *const AzPoint,
+                             aControlPoint2: *const AzPoint,
+                             aControlPoint3: *const AzPoint);
+
+pub fn AzPathBuilderClose(aPathBuilder: AzPathBuilderRef);
+
 pub fn AzPathBuilderFinish(aPathBuilder: AzPathBuilderRef) -> AzPathRef;
 
 pub fn AzReleasePath(aPath: AzPathRef);
diff --git a/src/azure_hl.rs b/src/azure_hl.rs
index 4d9723d..732a08f 100644
--- a/src/azure_hl.rs
+++ b/src/azure_hl.rs
@@ -53,7 +53,8 @@ use azure::{AzFilterNodeSetSourceSurfaceInput, AzReleaseFilterNode, AzDrawTarget
 use azure::{AzFilterNodeSetColorAttribute, AzFilterNodeSetFloatAttribute};
 use azure::{AzFilterNodeSetMatrix5x4Attribute, AzFilterNodeSetFilterNodeInput};
 use azure::{AzFilterNodeSetFloatArrayAttribute, AzFilterNodeSetBoolAttribute};
-use azure::{AzDrawTargetDrawFilter, AzFilterNodeRef, AzFilterType};
+use azure::{AzDrawTargetDrawFilter, AzFilterNodeRef, AzFilterType, AzPathBuilderBezierTo};
+use azure::{AzPathBuilderClose};
 
 use std::sync::Arc;
 use geom::matrix2d::Matrix2D;
@@ -404,7 +405,7 @@ impl DrawTarget {
                          size: Size2D<i32>,
                          stride: i32,
                          format: SurfaceFormat) -> DrawTarget {
-        assert!((data.len() - offset) as i32 >= stride * size.height);
+        assert!((data.len() - (offset as usize)) as i32 >= stride * size.height);
         let azure_draw_target = unsafe {
             AzCreateDrawTargetForData(backend.as_azure_backend_type(),
                                       data.as_mut_slice().as_mut_ptr().offset(offset as int),
@@ -955,6 +956,26 @@ impl PathBuilder {
         }
     }
 
+    /// Adds a cubic Bézier curve to the current figure.
+    pub fn bezier_curve_to(&self,
+                           control_point_1: &Point2D<AzFloat>,
+                           control_point_2: &Point2D<AzFloat>,
+                           control_point_3: &Point2D<AzFloat>) {
+        unsafe {
+            AzPathBuilderBezierTo(self.azure_path_builder,
+                                  &control_point_1.as_azure_point(),
+                                  &control_point_2.as_azure_point(),
+                                  &control_point_3.as_azure_point())
+        }
+    }
+
+    /// Closes the current path.
+    pub fn close(&self) {
+        unsafe {
+            AzPathBuilderClose(self.azure_path_builder)
+        }
+    }
+
     pub fn finish(&self) -> Path {
         let az_path = unsafe { AzPathBuilderFinish(self.azure_path_builder) };
         Path {
@@ -1025,6 +1046,22 @@ pub fn current_gl_context() -> AzGLContext {
     }
 }
 
+pub enum Pattern {
+    Color(ColorPattern),
+    LinearGradient(LinearGradientPattern),
+}
+
+impl Pattern {
+    pub fn to_pattern_ref(&self) -> PatternRef {
+        match *self {
+            Pattern::Color(ref color_pattern) => PatternRef::Color(color_pattern),
+            Pattern::LinearGradient(ref linear_gradient_pattern) => {
+                PatternRef::LinearGradient(linear_gradient_pattern)
+            }
+        }
+    }
+}
+
 pub struct FilterNode {
     pub azure_filter_node: AzFilterNodeRef,
 }