text: /* cairo - a vector graphics library with display and print output
   *
   * Copyright © 2006, 2008 Red Hat, Inc
   *
   * This library is free software; you can redistribute it and/or
   * modify it either under the terms of the GNU Lesser General Public
   * License version 2.1 as published by the Free Software Foundation
   * (the "LGPL") or, at your option, under the terms of the Mozilla
   * Public License Version 1.1 (the "MPL"). If you do not alter this
   * notice, a recipient may use your version of this file under either
   * the MPL or the LGPL.
   *
   * You should have received a copy of the LGPL along with this library
   * in the file COPYING-LGPL-2.1; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
   * You should have received a copy of the MPL along with this library
   * in the file COPYING-MPL-1.1
   *
   * The contents of this file are subject to the Mozilla Public License
   * Version 1.1 (the "License"); you may not use this file except in
   * compliance with the License. You may obtain a copy of the License at
   * http://www.mozilla.org/MPL/
   *
   * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
   * OF ANY KIND, either express or implied. See the LGPL or the MPL for
   * the specific language governing rights and limitations.
   *
   * The Original Code is the cairo graphics library.
   *
   * The Initial Developer of the Original Code is Red Hat, Inc.
   *
   * Contributor(s):
   *      Kristian Høgsberg <krh@redhat.com>
   *      Behdad Esfahbod <behdad@behdad.org>
   */
  
  #include "cairoint.h"
  #include "cairo-user-font-private.h"
  #include "cairo-recording-surface-private.h"
  #include "cairo-analysis-surface-private.h"
  #include "cairo-error-private.h"
  
  /**
   * SECTION:cairo-user-fonts
   * @Title:User Fonts
   * @Short_Description: Font support with font data provided by the user
   * 
   * The user-font feature allows the cairo user to provide drawings for glyphs
   * in a font.  This is most useful in implementing fonts in non-standard
   * formats, like SVG fonts and Flash fonts, but can also be used by games and
   * other application to draw "funky" fonts.
   **/
  
  /**
   * CAIRO_HAS_USER_FONT:
   *
   * Defined if the user font backend is available.
   * This macro can be used to conditionally compile backend-specific code.
   * The user font backend is always built in versions of cairo that support
   * this feature (1.8 and later).
   *
   * Since: 1.8
   **/
  
  typedef struct _cairo_user_scaled_font_methods {
      cairo_user_scaled_font_init_func_t			init;
      cairo_user_scaled_font_render_glyph_func_t		render_glyph;
      cairo_user_scaled_font_unicode_to_glyph_func_t	unicode_to_glyph;
      cairo_user_scaled_font_text_to_glyphs_func_t	text_to_glyphs;
  } cairo_user_scaled_font_methods_t;
  
  typedef struct _cairo_user_font_face {
      cairo_font_face_t	             base;
  
      /* Set to true after first scaled font is created.  At that point,
       * the scaled_font_methods cannot change anymore. */
      cairo_bool_t		     immutable;
  
      cairo_user_scaled_font_methods_t scaled_font_methods;
  } cairo_user_font_face_t;
  
  typedef struct _cairo_user_scaled_font {
      cairo_scaled_font_t  base;
  
      cairo_text_extents_t default_glyph_extents;
  
      /* space to compute extents in, and factors to convert back to user space */
      cairo_matrix_t extent_scale;
      double extent_x_scale;
      double extent_y_scale;
  
      /* multiplier for metrics hinting */
      double snap_x_scale;
      double snap_y_scale;
  
  } cairo_user_scaled_font_t;
  
  /* #cairo_user_scaled_font_t */
  
  static cairo_surface_t *
  _cairo_user_scaled_font_create_recording_surface (const cairo_user_scaled_font_t *scaled_font)
  {
      cairo_content_t content;
  
      content = scaled_font->base.options.antialias == CAIRO_ANTIALIAS_SUBPIXEL ?
  						     CAIRO_CONTENT_COLOR_ALPHA :
  						     CAIRO_CONTENT_ALPHA;
  
      return cairo_recording_surface_create (content, NULL);
  }
  
  
  static cairo_t *
  _cairo_user_scaled_font_create_recording_context (const cairo_user_scaled_font_t *scaled_font,
  						  cairo_surface_t                *recording_surface)
  {
      cairo_t *cr;
  
      cr = cairo_create (recording_surface);
  
      if (!_cairo_matrix_is_scale_0 (&scaled_font->base.scale)) {
          cairo_matrix_t scale;
  	scale = scaled_font->base.scale;
  	scale.x0 = scale.y0 = 0.;
  	cairo_set_matrix (cr, &scale);
      }
  
      cairo_set_font_size (cr, 1.0);
      cairo_set_font_options (cr, &scaled_font->base.options);
      cairo_set_source_rgb (cr, 1., 1., 1.);
  
      return cr;
  }
  
  static cairo_int_status_t
  _cairo_user_scaled_glyph_init (void			 *abstract_font,
  			       cairo_scaled_glyph_t	 *scaled_glyph,
  			       cairo_scaled_glyph_info_t  info)
  {
      cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
      cairo_user_scaled_font_t *scaled_font = abstract_font;
      cairo_surface_t *recording_surface = scaled_glyph->recording_surface;
  
      if (!scaled_glyph->recording_surface) {
  	cairo_user_font_face_t *face =
  	    (cairo_user_font_face_t *) scaled_font->base.font_face;
  	cairo_text_extents_t extents = scaled_font->default_glyph_extents;
  	cairo_t *cr;
  
  	if (!face->scaled_font_methods.render_glyph)
  	    return CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED;
  
  	recording_surface = _cairo_user_scaled_font_create_recording_surface (scaled_font);
  
  	/* special case for 0 rank matrix (as in _cairo_scaled_font_init): empty surface */
          if (!_cairo_matrix_is_scale_0 (&scaled_font->base.scale)) {
  	    cr = _cairo_user_scaled_font_create_recording_context (scaled_font, recording_surface);
  	    status = face->scaled_font_methods.render_glyph ((cairo_scaled_font_t *)scaled_font,
  							     _cairo_scaled_glyph_index(scaled_glyph),
  							     cr, &extents);
  	    if (status == CAIRO_INT_STATUS_SUCCESS)
  	        status = cairo_status (cr);
  
  	    cairo_destroy (cr);
  
  	    if (unlikely (status)) {
  	        cairo_surface_destroy (recording_surface);
  	        return status;
  	    }
  	}
  
  	_cairo_scaled_glyph_set_recording_surface (scaled_glyph,
  						   &scaled_font->base,
  						   recording_surface);
  
  
  	/* set metrics */
  
  	if (extents.width == 0.) {
  	    cairo_box_t bbox;
  	    double x1, y1, x2, y2;
  	    double x_scale, y_scale;
  
  	    /* Compute extents.x/y/width/height from recording_surface,
  	     * in font space.
  	     */
  	    status = _cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface,
  							&bbox,
  							&scaled_font->extent_scale);
  	    if (unlikely (status))
  		return status;
  
  	    _cairo_box_to_doubles (&bbox, &x1, &y1, &x2, &y2);
  
  	    x_scale = scaled_font->extent_x_scale;
  	    y_scale = scaled_font->extent_y_scale;
  	    extents.x_bearing = x1 * x_scale;
  	    extents.y_bearing = y1 * y_scale;
  	    extents.width     = (x2 - x1) * x_scale;
  	    extents.height    = (y2 - y1) * y_scale;
  	}
  
  	if (scaled_font->base.options.hint_metrics != CAIRO_HINT_METRICS_OFF) {
  	    extents.x_advance = _cairo_lround (extents.x_advance / scaled_font->snap_x_scale) * scaled_font->snap_x_scale;
  	    extents.y_advance = _cairo_lround (extents.y_advance / scaled_font->snap_y_scale) * scaled_font->snap_y_scale;
  	}
  
  	_cairo_scaled_glyph_set_metrics (scaled_glyph,
  					 &scaled_font->base,
  					 &extents);
      }
  
      if (info & CAIRO_SCALED_GLYPH_INFO_SURFACE) {
  	cairo_surface_t	*surface;
  	cairo_format_t format;
  	int width, height;
  
  	/* TODO
  	 * extend the glyph cache to support argb glyphs.
  	 * need to figure out the semantics and interaction with subpixel
  	 * rendering first.
  	 */
  
  	width = _cairo_fixed_integer_ceil (scaled_glyph->bbox.p2.x) -
  	  _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.x);
  	height = _cairo_fixed_integer_ceil (scaled_glyph->bbox.p2.y) -
  	  _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.y);
  
  	switch (scaled_font->base.options.antialias) {
  	default:
  	case CAIRO_ANTIALIAS_DEFAULT:
  	case CAIRO_ANTIALIAS_FAST:
  	case CAIRO_ANTIALIAS_GOOD:
  	case CAIRO_ANTIALIAS_GRAY:	format = CAIRO_FORMAT_A8;	break;
  	case CAIRO_ANTIALIAS_NONE:	format = CAIRO_FORMAT_A1;	break;
  	case CAIRO_ANTIALIAS_BEST:
  	case CAIRO_ANTIALIAS_SUBPIXEL:	format = CAIRO_FORMAT_ARGB32;	break;
  	}
  	surface = cairo_image_surface_create (format, width, height);
  
  	cairo_surface_set_device_offset (surface,
  	                                 - _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.x),
  	                                 - _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.y));
  	status = _cairo_recording_surface_replay (recording_surface, surface);
  
  	if (unlikely (status)) {
  	    cairo_surface_destroy(surface);
  	    return status;
  	}
  
  	_cairo_scaled_glyph_set_surface (scaled_glyph,
  					 &scaled_font->base,
  					 (cairo_image_surface_t *) surface);
      }
  
      if (info & CAIRO_SCALED_GLYPH_INFO_PATH) {
  	cairo_path_fixed_t *path = _cairo_path_fixed_create ();
  	if (!path)
  	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  
  	status = _cairo_recording_surface_get_path (recording_surface, path);
  	if (unlikely (status)) {
  	    _cairo_path_fixed_destroy (path);
  	    return status;
  	}
  
  	_cairo_scaled_glyph_set_path (scaled_glyph,
  				      &scaled_font->base,
  				      path);
      }
  
      return status;
  }
  
  static unsigned long
  _cairo_user_ucs4_to_index (void	    *abstract_font,
  			   uint32_t  ucs4)
  {
      cairo_user_scaled_font_t *scaled_font = abstract_font;
      cairo_user_font_face_t *face =
  	(cairo_user_font_face_t *) scaled_font->base.font_face;
      unsigned long glyph = 0;
  
      if (face->scaled_font_methods.unicode_to_glyph) {
  	cairo_status_t status;
  
  	status = face->scaled_font_methods.unicode_to_glyph (&scaled_font->base,
  							     ucs4, &glyph);
  
  	if (status == CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED)
  	    goto not_implemented;
  
  	if (status != CAIRO_STATUS_SUCCESS) {
  	    status = _cairo_scaled_font_set_error (&scaled_font->base, status);
  	    glyph = 0;
  	}
  
      } else {
  not_implemented:
  	glyph = ucs4;
      }
  
      return glyph;
  }
  
  static cairo_int_status_t
  _cairo_user_text_to_glyphs (void		      *abstract_font,
  			    double		       x,
  			    double		       y,
  			    const char		      *utf8,
  			    int			       utf8_len,
  			    cairo_glyph_t	     **glyphs,
  			    int			       *num_glyphs,
  			    cairo_text_cluster_t      **clusters,
  			    int			       *num_clusters,
  			    cairo_text_cluster_flags_t *cluster_flags)
  {
      cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
  
      cairo_user_scaled_font_t *scaled_font = abstract_font;
      cairo_user_font_face_t *face =
  	(cairo_user_font_face_t *) scaled_font->base.font_face;
  
      if (face->scaled_font_methods.text_to_glyphs) {
  	int i;
  	cairo_glyph_t *orig_glyphs = *glyphs;
  	int orig_num_glyphs = *num_glyphs;
  
  	status = face->scaled_font_methods.text_to_glyphs (&scaled_font->base,
  							   utf8, utf8_len,
  							   glyphs, num_glyphs,
  							   clusters, num_clusters, cluster_flags);
  
  	if (status != CAIRO_INT_STATUS_SUCCESS &&
  	    status != CAIRO_INT_STATUS_USER_FONT_NOT_IMPLEMENTED)
  	    return status;
  
  	if (status == CAIRO_INT_STATUS_USER_FONT_NOT_IMPLEMENTED ||
  	    *num_glyphs < 0) {
  	    if (orig_glyphs != *glyphs) {
  		cairo_glyph_free (*glyphs);
  		*glyphs = orig_glyphs;
  	    }
  	    *num_glyphs = orig_num_glyphs;
  	    return CAIRO_INT_STATUS_UNSUPPORTED;
  	}
  
  	/* Convert from font space to user space and add x,y */
  	for (i = 0; i < *num_glyphs; i++) {
  	    double gx = (*glyphs)[i].x;
  	    double gy = (*glyphs)[i].y;
  
  	    cairo_matrix_transform_point (&scaled_font->base.font_matrix,
  					  &gx, &gy);
  
  	    (*glyphs)[i].x = gx + x;
  	    (*glyphs)[i].y = gy + y;
  	}
      }
  
      return status;
  }
  
  static cairo_status_t
  _cairo_user_font_face_scaled_font_create (void                        *abstract_face,
  					  const cairo_matrix_t        *font_matrix,
  					  const cairo_matrix_t        *ctm,
  					  const cairo_font_options_t  *options,
  					  cairo_scaled_font_t        **scaled_font);
  
  static cairo_status_t
  _cairo_user_font_face_create_for_toy (cairo_toy_font_face_t   *toy_face,
  				      cairo_font_face_t      **font_face)
  {
      return _cairo_font_face_twin_create_for_toy (toy_face, font_face);
  }
  
  static const cairo_scaled_font_backend_t _cairo_user_scaled_font_backend = {
      CAIRO_FONT_TYPE_USER,
      NULL,	/* scaled_font_fini */
      _cairo_user_scaled_glyph_init,
      _cairo_user_text_to_glyphs,
      _cairo_user_ucs4_to_index,
      NULL,	/* show_glyphs */
      NULL,	/* load_truetype_table */
      NULL	/* index_to_ucs4 */
  };
  
  /* #cairo_user_font_face_t */
  
  static cairo_status_t
  _cairo_user_font_face_scaled_font_create (void                        *abstract_face,
  					  const cairo_matrix_t        *font_matrix,
  					  const cairo_matrix_t        *ctm,
  					  const cairo_font_options_t  *options,
  					  cairo_scaled_font_t        **scaled_font)
  {
      cairo_status_t status = CAIRO_STATUS_SUCCESS;
      cairo_user_font_face_t *font_face = abstract_face;
      cairo_user_scaled_font_t *user_scaled_font = NULL;
      cairo_font_extents_t font_extents = {1., 0., 1., 1., 0.};
  
      font_face->immutable = TRUE;
  
      user_scaled_font = malloc (sizeof (cairo_user_scaled_font_t));
      if (unlikely (user_scaled_font == NULL))
  	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  
      status = _cairo_scaled_font_init (&user_scaled_font->base,
  				      &font_face->base,
  				      font_matrix, ctm, options,
  				      &_cairo_user_scaled_font_backend);
  
      if (unlikely (status)) {
  	free (user_scaled_font);
  	return status;
      }
  
      /* XXX metrics hinting? */
  
      /* compute a normalized version of font scale matrix to compute
       * extents in.  This is to minimize error caused by the cairo_fixed_t
       * representation. */
      {
  	double fixed_scale, x_scale, y_scale;
  
  	user_scaled_font->extent_scale = user_scaled_font->base.scale_inverse;
  	status = _cairo_matrix_compute_basis_scale_factors (&user_scaled_font->extent_scale,
  						      &x_scale, &y_scale,
  						      1);
  	if (status == CAIRO_STATUS_SUCCESS) {
  
  	    if (x_scale == 0) x_scale = 1.;
  	    if (y_scale == 0) y_scale = 1.;
  
  	    user_scaled_font->snap_x_scale = x_scale;
  	    user_scaled_font->snap_y_scale = y_scale;
  
  	    /* since glyphs are pretty much 1.0x1.0, we can reduce error by
  	     * scaling to a larger square.  say, 1024.x1024. */
  	    fixed_scale = 1024.;
  	    x_scale /= fixed_scale;
  	    y_scale /= fixed_scale;
  
  	    cairo_matrix_scale (&user_scaled_font->extent_scale, 1. / x_scale, 1. / y_scale);
  
  	    user_scaled_font->extent_x_scale = x_scale;
  	    user_scaled_font->extent_y_scale = y_scale;
  	}
      }
  
      if (status == CAIRO_STATUS_SUCCESS &&
  	font_face->scaled_font_methods.init != NULL)
      {
  	/* Lock the scaled_font mutex such that user doesn't accidentally try
           * to use it just yet. */
  	CAIRO_MUTEX_LOCK (user_scaled_font->base.mutex);
  
  	/* Give away fontmap lock such that user-font can use other fonts */
  	status = _cairo_scaled_font_register_placeholder_and_unlock_font_map (&user_scaled_font->base);
  	if (status == CAIRO_STATUS_SUCCESS) {
  	    cairo_surface_t *recording_surface;
  	    cairo_t *cr;
  
  	    recording_surface = _cairo_user_scaled_font_create_recording_surface (user_scaled_font);
  	    cr = _cairo_user_scaled_font_create_recording_context (user_scaled_font, recording_surface);
  	    cairo_surface_destroy (recording_surface);
  
  	    status = font_face->scaled_font_methods.init (&user_scaled_font->base,
  							  cr,
  							  &font_extents);
  
  	    if (status == CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED)
  		status = CAIRO_STATUS_SUCCESS;
  
  	    if (status == CAIRO_STATUS_SUCCESS)
  		status = cairo_status (cr);
  
  	    cairo_destroy (cr);
  
  	    _cairo_scaled_font_unregister_placeholder_and_lock_font_map (&user_scaled_font->base);
  	}
  
  	CAIRO_MUTEX_UNLOCK (user_scaled_font->base.mutex);
      }
  
      if (status == CAIRO_STATUS_SUCCESS)
  	status = _cairo_scaled_font_set_metrics (&user_scaled_font->base, &font_extents);
  
      if (status != CAIRO_STATUS_SUCCESS) {
          _cairo_scaled_font_fini (&user_scaled_font->base);
  	free (user_scaled_font);
      } else {
          user_scaled_font->default_glyph_extents.x_bearing = 0.;
          user_scaled_font->default_glyph_extents.y_bearing = -font_extents.ascent;
          user_scaled_font->default_glyph_extents.width = 0.;
          user_scaled_font->default_glyph_extents.height = font_extents.ascent + font_extents.descent;
          user_scaled_font->default_glyph_extents.x_advance = font_extents.max_x_advance;
          user_scaled_font->default_glyph_extents.y_advance = 0.;
  
  	*scaled_font = &user_scaled_font->base;
      }
  
      return status;
  }
  
  const cairo_font_face_backend_t _cairo_user_font_face_backend = {
      CAIRO_FONT_TYPE_USER,
      _cairo_user_font_face_create_for_toy,
      _cairo_font_face_destroy,
      _cairo_user_font_face_scaled_font_create
  };
  
  
  cairo_bool_t
  _cairo_font_face_is_user (cairo_font_face_t *font_face)
  {
      return font_face->backend == &_cairo_user_font_face_backend;
  }
  
  /* Implement the public interface */
  
  /**
   * cairo_user_font_face_create:
   *
   * Creates a new user font-face.
   *
   * Use the setter functions to associate callbacks with the returned
   * user font.  The only mandatory callback is render_glyph.
   *
   * After the font-face is created, the user can attach arbitrary data
   * (the actual font data) to it using cairo_font_face_set_user_data()
   * and access it from the user-font callbacks by using
   * cairo_scaled_font_get_font_face() followed by
   * cairo_font_face_get_user_data().
   *
   * Return value: a newly created #cairo_font_face_t. Free with
   *  cairo_font_face_destroy() when you are done using it.
   *
   * Since: 1.8
   **/
  cairo_font_face_t * CAIRO_CALLCONV
  cairo_user_font_face_create (void)
  {
      cairo_user_font_face_t *font_face;
  
      font_face = malloc (sizeof (cairo_user_font_face_t));
      if (!font_face) {
  	_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
  	return (cairo_font_face_t *)&_cairo_font_face_nil;
      }
  
      _cairo_font_face_init (&font_face->base, &_cairo_user_font_face_backend);
  
      font_face->immutable = FALSE;
      memset (&font_face->scaled_font_methods, 0, sizeof (font_face->scaled_font_methods));
  
      return &font_face->base;
  }
  slim_hidden_def(cairo_user_font_face_create);
  
  /* User-font method setters */
  
  
  /**
   * cairo_user_font_face_set_init_func:
   * @font_face: A user font face
   * @init_func: The init callback, or %NULL
   *
   * Sets the scaled-font initialization function of a user-font.
   * See #cairo_user_scaled_font_init_func_t for details of how the callback
   * works.
   *
   * The font-face should not be immutable or a %CAIRO_STATUS_USER_FONT_IMMUTABLE
   * error will occur.  A user font-face is immutable as soon as a scaled-font
   * is created from it.
   *
   * Since: 1.8
   **/
  void CAIRO_CALLCONV
  cairo_user_font_face_set_init_func (cairo_font_face_t                  *font_face,
  				    cairo_user_scaled_font_init_func_t  init_func)
  {
      cairo_user_font_face_t *user_font_face;
  
      if (font_face->status)
  	return;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      if (user_font_face->immutable) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_USER_FONT_IMMUTABLE))
  	    return;
      }
      user_font_face->scaled_font_methods.init = init_func;
  }
  slim_hidden_def(cairo_user_font_face_set_init_func);
  
  /**
   * cairo_user_font_face_set_render_glyph_func:
   * @font_face: A user font face
   * @render_glyph_func: The render_glyph callback, or %NULL
   *
   * Sets the glyph rendering function of a user-font.
   * See #cairo_user_scaled_font_render_glyph_func_t for details of how the callback
   * works.
   *
   * The font-face should not be immutable or a %CAIRO_STATUS_USER_FONT_IMMUTABLE
   * error will occur.  A user font-face is immutable as soon as a scaled-font
   * is created from it.
   *
   * The render_glyph callback is the only mandatory callback of a user-font.
   * If the callback is %NULL and a glyph is tried to be rendered using
   * @font_face, a %CAIRO_STATUS_USER_FONT_ERROR will occur.
   *
   * Since: 1.8
   **/
  void CAIRO_CALLCONV
  cairo_user_font_face_set_render_glyph_func (cairo_font_face_t                          *font_face,
  					    cairo_user_scaled_font_render_glyph_func_t  render_glyph_func)
  {
      cairo_user_font_face_t *user_font_face;
  
      if (font_face->status)
  	return;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      if (user_font_face->immutable) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_USER_FONT_IMMUTABLE))
  	    return;
      }
      user_font_face->scaled_font_methods.render_glyph = render_glyph_func;
  }
  slim_hidden_def(cairo_user_font_face_set_render_glyph_func);
  
  /**
   * cairo_user_font_face_set_text_to_glyphs_func:
   * @font_face: A user font face
   * @text_to_glyphs_func: The text_to_glyphs callback, or %NULL
   *
   * Sets th text-to-glyphs conversion function of a user-font.
   * See #cairo_user_scaled_font_text_to_glyphs_func_t for details of how the callback
   * works.
   *
   * The font-face should not be immutable or a %CAIRO_STATUS_USER_FONT_IMMUTABLE
   * error will occur.  A user font-face is immutable as soon as a scaled-font
   * is created from it.
   *
   * Since: 1.8
   **/
  void CAIRO_CALLCONV
  cairo_user_font_face_set_text_to_glyphs_func (cairo_font_face_t                            *font_face,
  					      cairo_user_scaled_font_text_to_glyphs_func_t  text_to_glyphs_func)
  {
      cairo_user_font_face_t *user_font_face;
  
      if (font_face->status)
  	return;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      if (user_font_face->immutable) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_USER_FONT_IMMUTABLE))
  	    return;
      }
      user_font_face->scaled_font_methods.text_to_glyphs = text_to_glyphs_func;
  }
  
  /**
   * cairo_user_font_face_set_unicode_to_glyph_func:
   * @font_face: A user font face
   * @unicode_to_glyph_func: The unicode_to_glyph callback, or %NULL
   *
   * Sets the unicode-to-glyph conversion function of a user-font.
   * See #cairo_user_scaled_font_unicode_to_glyph_func_t for details of how the callback
   * works.
   *
   * The font-face should not be immutable or a %CAIRO_STATUS_USER_FONT_IMMUTABLE
   * error will occur.  A user font-face is immutable as soon as a scaled-font
   * is created from it.
   *
   * Since: 1.8
   **/
  void CAIRO_CALLCONV
  cairo_user_font_face_set_unicode_to_glyph_func (cairo_font_face_t                              *font_face,
  						cairo_user_scaled_font_unicode_to_glyph_func_t  unicode_to_glyph_func)
  {
      cairo_user_font_face_t *user_font_face;
      if (font_face->status)
  	return;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      if (user_font_face->immutable) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_USER_FONT_IMMUTABLE))
  	    return;
      }
      user_font_face->scaled_font_methods.unicode_to_glyph = unicode_to_glyph_func;
  }
  slim_hidden_def(cairo_user_font_face_set_unicode_to_glyph_func);
  
  /* User-font method getters */
  
  /**
   * cairo_user_font_face_get_init_func:
   * @font_face: A user font face
   *
   * Gets the scaled-font initialization function of a user-font.
   *
   * Return value: The init callback of @font_face
   * or %NULL if none set or an error has occurred.
   *
   * Since: 1.8
   **/
  cairo_user_scaled_font_init_func_t CAIRO_CALLCONV
  cairo_user_font_face_get_init_func (cairo_font_face_t *font_face)
  {
      cairo_user_font_face_t *user_font_face;
  
      if (font_face->status)
  	return NULL;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return NULL;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      return user_font_face->scaled_font_methods.init;
  }
  
  /**
   * cairo_user_font_face_get_render_glyph_func:
   * @font_face: A user font face
   *
   * Gets the glyph rendering function of a user-font.
   *
   * Return value: The render_glyph callback of @font_face
   * or %NULL if none set or an error has occurred.
   *
   * Since: 1.8
   **/
  cairo_user_scaled_font_render_glyph_func_t CAIRO_CALLCONV
  cairo_user_font_face_get_render_glyph_func (cairo_font_face_t *font_face)
  {
      cairo_user_font_face_t *user_font_face;
  
      if (font_face->status)
  	return NULL;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return NULL;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      return user_font_face->scaled_font_methods.render_glyph;
  }
  
  /**
   * cairo_user_font_face_get_text_to_glyphs_func:
   * @font_face: A user font face
   *
   * Gets the text-to-glyphs conversion function of a user-font.
   *
   * Return value: The text_to_glyphs callback of @font_face
   * or %NULL if none set or an error occurred.
   *
   * Since: 1.8
   **/
  cairo_user_scaled_font_text_to_glyphs_func_t CAIRO_CALLCONV
  cairo_user_font_face_get_text_to_glyphs_func (cairo_font_face_t *font_face)
  {
      cairo_user_font_face_t *user_font_face;
  
      if (font_face->status)
  	return NULL;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return NULL;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      return user_font_face->scaled_font_methods.text_to_glyphs;
  }
  
  /**
   * cairo_user_font_face_get_unicode_to_glyph_func:
   * @font_face: A user font face
   *
   * Gets the unicode-to-glyph conversion function of a user-font.
   *
   * Return value: The unicode_to_glyph callback of @font_face
   * or %NULL if none set or an error occurred.
   *
   * Since: 1.8
   **/
  cairo_user_scaled_font_unicode_to_glyph_func_t CAIRO_CALLCONV
  cairo_user_font_face_get_unicode_to_glyph_func (cairo_font_face_t *font_face)
  {
      cairo_user_font_face_t *user_font_face;
  
      if (font_face->status)
  	return NULL;
  
      if (! _cairo_font_face_is_user (font_face)) {
  	if (_cairo_font_face_set_error (font_face, CAIRO_STATUS_FONT_TYPE_MISMATCH))
  	    return NULL;
      }
  
      user_font_face = (cairo_user_font_face_t *) font_face;
      return user_font_face->scaled_font_methods.unicode_to_glyph;
  }
  