cairo 1.8.5-x86-mingw32 → 1.10.0-x86-mingw32

data/ext/cairo/rb_cairo_io.c

@@ -0,0 +1,166 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * Copyright 2005-2010 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+ */
+
+#include "rb_cairo.h"
+#include "rb_cairo_private.h"
+#include "rb_cairo_io.h"
+
+ID rb_cairo__io_id_read;
+ID rb_cairo__io_id_write;
+ID rb_cairo__io_id_output;
+
+/* read/write callback */
+rb_cairo__io_callback_closure_t *
+rb_cairo__io_closure_new (VALUE target)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  closure = ALLOC (rb_cairo__io_callback_closure_t);
+
+  closure->target = target;
+  closure->error = Qnil;
+
+  return closure;
+}
+
+void
+rb_cairo__io_closure_destroy (rb_cairo__io_callback_closure_t *closure)
+{
+  xfree (closure);
+}
+
+void
+rb_cairo__io_closure_free (void *closure)
+{
+  rb_cairo__io_closure_destroy ((rb_cairo__io_callback_closure_t *) closure);
+}
+
+static VALUE
+rb_cairo__io_func_rescue (VALUE io_closure)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  closure = (rb_cairo__io_callback_closure_t *)io_closure;
+  closure->error = RB_ERRINFO;
+  return Qnil;
+}
+
+static VALUE
+rb_cairo__io_func_invoke (VALUE user_data)
+{
+  rb_cairo__io_invoke_data_t *data;
+
+  data = (rb_cairo__io_invoke_data_t *)user_data;
+  return rb_rescue2 (data->func, data->data,
+                     rb_cairo__io_func_rescue, data->data, rb_eException,
+                     (VALUE)0);
+}
+
+/* write callback */
+static VALUE
+rb_cairo__io_write_func_invoke (VALUE write_closure)
+{
+  VALUE output, data;
+  long written_bytes;
+  rb_cairo__io_callback_closure_t *closure;
+  unsigned int length;
+
+  closure = (rb_cairo__io_callback_closure_t *)write_closure;
+
+  output = closure->target;
+  data = rb_str_new ((const char *)closure->data, closure->length);
+
+  length = RSTRING_LEN (data);
+  while (length != 0)
+    {
+      VALUE rb_written_bytes = rb_funcall (output,
+                                           rb_cairo__io_id_write, 1, data);
+      written_bytes = NUM2LONG (rb_written_bytes);
+      data = rb_str_substr (data, written_bytes,
+                            RSTRING_LEN (data) - written_bytes);
+      length -= written_bytes;
+    }
+
+  return Qnil;
+}
+
+cairo_status_t
+rb_cairo__io_write_func (void *write_closure,
+                         const unsigned char *data, unsigned int length)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  rb_cairo__io_invoke_data_t invoke_data;
+
+  closure = (rb_cairo__io_callback_closure_t *)write_closure;
+  closure->data = (unsigned char *)data;
+  closure->length = length;
+
+  invoke_data.func = rb_cairo__io_write_func_invoke;
+  invoke_data.data = (VALUE)closure;
+  rb_cairo__invoke_callback (rb_cairo__io_func_invoke, (VALUE)&invoke_data);
+
+  if (NIL_P (closure->error))
+    return CAIRO_STATUS_SUCCESS;
+  else
+    return CAIRO_STATUS_WRITE_ERROR;
+}
+
+/* read callback */
+static VALUE
+rb_cairo__io_read_func_invoke (VALUE read_closure)
+{
+  VALUE input, result;
+  rb_cairo__io_callback_closure_t *closure;
+  unsigned int length, rest;
+
+  closure = (rb_cairo__io_callback_closure_t *)read_closure;
+  input = closure->target;
+  length = closure->length;
+
+  result = rb_str_new2 ("");
+
+  for (rest = length; rest != 0; rest = length - RSTRING_LEN (result))
+    {
+      rb_str_concat (result,
+                     rb_funcall (input,
+                                 rb_cairo__io_id_read, 1, INT2NUM (rest)));
+    }
+
+  memcpy ((void *)closure->data, (const void *)StringValuePtr (result), length);
+
+  return Qnil;
+}
+
+cairo_status_t
+rb_cairo__io_read_func (void *read_closure,
+                        unsigned char *data, unsigned int length)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  rb_cairo__io_invoke_data_t invoke_data;
+
+  closure = (rb_cairo__io_callback_closure_t *)read_closure;
+  closure->data = data;
+  closure->length = length;
+
+  invoke_data.func = rb_cairo__io_read_func_invoke;
+  invoke_data.data = (VALUE)closure;
+  rb_cairo__invoke_callback (rb_cairo__io_func_invoke, (VALUE)&invoke_data);
+
+  if (NIL_P (closure->error))
+    return CAIRO_STATUS_SUCCESS;
+  else
+    return CAIRO_STATUS_READ_ERROR;
+}
+
+void
+Init_cairo_io (void)
+{
+  rb_cairo__io_id_read = rb_intern ("read");
+  rb_cairo__io_id_write = rb_intern ("write");
+  rb_cairo__io_id_output = rb_intern ("output");
+}

