cairo 1.8.5 → 1.10.0

data/ext/cairo/rb_cairo_surface.c

@@ -5,6 +5,7 @@
  * $Author: kou $
  * $Date: 2008-11-01 14:23:14 $
  *
+ * Copyright 2005-2010 Kouhei Sutou <kou@cozmixng.org>
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
  *
@@ -14,6 +15,7 @@
 
 #include "rb_cairo.h"
 #include "rb_cairo_private.h"
+#include "rb_cairo_io.h"
 
 #ifdef HAVE_RUBY_ST_H
 #  include <ruby/st.h>
@@ -44,14 +46,17 @@ enum ruby_value_type {
 #  define T_DATA RUBY_T_DATA
 #endif
 
-#if defined(CAIRO_HAS_PS_SURFACE) || \
-  defined(CAIRO_HAS_PDF_SURFACE) || \
-  defined(CAIRO_HAS_SVG_SURFACE)
-#  define HAS_CREATE_CR_CLOSURE_SURFACE 1
-#else
-#  define HAS_CREATE_CR_CLOSURE_SURFACE 0
+#ifdef CAIRO_HAS_XML_SURFACE
+#  include <cairo-xml.h>
+#endif
+
+#ifdef CAIRO_HAS_TEE_SURFACE
+#  include <cairo-tee.h>
 #endif
 
+#ifdef CAIRO_HAS_GL_SURFACE
+#  include <cairo-gl.h>
+#endif
 
 VALUE rb_cCairo_Surface;
 VALUE rb_cCairo_ImageSurface;
@@ -62,11 +67,18 @@ VALUE rb_cCairo_Win32Surface = Qnil;
 VALUE rb_cCairo_Win32PrintingSurface = Qnil;
 VALUE rb_cCairo_QuartzSurface = Qnil;
 VALUE rb_cCairo_QuartzImageSurface = Qnil;
+VALUE rb_cCairo_ScriptSurface = Qnil;
+VALUE rb_cCairo_QtSurface = Qnil;
+VALUE rb_cCairo_RecordingSurface = Qnil;
+VALUE rb_cCairo_VGSurface = Qnil;
+VALUE rb_cCairo_GLSurface = Qnil;
+VALUE rb_cCairo_GLTextureSurface = Qnil;
+VALUE rb_cCairo_DRMSurface = Qnil;
+VALUE rb_cCairo_TeeSurface = Qnil;
+VALUE rb_cCairo_XMLSurface = Qnil;
+VALUE rb_cCairo_SkiaSurface = Qnil;
+VALUE rb_cCairo_SubSurface = 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;
@@ -135,6 +147,38 @@ cr_surface_get_klass (cairo_surface_t *surface)
     case CAIRO_SURFACE_TYPE_QUARTZ_IMAGE:
       klass = rb_cCairo_QuartzImageSurface;
       break;
+#endif
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+    case CAIRO_SURFACE_TYPE_SCRIPT:
+      klass = rb_cCairo_ScriptSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_QT:
+      klass = rb_cCairo_QtSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_RECORDING:
+      klass = rb_cCairo_RecordingSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_VG:
+      klass = rb_cCairo_VGSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_GL:
+      klass = rb_cCairo_GLSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_DRM:
+      klass = rb_cCairo_DRMSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_TEE:
+      klass = rb_cCairo_TeeSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_XML:
+      klass = rb_cCairo_XMLSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_SKIA:
+      klass = rb_cCairo_SkiaSurface;
+      break;
+    case CAIRO_SURFACE_TYPE_SUBSURFACE:
+      klass = rb_cCairo_SubSurface;
+      break;
 #endif
     default:
       klass = rb_cCairo_Surface;
@@ -147,166 +191,6 @@ cr_surface_get_klass (cairo_surface_t *surface)
   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;
-  VALUE error;
-  unsigned char *data;
-  unsigned int length;
-} cr_io_callback_closure_t;
-
-typedef struct cr_invoke_data {
-  cr_callback_func_t func;
-  VALUE data;
-} cr_invoke_data_t;
-
-#if HAS_CREATE_CR_CLOSURE_SURFACE
-static cr_io_callback_closure_t *
-cr_closure_new (VALUE target)
-{
-  cr_io_callback_closure_t *closure;
-  closure = ALLOC (cr_io_callback_closure_t);
-
-  closure->target = target;
-  closure->error = Qnil;
-
-  return closure;
-}
-
-static void
-cr_closure_destroy (cr_io_callback_closure_t *closure)
-{
-  xfree (closure);
-}
-
-static void
-cr_closure_free (void *closure)
-{
-  cr_closure_destroy ((cr_io_callback_closure_t *) closure);
-}
-#endif
-
-static VALUE
-cr_surface_io_func_rescue (VALUE io_closure)
-{
-  cr_io_callback_closure_t *closure;
-  closure = (cr_io_callback_closure_t *)io_closure;
-  closure->error = RB_ERRINFO;
-  return Qnil;
-}
-
-static VALUE
-cr_surface_invoke_io_func (VALUE user_data)
-{
-  cr_invoke_data_t *data;
-
-  data = (cr_invoke_data_t *)user_data;
-  return rb_rescue2 (data->func, data->data,
-                     cr_surface_io_func_rescue, data->data, rb_eException,
-                     (VALUE)0);
-}
-
-/* write callback */
-static VALUE
-cr_surface_write_func_invoke (VALUE write_closure)
-{
-  VALUE output, data;
-  long written_bytes;
-  cr_io_callback_closure_t *closure;
-  unsigned int length;
-
-  closure = (cr_io_callback_closure_t *)write_closure;
-  
-  output = closure->target;
-  data = rb_str_new ((const char *)closure->data, closure->length);
-
-  length = RSTRING_LEN (data);
-  while (length != 0)
-    {
-      VALUE rb_written_bytes = rb_funcall (output, cr_id_write, 1, data);
-      written_bytes = NUM2LONG (rb_written_bytes);
-      data = rb_str_substr (data, written_bytes,
-                            RSTRING_LEN (data) - written_bytes);
-      length -= written_bytes;
-    }
-  
-  return Qnil;
-}
-
-static cairo_status_t
-cr_surface_write_func (void *write_closure,
-                       const unsigned char *data, unsigned int length)
-{
-  cr_io_callback_closure_t *closure;
-  cr_invoke_data_t invoke_data;
-
-  closure = (cr_io_callback_closure_t *)write_closure;
-  closure->data = (unsigned char *)data;
-  closure->length = length;
-
-  invoke_data.func = cr_surface_write_func_invoke;
-  invoke_data.data = (VALUE)closure;
-  rb_cairo__invoke_callback (cr_surface_invoke_io_func, (VALUE)&invoke_data);
-
-  if (NIL_P (closure->error))
-    return CAIRO_STATUS_SUCCESS;
-  else
-    return CAIRO_STATUS_WRITE_ERROR;
-}
-
-/* read callback */
-static VALUE
-cr_surface_read_func_invoke (VALUE read_closure)
-{
-  VALUE input, result;
-  cr_io_callback_closure_t *closure;
-  unsigned int length, rest;
-
-  closure = (cr_io_callback_closure_t *)read_closure;
-  input = closure->target;
-  length = closure->length;
-  
-  result = rb_str_new2 ("");
-
-  for (rest = length; rest != 0; rest = length - RSTRING_LEN (result))
-    {
-      rb_str_concat (result, rb_funcall (input, cr_id_read, 1, INT2NUM (rest)));
-    }
-
-  memcpy ((void *)closure->data, (const void *)StringValuePtr (result), length);
-
-  return Qnil;
-}
-
-static cairo_status_t
-cr_surface_read_func (void *read_closure,
-                      unsigned char *data, unsigned int length)
-{
-  cr_io_callback_closure_t *closure;
-  cr_invoke_data_t invoke_data;
-
-  closure = (cr_io_callback_closure_t *)read_closure;
-  closure->data = data;
-  closure->length = length;
-
-  invoke_data.func = cr_surface_read_func_invoke;
-  invoke_data.data = (VALUE)closure;
-  rb_cairo__invoke_callback (cr_surface_invoke_io_func, (VALUE)&invoke_data);
-
-  if (NIL_P (closure->error))
-    return CAIRO_STATUS_SUCCESS;
-  else
-    return CAIRO_STATUS_READ_ERROR;
-}
-
 /* constructor/de-constructor */
 cairo_surface_t *
 rb_cairo_surface_from_ruby_object (VALUE obj)
