Up version to 1.7.0.

Fri Sep 24 12:59:22 2004  Owen Taylor  <otaylor@redhat.com>

        * configure.in: Up version to 1.7.0.

        * pango/pango-renderer.[ch] pango/pango.h pango/Makefile.am:
        Add PangoRenderer, a base class that is subclassed to produce
        rendering drivers for different backends and purposes.

        * pango/pangoft2-private.h pango/pangoft2-render.c
        pango/pangoft2.c: Move rendering into pangoft2-render.c,
        use PangoRenderer.

        * pango/pangoft2-fontmap.c pango/pangoft2-private.h: Add
        _pango_ft2_font_map_get_renderer() to retrieve a singleton
        fontmap for the fontmap.

        * pango/pangoxft-render.[ch] pango/pangoxft.c pango/Makefile.am:
        Make Xft rendering use PangoRenderer, add publically
        visible, subclassable PangoXftRenderer.

        * pango/pangoxft-fontmap.c pango/pangoxft-private.h: Add
        _pango_xft_font_map_get_renderer() to retrieve a singleton
        fontmap for the fontmap.

        * examples/xftview.c examples/Makefile.am: Add a test program
        using the Xft backend.

        * docs/*: Update minimally for PangoRenderer.

22 files changed, 3319 insertions, 1117 deletions

diff --git a/ChangeLog b/ChangeLog
index c9da0c57..2dcb4eb4 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,32 @@
+Fri Sep 24 12:59:22 2004  Owen Taylor  <otaylor@redhat.com>
+
+	* configure.in: Up version to 1.7.0.
+
+	* pango/pango-renderer.[ch] pango/pango.h pango/Makefile.am: 
+	Add PangoRenderer, a base class that is subclassed to produce 
+	rendering drivers for different backends and purposes.
+
+	* pango/pangoft2-private.h pango/pangoft2-render.c 
+	pango/pangoft2.c: Move rendering into pangoft2-render.c,
+	use PangoRenderer.
+
+	* pango/pangoft2-fontmap.c pango/pangoft2-private.h: Add
+	_pango_ft2_font_map_get_renderer() to retrieve a singleton
+	fontmap for the fontmap.
+
+	* pango/pangoxft-render.[ch] pango/pangoxft.c pango/Makefile.am: 
+	Make Xft rendering use PangoRenderer, add publically 
+	visible, subclassable PangoXftRenderer.
+
+	* pango/pangoxft-fontmap.c pango/pangoxft-private.h: Add
+	_pango_xft_font_map_get_renderer() to retrieve a singleton
+	fontmap for the fontmap.
+
+	* examples/xftview.c examples/Makefile.am: Add a test program
+	using the Xft backend.
+
+	* docs/*: Update minimally for PangoRenderer.
+
 Wed Sep 22 16:15:40 2004  Owen Taylor  <otaylor@redhat.com>
 
 	* pango/pangoxft-font.c (pango_xft_font_get_glyph_extents): Use
diff --git a/ChangeLog.pre-1-10 b/ChangeLog.pre-1-10
index c9da0c57..2dcb4eb4 100644
--- a/ChangeLog.pre-1-10
+++ b/ChangeLog.pre-1-10
@@ -1,3 +1,32 @@
+Fri Sep 24 12:59:22 2004  Owen Taylor  <otaylor@redhat.com>
+
+	* configure.in: Up version to 1.7.0.
+
+	* pango/pango-renderer.[ch] pango/pango.h pango/Makefile.am: 
+	Add PangoRenderer, a base class that is subclassed to produce 
+	rendering drivers for different backends and purposes.
+
+	* pango/pangoft2-private.h pango/pangoft2-render.c 
+	pango/pangoft2.c: Move rendering into pangoft2-render.c,
+	use PangoRenderer.
+
+	* pango/pangoft2-fontmap.c pango/pangoft2-private.h: Add
+	_pango_ft2_font_map_get_renderer() to retrieve a singleton
+	fontmap for the fontmap.
+
+	* pango/pangoxft-render.[ch] pango/pangoxft.c pango/Makefile.am: 
+	Make Xft rendering use PangoRenderer, add publically 
+	visible, subclassable PangoXftRenderer.
+
+	* pango/pangoxft-fontmap.c pango/pangoxft-private.h: Add
+	_pango_xft_font_map_get_renderer() to retrieve a singleton
+	fontmap for the fontmap.
+
+	* examples/xftview.c examples/Makefile.am: Add a test program
+	using the Xft backend.
+
+	* docs/*: Update minimally for PangoRenderer.
+
 Wed Sep 22 16:15:40 2004  Owen Taylor  <otaylor@redhat.com>
 
 	* pango/pangoxft-font.c (pango_xft_font_get_glyph_extents): Use
diff --git a/ChangeLog.pre-1-8 b/ChangeLog.pre-1-8
index c9da0c57..2dcb4eb4 100644
--- a/ChangeLog.pre-1-8
+++ b/ChangeLog.pre-1-8
@@ -1,3 +1,32 @@
+Fri Sep 24 12:59:22 2004  Owen Taylor  <otaylor@redhat.com>
+
+	* configure.in: Up version to 1.7.0.
+
+	* pango/pango-renderer.[ch] pango/pango.h pango/Makefile.am: 
+	Add PangoRenderer, a base class that is subclassed to produce 
+	rendering drivers for different backends and purposes.
+
+	* pango/pangoft2-private.h pango/pangoft2-render.c 
+	pango/pangoft2.c: Move rendering into pangoft2-render.c,
+	use PangoRenderer.
+
+	* pango/pangoft2-fontmap.c pango/pangoft2-private.h: Add
+	_pango_ft2_font_map_get_renderer() to retrieve a singleton
+	fontmap for the fontmap.
+
+	* pango/pangoxft-render.[ch] pango/pangoxft.c pango/Makefile.am: 
+	Make Xft rendering use PangoRenderer, add publically 
+	visible, subclassable PangoXftRenderer.
+
+	* pango/pangoxft-fontmap.c pango/pangoxft-private.h: Add
+	_pango_xft_font_map_get_renderer() to retrieve a singleton
+	fontmap for the fontmap.
+
+	* examples/xftview.c examples/Makefile.am: Add a test program
+	using the Xft backend.
+
+	* docs/*: Update minimally for PangoRenderer.
+
 Wed Sep 22 16:15:40 2004  Owen Taylor  <otaylor@redhat.com>
 
 	* pango/pangoxft-font.c (pango_xft_font_get_glyph_extents): Use
diff --git a/configure.in b/configure.in
index 2115ff30..5e5f6a34 100644
--- a/configure.in
+++ b/configure.in
@@ -21,7 +21,7 @@ dnl
 
 dnl The triplet 
 m4_define([pango_major_version], [1])
-m4_define([pango_minor_version], [6])
+m4_define([pango_minor_version], [7])
 m4_define([pango_micro_version], [0])
 m4_define([pango_version],
           [pango_major_version.pango_minor_version.pango_micro_version])
diff --git a/docs/pango-sections.txt b/docs/pango-sections.txt
index cae925bd..d0e9c938 100644
--- a/docs/pango-sections.txt
+++ b/docs/pango-sections.txt
@@ -581,6 +581,40 @@ pango_module_register
 </SECTION>
 
 <SECTION>
+<FILE>pango-renderer</FILE>
+PangoRenderer
+PangoRenderPart
+PANGO_TYPE_RENDER_PART
+PangoRendererClass
+<TITLE>PangoRenderer</TITLE>
+pango_renderer_draw_layout
+pango_renderer_draw_layout_line
+pango_renderer_draw_glyphs
+pango_renderer_draw_rectangle
+pango_renderer_draw_error_underline
+pango_renderer_draw_trapezoid
+pango_renderer_draw_glyph
+pango_renderer_activate
+pango_renderer_deactivate
+pango_renderer_part_changed
+pango_renderer_set_color
+pango_renderer_get_color
+pango_renderer_set_matrix
+pango_renderer_get_matrix
+<SUBSECTION Standard>
+PANGO_RENDERER
+PANGO_IS_RENDERER
+PANGO_TYPE_RENDERER
+pango_renderer_get_type
+PANGO_RENDERER_CLASS
+PANGO_IS_RENDERER_CLASS
+PANGO_RENDERER_GET_CLASS
+<SUBSECTION Private>
+pango_render_part_get_type
+PangoRendererPrivate
+</SECTION>
+
+<SECTION>
 <TITLE>X Fonts and Rendering</TITLE>
 <FILE>x-fonts</FILE>
 PANGO_RENDER_TYPE_X
@@ -676,6 +710,8 @@ STRICT
 <SECTION>
 <TITLE>Xft Fonts and Rendering</TITLE>
 <FILE>xft-fonts</FILE>
+PangoXftFont
+PangoXftFontMap
 PANGO_RENDER_TYPE_XFT
 pango_xft_get_context
 pango_xft_get_font_map
@@ -683,8 +719,6 @@ pango_xft_set_default_substitute
 PangoXftSubstituteFunc
 pango_xft_substitute_changed
 pango_xft_shutdown_display
-pango_xft_render
-pango_xft_picture_render
 pango_xft_font_get_font
 pango_xft_font_get_display
 pango_xft_font_has_char
@@ -692,13 +726,35 @@ pango_xft_font_lock_face
 pango_xft_font_unlock_face
 pango_xft_font_get_glyph
 pango_xft_font_get_unknown_glyph
-
+PangoXftRenderer
+PangoXftRendererClass
+pango_xft_renderer_new
+pango_xft_renderer_set_draw
+pango_xft_renderer_set_default_color
+pango_xft_render
+pango_xft_picture_render
+pango_xft_render_transformed
+pango_xft_render_layout_line
+pango_xft_render_layout
 <SUBSECTION Standard>
 PANGO_TYPE_XFT_FONT
+PANGO_XFT_FONT
 PANGO_XFT_IS_FONT
+PANGO_TYPE_XFT_FONT_MAP
+PANGO_XFT_FONT_MAP
+PANGO_XFT_IS_FONT_MAP
+PANGO_XFT_RENDERER
+PANGO_IS_XFT_RENDERER
+PANGO_TYPE_XFT_RENDERER
+PANGO_XFT_RENDERER_CLASS
+PANGO_IS_XFT_RENDERER_CLASS
+PANGO_XFT_RENDERER_GET_CLASS
 
 <SUBSECTION Private>
+PangoXftRendererPrivate
 pango_xft_font_get_type
+pango_xft_font_map_get_type
+pango_xft_renderer_get_type
 </SECTION>
 
 <SECTION>
diff --git a/docs/tmpl/xft-fonts.sgml b/docs/tmpl/xft-fonts.sgml
index ef0b635b..00c7090c 100644
--- a/docs/tmpl/xft-fonts.sgml
+++ b/docs/tmpl/xft-fonts.sgml
@@ -14,6 +14,18 @@ Functions for shape engines to manipulate Xft fonts
 
 </para>
 
+<!-- ##### STRUCT PangoXftFont ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### STRUCT PangoXftFontMap ##### -->
+<para>
+
+</para>
+
+
 <!-- ##### MACRO PANGO_RENDER_TYPE_XFT ##### -->
 <para>
 A string constant that was used to identify shape engines that work
@@ -81,43 +93,35 @@ Function type for doing final config tweaking on prepared FcPatterns.
 @screen: 
 
 
-<!-- ##### FUNCTION pango_xft_render ##### -->
+<!-- ##### FUNCTION pango_xft_font_get_font ##### -->
 <para>
 
 </para>
 
-@draw: 
-@color: 
 @font: 
-@glyphs: 
-@x: 
-@y: 
+@Returns: 
 
 
-<!-- ##### FUNCTION pango_xft_picture_render ##### -->
+<!-- ##### FUNCTION pango_xft_font_get_display ##### -->
 <para>
 
 </para>
 
-@display: 
-@src_picture: 
-@dest_picture: 
 @font: 
-@glyphs: 
-@x: 
-@y: 
+@Returns: 
 
 
-<!-- ##### FUNCTION pango_xft_font_get_font ##### -->
+<!-- ##### FUNCTION pango_xft_font_has_char ##### -->
 <para>
 
 </para>
 
 @font: 
+@wc: 
 @Returns: 
 
 
-<!-- ##### FUNCTION pango_xft_font_get_display ##### -->
+<!-- ##### FUNCTION pango_xft_font_lock_face ##### -->
 <para>
 
 </para>
@@ -126,7 +130,15 @@ Function type for doing final config tweaking on prepared FcPatterns.
 @Returns: 
 
 
-<!-- ##### FUNCTION pango_xft_font_has_char ##### -->
+<!-- ##### FUNCTION pango_xft_font_unlock_face ##### -->
+<para>
+
+</para>
+
+@font: 
+
+
+<!-- ##### FUNCTION pango_xft_font_get_glyph ##### -->
 <para>
 
 </para>
@@ -136,40 +148,120 @@ Function type for doing final config tweaking on prepared FcPatterns.
 @Returns: 
 
 
-<!-- ##### FUNCTION pango_xft_font_lock_face ##### -->
+<!-- ##### FUNCTION pango_xft_font_get_unknown_glyph ##### -->
 <para>
 
 </para>
 
 @font: 
+@wc: 
 @Returns: 
 
 
-<!-- ##### FUNCTION pango_xft_font_unlock_face ##### -->
+<!-- ##### STRUCT PangoXftRenderer ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### STRUCT PangoXftRendererClass ##### -->
+<para>
+
+</para>
+
+@composite_trapezoids: 
+@composite_glyphs: 
+
+<!-- ##### FUNCTION pango_xft_renderer_new ##### -->
+<para>
+
+</para>
+
+@display: 
+@screen: 
+@Returns: 
+
+
+<!-- ##### FUNCTION pango_xft_renderer_set_draw ##### -->
+<para>
+
+</para>
+
+@xftrenderer: 
+@draw: 
+
+
+<!-- ##### FUNCTION pango_xft_renderer_set_default_color ##### -->
 <para>
 
 </para>
 
+@xftrenderer: 
+@default_color: 
+
+
+<!-- ##### FUNCTION pango_xft_render ##### -->
+<para>
+
+</para>
+
+@draw: 
+@color: 
 @font: 
+@glyphs: 
+@x: 
+@y: 
 
 
-<!-- ##### FUNCTION pango_xft_font_get_glyph ##### -->
+<!-- ##### FUNCTION pango_xft_picture_render ##### -->
 <para>
 
 </para>
 
+@display: 
+@src_picture: 
+@dest_picture: 
 @font: 
-@wc: 
-@Returns: 
+@glyphs: 
+@x: 
+@y: 
 
 
-<!-- ##### FUNCTION pango_xft_font_get_unknown_glyph ##### -->
+<!-- ##### FUNCTION pango_xft_render_transformed ##### -->
 <para>
 
 </para>
 
+@draw: 
+@color: 
+@matrix: 
 @font: 
-@wc: 
-@Returns: 
+@glyphs: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION pango_xft_render_layout_line ##### -->
+<para>
+
+</para>
+
+@draw: 
+@color: 
+@line: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION pango_xft_render_layout ##### -->
+<para>
+
+</para>
+
+@draw: 
+@color: 
+@layout: 
+@x: 
+@y: 
 
 
diff --git a/examples/Makefile.am b/examples/Makefile.am
index e5834148..2286cc71 100644
--- a/examples/Makefile.am
+++ b/examples/Makefile.am
@@ -35,6 +35,23 @@ pangoft2topgm_LDADD =					\
 	$(FREETYPE_LIBS)
 ###################################################
 
+###################################################
+if HAVE_XFT
+noinst_PROGRAMS += pango-xftview
+endif
+
+pango_xftview_SOURCES =				\
+	xftview.c				\
+	renderdemo.c				\
+	argcontext.c				\
+	argcontext.h
+pango_xftview_LDADD =					\
+	../pango/libpango-$(PANGO_API_VERSION).la	\
+	../pango/libpangoft2-$(PANGO_API_VERSION).la	\
+	../pango/libpangoxft-$(PANGO_API_VERSION).la	\
+	 $(XFT_LIBS)
+###################################################
+
 if CROSS_COMPILING
 else
 all-local: pango.modules
diff --git a/examples/xftview.c b/examples/xftview.c
new file mode 100644
index 00000000..0b95e2f9
--- /dev/null
+++ b/examples/xftview.c
@@ -0,0 +1,142 @@
+/* Pango
+ * pangoft2topgm.c: Example program to view a UTF-8 encoding file
+ *                  using Pango to render result.
+ *
+ * Copyright (C) 1999,2004 Red Hat, Inc.
+ * Copyright (C) 2001 Sun Microsystems
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "renderdemo.h"
+
+#include <pango/pangoxft.h>
+
+static Region update_region = NULL;
+static XftDraw *draw;
+static PangoContext *context;
+
+static void
+xft_render (PangoLayout *layout,
+	    int          x,
+	    int          y,
+	    gpointer     data)
+{
+  XftColor color;
+
+  color.color.red = 0x0;
+  color.color.green = 0x0;
+  color.color.blue = 0x0;
+  color.color.alpha = 0xffff;
+
+  pango_xft_render_layout (draw, &color, layout, x, y);
+}
+
+void
+update ()
+{
+  XRectangle area;
+  XftColor color;
+
+  XClipBox (update_region, &area);
+  XftDrawSetClip (draw, update_region);
+  XDestroyRegion (update_region);
+  update_region = NULL;
+
+  color.color.red = 0xffff;
+  color.color.blue = 0xffff;
+  color.color.green = 0xffff;
+  color.color.alpha = 0xffff;
+
+  XftDrawRect (draw, &color,
+	       area.x, area.y, area.width, area.height);
+
+  do_output (context, xft_render, draw, NULL, NULL);
+}
+
+void
+expose (XExposeEvent *xev)
+{
+  XRectangle area;
+  
+  if (!update_region)
+    update_region = XCreateRegion ();
+
+  area.x = xev->x;
+  area.y = xev->y;
+  area.width = xev->width;
+  area.height = xev->height;
+
+  XUnionRectWithRegion (&area, update_region, update_region);
+}
+
+int main (int argc, char **argv)
+{
+  Display *display;
+  int screen;
+  Window window;
+  XEvent xev;
+  unsigned long bg;
+  int width, height;
+  
+  g_type_init();
+
+  XftInit (NULL);
+  
+  parse_options (argc, argv);
+
+  display = XOpenDisplay (NULL);
+  if (!display)
+    fail ("Cannot open display %s\n", XDisplayName (NULL));
+
+  screen = DefaultScreen (display);
+  bg = WhitePixel (display, screen);
+
+  context = pango_xft_get_context (display, screen);
+  do_output (context, NULL, NULL, &width, &height);
+
+  window = XCreateSimpleWindow (display, DefaultRootWindow (display),
+				0, 0, width, height, 0,
+				bg, bg);
+  XSelectInput (display, window, ExposureMask);
+  
+  XMapWindow (display, window);
+  draw = XftDrawCreate (display, window,
+			DefaultVisual (display, screen),
+			DefaultColormap (display, screen));
+  XmbSetWMProperties (display, window,
+		      get_options_string (),
+		      NULL, NULL, 0, NULL, NULL, NULL);
+
+  while (1)
+    {
+      if (!XPending (display) && update_region)
+	update ();
+	
+      XNextEvent (display, &xev);
+      if (xev.xany.type == Expose)
+	{
+	  expose (&xev.xexpose);
+	}
+    }
+  
+  return 0;
+}
diff --git a/pango/Makefile.am b/pango/Makefile.am
index ee458a27..9dbf6308 100644
--- a/pango/Makefile.am
+++ b/pango/Makefile.am
@@ -77,6 +77,7 @@ libpango_1_0_la_SOURCES =      \
 	pango-layout.c	       \
 	pango-layout-private.h	       \
 	pango-markup.c	       \
+	pango-renderer.c       \
 	pango-script.c	       \
 	pango-script-lang-table.h \
 	pango-script-table.h   \
@@ -101,6 +102,7 @@ pango_headers =		   \
 	pango-item.h	   \
 	pango-layout.h	   \
 	pango-modules.h	   \
+	pango-renderer.h   \
 	pango-script.h	   \
 	pango-tabs.h	   \
 	pango-types.h	   \
@@ -195,7 +197,7 @@ pangoft2-win32res.lo: pangoft2.rc
 # ------------------- libpangoxft -------------------
 
 if HAVE_XFT
-pangoinclude_HEADERS += pangoxft.h pango-ot.h
+pangoinclude_HEADERS += pangoxft.h pangoxft-render.h pango-ot.h
 lib_LTLIBRARIES += libpangoxft-1.0.la
 endif
 
@@ -206,7 +208,8 @@ libpangoxft_1_0_la_DEPENDENCIES = libpangoft2-$(PANGO_API_VERSION).la libpango-$
 libpangoxft_1_0_la_SOURCES =   	\
 	pangoxft-font.c		\
 	pangoxft-fontmap.c      \
-	pangoxft-private.h
+	pangoxft-private.h	\
+	pangoxft-render.c
 
 
 # ------------------- libpangowin32 -------------------
diff --git a/pango/pango-renderer.c b/pango/pango-renderer.c
new file mode 100644
index 00000000..620685d1
--- /dev/null
+++ b/pango/pango-renderer.c
@@ -0,0 +1,1207 @@
+/* Pango
+ * pango-renderer.h: Base class for rendering
+ *
+ * Copyright (C) 2004 Red Hat, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+
+#include "pango-renderer.h"
+
+#define N_RENDER_PARTS 4
+
+#define IS_VALID_PART(part) ((guint)part < N_RENDER_PARTS)
+
+typedef struct _LineState LineState;
+typedef struct _Point Point;
+
+struct _Point
+{
+  double x, y;
+};
+
+struct _LineState
+{
+  PangoUnderline underline;
+  PangoRectangle underline_rect;
+  
+  gboolean strikethrough;
+  PangoRectangle strikethrough_rect;
+
+  int logical_rect_end;
+};
+
+struct _PangoRendererPrivate
+{
+  PangoColor color[N_RENDER_PARTS];
+  gboolean color_set[N_RENDER_PARTS];
+
+  LineState *line_state;
+};
+
+static void pango_renderer_finalize                     (GObject          *gobject);
+static void pango_renderer_default_draw_glyphs          (PangoRenderer    *renderer,
+							 PangoFont        *font,
+							 PangoGlyphString *glyphs,
+							 int               x,
+							 int               y);
+static void pango_renderer_default_draw_rectangle       (PangoRenderer    *renderer,
+							 PangoRenderPart   part,
+							 int               x,
+							 int               y,
+							 int               width,
+							 int               height);
+static void pango_renderer_default_draw_error_underline (PangoRenderer    *renderer,
+							 int               x,
+							 int               y,
+							 int               width,
+							 int               height);
+static void pango_renderer_default_prepare_run          (PangoRenderer    *renderer,
+							 PangoLayoutRun   *run);
+
+static void pango_renderer_prepare_run (PangoRenderer  *renderer,
+					PangoLayoutRun *run);
+
+static void
+to_device (PangoMatrix *matrix,
+	   double       x,
+	   double       y,
+	   Point       *result)
+{
+  if (matrix)
+    {
+      result->x = (x * matrix->xx + y * matrix->xy) / PANGO_SCALE + matrix->x0;
+      result->y = (x * matrix->yx + y * matrix->yy) / PANGO_SCALE + matrix->y0;
+    }
+  else
+    {
+      result->x = x / PANGO_SCALE;
+      result->y = y / PANGO_SCALE;
+    }
+}
+
+G_DEFINE_ABSTRACT_TYPE (PangoRenderer, pango_renderer, G_TYPE_OBJECT)
+
+static void
+pango_renderer_class_init (PangoRendererClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  
+  klass->draw_glyphs = pango_renderer_default_draw_glyphs;
+  klass->draw_rectangle = pango_renderer_default_draw_rectangle;
+  klass->draw_error_underline = pango_renderer_default_draw_error_underline;
+  klass->prepare_run = pango_renderer_default_prepare_run;
+
+  gobject_class->finalize = pango_renderer_finalize;
+
+  g_type_class_add_private (gobject_class, sizeof (PangoRendererPrivate));
+}
+
+static void
+pango_renderer_init (PangoRenderer *renderer)
+{
+  renderer->priv = G_TYPE_INSTANCE_GET_PRIVATE (renderer,
+						PANGO_TYPE_RENDERER,
+						PangoRendererPrivate);
+  renderer->matrix = NULL;
+}
+
+static void
+pango_renderer_finalize (GObject *gobject)
+{
+  PangoRenderer *renderer = PANGO_RENDERER (gobject);
+  
+  if (renderer->matrix)
+    pango_matrix_free (renderer->matrix);
+}
+
+/**
+ * pango_renderer_draw_layout:
+ * @renderer: a #PangoRenderer
+ * @layout: a #PangoLayout
+ * @x: x position of left edge of baseline, in user space coordinates
+ *   in Pango units.
+ * @y: x position of left edge of baseline, in user space coordinates
+ *    in Pango units.
+ *
+ * Draws @layout with the specified #PangoRenderer.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_draw_layout (PangoRenderer    *renderer,
+			    PangoLayout      *layout,
+			    int               x,
+			    int               y)
+{
+  PangoLayoutIter *iter;
+  
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  g_return_if_fail (PANGO_IS_LAYOUT (layout));
+
+  /* We only change the matrix if the renderer isn't already
+   * active.
+   */
+  if (!renderer->active_count)
+    {
+      PangoContext *context = pango_layout_get_context (layout);
+      pango_renderer_set_matrix (renderer,
+				 pango_context_get_matrix (context));
+    }
+  
+  pango_renderer_activate (renderer);
+
+  iter = pango_layout_get_iter (layout);
+
+  do
+    {
+      PangoRectangle   logical_rect;
+      PangoLayoutLine *line;
+      int              baseline;
+      
+      line = pango_layout_iter_get_line (iter);
+      
+      pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
+      baseline = pango_layout_iter_get_baseline (iter);
+
+      pango_renderer_draw_layout_line (renderer,
+				       line,
+				       x + logical_rect.x,
+				       y + baseline);
+    }
+  while (pango_layout_iter_next_line (iter));
+
+  pango_layout_iter_free (iter);
+  
+  pango_renderer_deactivate (renderer);
+}
+
+static void
+draw_underline (PangoRenderer *renderer,
+		LineState     *state)
+{
+  PangoRectangle *rect = &state->underline_rect;
+  
+  switch (state->underline)
+    {
+    case PANGO_UNDERLINE_NONE:
+      break;
+    case PANGO_UNDERLINE_DOUBLE:
+      pango_renderer_draw_rectangle (renderer,
+				     PANGO_RENDER_PART_UNDERLINE,
+				     rect->x,
+				     rect->y + 2 * rect->height,
+				     rect->width,
+				     rect->height);
+      /* Fall through */
+    case PANGO_UNDERLINE_SINGLE:
+    case PANGO_UNDERLINE_LOW:
+      pango_renderer_draw_rectangle (renderer,
+				     PANGO_RENDER_PART_UNDERLINE,
+				     rect->x,
+				     rect->y,
+				     rect->width,
+				     rect->height);
+      break;
+    case PANGO_UNDERLINE_ERROR:
+      pango_renderer_draw_error_underline (renderer,
+					   rect->x,
+					   rect->y,
+					   rect->width,
+					   3 * rect->height);
+      break;
+    }
+
+  state->underline = PANGO_UNDERLINE_NONE;
+}
+
+static void
+draw_strikethrough (PangoRenderer *renderer,
+		    LineState     *state)
+{
+  PangoRectangle *rect = &state->strikethrough_rect;
+
+  if (state->strikethrough)
+    pango_renderer_draw_rectangle (renderer,
+				   PANGO_RENDER_PART_STRIKETHROUGH,
+				   rect->x,
+				   rect->y,
+				   rect->width,
+				   rect->height);
+
+  state->strikethrough = FALSE;
+}
+
+static void
+handle_line_state_change (PangoRenderer  *renderer,
+			  PangoRenderPart part)
+{
+  LineState *state = renderer->priv->line_state;
+  if (!state)
+    return;
+    
+  if (part == PANGO_RENDER_PART_UNDERLINE &&
+      state->underline != PANGO_UNDERLINE_NONE)
+    {
+      PangoRectangle *rect = &state->underline_rect;
+      
+      rect->width = state->logical_rect_end - rect->x;
+      draw_underline (renderer, state);
+      state->underline = renderer->underline;
+      rect->x = state->logical_rect_end;
+    }
+
+  if (part == PANGO_RENDER_PART_STRIKETHROUGH &&
+      state->strikethrough)
+    {
+      PangoRectangle *rect = &state->strikethrough_rect;
+      
+      rect->width = state->logical_rect_end - rect->x;
+      draw_underline (renderer, state);
+      state->underline = renderer->underline;
+      rect->x = state->logical_rect_end;
+    }
+}
+
+static void
+add_underline (PangoRenderer    *renderer,
+	       LineState        *state,
+	       PangoFontMetrics *metrics, /* NULL if no underline */
+	       int               base_x,
+	       int               base_y,
+	       PangoRectangle   *ink_rect,
+	       PangoRectangle   *logical_rect)
+{
+  if (renderer->underline == PANGO_UNDERLINE_NONE)
+    {
+      draw_underline (renderer, state);
+    }
+  else
+    {
+      PangoRectangle *current_rect = &state->underline_rect;
+      PangoRectangle new_rect;
+      
+      int underline_thickness = pango_font_metrics_get_underline_thickness (metrics);
+      int underline_position = pango_font_metrics_get_underline_position (metrics);
+
+      new_rect.x = base_x + ink_rect->x;
+      new_rect.width = ink_rect->width;
+      new_rect.height = underline_thickness;
+      
+      switch (renderer->underline)
+	{
+	case PANGO_UNDERLINE_NONE:
+	  g_assert_not_reached ();
+	  break;
+	case PANGO_UNDERLINE_SINGLE:
+	case PANGO_UNDERLINE_DOUBLE:
+	case PANGO_UNDERLINE_ERROR:
+	  new_rect.y = base_y - underline_position;
+	  break;
+	case PANGO_UNDERLINE_LOW:
+	  new_rect.y = base_y + ink_rect->y + ink_rect->height + underline_thickness;
+	  break;
+	}
+
+      if (renderer->underline == state->underline &&
+	  new_rect.y == current_rect->y &&
+	  new_rect.height == current_rect->height)
+	{
+	  current_rect->y = new_rect.y;
+	  current_rect->width = new_rect.x + new_rect.width - current_rect->x;
+	  current_rect->height = new_rect.height;
+	}
+      else
+	{
+	  draw_underline (renderer, state);
+
+	  *current_rect = new_rect;
+	  state->underline = renderer->underline;
+	}
+    }
+}
+
+static void
+add_strikethrough (PangoRenderer    *renderer,
+		   LineState        *state,
+		   PangoFontMetrics *metrics, /* NULL if no strikethrough */
+		   int               base_x,
+		   int               base_y,
+		   PangoRectangle   *ink_rect,
+		   PangoRectangle   *logical_rect)
+{
+  if (!renderer->strikethrough)
+    {
+      draw_strikethrough (renderer, state);
+    }
+  else
+    {
+      PangoRectangle *current_rect = &state->strikethrough_rect;
+      PangoRectangle new_rect;
+      
+      int strikethrough_thickness = pango_font_metrics_get_strikethrough_thickness (metrics);
+      int strikethrough_position = pango_font_metrics_get_strikethrough_position (metrics);
+
+      new_rect.x = base_x + ink_rect->x;
+      new_rect.width = ink_rect->width;
+      new_rect.y = base_y - strikethrough_position;
+      new_rect.height = strikethrough_thickness;
+      
+      if (state->strikethrough &&
+	  new_rect.y == current_rect->y &&
+	  new_rect.height == current_rect->height)
+	{
+	  current_rect->y = new_rect.y;
+	  current_rect->width = new_rect.x + new_rect.width - current_rect->x;
+	  current_rect->height = new_rect.height;
+	}
+      else
+	{
+	  draw_strikethrough (renderer, state);
+
+	  *current_rect = new_rect;
+	  state->strikethrough = TRUE;
+	}
+    }
+}
+
+static void
+get_item_properties (PangoItem      *item,
+		     gint           *rise,
+		     gboolean       *shape_set,
+		     PangoRectangle *ink_rect,
+		     PangoRectangle *logical_rect)
+{
+  GSList *l;
+
+  if (rise)
+    *rise = 0;
+
+  if (shape_set)
+    *shape_set = FALSE;
+
+  for (l = item->analysis.extra_attrs; l; l = l->next)
+    {
+      PangoAttribute *attr = l->data;
+
+      switch (attr->klass->type)
+	{
+	case PANGO_ATTR_SHAPE:
+	  if (shape_set)
+	    *shape_set = TRUE;
+	  if (logical_rect)
+	    *logical_rect = ((PangoAttrShape *)attr)->logical_rect;
+	  if (ink_rect)
+	    *ink_rect = ((PangoAttrShape *)attr)->ink_rect;
+	  break;
+
+        case PANGO_ATTR_RISE:
+          if (rise)
+            *rise = ((PangoAttrInt *)attr)->value;
+          break;
+
+	default:
+	  break;
+	}
+    }
+}
+
+/**
+ * pango_renderer_draw_layout_line:
+ * @renderer: a #PangoRenderer
+ * @line: a #PangoLayoutLine
+ * @x: x position of left edge of baseline, in user space coordinates
+ *   in Pango units.
+ * @y: x position of left edge of baseline, in user space coordinates
+ *    in Pango units.
+ *
+ * Draws @line with the specified #PangoRenderer.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_draw_layout_line (PangoRenderer    *renderer,
+				 PangoLayoutLine  *line,
+				 int               x,
+				 int               y)
+{
+  int x_off = 0;
+  LineState state;
+  GSList *l;
+  gboolean got_overall = FALSE;
+  PangoRectangle overall_rect;
+  
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+
+  /* We only change the matrix if the renderer isn't already
+   * active.
+   */
+  if (!renderer->active_count)
+    {
+      PangoContext *context = pango_layout_get_context (line->layout);
+      pango_renderer_set_matrix (renderer,
+				 pango_context_get_matrix (context));
+    }
+
+  pango_renderer_activate (renderer);
+
+  renderer->priv->line_state = &state;
+
+  state.underline = PANGO_UNDERLINE_NONE;
+  state.strikethrough = FALSE;
+
+  for (l = line->runs; l; l = l->next)
+    {
+      PangoFontMetrics *metrics;
+      gint rise;
+      PangoLayoutRun *run = l->data;
+      PangoRectangle logical_rect;
+      PangoRectangle ink_rect;
+      gboolean shape_set;
+
+      pango_renderer_prepare_run (renderer, run);
+      
+      get_item_properties (run->item,
+			   &rise,
+			   &shape_set, &ink_rect, &logical_rect);
+
+      if (!shape_set)
+	{
+	  if (renderer->underline != PANGO_UNDERLINE_NONE ||
+	      renderer->strikethrough)
+	    pango_glyph_string_extents (run->glyphs, run->item->analysis.font,
+					&ink_rect, &logical_rect);
+	  else
+	    pango_glyph_string_extents (run->glyphs, run->item->analysis.font,
+					NULL, &logical_rect);
+	}
+
+      state.logical_rect_end = x_off + logical_rect.x + logical_rect.width;
+
+      if (renderer->priv->color_set[PANGO_RENDER_PART_BACKGROUND])
+	{
+	  if (!got_overall)
+	    {
+	      pango_layout_line_get_extents (line, NULL, &overall_rect);
+	      got_overall = TRUE;
+	    }
+	  
+	  pango_renderer_draw_rectangle (renderer,
+					 PANGO_RENDER_PART_BACKGROUND,
+					 x + x_off + logical_rect.x,
+					 y - rise + overall_rect.y,
+					 logical_rect.width,
+					 overall_rect.height);
+	}
+
+      if (!shape_set)
+	{
+	  pango_renderer_draw_glyphs (renderer,
+				      run->item->analysis.font, run->glyphs,
+				      x + x_off, y - rise);
+	}
+#if 0      
+      else
+	{
+	  pango_renderer_draw_shaped (renderer,
+				      x + x_off, y - rise);
+	}
+#endif      
+
+      if (renderer->underline != PANGO_UNDERLINE_NONE ||
+	  renderer->strikethrough)
+	{
+	  metrics = pango_font_get_metrics (run->item->analysis.font,
+					    run->item->analysis.language);
+	  
+	  if (renderer->underline != PANGO_UNDERLINE_NONE)
+	    add_underline (renderer, &state,metrics,
+			   x + x_off, y - rise,
+			   &ink_rect, &logical_rect);
+	  
+	  if (renderer->strikethrough)
+	    add_strikethrough (renderer, &state, metrics,
+			       x + x_off, y - rise,
+			       &ink_rect, &logical_rect);
+	  
+	  pango_font_metrics_unref (metrics);
+	}
+
+      x_off += logical_rect.width;
+    }
+
+  /* Finish off any remaining underlines
+   */
+  draw_underline (renderer, &state);
+  draw_strikethrough (renderer, &state);
+
+  pango_renderer_deactivate (renderer);
+
+}
+
+/**
+ * pango_renderer_draw_glyphs:
+ * @renderer: a #PangoRenderer
+ * @font: a #PangoFont
+ * @glyphs: a #PangoGlyphString
+ * @x: x position of left edge of baseline, in user space coordinates
+ *   in Pango units.
+ * @y: x position of left edge of baseline, in user space coordinates
+ *    in Pango units.
+ *
+ * Draws the glyphs in @glyphs with the specified #PangoRenderer.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_draw_glyphs (PangoRenderer    *renderer,
+			    PangoFont        *font,
+			    PangoGlyphString *glyphs,
+			    int               x,
+			    int               y)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  
+  PANGO_RENDERER_GET_CLASS (renderer)->draw_glyphs (renderer, font, glyphs, x, y);
+}
+
+static void
+pango_renderer_default_draw_glyphs (PangoRenderer    *renderer,
+				    PangoFont        *font,
+				    PangoGlyphString *glyphs,
+				    int               x,
+				    int               y)
+{
+  int i;
+  int x_position = 0;
+
+  for (i = 0; i < glyphs->num_glyphs; i++)
+    {
+      PangoGlyphInfo *gi = &glyphs->glyphs[i];
+      Point p;
+      
+      to_device (renderer->matrix,
+		 x + x_position + gi->geometry.x_offset,
+		 y +              gi->geometry.y_offset,
+		 &p);
+
+      pango_renderer_draw_glyph (renderer, font, gi->glyph, p.x, p.y);
+
+      x_position += gi->geometry.width;
+    }
+}
+
+/**
+ * pango_renderer_draw_rectangle:
+ * @renderer: a #PangoRenderer
+ * @part: type of object this rectangle is part of
+ * @x: x position at which to draw rectangle, in user space coordinates in Pango units
+ * @y: y position at which to draw rectangle, in user space coordinates in Pango units
+ * @width: width of rectangle in PangoUnits in user space coordinates
+ * @height: height of rectangle in PangoUnits in user space coordinates
+ *
+ * Draws an axis-aligned rectangle in user space coordinates with the
+ * specified #PangoRenderer.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_draw_rectangle (PangoRenderer   *renderer,
+			       PangoRenderPart  part,
+			       int              x,
+			       int              y,
+			       int              width,
+			       int              height)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  g_return_if_fail (IS_VALID_PART (part));
+  
+  PANGO_RENDERER_GET_CLASS (renderer)->draw_rectangle (renderer, part, x, y, width, height);
+}
+
+static int
+compare_points (const void *a,
+		const void *b)
+{
+  const Point *pa = a;
+  const Point *pb = b;
+
+  if (pa->y < pb->y)
+    return -1;
+  else if (pa->y > pb->y)
+    return 1;
+  else if (pa->x < pb->x)
+    return -1;
+  else if (pa->x > pb->x)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+draw_rectangle (PangoRenderer   *renderer,
+		PangoMatrix     *matrix,
+		PangoRenderPart  part,
+		int              x,
+		int              y,
+		int              width,
+		int              height)
+{
+  Point points[4];
+
+  /* Convert the points to device coordinates, and sort
+   * in ascending Y order. (Ordering by X for ties)
+   */
+  to_device (matrix, x, y, &points[0]);
+  to_device (matrix, x + width, y, &points[1]);
+  to_device (matrix, x, y + height, &points[2]);
+  to_device (matrix, x + width, y + height, &points[3]);
+
+  qsort (points, 4, sizeof (Point), compare_points);
+
+  /* There are essentially three cases. (There is a fourth
+   * case where trapezoid B is degenerate and we just have
+   * two triangles, but we don't need to handle it separately.)
+   *
+   *     1            2             3
+   *
+   *     ______       /\           /\
+   *    /     /      /A \         /A \
+   *   /  B  /      /____\       /____\
+   *  /_____/      /  B  /       \  B  \
+   *              /_____/         \_____\
+   *              \ C  /           \ C  /
+   *               \  /             \  /
+   *                \/               \/
+   */
+  if (points[0].y == points[1].y)
+    {
+     /* Case 1 (pure shear) */
+      pango_renderer_draw_trapezoid (renderer, part,                                      /* B */
+				     points[0].y, points[0].x, points[1].x,
+				     points[2].y, points[2].x, points[3].x);
+    }
+  else if (points[1].x < points[2].x)
+    {
+      /* Case 2 */
+      double tmp_width = ((points[2].x - points[0].x) * (points[1].y - points[0].y)) / (points[2].y - points[0].y);
+      double base_width = tmp_width + points[0].x - points[1].x;
+
+      pango_renderer_draw_trapezoid (renderer, part,                                      /* A */
+				     points[0].y, points[0].x, points[0].x,
+				     points[1].y, points[1].x, points[1].x + base_width);
+      pango_renderer_draw_trapezoid (renderer, part,                                      /* B */
+				     points[1].y, points[1].x, points[1].x + base_width,
+				     points[2].y, points[2].x - base_width, points[2].x);
+      pango_renderer_draw_trapezoid (renderer, part,                                      /* C */
+				     points[2].y, points[2].x - base_width, points[2].x, 
+				     points[3].y, points[3].x, points[3].x);
+    }
+  else
+    {
+      /* case 3 */
+      double tmp_width = ((points[0].x - points[2].x) * (points[1].y - points[0].y)) / (points[2].y - points[0].y);
+      double base_width = tmp_width + points[1].x - points[0].x;
+
+      pango_renderer_draw_trapezoid (renderer, part,                                     /* A */
+				     points[0].y, points[0].x, points[0].x,
+				     points[1].y,  points[1].x - base_width, points[1].x);
+      pango_renderer_draw_trapezoid (renderer, part,                                     /* B */
+				     points[1].y, points[1].x - base_width, points[1].x,
+				     points[2].y, points[2].x, points[2].x + base_width);
+      pango_renderer_draw_trapezoid (renderer, part,                                     /* C */
+				     points[2].y, points[2].x, points[2].x + base_width, 
+				     points[3].y, points[3].x, points[3].x);
+    }
+}
+
+static void
+pango_renderer_default_draw_rectangle (PangoRenderer  *renderer,
+				       PangoRenderPart part,
+				       int             x,
+				       int             y,
+				       int             width,
+				       int             height)
+{
+  draw_rectangle (renderer, renderer->matrix, part, x, y, width, height);
+}
+
+/**
+ * pango_renderer_draw_error_underline:
+ * @renderer: a #PangoRenderer
+ * @x: X coordinate of underline, in Pango units in user coordinate system
+ * @y: Y coordinate of underline, in Pango units in user coordinate system
+ * @width: width of underline, in Pango units in user coordinate system
+ * @height: height of underline, in Pango units in user coordinate system
+ *
+ * Draw a squiggly line that approximately covers the given rectangle
+ * in the style of an underline used to indicate a spelling error.
+ * (The width of the underline is rounded to an integer number
+ * of up/down segments and the resulting rectangle is centered
+ * in the original rectangle)
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_draw_error_underline (PangoRenderer *renderer,
+				     int            x,
+				     int            y,
+				     int            width,
+				     int            height)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  
+  PANGO_RENDERER_GET_CLASS (renderer)->draw_error_underline (renderer, x, y, width, height);
+}
+
+/* We are drawing an error underline that looks like one of:
+ *
+ *  /\      /\      /\        /\      /\               -
+ * /  \    /  \    /  \      /  \    /  \              |
+ * \   \  /\   \  /   /      \   \  /\   \             |
+ *  \   \/B \   \/ C /        \   \/B \   \            | height = HEIGHT_SQUARES * square
+ *   \ A \  /\ A \  /          \ A \  /\ A \           | 
+ *    \   \/  \   \/            \   \/  \   \          |
+ *     \  /    \  /              \  /    \  /          |
+ *      \/      \/                \/      \/           -
+ *
+ * |----|
+ *   unit_width = (HEIGHT_SQUARES - 1) * square
+ *
+ * To do this conveniently, we work in a coordinate system where A,B,C
+ * are axis aligned rectangles. (If fonts were square, the diagrams
+ * would be clearer)
+ *
+ *             (0,0)    
+ *              /\      /\        
+ *             /  \    /  \      
+ *            /\  /\  /\  /      
+ *           /  \/  \/  \/       
+ *          /    \  /\  /        
+ *      Y axis    \/  \/         
+ *                 \  /\          
+ *                  \/  \         
+ *                       \ X axis
+ *
+ * Note that the long side in this coordinate system is HEIGHT_SQUARES + 1
+ * units long
+ *
+ * The diagrams above are shown with HEIGHT_SQUARES an integer, but
+ * that is actually incidental; the value 2.5 below seems better than
+ * either HEIGHT_SQUARES=3 (a little long and skinny) or
+ * HEIGHT_SQUARES=2 (a bit short and stubby)
+ */
+ 
+#define HEIGHT_SQUARES 2.5
+
+static void
+get_total_matrix (PangoMatrix  *total,
+		  PangoMatrix  *global,
+		  int           x,
+		  int           y,
+		  int           square)
+{
+  PangoMatrix local;
+  gdouble scale = 0.5 * square;
+
+  /* The local matrix translates from the axis aligned coordinate system
+   * to the original user space coordinate system.
+   */
+  local.xx = scale;
+  local.xy = - scale;
+  local.yx = scale;
+  local.yy = scale;
+  local.x0 = 0;
+  local.y0 = 0;
+
+  *total = *global;
+  pango_matrix_concat (total, &local);
+
+  total->x0 = (global->xx * x + global->xy * y) / PANGO_SCALE + global->x0;
+  total->y0 = (global->yx * x + global->yy * y) / PANGO_SCALE + global->y0;
+}
+
+static void
+pango_renderer_default_draw_error_underline (PangoRenderer *renderer,
+					     int            x,
+					     int            y,
+					     int            width,
+					     int            height)
+{
+  int square = height / HEIGHT_SQUARES;
+  int unit_width = (HEIGHT_SQUARES - 1) * square;
+  int width_units = (width + unit_width / 2) / unit_width;
+  static const PangoMatrix identity = PANGO_MATRIX_INIT;
+  const PangoMatrix *matrix;
+
+  x += (width - width_units * unit_width) / 2;
+  width = width_units * unit_width;
+
+  if (renderer->matrix)
+    matrix = renderer->matrix;
+  else
+    matrix = &identity;
+
+  while (TRUE)
+    {
+      PangoMatrix total;
+      get_total_matrix (&total, renderer->matrix, x, y, square);
+
+      draw_rectangle (renderer, &total, PANGO_RENDER_PART_UNDERLINE, /* A */
+		      0,                      0,
+		      HEIGHT_SQUARES * 2 - 1, 1);
+
+      if (width_units > 2)
+	{
+	  draw_rectangle (renderer, &total, PANGO_RENDER_PART_UNDERLINE, /* B */
+			  HEIGHT_SQUARES * 2 - 2, - (HEIGHT_SQUARES * 2 - 3),
+			  1,                      HEIGHT_SQUARES * 2 - 3);
+	  width_units -= 2;
+	  x += unit_width * 2;
+	}
+      else if (width_units == 2)
+	{
+	  draw_rectangle (renderer, &total, PANGO_RENDER_PART_UNDERLINE, /* C */
+			  HEIGHT_SQUARES * 2 - 2, - (HEIGHT_SQUARES * 2 - 2),
+			  1,                      HEIGHT_SQUARES * 2 - 2);
+	  break;
+	}
+      else
+	break;
+    }
+}
+
+/**
+ * pango_renderer_draw_trapezoid:
+ * @renderer: a #PangoRenderer
+ * @part: type of object this trapezoid is part of
+ * @y1: Y coordinate of top of trapezoid
+ * @x11: X coordinate of left end of top of trapezoid
+ * @x21: X coordinate of right end of top of trapezoid
+ * @y2: X coordinate of top of trapezoid
+ * @x12: X coordinate of left end of top of trapezoid
+ * @x22: Y coordinate of left end of top of trapezoid
+ * 
+ * Draws a trapezoid with the parallel sides aligned with the X axis
+ * using the given #PangoRenderer; coordinates are in device space.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_draw_trapezoid (PangoRenderer  *renderer,
+			       PangoRenderPart part,
+			       double          y1,
+			       double          x11,
+			       double          x21,
+			       double          y2,
+			       double          x12,
+			       double          x22)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  
+  PANGO_RENDERER_GET_CLASS (renderer)->draw_trapezoid (renderer, part,
+						       y1, x11, x21,
+						       y2, x12, x22);
+}
+
+/**
+ * pango_renderer_draw_glyph:
+ * @renderer: a #PangoRenderer
+ * @font: a #PangoFont
+ * @glyph: the glyph index of a single glyph
+ * @x: X coordinate of left edge of baseline of glyph
+ * @y: Y coordinate of left edge of baseline of glyph
+ * 
+ * Draws a single glyph with coordinates in device space.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_draw_glyph (PangoRenderer *renderer,
+			   PangoFont     *font,
+			   PangoGlyph     glyph,
+			   double         x,
+			   double         y)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+
+  if (glyph == 0)		/* glyph 0 never renders */
+    return;
+  
+  PANGO_RENDERER_GET_CLASS (renderer)->draw_glyph (renderer, font, glyph, x, y);
+}
+
+/**
+ * pango_renderer_activate:
+ * @renderer: a #PangoRenderer
+ * 
+ * Does initial setup before rendering operations on @renderer.
+ * pango_renderer_deactivate() should be called when done drawing.
+ * Calls such as pango_renderer_draw_layout() automatically
+ * activate the layout before drawing on it. Calls to
+ * pango_renderer_activate() and pango_renderer_deactivate() can
+ * be nested and the renderer will only be initialized and
+ * deinitialized once.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_activate (PangoRenderer *renderer)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+
+  renderer->active_count++;
+  if (renderer->active_count == 1)
+    {
+      if (PANGO_RENDERER_GET_CLASS (renderer)->begin)
+	PANGO_RENDERER_GET_CLASS (renderer)->begin (renderer);
+    }
+}
+
+/**
+ * pango_renderer_deactivate:
+ * @renderer: a #PangoRenderer
+ * 
+ * Cleans up after rendering operations on @renderer. See
+ * docs for pango_renderer_activate().
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_deactivate (PangoRenderer *renderer)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  g_return_if_fail (renderer->active_count > 0);
+  
+  if (renderer->active_count == 1)
+    {
+      if (PANGO_RENDERER_GET_CLASS (renderer)->end)
+	PANGO_RENDERER_GET_CLASS (renderer)->end (renderer);
+    }
+  renderer->active_count--;
+}
+
+/**
+ * pango_renderer_set_color:
+ * @renderer: a #PangoRenderer
+ * @part: the part to change the color of
+ * @color: the new color or %NULL to unset the current color
+ * 
+ * Sets the color for part of the rendering.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_set_color (PangoRenderer   *renderer,
+			  PangoRenderPart  part,
+			  PangoColor      *color)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  g_return_if_fail (IS_VALID_PART (part));
+
+  pango_renderer_part_changed (renderer, part);
+  
+  if ((!color && !renderer->priv->color_set[part]) ||
+      (color && renderer->priv->color_set[part] &&
+       renderer->priv->color[part].red == color->red &&
+       renderer->priv->color[part].green == color->green &&
+       renderer->priv->color[part].blue == color->blue))
+    return;
+
+  if (color)
+    {
+      renderer->priv->color_set[part] = TRUE;
+      renderer->priv->color[part] = *color;
+    }
+  else
+    {
+      renderer->priv->color_set[part] = FALSE;
+    }
+
+  if (PANGO_RENDERER_GET_CLASS (renderer)->color_set)
+    PANGO_RENDERER_GET_CLASS (renderer)->color_set (renderer, part, color);
+}
+
+/**
+ * pango_renderer_get_color:
+ * @renderer: a #PangoRenderer
+ * @part: the part to get the color for
+ * 
+ * Gets the current rendering color for the specified part.
+ * 
+ * Return value: the color for the specified part, or %NULL
+ *  if it hasn't been set and should be inherited from the
+ *  environment.
+ *
+ * Since: 1.8
+ **/
+PangoColor *
+pango_renderer_get_color (PangoRenderer   *renderer,
+			  PangoRenderPart  part)
+{
+  g_return_val_if_fail (PANGO_IS_RENDERER (renderer), NULL);
+  g_return_val_if_fail (IS_VALID_PART (part), NULL);
+
+  if (renderer->priv->color_set[part])
+    return &renderer->priv->color[part];
+  else
+    return NULL;
+}
+
+/**
+ * pango_renderer_part_changed:
+ * @renderer: a #PangoRenderer
+ * @part: the part for which rendering has changed.
+ * 
+ * Informs Pango that the way that the renderering is done
+ * for @part has changed in a way that would prevent multiple
+ * pieces being joined together into one drawing call. For
+ * instance, if a subclass of #PangoRenderer was to add a stipple
+ * option for drawing underlines, it needs to call
+ *
+ * <informalexample><programlisting>
+ * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
+ * </programlisting></informalexample>
+ *
+ * When the stipple changes or underlines with different stipples
+ * might be joined together. Pango automatically calls this for
+ * changes to colors. (See pango_renderer_set_color())
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_part_changed (PangoRenderer    *renderer,
+			     PangoRenderPart   part)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  g_return_if_fail (IS_VALID_PART (part));
+
+  handle_line_state_change (renderer, part);
+
+  if (PANGO_RENDERER_GET_CLASS (renderer)->part_changed)
+    PANGO_RENDERER_GET_CLASS (renderer)->part_changed (renderer, part);
+}
+
+/**
+ * pango_renderer_prepare_run:
+ * @renderer: a #PangoRenderer
+ * @run: a #PangoLayoutRun
+ * 
+ * Set up the state of the PangoRenderer for rendering @run.
+ *
+ * Since: 1.8
+ **/
+static void
+pango_renderer_prepare_run (PangoRenderer  *renderer,
+			    PangoLayoutRun *run)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+  
+  PANGO_RENDERER_GET_CLASS (renderer)->prepare_run (renderer, run);
+}
+
+static void
+pango_renderer_default_prepare_run (PangoRenderer  *renderer,
+				    PangoLayoutRun *run)
+{
+  PangoColor *fg_color = NULL;
+  PangoColor *bg_color = NULL;
+  GSList *l;
+
+  renderer->underline = PANGO_UNDERLINE_NONE;
+  renderer->strikethrough = FALSE;
+
+  for (l = run->item->analysis.extra_attrs; l; l = l->next)
+    {
+      PangoAttribute *attr = l->data;
+      
+      switch (attr->klass->type)
+	{
+	case PANGO_ATTR_UNDERLINE:
+	  renderer->underline = ((PangoAttrInt *)attr)->value;
+	  break;
+	  
+	case PANGO_ATTR_STRIKETHROUGH:
+	  renderer->strikethrough = ((PangoAttrInt *)attr)->value;
+	  break;
+	  
+	case PANGO_ATTR_FOREGROUND:
+	  fg_color = &((PangoAttrColor *)attr)->color;
+	  break;
+	  
+	case PANGO_ATTR_BACKGROUND:
+	  bg_color = &((PangoAttrColor *)attr)->color;
+	  break;
+	  
+	default:
+	  break;
+	}
+    }
+
+  pango_renderer_set_color (renderer, PANGO_RENDER_PART_FOREGROUND, fg_color);
+  pango_renderer_set_color (renderer, PANGO_RENDER_PART_UNDERLINE, fg_color);
+  pango_renderer_set_color (renderer, PANGO_RENDER_PART_STRIKETHROUGH, fg_color);
+  pango_renderer_set_color (renderer, PANGO_RENDER_PART_BACKGROUND, bg_color);
+}
+
+/**
+ * pango_renderer_set_matrix:
+ * @renderer: a #PangoRenderer
+ * @matrix: a #PangoMatrix, or %NULL to unset any existing matrix.
+ *  (No matrix set is the same as setting the identity matrix.)
+ * 
+ * Sets the transformation matrix that will be applied when rendering.
+ *
+ * Since: 1.8
+ **/
+void
+pango_renderer_set_matrix (PangoRenderer     *renderer,
+			   const PangoMatrix *matrix)
+{
+  g_return_if_fail (PANGO_IS_RENDERER (renderer));
+
+  if (renderer->matrix)
+    pango_matrix_free (renderer->matrix);
+  if (matrix)
+    renderer->matrix = pango_matrix_copy (matrix);
+  else
+    renderer->matrix = NULL;
+
+}
+
+/**
+ * pango_renderer_get_matrix:
+ * @renderer: a #PangoRenderer
+ *
+ * Gets the transformation matrix that will be applied when
+ * rendering. See pango_renderer_set_matrix().
+ *
+ * Returns: the matrix, or %NULL if no matrix has been set
+ *  (which is the same as the identity matrix). The returned
+ *  matrix is owned by Pango and must not be modified or
+ *  freed.
+ *
+ * Since: 1.8
+ **/
+G_CONST_RETURN PangoMatrix *
+pango_renderer_get_matrix (PangoRenderer *renderer)
+{
+  g_return_val_if_fail (PANGO_IS_RENDERER (renderer), NULL);
+
+  return renderer->matrix;
+}
diff --git a/pango/pango-renderer.h b/pango/pango-renderer.h
new file mode 100644
index 00000000..5c587f85
--- /dev/null
+++ b/pango/pango-renderer.h
@@ -0,0 +1,238 @@
+/* Pango
+ * pango-renderer.h: Base class for rendering
+ *
+ * Copyright (C) 2004, Red Hat, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __PANGO_RENDERER_H_
+#define __PANGO_RENDERER_H_
+
+#include <pango/pango-layout.h>
+
+G_BEGIN_DECLS
+
+#define PANGO_TYPE_RENDERER            (pango_renderer_get_type())
+#define PANGO_RENDERER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_RENDERER, PangoRenderer))
+#define PANGO_IS_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_RENDERER))
+#define PANGO_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_RENDERER, PangoRendererClass))
+#define PANGO_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_RENDERER))
+#define PANGO_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_RENDERER, PangoRendererClass))
+
+typedef struct _PangoRenderer        PangoRenderer;
+typedef struct _PangoRendererClass   PangoRendererClass;
+typedef struct _PangoRendererPrivate PangoRendererPrivate;
+
+/**
+ * PangoRenderPart:
+ * @PANGO_RENDER_PART_FOREGROUND: the text itself
+ * @PANGO_RENDER_PART_BACKGROUND: the area behind the text
+ * @PANGO_RENDER_PART_UNDERLINE: underlines
+ * @PANGO_RENDER_PART_STRIKETHROUGH: strikethrough lines
+ *
+ * #PangoRenderPart defines different items to render for such
+ * purposes as setting colors.
+ *
+ * Since: 1.8
+ **/
+/* When extending, note N_RENDER_PARTS #define in pango-renderer.c */
+typedef enum
+{
+  PANGO_RENDER_PART_FOREGROUND,
+  PANGO_RENDER_PART_BACKGROUND,
+  PANGO_RENDER_PART_UNDERLINE,
+  PANGO_RENDER_PART_STRIKETHROUGH
+} PangoRenderPart;
+
+/**
+ * PangoRenderer:
+ * @matrix: the current transformation matrix for the Renderer; may
+ *    be %NULL, which should be treated the same as the identity matrix.
+ *
+ * #PangoRenderer is a base class for objects that are used to
+ * render Pango objects such as #PangoGlyphString and
+ * #PangoLayout.
+ *
+ * Since: 1.8
+ **/
+struct _PangoRenderer
+{
+  /*< private >*/
+  GObject parent_instance;
+
+  PangoUnderline underline;
+  gboolean strikethrough;
+  int active_count;
+  
+  /*< public >*/
+  PangoMatrix *matrix;		/* May be NULL */
+  
+  /*< private >*/
+  PangoRendererPrivate *priv;
+};
+
+/**
+ * PangoRendererClass:
+ * @draw_glyphs: draws a #PangoGlyphString
+ * @draw_rectangle: draws a rectangle
+ * @draw_error_underline: draws a squiggly line that approximately
+ * covers the given rectangle in the style of an underline used to
+ * indicate a spelling error. 
+ * @draw_trapezoid: draws a trapezoidal filled area
+ * @draw_glyph: draws a single glyph
+ * @part_changed: do renderer specific processing when rendering
+ *  attributes change
+ * @color_set: updates the renderer when a color has changed.
+ *   if @color is %NULL, means that the color has been unset
+ * @begin: Do renderer-specific initialization before drawing
+ * @end: Do renderer-specific cleanup after drawing
+ * @prepare_run: updates the renderer for a new run
+ *
+ * Class structure for #PangoRenderer.
+ *
+ * Since: 1.8
+ **/
+struct _PangoRendererClass
+{
+  /*< private >*/
+  GObjectClass parent_class;
+
+  /* vtable - not signals */
+  /*< public >*/
+
+  /* All of the following have default implementations
+   * and take as coordinates user coordinates in Pango units
+   */
+  void (*draw_glyphs) (PangoRenderer     *renderer,
+		       PangoFont         *font,
+		       PangoGlyphString  *glyphs,
+		       int                x,
+		       int                y);
+  void (*draw_rectangle) (PangoRenderer     *renderer,
+			  PangoRenderPart    part,
+			  int                x,
+			  int                y,
+			  int                width,
+			  int                height);
+  void (*draw_error_underline) (PangoRenderer     *renderer,
+				int                x,
+				int                y,
+				int                width,
+				int                height);
+
+  /* These two must be implemented and take coordinates in
+   * device space as doubles.
+   */
+  void (*draw_trapezoid) (PangoRenderer  *renderer,
+			  PangoRenderPart part,
+			  double          y1,
+			  double          x11,
+			  double          x21,
+			  double          y2,
+			  double          x12,
+			  double          x22);
+  void (*draw_glyph) (PangoRenderer *renderer,
+		      PangoFont     *font,
+		      PangoGlyph     glyph,
+		      double         x,
+		      double         y);
+
+  /* Notification of change in rendering attributes
+   */
+  void (*part_changed) (PangoRenderer   *renderer,
+			PangoRenderPart  part);
+  void (*color_set) (PangoRenderer  *renderer,
+		     PangoRenderPart part,
+		     PangoColor     *color);
+
+  /* Paired around drawing operations
+   */
+  void (*begin) (PangoRenderer *renderer);
+  void (*end)   (PangoRenderer *renderer);
+
+  /* Hooks into the details of layout rendering
+   */
+  void (*prepare_run) (PangoRenderer  *renderer,
+		       PangoLayoutRun *run);
+
+  /*< private >*/
+  
+  /* Padding for future expansion */
+  void (*_pango_reserved1) (void);
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+GType pango_renderer_get_type    (void);
+
+void pango_renderer_draw_layout          (PangoRenderer    *renderer,
+					  PangoLayout      *layout,
+					  int               x,
+					  int               y);
+void pango_renderer_draw_layout_line     (PangoRenderer    *renderer,
+					  PangoLayoutLine  *line,
+					  int               x,
+					  int               y);
+void pango_renderer_draw_glyphs          (PangoRenderer    *renderer,
+					  PangoFont        *font,
+					  PangoGlyphString *glyphs,
+					  int               x,
+					  int               y);
+void pango_renderer_draw_rectangle       (PangoRenderer    *renderer,
+					  PangoRenderPart   part,
+					  int               x,
+					  int               y,
+					  int               width,
+					  int               height);
+void pango_renderer_draw_error_underline (PangoRenderer    *renderer,
+					  int               x,
+					  int               y,
+					  int               width,
+					  int               height);
+void pango_renderer_draw_trapezoid       (PangoRenderer    *renderer,
+					  PangoRenderPart   part,
+					  double            y1,
+					  double            x11,
+					  double            x21,
+					  double            y2,
+					  double            x12,
+					  double            x22);
+void pango_renderer_draw_glyph           (PangoRenderer    *renderer,
+					  PangoFont        *font,
+					  PangoGlyph        glyph,
+					  double            x,
+					  double            y);
+
+void pango_renderer_activate             (PangoRenderer    *renderer);
+void pango_renderer_deactivate           (PangoRenderer    *renderer);
+
+void        pango_renderer_part_changed (PangoRenderer   *renderer,
+					 PangoRenderPart  part);
+void        pango_renderer_set_color    (PangoRenderer   *renderer,
+					 PangoRenderPart  part,
+					 PangoColor      *color);
+PangoColor *pango_renderer_get_color    (PangoRenderer   *renderer,
+					 PangoRenderPart  part);
+
+void                        pango_renderer_set_matrix (PangoRenderer     *renderer,
+						       const PangoMatrix *matrix);
+G_CONST_RETURN PangoMatrix *pango_renderer_get_matrix (PangoRenderer     *renderer);
+
+G_END_DECLS
+
+#endif /* __PANGO_RENDERER_H_ */
+
diff --git a/pango/pango.h b/pango/pango.h
index 592da837..8821ed4a 100644
--- a/pango/pango.h
+++ b/pango/pango.h
@@ -33,6 +33,7 @@
 #include <pango/pango-glyph.h>
 #include <pango/pango-item.h>
 #include <pango/pango-layout.h>
+#include <pango/pango-renderer.h>
 #include <pango/pango-script.h>
 #include <pango/pango-types.h>
 
diff --git a/pango/pangoft2-fontmap.c b/pango/pangoft2-fontmap.c
index 723fb495..43607b07 100644
--- a/pango/pangoft2-fontmap.c
+++ b/pango/pangoft2-fontmap.c
@@ -60,6 +60,8 @@ struct _PangoFT2FontMap
   PangoFT2SubstituteFunc substitute_func;
   gpointer substitute_data;
   GDestroyNotify substitute_destroy;
+
+  PangoRenderer *renderer;
 };
 
 struct _PangoFT2FontMapClass
