cairo 1.14.0-x64-mingw32

data/ext/cairo/rb_cairo_private.c

@@ -0,0 +1,255 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-17 07:21:42 $
+ *
+ * Copyright 2005-2014 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_cairo__cFFIPointer;
+
+static ID cr_id_normalize_const_name;
+static ID cr_id_objects;
+static ID cr_id_dup;
+static ID cr_id_inspect;
+static ID cr_id_exit_application;
+
+VALUE
+rb_cairo__float_array (double *values, unsigned count)
+{
+  VALUE result;
+  unsigned i;
+
+  result = rb_ary_new2 (count);
+  for (i = 0; i < count; i++)
+    {
+      rb_ary_push (result, rb_float_new (values[i]));
+    }
+  return result;
+}
+
+void
+rb_cairo__glyphs_to_array (VALUE rb_array, cairo_glyph_t *glyphs, int length)
+{
+  int i;
+
+  for (i = 0; i < length; i++)
+    {
+      memcpy ((char *) &glyphs[i],
+              (char *) RVAL2CRGLYPH (rb_ary_entry (rb_array, i)),
+              sizeof (cairo_glyph_t));
+    }
+}
+
+VALUE
+rb_cairo__const_get (VALUE name, const char *prefix)
+{
+  VALUE rb_normalized_name;
+  char *const_name, *normalized_name;
+  size_t prefix_len, normalized_name_len;
+
+  rb_normalized_name = rb_funcall (rb_mCairo,
+                                   cr_id_normalize_const_name, 1, name);
+  normalized_name = RVAL2CSTR (rb_normalized_name);
+
+  prefix_len = strlen (prefix);
+  normalized_name_len = strlen (normalized_name);
+
+  const_name = ALLOCA_N (char, prefix_len + normalized_name_len + 1);
+  strncpy (const_name, prefix, prefix_len);
+  strncpy (const_name + prefix_len, normalized_name, normalized_name_len);
+  const_name[prefix_len + normalized_name_len] = '\0';
+
+  return rb_const_get (rb_mCairo, rb_intern (const_name));
+}
+
+cairo_bool_t
+rb_cairo__is_kind_of (VALUE object, VALUE klass)
+{
+  return RVAL2CBOOL (rb_obj_is_kind_of (object, klass));
+}
+
+rb_cairo__object_holder_t *
+rb_cairo__object_holder_new (VALUE klass, VALUE object)
+{
+  rb_cairo__object_holder_t *holder;
+
+  holder = ALLOC(rb_cairo__object_holder_t);
+  rb_cairo__gc_guard_add (klass, object);
+  holder->object = object;
+  return holder;
+}
+
+void
+rb_cairo__object_holder_free (VALUE klass, void *ptr)
+{
+  rb_cairo__object_holder_t *holder = ptr;
+
+  if (!NIL_P (holder->object))
+    rb_cairo__gc_guard_remove (klass, holder->object);
+
+  xfree (holder);
+}
+
+void
+rb_cairo__initialize_gc_guard_holder_class (VALUE klass)
+{
+  rb_ivar_set (klass, cr_id_objects, rb_hash_new ());
+}
+
+void
+rb_cairo__gc_guard_add (VALUE klass, VALUE object)
+{
+  rb_hash_aset (rb_ivar_get (klass, cr_id_objects), object, Qnil);
+}
+
+void
+rb_cairo__gc_guard_remove (VALUE klass, VALUE object)
+{
+  rb_hash_delete (rb_ivar_get (klass, cr_id_objects), object);
+}
+
+VALUE
+rb_cairo__gc_guarded_objects (VALUE klass)
+{
+  return rb_funcall (rb_ivar_get (klass, cr_id_objects), cr_id_dup, 0);
+}
+
+const char *
+rb_cairo__inspect (VALUE object)
+{
+  VALUE inspected;
+
+  inspected = rb_funcall (object, cr_id_inspect, 0);
+  return RSTRING_PTR (inspected);
+}
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+VALUE
+rb_cairo__glyphs_to_ruby_object (cairo_glyph_t *glyphs, int num_glyphs)
+{
+  int i;
+  VALUE rb_glyphs;
+
+  rb_glyphs = rb_ary_new2 (num_glyphs);
+  for (i = 0; i < num_glyphs; i++)
+    {
+      RARRAY_PTR (rb_glyphs)[i] = CRGLYPH2RVAL (glyphs + i);
+    }
+
+  return rb_glyphs;
+}
+
+void
+rb_cairo__glyphs_from_ruby_object (VALUE rb_glyphs,
+                                   cairo_glyph_t **glyphs, int *num_glyphs)
+{
+  int i, len;
+
+  if (NIL_P (rb_glyphs))
+    {
+      *num_glyphs = -1;
+      return;
+    }
+
+  len = RARRAY_LEN (rb_glyphs);
+  if (*num_glyphs < len)
+    *glyphs = cairo_glyph_allocate (len);
+  *num_glyphs = len;
+  for (i = 0; i < len; i++)
+    {
+      cairo_glyph_t *glyph;
+
+      glyph = *glyphs + i;
+      *glyph = *(RVAL2CRGLYPH (RARRAY_PTR (rb_glyphs)[i]));
+    }
+}
+
+VALUE
+rb_cairo__text_clusters_to_ruby_object (cairo_text_cluster_t *clusters,
+                                        int num_clusters)
+{
+  int i;
+  VALUE rb_clusters;
+
+  rb_clusters = rb_ary_new2 (num_clusters);
+  for (i = 0; i < num_clusters; i++)
+    {
+      RARRAY_PTR (rb_clusters)[i] = CRTEXTCLUSTER2RVAL (clusters + i);
+    }
+
+  return rb_clusters;
+}
+
+void
+rb_cairo__text_clusters_from_ruby_object (VALUE rb_clusters,
+                                          cairo_text_cluster_t **clusters,
+                                          int *num_clusters)
+{
+  int i, len;
+
+  if (NIL_P (rb_clusters))
+    {
+      *num_clusters = -1;
+      return;
+    }
+
+  len = RARRAY_LEN (rb_clusters);
+  if (*num_clusters < len)
+    *clusters = cairo_text_cluster_allocate (len);
+  *num_clusters = len;
+  for (i = 0; i < len; i++)
+    {
+      cairo_text_cluster_t *cluster;
+
+      cluster = *clusters + i;
+      *cluster = *(RVAL2CRTEXTCLUSTER (RARRAY_PTR (rb_clusters)[i]));
+    }
+}
+#endif
+
+VALUE
+rb_cairo__invoke_callback (cr_callback_func_t func, VALUE data)
+{
+  int state = 0;
+  VALUE result, exception;
+
+  result = rb_protect (func, data, &state);
+  if (state)
+    {
+      exception = RB_ERRINFO;
+      if (exception)
+        rb_funcall (rb_mCairo, cr_id_exit_application, 2,
+                    exception, INT2NUM (EXIT_FAILURE));
+    }
+  return result;
+}
+
+void
+Init_cairo_private (void)
+{
+  cr_id_normalize_const_name = rb_intern ("normalize_const_name");
+  cr_id_objects = rb_intern ("objects");
+  cr_id_dup = rb_intern ("dup");
+  cr_id_inspect = rb_intern ("inspect");
+  cr_id_exit_application = rb_intern ("exit_application");
+
+  if (rb_const_defined (rb_cObject, rb_intern ("FFI")))
+    {
+      rb_cairo__cFFIPointer =
+        rb_const_get (rb_const_get (rb_cObject, rb_intern ("FFI")),
+                      rb_intern ("Pointer"));
+    }
+  else
+    {
+      rb_cairo__cFFIPointer = Qnil;
+    }
+}

