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

data/src/rb_cairo_context.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2008-03-25 13:43:50 $
+ * $Date: 2008-08-17 03:00:41 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -15,10 +15,17 @@
 #include "rb_cairo.h"
 #include "rb_cairo_private.h"
 
+#ifdef HAVE_RUBY_ST_H
+#  include <ruby/st.h>
+#else
+#  include <st.h>
+#endif
+
 VALUE rb_cCairo_Context;
 
 static ID cr_id_surface, cr_id_source;
 static ID cr_id_plus, cr_id_minus, cr_id_multi, cr_id_div;
+static cairo_user_data_key_t cr_object_holder_key;
 
 #define _SELF  (RVAL2CRCONTEXT(self))
 
@@ -57,9 +64,23 @@ rb_cairo_context_from_ruby_object (VALUE obj)
       rb_raise (rb_eTypeError, "not a cairo graphics context");
     }
   Data_Get_Struct (obj, cairo_t, context);
+  if (!context)
+    rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
   return context;
 }
 
+static rb_cairo__object_holder_t *
+cr_object_holder_new (VALUE object)
+{
+  return rb_cairo__object_holder_new (rb_cCairo_Context, object);
+}
+
+static void
+cr_object_holder_free (void *ptr)
+{
+  rb_cairo__object_holder_free (rb_cCairo_Context, ptr);
+}
+
 static void
 cr_context_free (void *ptr)
 {
@@ -89,16 +110,43 @@ cr_allocate (VALUE klass)
   return Data_Wrap_Struct (klass, NULL, cr_context_free, NULL);
 }
 
+static VALUE
+cr_destroy (VALUE self)
+{
+  cairo_t *cr;
+
+  cr = _SELF;
+  cairo_set_user_data (cr, &cr_object_holder_key, NULL, NULL); /* needed? */
+  cairo_destroy (cr);
+
+  DATA_PTR (self) = NULL;
+  return Qnil;
+}
+
+static VALUE
+cr_destroy_with_destroy_check (VALUE self)
+{
+  if (DATA_PTR (self))
+    cr_destroy (self);
+  return Qnil;
+}
+
 static VALUE
 cr_initialize (VALUE self, VALUE target)
 {
   cairo_t *cr;
+  VALUE result = Qnil;
 
   cr = cairo_create (RVAL2CRSURFACE (target));
   cr_check_status (cr);
   rb_ivar_set (self, cr_id_surface, target);
+  cairo_set_user_data (cr, &cr_object_holder_key,
+                       cr_object_holder_new(self),
+                       cr_object_holder_free);
   DATA_PTR (self) = cr;
-  return Qnil;
+  if (rb_block_given_p ())
+    result = rb_ensure (rb_yield, self, cr_destroy_with_destroy_check, self);
+  return result;
 }
 
 static VALUE
@@ -211,7 +259,7 @@ cr_set_source_rgb (int argc, VALUE *argv, VALUE self)
   if (n == 1 && rb_cairo__is_kind_of (red, rb_cArray))
     {
       VALUE ary = red;
-      n = RARRAY (ary)->len;
+      n = RARRAY_LEN (ary);
       red = rb_ary_entry (ary, 0);
       green = rb_ary_entry (ary, 1);
       blue = rb_ary_entry (ary, 2);
@@ -248,7 +296,7 @@ cr_set_source_rgba (int argc, VALUE *argv, VALUE self)
   if (n == 1 && rb_cairo__is_kind_of (red, rb_cArray))
     {
       VALUE ary = red;
-      n = RARRAY (ary)->len;
+      n = RARRAY_LEN (ary);
       red = rb_ary_entry (ary, 0);
       green = rb_ary_entry (ary, 1);
       blue = rb_ary_entry (ary, 2);
@@ -318,6 +366,12 @@ cr_set_source_generic (int argc, VALUE *argv, VALUE self)
     {
       return cr_set_source_rgba (argc, argv, self);
     }
+  else if (n == 1 && rb_cairo__is_kind_of (arg1, rb_cCairo_Surface))
+    {
+      return cr_set_source_surface (self, arg1,
+                                    rb_float_new (0),
+                                    rb_float_new (0));
+    }
   else if (n == 1)
     {
       return cr_set_source (self, arg1);
@@ -336,7 +390,7 @@ cr_set_source_generic (int argc, VALUE *argv, VALUE self)
                 "invalid argument (expect "
                 "(red, green, blue), (red, green, blue, alpha), "
                 "([red, green, blue]), ([red, green, blue, alpha]), "
-                "(pattern) or (surface, x, y))");
+                "(surface), (pattern) or (surface, x, y))");
     }
 }
 