data/ext/cairo/rb_cairo_io.h

@@ -0,0 +1,44 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * Copyright 2005-2010 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+*/
+
+#ifndef RB_CAIRO_IO_H
+#define RB_CAIRO_IO_H
+
+#include <rb_cairo.h>
+
+typedef struct rb_cairo__io_callback_closure {
+  VALUE target;
+  VALUE error;
+  unsigned char *data;
+  unsigned int length;
+} rb_cairo__io_callback_closure_t;
+
+typedef struct rb_cairo__io_invoke_data {
+  cr_callback_func_t func;
+  VALUE data;
+} rb_cairo__io_invoke_data_t;
+
+RB_CAIRO_VAR ID rb_cairo__io_id_read;
+RB_CAIRO_VAR ID rb_cairo__io_id_write;
+RB_CAIRO_VAR ID rb_cairo__io_id_output;
+
+rb_cairo__io_callback_closure_t *
+               rb_cairo__io_closure_new     (VALUE                target);
+void           rb_cairo__io_closure_destroy (rb_cairo__io_callback_closure_t *closure);
+void           rb_cairo__io_closure_free    (void                *closure);
+cairo_status_t rb_cairo__io_write_func      (void                *write_closure,
+                                             const unsigned char *data,
+                                             unsigned int         length);
+cairo_status_t rb_cairo__io_read_func       (void                *read_closure,
+                                             unsigned char       *data,
+                                             unsigned int         length);
+
+
+#endif

data/ext/cairo/rb_cairo_matrix.c

@@ -40,7 +40,7 @@ cr_matrix_free (void *ptr)
 {
   if (ptr)
     {
-      free ((cairo_matrix_t *) ptr);
+      xfree ((cairo_matrix_t *) ptr);
     }
 }
 

data/ext/cairo/rb_cairo_private.h

@@ -44,11 +44,14 @@
 #endif
 
 extern void Init_cairo_private (void);
+extern void Init_cairo_io (void);
 extern void Init_cairo_constants (void);
 
 extern void Init_cairo_context (void);
 extern void Init_cairo_path (void);
 extern void Init_cairo_matrix (void);
+extern void Init_cairo_region (void);
+extern void Init_cairo_device (void);
 extern void Init_cairo_surface (void);
 extern void Init_cairo_quartz_surface (void);
 extern void Init_cairo_exception (void);

data/ext/cairo/rb_cairo_region.c