data/ext/cairo/rb_cairo_private.h

@@ -0,0 +1,129 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-17 07:21:42 $
+ *
+ * Copyright 2005-2014 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+*/
+
+#ifndef RB_CAIRO_PRIVATE_H
+#define RB_CAIRO_PRIVATE_H
+
+#define CR_TRUE 1
+#define CR_FALSE 0
+
+#define CAIRO_INT_STATUS_UNSUPPORTED 100
+
+#define CSTR2RVAL(str) rb_str_new2(str)
+#define RVAL2CSTR(str) StringValueCStr(str)
+
+#define CBOOL2RVAL(bool) (bool ? Qtrue : Qfalse)
+#define RVAL2CBOOL(bool) RTEST(bool)
+
+#ifndef RSTRING_LEN
+#  define RSTRING_LEN(string) (RSTRING(string)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#  define RARRAY_PTR(array) (RARRAY(array)->ptr)
+#endif
+
+#ifndef RARRAY_LEN
+#  define RARRAY_LEN(array) (RARRAY(array)->len)
+#endif
+
+#ifdef HAVE_RB_ERRINFO
+#  define RB_ERRINFO (rb_errinfo())
+#else
+#  define RB_ERRINFO (ruby_errinfo)
+#endif
+
+/* from dl/dl.h (ruby 1.9) */
+#if SIZEOF_LONG == SIZEOF_VOIDP
+#  define PTR2NUM(x)   (ULONG2NUM((unsigned long)(x)))
+#  define NUM2PTR(x)   ((void *)(NUM2ULONG(x)))
+#else
+#  define PTR2NUM(x)   (ULL2NUM((unsigned long long)(x)))
+#  define NUM2PTR(x)   ((void *)(NUM2ULL(x)))
+#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_rectangle (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);
+extern void Init_cairo_font (void);
+extern void Init_cairo_font_extents (void);
+extern void Init_cairo_font_options (void);
+extern void Init_cairo_scaled_font (void);
+extern void Init_cairo_text_extents (void);
+extern void Init_cairo_pattern (void);
+extern void Init_cairo_glyph (void);
+extern void Init_cairo_text_cluster (void);
+
+#define RB_CAIRO__GLYPHS_TO_ARRAY(rb_array, glyphs, length)     \
+do                                                              \
+  {                                                             \
+    Check_Type (rb_array, T_ARRAY);                             \
+    length = RARRAY_LEN (rb_array);                             \
+    glyphs = ALLOCA_N (cairo_glyph_t, length);                  \
+                                                                \
+    if (!glyphs)                                                \
+      rb_cairo_check_status (CAIRO_STATUS_NO_MEMORY);           \
+                                                                \
+    rb_cairo__glyphs_to_array (rb_array, glyphs, length);       \
+  } while (0)
+
+VALUE rb_cairo__float_array (double *values, unsigned count);
+void rb_cairo__glyphs_to_array (VALUE rb_array, cairo_glyph_t *glyphs, int length);
+
+VALUE rb_cairo__const_get (VALUE name, const char *prefix);
+cairo_bool_t rb_cairo__is_kind_of (VALUE object, VALUE klass);
+
+typedef struct rb_cairo__object_holder {
+  VALUE object;
+} rb_cairo__object_holder_t;
+
+rb_cairo__object_holder_t *rb_cairo__object_holder_new (VALUE klass, VALUE object);
+void rb_cairo__object_holder_free (VALUE klass, void *ptr);
+
+
+void rb_cairo__initialize_gc_guard_holder_class (VALUE klass);
+void rb_cairo__gc_guard_add (VALUE klass, VALUE object);
+void rb_cairo__gc_guard_remove (VALUE klass, VALUE object);
+VALUE rb_cairo__gc_guarded_objects (VALUE klass);
+
+const char *rb_cairo__inspect (VALUE object);
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+VALUE rb_cairo__glyphs_to_ruby_object (cairo_glyph_t *glyphs, int num_glyphs);
+void rb_cairo__glyphs_from_ruby_object (VALUE rb_glyphs,
+                                        cairo_glyph_t **glyphs, int *num_glyphs);
+VALUE rb_cairo__text_clusters_to_ruby_object (cairo_text_cluster_t *clusters,
+                                              int num_clusters);
+void rb_cairo__text_clusters_from_ruby_object (VALUE rb_clusters,
+                                               cairo_text_cluster_t **clusters,
+                                               int *num_clusters);
+#endif
+
+cairo_status_t rb_cairo__exception_to_status (VALUE exception);
+
+typedef VALUE (*cr_callback_func_t) (VALUE user_data);
+VALUE rb_cairo__invoke_callback (cr_callback_func_t func, VALUE user_data);
+
+extern VALUE rb_cairo__cFFIPointer;
+
+#endif