@@ -413,7 +467,7 @@ cr_set_dash (int argc, VALUE *argv, VALUE self)
       values[0] = NUM2DBL (dash_array);
       cairo_set_dash (_SELF, values, 1, offset);
     }
-  else if (NIL_P (dash_array) || RARRAY (dash_array)->len == 0)
+  else if (NIL_P (dash_array) || RARRAY_LEN (dash_array) == 0)
     {
       cairo_set_dash (_SELF, NULL, 0, offset);
     }
@@ -421,7 +475,7 @@ cr_set_dash (int argc, VALUE *argv, VALUE self)
     {
       int i, length;
       double *values;
-      length = RARRAY (dash_array)->len;
+      length = RARRAY_LEN (dash_array);
       values = ALLOCA_N (double, length);
       if (!values)
         {
@@ -429,7 +483,7 @@ cr_set_dash (int argc, VALUE *argv, VALUE self)
         }
       for (i = 0; i < length; i++)
         {
-          values[i] = NUM2DBL (RARRAY (dash_array)->ptr[i]);
+          values[i] = NUM2DBL (RARRAY_PTR (dash_array)[i]);
         }
       cairo_set_dash (_SELF, values, length, offset);
     }
@@ -588,8 +642,8 @@ cr_quadratic_curve_to (VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
   VALUE current_point, x0, y0, cx1, cy1, cx2, cy2;
 
   current_point = cr_get_current_point (self);
-  x0 = RARRAY (current_point)->ptr[0];
-  y0 = RARRAY (current_point)->ptr[1];
+  x0 = RARRAY_PTR (current_point)[0];
+  y0 = RARRAY_PTR (current_point)[1];
 
   /* cx1 = x0 + 2 * ((x1 - x0) / 3.0) */
   cx1 = rb_funcall (x0, cr_id_plus, 1,
@@ -689,8 +743,8 @@ cr_rel_quadratic_curve_to (VALUE self, VALUE dx1, VALUE dy1,
   VALUE current_point, x0, y0;
 
   current_point = cr_get_current_point (self);
-  x0 = RARRAY (current_point)->ptr[0];
-  y0 = RARRAY (current_point)->ptr[1];
+  x0 = RARRAY_PTR (current_point)[0];
+  y0 = RARRAY_PTR (current_point)[1];
   return cr_quadratic_curve_to (self,
                                 rb_funcall (dx1, cr_id_plus, 1, x0),
                                 rb_funcall (dy1, cr_id_plus, 1, y0),
@@ -1017,11 +1071,31 @@ cr_clip_rectangle_list (VALUE self)
 static   VALUE
 cr_select_font_face (int argc, VALUE *argv, VALUE self)
 {
-  VALUE family, rb_slant, rb_weight;
+  VALUE rb_family, rb_slant, rb_weight;
+  const char *family;
   cairo_font_slant_t slant;
   cairo_font_weight_t weight;
 
-  rb_scan_args(argc, argv, "12", &family, &rb_slant, &rb_weight);
+  rb_scan_args(argc, argv, "03", &rb_family, &rb_slant, &rb_weight);
+
+  if (NIL_P (rb_family))
+    {
+      family = "";
+    }
+  else if (rb_cairo__is_kind_of (rb_family, rb_cString))
+    {
+      family = RSTRING_PTR (rb_family);
+    }
+  else if (rb_cairo__is_kind_of (rb_family, rb_cSymbol))
+    {
+      family = rb_id2name (SYM2ID (rb_family));
+    }
+  else
+    {
+      rb_raise (rb_eArgError,
+                "family name should be nil, String or Symbol: %s",
+                rb_cairo__inspect (rb_family));
+    }
 
   if (NIL_P (rb_slant))
     slant = CAIRO_FONT_SLANT_NORMAL;
@@ -1033,7 +1107,7 @@ cr_select_font_face (int argc, VALUE *argv, VALUE self)
   else
     weight = RVAL2CRFONTWEIGHT (rb_weight);
 
-  cairo_select_font_face (_SELF, RVAL2CSTR (family), slant, weight);
+  cairo_select_font_face (_SELF, family, slant, weight);
   cr_check_status (_SELF);
   return self;
 }
@@ -1117,6 +1191,46 @@ cr_show_glyphs (VALUE self, VALUE rb_glyphs)
   return self;
 }
 
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE
+cr_has_show_text_glyphs (VALUE self)
+{
+  return CBOOL2RVAL (cairo_has_show_text_glyphs (_SELF));
+}
+
+static VALUE
+cr_show_text_glyphs (VALUE self, VALUE rb_utf8, VALUE rb_glyphs,
+                     VALUE rb_clusters, VALUE rb_backward)
+{
+  cairo_t *cr;
+  const char *utf8;
+  int utf8_len;
+  cairo_glyph_t *glyphs = NULL;
+  int num_glyphs = 0;
+  cairo_text_cluster_t *clusters = NULL;
+  int num_clusters = 0;
+  cairo_bool_t backward;
+
+  cr = _SELF;
+  utf8 = RSTRING_PTR (rb_utf8);
+  utf8_len = RSTRING_LEN (rb_utf8);
+  rb_cairo__glyphs_from_ruby_object (rb_glyphs, &glyphs, &num_glyphs);
+  rb_cairo__text_clusters_from_ruby_object (rb_clusters,
+                                            &clusters, &num_clusters);
+  backward = RVAL2CBOOL (rb_backward);
+  cairo_show_text_glyphs (cr, utf8, utf8_len,
+                          glyphs, num_glyphs,
+                          clusters, num_clusters,
+                          backward);
+  if (glyphs)
+    cairo_glyph_free (glyphs);
+  if (clusters)
+    cairo_text_cluster_free (clusters);
+
+  return self;
+}
+#endif
+
 static VALUE
 cr_get_font_face (VALUE self)
 {
@@ -1370,6 +1484,21 @@ cr_copy_append_path (VALUE self, VALUE path)
   return self;
 }
 
+static int
+cr_destroy_all_guarded_contexts_at_end_iter (VALUE key, VALUE value, VALUE data)
+{
+  cr_destroy (key);
+  return ST_CONTINUE;
+}
+
+static void
+cr_destroy_all_guarded_contexts_at_end (VALUE data)
+{
+  rb_hash_foreach (rb_cairo__gc_guarded_objects (rb_cCairo_Context),
+                   cr_destroy_all_guarded_contexts_at_end_iter,
+                   Qnil);
+}
+
 void
 Init_cairo_context (void)
 {
@@ -1403,8 +1532,12 @@ Init_cairo_context (void)
 
   rb_define_alloc_func (rb_cCairo_Context, cr_allocate);
 
+  rb_cairo__initialize_gc_guard_holder_class (rb_cCairo_Context);
+  rb_set_end_proc(cr_destroy_all_guarded_contexts_at_end, Qnil);
+
   /* Functions for manipulating state objects */
   rb_define_method (rb_cCairo_Context, "initialize", cr_initialize, 1);
+  rb_define_method (rb_cCairo_Context, "destroy", cr_destroy, 0);
 
   rb_define_method (rb_cCairo_Context, "save", cr_save, 0);
   rb_define_method (rb_cCairo_Context, "restore", cr_restore, 0);
@@ -1507,6 +1640,14 @@ Init_cairo_context (void)
 #endif
   rb_define_method (rb_cCairo_Context, "show_text", cr_show_text, 1);
   rb_define_method (rb_cCairo_Context, "show_glyphs", cr_show_glyphs, 1);
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_define_method (rb_cCairo_Context, "have_show_text_glyphs?",
+                    cr_has_show_text_glyphs, 0);
+  rb_define_alias (rb_cCairo_Context,
+                   "has_show_text_glyphs?", "have_show_text_glyphs?");
+  rb_define_method (rb_cCairo_Context, "show_text_glyphs",
+                    cr_show_text_glyphs, 4);
+#endif
   rb_define_method (rb_cCairo_Context, "text_path", cr_text_path, 1);
   rb_define_method (rb_cCairo_Context, "glyph_path", cr_glyph_path, 1);
   rb_define_method (rb_cCairo_Context, "text_extents", cr_text_extents, 1);

data/src/rb_cairo_exception.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2008-02-21 13:18:10 $
+ * $Date: 2008-08-16 12:52:16 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -13,6 +13,7 @@
 */
 
 #include "rb_cairo.h"
+#include "rb_cairo_private.h"
 
 static VALUE rb_eCairo_InvalidRestoreError;
 static VALUE rb_eCairo_InvalidPopGroupError;
@@ -41,6 +42,15 @@ static VALUE rb_eCairo_ClipNotRepresentableError;
 static VALUE rb_eCairo_TempFileError;
 static VALUE rb_eCairo_InvalidStrideError;
 #endif
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE rb_eCairo_FontTypeMismatch;
+static VALUE rb_eCairo_UserFontImmutable;
+static VALUE rb_eCairo_UserFontError;
+static VALUE rb_eCairo_NegativeCount;
+static VALUE rb_eCairo_InvalidClusters;
+static VALUE rb_eCairo_InvalidSlant;
+static VALUE rb_eCairo_InvalidWeight;
+#endif
 
 void
 rb_cairo_check_status (cairo_status_t status)
@@ -126,10 +136,110 @@ rb_cairo_check_status (cairo_status_t status)
     case CAIRO_STATUS_INVALID_STRIDE:
       rb_raise (rb_eCairo_InvalidStringError, string);
       break;
+#endif
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+    case CAIRO_STATUS_FONT_TYPE_MISMATCH:
+      rb_raise (rb_eCairo_FontTypeMismatch, string);
+      break;
+    case CAIRO_STATUS_USER_FONT_IMMUTABLE:
+      rb_raise (rb_eCairo_UserFontImmutable, string);
+      break;
+    case CAIRO_STATUS_USER_FONT_ERROR:
+      rb_raise (rb_eCairo_UserFontError, string);
+      break;
+    case CAIRO_STATUS_NEGATIVE_COUNT:
+      rb_raise (rb_eCairo_NegativeCount, string);
+      break;
+    case CAIRO_STATUS_INVALID_CLUSTERS:
+      rb_raise (rb_eCairo_InvalidClusters, string);
+      break;
+    case CAIRO_STATUS_INVALID_SLANT:
+      rb_raise (rb_eCairo_InvalidSlant, string);
+      break;
+    case CAIRO_STATUS_INVALID_WEIGHT:
+      rb_raise (rb_eCairo_InvalidWeight, string);
+      break;
 #endif
     }
 }
 
+cairo_status_t
+rb_cairo__exception_to_status (VALUE exception)
+{
+  if (NIL_P (exception))
+    return CAIRO_STATUS_SUCCESS;
+  else if (rb_cairo__is_kind_of (exception, rb_eNoMemError))
+    return CAIRO_STATUS_NO_MEMORY;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidRestoreError))
+    return CAIRO_STATUS_INVALID_RESTORE;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidPopGroupError))
+    return CAIRO_STATUS_INVALID_POP_GROUP;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_NoCurrentPointError))
+    return CAIRO_STATUS_NO_CURRENT_POINT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidMatrixError))
+    return CAIRO_STATUS_INVALID_MATRIX;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidStatusError))
+    return CAIRO_STATUS_INVALID_STATUS;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_NullPointerError))
+    return CAIRO_STATUS_NULL_POINTER;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidStringError))
+    return CAIRO_STATUS_INVALID_STRING;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidPathDataError))
+    return CAIRO_STATUS_INVALID_PATH_DATA;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_ReadError))
+    return CAIRO_STATUS_READ_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_WriteError))
+    return CAIRO_STATUS_WRITE_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_SurfaceFinishedError))
+    return CAIRO_STATUS_SURFACE_FINISHED;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_SurfaceTypeMismatchError))
+    return CAIRO_STATUS_SURFACE_TYPE_MISMATCH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_PatternTypeMismatchError))
+    return CAIRO_STATUS_PATTERN_TYPE_MISMATCH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidContentError))
+    return CAIRO_STATUS_INVALID_CONTENT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidFormatError))
+    return CAIRO_STATUS_INVALID_FORMAT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidVisualError))
+    return CAIRO_STATUS_INVALID_VISUAL;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_FileNotFoundError))
+    return CAIRO_STATUS_FILE_NOT_FOUND;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidDashError))
+    return CAIRO_STATUS_INVALID_DASH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidDscCommentError))
+    return CAIRO_STATUS_INVALID_DSC_COMMENT;
+#if CAIRO_CHECK_VERSION(1, 3, 0)
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidIndexError))
+    return CAIRO_STATUS_INVALID_INDEX;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_ClipNotRepresentableError))
+    return CAIRO_STATUS_CLIP_NOT_REPRESENTABLE;
+#endif
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_TempFileError))
+    return CAIRO_STATUS_TEMP_FILE_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidStringError))
+    return CAIRO_STATUS_INVALID_STRIDE;
+#endif
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_FontTypeMismatch))
+    return CAIRO_STATUS_FONT_TYPE_MISMATCH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_UserFontImmutable))
+    return CAIRO_STATUS_USER_FONT_IMMUTABLE;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_UserFontError))
+    return CAIRO_STATUS_USER_FONT_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_NegativeCount))
+    return CAIRO_STATUS_NEGATIVE_COUNT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidClusters))
+    return CAIRO_STATUS_INVALID_CLUSTERS;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidSlant))
+    return CAIRO_STATUS_INVALID_SLANT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidWeight))
+    return CAIRO_STATUS_INVALID_WEIGHT;
+#endif
+
+  return -1;
+}
+
 void
 Init_cairo_exception ()
 {
@@ -208,7 +318,37 @@ Init_cairo_exception ()
                            rb_eCairo_Error);
 
   rb_eCairo_InvalidStrideError =
