cairo 1.5.1 → 1.6.0

data/src/rb_cairo_constants.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/20 09:18:49 $
+ * $Date: 2008-04-04 04:25:16 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -31,7 +31,8 @@ VALUE rb_mCairo_Content;
 VALUE rb_mCairo_Format;
 VALUE rb_mCairo_Extend;
 VALUE rb_mCairo_Filter;
-VALUE rb_mCairo_SVGVersion;
+VALUE rb_mCairo_SVGVersion = Qnil;
+VALUE rb_mCairo_PSLevel = Qnil;
 
 #define CAIRO_OPERATOR_MIN CAIRO_OPERATOR_CLEAR
 #define CAIRO_OPERATOR_MAX CAIRO_OPERATOR_SATURATE
@@ -81,6 +82,9 @@ VALUE rb_mCairo_SVGVersion;
 #define CAIRO_SVG_VERSION_MIN CAIRO_SVG_VERSION_1_1
 #define CAIRO_SVG_VERSION_MAX CAIRO_SVG_VERSION_1_2
 
+#define CAIRO_PS_LEVEL_MIN CAIRO_PS_LEVEL_2
+#define CAIRO_PS_LEVEL_MAX CAIRO_PS_LEVEL_3
+
 #define DEFINE_RVAL2ENUM(name, const_name)                      \
 cairo_ ## name ## _t                                            \
 rb_cairo_ ## name ## _from_ruby_object (VALUE rb_ ## name)      \
@@ -123,6 +127,102 @@ DEFINE_RVAL2ENUM(filter, FILTER)
 #if CAIRO_HAS_SVG_SURFACE
 DEFINE_RVAL2ENUM(svg_version, SVG_VERSION)
 #endif
+#if CAIRO_HAS_PS_SURFACE && CAIRO_CHECK_VERSION(1, 5, 2)
+DEFINE_RVAL2ENUM(ps_level, PS_LEVEL)
+#else
+#  ifdef RB_CAIRO_PLATFORM_WIN32
+void
+rb_cairo_ps_level_from_ruby_object (VALUE rb_ps_level)
+{
+  /* dummy */
+}
+#  endif
+#endif
+
+
+#if CAIRO_HAS_SVG_SURFACE
+static VALUE
+cr_svg_get_versions (VALUE self)
+{
+  VALUE rb_versions;
+  int i, num_versions;
+  cairo_svg_version_t const *versions;
+
+  cairo_svg_get_versions (&versions, &num_versions);
+
+  rb_versions = rb_ary_new2 (num_versions);
+
+  for (i = 0; i < num_versions; i++)
+    {
+      rb_ary_push (rb_versions, INT2NUM (versions[i]));
+    }
+
+  return rb_versions;
+}
+
+static VALUE
+cr_svg_version_to_string (int argc, VALUE *argv, VALUE self)
+{
+  if (argc == 0)
+    {
+      return rb_call_super (argc, argv);
+    }
+  else
+    {
+      VALUE version;
+      const char *ver_str;
+      rb_scan_args (argc, argv, "1", &version);
+      ver_str = cairo_svg_version_to_string (RVAL2CRSVGVERSION(version));
+      return rb_str_new2 (ver_str);
+    }
+}
+#endif
+
+#if CAIRO_CHECK_VERSION(1, 5, 8)
+static VALUE
+cr_format_stride_for_width (VALUE self, VALUE format, VALUE width)
+{
+  return INT2NUM (cairo_format_stride_for_width (RVAL2CRFORMAT (format),
+                                                 NUM2INT (width)));
+}
+#endif
+
+#if CAIRO_HAS_PS_SURFACE
+#  if CAIRO_CHECK_VERSION(1, 5, 8)
+static VALUE
+cr_ps_get_levels (VALUE self)
+{
+  VALUE rb_levels;
+  const cairo_ps_level_t *levels;
+  int i, n_levels;
+
+  cairo_ps_get_levels (&levels, &n_levels);
+
+  rb_levels = rb_ary_new2 (n_levels);
+  for (i = 0; i < n_levels; i++)
+    {
+      rb_ary_push (rb_levels, INT2NUM (levels[i]));
+    }
+
+  return rb_levels;
+}
+
+static VALUE
+cr_ps_level_to_string (int argc, VALUE *argv, VALUE self)
+{
+  if (argc == 0)
+    {
+      return rb_call_super (argc, argv);
+    }
+  else
+    {
+      VALUE level;
+      rb_scan_args (argc, argv, "1", &level);
+      return rb_str_new2 (cairo_ps_level_to_string (RVAL2CRPSLEVEL (level)));
+    }
+}
+#  endif
+#endif
 
 void
 Init_cairo_constants (void)
@@ -295,6 +395,11 @@ Init_cairo_constants (void)
                    INT2FIX (CAIRO_FORMAT_RGB16_565));
 #endif
 