data/ext/cairo/rb_cairo_rectangle.c

@@ -0,0 +1,83 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * Copyright 2005-2014 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+*/
+
+#include "rb_cairo.h"
+
+VALUE rb_cCairo_Rectangle;
+
+#define _SELF  ((cairo_rectangle_int_t *)DATA_PTR (self))
+
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+static VALUE
+cr_rectangle_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, xfree, NULL);
+}
+
+static VALUE
+cr_rectangle_initialize (VALUE self, VALUE x, VALUE y,
+                         VALUE width, VALUE height)
+{
+  cairo_rectangle_int_t *rectangle;
+
+  rectangle = ALLOC (cairo_rectangle_int_t);
+  DATA_PTR (self) = rectangle;
+
+  rectangle->x = NUM2INT (x);
+  rectangle->y = NUM2INT (y);
+  rectangle->width = NUM2INT (width);
+  rectangle->height = NUM2INT (height);
+
+  return Qnil;
+}
+
+#  define DEFINE_RECTANGLE_ACCESSOR(name)               \
+static VALUE                                            \
+cr_rectangle_get_ ## name (VALUE self)                  \
+{                                                       \
+  return INT2NUM (_SELF->name);                         \
+}                                                       \
+                                                        \
+static VALUE                                            \
+cr_rectangle_set_ ## name (VALUE self, VALUE value)     \
+{                                                       \
+  _SELF->name = NUM2INT (value);                        \
+  return self;                                          \
+}
+
+DEFINE_RECTANGLE_ACCESSOR(x)
+DEFINE_RECTANGLE_ACCESSOR(y)
+DEFINE_RECTANGLE_ACCESSOR(width)
+DEFINE_RECTANGLE_ACCESSOR(height)
+
+#  undef DEFINE_RECTANGLE_ACCESSOR
+#endif
+
+void
+Init_cairo_rectangle (void)
+{
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_cCairo_Rectangle =
+    rb_define_class_under (rb_mCairo, "Rectangle", rb_cObject);
+  rb_define_alloc_func (rb_cCairo_Rectangle, cr_rectangle_allocate);
+
+  rb_define_method (rb_cCairo_Rectangle, "initialize",
+                    cr_rectangle_initialize, 4);
+
+  rb_define_method (rb_cCairo_Rectangle, "x",  cr_rectangle_get_x, 0);
+  rb_define_method (rb_cCairo_Rectangle, "x=", cr_rectangle_set_x, 1);
+  rb_define_method (rb_cCairo_Rectangle, "y",  cr_rectangle_get_y, 0);
+  rb_define_method (rb_cCairo_Rectangle, "y=", cr_rectangle_set_y, 1);
+  rb_define_method (rb_cCairo_Rectangle, "width",  cr_rectangle_get_width, 0);
+  rb_define_method (rb_cCairo_Rectangle, "width=", cr_rectangle_set_width, 1);
+  rb_define_method (rb_cCairo_Rectangle, "height",  cr_rectangle_get_height, 0);
+  rb_define_method (rb_cCairo_Rectangle, "height=", cr_rectangle_set_height, 1);
+#endif
+}