cairo 1.4.1 → 1.5.0

data/src/rb_cairo_pattern.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/03/06 12:17:34 $
+ * $Date: 2007/05/22 14:24:34 $
  *
  * 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"
 
 VALUE rb_cCairo_Pattern;
 VALUE rb_cCairo_SolidPattern;
@@ -21,19 +22,57 @@ VALUE rb_cCairo_GradientPattern;
 VALUE rb_cCairo_LinearPattern;
 VALUE rb_cCairo_RadialPattern;
 
+static ID id_parse, id_to_rgb, id_to_a, id_inspect;
+
 #define _SELF(self)  (RVAL2CRPATTERN(self))
 
+static VALUE
+cr_color_parse (VALUE color)
+{
+  return rb_funcall (rb_mCairo_Color, id_parse, 1, color);
+}
+
 static inline void
 cr_pattern_check_status (cairo_pattern_t *pattern)
 {
   rb_cairo_check_status (cairo_pattern_status (pattern));
 }
 
+static VALUE
+cr_pattern_get_klass (cairo_pattern_t *pattern)
+{
+  VALUE klass;
+  cairo_pattern_type_t type;
+
+  type = cairo_pattern_get_type (pattern);
+  switch (type)
+    {
+    case CAIRO_PATTERN_TYPE_SOLID:
+      klass = rb_cCairo_SolidPattern;
+      break;
+    case CAIRO_PATTERN_TYPE_SURFACE:
+      klass = rb_cCairo_SurfacePattern;
+      break;
+    case CAIRO_PATTERN_TYPE_LINEAR:
+      klass = rb_cCairo_LinearPattern;
+      break;
+    case CAIRO_PATTERN_TYPE_RADIAL:
+      klass = rb_cCairo_RadialPattern;
+      break;
+    default:
+      rb_raise (rb_eArgError, "unknown pattern type: %d", type);
+      break;
+    }
+
+  return klass;
+}
+
+
 cairo_pattern_t *
 rb_cairo_pattern_from_ruby_object (VALUE obj)
 {
   cairo_pattern_t *pattern;
-  if (!RTEST (rb_obj_is_kind_of (obj, rb_cCairo_Pattern)))
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_Pattern))
     {
       rb_raise (rb_eTypeError, "not a cairo pattern");
     }
@@ -51,10 +90,12 @@ cr_pattern_free (void *ptr)
 }
 
 VALUE
-rb_cairo_pattern_to_ruby_object (cairo_pattern_t *pattern, VALUE klass)
+rb_cairo_pattern_to_ruby_object (cairo_pattern_t *pattern)
 {
   if (pattern)
     {
+      VALUE klass;
+      klass = cr_pattern_get_klass (pattern);
       cairo_pattern_reference (pattern);
       return Data_Wrap_Struct (klass, NULL, cr_pattern_free, pattern);
     }
@@ -77,12 +118,6 @@ cr_pattern_initialize (VALUE self)
   return Qnil;
 }
 
