cairo 1.6.3 → 1.7.0

data/src/rb_cairo_exception.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2008-02-21 13:18:10 $
+ * $Date: 2008-08-16 12:52:16 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -13,6 +13,7 @@
 */
 
 #include "rb_cairo.h"
+#include "rb_cairo_private.h"
 
 static VALUE rb_eCairo_InvalidRestoreError;
 static VALUE rb_eCairo_InvalidPopGroupError;
@@ -41,6 +42,15 @@ static VALUE rb_eCairo_ClipNotRepresentableError;
 static VALUE rb_eCairo_TempFileError;
 static VALUE rb_eCairo_InvalidStrideError;
 #endif
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE rb_eCairo_FontTypeMismatch;
+static VALUE rb_eCairo_UserFontImmutable;
+static VALUE rb_eCairo_UserFontError;
+static VALUE rb_eCairo_NegativeCount;
+static VALUE rb_eCairo_InvalidClusters;
+static VALUE rb_eCairo_InvalidSlant;
+static VALUE rb_eCairo_InvalidWeight;
+#endif
 
 void
 rb_cairo_check_status (cairo_status_t status)
@@ -126,10 +136,110 @@ rb_cairo_check_status (cairo_status_t status)
     case CAIRO_STATUS_INVALID_STRIDE:
       rb_raise (rb_eCairo_InvalidStringError, string);
       break;
+#endif
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+    case CAIRO_STATUS_FONT_TYPE_MISMATCH:
+      rb_raise (rb_eCairo_FontTypeMismatch, string);
+      break;
+    case CAIRO_STATUS_USER_FONT_IMMUTABLE:
+      rb_raise (rb_eCairo_UserFontImmutable, string);
+      break;
+    case CAIRO_STATUS_USER_FONT_ERROR:
+      rb_raise (rb_eCairo_UserFontError, string);
+      break;
+    case CAIRO_STATUS_NEGATIVE_COUNT:
+      rb_raise (rb_eCairo_NegativeCount, string);
+      break;
+    case CAIRO_STATUS_INVALID_CLUSTERS:
+      rb_raise (rb_eCairo_InvalidClusters, string);
+      break;
+    case CAIRO_STATUS_INVALID_SLANT:
+      rb_raise (rb_eCairo_InvalidSlant, string);
+      break;
+    case CAIRO_STATUS_INVALID_WEIGHT:
+      rb_raise (rb_eCairo_InvalidWeight, string);
+      break;
 #endif
     }
 }
 
+cairo_status_t
+rb_cairo__exception_to_status (VALUE exception)
+{
+  if (NIL_P (exception))
+    return CAIRO_STATUS_SUCCESS;
+  else if (rb_cairo__is_kind_of (exception, rb_eNoMemError))
+    return CAIRO_STATUS_NO_MEMORY;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidRestoreError))
+    return CAIRO_STATUS_INVALID_RESTORE;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidPopGroupError))
+    return CAIRO_STATUS_INVALID_POP_GROUP;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_NoCurrentPointError))
+    return CAIRO_STATUS_NO_CURRENT_POINT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidMatrixError))
+    return CAIRO_STATUS_INVALID_MATRIX;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidStatusError))
+    return CAIRO_STATUS_INVALID_STATUS;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_NullPointerError))
+    return CAIRO_STATUS_NULL_POINTER;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidStringError))
+    return CAIRO_STATUS_INVALID_STRING;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidPathDataError))
+    return CAIRO_STATUS_INVALID_PATH_DATA;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_ReadError))
+    return CAIRO_STATUS_READ_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_WriteError))
+    return CAIRO_STATUS_WRITE_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_SurfaceFinishedError))
+    return CAIRO_STATUS_SURFACE_FINISHED;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_SurfaceTypeMismatchError))
+    return CAIRO_STATUS_SURFACE_TYPE_MISMATCH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_PatternTypeMismatchError))
+    return CAIRO_STATUS_PATTERN_TYPE_MISMATCH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidContentError))
+    return CAIRO_STATUS_INVALID_CONTENT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidFormatError))
+    return CAIRO_STATUS_INVALID_FORMAT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidVisualError))
+    return CAIRO_STATUS_INVALID_VISUAL;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_FileNotFoundError))
+    return CAIRO_STATUS_FILE_NOT_FOUND;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidDashError))
+    return CAIRO_STATUS_INVALID_DASH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidDscCommentError))
+    return CAIRO_STATUS_INVALID_DSC_COMMENT;
+#if CAIRO_CHECK_VERSION(1, 3, 0)
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidIndexError))
+    return CAIRO_STATUS_INVALID_INDEX;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_ClipNotRepresentableError))
+    return CAIRO_STATUS_CLIP_NOT_REPRESENTABLE;
+#endif
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_TempFileError))
+    return CAIRO_STATUS_TEMP_FILE_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidStringError))
+    return CAIRO_STATUS_INVALID_STRIDE;
+#endif
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_FontTypeMismatch))
+    return CAIRO_STATUS_FONT_TYPE_MISMATCH;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_UserFontImmutable))
+    return CAIRO_STATUS_USER_FONT_IMMUTABLE;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_UserFontError))
+    return CAIRO_STATUS_USER_FONT_ERROR;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_NegativeCount))
+    return CAIRO_STATUS_NEGATIVE_COUNT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidClusters))
+    return CAIRO_STATUS_INVALID_CLUSTERS;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidSlant))
+    return CAIRO_STATUS_INVALID_SLANT;
+  else if (rb_cairo__is_kind_of (exception, rb_eCairo_InvalidWeight))
+    return CAIRO_STATUS_INVALID_WEIGHT;
+#endif
+
+  return -1;
+}
+
 void
 Init_cairo_exception ()
 {
@@ -208,7 +318,37 @@ Init_cairo_exception ()
                            rb_eCairo_Error);
 
   rb_eCairo_InvalidStrideError =