@@ -394,7 +278,7 @@ static VALUE
 cr_surface_finish (VALUE self)
 {
   cairo_surface_t *surface;
-  cr_io_callback_closure_t *closure;
+  rb_cairo__io_callback_closure_t *closure;
 
   surface = _SELF;
   closure = cairo_surface_get_user_data (surface, &cr_closure_key);
@@ -423,17 +307,72 @@ yield_and_finish (VALUE self)
 }
 
 static VALUE
-cr_surface_create_similar (VALUE self, VALUE content, VALUE width, VALUE height)
+cr_surface_create_similar (int argc, VALUE *argv, VALUE self)
+{
+  cairo_surface_t *surface, *similar_surface;
+  cairo_content_t content;
+  int width, height;
+  VALUE arg1, arg2, arg3;
+
+  rb_scan_args (argc, argv, "21", &arg1, &arg2, &arg3);
+
+  surface = _SELF;
+  if (argc == 2)
+    {
+      content = cairo_surface_get_content (surface);
+      width = NUM2INT (arg1);
+      height = NUM2INT (arg2);
+    }
+  else
+    {
+      content = RVAL2CRCONTENT (arg1);
+      width = NUM2INT (arg2);
+      height = NUM2INT (arg3);
+    }
+
+  similar_surface = cairo_surface_create_similar (surface, content,
+                                                  width, height);
+  cr_surface_check_status (similar_surface);
+  return CRSURFACE2RVAL_WITH_DESTROY (similar_surface);
+}
+
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+static VALUE
+cr_surface_destroy_with_destroy_check (VALUE self)
+{
+  if (DATA_PTR (self))
+    cr_surface_destroy (self);
+  return Qnil;
+}
+
+static VALUE
+cr_surface_create_sub_rectangle_surface (VALUE self, VALUE x, VALUE y,
+                                         VALUE width, VALUE height)
 {
+  VALUE rb_surface;
   cairo_surface_t *surface;
 
-  surface = cairo_surface_create_similar (RVAL2CRSURFACE (self),
-                                          RVAL2CRCONTENT (content),
-                                          NUM2INT (width), NUM2INT (height));
+  surface = cairo_surface_create_for_rectangle (RVAL2CRSURFACE (self),
+                                                NUM2DBL (x),
+                                                NUM2DBL (y),
+                                                NUM2DBL (width),
+                                                NUM2INT (height));
   cr_surface_check_status (surface);
-  return CRSURFACE2RVAL_WITH_DESTROY (surface);
+  rb_surface = CRSURFACE2RVAL_WITH_DESTROY (surface);
+  if (rb_block_given_p ())
+    return rb_ensure (rb_yield, rb_surface,
+                      cr_surface_destroy_with_destroy_check, rb_surface);
+  else
+    return rb_surface;
 }
 
