cairo 1.8.5 → 1.10.0

data/ext/cairo/rb_cairo_context.c

@@ -5,6 +5,7 @@
  * $Author: kou $
  * $Date: 2008-09-26 13:52:08 $
  *
+ * Copyright 2005-2010 Kouhei Sutou <kou@cozmixng.org>
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
  *
@@ -983,6 +984,19 @@ cr_in_fill (VALUE self, VALUE x, VALUE y)
   return CBOOL2RVAL (cairo_in_fill (_SELF, NUM2DBL (x), NUM2DBL (y)));
 }
 
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+static VALUE
+cr_in_clip (VALUE self, VALUE x, VALUE y)
+{
+  if (rb_block_given_p ())
+    {
+      cr_new_path (self);
+      rb_yield (self);
+    }
+  return CBOOL2RVAL (cairo_in_clip (_SELF, NUM2DBL (x), NUM2DBL (y)));
+}
+#endif
+
 /* Rectangular extents */
 static VALUE
 cr_stroke_extents (VALUE self)
@@ -1615,6 +1629,9 @@ Init_cairo_context (void)
   /* Insideness testing */
   rb_define_method (rb_cCairo_Context, "in_stroke?", cr_in_stroke, 2);
   rb_define_method (rb_cCairo_Context, "in_fill?", cr_in_fill, 2);
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_define_method (rb_cCairo_Context, "in_clip?", cr_in_clip, 2);
+#endif
 
   /* Rectangular extents */
   rb_define_method (rb_cCairo_Context, "stroke_extents", cr_stroke_extents, 0);

data/ext/cairo/rb_cairo_device.c

