Get tests passing and implement more Context functions

Author: mikowitz

lib/xairo/context.ex

@@ -38,15 +38,15 @@ defmodule Xairo.Context do
   end
 
   def stroke_preserve(%__MODULE__{context: ctx} = this) do
-    with {:ok, _} <- Xairo.Native.context_stroke(ctx), do: this
+    with {:ok, _} <- Xairo.Native.context_stroke_preserve(ctx), do: this
   end
 
   def fill(%__MODULE__{context: ctx} = this) do
     with {:ok, _} <- Xairo.Native.context_fill(ctx), do: this
   end
 
   def fill_preserve(%__MODULE__{context: ctx} = this) do
-    with {:ok, _} <- Xairo.Native.context_fill(ctx), do: this
+    with {:ok, _} <- Xairo.Native.context_fill_preserve(ctx), do: this
   end
 
   def move_to(%__MODULE__{context: ctx} = this, x, y) do
@@ -59,6 +59,46 @@ defmodule Xairo.Context do
     this
   end
 
+  def curve_to(%__MODULE__{context: ctx} = this, x1, y1, x2, y2, x3, y3) do
+    Xairo.Native.context_curve_to(ctx, x1 / 1, y1 / 1, x2 / 1, y2 / 1, x3 / 1, y3 / 1)
+    this
+  end
+
+  def rel_move_to(%__MODULE__{context: ctx} = this, x, y) do
+    Xairo.Native.context_rel_move_to(ctx, x / 1, y / 1)
+    this
+  end
+
+  def rel_line_to(%__MODULE__{context: ctx} = this, x, y) do
+    Xairo.Native.context_rel_line_to(ctx, x / 1, y / 1)
+    this
+  end
+
+  def rel_curve_to(%__MODULE__{context: ctx} = this, x1, y1, x2, y2, x3, y3) do
+    Xairo.Native.context_rel_curve_to(ctx, x1 / 1, y1 / 1, x2 / 1, y2 / 1, x3 / 1, y3 / 1)
+    this
+  end
+
+  def arc(%__MODULE__{context: ctx} = this, cx, cy, r, a1, a2) do
+    Xairo.Native.context_arc(ctx, cx / 1, cy / 1, r / 1, a1 / 1, a2 / 1)
+    this
+  end
+
+  def arc_negative(%__MODULE__{context: ctx} = this, cx, cy, r, a1, a2) do
+    Xairo.Native.context_arc_negative(ctx, cx / 1, cy / 1, r / 1, a1 / 1, a2 / 1)
+    this
+  end
+
+  def new_path(%__MODULE__{context: ctx} = this) do
+    Xairo.Native.context_new_path(ctx)
+    this
+  end
+
+  def new_sub_path(%__MODULE__{context: ctx} = this) do
+    Xairo.Native.context_new_sub_path(ctx)
+    this
+  end
+
   def rectangle(%__MODULE__{context: ctx} = this, x, y, w, h) do
     Xairo.Native.context_rectangle(ctx, x / 1, y / 1, w / 1, h / 1)
     this

lib/xairo/native.ex

@@ -139,8 +139,16 @@ defmodule Xairo.Native do
   def context_paint_with_alpha(_c, _a), do: error()
   def context_move_to(_c, _x, _y), do: error()
   def context_line_to(_c, _x, _y), do: error()
+  def context_rel_move_to(_c, _x, _y), do: error()
+  def context_rel_line_to(_c, _x, _y), do: error()
   def context_rectangle(_c, _x, _y, _w, _h), do: error()
   def context_close_path(_c), do: error()
+  def context_curve_to(_c, _x1, _y1, _x2, _y2, _x3, _y3), do: error()
+  def context_rel_curve_to(_c, _x1, _y1, _x2, _y2, _x3, _y3), do: error()
+  def context_arc(_c, _x, _y, _r, _a1, _a2), do: error()
+  def context_arc_negative(_c, _x, _y, _r, _a1, _a2), do: error()
+  def context_new_path(_c), do: error()
+  def context_new_sub_path(_c), do: error()
 
   def stride_for_width(_f, _w), do: error()
 

native/xairo/src/context.rs

@@ -1,5 +1,5 @@
-use crate::image_surface::ImageSurface;
 use crate::error::XairoError;