+static VALUE
+cr_surface_get_device (VALUE self)
+{
+  return CRDEVICE2RVAL (cairo_surface_get_device (_SELF));
+}
+#endif
+
 static VALUE
 cr_surface_get_content (VALUE self)
 {
@@ -446,12 +385,13 @@ static VALUE
 cr_surface_write_to_png_stream (VALUE self, VALUE target)
 {
   cairo_status_t status;
-  cr_io_callback_closure_t closure;
+  rb_cairo__io_callback_closure_t closure;
 
   closure.target = target;
   closure.error = Qnil;
 
-  status = cairo_surface_write_to_png_stream (_SELF, cr_surface_write_func,
+  status = cairo_surface_write_to_png_stream (_SELF,
+                                              rb_cairo__io_write_func,
                                               (void *)&closure);
   if (!NIL_P (closure.error))
     rb_exc_raise (closure.error);
@@ -472,13 +412,63 @@ cr_surface_write_to_png (VALUE self, VALUE filename)
 static VALUE
 cr_surface_write_to_png_generic (VALUE self, VALUE target)
 {
-  if (rb_respond_to (target, cr_id_write))
+  if (rb_respond_to (target, rb_cairo__io_id_write))
     return cr_surface_write_to_png_stream (self, target);
   else
     return cr_surface_write_to_png (self, target);
 }
 #endif
 
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+static VALUE
+cr_surface_get_mime_data (VALUE self, VALUE mime_type)
+{
+  cairo_surface_t *surface;
+  const unsigned char *data;
+  unsigned long length;
+
+  surface = _SELF;
+  cairo_surface_get_mime_data (surface, StringValueCStr (mime_type),
+                               &data, &length);
+  if (data)
+    return rb_str_new ((const char *)data, length);
+  else
+    return Qnil;
+}
+
+static VALUE
+cr_surface_set_mime_data (VALUE self, VALUE rb_mime_type, VALUE rb_data)
+{
+  cairo_status_t status;
+  cairo_surface_t *surface;
+  const char *mime_type;
+
+  surface = _SELF;
+  mime_type = StringValueCStr (rb_mime_type);
+  if (NIL_P (rb_data))
+    {
+      status = cairo_surface_set_mime_data (surface, mime_type,
+                                            NULL, 0, NULL, NULL);
+    }
+  else
+    {
+      const char *raw_data;
+      unsigned char *data;
+      unsigned long length;
+
+      raw_data = StringValuePtr (rb_data);
+      length = RSTRING_LEN (rb_data);
+      data = xmalloc (length);
+      memcpy (data, raw_data, length);
+      status = cairo_surface_set_mime_data (surface, mime_type,
+                                            data, length,
+                                            xfree, data);
+    }
+  rb_cairo_check_status (status);
+  return Qnil;
+}
+#endif
+
 static VALUE
 cr_surface_get_font_options (VALUE self)
 {
@@ -528,7 +518,7 @@ cr_surface_mark_dirty (int argc, VALUE *argv, VALUE self)
 
       rb_raise (rb_eArgError,
                 "invalid argument (expect () or (x, y, width, height)): %s",
-                inspect (args));
+                rb_cairo__inspect (args));
     }
 
   cr_surface_check_status (_SELF);
@@ -607,17 +597,17 @@ cr_surface_show_page (VALUE self)
 static cairo_surface_t *
 cr_image_surface_create_from_png_stream (VALUE target)
 {
-  cr_io_callback_closure_t closure;
+  rb_cairo__io_callback_closure_t closure;
   cairo_surface_t *surface;
 
   closure.target = target;
   closure.error = Qnil;
 
-  surface = cairo_image_surface_create_from_png_stream (cr_surface_read_func,
+  surface = cairo_image_surface_create_from_png_stream (rb_cairo__io_read_func,
                                                         (void *)&closure);
   if (!NIL_P (closure.error))
     rb_exc_raise (closure.error);
-  
+
   return surface;
 }
 
@@ -633,7 +623,7 @@ cr_image_surface_create_from_png_generic (VALUE klass, VALUE target)
   VALUE rb_surface;
   cairo_surface_t *surface;
 
-  if (rb_respond_to (target, cr_id_read))
+  if (rb_respond_to (target, rb_cairo__io_id_read))
     surface = cr_image_surface_create_from_png_stream (target);
   else
     surface = cr_image_surface_create_from_png (target);
@@ -692,7 +682,7 @@ cr_image_surface_initialize (int argc, VALUE *argv, VALUE self)
               "(width, height) or "
               "(format, width, height) or "
               "(data, format, width, height, stride)): %s",
-              inspect (rb_ary_new3 (4, arg1, arg2, arg3, arg4)));
+              rb_cairo__inspect (rb_ary_new3 (4, arg1, arg2, arg3, arg4)));
 
   cr_surface_check_status (surface);
   DATA_PTR (self) = surface;
@@ -742,6 +732,74 @@ cr_image_surface_get_stride (VALUE self)
   return INT2NUM (cairo_image_surface_get_stride (_SELF));
 }
 
