cairo 1.12.1-x86-mingw32 → 1.12.2-x86-mingw32

data/Gemfile

@@ -2,4 +2,4 @@
 
 source "http://rubygems.org/"
 
-gemfile
+gemspec

data/NEWS

@@ -1,3 +1,26 @@
+Release 1.12.2 (2012-06-03) Kouhei Sutou <kou@cozmixng.org>)
+============================================================
+
+Improvements
+------------
+
+  * Added Cairo::Device.supported?.
+    [GitHub#11] [Reported by Cédric Boutillier]
+  * Added Cairo::Device.gl_texture_supported?.
+  * Added Cairo::Surface.supported?.
+  * Defined all surfaces even if a surface isn't available. Use
+    Cairo::Surface.XXX_supported? method to check surface
+    availability.
+  * Added Cairo::Pattern.xxx_supported?.
+    [GitHub#12] [Reported by Mamoru Tasaka]
+  * [experimental] Supported auto native package install.
+
+Thanks
+------
+
+  * Cédric Boutillier
+  * Mamoru Tasaka
+
 Release 1.12.1 (2012-03-31) Kouhei Sutou <kou@cozmixng.org>)
 ============================================================
 

data/ext/cairo/extconf.rb

@@ -68,7 +68,127 @@ checking_for(checking_message("Mac OS X")) do
   end
 end
 
-PKGConfig.have_package(package, major, minor, micro) or exit 1
+def package_platform
+  if File.exist?("/etc/debian_version")
+    :debian
+  elsif File.exist?("/etc/fedora-release")
+    :fedora
+  elsif File.exist?("/etc/redhat-release")
+    :redhat
+  elsif find_executable("brew")
+    :homebrew
+  elsif find_executable("port")
+    :macports
+  else
+    :unknown
+  end
+end
+
+def super_user?
+  Process.uid.zero?
+end
+
+def normalize_native_package_info(native_package_info)
+  native_package_info ||= {}
+  native_package_info = native_package_info.dup
+  native_package_info[:fedora] ||= native_package_info[:redhat]
+  native_package_info
+end
+
+def install_missing_native_package(native_package_info)
+  platform = package_platform
+  native_package_info = normalize_native_package_info(native_package_info)
+  package = native_package_info[platform]
+  return false if package.nil?
+
+  need_super_user_priviledge = true
+  case platform
+  when :debian
+    install_command = "apt-get install -V -y #{package}"
+  when :fedora, :redhat
+    install_command = "yum install -y #{package}"
+  when :homebrew
+    need_super_user_priviledge = false
+    install_command = "brew install #{package}"
+  when :macports
+    install_command = "port install -y #{package}"
+  else
+    return false
+  end
+
+  have_priviledge = (not need_super_user_priviledge or super_user?)
+  unless have_priviledge
+    sudo = find_executable("sudo")
+  end
+
+  installing_message = "installing '#{package}' native package... "
+  message("%s", installing_message)
+  failed_to_get_super_user_priviledge = false
+  if have_priviledge
+    succeeded = xsystem(install_command)
+  else
+    if sudo
+      install_command = "#{sudo} #{install_command}"
+      succeeded = xsystem(install_command)
+    else
+      succeeded = false
+      failed_to_get_super_user_priviledge = true
+    end
+  end
+
+  if failed_to_get_super_user_priviledge
+    result_message = "require super user privilege"
+  else
+    result_message = succeeded ? "succeeded" : "failed"
+  end
+  Logging.postpone do
+    "#{installing_message}#{result_message}\n"
+  end
+  message("#{result_message}\n")
+
+  error_message = nil
+  unless succeeded
+    if failed_to_get_super_user_priviledge
+      error_message = <<-EOM
+'#{package}' native package is required.
+run the following command as super user to install required native package:
+  \# #{install_command}
+EOM
+    else
+      error_message = <<-EOM
+failed to run '#{install_command}'.
+EOM
+    end
+  end
+  if error_message
+    message("%s", error_message)
+    Logging.message("%s", error_message)
+  end
+
+  Logging.message("--------------------\n\n")
+
+  succeeded
+end
+
+def required_pkg_config_package(package_info, native_package_info=nil)
+  if package_info.is_a?(Array)
+    required_package_info = package_info
+  else
+    required_package_info = [package_info]
+  end
+  return true if PKGConfig.have_package(*required_package_info)
+
+  native_package_info ||= {}
+  return false unless install_missing_native_package(native_package_info)
+
+  PKGConfig.have_package(*required_package_info)
+end
+
+unless required_pkg_config_package([package, major, minor, micro],
+                                   :debian => "libcairo2-dev",
+                                   :redhat => "cairo-devel")
+  exit(false)
+end
 
 $defs << "-DRB_CAIRO_COMPILATION"
 

data/ext/cairo/rb_cairo.h

@@ -73,7 +73,7 @@ RB_CAIRO_BEGIN_DECLS
 
 #define RB_CAIRO_VERSION_MAJOR 1
 #define RB_CAIRO_VERSION_MINOR 12
-#define RB_CAIRO_VERSION_MICRO 1
+#define RB_CAIRO_VERSION_MICRO 2
 
 RB_CAIRO_VAR VALUE rb_mCairo;
 RB_CAIRO_VAR VALUE rb_cCairo_Context;

data/ext/cairo/rb_cairo_device.c

@@ -96,6 +96,26 @@ cr_device_get_klass (cairo_device_t *device)
   return klass;
 }
 
