cairo 1.10.2 → 1.12.0

data/ext/cairo/rb_cairo_pattern.c

@@ -5,6 +5,7 @@
  * $Author: kou $
  * $Date: 2008-06-12 10:59:54 $
  *
+ * Copyright 2012 Kouhei Sutou <kou@cozmixng.org>
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
  *
@@ -21,8 +22,10 @@ VALUE rb_cCairo_SurfacePattern;
 VALUE rb_cCairo_GradientPattern;
 VALUE rb_cCairo_LinearPattern;
 VALUE rb_cCairo_RadialPattern;
+VALUE rb_cCairo_MeshPattern;
+VALUE rb_cCairo_RasterSourcePattern;
 
-static ID id_parse, id_to_rgb, id_to_a, id_inspect;
+static ID id_parse, id_to_rgb, id_to_a, id_inspect, id_new, id_call;
 
 #define _SELF(self)  (RVAL2CRPATTERN(self))
 
@@ -59,6 +62,14 @@ cr_pattern_get_klass (cairo_pattern_t *pattern)
     case CAIRO_PATTERN_TYPE_RADIAL:
       klass = rb_cCairo_RadialPattern;
       break;
+#if CAIRO_CHECK_VERSION(1, 11, 4)
+    case CAIRO_PATTERN_TYPE_MESH:
+      klass = rb_cCairo_MeshPattern;
+      break;
+    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
+      klass = rb_cCairo_RasterSourcePattern;
+      break;
+#endif
     default:
       rb_raise (rb_eArgError, "unknown pattern type: %d", type);
       break;
@@ -441,6 +452,517 @@ cr_radial_pattern_get_radial_circles (VALUE self)
 /* Cairo::SurfacePattern */
 /* none */
 