+#if CAIRO_CHECK_VERSION(1, 5, 8)
+  rb_define_singleton_method (rb_mCairo_Format, "stride_for_width",
+                              cr_format_stride_for_width, 2);
+#endif
+
 
   /* cairo_extend_t */
   rb_mCairo_Extend = rb_define_module_under (rb_mCairo, "Extend");
@@ -330,5 +435,22 @@ Init_cairo_constants (void)
                    INT2FIX (CAIRO_SVG_VERSION_1_1));
   rb_define_const (rb_mCairo_SVGVersion, "VERSION_1_2",
                    INT2FIX (CAIRO_SVG_VERSION_1_2));
+
+  rb_define_singleton_method (rb_mCairo_SVGVersion, "list",
+                              cr_svg_get_versions, 0);
+  rb_define_singleton_method (rb_mCairo_SVGVersion, "name",
+                              cr_svg_version_to_string, -1);
+#endif
+
+#if CAIRO_HAS_PS_SURFACE && CAIRO_CHECK_VERSION(1, 5, 2)
+  /* cairo_ps_level_t */
+  rb_mCairo_PSLevel = rb_define_module_under (rb_mCairo, "PSLevel");
+  rb_define_const (rb_mCairo_PSLevel, "LEVEL_2", INT2FIX (CAIRO_PS_LEVEL_2));
+  rb_define_const (rb_mCairo_PSLevel, "LEVEL_3", INT2FIX (CAIRO_PS_LEVEL_3));
+
+  rb_define_singleton_method (rb_mCairo_PSLevel, "list",
+                              cr_ps_get_levels, 0);
+  rb_define_singleton_method (rb_mCairo_PSLevel, "name",
+                              cr_ps_level_to_string, -1);
 #endif
 }

data/src/rb_cairo_context.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007-12-29 11:42:26 $
+ * $Date: 2008-03-25 13:43:50 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -22,12 +22,12 @@ static ID cr_id_plus, cr_id_minus, cr_id_multi, cr_id_div;
 
 #define _SELF  (RVAL2CRCONTEXT(self))
 
+static VALUE cr_get_current_point (VALUE self);
+
 #if CAIRO_CHECK_VERSION(1, 3, 0)
 static VALUE rb_cCairo_Rectangle;
 static ID at_x, at_y, at_width, at_height;
 
-static VALUE cr_get_current_point (VALUE self);
-
 static VALUE
 cr_rectangle_initialize (VALUE self, VALUE x, VALUE y,
                          VALUE width, VALUE height)
@@ -97,7 +97,7 @@ cr_initialize (VALUE self, VALUE target)
   cr = cairo_create (RVAL2CRSURFACE (target));
   cr_check_status (cr);
   rb_ivar_set (self, cr_id_surface, target);
-  DATA_PTR(self) = cr;
+  DATA_PTR (self) = cr;
   return Qnil;
 }
 
@@ -738,6 +738,19 @@ cr_close_path (VALUE self)
   return self;
 }
 
+#if CAIRO_CHECK_VERSION(1, 5, 8)
+static VALUE
+cr_path_extents (VALUE self)
+{
+  double x1, y1, x2, y2;
+  cairo_path_extents (_SELF, &x1, &y1, &x2, &y2);
+  cr_check_status (_SELF);
+  return rb_ary_new3 (4,
+                      rb_float_new(x1), rb_float_new(y1),
+                      rb_float_new(x2), rb_float_new(y2));
+}
+#endif
+
 /* Painting functions */
 static VALUE
 cr_paint (VALUE self)
@@ -1216,9 +1229,17 @@ cr_get_tolerance (VALUE self)
 static VALUE
 cr_get_antialias(VALUE self)
 {
-  return INT2NUM (cairo_get_antialias(_SELF));
+  return INT2NUM (cairo_get_antialias (_SELF));
 }
 
+#if CAIRO_CHECK_VERSION(1, 5, 10)
+static VALUE
+cr_has_current_point(VALUE self)
+{
+  return RTEST (cairo_has_current_point (_SELF));
+}
+#endif
+
 static VALUE
 cr_get_current_point (VALUE self)
 {
@@ -1438,6 +1459,9 @@ Init_cairo_context (void)
                     cr_rel_curve_to_generic, -1);
   rb_define_method (rb_cCairo_Context, "rectangle", cr_rectangle, 4);
   rb_define_method (rb_cCairo_Context, "close_path", cr_close_path, 0);
+#if CAIRO_CHECK_VERSION(1, 5, 8)
+  rb_define_method (rb_cCairo_Context, "path_extents", cr_path_extents, 0);
+#endif
 
   /* Painting functions */
   rb_define_method (rb_cCairo_Context, "paint", cr_paint_generic, -1);
@@ -1494,6 +1518,12 @@ Init_cairo_context (void)
   rb_define_method (rb_cCairo_Context, "source", cr_get_source, 0);
   rb_define_method (rb_cCairo_Context, "tolerance", cr_get_tolerance, 0);
   rb_define_method (rb_cCairo_Context, "antialias", cr_get_antialias, 0);