+static VALUE
+cr_device_script_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_SCRIPT_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_device_xml_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_XML_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
 /* constructor/de-constructor */
 cairo_device_t *
 rb_cairo_device_from_ruby_object (VALUE obj)
@@ -168,6 +188,16 @@ cr_device_allocate (VALUE klass)
   return Data_Wrap_Struct (klass, NULL, cr_device_free, NULL);
 }
 
+static VALUE
+cr_device_initialize (int argc, VALUE *argv, VALUE self)
+{
+  rb_raise(rb_eNotImpError,
+           "%s class creation isn't supported on this cairo installation",
+           rb_obj_classname(self));
+
+  return Qnil;
+}
+
 /* Backend device manipulation */
 static VALUE
 cr_device_destroy (VALUE self)
@@ -377,7 +407,12 @@ Init_cairo_device (void)
   rb_cairo__initialize_gc_guard_holder_class (rb_cCairo_Device);
   rb_set_end_proc(cr_finish_all_guarded_devices_at_end, Qnil);
 
+  rb_define_singleton_method (rb_cCairo_Device, "script_supported?",
+                              cr_device_script_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Device, "xml_supported?",
+                              cr_device_xml_supported_p, 0);
 
+  rb_define_method (rb_cCairo_Device, "initialize", cr_device_initialize, -1);
   rb_define_method (rb_cCairo_Device, "destroy", cr_device_destroy, 0);
   rb_define_method (rb_cCairo_Device, "finish", cr_device_finish, 0);
   rb_define_method (rb_cCairo_Device, "flush", cr_device_flush, 0);

data/ext/cairo/rb_cairo_pattern.c

@@ -29,6 +29,11 @@ static ID id_parse, id_to_rgb, id_to_a, id_inspect, id_new, id_call;
 
 #define _SELF(self)  (RVAL2CRPATTERN(self))
 
+#if CAIRO_CHECK_VERSION(1, 11, 4)
+#  define RB_CAIRO_HAS_MESH_PATTERN
+#  define RB_CAIRO_HAS_RASTER_SOURCE_PATTERN
+#endif
+
 static VALUE
 cr_color_parse (VALUE color)
 {
@@ -78,6 +83,55 @@ cr_pattern_get_klass (cairo_pattern_t *pattern)
   return klass;
 }
 