+#if CAIRO_CHECK_VERSION(1, 11, 4)
+/* Cairo::MeshPattern */
+static VALUE
+cr_mesh_pattern_initialize (VALUE self)
+{
+  cairo_pattern_t *pattern;
+
+  pattern = cairo_pattern_create_mesh ();
+  cr_pattern_check_status (pattern);
+  DATA_PTR (self) = pattern;
+  return Qnil;
+}
+
+static VALUE
+cr_mesh_pattern_end_patch (VALUE self)
+{
+  cairo_pattern_t *pattern;
+
+  pattern = _SELF (self);
+  cairo_mesh_pattern_end_patch (pattern);
+  cr_pattern_check_status (pattern);
+  return self;
+}
+
+static VALUE
+cr_mesh_pattern_begin_patch (VALUE self)
+{
+  cairo_pattern_t *pattern;
+
+  pattern = _SELF (self);
+  cairo_mesh_pattern_begin_patch (pattern);
+  cr_pattern_check_status (pattern);
+  if (rb_block_given_p ())
+    return rb_ensure (rb_yield, self, cr_mesh_pattern_end_patch, self);
+  else
+    return self;
+}
+
+static VALUE
+cr_mesh_pattern_curve_to (VALUE self,
+                          VALUE x1, VALUE y1,
+                          VALUE x2, VALUE y2,
+                          VALUE x3, VALUE y3)
+{
+  cairo_pattern_t *pattern;
+
+  pattern = _SELF (self);
+  cairo_mesh_pattern_curve_to (pattern,
+                               NUM2DBL (x1), NUM2DBL (y1),
+                               NUM2DBL (x2), NUM2DBL (y2),
+                               NUM2DBL (x3), NUM2DBL (y3));
+  cr_pattern_check_status (pattern);
+  return self;
+}
+
+static VALUE
+cr_mesh_pattern_line_to (VALUE self, VALUE x, VALUE y)
+{
+  cairo_pattern_t *pattern;
+
+  pattern = _SELF (self);
+  cairo_mesh_pattern_line_to (pattern, NUM2DBL (x), NUM2DBL (y));
+  cr_pattern_check_status (pattern);
+  return self;
+}
+
+static VALUE
+cr_mesh_pattern_move_to (VALUE self, VALUE x, VALUE y)
+{
+  cairo_pattern_t *pattern;
+
+  pattern = _SELF (self);
+  cairo_mesh_pattern_move_to (pattern, NUM2DBL (x), NUM2DBL (y));
+  cr_pattern_check_status (pattern);
+  return self;
+}
+
+static VALUE
+cr_mesh_pattern_set_control_point (VALUE self, VALUE rb_nth_point,
+                                   VALUE rb_x, VALUE rb_y)
+{
+  cairo_pattern_t *pattern;
+  unsigned int nth_point;
+
+  pattern = _SELF (self);
+  nth_point = NUM2UINT (rb_nth_point);
+  if (0 <= nth_point && nth_point <= 3)
+    {
+      cairo_mesh_pattern_set_control_point (pattern, nth_point,
+                                            NUM2DBL (rb_x), NUM2DBL (rb_y));
+    }
+  else
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (rb_ary_new3 (3, rb_nth_point, rb_x, rb_y),
+                              id_inspect, 0);
+      rb_raise (rb_eArgError, "nth_point must be 0, 1, 2 or 3: <%u>: <%s>",
+                nth_point, RVAL2CSTR (inspected));
+    }
+  cr_pattern_check_status (pattern);
+  return self;
+}
+
+static VALUE
+cr_mesh_pattern_set_corner_color_generic (int argc, VALUE *argv, VALUE self)
+{
+  cairo_pattern_t *pattern;
+  VALUE rb_nth_corner, rb_red, rb_green, rb_blue, rb_alpha;
+  unsigned int nth_corner;
+  double red, green, blue, alpha;
+
+  rb_scan_args (argc, argv, "41",
+                &rb_nth_corner, &rb_red, &rb_green, &rb_blue, &rb_alpha);
+
+  nth_corner = NUM2UINT (rb_nth_corner);
+  if (!(0 <= nth_corner && nth_corner <= 3))
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (rb_ary_new4 (argc, argv), id_inspect, 0);
+      rb_raise (rb_eArgError, "nth_corner must be 0, 1, 2 or 3: <%u>: <%s>",
+                nth_corner, RVAL2CSTR (inspected));
+    }
+
+  pattern = _SELF (self);
+  red = NUM2DBL (rb_red);
+  green = NUM2DBL (rb_green);
+  blue = NUM2DBL (rb_blue);
+  if (NIL_P (rb_alpha))
+    {
+      cairo_mesh_pattern_set_corner_color_rgb (pattern, nth_corner,
+                                               red, green, blue);
+    }
+  else
+    {
+      alpha = NUM2DBL (rb_alpha);
+      cairo_mesh_pattern_set_corner_color_rgba (pattern, nth_corner,
+                                                red, green, blue, alpha);
+    }
+  cr_pattern_check_status (pattern);
+  return self;
+}
+
+static VALUE
+cr_mesh_pattern_get_patch_count (VALUE self)
+{
+  cairo_pattern_t *pattern;
+  unsigned int count;
+  cairo_status_t status;
+
+  pattern = _SELF (self);
+  status = cairo_mesh_pattern_get_patch_count (pattern, &count);
+  rb_cairo_check_status (status);
+  return UINT2NUM (count);
+}
+
+static VALUE
+cr_mesh_pattern_get_path (VALUE self, VALUE nth_patch)
+{
+  cairo_pattern_t *pattern;
+  cairo_path_t *path;
+
+  pattern = _SELF (self);
+  path = cairo_mesh_pattern_get_path (pattern, NUM2UINT (nth_patch));
+  rb_cairo_check_status (path->status);
+  return CRPATH2RVAL (path);
+}
+
+static VALUE
+cr_mesh_pattern_get_corner_color (VALUE self,
+                                  VALUE rb_nth_patch, VALUE rb_nth_corner)
+{
+  cairo_pattern_t *pattern;
+  unsigned int nth_patch, nth_corner;
+  double red, green, blue, alpha;
+  cairo_status_t status;
+
+  nth_patch = NUM2UINT (rb_nth_patch);
+  nth_corner = NUM2UINT (rb_nth_corner);
+  if (!(0 <= nth_corner && nth_corner <= 3))
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (rb_ary_new3 (2, rb_nth_patch, rb_nth_corner),
+                              id_inspect, 0);
+      rb_raise (rb_eArgError, "nth_corner must be 0, 1, 2 or 3: <%u>: <%s>",
+                nth_corner, RVAL2CSTR (inspected));
+    }
+
+  pattern = _SELF (self);
+  status = cairo_mesh_pattern_get_corner_color_rgba (pattern,
+                                                     nth_patch, nth_corner,
+                                                     &red,
+                                                     &green,
+                                                     &blue,
+                                                     &alpha);
+  rb_cairo_check_status (status);
+  return rb_ary_new3 (4,
+                      rb_float_new (red), rb_float_new (green),
+                      rb_float_new (blue), rb_float_new (alpha));
+}
+
+static VALUE
+cr_mesh_pattern_get_control_point (VALUE self,
+                                   VALUE rb_nth_patch, VALUE rb_nth_point)
+{
+  cairo_pattern_t *pattern;
+  unsigned int nth_patch, nth_point;
+  double x, y;
+  cairo_status_t status;
+
+  nth_patch = NUM2UINT (rb_nth_patch);
+  nth_point = NUM2UINT (rb_nth_point);
+  if (!(0 <= nth_point && nth_point <= 3))
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (rb_ary_new3 (2, rb_nth_patch, rb_nth_point),
+                              id_inspect, 0);
+      rb_raise (rb_eArgError, "nth_point must be 0, 1, 2 or 3: <%u>: <%s>",
+                nth_point, RVAL2CSTR (inspected));
+    }
+
+  pattern = _SELF (self);
+  status = cairo_mesh_pattern_get_control_point (pattern,
+                                                 nth_patch, nth_point,
+                                                 &x, &y);
+  rb_cairo_check_status (status);
+  return rb_ary_new3 (2, rb_float_new (x), rb_float_new (y));
+}
+
+/* Cairo::RasterPattern */
+static cairo_surface_t *
+cr_raster_source_acquire_callback (cairo_pattern_t *pattern,
+                                   void *callback_data,
+                                   cairo_surface_t *target,
+                                   const cairo_rectangle_int_t *extents)
+{
+  VALUE rb_pattern;
+  VALUE rb_acquire;
+  cairo_surface_t *acquired_surface = NULL;
+
+  rb_pattern = POINTER2RVAL (callback_data);
+  rb_acquire = rb_iv_get (rb_pattern, "@acquire");
+  if (!NIL_P (rb_acquire))
+    {
+      VALUE rb_acquired_surface;
+      VALUE rb_target;
+      VALUE rb_extents;
+
+      rb_target = CRSURFACE2RVAL (target);
+      rb_extents = rb_funcall (rb_cCairo_Rectangle, id_new, 4,
+                               INT2NUM (extents->x),
+                               INT2NUM (extents->y),
+                               INT2NUM (extents->width),
+                               INT2NUM (extents->height));
+      rb_acquired_surface = rb_funcall (rb_acquire, id_call, 3,
+                                        rb_pattern, rb_target, rb_extents);
+      if (!NIL_P (rb_acquired_surface))
+        acquired_surface = RVAL2CRSURFACE (rb_acquired_surface);
+    }
+
+  return acquired_surface;
+}
+
+static void
+cr_raster_source_release_callback (cairo_pattern_t *pattern,
+                                   void *callback_data,
+                                   cairo_surface_t *surface)
+{
+  VALUE rb_pattern;
+  VALUE rb_release;
+  VALUE rb_surface;
+
+  rb_pattern = POINTER2RVAL (callback_data);
+  rb_release = rb_iv_get (rb_pattern, "@release");
+  if (NIL_P (rb_release))
+    return;
+
+  rb_surface = CRSURFACE2RVAL (surface);
+  rb_funcall (rb_release, id_call, 2, rb_pattern, rb_surface);
+}
+
+typedef struct cr_raster_source_notify_callback_data
+{
+  VALUE pattern;
+  VALUE callback;
+  cairo_status_t status;
+} cr_raster_source_notify_callback_data_t;
+
+static VALUE
+cr_raster_source_notify_callback_body (VALUE data)
+{
+  cr_raster_source_notify_callback_data_t* callback_data;
+
+  callback_data = RVAL2POINTER (data);
+  rb_funcall (callback_data->callback, id_call, 1, callback_data->pattern);
+  return Qnil;
+}
+
+static VALUE
+cr_raster_source_notify_callback_rescue (VALUE data, VALUE exception)
+{
+  cr_raster_source_notify_callback_data_t *callback_data;
+
+  callback_data = RVAL2POINTER (data);
+  callback_data->status = rb_cairo__exception_to_status (exception);
+
+  if (callback_data->status == (cairo_status_t)-1)
+    rb_exc_raise (exception);
+
+  return Qnil;
+}
+
+static cairo_status_t
+cr_raster_source_snapshot_callback (cairo_pattern_t *pattern,
+                                    void *callback_data)
+{
+  VALUE rb_pattern;
+  VALUE rb_snapshot;
+  cr_raster_source_notify_callback_data_t data;
+
+  rb_pattern = POINTER2RVAL (callback_data);
+  rb_snapshot = rb_iv_get (rb_pattern, "@snapshot");
+  if (NIL_P (rb_snapshot))
+    return CAIRO_STATUS_SUCCESS;
+
+  data.pattern = rb_pattern;
+  data.callback = rb_snapshot;
+  data.status = CAIRO_STATUS_SUCCESS;
+  rb_rescue2 (cr_raster_source_notify_callback_body,
+              POINTER2RVAL (&data),
+              cr_raster_source_notify_callback_rescue,
+              POINTER2RVAL (&data),
+              rb_eException);
+  return data.status;
+}
+
+static cairo_status_t
+cr_raster_source_copy_callback (cairo_pattern_t *pattern,
+                                void *callback_data,
+                                const cairo_pattern_t *other)
+{
+  VALUE rb_pattern;
+  VALUE rb_copy;
+  cr_raster_source_notify_callback_data_t data;
+
+  rb_pattern = POINTER2RVAL (callback_data);
+  rb_copy = rb_iv_get (rb_pattern, "@copy");
+  if (NIL_P (rb_copy))
+    return CAIRO_STATUS_SUCCESS;
+
+  data.pattern = rb_pattern;
+  data.callback = rb_copy;
+  data.status = CAIRO_STATUS_SUCCESS;
+  rb_rescue2 (cr_raster_source_notify_callback_body,
+              POINTER2RVAL (&data),
+              cr_raster_source_notify_callback_rescue,
+              POINTER2RVAL (&data),
+              rb_eException);
+  return data.status;
+}
+
+static void
+cr_raster_source_finish_callback (cairo_pattern_t *pattern, void *callback_data)
+{
+  VALUE rb_pattern;
+  VALUE rb_finish;
+
+  rb_pattern = POINTER2RVAL (callback_data);
+  rb_finish = rb_iv_get (rb_pattern, "@finish");
+  if (NIL_P (rb_finish))
+    return;
+
+  rb_function (rb_finish, id_call, 1, rb_pattern);
+}
+
+static VALUE
+cr_raster_source_pattern_initialize (int argc, VALUE *argv, VALUE self)
+{
+  cairo_pattern_t *pattern;
+  cairo_content_t content;
+  int width, height;
+  VALUE arg1, arg2, arg3;
+
+  rb_scan_args (argc, argv, "21", &arg1, &arg2, &arg3);
+
+  if (argc == 2)
+    {
+      content = CAIRO_CONTENT_COLOR_ALPHA;
+      width = NUM2INT (arg1);
+      height = NUM2INT (arg2);
+    }
+  else
+    {
+      content = RVAL2CRCONTENT (arg1);
+      width = NUM2INT (arg2);
+      height = NUM2INT (arg3);
+    }
+
+  pattern = cairo_pattern_create_raster_source (RVAL2POINTER (self),
+                                                content, width, height);
+  cr_pattern_check_status (pattern);
+
+  DATA_PTR (self) = pattern;
+  rb_iv_set (self, "@acquire", Qnil);
+  rb_iv_set (self, "@release", Qnil);
+  rb_iv_set (self, "@snapshot", Qnil);
+  rb_iv_set (self, "@copy", Qnil);
+  rb_iv_set (self, "@finish", Qnil);
+
+  cairo_raster_source_pattern_set_acquire (pattern,
+                                           cr_raster_source_acquire_callback,
+                                           cr_raster_source_release_callback);
+  cairo_raster_source_pattern_set_snapshot (pattern,
+                                            cr_raster_source_snapshot_callback);
+  cairo_raster_source_pattern_set_copy (pattern,
+                                        cr_raster_source_copy_callback);
+  cairo_raster_source_pattern_set_finish (pattern,
+                                          cr_raster_source_finish_callback);
+
+  return Qnil;
+}
+
+static VALUE
+cr_raster_source_pattern_acquire (VALUE self)
+{
+  if (!rb_block_given_p ())
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (self, id_inspect, 0);
+      rb_raise (rb_eArgError, "acquire block is missing: %s",
+                RVAL2CSTR (inspected));
+    }
+
+  rb_iv_set (self, "@acquire", rb_block_proc ());
+
+  return self;
+}
+
+static VALUE
+cr_raster_source_pattern_release (VALUE self)
+{
+  if (!rb_block_given_p ())
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (self, id_inspect, 0);
+      rb_raise (rb_eArgError, "release block is missing: %s",
+                RVAL2CSTR (inspected));
+    }
+
+  rb_iv_set (self, "@release", rb_block_proc ());
+
+  return self;
+}
+
+static VALUE
+cr_raster_source_pattern_snapshot (VALUE self)
+{
+  if (!rb_block_given_p ())
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (self, id_inspect, 0);
+      rb_raise (rb_eArgError, "snapshot block is missing: %s",
+                RVAL2CSTR (inspected));
+    }
+
+  rb_iv_set (self, "@snapshot", rb_block_proc ());
+
+  return self;
+}
+
+static VALUE
+cr_raster_source_pattern_copy (VALUE self)
+{
+  if (!rb_block_given_p ())
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (self, id_inspect, 0);
+      rb_raise (rb_eArgError, "copy block is missing: %s",
+                RVAL2CSTR (inspected));
+    }
+
+  rb_iv_set (self, "@copy", rb_block_proc ());
+
+  return self;
+}
+
+static VALUE
+cr_raster_source_pattern_finish (VALUE self)
+{
+  if (!rb_block_given_p ())
+    {
+      VALUE inspected;
+
+      inspected = rb_funcall (self, id_inspect, 0);
+      rb_raise (rb_eArgError, "finish block is missing: %s",
+                RVAL2CSTR (inspected));
+    }
+
+  rb_iv_set (self, "@finish", rb_block_proc ());
+
+  return self;
+}
+#endif
+
 void
 Init_cairo_pattern (void)
 {
@@ -448,6 +970,8 @@ Init_cairo_pattern (void)
   id_to_rgb = rb_intern ("to_rgb");
   id_to_a = rb_intern ("to_a");
   id_inspect = rb_intern ("inspect");
+  id_new = rb_intern ("new");
+  id_call = rb_intern ("call");
 
   rb_cCairo_Pattern =
     rb_define_class_under (rb_mCairo, "Pattern", rb_cObject);
@@ -537,4 +1061,58 @@ Init_cairo_pattern (void)
 #endif
 
   RB_CAIRO_DEF_SETTERS (rb_cCairo_RadialPattern);
+
+  rb_cCairo_MeshPattern =
+    rb_define_class_under (rb_mCairo, "MeshPattern",
+                           rb_cCairo_Pattern);
+#if CAIRO_CHECK_VERSION(1, 11, 4)
+  rb_define_method (rb_cCairo_MeshPattern, "initialize",
+                    cr_mesh_pattern_initialize, 0);
+  rb_define_method (rb_cCairo_MeshPattern, "begin_patch",
+                    cr_mesh_pattern_begin_patch, 0);
+  rb_define_method (rb_cCairo_MeshPattern, "end_patch",
+                    cr_mesh_pattern_end_patch, 0);
+  rb_define_method (rb_cCairo_MeshPattern, "curve_to",
+                    cr_mesh_pattern_curve_to, 6);
+  rb_define_method (rb_cCairo_MeshPattern, "line_to",
+                    cr_mesh_pattern_line_to, 2);
+  rb_define_method (rb_cCairo_MeshPattern, "move_to",
+                    cr_mesh_pattern_move_to, 2);
+  rb_define_method (rb_cCairo_MeshPattern, "set_control_point",
+                    cr_mesh_pattern_set_control_point, 3);
+  rb_define_method (rb_cCairo_MeshPattern, "set_corner_color",
+                    cr_mesh_pattern_set_corner_color_generic, -1);
+  rb_define_alias (rb_cCairo_MeshPattern,
+                   "set_corner_color_rgb", "set_corner_color");
+  rb_define_alias (rb_cCairo_MeshPattern,
+                   "set_corner_color_rgba", "set_corner_color");
+  rb_define_method (rb_cCairo_MeshPattern, "patch_count",
+                    cr_mesh_pattern_get_patch_count, 0);
+  rb_define_method (rb_cCairo_MeshPattern, "get_path",
+                    cr_mesh_pattern_get_path, 1);
+  rb_define_method (rb_cCairo_MeshPattern, "get_corner_color",
+                    cr_mesh_pattern_get_corner_color, 2);
+  rb_define_method (rb_cCairo_MeshPattern, "get_control_point",
+                    cr_mesh_pattern_get_control_point, 2);
+#endif
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_MeshPattern);
+
+  rb_cCairo_RasterSourcePattern =
+    rb_define_class_under (rb_mCairo, "RasterSourcePattern",
+                           rb_cCairo_Pattern);
+#if CAIRO_CHECK_VERSION(1, 11, 4)
+  rb_define_method (rb_cCairo_RasterSourcePattern, "initialize",
+                    cr_raster_source_pattern_initialize, -1);
+  rb_define_method (rb_cCairo_RasterSourcePattern, "acquire",
+                    cr_raster_source_pattern_acquire, 0);
+  rb_define_method (rb_cCairo_RasterSourcePattern, "release",
+                    cr_raster_source_pattern_release, 0);
+  rb_define_method (rb_cCairo_RasterSourcePattern, "snapshot",
+                    cr_raster_source_pattern_snapshot, 0);
+  rb_define_method (rb_cCairo_RasterSourcePattern, "copy",
+                    cr_raster_source_pattern_copy, 0);
+  rb_define_method (rb_cCairo_RasterSourcePattern, "finish",
+                    cr_raster_source_pattern_finish, 0);
+#endif
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_RasterSourcePattern);
 }