cairo 1.6.1-x86-mswin32 → 1.7.0-x86-mswin32

data/src/rb_cairo_font_options.c

@@ -3,9 +3,9 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007-05-26 15:13:25 $
+ * $Date: 2008-08-17 07:21:42 $
  *
- * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
+ * Copyright 2005-2008 Kouhei Sutou <kou@cozmixng.org>
  *
  * This file is made available under the same terms as Ruby
  *
@@ -160,6 +160,22 @@ cr_options_get_hint_metrics (VALUE self)
   return INT2NUM (cairo_font_options_get_hint_metrics (_SELF (self)));
 }
 
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE
+cr_options_set_lcd_filter (VALUE self, VALUE lcd_filter)
+{
+  cairo_font_options_set_lcd_filter (_SELF (self),
+                                     RVAL2CRLCDFILTER (lcd_filter));
+  return self;
+}
+
+static VALUE
+cr_options_get_lcd_filter (VALUE self)
+{
+  return INT2NUM (cairo_font_options_get_lcd_filter (_SELF (self)));
+}
+#endif
+
 
 void
 Init_cairo_font_options (void)
@@ -192,6 +208,12 @@ Init_cairo_font_options (void)
                     cr_options_set_hint_metrics, 1);
   rb_define_method (rb_cCairo_FontOptions, "hint_metrics",
                     cr_options_get_hint_metrics, 0);
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_define_method (rb_cCairo_FontOptions, "set_lcd_filter",
+                    cr_options_set_lcd_filter, 1);
+  rb_define_method (rb_cCairo_FontOptions, "lcd_filter",
+                    cr_options_get_lcd_filter, 0);
+#endif
 
   RB_CAIRO_DEF_SETTERS (rb_cCairo_FontOptions);
 }

data/src/rb_cairo_glyph.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/03 02:47:39 $
+ * $Date: 2008-08-16 08:16:39 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -37,7 +37,7 @@ cr_glyph_free (void *ptr)
 {
   if (ptr)
     {
-      free (ptr);
+      xfree (ptr);
     }
 }
 
@@ -46,7 +46,9 @@ rb_cairo_glyph_to_ruby_object (cairo_glyph_t *glyph)
 {
   if (glyph)
     {
-      cairo_glyph_t *new_glyph = ALLOC (cairo_glyph_t);
+      cairo_glyph_t *new_glyph;
+
+      new_glyph = ALLOC (cairo_glyph_t);
       *new_glyph = *glyph;
       return Data_Wrap_Struct (rb_cCairo_Glyph, NULL, cr_glyph_free, new_glyph);
     }

data/src/rb_cairo_matrix.c

@@ -3,8 +3,9 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/21 11:54:44 $
+ * $Date: 2008-08-14 12:37:50 $
  *
+ * Copyright 2006-2008 Kouhei Sutou <kou@cozmixng.org>
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
  *
@@ -18,6 +19,8 @@
 
 VALUE rb_cCairo_Matrix;
 
+static ID cr_id_equal;
+
 #define _SELF  (RVAL2CRMATRIX(self))
 
 cairo_matrix_t *
@@ -295,10 +298,22 @@ cr_matrix_to_s(VALUE self)
   return ret;
 }
 