@@ -101,6 +103,9 @@ pango_ft2_font_map_finalize (GObject *object)
 {
   PangoFT2FontMap *ft2fontmap = PANGO_FT2_FONT_MAP (object);
   
+  if (ft2fontmap->renderer)
+    g_object_unref (ft2fontmap->renderer);
+
   if (ft2fontmap->substitute_destroy)
     ft2fontmap->substitute_destroy (ft2fontmap->substitute_data);
 
@@ -303,6 +308,24 @@ _pango_ft2_font_map_get_library (PangoFontMap *fontmap)
   return ft2fontmap->library;
 }
 
+
+/**
+ * _pango_ft2_font_map_get_renderer:
+ * @fontmap: a #PangoFT2Fontmap
+ * 
+ * Gets the singleton PangoFT2Renderer for this fontmap.
+ * 
+ * Return value: 
+ **/
+PangoRenderer *
+_pango_ft2_font_map_get_renderer (PangoFT2FontMap *ft2fontmap)
+{
+  if (!ft2fontmap->renderer)
+    ft2fontmap->renderer = g_object_new (PANGO_TYPE_FT2_RENDERER, NULL);
+
+  return ft2fontmap->renderer;
+}
+
 static void
 pango_ft2_font_map_default_substitute (PangoFcFontMap *fcfontmap,
 				       FcPattern      *pattern)