+use crate::image_surface::ImageSurface;
 use rustler::ResourceArc;
 
 pub struct ContextRaw {
@@ -15,15 +15,15 @@ pub type Context = ResourceArc<ContextRaw>;
 fn context_new_from_image_surface(surface: ImageSurface) -> Result<Context, XairoError> {
     match cairo::Context::new(&surface.surface) {
         Ok(context) => Ok(ResourceArc::new(ContextRaw { context })),
-        Err(err) => Err(err.into())
+        Err(err) => Err(err.into()),
     }
 }
 
 #[rustler::nif]
 fn context_status(context: Context) -> Result<(), XairoError> {
     match context.context.status() {
         Ok(_) => Ok(()),
-        Err(err) => Err(err.into())
+        Err(err) => Err(err.into()),
     }
 }
 
@@ -32,27 +32,56 @@ fn context_set_source_rgb(context: Context, r: f64, g: f64, b: f64) {
     context.context.set_source_rgb(r, g, b);
 }
 
+#[rustler::nif]
+fn context_set_source_rgba(context: Context, r: f64, g: f64, b: f64, a: f64) {
+    context.context.set_source_rgba(r, g, b, a);
+}
+
 #[rustler::nif]
 fn context_paint(context: Context) -> Result<(), XairoError> {
     match context.context.paint() {
         Ok(_) => Ok(()),
-        Err(err) => Err(err.into())
+        Err(err) => Err(err.into()),
+    }
+}
+
+#[rustler::nif]
+fn context_paint_with_alpha(context: Context, alpha: f64) -> Result<(), XairoError> {
+    match context.context.paint_with_alpha(alpha) {
+        Ok(_) => Ok(()),
+        Err(err) => Err(err.into()),
     }
 }
 
 #[rustler::nif]
 fn context_fill(context: Context) -> Result<(), XairoError> {
     match context.context.fill() {
         Ok(_) => Ok(()),
-        Err(err) => Err(err.into())
+        Err(err) => Err(err.into()),
+    }
+}
+
+#[rustler::nif]
+fn context_fill_preserve(context: Context) -> Result<(), XairoError> {
+    match context.context.fill_preserve() {
+        Ok(_) => Ok(()),
+        Err(err) => Err(err.into()),
     }
 }
 
 #[rustler::nif]
 fn context_stroke(context: Context) -> Result<(), XairoError> {
     match context.context.stroke() {
         Ok(_) => Ok(()),
-        Err(err) => Err(err.into())
+        Err(err) => Err(err.into()),
+    }
+}
+
+#[rustler::nif]
+fn context_stroke_preserve(context: Context) -> Result<(), XairoError> {
+    match context.context.stroke_preserve() {
+        Ok(_) => Ok(()),
+        Err(err) => Err(err.into()),
     }
 }
 
@@ -61,12 +90,57 @@ fn context_move_to(context: Context, x: f64, y: f64) {
     context.context.move_to(x, y);
 }
 
+#[rustler::nif]
+fn context_rel_move_to(context: Context, x: f64, y: f64) {
+    context.context.rel_move_to(x, y);
+}
+
 #[rustler::nif]
 fn context_line_to(context: Context, x: f64, y: f64) {
     context.context.line_to(x, y);
 }
 
+#[rustler::nif]
+fn context_rel_line_to(context: Context, x: f64, y: f64) {
+    context.context.rel_line_to(x, y);
+}
+
+#[rustler::nif]
+fn context_rectangle(context: Context, x: f64, y: f64, w: f64, h: f64) {
+    context.context.rectangle(x, y, w, h);
+}
+
 #[rustler::nif]
 fn context_close_path(context: Context) {
     context.context.close_path();
 }
+
+#[rustler::nif]
+fn context_curve_to(context: Context, x1: f64, y1: f64, x2: f64, y2: f64, x3: f64, y3: f64) {
+    context.context.curve_to(x1, y1, x2, y2, x3, y3);
+}
+
+#[rustler::nif]
+fn context_rel_curve_to(context: Context, x1: f64, y1: f64, x2: f64, y2: f64, x3: f64, y3: f64) {
+    context.context.rel_curve_to(x1, y1, x2, y2, x3, y3);
+}
+
+#[rustler::nif]
+fn context_arc(context: Context, cx: f64, cy: f64, r: f64, a1: f64, a2: f64) {
+    context.context.arc(cx, cy, r, a1, a2);
+}
+
+#[rustler::nif]
+fn context_arc_negative(context: Context, cx: f64, cy: f64, r: f64, a1: f64, a2: f64) {
+    context.context.arc_negative(cx, cy, r, a1, a2);
+}
+
+#[rustler::nif]
+fn context_new_path(context: Context) {
+    context.context.new_path();
+}
+
+#[rustler::nif]
+fn context_new_sub_path(context: Context) {
+    context.context.new_sub_path();
+}

native/xairo/src/lib.rs

@@ -150,12 +150,25 @@ rustler::init!(
         context::context_new_from_image_surface,
         context::context_status,
         context::context_set_source_rgb,
+        context::context_set_source_rgba,
         context::context_paint,
+        context::context_paint_with_alpha,
         context::context_fill,
+        context::context_fill_preserve,
         context::context_stroke,
+        context::context_stroke_preserve,
         context::context_move_to,
+        context::context_rel_move_to,
         context::context_line_to,
+        context::context_rel_line_to,
+        context::context_rectangle,
         context::context_close_path,
+        context::context_curve_to,
+        context::context_rel_curve_to,
+        context::context_arc,
+        context::context_arc_negative,
+        context::context_new_path,
+        context::context_new_sub_path,
         // enums
         enums::stride_for_width,
     ],

priv/native/libxairo.so

@@ -42,13 +42,13 @@ defmodule Xairo.ContextTest do
       |> Context.close_path()
       |> Context.fill()
 
-      ImageSurface.write_to_png(surface, "basic_lines.png")
+      ImageSurface.write_to_png(surface, "basic_drawing1.png")
 
-      assert File.exists?("basic_lines.png")
+      assert File.exists?("basic_drawing1.png")
 
-      assert hash("basic_lines.png") == hash("test/images/basic_lines.png")
+      assert hash("basic_drawing1.png") == hash("test/images/basic_drawing1.png")
 
-      :ok = File.rm("basic_lines.png")
+      :ok = File.rm("basic_drawing1.png")
     end
 
     test "set_source_rgba, fill_preserve, stroke_preserve, paint_with_alpha, rectangle", %{
@@ -74,5 +74,49 @@ defmodule Xairo.ContextTest do
 
       :ok = File.rm("basic_drawing2.png")
     end
+
+    test "arc, arc_negative, curve, new_sub_path", %{context: ctx, surface: sfc} do
+      ctx
+      |> Context.set_source_rgb(1, 1, 1)
+      |> Context.paint()
+      |> Context.set_source_rgb(0, 0, 1)
+      |> Context.move_to(10, 10)
+      |> Context.curve_to(20, 20, 50, 30, 30, 80)
+      |> Context.arc(60, 40, 10, 0, 3.1)
+      |> Context.new_sub_path()
+      |> Context.arc_negative(70, 80, 20, 0, 3.1)
+      |> Context.stroke()
+
+      ImageSurface.write_to_png(sfc, "basic_drawing3.png")
+
+      assert File.exists?("basic_drawing3.png")
+
+      assert hash("basic_drawing3.png") == hash("test/images/basic_drawing3.png")
+
+      :ok = File.rm("basic_drawing3.png")
+    end
+
+    test "new_path, rel_line_to, rel_move_to, rel_curve_to", %{context: ctx, surface: sfc} do
+      ctx
+      |> Context.set_source_rgb(1, 1, 1)
+      |> Context.paint()
+      |> Context.set_source_rgb(0.5, 0.5, 1)
+      |> Context.move_to(10, 10)
+      |> Context.rel_line_to(30, 30)
+      |> Context.new_path()
+      |> Context.move_to(10, 15)
+      |> Context.rel_line_to(20, 25)
+      |> Context.rel_move_to(30, 25)
+      |> Context.rel_curve_to(10, 15, 20, -20, 30, 20)
+      |> Context.stroke()
+
+      ImageSurface.write_to_png(sfc, "basic_drawing4.png")
+
+      assert File.exists?("basic_drawing4.png")
+
+      assert hash("basic_drawing4.png") == hash("test/images/basic_drawing4.png")
+
+      :ok = File.rm("basic_drawing4.png")
+    end
   end
 end