+#ifdef CAIRO_HAS_RECORDING_SURFACE
+/* Recording-surface functions */
+static VALUE
+cr_recording_surface_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE arg1, arg2, arg3, arg4, arg5;
+  cairo_surface_t *surface;
+  cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
+  cairo_rectangle_t extents;
+  const char *error_message =
+    "invalid argument (expect "
+    "(x, y, width, height), "
+    "([x, y, width, height]),"
+    "(x, y, width, height, content) or "
+    "([x, y, width, height], content)): %s";
+
+  rb_scan_args (argc, argv, "14", &arg1, &arg2, &arg3, &arg4, &arg5);
+  if (argc == 1 || argc == 2)
+    {
+      VALUE rb_extents;
+
+      rb_extents = rb_check_array_type (arg1);
+      if (RARRAY_LEN (rb_extents) != 4)
+        rb_raise (rb_eArgError, error_message, rb_cairo__inspect (arg1));
+      extents.x = NUM2DBL (RARRAY_PTR (rb_extents)[0]);
+      extents.y = NUM2DBL (RARRAY_PTR (rb_extents)[1]);
+      extents.width = NUM2DBL (RARRAY_PTR (rb_extents)[2]);
+      extents.height = NUM2DBL (RARRAY_PTR (rb_extents)[3]);
+      if (!NIL_P (arg2))
+        content = RVAL2CRCONTENT (arg2);
+    }
+  else if (argc == 4 || argc == 5)
+    {
+      extents.x = NUM2DBL (arg1);
+      extents.y = NUM2DBL (arg2);
+      extents.width = NUM2DBL (arg3);
+      extents.height = NUM2DBL (arg4);
+      if (!NIL_P (arg5))
+        content = RVAL2CRCONTENT (arg5);
+    }
+  else
+    {
+      rb_raise (rb_eArgError, error_message,
+                rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+    }
+
+  surface = cairo_recording_surface_create (content, &extents);
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+
+static VALUE
+cr_recording_surface_get_ink_extents (VALUE self)
+{
+  cairo_surface_t *surface;
+  double x, y, width, height;
+
+  surface = _SELF;
+  cairo_recording_surface_ink_extents (surface, &x, &y, &width, &height);
+  cr_surface_check_status (surface);
+  return rb_ary_new3 (4,
+                      rb_float_new (x), rb_float_new (y),
+                      rb_float_new (width), rb_float_new (height));
+}
+#endif
 
 /* Printing surfaces */
 #define DEFINE_SURFACE(type)                                            \
@@ -772,29 +830,30 @@ cr_ ## type ## _surface_initialize (int argc, VALUE *argv, VALUE self)  \
   width_in_points = NUM2DBL (rb_width_in_points);                       \
   height_in_points = NUM2DBL (rb_height_in_points);                     \
                                                                         \
-  if (rb_respond_to (target, cr_id_write))                              \
+  if (rb_respond_to (target, rb_cairo__io_id_write))                    \
     {                                                                   \
-      cr_io_callback_closure_t *closure;                                \
+      rb_cairo__io_callback_closure_t *closure;                         \
                                                                         \
-      closure = cr_closure_new (target);                                \
+      closure = rb_cairo__io_closure_new (target);                      \
       surface =                                                         \
         cairo_ ## type ## _surface_create_for_stream (                  \
-          cr_surface_write_func,                                        \
+          rb_cairo__io_write_func,                                      \
           (void *) closure,                                             \
           width_in_points,                                              \
           height_in_points);                                            \
                                                                         \
       if (cairo_surface_status (surface))                               \
         {                                                               \
-          cr_closure_destroy (closure);                                 \
+          rb_cairo__io_closure_destroy (closure);                       \
         }                                                               \
       else                                                              \
         {                                                               \
-          rb_ivar_set (self, cr_id_target, target);                     \
+          rb_ivar_set (self, rb_cairo__io_id_output, target);           \
           cairo_surface_set_user_data (surface, &cr_closure_key,        \
-                                       closure, cr_closure_free);       \
+                                       closure,                         \
+                                       rb_cairo__io_closure_free);      \
           cairo_surface_set_user_data (surface, &cr_object_holder_key,  \
-                                       cr_object_holder_new(self),      \
+                                       cr_object_holder_new (self),     \
                                        cr_object_holder_free);          \
         }                                                               \
     }                                                                   \