+static VALUE
+cr_matrix_equal (VALUE self, VALUE other)
+{
+  if (!rb_cairo__is_kind_of (other, rb_cCairo_Matrix))
+    return Qfalse;
+
+  return rb_funcall (cr_matrix_to_a (self),
+                     cr_id_equal, 1,
+                     cr_matrix_to_a (other));
+}
 
 void
 Init_cairo_matrix (void)
 {
+  cr_id_equal = rb_intern ("==");
+
   rb_cCairo_Matrix =
     rb_define_class_under (rb_mCairo, "Matrix", rb_cObject);
 
@@ -344,6 +359,7 @@ Init_cairo_matrix (void)
   rb_define_method (rb_cCairo_Matrix, "set", cr_matrix_set, 6);
   rb_define_method (rb_cCairo_Matrix, "to_a", cr_matrix_to_a, 0);
   rb_define_method (rb_cCairo_Matrix, "to_s", cr_matrix_to_s, 0);
+  rb_define_method (rb_cCairo_Matrix, "==", cr_matrix_equal, 1);
 
 
   RB_CAIRO_DEF_SETTERS (rb_cCairo_Matrix);

data/src/rb_cairo_pattern.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/22 14:24:34 $
+ * $Date: 2008-06-12 10:59:54 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -137,10 +137,10 @@ cr_solid_pattern_initialize (int argc, VALUE *argv, VALUE self)
     }
 
   if (n == 1 && rb_cairo__is_kind_of (red, rb_cArray) &&
-      (RARRAY (red)->len == 3 || RARRAY (red)->len == 4))
+      (RARRAY_LEN (red) == 3 || RARRAY_LEN (red) == 4))
     {
       VALUE ary = red;
-      n = RARRAY (ary)->len;
+      n = RARRAY_LEN (ary);
 
       red = rb_ary_entry (ary, 0);
       green = rb_ary_entry (ary, 1);
@@ -247,7 +247,7 @@ cr_gradient_pattern_add_color_stop_generic (int argc, VALUE *argv, VALUE self)
   if (n == 2 && rb_cairo__is_kind_of (red, rb_cArray))
     {
       VALUE ary = red;
-      n = RARRAY (ary)->len + 1;
+      n = RARRAY_LEN (ary) + 1;
 
       red = rb_ary_entry (ary, 0);
       green = rb_ary_entry (ary, 1);

data/src/rb_cairo_private.c

@@ -3,9 +3,9 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/18 14:07:48 $
+ * $Date: 2008-08-17 07:21:42 $
  *
- * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
+ * Copyright 2005-2008 Kouhei Sutou <kou@cozmixng.org>
  *
  * This file is made available under the same terms as Ruby
  *
@@ -14,7 +14,11 @@
 #include "rb_cairo.h"
 #include "rb_cairo_private.h"
 
-static ID id_normalize_const_name;
+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)
@@ -50,7 +54,8 @@ rb_cairo__const_get (VALUE name, const char *prefix)
   char *const_name, *normalized_name;
   size_t prefix_len, normalized_name_len;
 
-  rb_normalized_name = rb_funcall (rb_mCairo, id_normalize_const_name, 1, name);
+  rb_normalized_name = rb_funcall (rb_mCairo,
+                                   cr_id_normalize_const_name, 1, name);
   normalized_name = RVAL2CSTR (rb_normalized_name);
 
   prefix_len = strlen (prefix);
@@ -70,9 +75,168 @@ 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)
 {
-  id_normalize_const_name = rb_intern ("normalize_const_name");
+  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");
 }

data/src/rb_cairo_private.h

@@ -3,9 +3,9 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2008-01-11 08:03:39 $
+ * $Date: 2008-08-17 07:21:42 $
  *
- * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
+ * Copyright 2005-2008 Kouhei Sutou <kou@cozmixng.org>
  *
  * This file is made available under the same terms as Ruby
  *
@@ -17,6 +17,8 @@
 #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)
 
@@ -27,6 +29,14 @@
 #  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
@@ -49,12 +59,13 @@ 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 (rb_array)->len;                            \
+    length = RARRAY_LEN (rb_array);                             \
     glyphs = ALLOCA_N (cairo_glyph_t, length);                  \
                                                                 \
     if (!glyphs)                                                \
@@ -69,4 +80,35 @@ void rb_cairo__glyphs_to_array (VALUE rb_array, cairo_glyph_t *glyphs, int lengt
 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);
+
 #endif

data/src/rb_cairo_scaled_font.c

@@ -3,9 +3,9 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/20 09:18:49 $
+ * $Date: 2008-08-16 08:34:19 $
  *
- * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
+ * Copyright 2005-2008 Kouhei Sutou <kou@cozmixng.org>
  *
  * This file is made available under the same terms as Ruby
  *
@@ -114,6 +114,42 @@ cr_scaled_font_glyph_extents (VALUE self, VALUE rb_glyphs)
   return CRTEXTEXTENTS2RVAL (&extents);
 }
 
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE
+cr_scaled_font_text_to_glyphs (VALUE self, VALUE rb_x, VALUE rb_y, VALUE rb_utf8)
+{
+  double x, y;
+  const char *utf8;
+  int utf8_len;
+  cairo_glyph_t *glyphs = NULL;
+  int num_glyphs;
+  cairo_text_cluster_t *clusters = NULL;
+  int num_clusters;
+  cairo_bool_t backward;
+  cairo_status_t status;
+  VALUE rb_glyphs, rb_clusters;
+
+  x = NUM2DBL (rb_x);
+  y = NUM2DBL (rb_y);
+  utf8 = RSTRING_PTR (rb_utf8);
+  utf8_len = RSTRING_LEN (rb_utf8);
+
+  status = cairo_scaled_font_text_to_glyphs (_SELF (self),
+                                             x, y, utf8, utf8_len,
+                                             &glyphs, &num_glyphs,
+                                             &clusters, &num_clusters,
+                                             &backward);
+  rb_cairo_check_status (status);
+
+  rb_glyphs = rb_cairo__glyphs_to_ruby_object (glyphs, num_glyphs);
+  cairo_glyph_free (glyphs);
+  rb_clusters = rb_cairo__text_clusters_to_ruby_object (clusters, num_clusters);
+  cairo_text_cluster_free (clusters);
+
+  return rb_ary_new3 (3, rb_glyphs, rb_clusters, CBOOL2RVAL (backward));
+}
+#endif
+
 static VALUE
 cr_scaled_font_get_font_face (VALUE self)
 {
@@ -144,13 +180,27 @@ cr_scaled_font_get_ctm (VALUE self)
 static VALUE
 cr_scaled_font_get_font_options (VALUE self)
 {
-  cairo_font_options_t *options = cairo_font_options_create();
+  cairo_font_options_t *options;
+
+  options = cairo_font_options_create();
   cairo_scaled_font_get_font_options (_SELF (self), options);
   cr_scaled_font_check_status (_SELF (self));
   rb_cairo_check_status (cairo_font_options_status (options));
   return CRFONTOPTIONS2RVAL (options);
 }
 
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE
+cr_scaled_font_get_scale_matrix (VALUE self)
+{
+  cairo_matrix_t matrix;
+
+  cairo_scaled_font_get_scale_matrix (_SELF (self), &matrix);
+  cr_scaled_font_check_status (_SELF (self));
+  return CRMATRIX2RVAL (&matrix);
+}
+#endif
+
 void
 Init_cairo_scaled_font (void)
 {
@@ -167,6 +217,10 @@ Init_cairo_scaled_font (void)
                     cr_scaled_font_text_extents, 1);
   rb_define_method (rb_cCairo_ScaledFont, "glyph_extents",
                     cr_scaled_font_glyph_extents, 1);
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_define_method (rb_cCairo_ScaledFont, "text_to_glyphs",
+                    cr_scaled_font_text_to_glyphs, 3);
+#endif
   rb_define_method (rb_cCairo_ScaledFont, "font_face",
                     cr_scaled_font_get_font_face, 0);
   rb_define_method (rb_cCairo_ScaledFont, "font_matrix",
@@ -174,4 +228,8 @@ Init_cairo_scaled_font (void)
   rb_define_method (rb_cCairo_ScaledFont, "ctm", cr_scaled_font_get_ctm, 0);
   rb_define_method (rb_cCairo_ScaledFont, "font_options",
                     cr_scaled_font_get_font_options, 0);
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_define_method (rb_cCairo_ScaledFont, "scale_matrix",
+                    cr_scaled_font_get_scale_matrix, 0);
+#endif
 }