diff --git a/pango/pangoft2-private.h b/pango/pangoft2-private.h
index 6011fec2..c0b8a7e5 100644
--- a/pango/pangoft2-private.h
+++ b/pango/pangoft2-private.h
@@ -24,6 +24,7 @@
 #define __PANGOFT2_PRIVATE_H__
 
 #include "pangoft2.h"
+#include "pango-renderer.h"
 #include <fontconfig/fontconfig.h>
 #include <fontconfig/fcfreetype.h>
 
@@ -55,7 +56,7 @@
 
 typedef struct _PangoFT2Font      PangoFT2Font;
 typedef struct _PangoFT2GlyphInfo PangoFT2GlyphInfo;
-
+typedef struct _PangoFT2Renderer  PangoFT2Renderer;
 
 struct _PangoFT2Font
 {
@@ -111,4 +112,12 @@ void _pango_ft2_draw_error_underline (FT_Bitmap         *bitmap,
 				      int                width,
 				      int                height);
 
+#define PANGO_TYPE_FT2_RENDERER            (pango_ft2_renderer_get_type())
+#define PANGO_FT2_RENDERER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FT2_RENDERER, PangoFT2Renderer))
+#define PANGO_IS_FT2_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FT2_RENDERER))
+
+GType pango_ft2_renderer_get_type    (void);
+
+PangoRenderer *_pango_ft2_font_map_get_renderer (PangoFT2FontMap *ft2fontmap);
+
 #endif /* __PANGOFT2_PRIVATE_H__ */
diff --git a/pango/pangoft2-render.c b/pango/pangoft2-render.c
index 90d1ba3a..b716c0aa 100644
--- a/pango/pangoft2-render.c
+++ b/pango/pangoft2-render.c
@@ -24,6 +24,218 @@
 
 #include "pangoft2-private.h"
 
+typedef struct _PangoFT2RendererClass PangoFT2RendererClass;
+
+#define PANGO_FT2_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FT2_RENDERER, PangoFT2RendererClass))
+#define PANGO_IS_FT2_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FT2_RENDERER))
+#define PANGO_FT2_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FT2_RENDERER, PangoFT2RendererClass))
+
+struct _PangoFT2Renderer
+{
+  PangoRenderer parent_instance;
+
+  FT_Bitmap *bitmap;
+};
+
+struct _PangoFT2RendererClass
+{
+  PangoRendererClass parent_class;
+};
+
+static void pango_ft2_renderer_draw_glyph     (PangoRenderer    *renderer,
+					       PangoFont        *font,
+					       PangoGlyph        glyph,
+					       double            x,
+					       double            y);
+static void pango_ft2_renderer_draw_trapezoid (PangoRenderer    *renderer,
+					       PangoRenderPart   part,
+					       double            y1,
+					       double            x11,
+					       double            x21,
+					       double            y2,
+					       double            x12,
+					       double            x22);
+
+G_DEFINE_TYPE (PangoFT2Renderer, pango_ft2_renderer, PANGO_TYPE_RENDERER)
+
+static void
+pango_ft2_renderer_init (PangoFT2Renderer *renderer)
+{
+}
+
+static void
+pango_ft2_renderer_class_init (PangoFT2RendererClass *klass)
+{
+  PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);
+
+  renderer_class->draw_glyph = pango_ft2_renderer_draw_glyph;
+  renderer_class->draw_trapezoid = pango_ft2_renderer_draw_trapezoid;
+}
+
+static void
+pango_ft2_renderer_set_bitmap (PangoFT2Renderer *renderer,
+			      FT_Bitmap         *bitmap)
+{
+  renderer->bitmap = bitmap;
+}
+
+typedef struct
+{
+  FT_Bitmap bitmap;
+  int bitmap_left;
+  int bitmap_top;
+} PangoFT2RenderedGlyph;
+
+static void
+pango_ft2_free_rendered_glyph (PangoFT2RenderedGlyph *rendered)
+{
+  g_free (rendered->bitmap.buffer);
+  g_free (rendered);
+}
+
+static PangoFT2RenderedGlyph *
+pango_ft2_font_render_glyph (PangoFont *font,
+			     int glyph_index)
+{
+  PangoFT2RenderedGlyph *rendered;
+  FT_Face face;
+
+  rendered = g_new (PangoFT2RenderedGlyph, 1);
+
+  face = pango_ft2_font_get_face (font);
+  
+  if (face)
+    {
+      PangoFT2Font *ft2font = (PangoFT2Font *) font;
+
+      /* Draw glyph */
+      FT_Load_Glyph (face, glyph_index, ft2font->load_flags);
+      FT_Render_Glyph (face->glyph,
+		       (ft2font->load_flags & FT_LOAD_TARGET_MONO ?
+			ft_render_mode_mono : ft_render_mode_normal));
+
+      rendered->bitmap = face->glyph->bitmap;
+      rendered->bitmap.buffer = g_memdup (face->glyph->bitmap.buffer,
+					  face->glyph->bitmap.rows * face->glyph->bitmap.pitch);
+      rendered->bitmap_left = face->glyph->bitmap_left;
+      rendered->bitmap_top = face->glyph->bitmap_top;
+    }
+  else
+    g_error ("Couldn't get face for PangoFT2Face");
+
+  return rendered;
+}
+
+static void
+pango_ft2_renderer_draw_glyph (PangoRenderer *renderer,
+			       PangoFont     *font,
+			       PangoGlyph     glyph,
+			       double         x,
+			       double         y)
+{
+  FT_Bitmap *bitmap = PANGO_FT2_RENDERER (renderer)->bitmap;
+  PangoFT2RenderedGlyph *rendered_glyph;
+  gboolean add_glyph_to_cache;
+  guchar *src, *dest;
+
+  int x_start, x_limit;
+  int y_start, y_limit;
+  int ixoff = floor (x + 0.5);
+  int iyoff = floor (y + 0.5);
+  int ix, iy;
+
+  rendered_glyph = _pango_ft2_font_get_cache_glyph_data (font, glyph);
+  add_glyph_to_cache = FALSE;
+  if (rendered_glyph == NULL)
+    {
+      rendered_glyph = pango_ft2_font_render_glyph (font, glyph);
+      add_glyph_to_cache = TRUE;
+    }
+
+  x_start = MAX (0, - (ixoff + rendered_glyph->bitmap_left));
+  x_limit = MIN (rendered_glyph->bitmap.width,
+		 bitmap->width - (ixoff + rendered_glyph->bitmap_left));
+
+  y_start = MAX (0,  - (iyoff - rendered_glyph->bitmap_top));
+  y_limit = MIN (rendered_glyph->bitmap.rows,
+		 bitmap->rows - (iyoff - rendered_glyph->bitmap_top));
+
+  src = rendered_glyph->bitmap.buffer +
+    y_start * rendered_glyph->bitmap.pitch;
+
+  dest = bitmap->buffer +
+    (y_start + iyoff - rendered_glyph->bitmap_top) * bitmap->pitch +
+    x_start + ixoff + rendered_glyph->bitmap_left;
+
+  switch (rendered_glyph->bitmap.pixel_mode)
+    {
+    case ft_pixel_mode_grays:
+      src += x_start;
+      for (iy = y_start; iy < y_limit; iy++)
+	{
+	  guchar *s = src;
+	  guchar *d = dest;
+
+	  for (ix = x_start; ix < x_limit; ix++)
+	    {
+	      switch (*s)
+		{
+		case 0:
+		  break;
+		case 0xff:
+		  *d = 0xff;
+		default:
+		  *d = MIN ((gushort) *d + (gushort) *s, 0xff);
+		  break;
+		}
+
+	      s++;
+	      d++;
+	    }
+
+	  dest += bitmap->pitch;
+	  src  += rendered_glyph->bitmap.pitch;
+	}
+      break;
+
+    case ft_pixel_mode_mono:
+      src += x_start / 8;
+      for (iy = y_start; iy < y_limit; iy++)
+	{
+	  guchar *s = src;
+	  guchar *d = dest;
+
+	  for (ix = x_start; ix < x_limit; ix++)
+	    {
+	      if ((*s) & (1 << (7 - (ix % 8))))
+		*d |= 0xff;
+		      
+	      if ((ix % 8) == 7)
+		s++;
+	      d++;
+	    }
+
+	  dest += bitmap->pitch;
+	  src  += rendered_glyph->bitmap.pitch;
+	}
+      break;
+	      
+    default:
+      g_warning ("pango_ft2_render: "
+		 "Unrecognized glyph bitmap pixel mode %d\n",
+		 rendered_glyph->bitmap.pixel_mode);
+      break;
+    }
+
+  if (add_glyph_to_cache)
+    {
+      _pango_ft2_font_set_glyph_cache_destroy (font,
+					       (GDestroyNotify) pango_ft2_free_rendered_glyph);
+      _pango_ft2_font_set_cache_glyph_data (font,
+					    glyph, rendered_glyph);
+    }
+}
+
 typedef struct {
   double y;
   double x1;
@@ -31,10 +243,11 @@ typedef struct {
 } Position;
 
 static void
-draw_simple_trap (FT_Bitmap *bitmap,
-		  Position  *t,
-		  Position  *b)
+draw_simple_trap (PangoRenderer *renderer,
+		  Position      *t,
+		  Position      *b)
 {
+  FT_Bitmap *bitmap = PANGO_FT2_RENDERER (renderer)->bitmap;
   int iy = floor (t->y);
   int x1, x2, x;
   double dy = b->y - t->y;
@@ -96,13 +309,14 @@ interpolate_position (Position *result,
  * line so we have to accumulate to get the final result.
  */
 static void
-draw_trap (FT_Bitmap *bitmap,
-	   double     y1,
-	   double     x11,
-	   double     x21,
-	   double     y2,
-	   double     x12,
-	   double     x22)
+pango_ft2_renderer_draw_trapezoid (PangoRenderer   *renderer,
+				   PangoRenderPart  part,
+				   double           y1,
+				   double           x11,
+				   double           x21,
+				   double           y2,
+				   double           x12,
+				   double           x22)
 {
   Position pos;
   Position t;
@@ -216,267 +430,182 @@ draw_trap (FT_Bitmap *bitmap,
 	    }
 	}
 
-      draw_simple_trap (bitmap, &pos, &pos_next);
+      draw_simple_trap (renderer, &pos, &pos_next);
       pos = pos_next;
     }
 }
 
-typedef struct
+/**
+ * pango_ft2_render_layout_subpixel:
+ * @bitmap:    a FT_Bitmap to render the layout onto
+ * @layout:    a #PangoLayout
+ * @x:         the X position of the left of the layout (in Pango units)
+ * @y:         the Y position of the top of the layout (in Pango units)
+ *
+ * Render a #PangoLayout onto a FreeType2 bitmap, with he
+ * location specified in fixed-point pango units rather than
+ * pixels. (Using this will avoid extra inaccuracies from
+ * rounding to integer pixels multiple times, even if the
+ * final glyph positions are integers.)
+ *
+ * Since: 1.6
+ */
+void 
+pango_ft2_render_layout_subpixel (FT_Bitmap   *bitmap,
+				  PangoLayout *layout,
+				  int          x, 
+				  int          y)
 {
-  double x, y;
-} Point;
+  PangoContext *context;
+  PangoFontMap *fontmap;
+  PangoRenderer *renderer;
 
-static void
-to_device (const PangoMatrix *matrix,
-	   double             x,
-	   double             y,
-	   Point             *result)
-{
-  result->x = (x * matrix->xx + y * matrix->xy) / PANGO_SCALE + matrix->x0;
-  result->y = (x * matrix->yx + y * matrix->yy) / PANGO_SCALE + matrix->y0;
-}
+  g_return_if_fail (bitmap != NULL);
+  g_return_if_fail (PANGO_IS_LAYOUT (layout));
 
-static int
-compare_points (const void *a,
-		const void *b)
-{
-  const Point *pa = a;
-  const Point *pb = b;
-
-  if (pa->y < pb->y)
-    return -1;
-  else if (pa->y > pb->y)
-    return 1;
-  else if (pa->x < pb->x)
-    return -1;
-  else if (pa->x > pb->x)
-    return 1;
-  else
-    return 0;
+  context = pango_layout_get_context (layout);
+  fontmap = pango_context_get_font_map (context);
+  renderer = _pango_ft2_font_map_get_renderer (PANGO_FT2_FONT_MAP (fontmap));
+
+  pango_ft2_renderer_set_bitmap (PANGO_FT2_RENDERER (renderer), bitmap);
+  
+  pango_renderer_draw_layout (renderer, layout, x, y);
 }
 
 /**
- * _pango_ft2_draw_rect:
- * @bitmap: a #FT_Bitmap
- * @matrix: a #PangoMatrix giving the user to device transformation,
- *          or %NULL for the identity.
- * @x: X coordinate of rectangle, in Pango units in user coordinate system
- * @y: Y coordinate of rectangle, in Pango units in user coordinate system
- * @width: width of rectangle, in Pango units in user coordinate system
- * @height: height of rectangle, in Pango units in user coordinate system
+ * pango_ft2_render_layout:
+ * @bitmap:    a FT_Bitmap to render the layout onto
+ * @layout:    a #PangoLayout
+ * @x:         the X position of the left of the layout (in pixels)
+ * @y:         the Y position of the top of the layout (in pixels)
  *
- * Render an axis aligned rectangle in user coordinates onto
- * a bitmap after transformation by the given matrix. Rendering
- * is done anti-aliased.
- **/
-void
-_pango_ft2_draw_rect (FT_Bitmap          *bitmap,
-		      const PangoMatrix  *matrix,
-		      int                 x,
-		      int                 y,
-		      int                 width,
-		      int                 height)
+ * Render a #PangoLayout onto a FreeType2 bitmap
+ */
+void 
+pango_ft2_render_layout (FT_Bitmap   *bitmap,
+			 PangoLayout *layout,
+			 int          x, 
+			 int          y)
 {
-  static const PangoMatrix identity = PANGO_MATRIX_INIT;
-  Point points[4];
-
-  if (!matrix)
-    matrix = &identity;
-
-  /* Convert the points to device coordinates, and sort
-   * in ascending Y order. (Ordering by X for ties)
-   */
-  to_device (matrix, x, y, &points[0]);
-  to_device (matrix, x + width, y, &points[1]);
-  to_device (matrix, x, y + height, &points[2]);
-  to_device (matrix, x + width, y + height, &points[3]);
-
-  qsort (points, 4, sizeof (Point), compare_points);
-
-  /* There are essentially three cases. (There is a fourth
-   * case where trapezoid B is degenerate and we just have
-   * two triangles, but we don't need to handle it separately.)
-   *
-   *     1            2             3
-   *
-   *     ______       /\           /\
-   *    /     /      /A \         /A \
-   *   /  B  /      /____\       /____\
-   *  /_____/      /  B  /       \  B  \
-   *              /_____/         \_____\
-   *              \ C  /           \ C  /
-   *               \  /             \  /
-   *                \/               \/
-   */
-  if (points[0].y == points[1].y)
-    {
-     /* Case 1 (pure shear) */
-      draw_trap (bitmap,                                 /* B */
-		 points[0].y, points[0].x, points[1].x,
-		 points[2].y, points[2].x, points[3].x);
-    }
-  else if (points[1].x < points[2].x)
-    {
-      /* Case 2 */
-      double tmp_width = ((points[2].x - points[0].x) * (points[1].y - points[0].y)) / (points[2].y - points[0].y);
-      double base_width = tmp_width + points[0].x - points[1].x;
-
-      draw_trap (bitmap,                                              /* A */
-		 points[0].y, points[0].x, points[0].x,
-		 points[1].y, points[1].x, points[1].x + base_width);
-      draw_trap (bitmap,
-		 points[1].y, points[1].x, points[1].x + base_width,  /* B */
-		 points[2].y, points[2].x - base_width, points[2].x);
-      draw_trap (bitmap,
-		 points[2].y, points[2].x - base_width, points[2].x,  /* C */
-		 points[3].y, points[3].x, points[3].x);
-    }
-  else
-    {
-      /* case 3 */
-      double tmp_width = ((points[0].x - points[2].x) * (points[1].y - points[0].y)) / (points[2].y - points[0].y);
-      double base_width = tmp_width + points[1].x - points[0].x;
-
-      draw_trap (bitmap,                                             /* A */
-		 points[0].y, points[0].x, points[0].x,
-		 points[1].y,  points[1].x - base_width, points[1].x);
-      draw_trap (bitmap,
-		 points[1].y, points[1].x - base_width, points[1].x, /* B */
-		 points[2].y, points[2].x, points[2].x + base_width);
-      draw_trap (bitmap,
-		 points[2].y, points[2].x, points[2].x + base_width, /* C */
-		 points[3].y, points[3].x, points[3].x);
-    }
+  pango_ft2_render_layout_subpixel (bitmap, layout, x * PANGO_SCALE, y * PANGO_SCALE);
 }
 
-/* We are drawing an error underline that looks like one of:
- *
- *  /\      /\      /\        /\      /\               -
- * /  \    /  \    /  \      /  \    /  \              |
- * \   \  /\   \  /   /      \   \  /\   \             |
- *  \   \/B \   \/ C /        \   \/B \   \            | height = HEIGHT_SQUARES * square
- *   \ A \  /\ A \  /          \ A \  /\ A \           | 
- *    \   \/  \   \/            \   \/  \   \          |
- *     \  /    \  /              \  /    \  /          |
- *      \/      \/                \/      \/           -
- *
- * |----|
- *   unit_width = (HEIGHT_SQUARES - 1) * square
- *
- * To do this conveniently, we work in a coordinate system where A,B,C
- * are axis aligned rectangles. (If fonts were square, the diagrams
- * would be clearer)
- *
- *             (0,0)    
- *              /\      /\        
- *             /  \    /  \      
- *            /\  /\  /\  /      
- *           /  \/  \/  \/       
- *          /    \  /\  /        
- *      Y axis    \/  \/         
- *                 \  /\          
- *                  \/  \         
- *                       \ X axis
+/**
+ * pango_ft2_render_layout_line_subpixel:
+ * @bitmap:    a FT_Bitmap to render the line onto
+ * @line:      a #PangoLayoutLine
+ * @x:         the x position of start of string (in pango units)
+ * @y:         the y position of baseline (in pango units)
  *
- * Note that the long side in this coordinate system is HEIGHT_SQUARES + 1
- * units long
+ * Render a #PangoLayoutLine onto a FreeType2 bitmap, with he
+ * location specified in fixed-point pango units rather than
+ * pixels. (Using this will avoid extra inaccuracies from
+ * rounding to integer pixels multiple times, even if the
+ * final glyph positions are integers.)
  *
- * The diagrams above are shown with HEIGHT_SQUARES an integer, but
- * that is actually incidental; the value 2.5 below seems better than
- * either HEIGHT_SQUARES=3 (a little long and skinny) or
- * HEIGHT_SQUARES=2 (a bit short and stubby)
+ * Since: 1.6
  */
- 
-#define HEIGHT_SQUARES 2.5
+void 
+pango_ft2_render_layout_line_subpixel (FT_Bitmap       *bitmap,
+				       PangoLayoutLine *line,
+				       int              x, 
+				       int              y)
+{
+  PangoContext *context;
+  PangoFontMap *fontmap;
+  PangoRenderer *renderer;
 
-static void
-get_total_matrix (PangoMatrix        *total,
-		  const PangoMatrix  *global,
-		  int                 x,
-		  int                 y,
-		  int                 square)
+  g_return_if_fail (bitmap != NULL);
+  g_return_if_fail (line != NULL);
+
+  context = pango_layout_get_context (line->layout);
+  fontmap = pango_context_get_font_map (context);
+  renderer = _pango_ft2_font_map_get_renderer (PANGO_FT2_FONT_MAP (fontmap));
+
+  pango_ft2_renderer_set_bitmap (PANGO_FT2_RENDERER (renderer), bitmap);
+  
+  pango_renderer_draw_layout_line (renderer, line, x, y);
+}
+
+/**
+ * pango_ft2_render_layout_line:
+ * @bitmap:    a FT_Bitmap to render the line onto
+ * @line:      a #PangoLayoutLine
+ * @x:         the x position of start of string (in pixels)
+ * @y:         the y position of baseline (in pixels)
+ *
+ * Render a #PangoLayoutLine onto a FreeType2 bitmap
+ */
+void 
+pango_ft2_render_layout_line (FT_Bitmap       *bitmap,
+			      PangoLayoutLine *line,
+			      int              x, 
+			      int              y)
 {
-  PangoMatrix local;
-  gdouble scale = 0.5 * square;
-
-  /* The local matrix translates from the axis aligned coordinate system
-   * to the original user space coordinate system.
-   */
-  local.xx = scale;
-  local.xy = - scale;
-  local.yx = scale;
-  local.yy = scale;
-  local.x0 = 0;
-  local.y0 = 0;
-
-  *total = *global;
-  pango_matrix_concat (total, &local);
-
-  total->x0 = (global->xx * x + global->xy * y) / PANGO_SCALE + global->x0;
-  total->y0 = (global->yx * x + global->yy * y) / PANGO_SCALE + global->y0;
+  pango_ft2_render_layout_line_subpixel (bitmap, line, x * PANGO_SCALE, y * PANGO_SCALE);
 }
 
 /**
- * _pango_ft2_draw_error_underline:
- * @bitmap: a #FT_Bitmap
- * @matrix: a #PangoMatrix giving the user to device transformation,
- *          or %NULL for the identity.
- * @x: X coordinate of underline, in Pango units in user coordinate system
- * @y: Y coordinate of underline, in Pango units in user coordinate system
- * @width: width of underline, in Pango units in user coordinate system
- * @height: height of underline, in Pango units in user coordinate system
+ * pango_ft2_render_transformed:
+ * @bitmap:  the FreeType2 bitmap onto which to draw the string
+ * @font:    the font in which to draw the string
+ * @matrix: a #PangoMatrix, or %NULL to use an identity transformation
+ * @glyphs:  the glyph string to draw
+ * @x:       the x position of the start of the string (in Pango
+ *           units in user space coordinates)
+ * @y:       the y position of the baseline (in Pango units
+ *           in user space coordinates)
+ *
+ * Renders a #PangoGlyphString onto a FreeType2 bitmap, possibly
+ * transforming the layed-out coordinates through a transformation
+ * matrix. Note that the transformation matrix for @font is not
+ * changed, so to produce correct rendering results, the @font
+ * must have been loaded using a #PangoContext with an identical
+ * transformation matrix to that passed in to this function.
  *
- * Draw a squiggly line that approximately covers the given rectangle
- * in the style of an underline used to indicate a spelling error.
- * (The width of the underline is rounded to an integer number
- * of up/down segments and the resulting rectangle is centered
- * in the original rectangle)
+ * Since: 1.6
  **/
-void
-_pango_ft2_draw_error_underline (FT_Bitmap          *bitmap,
-				 const PangoMatrix  *matrix,
-				 int                 x,
-				 int                 y,
-				 int                 width,
-				 int                 height)
+void 
+pango_ft2_render_transformed (FT_Bitmap         *bitmap,
+			      const PangoMatrix *matrix,
+			      PangoFont         *font,
+			      PangoGlyphString  *glyphs,
+			      int                x, 
+			      int                y)
 {
+  PangoFontMap *fontmap;
+  PangoRenderer *renderer;
 
-  int square = height / HEIGHT_SQUARES;
-  int unit_width = (HEIGHT_SQUARES - 1) * square;
-  int width_units = (width + unit_width / 2) / unit_width;
-  static const PangoMatrix identity = PANGO_MATRIX_INIT;
+  g_return_if_fail (bitmap != NULL);
+  g_return_if_fail (PANGO_FT2_IS_FONT (font));
+  g_return_if_fail (glyphs != NULL);
 
-  x += (width - width_units * unit_width) / 2;
-  width = width_units * unit_width;
+  fontmap = PANGO_FC_FONT (font)->fontmap;
+  renderer = _pango_ft2_font_map_get_renderer (PANGO_FT2_FONT_MAP (fontmap));
 
-  if (!matrix)
-    matrix = &identity;
-
-  while (TRUE)
-    {
-      PangoMatrix total;
-      get_total_matrix (&total, matrix, x, y, square);
-
-      _pango_ft2_draw_rect (bitmap, &total,              /* A */
-			    0,                      0,
-			    HEIGHT_SQUARES * 2 - 1, 1);
+  pango_ft2_renderer_set_bitmap (PANGO_FT2_RENDERER (renderer), bitmap);
+  pango_renderer_set_matrix (renderer, matrix);
+  
+  pango_renderer_draw_glyphs (renderer, font, glyphs, x, y);
+}
 
-      if (width_units > 2)
-	{
-	  _pango_ft2_draw_rect (bitmap, &total,
-				HEIGHT_SQUARES * 2 - 2, - (HEIGHT_SQUARES * 2 - 3),
-				1,                      HEIGHT_SQUARES * 2 - 3); /* B */
-	  width_units -= 2;
-	  x += unit_width * 2;
-	}
-      else if (width_units == 2)
-	{
-	  _pango_ft2_draw_rect (bitmap, &total,
-				HEIGHT_SQUARES * 2 - 2, - (HEIGHT_SQUARES * 2 - 2),
-				1,                      HEIGHT_SQUARES * 2 - 2); /* C */
-	  break;
-	}
-      else
-	break;
-    }
+/**
+ * pango_ft2_render:
+ * @bitmap:  the FreeType2 bitmap onto which to draw the string
+ * @font:    the font in which to draw the string
+ * @glyphs:  the glyph string to draw
+ * @x:       the x position of the start of the string (in pixels)
+ * @y:       the y position of the baseline (in pixels)
+ *
+ * Renders a #PangoGlyphString onto a FreeType2 bitmap.
+ **/
+void 
+pango_ft2_render (FT_Bitmap        *bitmap,
+		  PangoFont        *font,
+		  PangoGlyphString *glyphs,
+		  int               x, 
+		  int               y)
+{
+  pango_ft2_render_transformed (bitmap, NULL, font, glyphs, x * PANGO_SCALE, y * PANGO_SCALE);
 }
+
diff --git a/pango/pangoft2.c b/pango/pangoft2.c
index 78e9fb6d..268b01dc 100644
--- a/pango/pangoft2.c
+++ b/pango/pangoft2.c
@@ -49,13 +49,6 @@ struct _PangoFT2FontClass
   PangoFcFontClass parent_class;
 };
 
