ImageSurface

* Add `ImageSurface` struct in Elixir and Rust
  * `new`
  * `format`
  * `width`
  * `height`
  * `stride`
  * `write_to_png`
* Add `Format` enum/atoms
* Start adding `XairoError` mapping to cairo::Error
  - [ ] (eventually move existing errors over)
* Add `Utilities` module
  * `stride_for_width`

Author: mikowitz

.projections.json

@@ -0,0 +1,21 @@
+{
+  "lib/*.ex": {
+    "alternate": "test/{}_test.exs",
+    "type": "source",
+    "template": [
+      "defmodule {camelcase|capitalize|dot} do",
+      "end"
+    ]
+  },
+  "test/*_test.exs": {
+    "alternate": "lib/{}.ex",
+    "type": "test",
+    "template": [
+      "defmodule {camelcase|capitalize|dot}Test do",
+      "  use ExUnit.Case, async: true",
+      "",
+      "  alias {camelcase|capitalize|dot}",
+      "end"
+    ]
+  }
+}

lib/xairo/image_surface.ex

@@ -0,0 +1,33 @@
+defmodule Xairo.ImageSurface do
+  @moduledoc false
+
+  defstruct [:resource]
+
+  def new(format, width, height) do
+    with {:ok, image_surface} <- Xairo.Native.image_surface_create(format, width, height) do
+      %__MODULE__{
+        resource: image_surface
+      }
+    end
+  end
+
+  def format(%__MODULE__{resource: resource}) do
+    Xairo.Native.image_surface_format(resource)
+  end
+
+  def width(%__MODULE__{resource: resource}) do
+    Xairo.Native.image_surface_width(resource)
+  end
+
+  def height(%__MODULE__{resource: resource}) do
+    Xairo.Native.image_surface_height(resource)
+  end
+
+  def stride(%__MODULE__{resource: resource}) do
+    Xairo.Native.image_surface_stride(resource)
+  end
+
+  def write_to_png(%__MODULE__{resource: resource}, filename) do
+    Xairo.Native.image_surface_write_to_png(resource, filename)
+  end
+end

lib/xairo/native.ex

@@ -120,5 +120,14 @@ defmodule Xairo.Native do
 
   def set_surface_pattern_source(_i, _p), do: error()
 
+  def image_surface_create(_f, _w, _h), do: error()
+  def image_surface_format(_is), do: error()
+  def image_surface_width(_is), do: error()
+  def image_surface_height(_is), do: error()
+  def image_surface_stride(_is), do: error()
+  def image_surface_write_to_png(_is, _f), do: error()
+
+  def stride_for_width(_f, _w), do: error()
+
   defp error, do: :erlang.nif_error(:nif_not_loaded)
 end

lib/xairo/utilities.ex

@@ -0,0 +1,11 @@
+defmodule Xairo.Utilities do
+  @moduledoc false
+
+  def stride_for_width(format, width) do
+    case Xairo.Native.stride_for_width(format, width) do
+      {:ok, stride} -> stride
+      {:error, _} = error -> error
+      error -> {:error, error}
+    end
+  end
+end

native/xairo/src/enums.rs

@@ -0,0 +1,59 @@
+use crate::error::XairoError;
+use std::convert::From;
+
+#[derive(Copy, Clone, Debug, NifUnitEnum)]
+pub enum Format {
+    Invalid,
+    Argb32,
+    Rgb24,
+    A8,
+    A1,
+    Rgb16_565,
+    Rgb30,
+}
+
+impl Format {
+    fn stride_for_width(self, width: u32) -> Result<i32, XairoError> {
+        match cairo::Format::from(self).stride_for_width(width) {
+            Ok(stride) => Ok(stride),
+            Err(err) => Err(err.into()), //Err(Error::Stride),
+        }
+    }
+}
+
+#[rustler::nif]
+fn stride_for_width(format: Format, width: u32) -> Result<i32, XairoError> {
+    if width <= i32::MAX as u32 {
+        format.stride_for_width(width)
+    } else {
+        Err(XairoError::InvalidStride)
+    }
+}
+
+impl From<Format> for cairo::Format {
+    fn from(format: Format) -> Self {
+        match format {
+            Format::Invalid => cairo::Format::Invalid,
+            Format::Argb32 => cairo::Format::ARgb32,
+            Format::Rgb24 => cairo::Format::Rgb24,
+            Format::A8 => cairo::Format::A8,
+            Format::A1 => cairo::Format::A1,
+            Format::Rgb16_565 => cairo::Format::Rgb16_565,
+            Format::Rgb30 => cairo::Format::Rgb30,
+        }
+    }
+}
+
+impl From<cairo::Format> for Format {
+    fn from(format: cairo::Format) -> Self {
+        match format {
+            cairo::Format::ARgb32 => Format::Argb32,
+            cairo::Format::Rgb24 => Format::Rgb24,
+            cairo::Format::A8 => Format::A8,
+            cairo::Format::A1 => Format::A1,
+            cairo::Format::Rgb16_565 => Format::Rgb16_565,
+            cairo::Format::Rgb30 => Format::Rgb30,
+            _ => Format::Invalid,
+        }
+    }
+}