@@ -0,0 +1,406 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * Copyright 2010 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+ */
+
+#include "rb_cairo.h"
+#include "rb_cairo_private.h"
+#include "rb_cairo_io.h"
+
+#ifdef HAVE_RUBY_ST_H
+#  include <ruby/st.h>
+#else
+#  include <st.h>
+#endif
+
+#ifdef CAIRO_HAS_XML_SURFACE
+#  include <cairo-xml.h>
+#endif
+
+VALUE rb_cCairo_Device = Qnil;
+VALUE rb_cCairo_DRMDevice = Qnil;
+VALUE rb_cCairo_GLDevice = Qnil;
+VALUE rb_cCairo_ScriptDevice = Qnil;
+VALUE rb_cCairo_XCBDevice = Qnil;
+VALUE rb_cCairo_XlibDevice = Qnil;
+VALUE rb_cCairo_XMLDevice = Qnil;
+
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+
+static cairo_user_data_key_t cr_closure_key;
+static cairo_user_data_key_t cr_object_holder_key;
+static cairo_user_data_key_t cr_finished_key;
+
+#define _SELF  (RVAL2CRDEVICE(self))
+
+static inline void
+cr_device_check_status (cairo_device_t *device)
+{
+  rb_cairo_check_status (cairo_device_status (device));
+}
+
+static VALUE
+cr_device_get_klass (cairo_device_t *device)
+{
+  VALUE klass;
+  cairo_device_type_t type;
+
+  type = cairo_device_get_type (device);
+  switch (type)
+    {
+    case CAIRO_DEVICE_TYPE_DRM:
+      klass = rb_cCairo_DRMDevice;
+      break;
+    case CAIRO_DEVICE_TYPE_GL:
+      klass = rb_cCairo_GLDevice;
+      break;
+    case CAIRO_DEVICE_TYPE_SCRIPT:
+      klass = rb_cCairo_ScriptDevice;
+      break;
+    case CAIRO_DEVICE_TYPE_XCB:
+      klass = rb_cCairo_XCBDevice;
+      break;
+    case CAIRO_DEVICE_TYPE_XLIB:
+      klass = rb_cCairo_XlibDevice;
+      break;
+    case CAIRO_DEVICE_TYPE_XML:
+      klass = rb_cCairo_XMLDevice;
+      break;
+    default:
+      klass = rb_cCairo_Device;
+      break;
+    }
+
+  if (NIL_P (klass))
+    rb_raise (rb_eArgError, "unknown device type: %d", type);
+
+  return klass;
+}
+
+/* constructor/de-constructor */
+cairo_device_t *
+rb_cairo_device_from_ruby_object (VALUE obj)
+{
+  cairo_device_t *device;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_Device))
+    {
+      rb_raise (rb_eTypeError, "not a cairo device");
+    }
+  Data_Get_Struct (obj, cairo_device_t, device);
+  if (!device)
+    rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
+  return device;
+}
+
+static rb_cairo__object_holder_t *
+cr_object_holder_new (VALUE object)
+{
+  return rb_cairo__object_holder_new (rb_cCairo_Device, object);
+}
+
+static void
+cr_object_holder_free (void *ptr)
+{
+  rb_cairo__object_holder_free (rb_cCairo_Device, ptr);
+}
+
+static void
+cr_device_free (void *ptr)
+{
+  cairo_device_t *device = ptr;
+
+  if (device)
+    cairo_device_destroy (device);
+}
+
+VALUE
+rb_cairo_device_to_ruby_object (cairo_device_t *device)
+{
+  if (device)
+    {
+      VALUE klass;
+      klass = cr_device_get_klass (device);
+      cairo_device_reference (device);
+      return Data_Wrap_Struct (klass, NULL, cr_device_free, device);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+VALUE
+rb_cairo_device_to_ruby_object_with_destroy (cairo_device_t *device)
+{
+  VALUE rb_device;
+
+  rb_device = rb_cairo_device_to_ruby_object (device);
+  if (device)
+    cairo_device_destroy (device);
+
+  return rb_device;
+}
+
+static VALUE
+cr_device_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_device_free, NULL);
+}
+
+/* Backend device manipulation */
+static VALUE
+cr_device_destroy (VALUE self)
+{
+  cairo_device_t *device;
+
+  device = _SELF;
+  cairo_device_destroy (device);
+  DATA_PTR (self) = NULL;
+
+  return self;
+}
+
+static VALUE
+cr_device_finish (VALUE self)
+{
+  cairo_device_t *device;
+  rb_cairo__io_callback_closure_t *closure;
+
+  device = _SELF;
+  closure = cairo_device_get_user_data (device, &cr_closure_key);
+
+  cairo_device_finish (device);
+  cairo_device_set_user_data (device, &cr_finished_key, (void *)CR_TRUE, NULL);
+  cairo_device_set_user_data (device, &cr_object_holder_key, NULL, NULL);
+
+  if (closure && !NIL_P (closure->error))
+    rb_exc_raise (closure->error);
+  cr_device_check_status (device);
+
+  return self;
+}
+
+static VALUE
+cr_device_flush (VALUE self)
+{
+  cairo_device_flush (_SELF);
+  cr_device_check_status (_SELF);
+  return self;
+}
+
+static VALUE
+cr_device_release (VALUE self)
+{
+  cairo_device_release (_SELF);
+  cr_device_check_status (_SELF);
+  return self;
+}
+
+static VALUE
+cr_device_acquire (VALUE self)
+{
+  cairo_device_acquire (_SELF);
+  cr_device_check_status (_SELF);
+  if (rb_block_given_p ())
+    return rb_ensure (rb_yield, self, cr_device_release, self);
+  else
+    return self;
+}
+
+static int
+cr_finish_all_guarded_devices_at_end_iter (VALUE key, VALUE value, VALUE data)
+{
+  cr_device_finish (key);
+  return ST_CONTINUE;
+}
+
+static void
+cr_finish_all_guarded_devices_at_end (VALUE data)
+{
+  rb_hash_foreach (rb_cairo__gc_guarded_objects (rb_cCairo_Device),
+                   cr_finish_all_guarded_devices_at_end_iter,
+                   Qnil);
+}
+
+static void
+yield_and_finish (VALUE self)
+{
+  cairo_device_t *device;
+
+  rb_yield (self);
+
+  device = _SELF;
+  if (!cairo_device_get_user_data (device, &cr_finished_key))
+    cr_device_finish (self);
+}
+
+#define DEFINE_OUTPUT_INITIALIZE(type)                                  \
+static VALUE                                                            \
+cr_ ## type ## _device_initialize (VALUE self,                          \
+                                   VALUE file_name_or_output)           \
+{                                                                       \
+  cairo_device_t *device;                                               \
+                                                                        \
+  if (rb_respond_to (file_name_or_output, rb_cairo__io_id_write))       \
+    {                                                                   \
+      rb_cairo__io_callback_closure_t *closure;                         \
+                                                                        \
+      closure = rb_cairo__io_closure_new (file_name_or_output);         \
+      device =                                                          \
+        cairo_ ## type ## _create_for_stream (rb_cairo__io_write_func,  \
+                                                     (void *)closure);  \
+      if (cairo_device_status (device))                                 \
+        {                                                               \
+          rb_cairo__io_closure_destroy (closure);                       \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          rb_ivar_set (self, rb_cairo__io_id_output,                    \
+                       file_name_or_output);                            \
+          cairo_device_set_user_data (device, &cr_closure_key,          \
+                                      closure,                          \
+                                      rb_cairo__io_closure_free);       \
+          cairo_device_set_user_data (device, &cr_object_holder_key,    \
+                                      cr_object_holder_new (self),      \
+                                      cr_object_holder_free);           \
+        }                                                               \
+    }                                                                   \
+  else                                                                  \
+    {                                                                   \
+      const char *file_name;                                            \
+      file_name = StringValueCStr (file_name_or_output);                \
+      device = cairo_ ## type ## _create (file_name);                   \
+    }                                                                   \
+                                                                        \
+  cr_device_check_status (device);                                      \
+  DATA_PTR (self) = device;                                             \
+  if (rb_block_given_p ())                                              \
+    yield_and_finish (self);                                            \
+  return Qnil;                                                          \
+}
+
+#  ifdef CAIRO_HAS_SCRIPT_SURFACE
+DEFINE_OUTPUT_INITIALIZE(script)
+
+static VALUE
+cr_script_device_write_comment (VALUE self, VALUE comment)
+{
+  cairo_device_t *device;
+
+  device = _SELF;
+  cairo_script_write_comment (device,
+                              StringValuePtr (comment),
+                              RSTRING_LEN (comment));
+  cr_device_check_status (device);
+  return Qnil;
+}
+
+static VALUE
+cr_script_device_set_mode (VALUE self, VALUE mode)
+{
+  cairo_device_t *device;
+
+  device = _SELF;
+  cairo_script_set_mode (device, RVAL2CRSCRIPTMODE (mode));
+  cr_device_check_status (device);
+  return Qnil;
+}
+
+static VALUE
+cr_script_device_get_mode (VALUE self)
+{
+  return INT2NUM (cairo_script_get_mode (_SELF));
+}
+
+static VALUE
+cr_script_device_reply (VALUE self, VALUE recording_surface)
+{
+  cairo_device_t *device;
+
+  device = _SELF;
+  cairo_script_from_recording_surface (device,
+                                       RVAL2CRSURFACE (recording_surface));
+  cr_device_check_status (device);
+  return Qnil;
+}
+#  endif
+
+#  ifdef CAIRO_HAS_XML_SURFACE
+DEFINE_OUTPUT_INITIALIZE(xml)
+
+static VALUE
+cr_xml_device_reply (VALUE self, VALUE recording_surface)
+{
+  cairo_device_t *device;
+
+  device = _SELF;
+  cairo_xml_for_recording_surface (device,
+                                   RVAL2CRSURFACE (recording_surface));
+  cr_device_check_status (device);
+  return Qnil;
+}
+#  endif
+
+#endif
+
+void
+Init_cairo_device (void)
+{
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_cCairo_Device =
+    rb_define_class_under (rb_mCairo, "Device", rb_cObject);
+  rb_define_alloc_func (rb_cCairo_Device, cr_device_allocate);
+
+  rb_cairo__initialize_gc_guard_holder_class (rb_cCairo_Device);
+  rb_set_end_proc(cr_finish_all_guarded_devices_at_end, Qnil);
+
+
+  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);
+  rb_define_method (rb_cCairo_Device, "acquire", cr_device_acquire, 0);
+  rb_define_method (rb_cCairo_Device, "release", cr_device_release, 0);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_Device);
+
+#  ifdef CAIRO_HAS_SCRIPT_SURFACE
+  rb_cCairo_ScriptDevice =
+    rb_define_class_under (rb_mCairo, "ScriptDevice", rb_cCairo_Device);
+
+  rb_define_method (rb_cCairo_ScriptDevice, "initialize",
+                    cr_script_device_initialize, 1);
+
+  rb_define_method (rb_cCairo_ScriptDevice, "write_comment",
+                    cr_script_device_write_comment, 1);
+
+  rb_define_method (rb_cCairo_ScriptDevice, "set_mode",
+                    cr_script_device_set_mode, 1);
+  rb_define_method (rb_cCairo_ScriptDevice, "mode",
+                    cr_script_device_get_mode, 0);
+
+  rb_define_method (rb_cCairo_ScriptDevice, "reply",
+                    cr_script_device_reply, 1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_ScriptDevice);
+#  endif
+
+#  ifdef CAIRO_HAS_XML_SURFACE
+  rb_cCairo_XMLDevice =
+    rb_define_class_under (rb_mCairo, "XMLDevice", rb_cCairo_Device);
+
+  rb_define_method (rb_cCairo_XMLDevice, "initialize",
+                    cr_xml_device_initialize, 1);
+
+  rb_define_method (rb_cCairo_XMLDevice, "reply",
+                    cr_xml_device_reply, 1);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_XMLDevice);
+#  endif
+
+#endif
+}