+static VALUE
+cr_pattern_solid_supported_p (VALUE klass)
+{
+  return Qtrue;
+}
+
+static VALUE
+cr_pattern_surface_supported_p (VALUE klass)
+{
+  return Qtrue;
+}
+
+static VALUE
+cr_pattern_gradient_supported_p (VALUE klass)
+{
+  return Qtrue;
+}
+
+static VALUE
+cr_pattern_linear_supported_p (VALUE klass)
+{
+  return Qtrue;
+}
+
+static VALUE
+cr_pattern_radial_supported_p (VALUE klass)
+{
+  return Qtrue;
+}
+
+static VALUE
+cr_pattern_mesh_supported_p (VALUE klass)
+{
+#ifdef RB_CAIRO_HAS_MESH_PATTERN
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_pattern_raster_source_supported_p (VALUE klass)
+{
+#ifdef RB_CAIRO_HAS_RASTER_SOURCE_PATTERN
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
 
 cairo_pattern_t *
 rb_cairo_pattern_from_ruby_object (VALUE obj)
@@ -123,9 +177,12 @@ cr_pattern_allocate (VALUE klass)
 }
 
 static VALUE
-cr_pattern_initialize (VALUE self)
+cr_pattern_initialize (int argc, VALUE *argv, VALUE self)
 {
-  rb_raise (rb_eTypeError, "abstract class");
+  rb_raise(rb_eNotImpError,
+           "%s class instantiation isn't supported on this cairo installation",
+           rb_obj_classname(self));
+
   return Qnil;
 }
 
@@ -452,7 +509,7 @@ cr_radial_pattern_get_radial_circles (VALUE self)
 /* Cairo::SurfacePattern */
 /* none */
 
-#if CAIRO_CHECK_VERSION(1, 11, 4)
+#ifdef RB_CAIRO_HAS_MESH_PATTERN
 /* Cairo::MeshPattern */
 static VALUE
 cr_mesh_pattern_initialize (VALUE self)
@@ -683,8 +740,10 @@ cr_mesh_pattern_get_control_point (VALUE self,
   rb_cairo_check_status (status);
   return rb_ary_new3 (2, rb_float_new (x), rb_float_new (y));
 }
+#endif
 
-/* Cairo::RasterPattern */
+#ifdef RB_CAIRO_HAS_RASTER_SOURCE_PATTERN
+/* Cairo::RasterSourcePattern */
 static cairo_surface_t *
 cr_raster_source_acquire_callback (cairo_pattern_t *pattern,
                                    void *callback_data,
@@ -978,7 +1037,22 @@ Init_cairo_pattern (void)
 
   rb_define_alloc_func (rb_cCairo_Pattern, cr_pattern_allocate);
 
-  rb_define_method (rb_cCairo_Pattern, "initialize", cr_pattern_initialize, 0);
+  rb_define_singleton_method (rb_cCairo_Pattern, "solid_supported?",
+                              cr_pattern_solid_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Pattern, "surface_supported?",
+                              cr_pattern_surface_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Pattern, "gradient_supported?",
+                              cr_pattern_gradient_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Pattern, "linear_supported?",
+                              cr_pattern_linear_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Pattern, "radial_supported?",
+                              cr_pattern_radial_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Pattern, "mesh_supported?",
+                              cr_pattern_mesh_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Pattern, "raster_source_supported?",
+                              cr_pattern_raster_source_supported_p, 0);
+
+  rb_define_method (rb_cCairo_Pattern, "initialize", cr_pattern_initialize, -1);
 
   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);
@@ -1065,7 +1139,7 @@ Init_cairo_pattern (void)
   rb_cCairo_MeshPattern =
     rb_define_class_under (rb_mCairo, "MeshPattern",
                            rb_cCairo_Pattern);
-#if CAIRO_CHECK_VERSION(1, 11, 4)
+#ifdef RB_CAIRO_HAS_MESH_PATTERN
   rb_define_method (rb_cCairo_MeshPattern, "initialize",
                     cr_mesh_pattern_initialize, 0);
   rb_define_method (rb_cCairo_MeshPattern, "begin_patch",
@@ -1100,7 +1174,7 @@ Init_cairo_pattern (void)
   rb_cCairo_RasterSourcePattern =
     rb_define_class_under (rb_mCairo, "RasterSourcePattern",
                            rb_cCairo_Pattern);
-#if CAIRO_CHECK_VERSION(1, 11, 4)
+#ifdef RB_CAIRO_HAS_RASTER_SOURCE_PATTERN
   rb_define_method (rb_cCairo_RasterSourcePattern, "initialize",
                     cr_raster_source_pattern_initialize, -1);
   rb_define_method (rb_cCairo_RasterSourcePattern, "acquire",

data/ext/cairo/rb_cairo_surface.c

@@ -23,10 +23,21 @@
 #  include <st.h>
 #endif
 
+#if CAIRO_CHECK_VERSION(1, 5, 2)
+#  define RB_CAIRO_HAS_WIN32_PRINTING_SURFACE_TYPE
+#endif
+
+#if CAIRO_CHECK_VERSION(1, 5, 12)
+#  define RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE_TYPE
+#endif
+
 #ifdef CAIRO_HAS_WIN32_SURFACE
 #  define OpenFile OpenFile_win32
 #  include <cairo-win32.h>
 #  undef OpenFile
+#  ifdef RB_CAIRO_HAS_WIN32_PRINTING_SURFACE_TYPE
+#    define RB_CAIRO_HAS_WIN32_PRINTING_SURFACE
+#  endif
 #endif
 
 #ifdef HAVE_RUBY_IO_H
@@ -44,6 +55,12 @@ enum ruby_value_type {
 #  undef T_DATA
 #  include <cairo-quartz.h>
 #  define T_DATA RUBY_T_DATA
+#  ifdef HAVE_RUBY_COCOA
+#    define RB_CAIRO_HAS_QUARTZ_SURFACE
+#    ifdef RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE_TYPE
+#      define RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE
+#    endif
+#  endif
 #endif
 
 #ifdef CAIRO_HAS_XML_SURFACE
@@ -151,12 +168,12 @@ cr_surface_get_klass (cairo_surface_t *surface)
     case CAIRO_SURFACE_TYPE_SVG:
       klass = rb_cCairo_SVGSurface;
       break;
-#if CAIRO_CHECK_VERSION(1, 5, 2)
+#ifdef RB_CAIRO_HAS_WIN32_PRINTING_SURFACE_TYPE
     case CAIRO_SURFACE_TYPE_WIN32_PRINTING:
       klass = rb_cCairo_Win32PrintingSurface;
       break;
 #endif
-#if CAIRO_CHECK_VERSION(1, 5, 12)
+#ifdef RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE_TYPE
     case CAIRO_SURFACE_TYPE_QUARTZ_IMAGE:
       klass = rb_cCairo_QuartzImageSurface;
       break;
@@ -209,6 +226,138 @@ cr_surface_get_klass (cairo_surface_t *surface)
   return klass;
 }
 
+static VALUE
+cr_surface_image_supported_p (VALUE klass)
+{
+  return Qtrue;
+}
+
+static VALUE
+cr_surface_pdf_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_PDF_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_ps_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_PS_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_quartz_supported_p (VALUE klass)
+{
+#ifdef RB_CAIRO_HAS_QUARTZ_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_win32_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_WIN32_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_svg_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_SVG_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_win32_printing_supported_p (VALUE klass)
+{
+#ifdef RB_CAIRO_HAS_WIN32_PRINTING_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_quartz_image_supported_p (VALUE klass)
+{
+#ifdef RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_script_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_SCRIPT_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_recording_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_RECORDING_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_gl_supported_p (VALUE klass)
+{
+#ifdef RB_CAIRO_HAS_GL_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_gl_texture_supported_p (VALUE klass)
+{
+  return cr_surface_gl_supported_p(klass);
+}
+
+static VALUE
+cr_surface_tee_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_TEE_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+static VALUE
+cr_surface_xml_supported_p (VALUE klass)
+{
+#ifdef CAIRO_HAS_XML_SURFACE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
 /* constructor/de-constructor */
 cairo_surface_t *
 rb_cairo_surface_from_ruby_object (VALUE obj)
@@ -279,6 +428,16 @@ cr_surface_allocate (VALUE klass)
   return Data_Wrap_Struct (klass, NULL, cr_surface_free, NULL);
 }
 
+static VALUE
+cr_surface_initialize (int argc, VALUE *argv, VALUE self)
+{
+  rb_raise(rb_eNotImpError,
+           "%s class creation isn't supported on this cairo installation",
+           rb_obj_classname(self));
+
+  return Qnil;
+}
+
 /* Surface manipulation */
 static VALUE
 cr_surface_destroy (VALUE self)
@@ -617,7 +776,7 @@ cr_surface_mark_dirty (int argc, VALUE *argv, VALUE self)
 {
   VALUE x, y, width, height;
   int n;
-  
+
   n = rb_scan_args (argc, argv, "04", &x, &y, &width, &height);
 
   if (n == 0)
@@ -717,7 +876,7 @@ cr_surface_show_page (VALUE self)
 }
 #endif
 
-/* Image-surface functions */
+/* image surface functions */
 #ifdef CAIRO_HAS_PNG_FUNCTIONS
 static cairo_surface_t *
 cr_image_surface_create_from_png_stream (VALUE target)
@@ -777,7 +936,7 @@ cr_image_surface_create_for_data (VALUE self, VALUE rb_data, VALUE format,
   unsigned char *data;
 
   data = (unsigned char *)StringValuePtr (rb_data);
-  
+
   return cairo_image_surface_create_for_data (data,
                                               RVAL2CRFORMAT (format),
                                               NUM2INT (width),
@@ -791,7 +950,7 @@ cr_image_surface_initialize (int argc, VALUE *argv, VALUE self)
   cairo_surface_t *surface;
   VALUE arg1, arg2, arg3, arg4, arg5;
   int n;
-  
+
   n = rb_scan_args (argc, argv, "23", &arg1, &arg2, &arg3, &arg4, &arg5);
 
   if (n == 2)
@@ -857,94 +1016,7 @@ 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));
-}
-
-#  if CAIRO_CHECK_VERSION(1, 11, 4)
-static VALUE
-cr_recording_surface_get_extents (VALUE self)
-{
-  cairo_surface_t *surface;
-  cairo_rectangle_t extents;
-
-  surface = _SELF;
-  cairo_recording_surface_get_extents (surface, &extents);
-  cr_surface_check_status (surface);
-  return rb_ary_new3 (4,
-                      rb_float_new (extents.x),
-                      rb_float_new (extents.y),
-                      rb_float_new (extents.width),
-                      rb_float_new (extents.height));
-}
-#  endif
-#endif
-
-/* Printing surfaces */
+/* printing surfaces */
 #define DEFINE_SURFACE(type)                                            \
 static VALUE                                                            \
 cr_ ## type ## _surface_initialize (int argc, VALUE *argv, VALUE self)  \
@@ -1045,6 +1117,22 @@ cr_ ## type ## _surface_set_size (int argc, VALUE *argv, VALUE self)    \
   return Qnil;                                                          \
 }
 
+#ifdef CAIRO_HAS_PDF_SURFACE
+/* 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_PS_SURFACE
 /* PS-surface functions */
 DEFINE_SURFACE(ps)
@@ -1105,64 +1193,108 @@ cr_ps_surface_set_eps (VALUE self, VALUE eps)
 #  endif
 #endif
 
-#ifdef CAIRO_HAS_PDF_SURFACE
-/* 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 RB_CAIRO_HAS_QUARTZ_SURFACE
+/* Quartz-surface functions */
+#include <objc/objc-runtime.h>
 
-#ifdef CAIRO_HAS_XLIB_SURFACE
-static VALUE
-cr_xlib_surface_initialize (int argc, VALUE *argv, VALUE self)
-{
-  rb_notimplement();
-  return Qnil;
-}
-#endif
+BOOL rbobj_to_nsobj (VALUE obj, id* nsobj);
+VALUE ocid_to_rbobj (VALUE context_obj, id ocid);
 
-#ifdef CAIRO_HAS_XCB_SURFACE
 static VALUE
-cr_xcb_surface_initialize (int argc, VALUE *argv, VALUE self)
+cr_quartz_surface_initialize (int argc, VALUE *argv, VALUE self)
 {
-  rb_notimplement();
-  return Qnil;
-}
-#endif
+  id objc_object = nil;
+  CGContextRef context;
+  unsigned int width, height;
+  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;
 
-#ifdef CAIRO_HAS_SVG_SURFACE
-/* SVG-surface functions */
-DEFINE_SURFACE(svg)
+  rb_scan_args (argc, argv, "21", &arg1, &arg2, &arg3);
 
-static VALUE
-cr_svg_surface_restrict_to_version (VALUE self, VALUE version)
-{
-  cairo_svg_surface_restrict_to_version (_SELF, RVAL2CRSVGVERSION (version));
-  cr_surface_check_status (_SELF);
-  return Qnil;
-}
+  if (argc == 2)
+    {
+      rb_width = arg1;
+      rb_height = arg2;
+    }
+  else
+    {
+      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",
+                      rb_cairo__inspect (rb_ary_new3 (3, arg1, arg2, arg3)));
+          break;
+        }
+
+      rb_width = arg2;
+      rb_height = arg3;
+    }
+
+  width = NUM2UINT (rb_width);
+  height = NUM2UINT (rb_height);
+
+  if (objc_object == nil)
+    {
+      surface = cairo_quartz_surface_create (format, width, height);
+    }
+  else
+    {
+      context = (CGContextRef)objc_object;
+      surface =
+        cairo_quartz_surface_create_for_cg_context (context, 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_quartz_surface_get_cg_context (VALUE self)
+{
+  CGContextRef context;
+  id objc_object;
+
+  context = cairo_quartz_surface_get_cg_context (_SELF);
+  objc_object = (id)context;
+  return ocid_to_rbobj (Qnil, objc_object);
+}
 #endif
 
 #ifdef CAIRO_HAS_WIN32_SURFACE
-/* WIN32-surface functions */
+/* Win32 surface functions */
 
 /* from dl/dl.h (ruby 1.9) */
-#if SIZEOF_LONG == SIZEOF_VOIDP
-#  define PTR2NUM(x)   (ULONG2NUM((unsigned long)(x)))
-#  define NUM2PTR(x)   ((void *)(NUM2ULONG(x)))
-#else
-#  define PTR2NUM(x)   (ULL2NUM((unsigned long long)(x)))
-#  define NUM2PTR(x)   ((void *)(NUM2ULL(x)))
-#endif
+#  if SIZEOF_LONG == SIZEOF_VOIDP
+#    define PTR2NUM(x)   (ULONG2NUM((unsigned long)(x)))
+#    define NUM2PTR(x)   ((void *)(NUM2ULONG(x)))
+#  else
+#    define PTR2NUM(x)   (ULL2NUM((unsigned long long)(x)))
+#    define NUM2PTR(x)   ((void *)(NUM2ULL(x)))
+#  endif
 
 static VALUE
 cr_win32_surface_initialize (int argc, VALUE *argv, VALUE self)
@@ -1248,21 +1380,6 @@ 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)
 {
@@ -1290,98 +1407,37 @@ cr_win32_surface_get_image (VALUE self)
 #  endif
 #endif
 
-#if defined(CAIRO_HAS_QUARTZ_SURFACE) && defined(HAVE_RUBY_COCOA)
-/* Quartz-surface functions */
-
-#include <objc/objc-runtime.h>
+#ifdef CAIRO_HAS_SVG_SURFACE
+/* SVG-surface functions */
+DEFINE_SURFACE(svg)
 
-BOOL rbobj_to_nsobj (VALUE obj, id* nsobj);
-VALUE ocid_to_rbobj (VALUE context_obj, id ocid);
+static VALUE
+cr_svg_surface_restrict_to_version (VALUE self, VALUE version)
+{
+  cairo_svg_surface_restrict_to_version (_SELF, RVAL2CRSVGVERSION (version));
+  cr_surface_check_status (_SELF);
+  return Qnil;
+}
+#endif
 
+#ifdef RB_CAIRO_HAS_WIN32_PRINTING_SURFACE
+/* Win32 printing surface functions */
 static VALUE
-cr_quartz_surface_initialize (int argc, VALUE *argv, VALUE self)
+cr_win32_printing_surface_initialize (VALUE self, VALUE hdc)
 {
-  id objc_object = nil;
-  CGContextRef context;
-  unsigned int width, height;
   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);
-
-  if (argc == 2)
-    {
-      rb_width = arg1;
-      rb_height = arg2;
-    }
-  else
-    {
-      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",
-                      rb_cairo__inspect (rb_ary_new3 (3, arg1, arg2, arg3)));
-          break;
-        }
-
-      rb_width = arg2;
-      rb_height = arg3;
-    }
-
-  width = NUM2UINT (rb_width);
-  height = NUM2UINT (rb_height);
-
-  if (objc_object == nil)
-    {
-      surface = cairo_quartz_surface_create (format, width, height);
-    }
-  else
-    {
-      context = (CGContextRef)objc_object;
-      surface =
-        cairo_quartz_surface_create_for_cg_context (context, width, height);
-    }
 
+  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_quartz_surface_get_cg_context (VALUE self)
-{
-  CGContextRef context;
-  id objc_object;
-
-  context = cairo_quartz_surface_get_cg_context (_SELF);
-  objc_object = (id)context;
-  return ocid_to_rbobj (Qnil, objc_object);
-}
-
-#  if CAIRO_CHECK_VERSION(1, 5, 12)
+#ifdef RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE
+/* Quartz image surface functions */
 static VALUE
 cr_quartz_image_surface_initialize (VALUE self, VALUE image_surface)
 {
@@ -1406,10 +1462,10 @@ cr_quartz_image_surface_get_image (VALUE self)
   cr_surface_check_status (surface);
   return CRSURFACE2RVAL (surface);
 }
-#  endif
 #endif
 
 #ifdef CAIRO_HAS_SCRIPT_SURFACE
+/* script surface functions */
 static VALUE
 cr_script_surface_initialize (int argc, VALUE *argv, VALUE self)
 {
@@ -1463,13 +1519,101 @@ cr_script_surface_initialize (int argc, VALUE *argv, VALUE self)
 }
 #endif
 
-#ifdef CAIRO_HAS_XML_SURFACE
+#ifdef CAIRO_HAS_RECORDING_SURFACE
+/* recording surface functions */
 static VALUE
-cr_xml_surface_initialize (int argc, VALUE *argv, VALUE self)
+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));
+}
+
+#  if CAIRO_CHECK_VERSION(1, 11, 4)
+static VALUE
+cr_recording_surface_get_extents (VALUE self)
+{
+  cairo_surface_t *surface;
+  cairo_rectangle_t extents;
+
+  surface = _SELF;
+  cairo_recording_surface_get_extents (surface, &extents);
+  cr_surface_check_status (surface);
+  return rb_ary_new3 (4,
+                      rb_float_new (extents.x),
+                      rb_float_new (extents.y),
+                      rb_float_new (extents.width),
+                      rb_float_new (extents.height));
+}
+#  endif
+#endif
+
+#ifdef RB_CAIRO_HAS_GL_SURFACE
+/* GL surface functions */
+static VALUE
+cr_gl_surface_initialize (int argc, VALUE *argv, VALUE self)
 {
   cairo_surface_t *surface;
   cairo_device_t *device;
-  double width, height;
+  int width, height;
   cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
   VALUE rb_device, rb_width, rb_height, rb_content;
 
@@ -1477,8 +1621,8 @@ cr_xml_surface_initialize (int argc, VALUE *argv, VALUE self)
                 &rb_device, &rb_width, &rb_height, &rb_content);
 
   device = RVAL2CRDEVICE (rb_device);