-static VALUE
-cr_pattern_get_type (VALUE self)
-{
-  return INT2NUM (cairo_pattern_get_type (_SELF (self)));
-}
-
 static VALUE
 cr_solid_pattern_initialize (int argc, VALUE *argv, VALUE self)
 {
@@ -91,13 +126,22 @@ cr_solid_pattern_initialize (int argc, VALUE *argv, VALUE self)
   cairo_pattern_t *pattern;
 
   n = rb_scan_args (argc, argv, "13", &red, &green, &blue, &alpha);
-  
-  if (n == 1 && rb_obj_is_kind_of (red, rb_cArray) &&
+
+  if (n == 1)
+    {
+      VALUE color = red;
+
+      color = cr_color_parse (color);
+      if (rb_cairo__is_kind_of (color, rb_cCairo_Color_Base))
+        red = rb_funcall (rb_funcall (color, id_to_rgb, 0), id_to_a, 0);
+    }
+
+  if (n == 1 && rb_cairo__is_kind_of (red, rb_cArray) &&
       (RARRAY (red)->len == 3 || RARRAY (red)->len == 4))
     {
       VALUE ary = red;
       n = RARRAY (ary)->len;
-      
+
       red = rb_ary_entry (ary, 0);
       green = rb_ary_entry (ary, 1);
       blue = rb_ary_entry (ary, 2);
@@ -119,15 +163,25 @@ cr_solid_pattern_initialize (int argc, VALUE *argv, VALUE self)
     }
   else
     {
+      VALUE inspected;
+
+      inspected = rb_funcall (argc == 1 ? red : rb_ary_new4 (argc, argv),
+                              id_inspect, 0);
       rb_raise (rb_eArgError,
-                "invalid argument (expect "
+                "invalid argument: %s (expect "
+                "(color_name), "
+                "(color_hex_triplet), "
+                "(Cairo::Color::RGB), "
+                "(Cairo::Color::CMYK), "
+                "(Cairo::Color::HSV), "
                 "(red, green, blue), "
                 "([red, green, blue]), "
                 "(red, green, blue, alpha) or "
                 "([red, green, blue, alpha])"
-                ")");
+                ")",
+                RVAL2CSTR (inspected));
     }
-  
+
   cr_pattern_check_status (pattern);
   DATA_PTR (self) = pattern;
   return Qnil;
@@ -174,57 +228,27 @@ cr_radial_pattern_initialize (VALUE self, VALUE cx0, VALUE cy0, VALUE radius0,
 
 /* Cairo::GradientPattern */
 static VALUE
-cr_gradient_pattern_add_color_stop_rgb (int argc, VALUE *argv, VALUE self)
+cr_gradient_pattern_add_color_stop_generic (int argc, VALUE *argv, VALUE self)
 {
-  VALUE offset, red, green, blue;
+  VALUE offset, red, green, blue, alpha;
   int n;
-  
-  n = rb_scan_args (argc, argv, "22", &offset, &red, &green, &blue);
 
-  if (n == 2 && rb_obj_is_kind_of (red, rb_cArray))
-    {
-      VALUE ary = red;
-      n = RARRAY (ary)->len + 1;
-      
-      red = rb_ary_entry (ary, 0);
-      green = rb_ary_entry (ary, 1);
-      blue = rb_ary_entry (ary, 2);
-    }
+  n = rb_scan_args (argc, argv, "23", &offset, &red, &green, &blue, &alpha);
 
-  if (n == 4)
+  if (n == 2)
     {
-      cairo_pattern_add_color_stop_rgb (_SELF (self), NUM2DBL (offset),
-                                        NUM2DBL (red), NUM2DBL (green),
-                                        NUM2DBL (blue));
-    }
-  else
-    {
-      VALUE inspected_arg = rb_inspect (rb_ary_new4 (argc, argv));
-      rb_raise (rb_eArgError,
-                "invalid argument: %s (expect "
-                "(offset, red, green, blue) or "
-                "(offset, [red, green, blue])"
-                ")",
-                StringValuePtr (inspected_arg));
-    }
-
-  cr_pattern_check_status (_SELF (self));
-  return self;
-}
+      VALUE color = red;
 
-static VALUE
-cr_gradient_pattern_add_color_stop_rgba (int argc, VALUE *argv, VALUE self)
-{
-  VALUE offset, red, green, blue, alpha;
-  int n;
-  
-  n = rb_scan_args (argc, argv, "23", &offset, &red, &green, &blue, &alpha);
+      color = cr_color_parse (color);
+      if (rb_cairo__is_kind_of (color, rb_cCairo_Color_Base))
+        red = rb_funcall (rb_funcall (color, id_to_rgb, 0), id_to_a, 0);
+    }
 
-  if (n == 2 && rb_obj_is_kind_of (red, rb_cArray))
+  if (n == 2 && rb_cairo__is_kind_of (red, rb_cArray))
     {
       VALUE ary = red;
       n = RARRAY (ary)->len + 1;
-      
+
       red = rb_ary_entry (ary, 0);
       green = rb_ary_entry (ary, 1);
       blue = rb_ary_entry (ary, 2);
@@ -245,22 +269,28 @@ cr_gradient_pattern_add_color_stop_rgba (int argc, VALUE *argv, VALUE self)
     }
   else
     {
-      VALUE inspected_arg = rb_inspect (rb_ary_new4 (argc, argv));
+      VALUE inspected;
+
+      inspected = rb_funcall (rb_ary_new4 (argc, argv), id_inspect, 0);
       rb_raise (rb_eArgError,
                 "invalid argument: %s (expect "
+                "(offset, color_name), "
+                "(offset, color_hex_triplet), "
+                "(offset, Cairo::Color::RGB), "
+                "(offset, Cairo::Color::CMYK), "
+                "(offset, Cairo::Color::HSV), "
                 "(offset, red, green, blue), "
                 "(offset, [red, green, blue]), "
                 "(offset, red, green, blue, alpha) or "
                 "(offset, [red, green, blue, alpha])"
                 ")",
-                StringValuePtr (inspected_arg));
+                RVAL2CSTR (inspected));
     }
 
   cr_pattern_check_status (_SELF (self));
   return self;
 }
 