-typedef struct
-{
-  FT_Bitmap bitmap;
-  int bitmap_left;
-  int bitmap_top;
-} PangoFT2RenderedGlyph;
-
 static void pango_ft2_font_finalize   (GObject         *object);
 
 static void                   pango_ft2_font_get_glyph_extents (PangoFont      *font,
@@ -72,15 +65,6 @@ static guint      pango_ft2_font_real_get_glyph         (PangoFcFont      *font,
 static PangoGlyph pango_ft2_font_real_get_unknown_glyph (PangoFcFont      *font,
 							 gunichar          wc);
 
-static void       pango_ft2_get_item_properties         (PangoItem      *item,
-							 PangoUnderline *uline,
-							 gboolean       *strikethrough,
-							 gint           *rise,
-							 gboolean       *shape_set,
-							 PangoRectangle *ink_rect,
-							 PangoRectangle *logical_rect);
-
-
 PangoFT2Font *
 _pango_ft2_font_new (PangoFT2FontMap *ft2fontmap,
 		     FcPattern       *pattern)
@@ -284,246 +268,6 @@ pango_ft2_font_class_init (PangoFT2FontClass *class)
   fc_font_class->get_unknown_glyph = pango_ft2_font_real_get_unknown_glyph;
 }
 
-static void
-pango_ft2_free_rendered_glyph (PangoFT2RenderedGlyph *rendered)
-{
-  g_free (rendered->bitmap.buffer);
-  g_free (rendered);
-}
-
-static PangoFT2RenderedGlyph *
-pango_ft2_font_render_glyph (PangoFont *font,
-			     int glyph_index)
-{
-  PangoFT2RenderedGlyph *rendered;
-  FT_Face face;
-
-  rendered = g_new (PangoFT2RenderedGlyph, 1);
-
-  face = pango_ft2_font_get_face (font);
-  
-  if (face)
-    {
-      PangoFT2Font *ft2font = (PangoFT2Font *) font;
-
-      /* Draw glyph */
-      FT_Load_Glyph (face, glyph_index, ft2font->load_flags);
-      FT_Render_Glyph (face->glyph,
-		       (ft2font->load_flags & FT_LOAD_TARGET_MONO ?
-			ft_render_mode_mono : ft_render_mode_normal));
-
-      rendered->bitmap = face->glyph->bitmap;
-      rendered->bitmap.buffer = g_memdup (face->glyph->bitmap.buffer,
-					  face->glyph->bitmap.rows * face->glyph->bitmap.pitch);
-      rendered->bitmap_left = face->glyph->bitmap_left;
-      rendered->bitmap_top = face->glyph->bitmap_top;
-    }
-  else
-    g_error ("Couldn't get face for PangoFT2Face");
-
-  return rendered;
-}
-
-static void
-transform_point (const PangoMatrix *matrix,
-		 int                x,
-		 int                y,
-		 int               *x_out_pixels,
-		 int               *y_out_pixels)
-{
-  double x_out = (matrix->xx * x + matrix->xy * y) / PANGO_SCALE + matrix->x0;
-  double y_out = (matrix->yx * x + matrix->yy * y) / PANGO_SCALE + matrix->y0;
-
-  *x_out_pixels = floor (x_out + 0.5);
-  *y_out_pixels = floor (y_out + 0.5);
-}
-
-/**
- * pango_ft2_render_transformed:
- * @bitmap:  the FreeType2 bitmap onto which to draw the string
- * @font:    the font in which to draw the string
- * @matrix: a #PangoMatrix, or %NULL to use an identity transformation
- * @glyphs:  the glyph string to draw
- * @x:       the x position of the start of the string (in Pango
- *           units in user space coordinates)
- * @y:       the y position of the baseline (in Pango units
- *           in user space coordinates)
- *
- * Renders a #PangoGlyphString onto a FreeType2 bitmap, possibly
- * transforming the layed-out coordinates through a transformation
- * matrix. Note that the transformation matrix for @font is not
- * changed, so to produce correct rendering results, the @font
- * must have been loaded using a #PangoContext with an identical
- * transformation matrix to that passed in to this function.
- *
- * Since: 1.6
- **/
-void 
-pango_ft2_render_transformed (FT_Bitmap         *bitmap,
-			      const PangoMatrix *matrix,
-			      PangoFont         *font,
-			      PangoGlyphString  *glyphs,
-			      int                x, 
-			      int                y)
-{
-  FT_UInt glyph_index;
-  int i;
-  int x_position = 0;
-  int ix, iy, ixoff, iyoff, y_start, y_limit, x_start, x_limit;
-  PangoGlyphInfo *gi;
-  guchar *dest, *src;
-  gboolean add_glyph_to_cache;
-
-  g_return_if_fail (bitmap != NULL);
-  g_return_if_fail (glyphs != NULL);
-
-  PING (("bitmap: %dx%d@+%d+%d", bitmap->width, bitmap->rows, x, y));
-
-  gi = glyphs->glyphs;
-  for (i = 0; i < glyphs->num_glyphs; i++, gi++)
-    {
-      if (gi->glyph)
-	{
-	  PangoFT2RenderedGlyph *rendered_glyph;
-	  glyph_index = gi->glyph;
-
-	  rendered_glyph = _pango_ft2_font_get_cache_glyph_data (font,
-								 glyph_index);
-	  add_glyph_to_cache = FALSE;
-	  if (rendered_glyph == NULL)
-	    {
-	      rendered_glyph = pango_ft2_font_render_glyph (font, glyph_index);
-	      add_glyph_to_cache = TRUE;
-	    }
-
-	  if (matrix)
-	    {
-	      transform_point (matrix,
-			       x + x_position + gi->geometry.x_offset,
-			       y + gi->geometry.y_offset,
-			       &ixoff, &iyoff);
-	    }
-	  else
-	    {
-	      ixoff = PANGO_PIXELS (x + x_position + gi->geometry.x_offset);
-	      iyoff =  PANGO_PIXELS (y + gi->geometry.y_offset);
-	    }
-	  
-	  x_start = MAX (0, - (ixoff + rendered_glyph->bitmap_left));
-	  x_limit = MIN (rendered_glyph->bitmap.width,
-			 bitmap->width - (ixoff + rendered_glyph->bitmap_left));
-
-	  y_start = MAX (0,  - (iyoff - rendered_glyph->bitmap_top));
-	  y_limit = MIN (rendered_glyph->bitmap.rows,
-			 bitmap->rows - (iyoff - rendered_glyph->bitmap_top));
-
-	  PING (("glyph %d:%d: bitmap: %dx%d, left:%d top:%d",
-		 i, glyph_index,
-		 rendered_glyph->bitmap.width, rendered_glyph->bitmap.rows,
-		 rendered_glyph->bitmap_left, rendered_glyph->bitmap_top));
-	  PING (("xstart:%d xlim:%d ystart:%d ylim:%d",
-		 x_start, x_limit, y_start, y_limit));
-
-	  src = rendered_glyph->bitmap.buffer +
-	    y_start * rendered_glyph->bitmap.pitch;
-
-	  dest = bitmap->buffer +
-	    (y_start + iyoff - rendered_glyph->bitmap_top) * bitmap->pitch +
-	    x_start + ixoff + rendered_glyph->bitmap_left;
-
-	  switch (rendered_glyph->bitmap.pixel_mode)
-	    {
-	    case ft_pixel_mode_grays:
-	      src += x_start;
-	      for (iy = y_start; iy < y_limit; iy++)
-		{
-		  guchar *s = src;
-		  guchar *d = dest;
-
-		  for (ix = x_start; ix < x_limit; ix++)
-		    {
-		      switch (*s)
-			{
-			case 0:
-			  break;
-			case 0xff:
-			  *d = 0xff;
-			default:
-			  *d = MIN ((gushort) *d + (gushort) *s, 0xff);
-			  break;
-			}
-
-		      s++;
-		      d++;
-		    }
-
-		  dest += bitmap->pitch;
-		  src  += rendered_glyph->bitmap.pitch;
-		}
-	      break;
-
-	    case ft_pixel_mode_mono:
-	      src += x_start / 8;
-	      for (iy = y_start; iy < y_limit; iy++)
-		{
-		  guchar *s = src;
-		  guchar *d = dest;
-
-		  for (ix = x_start; ix < x_limit; ix++)
-		    {
-		      if ((*s) & (1 << (7 - (ix % 8))))
-			*d |= 0xff;
-		      
-		      if ((ix % 8) == 7)
-			s++;
-		      d++;
-		    }
-
-		  dest += bitmap->pitch;
-		  src  += rendered_glyph->bitmap.pitch;
-		}
-	      break;
-	      
-	    default:
-	      g_warning ("pango_ft2_render: "
-			 "Unrecognized glyph bitmap pixel mode %d\n",
-			 rendered_glyph->bitmap.pixel_mode);
-	      break;
-	    }
-
-	  if (add_glyph_to_cache)
-	    {
-	      _pango_ft2_font_set_glyph_cache_destroy (font,
-						       (GDestroyNotify) pango_ft2_free_rendered_glyph);
-	      _pango_ft2_font_set_cache_glyph_data (font,
-						    glyph_index, rendered_glyph);
-	    }
-	}
-
-      x_position += glyphs->glyphs[i].geometry.width;
-    }
-}
-
-/**
- * pango_ft2_render:
- * @bitmap:  the FreeType2 bitmap onto which to draw the string
- * @font:    the font in which to draw the string
- * @glyphs:  the glyph string to draw
- * @x:       the x position of the start of the string (in pixels)
- * @y:       the y position of the baseline (in pixels)
- *
- * Renders a #PangoGlyphString onto a FreeType2 bitmap.
- **/
-void 
-pango_ft2_render (FT_Bitmap        *bitmap,
-		  PangoFont        *font,
-		  PangoGlyphString *glyphs,
-		  int               x, 
-		  int               y)
-{
-  pango_ft2_render_transformed (bitmap, NULL, font, glyphs, x * PANGO_SCALE, y * PANGO_SCALE);
-}
-
 static PangoFT2GlyphInfo *
 pango_ft2_font_get_glyph_info (PangoFont   *font,
 			       PangoGlyph   glyph,
@@ -721,311 +465,6 @@ pango_ft2_get_unknown_glyph (PangoFont *font)
   return 0;
 }
 
-static void
-draw_underline (FT_Bitmap         *bitmap,
-		const PangoMatrix *matrix,
-		PangoFontMetrics  *metrics,
-		PangoUnderline     uline,
-		int                x,
-		int                width,
-		int                base_y,
-		int                descent)
-{
-  int underline_thickness = pango_font_metrics_get_underline_thickness (metrics);
-  int underline_position = pango_font_metrics_get_underline_position (metrics);
-  int y_off = 0;		/* Quiet GCC */
-
-  switch (uline)
-    {
-    case PANGO_UNDERLINE_NONE:
-      g_assert_not_reached();
-      break;
-    case PANGO_UNDERLINE_SINGLE:
-      y_off = - underline_position;
-      break;
-    case PANGO_UNDERLINE_DOUBLE:
-      y_off = - underline_position;
-      break;
-    case PANGO_UNDERLINE_LOW:
-      y_off = underline_thickness + descent;
-      break;
-    case PANGO_UNDERLINE_ERROR:
-      {
-	_pango_ft2_draw_error_underline (bitmap, matrix,
-					 x,
-					 base_y - underline_position,
-					 width,
-					 3 * underline_thickness);
-	return;
-      }
-    }
-
-  _pango_ft2_draw_rect (bitmap, matrix,
-			x,
-			base_y + y_off,
-			width,
-			underline_thickness);
-
-  if (uline == PANGO_UNDERLINE_DOUBLE)
-    {
-      y_off += 2 * underline_thickness;
-      
-      _pango_ft2_draw_rect (bitmap, matrix,
-			    x,
-			    base_y + y_off,
-			    width,
-			    underline_thickness);
-    }
-}
-
-static void
-draw_strikethrough (FT_Bitmap         *bitmap,
-		    const PangoMatrix *matrix,
-		    PangoFontMetrics  *metrics,
-		    int                x,
-		    int                width,
-		    int                base_y)
-{
-  int strikethrough_thickness = pango_font_metrics_get_strikethrough_thickness (metrics);
-  int strikethrough_position = pango_font_metrics_get_strikethrough_position (metrics);
-
-  _pango_ft2_draw_rect (bitmap, matrix,
-			x,
-			base_y - strikethrough_position,
-			width,
-			strikethrough_thickness);
-}
-
-/**
- * pango_ft2_render_layout_line_subpixel:
- * @bitmap:    a FT_Bitmap to render the line onto
- * @line:      a #PangoLayoutLine
- * @x:         the x position of start of string (in pango units)
- * @y:         the y position of baseline (in pango units)
- *
- * Render a #PangoLayoutLine onto a FreeType2 bitmap, with he
- * location specified in fixed-point pango units rather than
- * pixels. (Using this will avoid extra inaccuracies from
- * rounding to integer pixels multiple times, even if the
- * final glyph positions are integers.)
- *
- * Since: 1.6
- */
-void 
-pango_ft2_render_layout_line_subpixel (FT_Bitmap       *bitmap,
-				       PangoLayoutLine *line,
-				       int              x, 
-				       int              y)
-{
-  GSList *tmp_list = line->runs;
-  PangoRectangle logical_rect;
-  PangoRectangle ink_rect;
-  int x_off = 0;
-  const PangoMatrix *matrix;
-
-  matrix = pango_context_get_matrix (pango_layout_get_context (line->layout));
-
-  while (tmp_list)
-    {
-      PangoUnderline uline = PANGO_UNDERLINE_NONE;
-      gboolean strike, shape_set;
-      gint rise;
-      PangoLayoutRun *run = tmp_list->data;
-
-      tmp_list = tmp_list->next;
-
-      pango_ft2_get_item_properties (run->item,
-				     &uline, &strike, &rise,
-				     &shape_set, &ink_rect, &logical_rect);
-
-      if (!shape_set)
-	{
-	  if (uline == PANGO_UNDERLINE_NONE && !strike)
-	    pango_glyph_string_extents (run->glyphs, run->item->analysis.font,
-					NULL, &logical_rect);
-	  else
-	    pango_glyph_string_extents (run->glyphs, run->item->analysis.font,
-					&ink_rect, &logical_rect);
-	  
-	  pango_ft2_render_transformed (bitmap, matrix,
-					run->item->analysis.font, run->glyphs,
-					x + x_off, y - rise);
-
-	  if (uline != PANGO_UNDERLINE_NONE || strike)
-	    {
-	      PangoFontMetrics *metrics = pango_font_get_metrics (run->item->analysis.font,
-								  run->item->analysis.language);
-	      
-	      if (uline != PANGO_UNDERLINE_NONE)
-		draw_underline (bitmap, matrix, metrics,
-				uline,
-				x_off + ink_rect.x,
-				ink_rect.width,
-				y - rise,
-				ink_rect.y + ink_rect.height);
-	      
-	      if (strike)
-		draw_strikethrough (bitmap, matrix, metrics,
-				    x_off + ink_rect.x,
-				    ink_rect.width,
-				    y - rise);
-
-	      pango_font_metrics_unref (metrics);
-	    }
-	}
-
-      x_off += logical_rect.width;
-    }
-}
-
-
-/**
- * pango_ft2_render_layout_line:
- * @bitmap:    a FT_Bitmap to render the line onto
- * @line:      a #PangoLayoutLine
- * @x:         the x position of start of string (in pixels)
- * @y:         the y position of baseline (in pixels)
- *
- * Render a #PangoLayoutLine onto a FreeType2 bitmap
- */
-void 
-pango_ft2_render_layout_line (FT_Bitmap       *bitmap,
-			      PangoLayoutLine *line,
-			      int              x, 
-			      int              y)
-{
-  pango_ft2_render_layout_line_subpixel (bitmap, line, x * PANGO_SCALE, y * PANGO_SCALE);
-}
-
-
-/**
- * pango_ft2_render_layout_subpixel:
- * @bitmap:    a FT_Bitmap to render the layout onto
- * @layout:    a #PangoLayout
- * @x:         the X position of the left of the layout (in Pango units)
- * @y:         the Y position of the top of the layout (in Pango units)
- *
- * Render a #PangoLayout onto a FreeType2 bitmap, with he
- * location specified in fixed-point pango units rather than
- * pixels. (Using this will avoid extra inaccuracies from
- * rounding to integer pixels multiple times, even if the
- * final glyph positions are integers.)
- *
- * Since: 1.6
- */
-void 
-pango_ft2_render_layout_subpixel (FT_Bitmap   *bitmap,
-				  PangoLayout *layout,
-				  int          x, 
-				  int          y)
-{
-  PangoLayoutIter *iter;
-
-  g_return_if_fail (bitmap != NULL);
-  g_return_if_fail (PANGO_IS_LAYOUT (layout));
-
-  iter = pango_layout_get_iter (layout);
-
-  do
-    {
-      PangoRectangle   logical_rect;
-      PangoLayoutLine *line;
-      int              baseline;
-      
-      line = pango_layout_iter_get_line (iter);
-      
-      pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
-      baseline = pango_layout_iter_get_baseline (iter);
-
-      pango_ft2_render_layout_line_subpixel (bitmap,
-					     line,
-					     x + logical_rect.x,
-					     y + baseline);
-    }
-  while (pango_layout_iter_next_line (iter));
-
-  pango_layout_iter_free (iter);
-}
-
-/**
- * pango_ft2_render_layout:
- * @bitmap:    a FT_Bitmap to render the layout onto
- * @layout:    a #PangoLayout
- * @x:         the X position of the left of the layout (in pixels)
- * @y:         the Y position of the top of the layout (in pixels)
- *
- * Render a #PangoLayout onto a FreeType2 bitmap
- */
-void 
-pango_ft2_render_layout (FT_Bitmap   *bitmap,
-			 PangoLayout *layout,
-			 int          x, 
-			 int          y)
-{
-  pango_ft2_render_layout_subpixel (bitmap, layout, x * PANGO_SCALE, y * PANGO_SCALE);
-}
-
-/* This utility function is duplicated here and in pango-layout.c; should it be
- * public? Trouble is - what is the appropriate set of properties?
- */
-static void
-pango_ft2_get_item_properties (PangoItem      *item,
-			       PangoUnderline *uline,
-			       gboolean       *strikethrough,
-                               gint           *rise,
-			       gboolean       *shape_set,
-			       PangoRectangle *ink_rect,
-			       PangoRectangle *logical_rect)
-{
-  GSList *tmp_list = item->analysis.extra_attrs;
-
-  if (strikethrough)
-    *strikethrough = FALSE;
-
-  if (rise)
-    *rise = 0;
-
-  if (shape_set)
-    *shape_set = FALSE;
-
-  while (tmp_list)
-    {
-      PangoAttribute *attr = tmp_list->data;
-
-      switch (attr->klass->type)
-	{
-	case PANGO_ATTR_UNDERLINE:
-	  if (uline)
-	    *uline = ((PangoAttrInt *)attr)->value;
-	  break;
-	  
-	case PANGO_ATTR_STRIKETHROUGH:
-	  if (strikethrough)
-	    *strikethrough = ((PangoAttrInt *)attr)->value;
-	  break;
-
-	case PANGO_ATTR_SHAPE:
-	  if (shape_set)
-	    *shape_set = TRUE;
-	  if (logical_rect)
-	    *logical_rect = ((PangoAttrShape *)attr)->logical_rect;
-	  if (ink_rect)
-	    *ink_rect = ((PangoAttrShape *)attr)->ink_rect;
-	  break;
-
-        case PANGO_ATTR_RISE:
-          if (rise)
-            *rise = ((PangoAttrInt *)attr)->value;
-          break;
-
-	default:
-	  break;
-	}
-
-      tmp_list = tmp_list->next;
-    }
-}
-
 typedef struct
 {
   FT_Error     code;
@@ -1068,7 +507,6 @@ _pango_ft2_ft_strerror (FT_Error error)
     }
 }
 