-  width = NUM2DBL (rb_width);
-  height = NUM2DBL (rb_height);
+  width = NUM2INT (rb_width);
+  height = NUM2INT (rb_height);
   switch (TYPE (rb_content))
     {
     case T_NIL:
@@ -1497,17 +1641,99 @@ cr_xml_surface_initialize (int argc, VALUE *argv, VALUE self)
       break;
     }
 
-  surface = cairo_xml_surface_create (device, content, width, height);
+  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);
-  DATA_PTR (self) = surface;
-  if (rb_block_given_p ())
-    yield_and_finish (self);
   return Qnil;
 }
 #endif
 
 #ifdef CAIRO_HAS_TEE_SURFACE
+/* tee surface functions */
 static VALUE
 cr_tee_surface_initialize (VALUE self, VALUE master)
 {
@@ -1599,13 +1825,14 @@ cr_tee_surface_array_reference (VALUE self, VALUE index)
 }
 #endif
 
-#ifdef RB_CAIRO_HAS_GL_SURFACE
+#ifdef CAIRO_HAS_XML_SURFACE
+/* XML surface functions */
 static VALUE
-cr_gl_surface_initialize (int argc, VALUE *argv, VALUE self)
+cr_xml_surface_initialize (int argc, VALUE *argv, VALUE self)
 {
   cairo_surface_t *surface;
   cairo_device_t *device;
-  int width, height;
+  double width, height;
   cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
   VALUE rb_device, rb_width, rb_height, rb_content;
 
@@ -1613,8 +1840,8 @@ cr_gl_surface_initialize (int argc, VALUE *argv, VALUE self)
                 &rb_device, &rb_width, &rb_height, &rb_content);
 
   device = RVAL2CRDEVICE (rb_device);