-        rb_define_class_under (rb_mCairo, "InvalidStrideError",
-                               rb_eArgError);
+    rb_define_class_under (rb_mCairo, "InvalidStrideError",
+                           rb_eArgError);
+#endif
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_eCairo_FontTypeMismatch =
+    rb_define_class_under (rb_mCairo, "FontTypeMismatch",
+                           rb_eCairo_Error);
+
+  rb_eCairo_UserFontImmutable =
+    rb_define_class_under (rb_mCairo, "UserFontImmutable",
+                           rb_eCairo_Error);
+
+  rb_eCairo_UserFontError =
+    rb_define_class_under (rb_mCairo, "UserFontError",
+                           rb_eCairo_Error);
+
+  rb_eCairo_NegativeCount =
+    rb_define_class_under (rb_mCairo, "NegativeCount",
+                           rb_eCairo_Error);
+
+  rb_eCairo_InvalidClusters =
+    rb_define_class_under (rb_mCairo, "InvalidClusters",
+                           rb_eArgError);
+
+  rb_eCairo_InvalidSlant =
+    rb_define_class_under (rb_mCairo, "InvalidSlant",
+                           rb_eCairo_Error);
+
+  rb_eCairo_InvalidWeight =
+    rb_define_class_under (rb_mCairo, "InvalidWeight",
+                           rb_eArgError);
 #endif
 }

data/src/rb_cairo_font_extents.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/03 02:47:39 $
+ * $Date: 2008-08-17 05:12:37 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -46,36 +46,94 @@ rb_cairo_font_extents_to_ruby_object (cairo_font_extents_t *extents)
     }
 }
 
-static    VALUE
+static VALUE
+cr_font_extents_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, -1, NULL);
+}
+
+static VALUE
+cr_font_extents_initialize (VALUE self)
+{
+  cairo_font_extents_t *extents;
+
+  extents = ALLOC (cairo_font_extents_t);
+  extents->ascent = 1.0;
+  extents->descent = 0.0;
+  extents->height = 1.0;
+  extents->max_x_advance = 1.0;
+  extents->max_y_advance = 0.0;
+
+  DATA_PTR (self) = extents;
+
+  return Qnil;
+}
+
+static VALUE
 cr_font_extents_ascent (VALUE self)
 {
   return rb_float_new (_SELF(self)->ascent);
 }
 
-static    VALUE
+static VALUE
+cr_font_extents_set_ascent (VALUE self, VALUE ascent)
+{
+  _SELF(self)->ascent = NUM2DBL (ascent);
+  return self;
+}
+
+static VALUE
 cr_font_extents_descent (VALUE self)
 {
   return rb_float_new (_SELF(self)->descent);
 }
 
-static    VALUE
+static VALUE
+cr_font_extents_set_descent (VALUE self, VALUE descent)
+{
+  _SELF(self)->descent = NUM2DBL (descent);
+  return self;
+}
+
+static VALUE
 cr_font_extents_height (VALUE self)
 {
   return rb_float_new (_SELF(self)->height);
 }
 
-static    VALUE
+static VALUE
+cr_font_extents_set_height (VALUE self, VALUE height)
+{
+  _SELF(self)->height = NUM2DBL (height);
+  return self;
+}
+
+static VALUE
 cr_font_extents_max_x_advance (VALUE self)
 {
   return rb_float_new (_SELF(self)->max_x_advance);
 }
 