@@ -0,0 +1,385 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * Copyright 2010 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+ */
+
+
+#include "rb_cairo.h"
+#include "rb_cairo_private.h"
+
+VALUE rb_cCairo_Region = Qnil;
+
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+
+#define _SELF  (RVAL2CRREGION(self))
+
+static inline void
+cr_region_check_status (cairo_region_t *region)
+{
+  rb_cairo_check_status (cairo_region_status (region));
+}
+
+cairo_region_t *
+rb_cairo_region_from_ruby_object (VALUE obj)
+{
+  cairo_region_t *region;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_Region))
+    {
+      rb_raise (rb_eTypeError, "not a cairo region");
+    }
+  Data_Get_Struct (obj, cairo_region_t, region);
+  return region;
+}
+
+static void
+cr_region_free (void *ptr)
+{
+  if (ptr)
+    {
+      cairo_region_destroy ((cairo_region_t *) ptr);
+    }
+}
+
+VALUE
+rb_cairo_region_to_ruby_object (cairo_region_t *region)
+{
+  if (region)
+    {
+      cairo_region_reference (region);
+      return Data_Wrap_Struct (rb_cCairo_Region, NULL, cr_region_free, region);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_region_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_region_free, NULL);
+}
+
+static VALUE
+cr_region_initialize (int argc, VALUE *argv, VALUE self)
+{
+  cairo_region_t *region;
+
+  if (argc == 0)
+    {
+      region = cairo_region_create ();
+    }
+  else
+    {
+      int i;
+      cairo_rectangle_int_t *rectangles;
+
+      rectangles = ALLOCA_N (cairo_rectangle_int_t, argc);
+      for (i = 0; i < argc; i++)
+        {
+          VALUE rb_rectangle;
+
+          rb_rectangle = rb_check_array_type (argv[i]);
+          if (RARRAY_LEN (rb_rectangle) != 4)
+            rb_raise (rb_eArgError,
+                      "invalid argument (expect "
+                      "() or ([x, y, width, height], ...): %s",
+                      rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+          rectangles[i].x = NUM2INT (RARRAY_PTR (rb_rectangle)[0]);
+          rectangles[i].y = NUM2INT (RARRAY_PTR (rb_rectangle)[1]);
+          rectangles[i].width = NUM2INT (RARRAY_PTR (rb_rectangle)[2]);
+          rectangles[i].height = NUM2INT (RARRAY_PTR (rb_rectangle)[3]);
+        }
+      region = cairo_region_create_rectangles (rectangles, argc);
+    }
+  cr_region_check_status (region);
+  DATA_PTR (self) = region;
+  return Qnil;
+}
+
+static VALUE
+cr_region_dup (VALUE self)
+{
+  cairo_region_t *copied_region;
+  VALUE rb_copied_region;
+
+  copied_region = cairo_region_copy (_SELF);
+  cr_region_check_status (copied_region);
+  rb_copied_region = CRREGION2RVAL (copied_region);
+  cairo_region_destroy (copied_region);
+  return rb_copied_region;
+}
+
+static VALUE
+cr_region_equal (VALUE self, VALUE other)
+{
+  cairo_region_t *region, *other_region;
+
+  if (!rb_cairo__is_kind_of (other, rb_cCairo_Region))
+    return Qfalse;
+
+  region = _SELF;
+  other_region = RVAL2CRREGION (other);
+  return CBOOL2RVAL (cairo_region_equal (region, other_region));
+}
+
+static VALUE
+cr_region_get_extents (VALUE self)
+{
+  cairo_region_t *region;
+  cairo_rectangle_int_t extents;
+
+  region = _SELF;
+  cairo_region_get_extents (region, &extents);
+  cr_region_check_status (region);
+  return rb_ary_new3 (4,
+                      INT2NUM (extents.x), INT2NUM (extents.y),
+                      INT2NUM (extents.width), INT2NUM (extents.height));
+}
+
+static VALUE
+cr_region_num_rectangles (VALUE self)
+{
+  cairo_region_t *region;
+  int num_rectangles;
+
+  region = _SELF;
+  num_rectangles = cairo_region_num_rectangles (region);
+  cr_region_check_status (region);
+  return INT2NUM (num_rectangles);
+}
+
+static VALUE
+cr_region_get_rectangle (VALUE self, VALUE index)
+{
+  cairo_region_t *region;
+  cairo_rectangle_int_t extents;
+
+  region = _SELF;
+  cairo_region_get_rectangle (region, NUM2INT (index), &extents);
+  cr_region_check_status (region);
+  return rb_ary_new3 (4,
+                      INT2NUM (extents.x), INT2NUM (extents.y),
+                      INT2NUM (extents.width), INT2NUM (extents.height));
+}
+
+static VALUE
+cr_region_is_empty (VALUE self)
+{
+  return CBOOL2RVAL (cairo_region_is_empty (_SELF));
+}
+
+static VALUE
+cr_region_containts_rectangle (int argc, VALUE *argv, VALUE self)
+{
+  cairo_region_t *region;
+  cairo_rectangle_int_t rectangle;
+  cairo_region_overlap_t overlap;
+  VALUE arg1, arg2, arg3, arg4;
+  const char *error_message =
+    "invalid argument (expect "
+    "(x, y, width, height) or ([x, y, width, height])): %s";
+
+  rb_scan_args (argc, argv, "13", &arg1, &arg2, &arg3, &arg4);
+
+  region = _SELF;
+  if (argc == 1)
+    {
+      VALUE rb_rectangle;
+
+      rb_rectangle = rb_check_array_type (arg1);
+      if (RARRAY_LEN (rb_rectangle) != 4)
+        rb_raise (rb_eArgError, error_message,
+                  rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+      rectangle.x = NUM2INT (RARRAY_PTR (rb_rectangle)[0]);
+      rectangle.y = NUM2INT (RARRAY_PTR (rb_rectangle)[1]);
+      rectangle.width = NUM2INT (RARRAY_PTR (rb_rectangle)[2]);
+      rectangle.height = NUM2INT (RARRAY_PTR (rb_rectangle)[3]);
+    }
+  else if (argc == 4)
+    {
+      rectangle.x = NUM2INT (arg1);
+      rectangle.y = NUM2INT (arg2);
+      rectangle.width = NUM2INT (arg3);
+      rectangle.height = NUM2INT (arg4);
+    }
+  else
+    {
+      rb_raise (rb_eArgError, error_message,
+                rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+    }
+
+  overlap = cairo_region_contains_rectangle (region, &rectangle);
+  cr_region_check_status (region);
+  return INT2NUM (overlap);
+}
+
+static VALUE
+cr_region_containts_point (int argc, VALUE *argv, VALUE self)
+{
+  cairo_region_t *region;
+  int x, y;
+  VALUE arg1, arg2;
+  const char *error_message =
+    "invalid argument (expect "
+    "(x, y) or ([x, y])): %s";
+
+  rb_scan_args (argc, argv, "11", &arg1, &arg2);
+
+  region = _SELF;
+  if (argc == 1)
+    {
+      VALUE point;
+
+      point = rb_check_array_type (arg1);
+      if (RARRAY_LEN (point) != 4)
+        rb_raise (rb_eArgError, error_message,
+                  rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+      x = NUM2INT (RARRAY_PTR (point)[0]);
+      y = NUM2INT (RARRAY_PTR (point)[1]);
+    }
+  else
+    {
+      x = NUM2INT (arg1);
+      y = NUM2INT (arg2);
+    }
+  return CBOOL2RVAL (cairo_region_contains_point (region, x, y));
+}
+
+static VALUE
+cr_region_translate (int argc, VALUE *argv, VALUE self)
+{
+  cairo_region_t *region;
+  int x, y;
+  VALUE arg1, arg2;
+  const char *error_message =
+    "invalid argument (expect "
+    "(x, y) or ([x, y])): %s";
+
+  rb_scan_args (argc, argv, "11", &arg1, &arg2);
+
+  region = _SELF;
+  if (argc == 1)
+    {
+      VALUE point;
+
+      point = rb_check_array_type (arg1);
+      if (RARRAY_LEN (point) != 4)
+        rb_raise (rb_eArgError, error_message,
+                  rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+      x = NUM2INT (RARRAY_PTR (point)[0]);
+      y = NUM2INT (RARRAY_PTR (point)[1]);
+    }
+  else
+    {
+      x = NUM2INT (arg1);
+      y = NUM2INT (arg2);
+    }
+
+  cairo_region_translate (region, x, y);
+  cr_region_check_status (region);
+  return Qnil;
+}
+
+#define DEFINE_OPERATOR(type)                                           \
+static VALUE                                                            \
+cr_region_ ## type (int argc, VALUE *argv, VALUE self)                  \
+{                                                                       \
+  cairo_status_t status;                                                \
+  cairo_region_t *region, *other = NULL;                                \
+  cairo_rectangle_int_t rectangle;                                      \
+  VALUE arg1, arg2, arg3, arg4;                                         \
+  const char *error_message =                                           \
+    "invalid argument (expect "                                         \
+    "(region), (x, y, width, height) or ([x, y, width, height])): %s";  \
+                                                                        \
+  rb_scan_args (argc, argv, "13", &arg1, &arg2, &arg3, &arg4);          \
+                                                                        \
+  region = _SELF;                                                       \
+  if (argc == 1)                                                        \
+    {                                                                   \
+      if (rb_cairo__is_kind_of (arg1, rb_cCairo_Region))                \
+        {                                                               \
+          other = RVAL2CRREGION (arg1);                                 \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          VALUE rb_rectangle;                                           \
+                                                                        \
+          rb_rectangle = rb_check_array_type (arg1);                    \
+          if (RARRAY_LEN (rb_rectangle) != 4)                           \
+            rb_raise (rb_eArgError, error_message,                      \
+                      rb_cairo__inspect (rb_ary_new4 (argc, argv)));    \
+          rectangle.x = NUM2INT (RARRAY_PTR (rb_rectangle)[0]);         \
+          rectangle.y = NUM2INT (RARRAY_PTR (rb_rectangle)[1]);         \
+          rectangle.width = NUM2INT (RARRAY_PTR (rb_rectangle)[2]);     \
+          rectangle.height = NUM2INT (RARRAY_PTR (rb_rectangle)[3]);    \
+        }                                                               \
+    }                                                                   \
+  else if (argc == 4)                                                   \
+    {                                                                   \
+      rectangle.x = NUM2INT (arg1);                                     \
+      rectangle.y = NUM2INT (arg2);                                     \
+      rectangle.width = NUM2INT (arg3);                                 \
+      rectangle.height = NUM2INT (arg4);                                \
+    }                                                                   \
+  else                                                                  \
+    {                                                                   \
+      rb_raise (rb_eArgError, error_message,                            \
+                rb_cairo__inspect (rb_ary_new4 (argc, argv)));          \
+    }                                                                   \
+                                                                        \
+  if (other)                                                            \
+    status = cairo_region_ ## type (region, other);                     \
+  else                                                                  \
+    status = cairo_region_ ## type ## _rectangle (region, &rectangle);  \
+  rb_cairo_check_status (status);                                       \
+  cr_region_check_status (region);                                      \
+  return Qnil;                                                          \
+}
+
+DEFINE_OPERATOR(subtract)
+DEFINE_OPERATOR(intersect)
+DEFINE_OPERATOR(union)
+DEFINE_OPERATOR(xor)
+#endif
+
+void
+Init_cairo_region (void)
+{
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_cCairo_Region =
+    rb_define_class_under (rb_mCairo, "Region", rb_cObject);
+
+  rb_define_alloc_func (rb_cCairo_Region, cr_region_allocate);
+
+  rb_define_method (rb_cCairo_Region, "initialize", cr_region_initialize, -1);
+
+  rb_define_method (rb_cCairo_Region, "dup", cr_region_dup, 0);
+  rb_define_method (rb_cCairo_Region, "==", cr_region_equal, 1);
+
+  rb_define_method (rb_cCairo_Region, "extents", cr_region_get_extents, 0);
+  rb_define_method (rb_cCairo_Region, "num_rectangles",
+                    cr_region_num_rectangles, 0);
+  rb_define_method (rb_cCairo_Region, "[]",
+                    cr_region_get_rectangle, 1);
+  rb_define_method (rb_cCairo_Region, "empty?", cr_region_is_empty, 0);
+  rb_define_method (rb_cCairo_Region, "contains_rectangle",
+                    cr_region_containts_rectangle, -1);
+  rb_define_method (rb_cCairo_Region, "contains_point?",
+                    cr_region_containts_point, -1);
+
+  rb_define_method (rb_cCairo_Region, "translate!", cr_region_translate, -1);
+  rb_define_method (rb_cCairo_Region, "subtract!", cr_region_subtract, -1);
+  rb_define_method (rb_cCairo_Region, "intersect!", cr_region_intersect, -1);
+  rb_define_method (rb_cCairo_Region, "union!", cr_region_union, -1);
+  rb_define_method (rb_cCairo_Region, "xor!", cr_region_xor, -1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_Region);
+#endif
+}