-  width = NUM2INT (rb_width);
-  height = NUM2INT (rb_height);
+  width = NUM2DBL (rb_width);
+  height = NUM2DBL (rb_height);
   switch (TYPE (rb_content))
     {
     case T_NIL:
@@ -1633,54 +1860,7 @@ cr_gl_surface_initialize (int argc, VALUE *argv, VALUE self)
       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);
+  surface = cairo_xml_surface_create (device, content, width, height);
 
   cr_surface_check_status (surface);
   DATA_PTR (self) = surface;
@@ -1688,40 +1868,6 @@ cr_gl_texture_surface_initialize (int argc, VALUE *argv, VALUE self)
     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
@@ -1753,6 +1899,37 @@ Init_cairo_surface (void)
   rb_cairo__initialize_gc_guard_holder_class (rb_cCairo_Surface);
   rb_set_end_proc(cr_finish_all_guarded_surfaces_at_end, Qnil);
 
+  rb_define_singleton_method (rb_cCairo_Surface, "image_supported?",
+                              cr_surface_image_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "pdf_supported?",
+                              cr_surface_pdf_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "ps_supported?",
+                              cr_surface_ps_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "quartz_supported?",
+                              cr_surface_quartz_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "win32_supported?",
+                              cr_surface_win32_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "svg_supported?",
+                              cr_surface_svg_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "win32_printing_supported?",
+                              cr_surface_win32_printing_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "quartz_image_supported?",
+                              cr_surface_quartz_image_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "script_supported?",
+                              cr_surface_script_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "recording_supported?",
+                              cr_surface_recording_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "gl_supported?",
+                              cr_surface_gl_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "gl_texture_supported?",
+                              cr_surface_gl_texture_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "tee_supported?",
+                              cr_surface_tee_supported_p, 0);
+  rb_define_singleton_method (rb_cCairo_Surface, "xml_supported?",
+                              cr_surface_xml_supported_p, 0);
+
+  rb_define_method (rb_cCairo_Surface, "initialize",
+                    cr_surface_initialize, -1);
 
   rb_define_method (rb_cCairo_Surface, "create_similar",
                     cr_surface_create_similar, -1);