@@ -907,6 +966,16 @@ cr_ps_surface_set_eps (VALUE self, VALUE eps)
 /* PDF-surface functions */
 DEFINE_SURFACE(pdf)
 DEFINE_SURFACE_SET_SIZE(pdf)
+
+#  if CAIRO_CHECK_VERSION(1, 10, 0)
+static VALUE
+cr_pdf_surface_restrict_to_version (VALUE self, VALUE version)
+{
+  cairo_pdf_surface_restrict_to_version (_SELF, RVAL2CRPDFVERSION (version));
+  cr_surface_check_status (_SELF);
+  return Qnil;
+}
+#  endif
 #endif
 
 #ifdef CAIRO_HAS_SVG_SURFACE
@@ -1111,7 +1180,7 @@ cr_quartz_surface_initialize (int argc, VALUE *argv, VALUE self)
                       "(width, height), "
                       "(format, width, height) or "
                       "(cg_context, width, height)): %s",
-                      inspect (rb_ary_new3 (3, arg1, arg2, arg3)));
+                      rb_cairo__inspect (rb_ary_new3 (3, arg1, arg2, arg3)));
           break;
         }
 
@@ -1179,6 +1248,321 @@ cr_quartz_image_surface_get_image (VALUE self)
 #  endif
 #endif
 