-
 void *
 _pango_ft2_font_get_cache_glyph_data (PangoFont *font,
 				     int        glyph_index)
diff --git a/pango/pangoxft-font.c b/pango/pangoxft-font.c
index 9834ba6b..884d49a5 100644
--- a/pango/pangoxft-font.c
+++ b/pango/pangoxft-font.c
@@ -27,13 +27,10 @@
 #include "pangoxft-private.h"
 #include "pangofc-private.h"
 
-#define PANGO_XFT_FONT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_XFT_FONT, PangoXftFont))
 #define PANGO_XFT_FONT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_XFT_FONT, PangoXftFontClass))
 #define PANGO_XFT_IS_FONT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_XFT_FONT))
 #define PANGO_XFT_FONT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_XFT_FONT, PangoXftFontClass))
 
-#define PANGO_XFT_UNKNOWN_FLAG 0x10000000
-
 typedef struct _PangoXftFontClass    PangoXftFontClass;
 
 struct _PangoXftFontClass
@@ -105,11 +102,21 @@ _pango_xft_font_new (PangoXftFontMap *xftfontmap,
   return xfont;
 }
 
-static PangoFont *
-get_mini_font (PangoFont *font)
+/**
+ * _pango_xft_font_get_mini_font:
+ * @xfont: a #PangoXftFont
+ * 
+ * Gets the font used for drawing the digits in the
+ * missing-character hex squares
+ * 
+ * Return value: the PangoFont used for the digits; this
+ *  value is associated with the main font and will be freed
+ *  along with the main font.
+ **/
+PangoFont *
+_pango_xft_font_get_mini_font (PangoXftFont *xfont)
 {
-  PangoXftFont *xfont = (PangoXftFont *)font;
-  PangoFcFont *fcfont = (PangoFcFont *)font;
+  PangoFcFont *fcfont = (PangoFcFont *)xfont;
 
   g_assert (fcfont->fontmap);
 
@@ -142,257 +149,15 @@ get_mini_font (PangoFont *font)
 	}
 
       