-static    VALUE
+static VALUE
+cr_font_extents_set_max_x_advance (VALUE self, VALUE max_x_advance)
+{
+  _SELF(self)->max_x_advance = NUM2DBL (max_x_advance);
+  return self;
+}
+
+static VALUE
 cr_font_extents_max_y_advance (VALUE self)
 {
   return rb_float_new (_SELF(self)->max_y_advance);
 }
 
+static VALUE
+cr_font_extents_set_max_y_advance (VALUE self, VALUE max_y_advance)
+{
+  _SELF(self)->max_y_advance = NUM2DBL (max_y_advance);
+  return self;
+}
+
 static VALUE
 cr_font_extents_to_s (VALUE self)
 {
@@ -110,16 +168,33 @@ Init_cairo_font_extents (void)
   rb_cCairo_FontExtents =
     rb_define_class_under (rb_mCairo, "FontExtents", rb_cObject);
 
+  rb_define_alloc_func (rb_cCairo_FontExtents, cr_font_extents_allocate);
+
+  rb_define_method (rb_cCairo_FontExtents, "initialize",
+                    cr_font_extents_initialize, 0);
+
   rb_define_method (rb_cCairo_FontExtents, "ascent",
                     cr_font_extents_ascent, 0);
+  rb_define_method (rb_cCairo_FontExtents, "set_ascent",
+                    cr_font_extents_set_ascent, 1);
   rb_define_method (rb_cCairo_FontExtents, "descent",
                     cr_font_extents_descent, 0);
+  rb_define_method (rb_cCairo_FontExtents, "set_descent",
+                    cr_font_extents_set_descent, 1);
   rb_define_method (rb_cCairo_FontExtents, "height",
                     cr_font_extents_height, 0);
+  rb_define_method (rb_cCairo_FontExtents, "set_height",
+                    cr_font_extents_set_height, 1);
   rb_define_method (rb_cCairo_FontExtents, "max_x_advance",
                     cr_font_extents_max_x_advance, 0);
+  rb_define_method (rb_cCairo_FontExtents, "set_max_x_advance",
+                    cr_font_extents_set_max_x_advance, 1);
   rb_define_method (rb_cCairo_FontExtents, "max_y_advance",
                     cr_font_extents_max_y_advance, 0);
+  rb_define_method (rb_cCairo_FontExtents, "set_max_y_advance",
+                    cr_font_extents_set_max_y_advance, 1);
 
   rb_define_method (rb_cCairo_FontExtents, "to_s", cr_font_extents_to_s, 0);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_FontExtents);
 }

data/src/rb_cairo_font_face.c

@@ -3,7 +3,7 @@
  * Ruby Cairo Binding
  *
  * $Author: kou $
- * $Date: 2007/05/20 09:25:37 $
+ * $Date: 2008-08-17 06:11:51 $
  *
  * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
  * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
@@ -17,29 +17,87 @@
 #include "rb_cairo_private.h"
 
 VALUE rb_cCairo_FontFace;
+VALUE rb_cCairo_ToyFontFace = Qnil;
+VALUE rb_cCairo_UserFontFace = Qnil;
+VALUE rb_cCairo_UserFontFace_TextToGlyphsData = Qnil;
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static cairo_user_data_key_t ruby_object_key;
+static ID cr_id_call;
+static ID cr_id_new;
+
+static ID cr_id_init;
+static ID cr_id_render_glyph;
+static ID cr_id_text_to_glyphs;
+static ID cr_id_unicode_to_glyph;
+
+static ID cr_id_at_glyphs;
+static ID cr_id_at_clusters;
+static ID cr_id_at_backward;
+static ID cr_id_at_need_glyphs;
+static ID cr_id_at_need_clusters;
+static ID cr_id_at_need_backward;
+#endif
 
 #define _SELF  (RVAL2CRFONTFACE(self))
 
+static inline void
+cr_font_face_check_status (cairo_font_face_t *face)
+{
+  rb_cairo_check_status (cairo_font_face_status (face));
+}
+
 cairo_font_face_t *
 rb_cairo_font_face_from_ruby_object (VALUE obj)
 {
   cairo_font_face_t *face;
+
   if (!rb_cairo__is_kind_of (obj, rb_cCairo_FontFace))
     {
-      rb_raise (rb_eTypeError, "not a cairo font face");
+      rb_raise (rb_eTypeError,
+                "not a cairo font face: %s",
+                rb_cairo__inspect (obj));
     }
   Data_Get_Struct (obj, cairo_font_face_t, face);
+  if (!face)
+    rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
+  cr_font_face_check_status (face);
   return face;
 }
 