+#ifdef CAIRO_HAS_SCRIPT_SURFACE
+static VALUE
+cr_script_surface_initialize (int argc, VALUE *argv, VALUE self)
+{
+  cairo_surface_t *surface = NULL, *target = NULL;
+  cairo_device_t *device;
+  double width = 0.0, height = 0.0;
+  cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
+  VALUE arg1, arg2, arg3, arg4;
+
+  rb_scan_args (argc, argv, "22", &arg1, &arg2, &arg3, &arg4);
+
+  device = RVAL2CRDEVICE (arg1);
+  if (argc == 2)
+    {
+      target = RVAL2CRSURFACE (arg2);
+    }
+  else
+    {
+      width = NUM2DBL (arg2);
+      height = NUM2DBL (arg3);
+      switch (TYPE (arg4))
+        {
+        case T_NIL:
+          break;
+        case T_STRING:
+        case T_SYMBOL:
+        case T_FIXNUM:
+          content = RVAL2CRCONTENT (arg4);
+          break;
+        default:
+          rb_raise (rb_eArgError,
+                    "invalid argument (expect "
+                    "(device, width, height), "
+                    "(device, width, height, content) or "
+                    "(device, surface)): %s",
+                    rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+          break;
+        }
+    }
+
+  if (target)
+    surface = cairo_script_surface_create_for_target (device, target);
+  else
+    surface = cairo_script_surface_create (device, content, width, height);
+
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+#endif
+
+#ifdef CAIRO_HAS_XML_SURFACE
+static VALUE
+cr_xml_surface_initialize (int argc, VALUE *argv, VALUE self)
+{
+  cairo_surface_t *surface;
+  cairo_device_t *device;
+  double width, height;
+  cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
+  VALUE rb_device, rb_width, rb_height, rb_content;
+
+  rb_scan_args (argc, argv, "31",
+                &rb_device, &rb_width, &rb_height, &rb_content);
+
+  device = RVAL2CRDEVICE (rb_device);
+  width = NUM2DBL (rb_width);
+  height = NUM2DBL (rb_height);
+  switch (TYPE (rb_content))
+    {
+    case T_NIL:
+      break;
+    case T_STRING:
+    case T_SYMBOL:
+    case T_FIXNUM:
+      content = RVAL2CRCONTENT (rb_content);
+      break;
+    default:
+      rb_raise (rb_eArgError,
+                "invalid argument (expect "
+                "(device, width, height) or "
+                "(device, width, height, content)): %s",
+                rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+      break;
+    }
+
+  surface = cairo_xml_surface_create (device, content, width, height);
+
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+#endif
+
+#ifdef CAIRO_HAS_TEE_SURFACE
+static VALUE
+cr_tee_surface_initialize (VALUE self, VALUE master)
+{
+  cairo_surface_t *surface = NULL;
+
+  surface = cairo_tee_surface_create (RVAL2CRSURFACE (master));
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  rb_iv_set (self, "surfaces", rb_ary_new3 (1, master));
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+
+static VALUE
+cr_tee_surface_add (VALUE self, VALUE target)
+{
+  cairo_surface_t *surface = NULL;
+
+  surface = _SELF;
+  cairo_tee_surface_add (surface, RVAL2CRSURFACE (target));
+  cr_surface_check_status (surface);
+  rb_ary_push (rb_iv_get (self, "surfaces"), target);
+  return Qnil;
+}
+
+static VALUE
+cr_tee_surface_shift_operator (VALUE self, VALUE target)
+{
+  cr_tee_surface_add (self, target);
+  return self;
+}
+
+static VALUE
+cr_tee_surface_remove (VALUE self, VALUE target_or_index)
+{
+  cairo_surface_t *surface = NULL, *target;
+  VALUE rb_surfaces;
+  int i;
+
+  surface = _SELF;
+  if (rb_cairo__is_kind_of (target_or_index, rb_cCairo_Surface))
+    {
+      target = RVAL2CRSURFACE (target_or_index);
+    }
+  else
+    {
+      VALUE index;
+
+      index = rb_check_to_integer (target_or_index, "to_int");
+      if (NIL_P (index))
+        rb_raise (rb_eArgError,
+                  "invalid argument (expect (surface) or (index)): %s",
+                  rb_cairo__inspect (target_or_index));
+      target = cairo_tee_surface_index (surface, NUM2INT (index));
+    }
+  cairo_tee_surface_remove (surface, target);
+  cr_surface_check_status (surface);
+
+  rb_surfaces = rb_iv_get (self, "surfaces");
+  for (i = 0; i < RARRAY_LEN (rb_surfaces); i++)
+    {
+      VALUE rb_marked_surface;
+      cairo_surface_t *marked_surface;
+
+      rb_marked_surface = RARRAY_PTR (rb_surfaces)[i];
+      marked_surface = RVAL2CRSURFACE (rb_marked_surface);
+      if (marked_surface == target)
+        {
+          rb_ary_delete (rb_surfaces, rb_marked_surface);
+          break;
+        }
+    }
+
+  return Qnil;
+}
+
+static VALUE
+cr_tee_surface_array_reference (VALUE self, VALUE index)
+{
+  cairo_surface_t *surface = NULL, *target;
+
+  surface = _SELF;
+  index = rb_Integer (index);
+  target = cairo_tee_surface_index (surface, NUM2INT (index));
+  cr_surface_check_status (surface);
+  cr_surface_check_status (target);
+  return CRSURFACE2RVAL (target);
+}
+#endif
+
+#ifdef CAIRO_HAS_GL_SURFACE
+static VALUE
+cr_gl_surface_initialize (int argc, VALUE *argv, VALUE self)
+{
+  cairo_surface_t *surface;
+  cairo_device_t *device;
+  int width, height;
+  cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
+  VALUE rb_device, rb_width, rb_height, rb_content;
+
+  rb_scan_args (argc, argv, "31",
+                &rb_device, &rb_width, &rb_height, &rb_content);
+
+  device = RVAL2CRDEVICE (rb_device);
+  width = NUM2INT (rb_width);
+  height = NUM2INT (rb_height);
+  switch (TYPE (rb_content))
+    {
+    case T_NIL:
+      break;
+    case T_STRING:
+    case T_SYMBOL:
+    case T_FIXNUM:
+      content = RVAL2CRCONTENT (rb_content);
+      break;
+    default:
+      rb_raise (rb_eArgError,
+                "invalid argument (expect "
+                "(device, width, height) or "
+                "(device, width, height, content)): %s",
+                rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+      break;
+    }
+
+  surface = cairo_gl_surface_create (device, content, width, height);
+
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+
+static VALUE
+cr_gl_texture_surface_initialize (int argc, VALUE *argv, VALUE self)
+{
+  cairo_surface_t *surface;
+  cairo_device_t *device;
+  unsigned int texture;
+  int width, height;
+  cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
+  VALUE rb_device, rb_texture, rb_width, rb_height, rb_content;
+
+  rb_scan_args (argc, argv, "41",
+                &rb_device, &rb_texture, &rb_width, &rb_height, &rb_content);
+
+  device = RVAL2CRDEVICE (rb_device);
+  texture = NUM2UINT (rb_texture);
+  width = NUM2INT (rb_width);
+  height = NUM2INT (rb_height);
+  switch (TYPE (rb_content))
+    {
+    case T_NIL:
+      break;
+    case T_STRING:
+    case T_SYMBOL:
+    case T_FIXNUM:
+      content = RVAL2CRCONTENT (rb_content);
+      break;
+    default:
+      rb_raise (rb_eArgError,
+                "invalid argument (expect "
+                "(device, texture, width, height) or "
+                "(device, texture, width, height, content)): %s",
+                rb_cairo__inspect (rb_ary_new4 (argc, argv)));
+      break;
+    }
+
+  surface = cairo_gl_surface_create_for_texture (device, content,
+                                                 texture,
+                                                 width,
+                                                 height);
+
+  cr_surface_check_status (surface);
+  DATA_PTR (self) = surface;
+  if (rb_block_given_p ())
+    yield_and_finish (self);
+  return Qnil;
+}
+
+static VALUE
+cr_gl_surface_set_size (VALUE self, VALUE width, VALUE height)
+{
+  cairo_surface_t *surface = NULL;
+
+  surface = _SELF;
+  cairo_gl_surface_set_size (surface, NUM2INT (width), NUM2INT (height));
+  cr_surface_check_status (surface);
+  return Qnil;
+}
+
+static VALUE
+cr_gl_surface_get_width (VALUE self)
+{
+  return INT2NUM (cairo_gl_surface_get_width (_SELF));
+}
+
+static VALUE
+cr_gl_surface_get_height (VALUE self)
+{
+  return INT2NUM (cairo_gl_surface_get_height (_SELF));
+}
+
+static VALUE
+cr_gl_surface_swap_buffers (VALUE self)
+{
+  cairo_surface_t *surface = NULL;
+
+  surface = _SELF;
+  cairo_gl_surface_swapbuffers (surface);
+  cr_surface_check_status (surface);
+  return Qnil;
+}
+#endif
+
 static int
 cr_finish_all_guarded_surfaces_at_end_iter (VALUE key, VALUE value, VALUE data)
 {
@@ -1197,10 +1581,6 @@ cr_finish_all_guarded_surfaces_at_end (VALUE data)
 void
 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=");
@@ -1214,11 +1594,24 @@ Init_cairo_surface (void)
 
 
   rb_define_method (rb_cCairo_Surface, "create_similar",
-                    cr_surface_create_similar, 3);
+                    cr_surface_create_similar, -1);
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_define_method (rb_cCairo_Surface, "sub_rectangle_surface",
+                    cr_surface_create_sub_rectangle_surface, 4);
+  rb_define_method (rb_cCairo_Surface, "device",
+                    cr_surface_get_device, 0);
+#endif
   rb_define_method (rb_cCairo_Surface, "destroy", cr_surface_destroy, 0);
   rb_define_method (rb_cCairo_Surface, "finish", cr_surface_finish, 0);
   rb_define_method (rb_cCairo_Surface, "content", cr_surface_get_content, 0);
 
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_define_method (rb_cCairo_Surface, "get_mime_data",
+                    cr_surface_get_mime_data, 1);
+  rb_define_method (rb_cCairo_Surface, "set_mime_data",
+                    cr_surface_set_mime_data, 2);
+#endif
+
   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);
@@ -1270,6 +1663,18 @@ Init_cairo_surface (void)
   rb_define_method (rb_cCairo_ImageSurface, "stride",
                     cr_image_surface_get_stride, 0);
 
+#ifdef CAIRO_HAS_RECORDING_SURFACE
+  /* Recording-surface */
+  rb_cCairo_RecordingSurface =
+    rb_define_class_under (rb_mCairo, "RecordingSurface", rb_cCairo_Surface);
+
+  rb_define_method (rb_cCairo_RecordingSurface, "initialize",
+                    cr_recording_surface_initialize, -1);
+
+  rb_define_method (rb_cCairo_RecordingSurface, "ink_extents",
+                    cr_recording_surface_get_ink_extents, 0);
+#endif
+
 #define INIT_SURFACE(type, name)                                        \
   rb_cCairo_ ## name ## Surface =                                       \
     rb_define_class_under (rb_mCairo, # name "Surface",                 \
@@ -1307,6 +1712,11 @@ Init_cairo_surface (void)
   rb_define_method (rb_cCairo_PDFSurface, "set_size",
                     cr_pdf_surface_set_size, -1);
 
+#  if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_define_method (rb_cCairo_PDFSurface, "restrict_to_version",
+                    cr_pdf_surface_restrict_to_version, 1);
+#  endif
+
   RB_CAIRO_DEF_SETTERS (rb_cCairo_PDFSurface);
 #endif
 
@@ -1366,6 +1776,71 @@ Init_cairo_surface (void)
   rb_define_method (rb_cCairo_QuartzImageSurface, "image",
                     cr_quartz_image_surface_get_image, 0);
 #  endif
+#endif
+
+#ifdef CAIRO_HAS_SCRIPT_SURFACE
+  rb_cCairo_ScriptSurface =
+    rb_define_class_under (rb_mCairo, "ScriptSurface", rb_cCairo_Surface);
+
+  rb_define_method (rb_cCairo_ScriptSurface, "initialize",
+                    cr_script_surface_initialize, -1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_ScriptSurface);
+#endif
+
+#ifdef CAIRO_HAS_XML_SURFACE
+  rb_cCairo_XMLSurface =
+    rb_define_class_under (rb_mCairo, "XMLSurface", rb_cCairo_Surface);
+
+  rb_define_method (rb_cCairo_XMLSurface, "initialize",
+                    cr_xml_surface_initialize, -1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_XMLSurface);
+#endif
+
+#ifdef CAIRO_HAS_TEE_SURFACE
+  rb_cCairo_TeeSurface =
+    rb_define_class_under (rb_mCairo, "TeeSurface", rb_cCairo_Surface);
+
+  rb_define_method (rb_cCairo_TeeSurface, "initialize",
+                    cr_tee_surface_initialize, 1);
+
+  rb_define_method (rb_cCairo_TeeSurface, "add",
+                    cr_tee_surface_add, 1);
+  rb_define_method (rb_cCairo_TeeSurface, "<<",
+                    cr_tee_surface_shift_operator, 1);
+  rb_define_method (rb_cCairo_TeeSurface, "remove",
+                    cr_tee_surface_remove, 1);
+  rb_define_method (rb_cCairo_TeeSurface, "[]",
+                    cr_tee_surface_array_reference, 1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_TeeSurface);
+#endif
+
+#ifdef CAIRO_HAS_GL_SURFACE
+  rb_cCairo_GLSurface =
+    rb_define_class_under (rb_mCairo, "GLSurface", rb_cCairo_Surface);
+
+  rb_define_method (rb_cCairo_GLSurface, "initialize",
+                    cr_gl_surface_initialize, 1);
+
+  rb_define_method (rb_cCairo_GLSurface, "set_size",
+                    cr_gl_surface_set_size, 2);
+  rb_define_method (rb_cCairo_GLSurface, "width",
+                    cr_gl_surface_get_width, 0);
+  rb_define_method (rb_cCairo_GLSurface, "height",
+                    cr_gl_surface_get_height, 0);
+  rb_define_method (rb_cCairo_GLSurface, "swap_buffers",
+                    cr_gl_surface_swap_buffers, 0);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_GLSurface);
+
+  rb_cCairo_GLTextureSurface =
+    rb_define_class_under (rb_mCairo, "GLTextureSurface", rb_cCairo_GLSurface);
+
+  rb_define_method (rb_cCairo_GLTextureSurface, "initialize",
+                    cr_gl_texture_surface_initialize, 1);
 
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_GLTextureSurface);
 #endif
 }