native/xairo/src/error.rs

@@ -49,10 +49,42 @@ pub enum Error {
     RadialCircles,
     #[error("Error retrieving color for solid pattern")]
     SolidPatternColor,
+    #[error("Error calculating stride for width")]
+    Stride,
 }
 
 impl rustler::Encoder for Error {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
         format!("{}", self).encode(env)
     }
 }
+
+#[derive(Copy, Clone, Debug, NifUnitEnum)]
+pub enum XairoError {
+    WriteError,
+    InvalidSize,
+    InvalidStride,
+    UnknownError,
+}
+
+impl From<XairoError> for cairo::Error {
+    fn from(error: XairoError) -> Self {
+        match error {
+            XairoError::InvalidStride => cairo::Error::InvalidStride,
+            XairoError::InvalidSize => cairo::Error::InvalidSize,
+            XairoError::WriteError => cairo::Error::WriteError,
+            XairoError::UnknownError => cairo::Error::LastStatus,
+        }
+    }
+}
+
+impl From<cairo::Error> for XairoError {
+    fn from(error: cairo::Error) -> Self {
+        match error {
+            cairo::Error::InvalidStride => XairoError::InvalidStride,
+            cairo::Error::InvalidSize => XairoError::InvalidSize,
+            cairo::Error::WriteError => XairoError::WriteError,
+            _ => XairoError::UnknownError,
+        }
+    }
+}

native/xairo/src/image_surface.rs

@@ -0,0 +1,57 @@
+use crate::enums::Format;
+use crate::error::{Error, XairoError};
+use rustler::ResourceArc;
+use std::fs::File;
+
+pub struct ImageSurfaceRaw {
+    pub surface: cairo::ImageSurface,
+}
+
+unsafe impl Send for ImageSurfaceRaw {}
+unsafe impl Sync for ImageSurfaceRaw {}
+
+pub type ImageSurface = ResourceArc<ImageSurfaceRaw>;
+
+#[rustler::nif]
+fn image_surface_create(
+    format: Format,
+    width: i32,
+    height: i32,
+) -> Result<ImageSurface, XairoError> {
+    let format: cairo::Format = format.into();
+    match cairo::ImageSurface::create(format, width, height) {
+        Ok(surface) => Ok(ResourceArc::new(ImageSurfaceRaw { surface })),
+        Err(err) => Err(err.into()),
+    }
+}
+
+#[rustler::nif]
+fn image_surface_format(surface: ImageSurface) -> Format {
+    surface.surface.format().into()
+}
+
+#[rustler::nif]
+fn image_surface_width(surface: ImageSurface) -> i32 {
+    surface.surface.width()
+}
+
+#[rustler::nif]
+fn image_surface_height(surface: ImageSurface) -> i32 {
+    surface.surface.height()
+}
+
+#[rustler::nif]
+fn image_surface_stride(surface: ImageSurface) -> i32 {
+    surface.surface.stride()
+}
+
+#[rustler::nif]
+fn image_surface_write_to_png(surface: ImageSurface, filename: String) -> Result<(), XairoError> {
+    match File::create(filename) {
+        Ok(mut file) => match surface.surface.write_to_png(&mut file) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(XairoError::WriteError),
+        },
+        Err(_) => Err(XairoError::WriteError),
+    }
+}

native/xairo/src/lib.rs

@@ -4,8 +4,11 @@ use rustler::{Env, Term};
 
 mod color;
 mod drawing;
+mod enums;
 mod error;
 mod extents;
+mod image_surface;
+use image_surface::ImageSurfaceRaw;
 mod line_cap;
 mod line_join;
 mod linear_gradient;
@@ -133,7 +136,16 @@ rustler::init!(
         path::copy_path_flat,
         path::append_path,
         path::get_tolerance,
-        path::set_tolerance
+        path::set_tolerance,
+        // image_surface
+        image_surface::image_surface_create,
+        image_surface::image_surface_format,
+        image_surface::image_surface_width,
+        image_surface::image_surface_height,
+        image_surface::image_surface_stride,
+        image_surface::image_surface_write_to_png,
+        // enums
+        enums::stride_for_width,
     ],
     load = on_load
 );
@@ -145,5 +157,6 @@ fn on_load(env: Env, _info: Term) -> bool {
     rustler::resource!(XairoLinearGradient, env);
     rustler::resource!(XairoRadialGradient, env);
     rustler::resource!(XairoSolidPattern, env);
+    rustler::resource!(ImageSurfaceRaw, env);
     true
 }

priv/native/libxairo.so

@@ -39,7 +39,7 @@ defmodule Xairo.Helpers.ImageHelpers do
     :ok = File.rm(filename)
   end
 
-  defp hash(file) do
+  def hash(file) do
     File.stream!(file)
     |> Enum.reduce(:crypto.hash_init(:sha256), fn line, acc ->
       :crypto.hash_update(acc, line)