@@ -1814,15 +1991,15 @@ Init_cairo_surface (void)
 
   RB_CAIRO_DEF_SETTERS (rb_cCairo_Surface);
 
-  /* Image-surface */
+  /* image surface */
   rb_cCairo_ImageSurface =
     rb_define_class_under (rb_mCairo, "ImageSurface", rb_cCairo_Surface);
-  
+
 #ifdef CAIRO_HAS_PNG_FUNCTIONS
   rb_define_singleton_method (rb_cCairo_ImageSurface, "from_png",
                               cr_image_surface_create_from_png_generic, 1);
 #endif
-  
+
   rb_define_method (rb_cCairo_ImageSurface, "initialize",
                     cr_image_surface_initialize, -1);
 
@@ -1837,34 +2014,30 @@ 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);
+  /* PDF surface */
+  rb_cCairo_PDFSurface =
+    rb_define_class_under (rb_mCairo, "PDFSurface", rb_cCairo_Surface);
+#ifdef CAIRO_HAS_PDF_SURFACE
+  rb_define_method (rb_cCairo_PDFSurface, "initialize",
+                    cr_pdf_surface_initialize, -1);
 
-  rb_define_method (rb_cCairo_RecordingSurface, "initialize",
-                    cr_recording_surface_initialize, -1);
+  rb_define_method (rb_cCairo_PDFSurface, "set_size",
+                    cr_pdf_surface_set_size, -1);
 