+static void
+cr_font_face_free (void *ptr)
+{
+  if (ptr)
+    {
+      cairo_font_face_t *face = ptr;
+      cairo_font_face_destroy (face);
+    }
+}
+
 VALUE
 rb_cairo_font_face_to_ruby_object (cairo_font_face_t *face)
 {
   if (face)
     {
+      VALUE klass;
+
+      switch (cairo_font_face_get_type (face))
+        {
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+        case CAIRO_FONT_TYPE_TOY:
+          klass = rb_cCairo_ToyFontFace;
+          break;
+        case CAIRO_FONT_TYPE_USER:
+          klass = rb_cCairo_UserFontFace;
+          break;
+#endif
+        default:
+          klass = rb_cCairo_FontFace;
+          break;
+        }
       cairo_font_face_reference (face);
-      return Data_Wrap_Struct (rb_cCairo_FontFace, NULL,
-                               cairo_font_face_destroy, face);
+      return Data_Wrap_Struct (klass, NULL, cr_font_face_free, face);
     }
   else
     {
@@ -47,10 +105,594 @@ rb_cairo_font_face_to_ruby_object (cairo_font_face_t *face)
     }
 }
 
+static VALUE
+cr_font_face_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_font_face_free, NULL);
+}
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE
+cr_toy_font_face_initialize (int argc, VALUE *argv, VALUE self)
+{
+  cairo_font_face_t *face;
+  VALUE rb_family, rb_slant, rb_weight;
+  const char *family;
+  cairo_font_slant_t slant;
+  cairo_font_weight_t weight;
+
+  rb_scan_args (argc, argv, "03", &rb_family, &rb_slant, &rb_weight);
+
+  if (NIL_P (rb_family))
+    {
+      family = "";
+    }
+  else if (rb_cairo__is_kind_of (rb_family, rb_cString))
+    {
+      family = RSTRING_PTR (rb_family);
+    }
+  else if (rb_cairo__is_kind_of (rb_family, rb_cSymbol))
+    {
+      family = rb_id2name (SYM2ID (rb_family));
+    }
+  else
+    {
+      rb_raise (rb_eArgError,
+                "family name should be nil, String or Symbol: %s",
+                rb_cairo__inspect (rb_family));
+    }
+
+  if (NIL_P (rb_slant))
+    slant = CAIRO_FONT_SLANT_NORMAL;
+  else
+    slant = RVAL2CRFONTSLANT (rb_slant);
+
+  if (NIL_P (rb_weight))
+    weight = CAIRO_FONT_WEIGHT_NORMAL;
+  else
+    weight = RVAL2CRFONTWEIGHT (rb_weight);
+
+  face = cairo_toy_font_face_create (family, slant, weight);
+  cr_font_face_check_status (face);
+  DATA_PTR (self) = face;
+
+  return Qnil;
+}
+
+static VALUE
+cr_toy_font_face_get_family (VALUE self)
+{
+  return CSTR2RVAL (cairo_toy_font_face_get_family (_SELF));
+}
+
+static VALUE
+cr_toy_font_face_get_slant (VALUE self)
+{
+  return INT2NUM (cairo_toy_font_face_get_slant (_SELF));
+}
+
+static VALUE
+cr_toy_font_face_get_weight (VALUE self)
+{
+  return INT2NUM (cairo_toy_font_face_get_weight (_SELF));
+}
+
+typedef struct cr_user_font_face_invoke_data
+{
+  VALUE receiver;
+  ID method;
+  int argc;
+  VALUE *argv;
+  cairo_status_t *status;
+  VALUE result;
+  cr_callback_func_t after_hook;
+  void *after_hook_data;
+} cr_user_font_face_invoke_data_t;
+
+static VALUE
+cr_user_font_face_invoke_body (VALUE user_data)
+{
+  cr_user_font_face_invoke_data_t *data;
+  VALUE result;
+
+  data = (cr_user_font_face_invoke_data_t *)user_data;
+  result = rb_funcall2 (data->receiver, data->method, data->argc, data->argv);
+  data->result = result;
+  if (data->after_hook)
+    result = data->after_hook(user_data);
+  return result;
+}
+
+static VALUE
+cr_user_font_face_invoke_rescue (VALUE user_data, VALUE exception)
+{
+  cr_user_font_face_invoke_data_t *data;
+
+  data = (cr_user_font_face_invoke_data_t *)user_data;
+  *(data->status) = rb_cairo__exception_to_status (exception);
+
+  if (*(data->status) == -1)
+    rb_exc_raise (exception);
+
+  return Qnil;
+}
+
+static VALUE
+cr_user_font_face_invoke_func (VALUE user_data)
+{
+  return rb_rescue2 (cr_user_font_face_invoke_body, user_data,
+                     cr_user_font_face_invoke_rescue, user_data, rb_eException,
+                     (VALUE)0);
+}
+
+static VALUE
+cr_user_font_face_init_func_after (VALUE user_data)
+{
+  cr_user_font_face_invoke_data_t *data;
+  cairo_font_extents_t *extents;
+
+  data = (cr_user_font_face_invoke_data_t *)user_data;
+  extents = data->after_hook_data;
+
+  *extents = *(RVAL2CRFONTEXTENTS (data->argv[2]));
+
+  return data->result;
+}
+
+static cairo_status_t
+cr_user_font_face_init_func (cairo_scaled_font_t *scaled_font,
+                             cairo_t *cr, cairo_font_extents_t *extents)
+{
+  cairo_status_t status = CAIRO_STATUS_SUCCESS;
+  cairo_font_face_t *face;
+  VALUE self;
+  VALUE receiver = Qnil;
+  ID id_method_name = cr_id_call;
+
+  face = cairo_scaled_font_get_font_face (scaled_font);
+  self = (VALUE)cairo_font_face_get_user_data (face, &ruby_object_key);
+  receiver = rb_ivar_get (self, cr_id_init);
+  if (NIL_P (receiver) && rb_obj_respond_to (self, cr_id_init, Qtrue))
+    {
+      receiver = self;
+      id_method_name = cr_id_init;
+    }
+
+  if (!NIL_P (receiver))
+    {
+      cr_user_font_face_invoke_data_t data;
+      VALUE argv[3];
+
+      argv[0] = CRSCALEDFONT2RVAL (scaled_font);
+      argv[1] = CRCONTEXT2RVAL (cr);
+      argv[2] = CRFONTEXTENTS2RVAL (extents);
+
+      data.receiver = receiver;
+      data.method = id_method_name;
+      data.argc = 3;
+      data.argv = argv;
+      data.status = &status;
+      data.after_hook = cr_user_font_face_init_func_after;
+      data.after_hook_data = extents;
+
+      rb_cairo__invoke_callback (cr_user_font_face_invoke_func, (VALUE)&data);
+    }
+
+  return status;
+}
+
+static VALUE
+cr_user_font_face_render_glyph_func_after (VALUE user_data)
+{
+  cr_user_font_face_invoke_data_t *data;
+  cairo_text_extents_t *extents;
+
+  data = (cr_user_font_face_invoke_data_t *)user_data;
+  extents = data->after_hook_data;
+
+  *extents = *(RVAL2CRTEXTEXTENTS (data->argv[3]));
+
+  return data->result;
+}
+
+static cairo_status_t
+cr_user_font_face_render_glyph_func (cairo_scaled_font_t *scaled_font,
+                                     unsigned long glyph,
+                                     cairo_t *cr,
+                                     cairo_text_extents_t *extents)
+{
+  cairo_status_t status = CAIRO_STATUS_SUCCESS;
+  cairo_font_face_t *face;
+  VALUE self;
+  VALUE receiver = Qnil;
+  ID id_method_name = cr_id_call;
+
+  face = cairo_scaled_font_get_font_face (scaled_font);
+  self = (VALUE)cairo_font_face_get_user_data (face, &ruby_object_key);
+  receiver = rb_ivar_get (self, cr_id_render_glyph);
+  if (NIL_P (receiver) && rb_obj_respond_to (self, cr_id_render_glyph, Qtrue))
+    {
+      receiver = self;
+      id_method_name = cr_id_render_glyph;
+    }
+
+  if (!NIL_P (receiver))
+    {
+      cr_user_font_face_invoke_data_t data;
+      VALUE argv[4];
+
+      argv[0] = CRSCALEDFONT2RVAL (scaled_font);
+      argv[1] = ULONG2NUM (glyph);
+      argv[2] = CRCONTEXT2RVAL (cr);
+      argv[3] = CRTEXTEXTENTS2RVAL (extents);
+
+      data.receiver = receiver;
+      data.method = id_method_name;
+      data.argc = 4;
+      data.argv = argv;
+      data.status = &status;
+      data.after_hook = cr_user_font_face_render_glyph_func_after;
+      data.after_hook_data = extents;
+
+      rb_cairo__invoke_callback (cr_user_font_face_invoke_func, (VALUE)&data);
+    }
+
+  return status;
+}
+
+typedef struct _cr_text_to_glyphs_after_hook_data {
+  VALUE text_to_glyphs_data;
+  cairo_glyph_t **glyphs;
+  int *num_glyphs;
+  cairo_text_cluster_t **clusters;
+  int *num_clusters;
+  cairo_bool_t *backward;
+} cr_text_to_glyphs_after_hook_data_t;
+
+static VALUE
+cr_user_font_face_text_to_glyphs_func_after (VALUE user_data)
+{
+  cr_user_font_face_invoke_data_t *data;
+  cr_text_to_glyphs_after_hook_data_t *after_hook_data;
+  VALUE text_to_glyphs_data;
+
+
+  data = (cr_user_font_face_invoke_data_t *)user_data;
+  after_hook_data = data->after_hook_data;
+  text_to_glyphs_data = after_hook_data->text_to_glyphs_data;
+
+  if (after_hook_data->glyphs)
+    {
+      VALUE rb_glyphs;
+
+      rb_glyphs = rb_ivar_get (text_to_glyphs_data, cr_id_at_glyphs);
+      rb_cairo__glyphs_from_ruby_object (rb_glyphs,
+                                         after_hook_data->glyphs,
+                                         after_hook_data->num_glyphs);
+    }
+
+  if (after_hook_data->clusters)
+    {
+      VALUE rb_clusters;
+
+      rb_clusters = rb_ivar_get (text_to_glyphs_data, cr_id_at_clusters);
+      rb_cairo__text_clusters_from_ruby_object (rb_clusters,
+                                                after_hook_data->clusters,
+                                                after_hook_data->num_clusters);
+    }
+
+  if (after_hook_data->backward)
+    {
+      VALUE rb_backward;
+
+      rb_backward = rb_ivar_get (text_to_glyphs_data, cr_id_at_backward);
+      *(after_hook_data->backward) = RVAL2CBOOL (rb_backward);
+    }
+
+  return data->result;
+}
+
+static cairo_status_t
+cr_user_font_face_text_to_glyphs_func (cairo_scaled_font_t *scaled_font,
+                                       const char *utf8, int utf8_len,
+                                       cairo_glyph_t **glyphs, int *num_glyphs,
+                                       cairo_text_cluster_t **clusters,
+                                       int *num_clusters,
+                                       cairo_bool_t *backward)
+{
+  cairo_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
+  cairo_font_face_t *face;
+  VALUE self;
+  VALUE receiver = Qnil;
+  ID id_method_name = cr_id_call;
+
+  face = cairo_scaled_font_get_font_face (scaled_font);
+  self = (VALUE)cairo_font_face_get_user_data (face, &ruby_object_key);
+  receiver = rb_ivar_get (self, cr_id_text_to_glyphs);
+  if (NIL_P (receiver) && rb_obj_respond_to (self, cr_id_text_to_glyphs, Qtrue))
+    {
+      receiver = self;
+      id_method_name = cr_id_text_to_glyphs;
+    }
+
+  if (NIL_P (receiver))
+    {
+      if (num_glyphs)
+        *num_glyphs = -1;
+    }
+  else
+    {
+      cr_user_font_face_invoke_data_t data;
+      cr_text_to_glyphs_after_hook_data_t after_hook_data;
+      VALUE text_to_glyphs_data;
+      VALUE argv[3];
+
+      argv[0] = CRSCALEDFONT2RVAL (scaled_font);
+      argv[1] = rb_str_new (utf8, utf8_len);
+      text_to_glyphs_data = rb_funcall (rb_cCairo_UserFontFace_TextToGlyphsData,
+                                        cr_id_new,
+                                        3,
+                                        CBOOL2RVAL (glyphs != NULL),
+                                        CBOOL2RVAL (clusters != NULL),
+                                        CBOOL2RVAL (backward != NULL));
+      argv[2] = text_to_glyphs_data;
+
+      data.receiver = receiver;
+      data.method = id_method_name;
+      data.argc = 3;
+      data.argv = argv;
+      data.status = &status;
+      data.after_hook = cr_user_font_face_text_to_glyphs_func_after;
+      data.after_hook_data = &after_hook_data;
+
+      after_hook_data.text_to_glyphs_data = text_to_glyphs_data;
+      after_hook_data.glyphs = glyphs;
+      after_hook_data.num_glyphs = num_glyphs;
+      after_hook_data.clusters = clusters;
+      after_hook_data.num_clusters = num_clusters;
+      after_hook_data.backward = backward;
+
+      rb_cairo__invoke_callback (cr_user_font_face_invoke_func, (VALUE)&data);
+    }
+
+  return status;
+}
+
+static VALUE
+cr_user_font_face_unicode_to_glyph_func_after (VALUE user_data)
+{
+  cr_user_font_face_invoke_data_t *data;
+  unsigned long *glyph_index;
+
+  data = (cr_user_font_face_invoke_data_t *)user_data;
+  glyph_index = data->after_hook_data;
+
+  *glyph_index = NUM2ULONG (data->result);
+
+  return data->result;
+}
+
+static cairo_status_t
+cr_user_font_face_unicode_to_glyph_func (cairo_scaled_font_t *scaled_font,
+                                         unsigned long unicode,
+                                         unsigned long *glyph_index)
+{
+  cairo_status_t status = CAIRO_STATUS_SUCCESS;
+  cairo_font_face_t *face;
+  VALUE self;
+  VALUE receiver = Qnil;
+  ID id_method_name = cr_id_call;
+
+  face = cairo_scaled_font_get_font_face (scaled_font);
+  self = (VALUE)cairo_font_face_get_user_data (face, &ruby_object_key);
+  receiver = rb_ivar_get (self, cr_id_unicode_to_glyph);
+  if (NIL_P (receiver) &&
+      rb_obj_respond_to (self, cr_id_unicode_to_glyph, Qtrue))
+    {
+      receiver = self;
+      id_method_name = cr_id_unicode_to_glyph;
+    }
+
+  if (NIL_P (receiver))
+    {
+      *glyph_index = unicode;
+    }
+  else
+    {
+      cr_user_font_face_invoke_data_t data;
+      VALUE argv[2];
+
+      argv[0] = CRSCALEDFONT2RVAL (scaled_font);
+      argv[1] = ULONG2NUM (unicode);
+
+      data.receiver = receiver;
+      data.method = id_method_name;
+      data.argc = 2;
+      data.argv = argv;
+      data.status = &status;
+      data.after_hook = cr_user_font_face_unicode_to_glyph_func_after;
+      data.after_hook_data = glyph_index;
+
+      rb_cairo__invoke_callback (cr_user_font_face_invoke_func, (VALUE)&data);
+    }
+
+  return status;
+}
+
+
+static VALUE
+cr_user_font_face_initialize (VALUE self)
+{
+  cairo_font_face_t *face;
+
+  face = cairo_user_font_face_create ();
+  cr_font_face_check_status (face);
+
+  cairo_font_face_set_user_data (face, &ruby_object_key, (void *)self, NULL);
+
+  cairo_user_font_face_set_init_func
+    (face, cr_user_font_face_init_func);
+  cairo_user_font_face_set_render_glyph_func
+    (face, cr_user_font_face_render_glyph_func);
+  cairo_user_font_face_set_text_to_glyphs_func
+    (face, cr_user_font_face_text_to_glyphs_func);
+  cairo_user_font_face_set_unicode_to_glyph_func
+    (face, cr_user_font_face_unicode_to_glyph_func);
+
+  rb_ivar_set (self, cr_id_init, Qnil);
+  rb_ivar_set (self, cr_id_render_glyph, Qnil);
+  rb_ivar_set (self, cr_id_text_to_glyphs, Qnil);
+  rb_ivar_set (self, cr_id_unicode_to_glyph, Qnil);
+
+  DATA_PTR (self) = face;
+
+  return Qnil;
+}
+
+static VALUE
+cr_user_font_face_on_init (VALUE self)
+{
+  rb_ivar_set (self, cr_id_init, rb_block_proc ());
+  return self;
+}
+
+static VALUE
+cr_user_font_face_on_render_glyph (VALUE self)
+{
+  rb_ivar_set (self, cr_id_render_glyph, rb_block_proc ());
+  return self;
+}
+
+static VALUE
+cr_user_font_face_on_text_to_glyphs (VALUE self)
+{
+  rb_ivar_set (self, cr_id_text_to_glyphs, rb_block_proc ());
+  return self;
+}
+
+static VALUE
+cr_user_font_face_on_unicode_to_glyph (VALUE self)
+{
+  rb_ivar_set (self, cr_id_unicode_to_glyph, rb_block_proc ());
+  return self;
+}
+
+
+static VALUE
+cr_text_to_glyphs_data_initialize (VALUE self,
+                                   VALUE need_glyphs, VALUE need_clusters,
+                                   VALUE need_backward)
+{
+  rb_ivar_set (self, cr_id_at_glyphs, Qnil);
+  rb_ivar_set (self, cr_id_at_clusters, Qnil);
+  rb_ivar_set (self, cr_id_at_backward, Qfalse);
+  rb_ivar_set (self, cr_id_at_need_glyphs, need_glyphs);
+  rb_ivar_set (self, cr_id_at_need_clusters, need_clusters);
+  rb_ivar_set (self, cr_id_at_need_backward, need_backward);
+
+  return Qnil;
+}
+
+static VALUE
+cr_text_to_glyphs_data_backward_p (VALUE self)
+{
+  return rb_ivar_get (self, cr_id_at_backward);
+}
+
+static VALUE
+cr_text_to_glyphs_data_need_glyphs (VALUE self)
+{
+  return rb_ivar_get (self, cr_id_at_need_glyphs);
+}
+
+static VALUE
+cr_text_to_glyphs_data_need_clusters (VALUE self)
+{
+  return rb_ivar_get (self, cr_id_at_need_clusters);
+}
+
+static VALUE
+cr_text_to_glyphs_data_need_backward (VALUE self)
+{
+  return rb_ivar_get (self, cr_id_at_need_backward);
+}
+#endif
 
 void
 Init_cairo_font (void)
 {
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  cr_id_call = rb_intern ("call");
+  cr_id_new = rb_intern ("new");
+
+  cr_id_init = rb_intern ("init");
+  cr_id_render_glyph = rb_intern ("render_glyph");
+  cr_id_text_to_glyphs = rb_intern ("text_to_glyphs");
+  cr_id_unicode_to_glyph = rb_intern ("unicode_to_glyph");
+
+  cr_id_at_glyphs = rb_intern ("@glyphs");
+  cr_id_at_clusters = rb_intern ("@clusters");
+  cr_id_at_backward = rb_intern ("@backward");
+  cr_id_at_need_glyphs = rb_intern ("@need_glyphs");
+  cr_id_at_need_clusters = rb_intern ("@need_clusters");
+  cr_id_at_need_backward = rb_intern ("@need_backward");
+#endif
+
   rb_cCairo_FontFace =
     rb_define_class_under (rb_mCairo, "FontFace", rb_cObject);
+  rb_define_alloc_func (rb_cCairo_FontFace, cr_font_face_allocate);
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_cCairo_ToyFontFace =
+    rb_define_class_under (rb_mCairo, "ToyFontFace", rb_cCairo_FontFace);
+
+  rb_define_method (rb_cCairo_ToyFontFace, "initialize",
+                    cr_toy_font_face_initialize, -1);
+
+  rb_define_method (rb_cCairo_ToyFontFace, "family",
+                    cr_toy_font_face_get_family, 0);
+  rb_define_method (rb_cCairo_ToyFontFace, "slant",
+                    cr_toy_font_face_get_slant, 0);
+  rb_define_method (rb_cCairo_ToyFontFace, "weight",
+                    cr_toy_font_face_get_weight, 0);
+
+
+  rb_cCairo_UserFontFace =
+    rb_define_class_under (rb_mCairo, "UserFontFace", rb_cCairo_FontFace);
+
+  rb_define_method (rb_cCairo_UserFontFace, "initialize",
+                    cr_user_font_face_initialize, 0);
+
+  rb_define_method (rb_cCairo_UserFontFace, "on_init",
+                    cr_user_font_face_on_init, 0);
+  rb_define_method (rb_cCairo_UserFontFace, "on_render_glyph",
+                    cr_user_font_face_on_render_glyph, 0);
+  rb_define_method (rb_cCairo_UserFontFace, "on_text_to_glyphs",
+                    cr_user_font_face_on_text_to_glyphs, 0);
+  rb_define_method (rb_cCairo_UserFontFace, "on_unicode_to_glyph",
+                    cr_user_font_face_on_unicode_to_glyph, 0);
+
+
+  rb_cCairo_UserFontFace_TextToGlyphsData =
+    rb_define_class_under (rb_cCairo_UserFontFace,
+                           "TextToGlyphsData", rb_cObject);
+  rb_attr (rb_cCairo_UserFontFace_TextToGlyphsData, rb_intern ("glyphs"),
+           CR_TRUE, CR_TRUE, CR_TRUE);
+  rb_attr (rb_cCairo_UserFontFace_TextToGlyphsData, rb_intern ("clusters"),
+           CR_TRUE, CR_TRUE, CR_TRUE);
+  rb_attr (rb_cCairo_UserFontFace_TextToGlyphsData, rb_intern ("backward"),
+           CR_FALSE, CR_TRUE, CR_TRUE);
+
+  rb_define_method (rb_cCairo_UserFontFace_TextToGlyphsData,
+                    "initialize", cr_text_to_glyphs_data_initialize, 3);
+
+  rb_define_method (rb_cCairo_UserFontFace_TextToGlyphsData,
+                    "backward?", cr_text_to_glyphs_data_backward_p, 0);
+  rb_define_method (rb_cCairo_UserFontFace_TextToGlyphsData,
+                    "need_glyphs?", cr_text_to_glyphs_data_need_glyphs, 0);
+  rb_define_method (rb_cCairo_UserFontFace_TextToGlyphsData,
+                    "need_clusters?", cr_text_to_glyphs_data_need_clusters, 0);
+  rb_define_method (rb_cCairo_UserFontFace_TextToGlyphsData,
+                    "need_backward?", cr_text_to_glyphs_data_need_backward, 0);
+#endif
 }