-        rb_define_class_under (rb_mCairo, "InvalidStrideError",
-                               rb_eArgError);
+    rb_define_class_under (rb_mCairo, "InvalidStrideError",
+                           rb_eArgError);
+#endif
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_eCairo_FontTypeMismatch =
+    rb_define_class_under (rb_mCairo, "FontTypeMismatch",
+                           rb_eCairo_Error);
+
+  rb_eCairo_UserFontImmutable =
+    rb_define_class_under (rb_mCairo, "UserFontImmutable",
+                           rb_eCairo_Error);
+
+  rb_eCairo_UserFontError =
+    rb_define_class_under (rb_mCairo, "UserFontError",
+                           rb_eCairo_Error);
+
+  rb_eCairo_NegativeCount =
+    rb_define_class_under (rb_mCairo, "NegativeCount",
+                           rb_eCairo_Error);
+
+  rb_eCairo_InvalidClusters =
+    rb_define_class_under (rb_mCairo, "InvalidClusters",
+                           rb_eArgError);
+
+  rb_eCairo_InvalidSlant =
+    rb_define_class_under (rb_mCairo, "InvalidSlant",
+                           rb_eCairo_Error);
+
+  rb_eCairo_InvalidWeight =
+    rb_define_class_under (rb_mCairo, "InvalidWeight",
+                           rb_eArgError);
 #endif
 }