+#if CAIRO_CHECK_VERSION(1, 5, 10)
+  rb_define_method (rb_cCairo_Context, "have_current_point?",
+                    cr_has_current_point, 0);
+  rb_define_alias (rb_cCairo_Context,
+                   "has_current_point?", "have_current_point?");
+#endif
   rb_define_method (rb_cCairo_Context, "current_point",
                     cr_get_current_point, 0);
   rb_define_method (rb_cCairo_Context, "fill_rule", cr_get_fill_rule, 0);

data/src/rb_cairo_exception.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/03/06 12:17:34 $
+ * $Date: 2008-02-21 13:18:10 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -37,6 +37,10 @@ static VALUE rb_eCairo_InvalidDscCommentError;
 static VALUE rb_eCairo_InvalidIndexError;
 static VALUE rb_eCairo_ClipNotRepresentableError;
 #endif
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+static VALUE rb_eCairo_TempFileError;
+static VALUE rb_eCairo_InvalidStrideError;
+#endif
 
 void
 rb_cairo_check_status (cairo_status_t status)
@@ -114,6 +118,14 @@ rb_cairo_check_status (cairo_status_t status)
     case CAIRO_STATUS_CLIP_NOT_REPRESENTABLE:
       rb_raise (rb_eCairo_ClipNotRepresentableError, string);
       break;
+#endif
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+    case CAIRO_STATUS_TEMP_FILE_ERROR:
+      rb_raise (rb_eCairo_TempFileError, string);
+      break;
+    case CAIRO_STATUS_INVALID_STRIDE:
+      rb_raise (rb_eCairo_InvalidStringError, string);
+      break;
 #endif
     }
 }
@@ -189,4 +201,14 @@ Init_cairo_exception ()
     rb_define_class_under (rb_mCairo, "ClipNotRepresentableError",
                            rb_eCairo_Error);
 #endif
+
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+  rb_eCairo_TempFileError =
+    rb_define_class_under (rb_mCairo, "TempFileError",
+                           rb_eCairo_Error);
+
+  rb_eCairo_InvalidStrideError =
+        rb_define_class_under (rb_mCairo, "InvalidStrideError",
+                               rb_eArgError);
+#endif
 }

data/src/rb_cairo_font_options.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/26 15:13:25 $
+ * $Date: 2007-05-26 15:13:25 $
  *
  * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
  *

data/src/rb_cairo_path.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/22 11:41:45 $
+ * $Date: 2008-04-04 03:52:31 $
  *
  * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
  *
@@ -132,19 +132,6 @@ cr_path_data_to_ruby_object (cairo_path_data_t *data)
     }
 
   return rb_data;
-
-  int i;
-  VALUE points;
-
-  points = rb_ary_new ();
-  for (i = 1; i < data->header.length; i++)
-    {
-      rb_ary_push (points, cr_point_new (rb_float_new (data[i].point.x),
-                                         rb_float_new (data[i].point.y)));
-    }
-
-  return rb_funcall (rb_cCairo_PathData, id_new, 2,
-                     INT2FIX (data->header.type), points);
 }
 
 

data/src/rb_cairo_surface.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2008-01-11 12:19:44 $
+ * $Date: 2008-04-11 11:07:10 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -30,15 +30,38 @@ VALUE rb_cCairo_PDFSurface = Qnil;
 VALUE rb_cCairo_PSSurface = Qnil;
 VALUE rb_cCairo_SVGSurface = Qnil;
 VALUE rb_cCairo_Win32Surface = Qnil;
+VALUE rb_cCairo_Win32PrintingSurface = Qnil;
 VALUE rb_cCairo_QuartzSurface = Qnil;
+VALUE rb_cCairo_QuartzImageSurface = Qnil;
 
 static ID cr_id_target;
 static ID cr_id_read;
 static ID cr_id_write;
+static ID cr_id_inspect;
+static ID cr_id_parse;
+static ID cr_id_size;
+static ID cr_id_set_unit;
 static cairo_user_data_key_t cr_closure_key;
 
 #define _SELF  (RVAL2CRSURFACE(self))
 