-  rb_define_method (rb_cCairo_RecordingSurface, "ink_extents",
-                    cr_recording_surface_get_ink_extents, 0);
-#  if CAIRO_CHECK_VERSION(1, 11, 4)
-  rb_define_method (rb_cCairo_RecordingSurface, "extents",
-                    cr_recording_surface_get_extents, 0);
+#  if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_define_method (rb_cCairo_PDFSurface, "restrict_to_version",
+                    cr_pdf_surface_restrict_to_version, 1);
 #  endif
-#endif
 
-#define INIT_SURFACE(type, name)                                        \
-  rb_cCairo_ ## name ## Surface =                                       \
-    rb_define_class_under (rb_mCairo, # name "Surface",                 \
-                           rb_cCairo_Surface);                          \
-                                                                        \
-  rb_define_method (rb_cCairo_ ## name ## Surface, "initialize",        \
-                    cr_ ## type ## _surface_initialize, -1);
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_PDFSurface);
+#endif
 
+  /* PS surface */
+  rb_cCairo_PSSurface =
+    rb_define_class_under (rb_mCairo, "PSSurface", rb_cCairo_Surface);
 #ifdef CAIRO_HAS_PS_SURFACE
-  /* PS-surface */
-  INIT_SURFACE(ps, PS)
-
+  rb_define_method (rb_cCairo_PSSurface, "initialize",
+                    cr_ps_surface_initialize, -1);
   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);
@@ -1883,50 +2056,28 @@ Init_cairo_surface (void)
   RB_CAIRO_DEF_SETTERS (rb_cCairo_PSSurface);
 #endif
 
-#ifdef CAIRO_HAS_PDF_SURFACE
-  /* PDF-surface */
-  INIT_SURFACE(pdf, PDF)
-
-  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
-
-#ifdef CAIRO_HAS_XLIB_SURFACE
-  /* XLib-surface */
-  INIT_SURFACE(xlib, XLib)
-
-  RB_CAIRO_DEF_SETTERS (rb_cCairo_XLibSurface);
-#endif
-
-#ifdef CAIRO_HAS_XCB_SURFACE
-  /* XLib-surface */
-  INIT_SURFACE(xcb, XCB)
-
-  RB_CAIRO_DEF_SETTERS (rb_cCairo_XCBSurface);
-#endif
-
-#ifdef CAIRO_HAS_SVG_SURFACE
-  /* SVG-surface */
-  INIT_SURFACE(svg, SVG)
+  /* XLib surface */
+  rb_cCairo_XLibSurface =
+    rb_define_class_under (rb_mCairo, "XLibSurface", rb_cCairo_Surface);
 
-  rb_define_method (rb_cCairo_SVGSurface, "restrict_to_version",
-                    cr_svg_surface_restrict_to_version, 1);
+  /* XCB surface */
+  rb_cCairo_XCBSurface =
+    rb_define_class_under (rb_mCairo, "XCBSurface", rb_cCairo_Surface);
 
-  RB_CAIRO_DEF_SETTERS (rb_cCairo_SVGSurface);
+  /* Quartz surface */
+  rb_cCairo_QuartzSurface =
+    rb_define_class_under (rb_mCairo, "QuartzSurface", rb_cCairo_Surface);
+#ifdef RB_CAIRO_HAS_QUARTZ_SURFACE
+  rb_define_method (rb_cCairo_QuartzSurface, "initialize",
+                    cr_quartz_surface_initialize, -1);
+  rb_define_method (rb_cCairo_QuartzSurface, "cg_context",
+                    cr_quartz_surface_get_cg_context, 0);
 #endif
 
-#ifdef CAIRO_HAS_WIN32_SURFACE
-  /* Win32-surface */
+  /* Win32 surface */
   rb_cCairo_Win32Surface =
     rb_define_class_under (rb_mCairo, "Win32Surface", rb_cCairo_Surface);