data/ext/cairo/rb_cairo_exception.c

@@ -51,113 +51,136 @@ static VALUE rb_eCairo_InvalidClusters;
 static VALUE rb_eCairo_InvalidSlant;
 static VALUE rb_eCairo_InvalidWeight;
 #endif
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+static VALUE rb_eCairo_InvalidSize;
+static VALUE rb_eCairo_UserFontNotImplemented;
+static VALUE rb_eCairo_DeviceTypeMismatch;
+static VALUE rb_eCairo_DeviceError;
+#endif
 
 void
 rb_cairo_check_status (cairo_status_t status)
 {
   const char *string = cairo_status_to_string (status);
-  
+
   switch (status)
     {
     case CAIRO_STATUS_SUCCESS:
       break;
     case CAIRO_STATUS_NO_MEMORY:
-      rb_raise (rb_eNoMemError, string);
+      rb_raise (rb_eNoMemError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_RESTORE:
-      rb_raise (rb_eCairo_InvalidRestoreError, string);
+      rb_raise (rb_eCairo_InvalidRestoreError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_POP_GROUP:
-      rb_raise (rb_eCairo_InvalidPopGroupError, string);
+      rb_raise (rb_eCairo_InvalidPopGroupError, "%s", string);
       break;
     case CAIRO_STATUS_NO_CURRENT_POINT:
-      rb_raise (rb_eCairo_NoCurrentPointError, string);
+      rb_raise (rb_eCairo_NoCurrentPointError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_MATRIX:
-      rb_raise (rb_eCairo_InvalidMatrixError, string);
+      rb_raise (rb_eCairo_InvalidMatrixError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_STATUS:
-      rb_raise (rb_eCairo_InvalidStatusError, string);
+      rb_raise (rb_eCairo_InvalidStatusError, "%s", string);
       break;
     case CAIRO_STATUS_NULL_POINTER:
-      rb_raise (rb_eCairo_NullPointerError, string);
+      rb_raise (rb_eCairo_NullPointerError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_STRING:
-      rb_raise (rb_eCairo_InvalidStringError, string);
+      rb_raise (rb_eCairo_InvalidStringError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_PATH_DATA:
-      rb_raise (rb_eCairo_InvalidPathDataError, string);
+      rb_raise (rb_eCairo_InvalidPathDataError, "%s", string);
       break;
     case CAIRO_STATUS_READ_ERROR:
-      rb_raise (rb_eCairo_ReadError, string);
+      rb_raise (rb_eCairo_ReadError, "%s", string);
       break;
     case CAIRO_STATUS_WRITE_ERROR:
-      rb_raise (rb_eCairo_WriteError, string);
+      rb_raise (rb_eCairo_WriteError, "%s", string);
       break;
     case CAIRO_STATUS_SURFACE_FINISHED:
-      rb_raise (rb_eCairo_SurfaceFinishedError, string);
+      rb_raise (rb_eCairo_SurfaceFinishedError, "%s", string);
       break;
     case CAIRO_STATUS_SURFACE_TYPE_MISMATCH:
-      rb_raise (rb_eCairo_SurfaceTypeMismatchError, string);
+      rb_raise (rb_eCairo_SurfaceTypeMismatchError, "%s", string);
       break;
     case CAIRO_STATUS_PATTERN_TYPE_MISMATCH:
-      rb_raise (rb_eCairo_PatternTypeMismatchError, string);
+      rb_raise (rb_eCairo_PatternTypeMismatchError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_CONTENT:
-      rb_raise (rb_eCairo_InvalidContentError, string);
+      rb_raise (rb_eCairo_InvalidContentError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_FORMAT:
-      rb_raise (rb_eCairo_InvalidFormatError, string);
+      rb_raise (rb_eCairo_InvalidFormatError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_VISUAL:
-      rb_raise (rb_eCairo_InvalidVisualError, string);
+      rb_raise (rb_eCairo_InvalidVisualError, "%s", string);
       break;
     case CAIRO_STATUS_FILE_NOT_FOUND:
-      rb_raise (rb_eCairo_FileNotFoundError, string);
+      rb_raise (rb_eCairo_FileNotFoundError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_DASH:
-      rb_raise (rb_eCairo_InvalidDashError, string);
+      rb_raise (rb_eCairo_InvalidDashError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_DSC_COMMENT:
-      rb_raise (rb_eCairo_InvalidDscCommentError, string);
+      rb_raise (rb_eCairo_InvalidDscCommentError, "%s", string);
       break;
 #if CAIRO_CHECK_VERSION(1, 3, 0)
     case CAIRO_STATUS_INVALID_INDEX:
-      rb_raise (rb_eCairo_InvalidIndexError, string);
+      rb_raise (rb_eCairo_InvalidIndexError, "%s", string);
       break;
     case CAIRO_STATUS_CLIP_NOT_REPRESENTABLE:
-      rb_raise (rb_eCairo_ClipNotRepresentableError, string);
+      rb_raise (rb_eCairo_ClipNotRepresentableError, "%s", string);
       break;
 #endif
 #if CAIRO_CHECK_VERSION(1, 5, 6)
     case CAIRO_STATUS_TEMP_FILE_ERROR:
-      rb_raise (rb_eCairo_TempFileError, string);
+      rb_raise (rb_eCairo_TempFileError, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_STRIDE:
-      rb_raise (rb_eCairo_InvalidStringError, string);
+      rb_raise (rb_eCairo_InvalidStringError, "%s", string);
       break;
 #endif
 #if CAIRO_CHECK_VERSION(1, 7, 2)
     case CAIRO_STATUS_FONT_TYPE_MISMATCH:
-      rb_raise (rb_eCairo_FontTypeMismatch, string);
+      rb_raise (rb_eCairo_FontTypeMismatch, "%s", string);
       break;
     case CAIRO_STATUS_USER_FONT_IMMUTABLE:
-      rb_raise (rb_eCairo_UserFontImmutable, string);
+      rb_raise (rb_eCairo_UserFontImmutable, "%s", string);
       break;
     case CAIRO_STATUS_USER_FONT_ERROR:
-      rb_raise (rb_eCairo_UserFontError, string);
+      rb_raise (rb_eCairo_UserFontError, "%s", string);
       break;
     case CAIRO_STATUS_NEGATIVE_COUNT:
-      rb_raise (rb_eCairo_NegativeCount, string);
+      rb_raise (rb_eCairo_NegativeCount, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_CLUSTERS:
-      rb_raise (rb_eCairo_InvalidClusters, string);
+      rb_raise (rb_eCairo_InvalidClusters, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_SLANT:
-      rb_raise (rb_eCairo_InvalidSlant, string);
+      rb_raise (rb_eCairo_InvalidSlant, "%s", string);
       break;
     case CAIRO_STATUS_INVALID_WEIGHT:
-      rb_raise (rb_eCairo_InvalidWeight, string);
+      rb_raise (rb_eCairo_InvalidWeight, "%s", string);
+      break;
+#endif
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+    case CAIRO_STATUS_INVALID_SIZE:
+      rb_raise (rb_eCairo_InvalidSize, "%s", string);
+      break;
+    case CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED:
+      rb_raise (rb_eCairo_UserFontNotImplemented, "%s", string);
+      break;
+    case CAIRO_STATUS_DEVICE_TYPE_MISMATCH:
+      rb_raise (rb_eCairo_DeviceTypeMismatch, "%s", string);
+      break;
+    case CAIRO_STATUS_DEVICE_ERROR:
+      rb_raise (rb_eCairo_DeviceError, "%s", string);
+      break;
+    case CAIRO_STATUS_LAST_STATUS:
+      rb_raise (rb_eArgError, "bug: %s: %d", string, status);
       break;
 #endif
     }
@@ -236,6 +259,16 @@ rb_cairo__exception_to_status (VALUE exception)
   else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidWeight))
     return CAIRO_STATUS_INVALID_WEIGHT;
 #endif
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidSize))
+    return CAIRO_STATUS_INVALID_SIZE;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_UserFontNotImplemented))
+    return CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_DeviceTypeMismatch))
+    return CAIRO_STATUS_DEVICE_TYPE_MISMATCH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_DeviceError))
+    return CAIRO_STATUS_DEVICE_ERROR;
+#endif
 
   return -1;
 }
@@ -351,4 +384,22 @@ Init_cairo_exception ()
     rb_define_class_under (rb_mCairo, "InvalidWeight",
                            rb_eArgError);
 #endif
+
+#if CAIRO_CHECK_VERSION(1, 10, 0)
+  rb_eCairo_InvalidSize =
+    rb_define_class_under (rb_mCairo, "InvalidSize",
+                           rb_eArgError);
+
+  rb_eCairo_UserFontNotImplemented =
+    rb_define_class_under (rb_mCairo, "UserFontNotImplemented",
+                           rb_eCairo_Error);
+
+  rb_eCairo_DeviceTypeMismatch =
+    rb_define_class_under (rb_mCairo, "DeviceTypeMismatch",
+                           rb_eArgError);
+
+  rb_eCairo_DeviceError =
+    rb_define_class_under (rb_mCairo, "DeviceError",
+                           rb_eCairo_Error);
+#endif
 }