+static VALUE
+cr_paper_parse (VALUE paper_description)
+{
+  return rb_funcall (rb_cCairo_Paper, cr_id_parse, 2, paper_description, Qtrue);
+}
+
+static void
+cr_paper_to_size_in_points (VALUE paper_description, VALUE *width, VALUE *height)
+{
+  VALUE paper, size;
+
+  paper = cr_paper_parse (paper_description);
+  size = rb_funcall (paper, cr_id_size, 1, rb_str_new2 ("pt"));
+  *width = RARRAY_PTR (size)[0];
+  *height = RARRAY_PTR (size)[1];
+}
+
 static inline void
 cr_surface_check_status (cairo_surface_t *surface)
 {
@@ -63,20 +86,44 @@ cr_surface_get_klass (cairo_surface_t *surface)
     case CAIRO_SURFACE_TYPE_PS:
       klass = rb_cCairo_PSSurface;
       break;
-    case CAIRO_SURFACE_TYPE_SVG:
-      klass = rb_cCairo_SVGSurface;
+    case CAIRO_SURFACE_TYPE_QUARTZ:
+      klass = rb_cCairo_QuartzSurface;
       break;
     case CAIRO_SURFACE_TYPE_WIN32:
       klass = rb_cCairo_Win32Surface;
       break;
+    case CAIRO_SURFACE_TYPE_SVG:
+      klass = rb_cCairo_SVGSurface;
+      break;
+#if CAIRO_CHECK_VERSION(1, 5, 2)
+    case CAIRO_SURFACE_TYPE_WIN32_PRINTING:
+      klass = rb_cCairo_Win32PrintingSurface;
+      break;
+#endif
+#if CAIRO_CHECK_VERSION(1, 5, 12)
+    case CAIRO_SURFACE_TYPE_QUARTZ_IMAGE:
+      klass = rb_cCairo_QuartzImageSurface;
+      break;
+#endif
     default:
       rb_raise (rb_eArgError, "unknown source type: %d", type);
       break;
     }
 
+  if (NIL_P (klass))
+    rb_raise (rb_eArgError, "unknown source type: %d", type);
+
   return klass;
 }
 
+static char *
+inspect (VALUE object)
+{
+  VALUE inspected;
+  inspected = rb_funcall (object, cr_id_inspect, 0);
+  return StringValueCStr(inspected);
+}
+
 /* read/write callback */
 typedef struct cr_io_callback_closure {
   VALUE target;
@@ -248,6 +295,16 @@ rb_cairo_surface_to_ruby_object (cairo_surface_t *surface)
     }
 }
 
+VALUE
+rb_cairo_surface_to_ruby_object_with_destroy (cairo_surface_t *surface)
+{
+  VALUE rb_surface;
+  rb_surface = rb_cairo_surface_to_ruby_object (surface);
+  if (surface)
+    cairo_surface_destroy (surface);
+  return rb_surface;
+}
+
 static VALUE
 cr_surface_allocate (VALUE klass)
 {
@@ -275,8 +332,7 @@ yield_and_finish (VALUE self)
 }
 
 static VALUE
-cr_surface_create_similar (VALUE self, VALUE content,
-                           VALUE width, VALUE height)
+cr_surface_create_similar (VALUE self, VALUE content, VALUE width, VALUE height)
 {
   cairo_surface_t *surface;
 
@@ -284,7 +340,7 @@ cr_surface_create_similar (VALUE self, VALUE content,
                                           RVAL2CRCONTENT (content),
                                           NUM2INT (width), NUM2INT (height));
   cr_surface_check_status (surface);
-  return CRSURFACE2RVAL (surface);
+  return CRSURFACE2RVAL_WITH_DESTROY (surface);
 }
 
 static VALUE
@@ -385,8 +441,18 @@ cr_surface_mark_dirty (int argc, VALUE *argv, VALUE self)
     }
   else
     {
+      int i;
+      VALUE args;
+
+      args = rb_ary_new2 (n);
+      for (i = 0; i < n; i++)
+        {
+          rb_ary_push (args, argv[i]);
+        }
+
       rb_raise (rb_eArgError,
-                "invalid argument (expect () or (x, y, width, height))");
+                "invalid argument (expect () or (x, y, width, height)): %s",
+                inspect (args));
     }
 
   cr_surface_check_status (_SELF);
@@ -425,6 +491,23 @@ cr_surface_set_fallback_resolution (VALUE self,
   return self;
 }
 
+#if CAIRO_CHECK_VERSION(1, 5, 2)
+static VALUE
+cr_surface_copy_page (VALUE self)
+{
+  cairo_surface_copy_page (_SELF);
+  cr_surface_check_status (_SELF);
+  return self;
+}
+
+static VALUE
+cr_surface_show_page (VALUE self)
+{
+  cairo_surface_show_page (_SELF);
+  cr_surface_check_status (_SELF);
+  return self;
+}
+#endif
 
 /* Image-surface functions */
 #if CAIRO_HAS_PNG_FUNCTIONS
@@ -469,7 +552,6 @@ cr_image_surface_create_from_png_generic (VALUE klass, VALUE target)
 }
 #endif
 
-
 static cairo_surface_t *
 cr_image_surface_create (VALUE self, VALUE format, VALUE width, VALUE height)
 {
@@ -516,7 +598,8 @@ cr_image_surface_initialize (int argc, VALUE *argv, VALUE self)
               "invalid argument (expect "
               "(width, height) or "
               "(format, width, height) or "
-              "(data, format, width, height, stride))");
+              "(data, format, width, height, stride)): %s",
+              inspect (rb_ary_new3 (4, arg1, arg2, arg3, arg4)));
 
   cr_surface_check_status (surface);
   DATA_PTR (self) = surface;