-      xfont->mini_width = width;
-      xfont->mini_height = height;
-      xfont->mini_pad = MAX (height / 10, 1);
+      xfont->mini_width = PANGO_SCALE * width;
+      xfont->mini_height = PANGO_SCALE * height;
+      xfont->mini_pad = PANGO_SCALE * MAX (height / 10, 1);
     }
 
   return xfont->mini_font;
 }
 
 static void
-draw_rectangle (Display      *display,
-		Picture       src_picture,
-		Picture       dest_picture,
-		XftDraw      *draw,
-		XftColor     *color,
-		gint          x,
-		gint          y,
-		gint          width,
-		gint          height)
-{
-  if (draw)
-    {
-      XftDrawRect (draw, color, x, y, width, height);
-    }
-  else
-    {
-      XRenderComposite (display, PictOpOver, src_picture, None, dest_picture,
-			0, 0, 0, 0, x, y, width, height);
-    }
-}
-
-static void
-draw_box (Display      *display,
-	  Picture       src_picture,
-	  Picture       dest_picture,
-	  XftDraw      *draw,
-	  XftColor     *color,
-	  PangoXftFont *xfont,
-	  gint          x,
-	  gint          y,
-	  gint          width,
-	  gint          height)
-{
-  draw_rectangle (display, src_picture, dest_picture, draw, color,
-		  x, y, width, xfont->mini_pad);
-  draw_rectangle (display, src_picture, dest_picture, draw, color,
-		  x, y + xfont->mini_pad, xfont->mini_pad, height - xfont->mini_pad * 2);
-  draw_rectangle (display, src_picture, dest_picture, draw, color,
-		  x + width - xfont->mini_pad, y + xfont->mini_pad, xfont->mini_pad, height - xfont->mini_pad * 2);
-  draw_rectangle (display, src_picture, dest_picture, draw, color,
-		  x, y + height - xfont->mini_pad, width, xfont->mini_pad);
-}
-
-/**
- * pango_xft_render:
- * @draw:    the <type>XftDraw</type> object.
- * @color:   the color in which to draw the string
- * @font:    the font in which to draw the string
- * @glyphs:  the glyph string to draw
- * @x:       the x position of start of string (in pixels)
- * @y:       the y position of baseline (in pixels)
- *
- * Renders a #PangoGlyphString onto an <type>XftDraw</type> object wrapping an X drawable.
- */
-static void
-pango_xft_real_render (Display          *display,
-		       Picture           src_picture,
-		       Picture           dest_picture,
-		       XftDraw          *draw,
-		       XftColor         *color,
-		       PangoFont        *font,
-		       PangoGlyphString *glyphs,
-		       gint              x,
-		       gint              y)
-{
-  PangoXftFont *xfont = PANGO_XFT_FONT (font);
-  PangoFcFont *fcfont = PANGO_FC_FONT (font);
-  XftFont *xft_font = xft_font_get_font (font);
-  int i;
-  int x_off = 0;
-#define N_XFT_LOCAL	1024
-  XftGlyphSpec  xft_glyphs[N_XFT_LOCAL];
-  XftCharSpec	chars[6];     /* for unknown */
-  int		n_xft_glyph = 0;
-
-  if (!fcfont->fontmap)		/* Display closed */
-    return;
-
-#define FLUSH_GLYPHS() G_STMT_START {						\
-  if (n_xft_glyph)								\
-    {										\
-       if (draw)								\
-         XftDrawGlyphSpec (draw, color, xft_font, xft_glyphs, n_xft_glyph);	\
-       else									\
-         XftGlyphSpecRender (display, PictOpOver, src_picture, xft_font,	\
-	  		     dest_picture, 0, 0, xft_glyphs, n_xft_glyph);	\
-       n_xft_glyph = 0;								\
-    }										\
-  } G_STMT_END
-
-  if (!display)
-    _pango_xft_font_map_get_info (fcfont->fontmap, &display, NULL);
-
-  for (i=0; i<glyphs->num_glyphs; i++)
-    {
-      PangoGlyph glyph = glyphs->glyphs[i].glyph;
-      int glyph_x = x + PANGO_PIXELS (x_off + glyphs->glyphs[i].geometry.x_offset);
-      int glyph_y = y + PANGO_PIXELS (glyphs->glyphs[i].geometry.y_offset);
-
-      /* Clip glyphs into the X coordinate range; we really
-       * want to clip glyphs with an ink rect outside the
-       * [0,32767] x [0,32767] rectangle but looking up
-       * the ink rect here would be a noticeable speed hit.
-       * This is close enough.
-       */
-      if (glyph &&
-	  glyph_x >= -16384 && glyph_x <= 32767 &&
-	  glyph_y >= -16384 && glyph_y <= 32767)
-	{
-	  if (glyph & PANGO_XFT_UNKNOWN_FLAG)
-	    {
-	      char buf[7];
-	      int ys[3];
-	      int xs[4];
-	      int row, col;
-              int cols;
-	      
-	      PangoFont *mini_font = get_mini_font (font);
-	      XftFont *mini_xft = xft_font_get_font (mini_font);
-      
-	      glyph &= ~PANGO_XFT_UNKNOWN_FLAG;
-	      
-	      ys[0] = glyph_y - xft_font->ascent + (xft_font->ascent + xft_font->descent - xfont->mini_height * 2 - xfont->mini_pad * 5) / 2;
-	      ys[1] = ys[0] + 2 * xfont->mini_pad + xfont->mini_height;
-	      ys[2] = ys[1] + xfont->mini_height + xfont->mini_pad;
-
-	      xs[0] = glyph_x; 
-	      xs[1] = xs[0] + 2 * xfont->mini_pad;
-	      xs[2] = xs[1] + xfont->mini_width + xfont->mini_pad;
-	      xs[3] = xs[2] + xfont->mini_width + xfont->mini_pad;
-
-              if (glyph > 0xffff)
-                {
-                  cols = 3;
-                  g_snprintf (buf, sizeof(buf), "%06X", glyph);
-                }
-              else
-                {
-                  cols = 2;
-                  g_snprintf (buf, sizeof(buf), "%04X", glyph);
-                }
-
-	      draw_box (display, src_picture, dest_picture, draw, color, xfont,
-			xs[0], ys[0],
-			xfont->mini_width * cols + xfont->mini_pad * (2 * cols + 1),
-			xfont->mini_height * 2 + xfont->mini_pad * 5);
-
-	      FLUSH_GLYPHS ();
-	      for (row = 0; row < 2; row++)
-		for (col = 0; col < cols; col++)
-		  {
-		    XftCharSpec *c = &chars[row * cols + col];
-		    c->ucs4 = buf[row * cols + col] & 0xff;
-		    c->x = xs[col+1];
-		    c->y = ys[row+1];
-		  }
-	      if (draw)
-		XftDrawCharSpec (draw, color, mini_xft,
-				 chars, 2 * cols);
-	      else
-		XftCharSpecRender (display, PictOpOver, src_picture,
-				   mini_xft, dest_picture, 0, 0,
-				   chars, 2 * cols);
-	    }
-	  else if (glyph)
-	    {
-	      if (n_xft_glyph == N_XFT_LOCAL)
-		FLUSH_GLYPHS ();
-	      
-	      xft_glyphs[n_xft_glyph].x = glyph_x;
-	      xft_glyphs[n_xft_glyph].y = glyph_y;
-	      xft_glyphs[n_xft_glyph].glyph = glyph;
-	      n_xft_glyph++;
-	    }
-	}
-      
-      x_off += glyphs->glyphs[i].geometry.width;
-    }
-  
-  FLUSH_GLYPHS ();
-
-#undef FLUSH_GLYPHS
-}
-
-/**
- * pango_xft_render:
- * @draw:    the <type>XftDraw</type> object.
- * @color:   the color in which to draw the string
- * @font:    the font in which to draw the string
- * @glyphs:  the glyph string to draw
- * @x:       the x position of start of string (in pixels)
- * @y:       the y position of baseline (in pixels)
- *
- * Renders a #PangoGlyphString onto an <type>XftDraw</type> object wrapping an X drawable.
- */
-void
-pango_xft_render (XftDraw          *draw,
-		  XftColor         *color,
-		  PangoFont        *font,
-		  PangoGlyphString *glyphs,
-		  gint              x,
-		  gint              y)
-{
-  g_return_if_fail (draw != NULL);
-  g_return_if_fail (color != NULL);
-  g_return_if_fail (PANGO_XFT_IS_FONT (font));
-  g_return_if_fail (glyphs != NULL);
-  
-  pango_xft_real_render (NULL, None, None, draw, color, font, glyphs, x, y);
-}
-
-/**
- * pango_xft_picture_render:
- * @display:      an X display
- * @src_picture:  the source picture to draw the string with
- * @dest_picture: the destination picture to draw the strign onto
- * @font:         the font in which to draw the string
- * @glyphs:       the glyph string to draw
- * @x:            the x position of start of string (in pixels)
- * @y:            the y position of baseline (in pixels)
- *
- * Renders a #PangoGlyphString onto an Xrender <type>Picture</type> object.
- */
-void
-pango_xft_picture_render (Display          *display,
-			  Picture           src_picture,
-			  Picture           dest_picture,
-			  PangoFont        *font,
-			  PangoGlyphString *glyphs,
-			  gint              x,
-			  gint              y)
-{
-  g_return_if_fail (display != NULL);
-  g_return_if_fail (src_picture != None);
-  g_return_if_fail (dest_picture != None);
-  g_return_if_fail (PANGO_XFT_IS_FONT (font));
-  g_return_if_fail (glyphs != NULL);
-  
-  pango_xft_real_render (display, src_picture, dest_picture, NULL, NULL, font, glyphs, x, y);
-}
-
-static void
 pango_xft_font_finalize (GObject *object)
 {
   PangoXftFont *xfont = (PangoXftFont *)object;
@@ -427,7 +192,7 @@ get_glyph_extents_missing (PangoXftFont    *xfont,
   
   gint cols = (glyph & ~PANGO_XFT_UNKNOWN_FLAG) > 0xffff ? 3 : 2;
   
-  get_mini_font (font);
+  _pango_xft_font_get_mini_font (xfont);
   
   if (ink_rect)
     {
diff --git a/pango/pangoxft-fontmap.c b/pango/pangoxft-fontmap.c
index 6d91ea6b..cc3f62b5 100644
--- a/pango/pangoxft-fontmap.c
+++ b/pango/pangoxft-fontmap.c
@@ -49,6 +49,8 @@ struct _PangoXftFontMap
   PangoXftSubstituteFunc substitute_func;
   gpointer substitute_data;
   GDestroyNotify substitute_destroy;
+
+  PangoRenderer *renderer;
 };
 
 struct _PangoXftFontMapClass
@@ -87,6 +89,9 @@ pango_xft_font_map_finalize (GObject *object)
 {
   PangoXftFontMap *xftfontmap = PANGO_XFT_FONT_MAP (object);
   
+  if (xftfontmap->renderer)
+    g_object_unref (xftfontmap->renderer);
+
   fontmaps = g_slist_remove (fontmaps, object);
 
   if (xftfontmap->substitute_destroy)
@@ -323,6 +328,24 @@ pango_xft_get_context (Display *display,
   return pango_fc_font_map_create_context (PANGO_FC_FONT_MAP (fontmap));
 }
 
+/**
+ * _pango_xft_font_map_get_renderer:
+ * @fontmap: a #PangoXftFontmap
+ * 
+ * Gets the singleton PangoXFTRenderer for this fontmap.
+ * 
+ * Return value: 
+ **/
+PangoRenderer *
+_pango_xft_font_map_get_renderer (PangoXftFontMap *xftfontmap)
+{
+  if (!xftfontmap->renderer)
+    xftfontmap->renderer = pango_xft_renderer_new (xftfontmap->display,
+						   xftfontmap->screen);
+
+  return xftfontmap->renderer;
+}
+
 static void
 pango_xft_font_map_default_substitute (PangoFcFontMap *fcfontmap,
 				       FcPattern      *pattern)
diff --git a/pango/pangoxft-private.h b/pango/pangoxft-private.h
index cfd0b3fb..6a8a08af 100644
--- a/pango/pangoxft-private.h
+++ b/pango/pangoxft-private.h
@@ -22,13 +22,12 @@
 #ifndef __PANGOXFT_PRIVATE_H__
 #define __PANGOXFT_PRIVATE_H__
 
-#include <pangoxft.h>
-#include <pango-ot.h>
+#include "pangoxft.h"
+#include "pango-renderer.h"
 
 G_BEGIN_DECLS
 
-typedef struct _PangoXftFont    PangoXftFont;
-typedef struct _PangoXftFontMap PangoXftFontMap;
+#define PANGO_XFT_UNKNOWN_FLAG 0x10000000
 
 struct _PangoXftFont
 {
@@ -49,10 +48,15 @@ struct _PangoXftFont
 
 PangoXftFont *_pango_xft_font_new          (PangoXftFontMap  *xftfontmap,
 					    FcPattern        *pattern);
+
 void          _pango_xft_font_map_get_info (PangoFontMap     *fontmap,
 					    Display         **display,
 					    int              *screen);
 
+PangoRenderer *_pango_xft_font_map_get_renderer (PangoXftFontMap *xftfontmap);
+
+PangoFont *_pango_xft_font_get_mini_font (PangoXftFont *xfont);
+
 G_END_DECLS
 
 #endif /* __PANGOXFT_PRIVATE_H__ */
diff --git a/pango/pangoxft-render.c b/pango/pangoxft-render.c
new file mode 100644
index 00000000..145b6f59
--- /dev/null
+++ b/pango/pangoxft-render.c
@@ -0,0 +1,836 @@
+/* Pango
+ * pangoxft-render.c: Rendering routines for the Xft library
+ *
+ * Copyright (C) 2004 Red Hat Software
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <math.h>
+
+#include "pangoxft-render.h"
+#include "pangoxft-private.h"
+
+enum {
+  PROP_0,
+  PROP_DISPLAY,
+  PROP_SCREEN
+};
+
+struct _PangoXftRendererPrivate
+{
+  PangoColor default_color;
+
+  Picture src_picture;
+  Picture dest_picture;
+  
+  XRenderPictFormat *mask_format;
+
+  GArray *trapezoids;
+  PangoRenderPart trapezoid_part;
+
+  GArray *glyphs;
+  PangoFont *glyph_font;
+};
+
+static void pango_xft_renderer_finalize     (GObject      *object);
+static void pango_xft_renderer_set_property (GObject      *object,
+					     guint         prop_id,
+					     const GValue *value,
+					     GParamSpec   *pspec);
+
+static void pango_xft_renderer_real_composite_trapezoids (PangoXftRenderer *xftrenderer,
+							  PangoRenderPart   part,
+							  XTrapezoid       *trapezoids,
+							  int               n_trapezoids);
+static void pango_xft_renderer_real_composite_glyphs     (PangoXftRenderer *xftrenderer,
+							  XftFont          *xft_font,
+							  XftGlyphSpec     *glyphs,
+							  int               n_glyphs);
+
+static void pango_xft_renderer_draw_glyphs    (PangoRenderer    *renderer,
+					       PangoFont        *font,
+					       PangoGlyphString *glyphs,
+					       int               x,
+					       int               y);
+static void pango_xft_renderer_draw_glyph     (PangoRenderer    *renderer,
+					       PangoFont        *font,
+					       PangoGlyph        glyph,
+					       double            x,
+					       double            y);
+static void pango_xft_renderer_draw_trapezoid (PangoRenderer    *renderer,
+					       PangoRenderPart   part,
+					       double            y1,
+					       double            x11,
+					       double            x21,
+					       double            y2,
+					       double            x12,
+					       double            x22);
+static void pango_xft_renderer_part_changed   (PangoRenderer    *renderer,
+					       PangoRenderPart   part);
+static void pango_xft_renderer_end            (PangoRenderer    *renderer);
+
+static void flush_trapezoids (PangoXftRenderer *xftrenderer);
+static void flush_glyphs (PangoXftRenderer *xftrenderer);
+
+G_DEFINE_TYPE (PangoXftRenderer, pango_xft_renderer, PANGO_TYPE_RENDERER)
+
+static void
+pango_xft_renderer_init (PangoXftRenderer *xftrenderer)
+{
+  xftrenderer->priv = G_TYPE_INSTANCE_GET_PRIVATE (xftrenderer,
+						   PANGO_TYPE_XFT_RENDERER,
+						   PangoXftRendererPrivate);
+}
+
+static void
+pango_xft_renderer_class_init (PangoXftRendererClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);
+
+  klass->composite_glyphs = pango_xft_renderer_real_composite_glyphs;
+  klass->composite_trapezoids = pango_xft_renderer_real_composite_trapezoids;
+
+  renderer_class->draw_glyphs = pango_xft_renderer_draw_glyphs;
+  renderer_class->draw_glyph = pango_xft_renderer_draw_glyph;
+  renderer_class->draw_trapezoid = pango_xft_renderer_draw_trapezoid;
+  renderer_class->part_changed = pango_xft_renderer_part_changed;
+  renderer_class->end = pango_xft_renderer_end;
+
+  object_class->finalize = pango_xft_renderer_finalize;
+  object_class->set_property = pango_xft_renderer_set_property;
+
+  g_object_class_install_property (object_class, PROP_DISPLAY,
+				   g_param_spec_pointer ("display",
+							 "Display",
+							 "The display being rendered to",
+							 G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property (object_class, PROP_SCREEN,
+				   g_param_spec_int ("screen",
+						     "Screen",
+						     "The screen being rendered to",
+						     0, G_MAXINT, 0,
+						     G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+
+  g_type_class_add_private (object_class, sizeof (PangoXftRendererPrivate));
+}
+
+static void
+pango_xft_renderer_finalize (GObject *object)
+{
+  PangoXftRenderer *renderer = PANGO_XFT_RENDERER (object);
+
+  if (renderer->priv->glyphs)
+    g_array_free (renderer->priv->glyphs, TRUE);
+  if (renderer->priv->trapezoids)
+    g_array_free (renderer->priv->trapezoids, TRUE);
+
+  G_OBJECT_CLASS (pango_xft_renderer_parent_class)->finalize (object);
+}
+
+static void
+pango_xft_renderer_set_property (GObject      *object,
+				 guint         prop_id,
+				 const GValue *value,
+				 GParamSpec   *pspec)
+{
+  PangoXftRenderer *xftrenderer = PANGO_XFT_RENDERER (object);
+	
+  switch (prop_id)
+    {
+    case PROP_DISPLAY:
+      xftrenderer->display = g_value_get_pointer (value);
+      /* We possibly should use ARGB format when subpixel-AA is turned
+       * on for the fontmap; we could discover that using the technique
+       * for FC_DPI in pango_fc_face_list_sizes.
+       */
+      xftrenderer->priv->mask_format = XRenderFindStandardFormat (xftrenderer->display,
+								  PictStandardA8);
+      break;
+    case PROP_SCREEN:
+      xftrenderer->screen = g_value_get_int (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      
+      break;    
+    }
+}
+
+static void
+pango_xft_renderer_set_pictures (PangoXftRenderer *renderer,
+				 Picture           src_picture,
+				 Picture           dest_picture)
+{
+  renderer->priv->src_picture = src_picture;
+  renderer->priv->dest_picture = dest_picture;
+}
+
+static void
+flush_glyphs (PangoXftRenderer *xftrenderer)
+{
+  XftFont *xft_font;
+
+  if (!xftrenderer->priv->glyphs ||
+      xftrenderer->priv->glyphs->len == 0)
+    return;
+
+  xft_font = pango_xft_font_get_font (xftrenderer->priv->glyph_font);
+
+  PANGO_XFT_RENDERER_GET_CLASS (xftrenderer)->composite_glyphs (xftrenderer,
+								xft_font,
+								(XftGlyphSpec *)xftrenderer->priv->glyphs->data,
+								xftrenderer->priv->glyphs->len);
+
+  g_array_set_size (xftrenderer->priv->glyphs, 0);
+  g_object_unref (xftrenderer->priv->glyph_font);
+  xftrenderer->priv->glyph_font = NULL;
+}
+
+#define MAX_GLYPHS	1024
+
+static void
+draw_glyph (PangoRenderer *renderer,
+	    PangoFont     *font,
+	    FT_UInt        glyph,
+	    int            x,
+	    int            y)
+{
+  PangoXftRenderer *xftrenderer = PANGO_XFT_RENDERER (renderer);
+  XftGlyphSpec gs;
+  int pixel_x, pixel_y;
+
+  if (renderer->matrix)
+    {
+      pixel_x = floor (0.5 + (x * renderer->matrix->xx + y * renderer->matrix->xy) / PANGO_SCALE + renderer->matrix->x0);
+      pixel_y = floor (0.5 + (x * renderer->matrix->yx + y * renderer->matrix->yy) / PANGO_SCALE + renderer->matrix->y0);
+    }
+  else
+    {
+      pixel_x = PANGO_PIXELS (x);
+      pixel_y = PANGO_PIXELS (y);
+    }
+
+  /* Clip glyphs into the X coordinate range; we really
+   * want to clip glyphs with an ink rect outside the
+   * [0,32767] x [0,32767] rectangle but looking up
+   * the ink rect here would be a noticeable speed hit.
+   * This is close enough.
+   */
+  if (pixel_x < -32768 || pixel_x > 32767 ||
+      pixel_y < -32768 || pixel_y > 32767)
+    return;
+      
+  flush_trapezoids (xftrenderer);
+
+  if (!xftrenderer->priv->glyphs)
+    xftrenderer->priv->glyphs = g_array_new (FALSE, FALSE,
+					     sizeof (XftGlyphSpec));
+  
+  if (xftrenderer->priv->glyph_font != font)
+    {
+      flush_glyphs (xftrenderer);
+      
+      xftrenderer->priv->glyph_font = g_object_ref (font);
+    }
+
+  if (xftrenderer->priv->glyphs->len == MAX_GLYPHS)
+    flush_glyphs (xftrenderer);
+
+  gs.x = pixel_x;
+  gs.y = pixel_y;
+  gs.glyph = glyph;
+
+  g_array_append_val (xftrenderer->priv->glyphs, gs);
+}
+
+static gboolean
+point_in_bounds (PangoRenderer *renderer,
+		 gint           x,
+		 gint           y)
+{
+  gdouble pixel_x = (x * renderer->matrix->xx + y * renderer->matrix->xy) / PANGO_SCALE + renderer->matrix->x0;
+  gdouble pixel_y = (x * renderer->matrix->yx + y * renderer->matrix->yy) / PANGO_SCALE + renderer->matrix->y0;
+
+  return (pixel_x >= -32768. && pixel_x < 32768. &&
+	  pixel_y >= -32768. && pixel_y < 32768.);
+}
+
+static gboolean
+box_in_bounds (PangoRenderer *renderer,
+	       gint           x,
+	       gint           y,
+	       gint           width,
+	       gint           height)
+{
+  if (!renderer->matrix)
+    {
+#define COORD_MIN (PANGO_SCALE * -16384 - PANGO_SCALE / 2)
+#define COORD_MAX (PANGO_SCALE * -32767 + PANGO_SCALE / 2 - 1)
+      return (x >= COORD_MIN && x + width <= COORD_MAX &&
+	      y >= COORD_MIN && y + width <= COORD_MAX);
+#undef COORD_MIN
+#undef COORD_MAX
+    }
+  else
+    {
+      return (point_in_bounds (renderer, x, y) &&
+	      point_in_bounds (renderer, x + width, y) &&
+	      point_in_bounds (renderer, x + width, y + height) &&
+	      point_in_bounds (renderer, x, y + height));
+    }
+}
+
+static void
+draw_box (PangoRenderer *renderer,
+	  PangoXftFont  *xfont,
+	  gint           x,
+	  gint           y,
+	  gint           width,
+	  gint           height)
+{
+  pango_renderer_draw_rectangle (renderer, PANGO_RENDER_PART_FOREGROUND,
+				 x, y, width, xfont->mini_pad);
+  pango_renderer_draw_rectangle (renderer, PANGO_RENDER_PART_FOREGROUND,
+				 x, y + xfont->mini_pad, xfont->mini_pad, height - xfont->mini_pad * 2);
+  pango_renderer_draw_rectangle (renderer, PANGO_RENDER_PART_FOREGROUND,
+				 x + width - xfont->mini_pad, y + xfont->mini_pad, xfont->mini_pad, height - xfont->mini_pad * 2);
+  pango_renderer_draw_rectangle (renderer, PANGO_RENDER_PART_FOREGROUND,
+				 x, y + height - xfont->mini_pad, width, xfont->mini_pad);
+}
+
+static void
+pango_xft_renderer_draw_glyphs (PangoRenderer    *renderer,
+				PangoFont        *font,
+				PangoGlyphString *glyphs,
+				int               x,
+				int               y)
+{
+  PangoXftFont *xfont = PANGO_XFT_FONT (font);
+  PangoFcFont *fcfont = PANGO_FC_FONT (font);
+  XftFont *xft_font = pango_xft_font_get_font (font);
+  int i;
+  int x_off = 0;
+
+  if (!fcfont->fontmap)		/* Display closed */
+    return;
+
+  for (i=0; i<glyphs->num_glyphs; i++)
+    {
+      PangoGlyph glyph = glyphs->glyphs[i].glyph;
+      int glyph_x = x + x_off + glyphs->glyphs[i].geometry.x_offset;
+      int glyph_y = y + glyphs->glyphs[i].geometry.y_offset;
+
+      if (glyph)
+	{
+	  if (glyph & PANGO_XFT_UNKNOWN_FLAG)
+	    {
+	      char buf[7];
+	      int ys[3];
+	      int xs[4];
+	      int row, col;
+              int cols;
+	      
+	      PangoFont *mini_font = _pango_xft_font_get_mini_font (xfont);
+	      
+	      glyph &= ~PANGO_XFT_UNKNOWN_FLAG;
+	      
+	      ys[0] = glyph_y - PANGO_SCALE * xft_font->ascent + (PANGO_SCALE * (xft_font->ascent + xft_font->descent) - xfont->mini_height * 2 - xfont->mini_pad * 5) / 2;
+	      ys[1] = ys[0] + 2 * xfont->mini_pad + xfont->mini_height;
+	      ys[2] = ys[1] + xfont->mini_height + xfont->mini_pad;
+
+	      xs[0] = glyph_x; 
+	      xs[1] = xs[0] + 2 * xfont->mini_pad;
+	      xs[2] = xs[1] + xfont->mini_width + xfont->mini_pad;
+	      xs[3] = xs[2] + xfont->mini_width + xfont->mini_pad;
+
+              if (glyph > 0xffff)
+                {
+                  cols = 3;
+                  g_snprintf (buf, sizeof(buf), "%06X", glyph);
+                }
+              else
+                {
+                  cols = 2;
+                  g_snprintf (buf, sizeof(buf), "%04X", glyph);
+                }
+
+	      if (box_in_bounds (renderer,
+				 xs[0], ys[0],
+				 xfont->mini_width * cols + xfont->mini_pad * (2 * cols + 1),
+				 xfont->mini_height * 2 + xfont->mini_pad * 5))
+		{
+		  draw_box (renderer, xfont,
+			    xs[0], ys[0],
+			    xfont->mini_width * cols + xfont->mini_pad * (2 * cols + 1),
+			    xfont->mini_height * 2 + xfont->mini_pad * 5);
+		  
+		  for (row = 0; row < 2; row++)
+		    for (col = 0; col < cols; col++)
+		      {
+			draw_glyph (renderer, mini_font,
+				    XftCharIndex (NULL, xft_font,
+						  buf[row * cols + col] & 0xff),
+				    xs[col+1],
+				    ys[row+1]);
+		      }
+		}
+	    }
+	  else if (glyph)
+	    {
+	      draw_glyph (renderer, font,
+			  glyph, glyph_x, glyph_y);
+	    }
+	}
+      
+      x_off += glyphs->glyphs[i].geometry.width;
+    }
+}
+
+static void
+pango_xft_renderer_draw_glyph (PangoRenderer   *renderer,
+			       PangoFont       *font,
+			       PangoGlyph       glyph,
+			       double           x,
+			       double           y)
+{
+  g_error ("pango_xft_renderer_draw_glyph(): should not be called\n");
+}
+
+static void
+flush_trapezoids (PangoXftRenderer *xftrenderer)
+{
+  if (!xftrenderer->priv->trapezoids ||
+      xftrenderer->priv->trapezoids->len == 0)
+    return;
+
+  PANGO_XFT_RENDERER_GET_CLASS (xftrenderer)->composite_trapezoids (xftrenderer,
+								    xftrenderer->priv->trapezoid_part,
+								    (XTrapezoid *)xftrenderer->priv->trapezoids->data,
+								    xftrenderer->priv->trapezoids->len);
+
+  g_array_set_size (xftrenderer->priv->trapezoids, 0);
+}
+
+static void
+pango_xft_renderer_draw_trapezoid (PangoRenderer   *renderer,
+				   PangoRenderPart  part,
+				   double           y1,
+				   double           x11,
+				   double           x21,
+				   double           y2,
+				   double           x12,
+				   double           x22)
+{
+  PangoXftRenderer *xftrenderer = PANGO_XFT_RENDERER (renderer);
+  XTrapezoid trap;
+
+  flush_glyphs (xftrenderer);
+
+  if (!xftrenderer->priv->trapezoids)
+    xftrenderer->priv->trapezoids = g_array_new (FALSE, FALSE,
+						 sizeof (XTrapezoid));
+  
+  if (xftrenderer->draw)
+    {
+      if (xftrenderer->priv->trapezoids->len > 0 &&
+	  xftrenderer->priv->trapezoid_part != part)
+	flush_trapezoids (xftrenderer);
+
+      xftrenderer->priv->trapezoid_part = part;
+    }
+
+  trap.top = XDoubleToFixed (y1);
+  trap.bottom = XDoubleToFixed (y2);
+  trap.left.p1.x = XDoubleToFixed (x11);
+  trap.left.p1.y = XDoubleToFixed (y1);
+  trap.left.p2.x = XDoubleToFixed (x12);
+  trap.left.p2.y = XDoubleToFixed (y2);
+  trap.right.p1.x = XDoubleToFixed (x21);
+  trap.right.p1.y = XDoubleToFixed (y1);
+  trap.right.p2.x = XDoubleToFixed (x22);
+  trap.right.p2.y = XDoubleToFixed (y2);
+
+  g_array_append_val (xftrenderer->priv->trapezoids, trap);
+}
+
+static void
+pango_xft_renderer_part_changed (PangoRenderer   *renderer,
+				 PangoRenderPart  part)
+{
+  PangoXftRenderer *xftrenderer = PANGO_XFT_RENDERER (renderer);
+
+  if (part == PANGO_RENDER_PART_FOREGROUND)
+    flush_glyphs (xftrenderer);
+
+  if (part == xftrenderer->priv->trapezoid_part)
+    flush_trapezoids (xftrenderer);
+}
+
+static void
+pango_xft_renderer_end (PangoRenderer *renderer)
+{
+  PangoXftRenderer *xftrenderer = PANGO_XFT_RENDERER (renderer);
+
+  flush_glyphs (xftrenderer);
+  flush_trapezoids (xftrenderer);
+}
+
+static void
+pango_xft_renderer_real_composite_trapezoids (PangoXftRenderer *xftrenderer,
+					      PangoRenderPart   part,
+					      XTrapezoid       *trapezoids,
+					      int               n_trapezoids)
+{
+  Picture src_picture;
+  Picture dest_picture;
+
+  if (!XftDefaultHasRender (xftrenderer->display))
+      return;
+
+  if (xftrenderer->priv->src_picture != None)
+    {
+      src_picture = xftrenderer->priv->src_picture;
+      dest_picture = xftrenderer->priv->dest_picture;
+    }
+  else
+    {
+      XftColor xft_color;
+      PangoColor *color = pango_renderer_get_color (PANGO_RENDERER (xftrenderer),
+						    part);
+      if (!color)
+	color = &xftrenderer->priv->default_color;
+	  
+      xft_color.color.red = color->red;
+      xft_color.color.green = color->green;
+      xft_color.color.blue = color->blue;
+      xft_color.color.alpha = 0xffff;
+
+      src_picture = XftDrawSrcPicture (xftrenderer->draw, &xft_color);
+      dest_picture = XftDrawPicture (xftrenderer->draw);
+    }
+
+  XRenderCompositeTrapezoids (xftrenderer->display,
+			      PictOpOver,
+			      src_picture, dest_picture,
+			      xftrenderer->priv->mask_format,
+			      0, 0,
+			      trapezoids, n_trapezoids);
+}
+
+static void
+pango_xft_renderer_real_composite_glyphs (PangoXftRenderer *xftrenderer,
+					  XftFont          *xft_font,
+					  XftGlyphSpec     *glyphs,
+					  int               n_glyphs)
+{
+  if (xftrenderer->priv->src_picture != None)
+    {
+      XftGlyphSpecRender (xftrenderer->display, PictOpOver,
+			  xftrenderer->priv->src_picture,
+			  xft_font,
+			  xftrenderer->priv->dest_picture, 0, 0,
+			  glyphs, n_glyphs);
+    }
+  else
+    {
+      XftColor xft_color;
+      PangoColor *color = pango_renderer_get_color (PANGO_RENDERER (xftrenderer),
+						    PANGO_RENDER_PART_FOREGROUND);
+      if (!color)
+      	color = &xftrenderer->priv->default_color;
+      
+      xft_color.color.red = color->red;
+      xft_color.color.green = color->green;
+      xft_color.color.blue = color->blue;
+      xft_color.color.alpha = 0xffff;
+
+      XftDrawGlyphSpec (xftrenderer->draw, &xft_color,
+			xft_font,
+			glyphs, n_glyphs);
+    }
+}
+
+static PangoRenderer *
+get_renderer (PangoFontMap *fontmap,
+	      XftDraw      *draw,
+	      XftColor     *color)
+{
+  PangoRenderer *renderer;
+  PangoColor pango_color;
+  
+  renderer = _pango_xft_font_map_get_renderer (PANGO_XFT_FONT_MAP (fontmap));
+  
+  pango_xft_renderer_set_draw (PANGO_XFT_RENDERER (renderer), draw);
+
+  pango_color.red = color->color.red;
+  pango_color.green = color->color.green;
+  pango_color.blue = color->color.blue;
+  pango_xft_renderer_set_default_color (PANGO_XFT_RENDERER (renderer), &pango_color);
+
+  return renderer;
+}
+
+/**
+ * pango_xft_render_layout:
+ * @draw:      an #XftDraw
+ * @color:     the foreground color in which to draw the layout
+ *             (may be overriden by color attributes)
+ * @layout:    a #PangoLayout
+ * @x:         the X position of the left of the layout (in Pango units)
+ * @y:         the Y position of the top of the layout (in Pango units)
+ *
+ * Render a #PangoLayout onto a #XftDraw
+ *
+ * Since: 1.8
+ */
+void 
+pango_xft_render_layout (XftDraw     *draw,
+			 XftColor    *color,
+			 PangoLayout *layout,
+			 int          x, 
+			 int          y)
+{
+  PangoContext *context;
+  PangoFontMap *fontmap;
+  PangoRenderer *renderer;
+
+  g_return_if_fail (draw != NULL);
+  g_return_if_fail (color != NULL);
+  g_return_if_fail (PANGO_IS_LAYOUT (layout));
+
+  context = pango_layout_get_context (layout);
+  fontmap = pango_context_get_font_map (context);
+  renderer = get_renderer (fontmap, draw, color);
+
+  pango_renderer_draw_layout (renderer, layout, x, y);
+}
+
+/**
+ * pango_xft_render_layout_line:
+ * @draw:      an #XftDraw
+ * @color:     the foreground color in which to draw the layout line
+ *             (may be overriden by color attributes)
+ * @line:      a #PangoLayoutLine
+ * @x:         the x position of start of string (in pango units)
+ * @y:         the y position of baseline (in pango units)
+ *
+ * Render a #PangoLayoutLine onto a #XftDraw
+ *
+ * Since: 1.8
+ */
+void 
+pango_xft_render_layout_line (XftDraw         *draw,
+			      XftColor        *color,
+			      PangoLayoutLine *line,
+			      int              x, 
+			      int              y)
+{
+  PangoContext *context;
+  PangoFontMap *fontmap;
+  PangoRenderer *renderer;
+
+  g_return_if_fail (draw != NULL);
+  g_return_if_fail (color != NULL);
+  g_return_if_fail (line != NULL);
+
+  context = pango_layout_get_context (line->layout);
+  fontmap = pango_context_get_font_map (context);
+  renderer = get_renderer (fontmap, draw, color);
+  
+  pango_renderer_draw_layout_line (renderer, line, x, y);
+}
+
+/**
+ * pango_xft_render_transformed:
+ * @draw:    an #XftDraw
+ * @color:   the color in which to draw the glyphs
+ * @font:    the font in which to draw the string
+ * @matrix: a #PangoMatrix, or %NULL to use an identity transformation
+ * @glyphs:  the glyph string to draw
+ * @x:       the x position of the start of the string (in Pango
+ *           units in user space coordinates)
+ * @y:       the y position of the baseline (in Pango units
+ *           in user space coordinates)
+ *
+ * Renders a #PangoGlyphString onto a #XftDraw, possibly
+ * transforming the layed-out coordinates through a transformation
+ * matrix. Note that the transformation matrix for @font is not
+ * changed, so to produce correct rendering results, the @font
+ * must have been loaded using a #PangoContext with an identical
+ * transformation matrix to that passed in to this function.
+ *
+ * Since: 1.8
+ **/
+void 
+pango_xft_render_transformed (XftDraw          *draw,
+			      XftColor         *color,
+			      PangoMatrix      *matrix,
+			      PangoFont        *font,
+			      PangoGlyphString *glyphs,
+			      int               x, 
+			      int               y)
+{
+  PangoFontMap *fontmap;
+  PangoRenderer *renderer;
+
+  g_return_if_fail (draw != NULL);
+  g_return_if_fail (color != NULL);
+  g_return_if_fail (PANGO_XFT_IS_FONT (font));
+  g_return_if_fail (glyphs != NULL);
+
+  fontmap = PANGO_FC_FONT (font)->fontmap;
+  renderer = get_renderer (fontmap, draw, color);
+
+  pango_renderer_set_matrix (renderer, matrix);
+  
+  pango_renderer_draw_glyphs (renderer, font, glyphs, x, y);
+}
+
+/**
+ * pango_xft_render:
+ * @draw:    the <type>XftDraw</type> object.
+ * @color:   the color in which to draw the string
+ * @font:    the font in which to draw the string
+ * @glyphs:  the glyph string to draw
+ * @x:       the x position of start of string (in pixels)
+ * @y:       the y position of baseline (in pixels)
+ *
+ * Renders a #PangoGlyphString onto an <type>XftDraw</type> object wrapping an X drawable.
+ */
+void
+pango_xft_render (XftDraw          *draw,
+		  XftColor         *color,
+		  PangoFont        *font,
+		  PangoGlyphString *glyphs,
+		  gint              x,
+		  gint              y)
+{
+  g_return_if_fail (draw != NULL);
+  g_return_if_fail (color != NULL);
+  g_return_if_fail (PANGO_XFT_IS_FONT (font));
+  g_return_if_fail (glyphs != NULL);
+  
+  pango_xft_render_transformed (draw, color, NULL, font, glyphs,
+				x * PANGO_SCALE, y * PANGO_SCALE);
+}
+
+/**
+ * pango_xft_picture_render:
+ * @display:      an X display
+ * @src_picture:  the source picture to draw the string with
+ * @dest_picture: the destination picture to draw the strign onto
+ * @font:         the font in which to draw the string
+ * @glyphs:       the glyph string to draw
+ * @x:            the x position of start of string (in pixels)
+ * @y:            the y position of baseline (in pixels)
+ *
+ * Renders a #PangoGlyphString onto an Xrender <type>Picture</type> object.
+ */
+void
+pango_xft_picture_render (Display          *display,
+			  Picture           src_picture,
+			  Picture           dest_picture,
+			  PangoFont        *font,
+			  PangoGlyphString *glyphs,
+			  gint              x,
+			  gint              y)
+{
+  PangoFontMap *fontmap;
+  PangoRenderer *renderer;
+
+  g_return_if_fail (display != NULL);
+  g_return_if_fail (src_picture != None);
+  g_return_if_fail (dest_picture != None);
+  g_return_if_fail (PANGO_XFT_IS_FONT (font));
+  g_return_if_fail (glyphs != NULL);
+  
+  fontmap = PANGO_FC_FONT (font)->fontmap;
+  renderer = _pango_xft_font_map_get_renderer (PANGO_XFT_FONT_MAP (fontmap));
+
+  pango_xft_renderer_set_pictures (PANGO_XFT_RENDERER (renderer),
+				   src_picture, dest_picture);
+  pango_renderer_set_matrix (renderer, NULL);
+  
+  pango_renderer_draw_glyphs (renderer, font, glyphs, x * PANGO_SCALE, y * PANGO_SCALE);
+  
+  pango_xft_renderer_set_pictures (PANGO_XFT_RENDERER (renderer),
+				   None, None);
+}
+
+/**
+ * pango_xft_renderer_new:
+ * @display: an X display
+ * @screen:   the index of the screen for @display to which rendering will be done
+ * 
+ * Create a new #PangoXftRenderer to allow rendering Pango objects
+ * with the Xft library.
+ *
+ * Return value: the newly created #PangoXftRenderer object. Unref
+ * with g_object_unref() when you are finished with it.
+ *
+ * Since: 1.8
+ **/
+PangoRenderer *
+pango_xft_renderer_new (Display *display,
+			int      screen)
+{
+  PangoXftRenderer *xftrenderer;
+
+  xftrenderer = g_object_new (PANGO_TYPE_XFT_RENDERER,
+			      "display", display,
+			      "screen", screen,
+			      NULL);
+  
+  return PANGO_RENDERER (xftrenderer);
+}
+
+/**
+ * pango_xft_renderer_set_draw:
+ * @xftrenderer: a #PangoXftRenderer
+ * @draw: a #XftDraw
+ * 
+ * Sets the #XftDraw object that the renderer is drawing to.
+ * The renderer must not be currently active.
+ *
+ * Since: 1.8
+ **/
+void
+pango_xft_renderer_set_draw (PangoXftRenderer *xftrenderer,
+			     XftDraw          *draw)
+{
+  g_return_if_fail (PANGO_IS_XFT_RENDERER (xftrenderer));
+
+  xftrenderer->draw = draw;
+}
+
+/**
+ * pango_xft_renderer_set_default_color:
+ * @xftrenderer: a #XftRenderer
+ * @default_color: the default foreground color
+ * 
+ * Sets the default foreground color for a #XftRenderer.
+ *
+ * Since: 1.8
+ **/
+void
+pango_xft_renderer_set_default_color (PangoXftRenderer *xftrenderer,
+				      PangoColor       *default_color)
+{
+  g_return_if_fail (PANGO_IS_XFT_RENDERER (xftrenderer));
+		    
+  xftrenderer->priv->default_color = *default_color;
+}
diff --git a/pango/pangoxft-render.h b/pango/pangoxft-render.h
new file mode 100644
index 00000000..00390928
--- /dev/null
+++ b/pango/pangoxft-render.h
@@ -0,0 +1,142 @@
+/* Pango
+ * pangoxft-render.h: Rendering routines for the Xft library
+ *
+ * Copyright (C) 2004 Red Hat Software
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __PANGOXFT_RENDER_H__
+#define __PANGOXFT_RENDER_H__
+
+#include <pango/pango-renderer.h>
+
+G_BEGIN_DECLS
+
+#define _XFT_NO_COMPAT
+#define _XFTCOMPAT_H_
+#include <X11/Xlib.h>
+#include <X11/Xft/Xft.h>
+#if defined(XftVersion) && XftVersion >= 20000
+#else
+#error "must have Xft version 2 or newer"
+#endif
+
+typedef struct _PangoXftRenderer        PangoXftRenderer;
+typedef struct _PangoXftRendererClass   PangoXftRendererClass;
+typedef struct _PangoXftRendererPrivate PangoXftRendererPrivate;
+
+#define PANGO_TYPE_XFT_RENDERER            (pango_xft_renderer_get_type())
+#define PANGO_XFT_RENDERER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_XFT_RENDERER, PangoXftRenderer))
+#define PANGO_IS_XFT_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_RENDERER))
+#define PANGO_XFT_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_XFT_RENDERER, PangoXftRendererClass))
+#define PANGO_IS_XFT_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_XFT_RENDERER))
+#define PANGO_XFT_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_XFT_RENDERER, PangoXftRendererClass))
+
+/**
+ * PangoXftRenderer
+ *
+ * #PangoXftRenderer is a subclass of #PangoRenderer used for rendering
+ * with Pango's Xft backend. It can be used directly, or it can be
+ * further subclassed to modify exactly how drawing of individual
+ * elements occurs.
+ *
+ * Since: 1.8
+ */
+struct _PangoXftRenderer
+{
+  /*< private >*/	
+  PangoRenderer parent_instance;
+
+  Display *display;
+  int screen;
+  XftDraw *draw;
+
+  PangoXftRendererPrivate *priv;
+};
+
+/**
+ * PangoXftRendererClass
+ * @composite_trapezoids: draw the specified trapezoids using
+ *   the current color and other attributes for @part
+ * @composite_glyphs: draw the specified glyphs using
+ *   the current color and other attributes for @part
+ *
+ * #PangoXftRenderer is a subclass of #PangoRenderer used for rendering
+ * Renders a #PangoGlyphString onto an Xrender <type>Picture</type> object.
+ *
+ * Since: 1.8
+ */
+struct _PangoXftRendererClass
+{
+  /*< private >*/	
+  PangoRendererClass parent_class;
+
+  /*< public >*/
+  void (*composite_trapezoids) (PangoXftRenderer *xftrenderer,
+				PangoRenderPart   part,
+				XTrapezoid       *trapezoids,
+				int               n_trapezoids);
+  void (*composite_glyphs)     (PangoXftRenderer *xftrenderer,
+				XftFont          *xft_font,
+				XftGlyphSpec     *glyphs,
+				int               n_glyphs);
+};
+
+GType pango_xft_renderer_get_type    (void);
+
+PangoRenderer *pango_xft_renderer_new                 (Display          *display,
+						       int               screen);
+void           pango_xft_renderer_set_draw            (PangoXftRenderer *xftrenderer,
+						       XftDraw          *draw);
+void           pango_xft_renderer_set_default_color   (PangoXftRenderer *xftrenderer,
+						       PangoColor       *default_color);
+
+void pango_xft_render             (XftDraw          *draw,
+				   XftColor         *color,
+				   PangoFont        *font,
+				   PangoGlyphString *glyphs,
+				   gint              x,
+				   gint              y);
+void pango_xft_picture_render     (Display          *display,
+				   Picture           src_picture,
+				   Picture           dest_picture,
+				   PangoFont        *font,
+				   PangoGlyphString *glyphs,
+				   gint              x,
+				   gint              y);
+void pango_xft_render_transformed (XftDraw          *draw,
+				   XftColor         *color,
+				   PangoMatrix      *matrix,
+				   PangoFont        *font,
+				   PangoGlyphString *glyphs,
+				   int               x,
+				   int               y);
+void pango_xft_render_layout_line (XftDraw          *draw,
+				   XftColor         *color,
+				   PangoLayoutLine  *line,
+				   int               x,
+				   int               y);
+void pango_xft_render_layout      (XftDraw          *draw,
+				   XftColor         *color,
+				   PangoLayout      *layout,
+				   int               x,
+				   int               y);
+
+G_END_DECLS
+
+#endif /* __PANGOXFT_RENDER_H__ */
+
diff --git a/pango/pangoxft.h b/pango/pangoxft.h
index 3f6ecfd5..52c1d496 100644
--- a/pango/pangoxft.h
+++ b/pango/pangoxft.h
@@ -26,22 +26,23 @@
 #include <pango/pango-context.h>
 #include <pango/pango-ot.h>
 #include <pango/pangofc-font.h>
+#include <pango/pango-layout.h>
+#include <pango/pangoxft-render.h>
 
 G_BEGIN_DECLS
 
-#define _XFT_NO_COMPAT
-#define _XFTCOMPAT_H_
-#include <X11/Xlib.h>
-#include <X11/Xft/Xft.h>
-#if defined(XftVersion) && XftVersion >= 20000
-#else
-#error "must have Xft version 2 or newer"
-#endif
-
 #ifndef PANGO_DISABLE_DEPRECATED
 #define PANGO_RENDER_TYPE_XFT "PangoRenderXft"
 #endif
 
+#define PANGO_TYPE_XFT_FONT_MAP              (pango_xft_font_map_get_type ())
+#define PANGO_XFT_FONT_MAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_XFT_FONT_MAP, PangoXftFontMap))
+#define PANGO_XFT_IS_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_FONT_MAP))
+
+typedef struct _PangoXftFontMap      PangoXftFontMap;
+
+typedef struct _PangoXftFont    PangoXftFont;
+
 typedef void (*PangoXftSubstituteFunc) (FcPattern *pattern,
                                         gpointer   data);
 
@@ -54,20 +55,6 @@ PangoContext *pango_xft_get_context      (Display *display,
 void          pango_xft_shutdown_display (Display *display,
 					  int      screen);
 
-void          pango_xft_render         (XftDraw          *draw,
-					XftColor         *color,
-					PangoFont        *font,
-					PangoGlyphString *glyphs,
-					gint              x,
-					gint              y);
-void          pango_xft_picture_render (Display          *display,
-					Picture           src_picture,
-					Picture           dest_picture,
-					PangoFont        *font,
-					PangoGlyphString *glyphs,
-					gint              x,
-					gint              y);
-
 void pango_xft_set_default_substitute (Display                *display,
 				       int                     screen,
 				       PangoXftSubstituteFunc  func,
@@ -76,6 +63,9 @@ void pango_xft_set_default_substitute (Display                *display,
 void pango_xft_substitute_changed     (Display                *display,
 				       int                     screen);
 
+GType pango_xft_font_map_get_type (void);
+
+#define PANGO_XFT_FONT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_XFT_FONT, PangoXftFont))
 #define PANGO_TYPE_XFT_FONT              (pango_xft_font_get_type ())
 #define PANGO_XFT_IS_FONT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_FONT))