-
+#ifdef CAIRO_HAS_WIN32_SURFACE
   rb_define_method (rb_cCairo_Win32Surface, "initialize",
                     cr_win32_surface_initialize, -1);
   rb_define_method (rb_cCairo_Win32Surface, "hdc",
@@ -1935,84 +2086,79 @@ Init_cairo_surface (void)
   rb_define_method (rb_cCairo_Win32Surface, "image",
                     cr_win32_surface_get_image, 0);
 #  endif
+#endif
 
-#  if CAIRO_CHECK_VERSION(1, 5, 2)
+  /* SVG surface */
+  rb_cCairo_SVGSurface =
+    rb_define_class_under (rb_mCairo, "SVGSurface", rb_cCairo_Surface);
+#ifdef CAIRO_HAS_SVG_SURFACE
+  rb_define_method (rb_cCairo_SVGSurface, "initialize",
+                    cr_svg_surface_initialize, -1);
+  rb_define_method (rb_cCairo_SVGSurface, "restrict_to_version",
+                    cr_svg_surface_restrict_to_version, 1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_SVGSurface);
+#endif
+
+  /* Win32 printing surface */
   rb_cCairo_Win32PrintingSurface =
     rb_define_class_under (rb_mCairo, "Win32PrintingSurface", rb_cCairo_Surface);
-
+#ifdef RB_CAIRO_HAS_WIN32_PRINTING_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 defined(CAIRO_HAS_QUARTZ_SURFACE) && defined(HAVE_RUBY_COCOA)
-  /* Quartz-surface */
-
-  rb_cCairo_QuartzSurface =
-    rb_define_class_under (rb_mCairo, "QuartzSurface", rb_cCairo_Surface);
-
-  rb_define_method (rb_cCairo_QuartzSurface, "initialize",
-                    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)
+  /* Quartz image surface */
   rb_cCairo_QuartzImageSurface =
     rb_define_class_under (rb_mCairo, "QuartzImageSurface", rb_cCairo_Surface);
-
+#ifdef RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE
   rb_define_method (rb_cCairo_QuartzImageSurface, "initialize",
                     cr_quartz_image_surface_initialize, 1);
   rb_define_method (rb_cCairo_QuartzImageSurface, "image",
                     cr_quartz_image_surface_get_image, 0);
-#  endif
 #endif
 
-#ifdef CAIRO_HAS_SCRIPT_SURFACE
+  /* script surface */
   rb_cCairo_ScriptSurface =
     rb_define_class_under (rb_mCairo, "ScriptSurface", rb_cCairo_Surface);
-
+#ifdef CAIRO_HAS_SCRIPT_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);
+  /* Qt surface */
+  rb_cCairo_QtSurface =
+    rb_define_class_under (rb_mCairo, "QtSurface", rb_cCairo_Surface);
 
-  rb_define_method (rb_cCairo_XMLSurface, "initialize",
-                    cr_xml_surface_initialize, -1);
+  /* recording surface */
+  rb_cCairo_RecordingSurface =
+    rb_define_class_under (rb_mCairo, "RecordingSurface", rb_cCairo_Surface);
+#ifdef CAIRO_HAS_RECORDING_SURFACE
+  rb_define_method (rb_cCairo_RecordingSurface, "initialize",
+                    cr_recording_surface_initialize, -1);
 
-  RB_CAIRO_DEF_SETTERS (rb_cCairo_XMLSurface);
+  rb_define_method (rb_cCairo_RecordingSurface, "ink_extents",
+                    cr_recording_surface_get_ink_extents, 0);
+#  if CAIRO_CHECK_VERSION(1, 11, 4)
+  rb_define_method (rb_cCairo_RecordingSurface, "extents",
+                    cr_recording_surface_get_extents, 0);
+#  endif
 #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
+  /* VG surface */
+  rb_cCairo_VGSurface =
+    rb_define_class_under (rb_mCairo, "VGSurface", rb_cCairo_Surface);
 
-#ifdef RB_CAIRO_HAS_GL_SURFACE
+  /* GL surface */
   rb_cCairo_GLSurface =
     rb_define_class_under (rb_mCairo, "GLSurface", rb_cCairo_Surface);
-
+  rb_cCairo_GLTextureSurface =
+    rb_define_class_under (rb_mCairo, "GLTextureSurface", rb_cCairo_GLSurface);
+#ifdef RB_CAIRO_HAS_GL_SURFACE
   rb_define_method (rb_cCairo_GLSurface, "initialize",
                     cr_gl_surface_initialize, 1);
 
@@ -2027,12 +2173,54 @@ Init_cairo_surface (void)
 
   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
+
+  /* DRM surface */
+  rb_cCairo_DRMSurface =
+    rb_define_class_under (rb_mCairo, "DRMSurface", rb_cCairo_Surface);
+
+  /* tee surface */
+  rb_cCairo_TeeSurface =
+    rb_define_class_under (rb_mCairo, "TeeSurface", rb_cCairo_Surface);
+#ifdef CAIRO_HAS_TEE_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
+
+  /* XML surface */
+  rb_cCairo_XMLSurface =
+    rb_define_class_under (rb_mCairo, "XMLSurface", rb_cCairo_Surface);
+#ifdef CAIRO_HAS_XML_SURFACE
+  rb_define_method (rb_cCairo_XMLSurface, "initialize",
+                    cr_xml_surface_initialize, -1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_XMLSurface);
+#endif
+
+  /* Skia surface */
+  rb_cCairo_SkiaSurface =
+    rb_define_class_under (rb_mCairo, "SkiaSurface", rb_cCairo_Surface);
+
+  /* sub surface */
+  rb_cCairo_SubSurface =
+    rb_define_class_under (rb_mCairo, "SubSurface", rb_cCairo_Surface);
+
+  /* Cogl surface */
+  rb_cCairo_CoglSurface =
+    rb_define_class_under (rb_mCairo, "CoglSurface", rb_cCairo_Surface);
 }