@@ -570,13 +653,29 @@ cr_image_surface_get_stride (VALUE self)
 /* Printing surfaces */
 #define DEFINE_SURFACE(type)                                            \
 static VALUE                                                            \
-cr_ ## type ## _surface_initialize (VALUE self, VALUE target,           \
-                                    VALUE rb_width_in_points,           \
-                                    VALUE rb_height_in_points)          \
+cr_ ## type ## _surface_initialize (int argc, VALUE *argv, VALUE self)  \
 {                                                                       \
+  VALUE target, rb_width_in_points, rb_height_in_points;                \
+  VALUE arg2, arg3;                                                     \
   cairo_surface_t *surface;                                             \
   double width_in_points, height_in_points;                             \
                                                                         \
+  rb_scan_args (argc, argv, "21", &target, &arg2, &arg3);               \
+  if (argc == 2)                                                        \
+    {                                                                   \
+      VALUE paper;                                                      \
+                                                                        \
+      paper = arg2;                                                     \
+      cr_paper_to_size_in_points (paper,                                \
+                                  &rb_width_in_points,                  \
+                                  &rb_height_in_points);                \
+    }                                                                   \
+  else                                                                  \
+    {                                                                   \
+      rb_width_in_points = arg2;                                        \
+      rb_height_in_points = arg3;                                       \
+    }                                                                   \
+                                                                        \
   width_in_points = NUM2DBL (rb_width_in_points);                       \
   height_in_points = NUM2DBL (rb_height_in_points);                     \
                                                                         \
@@ -618,22 +717,40 @@ cr_ ## type ## _surface_initialize (VALUE self, VALUE target,           \
   return Qnil;                                                          \
 }
 
+#define DEFINE_SURFACE_SET_SIZE(type)                                   \
+static VALUE                                                            \
+cr_ ## type ## _surface_set_size (int argc, VALUE *argv, VALUE self)    \
+{                                                                       \
+  VALUE arg1, arg2;                                                     \
+  VALUE width_in_points, height_in_points;                              \
+                                                                        \
+  rb_scan_args(argc, argv, "11", &arg1, &arg2);                         \
+  if (argc == 1)                                                        \
+    {                                                                   \
+      VALUE paper;                                                      \
+                                                                        \
+      paper = arg1;                                                     \
+      cr_paper_to_size_in_points (paper,                                \
+                                  &width_in_points,                     \
+                                  &height_in_points);                   \
+    }                                                                   \
+  else                                                                  \
+    {                                                                   \
+      width_in_points = arg1;                                           \
+      height_in_points = arg2;                                          \
+    }                                                                   \
+                                                                        \
+  cairo_ ## type ## _surface_set_size (_SELF,                           \
+                                       NUM2DBL (width_in_points),       \
+                                       NUM2DBL (height_in_points));     \
+  cr_surface_check_status (_SELF);                                      \
+  return Qnil;                                                          \
+}
 
 #if CAIRO_HAS_PS_SURFACE
 /* PS-surface functions */
 DEFINE_SURFACE(ps)
-
-static VALUE
-cr_ps_surface_set_size (VALUE self,
-                        VALUE width_in_points,
-                        VALUE height_in_points)
-{
-  cairo_ps_surface_set_size (_SELF,
-                             NUM2DBL (width_in_points),
-                             NUM2DBL (height_in_points));
-  cr_surface_check_status (_SELF);
-  return Qnil;
-}
+DEFINE_SURFACE_SET_SIZE(ps)
 
 static VALUE
 cr_ps_surface_dsc_comment (VALUE self, VALUE comment)
@@ -664,23 +781,36 @@ cr_ps_surface_dsc_begin_page_setup (VALUE self)
   else
     return Qnil;
 }
-#endif
 
-#if CAIRO_HAS_PDF_SURFACE
-/* PDF-surface functions */
-DEFINE_SURFACE(pdf)
+#  if CAIRO_CHECK_VERSION(1, 5, 2)
+static VALUE
+cr_ps_surface_restrict_to_level (VALUE self, VALUE level)
+{
+  cairo_ps_surface_restrict_to_level (_SELF, RVAL2CRPSLEVEL (level));
+  cr_surface_check_status (_SELF);
+  return Qnil;
+}
+
+static VALUE
+cr_ps_surface_get_eps (VALUE self)
+{
+  return cairo_ps_surface_get_eps (_SELF) ? Qtrue : Qfalse;
+}
 
 static VALUE
-cr_pdf_surface_set_size (VALUE self,
-                         VALUE width_in_points,
-                         VALUE height_in_points)
+cr_ps_surface_set_eps (VALUE self, VALUE eps)
 {
-  cairo_pdf_surface_set_size (_SELF,
-                              NUM2DBL (width_in_points),
-                              NUM2DBL (height_in_points));
+  cairo_ps_surface_set_eps (_SELF, RTEST (eps));
   cr_surface_check_status (_SELF);
   return Qnil;
 }