-
 /* Cairo::Pattern */
 static VALUE
 cr_pattern_set_matrix (VALUE self, VALUE matrix)
@@ -320,6 +350,12 @@ cr_solid_pattern_get_rgba (VALUE self)
                       rb_float_new (blue), rb_float_new (alpha));
 }
 
+static VALUE
+cr_solid_pattern_get_color (VALUE self)
+{
+  return cr_color_parse (cr_solid_pattern_get_rgba (self));
+}
+
 static VALUE
 cr_surface_pattern_get_surface (VALUE self)
 {
@@ -344,6 +380,18 @@ cr_gradient_pattern_get_color_stop_rgba (VALUE self, VALUE index)
                       rb_float_new (blue), rb_float_new (alpha));
 }
 
+static VALUE
+cr_gradient_pattern_get_color_stop_color (VALUE self, VALUE index)
+{
+  VALUE result, offset, rgba;
+
+  result = cr_gradient_pattern_get_color_stop_rgba (self, index);
+  offset = rb_ary_shift (result);
+  rgba = result;
+
+  return rb_ary_new3 (2, offset, cr_color_parse (rgba));
+}
+
 static VALUE
 cr_gradient_pattern_get_color_stop_count (VALUE self)
 {
@@ -378,9 +426,15 @@ cr_radial_pattern_get_radial_circles (VALUE self)
                                              &x0, &y0, &r0,
                                              &x1, &y1, &r1);
   rb_cairo_check_status (status);
-  return rb_ary_new3 (6,
-                      rb_float_new (x0), rb_float_new (y0), rb_float_new (r0),
-                      rb_float_new (x1), rb_float_new (y1), rb_float_new (r1));
+  return rb_ary_new3 (2,
+                      rb_ary_new3 (3,
+                                   rb_float_new (x0),
+                                   rb_float_new (y0),
+                                   rb_float_new (r0)),
+                      rb_ary_new3 (3,
+                                   rb_float_new (x1),
+                                   rb_float_new (y1),
+                                   rb_float_new (r1)));
 }
 #endif
 
@@ -390,13 +444,17 @@ cr_radial_pattern_get_radial_circles (VALUE self)
 void
 Init_cairo_pattern (void)
 {
+  id_parse = rb_intern ("parse");
+  id_to_rgb = rb_intern ("to_rgb");
+  id_to_a = rb_intern ("to_a");
+  id_inspect = rb_intern ("inspect");
+
   rb_cCairo_Pattern =
     rb_define_class_under (rb_mCairo, "Pattern", rb_cObject);
 
   rb_define_alloc_func (rb_cCairo_Pattern, cr_pattern_allocate);
 
   rb_define_method (rb_cCairo_Pattern, "initialize", cr_pattern_initialize, 0);
-  rb_define_method (rb_cCairo_Pattern, "type", cr_pattern_get_type, 0);
 
   rb_define_method (rb_cCairo_Pattern, "set_matrix", cr_pattern_set_matrix, 1);
   rb_define_method (rb_cCairo_Pattern, "matrix", cr_pattern_get_matrix, 0);
@@ -416,6 +474,8 @@ Init_cairo_pattern (void)
 #if CAIRO_CHECK_VERSION(1, 3, 0)
   rb_define_method (rb_cCairo_SolidPattern, "rgba",
                     cr_solid_pattern_get_rgba, 0);
+  rb_define_method (rb_cCairo_SolidPattern, "color",
+                    cr_solid_pattern_get_color, 0);
 #endif
 
   RB_CAIRO_DEF_SETTERS (rb_cCairo_SolidPattern);
@@ -435,17 +495,17 @@ Init_cairo_pattern (void)
   rb_cCairo_GradientPattern =
     rb_define_class_under (rb_mCairo, "GradientPattern", rb_cCairo_Pattern);
 
-  rb_define_method (rb_cCairo_GradientPattern, "add_color_stop_rgb",
-                    cr_gradient_pattern_add_color_stop_rgb, -1);
-  rb_define_method (rb_cCairo_GradientPattern, "add_color_stop_rgba",
-                    cr_gradient_pattern_add_color_stop_rgba, -1);
+  rb_define_method (rb_cCairo_GradientPattern, "add_color_stop",
+                    cr_gradient_pattern_add_color_stop_generic, -1);
   rb_define_alias (rb_cCairo_GradientPattern,
-                   "add_color_stop", "add_color_stop_rgba");
+                   "add_color_stop_rgb", "add_color_stop");
+  rb_define_alias (rb_cCairo_GradientPattern,
+                   "add_color_stop_rgba", "add_color_stop");
 #if CAIRO_CHECK_VERSION(1, 3, 0)
   rb_define_method (rb_cCairo_GradientPattern, "get_color_stop_rgba",
                     cr_gradient_pattern_get_color_stop_rgba, 1);