+#  endif
+#endif
+
+#if CAIRO_HAS_PDF_SURFACE
+/* PDF-surface functions */
+DEFINE_SURFACE(pdf)
+DEFINE_SURFACE_SET_SIZE(pdf)
 #endif
 
 #if CAIRO_HAS_SVG_SURFACE
@@ -694,33 +824,6 @@ cr_svg_surface_restrict_to_version (VALUE self, VALUE version)
   cr_surface_check_status (_SELF);
   return Qnil;
 }
-
-static VALUE
-cr_svg_get_versions (VALUE self)
-{
-  VALUE rb_versions;
-  int i, num_versions;
-  cairo_svg_version_t const *versions;
-
-  cairo_svg_get_versions (&versions, &num_versions);
-
-  rb_versions = rb_ary_new2 (num_versions);
-
-  for (i = 0; i < num_versions; i++)
-    {
-      rb_ary_push (rb_versions, INT2NUM (versions[i]));
-    }
-
-  return rb_versions;
-}
-
-static VALUE
-cr_svg_version_to_string (VALUE self, VALUE version)
-{
-  const char *ver_str;
-  ver_str = cairo_svg_version_to_string (RVAL2CRSVGVERSION(version));
-  return rb_str_new2 (ver_str);
-}
 #endif
 
 #if CAIRO_HAS_WIN32_SURFACE
@@ -762,14 +865,21 @@ cr_win32_surface_initialize (int argc, VALUE *argv, VALUE self)
           (rb_cairo__is_kind_of (arg1, rb_cNumeric) &&
            NUM2INT (arg1) != CAIRO_FORMAT_RGB24))
         {
+#  if CAIRO_CHECK_VERSION(1, 4, 0)
+          HDC win32_hdc;
           hdc = arg1;
           width = arg2;
           height = arg3;
-          HDC win32_hdc = NIL_P (hdc) ? NULL : NUM2PTR (hdc);
+          win32_hdc = NIL_P (hdc) ? NULL : NUM2PTR (hdc);
           surface = cairo_win32_surface_create_with_ddb (win32_hdc,
                                                          CAIRO_FORMAT_RGB24,
                                                          NUM2INT (width),
                                                          NUM2INT (height));
+#  else
+          rb_raise (rb_eArgError,
+                    "Cairo::Win32Surface.new(hdc, width, height) "
+                    "is available since cairo >= 1.4.0");
+#  endif
         }
       else
         {
@@ -783,6 +893,7 @@ cr_win32_surface_initialize (int argc, VALUE *argv, VALUE self)
       break;
     case 4:
       {
+#  if CAIRO_CHECK_VERSION(1, 4, 0)
         HDC win32_hdc;
         hdc = arg1;
         format = arg2;
@@ -793,6 +904,11 @@ cr_win32_surface_initialize (int argc, VALUE *argv, VALUE self)
                                                        RVAL2CRFORMAT (format),
                                                        NUM2INT (width),
                                                        NUM2INT (height));
+#  else
+        rb_raise (rb_eArgError,
+                  "Cairo::Win32Surface.new(hdc, format, width, height) "
+                  "is available since cairo >= 1.4.0");
+#  endif
       }
       break;
     }