-  rb_define_alias (rb_cCairo_GradientPattern,
-                   "get_color_stop", "get_color_stop_rgba");
+  rb_define_method (rb_cCairo_GradientPattern, "get_color_stop_color",
+                    cr_gradient_pattern_get_color_stop_color, 1);
   rb_define_method (rb_cCairo_GradientPattern, "color_stop_count",
                     cr_gradient_pattern_get_color_stop_count, 0);
 #endif

data/src/rb_cairo_private.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/03/06 12:17:34 $
+ * $Date: 2007/05/18 14:07:48 $
  *
  * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
  *
@@ -12,6 +12,9 @@
 */
 
 #include "rb_cairo.h"
+#include "rb_cairo_private.h"
+
+static ID id_normalize_const_name;
 
 VALUE
 rb_cairo__float_array (double *values, unsigned count)
@@ -28,24 +31,48 @@ rb_cairo__float_array (double *values, unsigned count)
 }
 
 void
-rb_cairo__glyphs_to_array (VALUE rb_array, cairo_glyph_t **glyphs, int *length)
+rb_cairo__glyphs_to_array (VALUE rb_array, cairo_glyph_t *glyphs, int length)
 {
   int i;
-  
-  if (!rb_obj_is_kind_of (rb_array, rb_cArray))
-     rb_raise (rb_eTypeError, "expected array");
-
-  *length = RARRAY(rb_array)->len;
-  *glyphs = ALLOCA_N (cairo_glyph_t, *length);
-
-  if (!*glyphs)
-    rb_cairo_check_status (CAIRO_STATUS_NO_MEMORY);
 
-  for (i = 0; i < *length; i++)
+  for (i = 0; i < length; i++)
     {
-      memcpy ((char *) &(*glyphs)[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, 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));
+}
+
+
+void
+Init_cairo_private (void)
+{
+  id_normalize_const_name = rb_intern ("normalize_const_name");
+}

data/src/rb_cairo_private.h

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/03/06 12:17:34 $
+ * $Date: 2007/05/18 14:07:48 $
  *
  * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
  *
@@ -17,7 +17,45 @@
 #define CR_TRUE 1
 #define CR_FALSE 0
 
+#define CSTR2RVAL(str) rb_str_new2(str)
+#define RVAL2CSTR(str) StringValueCStr(str)
+
+#define CBOOL2RVAL(bool) (bool ? Qtrue : Qfalse)
+#define RVAL2CBOOL(bool) RTEST(bool)
+
+extern void Init_cairo_private (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_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);
+
+#define RB_CAIRO__GLYPHS_TO_ARRAY(rb_array, glyphs, length)     \
+do                                                              \
+  {                                                             \
+    Check_Type (rb_array, T_ARRAY);                             \
+    length = RARRAY (rb_array)->len;                            \
+    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);
+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);
 
 #endif