@@ -806,6 +922,21 @@ cr_win32_surface_initialize (int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+#  if CAIRO_CHECK_VERSION(1, 5, 2)
+static VALUE
+cr_win32_printing_surface_initialize (VALUE self, VALUE hdc)
+{
+  cairo_surface_t *surface = NULL;
+
+  surface = cairo_win32_printing_surface_create (NUM2PTR (hdc));
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+#  endif
+
 static VALUE
 cr_win32_surface_get_hdc (VALUE self)
 {
@@ -818,6 +949,7 @@ cr_win32_surface_get_hdc (VALUE self)
     return PTR2NUM (hdc);
 }
 
+#  if CAIRO_CHECK_VERSION(1, 4, 0)
 static VALUE
 cr_win32_surface_get_image (VALUE self)
 {
@@ -826,19 +958,19 @@ cr_win32_surface_get_image (VALUE self)
   surface = cairo_win32_surface_get_image (_SELF);
   if (!surface)
     return Qnil;
-  rb_cairo_check_status (cairo_surface_status (surface));
+  cr_surface_check_status (surface);
   return CRSURFACE2RVAL (surface);
 }
+#  endif
 #endif
 
-#if CAIRO_HAS_QUARTZ_SURFACE
+#if CAIRO_HAS_QUARTZ_SURFACE && defined(HAVE_RUBY_COCOA)
 /* Quartz-surface functions */
 
 #include <objc/objc-runtime.h>
 
-VALUE ocobj_s_new (id ocid);
-id rbobj_get_ocid (VALUE obj);
-
+BOOL rbobj_to_nsobj (VALUE obj, id* nsobj);
+VALUE ocid_to_rbobj (VALUE context_obj, id ocid);
 
 static VALUE
 cr_quartz_surface_initialize (int argc, VALUE *argv, VALUE self)
@@ -849,6 +981,7 @@ cr_quartz_surface_initialize (int argc, VALUE *argv, VALUE self)
   cairo_surface_t *surface = NULL;
   cairo_format_t format = CAIRO_FORMAT_ARGB32;
   VALUE arg1, arg2, arg3, rb_width, rb_height;
+  static VALUE rb_cOSXCGContextRef = Qnil;
 
   rb_scan_args (argc, argv, "21", &arg1, &arg2, &arg3);
 
@@ -859,9 +992,32 @@ cr_quartz_surface_initialize (int argc, VALUE *argv, VALUE self)
     }
   else
     {
-      objc_object = rbobj_get_ocid (arg1);
-      if (objc_object == nil)
-        format = RVAL2CRFORMAT (arg1);
+      switch (TYPE (arg1))
+        {
+        case T_NIL:
+          break;
+        case T_STRING:
+        case T_SYMBOL:
+        case T_FIXNUM:
+          format = RVAL2CRFORMAT (arg1);
+          break;
+        default:
+          if (NIL_P (rb_cOSXCGContextRef))
+            rb_cOSXCGContextRef =
+              rb_const_get (rb_const_get (rb_cObject, rb_intern ("OSX")),
+                            rb_intern ("CGContextRef"));
+
+          if (RTEST (rb_obj_is_kind_of (arg1, rb_cOSXCGContextRef)))
+            rbobj_to_nsobj (arg1, &objc_object);
+          else
+            rb_raise (rb_eArgError,
+                      "invalid argument (expect "
+                      "(width, height), "
+                      "(format, width, height) or "
+                      "(cg_context, width, height)): %s",
+                      inspect (rb_ary_new3 (3, arg1, arg2, arg3)));
+          break;
+        }
 
       rb_width = arg2;
       rb_height = arg3;
@@ -896,8 +1052,35 @@ cr_quartz_surface_get_cg_context (VALUE self)
 
   context = cairo_quartz_surface_get_cg_context (_SELF);
   objc_object = (id)context;
-  return ocobj_s_new (objc_object);
+  return ocid_to_rbobj (Qnil, objc_object);
+}
+
+#  if CAIRO_CHECK_VERSION(1, 5, 12)
+static VALUE
+cr_quartz_image_surface_initialize (VALUE self, VALUE image_surface)
+{
+  cairo_surface_t *surface;
+
+  surface = cairo_quartz_image_surface_create (RVAL2CRSURFACE (image_surface));
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+
+static VALUE
+cr_quartz_image_surface_get_image (VALUE self)
+{
+  cairo_surface_t *surface;
+
+  surface = cairo_quartz_image_surface_get_image (_SELF);
+  if (!surface)
+    return Qnil;
+  cr_surface_check_status (surface);
+  return CRSURFACE2RVAL (surface);
 }
+#  endif
 #endif
 
 
@@ -907,7 +1090,11 @@ Init_cairo_surface (void)
   cr_id_target = rb_intern ("target");
   cr_id_read = rb_intern ("read");
   cr_id_write = rb_intern ("write");
-  
+  cr_id_inspect = rb_intern ("inspect");
+  cr_id_parse = rb_intern ("parse");
+  cr_id_size = rb_intern ("size");
+  cr_id_set_unit = rb_intern ("unit=");
+
   rb_cCairo_Surface =
     rb_define_class_under (rb_mCairo, "Surface", rb_cObject);
   rb_define_alloc_func (rb_cCairo_Surface, cr_surface_allocate);
@@ -920,13 +1107,19 @@ Init_cairo_surface (void)
   rb_define_method (rb_cCairo_Surface, "font_options",
                     cr_surface_get_font_options, 0);
   rb_define_method (rb_cCairo_Surface, "flush", cr_surface_flush, 0);
-  rb_define_method (rb_cCairo_Surface, "mark_dirty", cr_surface_mark_dirty, 0);
+  rb_define_method (rb_cCairo_Surface, "mark_dirty", cr_surface_mark_dirty, -1);
   rb_define_method (rb_cCairo_Surface, "set_device_offset",
                     cr_surface_set_device_offset, 2);
   rb_define_method (rb_cCairo_Surface, "device_offset",
                     cr_surface_get_device_offset, 0);
   rb_define_method (rb_cCairo_Surface, "set_fallback_resolution",
                     cr_surface_set_fallback_resolution, 2);
+#if CAIRO_CHECK_VERSION(1, 5, 2)
+  rb_define_method (rb_cCairo_Surface, "copy_page",
+                    cr_surface_copy_page, 2);
+  rb_define_method (rb_cCairo_Surface, "show_page",
+                    cr_surface_show_page, 2);
+#endif
 
 #if CAIRO_HAS_PNG_FUNCTIONS
   rb_define_method (rb_cCairo_Surface, "write_to_png",
@@ -964,13 +1157,13 @@ Init_cairo_surface (void)
                            rb_cCairo_Surface);                          \
                                                                         \
   rb_define_method (rb_cCairo_ ## name ## Surface, "initialize",        \
-                    cr_ ## type ## _surface_initialize, 3);
+                    cr_ ## type ## _surface_initialize, -1);
 
 #if CAIRO_HAS_PS_SURFACE
   /* PS-surface */
   INIT_SURFACE(ps, PS)
 
-  rb_define_method (rb_cCairo_PSSurface, "set_size", cr_ps_surface_set_size, 2);
+  rb_define_method (rb_cCairo_PSSurface, "set_size", cr_ps_surface_set_size, -1);
   rb_define_method (rb_cCairo_PSSurface, "dsc_comment",
                     cr_ps_surface_dsc_comment, 1);
   rb_define_method (rb_cCairo_PSSurface, "dsc_begin_setup",
@@ -978,6 +1171,13 @@ Init_cairo_surface (void)
   rb_define_method (rb_cCairo_PSSurface, "dsc_begin_page_setup",
                     cr_ps_surface_dsc_begin_page_setup, 0);
 
+#if CAIRO_CHECK_VERSION(1, 5, 2)
+  rb_define_method (rb_cCairo_PSSurface, "restrict_to_level",
+                    cr_ps_surface_restrict_to_level, 1);
+  rb_define_method (rb_cCairo_PSSurface, "eps?", cr_ps_surface_get_eps, 0);
+  rb_define_method (rb_cCairo_PSSurface, "set_eps", cr_ps_surface_set_eps, 1);
+#endif
+
   RB_CAIRO_DEF_SETTERS (rb_cCairo_PSSurface);
 #endif
 
@@ -986,7 +1186,7 @@ Init_cairo_surface (void)
   INIT_SURFACE(pdf, PDF)
 
   rb_define_method (rb_cCairo_PDFSurface, "set_size",
-                    cr_pdf_surface_set_size, 2);
+                    cr_pdf_surface_set_size, -1);
 
   RB_CAIRO_DEF_SETTERS (rb_cCairo_PDFSurface);
 #endif
@@ -995,11 +1195,6 @@ Init_cairo_surface (void)
   /* SVG-surface */
   INIT_SURFACE(svg, SVG)
 
-  rb_define_singleton_method (rb_cCairo_SVGSurface, "versions",
-                              cr_svg_get_versions, 0);
-  rb_define_singleton_method (rb_cCairo_SVGSurface, "version_to_string",
-                              cr_svg_version_to_string, 1);
-
   rb_define_method (rb_cCairo_SVGSurface, "restrict_to_version",
                     cr_svg_surface_restrict_to_version, 1);
 
@@ -1015,11 +1210,24 @@ Init_cairo_surface (void)
                     cr_win32_surface_initialize, -1);
   rb_define_method (rb_cCairo_Win32Surface, "hdc",
                     cr_win32_surface_get_hdc, 0);
+#  if CAIRO_CHECK_VERSION(1, 4, 0)
   rb_define_method (rb_cCairo_Win32Surface, "image",
                     cr_win32_surface_get_image, 0);
+#  endif
+
+#  if CAIRO_CHECK_VERSION(1, 5, 2)
+  rb_cCairo_Win32PrintingSurface =
+    rb_define_class_under (rb_mCairo, "Win32PrintingSurface", rb_cCairo_Surface);
+
+  rb_define_method (rb_cCairo_Win32PrintingSurface, "initialize",
+                    cr_win32_printing_surface_initialize, -1);
+  rb_define_method (rb_cCairo_Win32PrintingSurface, "hdc",
+                    cr_win32_surface_get_hdc, 0);
+#  endif
+
 #endif
 
-#if CAIRO_HAS_QUARTZ_SURFACE
+#if CAIRO_HAS_QUARTZ_SURFACE && defined(HAVE_RUBY_COCOA)
   /* Quartz-surface */
 
   rb_cCairo_QuartzSurface =
@@ -1029,5 +1237,16 @@ Init_cairo_surface (void)
                     cr_quartz_surface_initialize, -1);
   rb_define_method (rb_cCairo_QuartzSurface, "cg_context",
                     cr_quartz_surface_get_cg_context, 0);
+
+#  if CAIRO_CHECK_VERSION(1, 5, 12)
+  rb_cCairo_QuartzImageSurface =
+    rb_define_class_under (rb_mCairo, "QuartzImageSurface", rb_cCairo_Surface);
+
+  rb_define_method (rb_cCairo_QuartzImageSurface, "initialize",
+                    cr_quartz_image_surface_initialize, 1);
+  rb_define_method (rb_cCairo_Win32PrintingSurface, "hdc",
+                    cr_quartz_image_surfaceE_get_image, 0);
+#  endif
+
 #endif
 }