Initial commit0.0.0

32 files changed, 4609 insertions, 0 deletions

diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-attributes.h b/gtk+-mingw/include/pango-1.0/pango/pango-attributes.h
new file mode 100644
index 0000000..59f97a3
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-attributes.h
@@ -0,0 +1,280 @@
+/* Pango
+ * pango-attributes.h: Attributed text
+ *
+ * Copyright (C) 2000 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 __PANGO_ATTRIBUTES_H__
+#define __PANGO_ATTRIBUTES_H__
+
+#include <pango/pango-font.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* PangoColor */
+
+typedef struct _PangoColor PangoColor;
+
+struct _PangoColor
+{
+  guint16 red;
+  guint16 green;
+  guint16 blue;
+};
+
+#define PANGO_TYPE_COLOR pango_color_get_type ()
+GType       pango_color_get_type (void) G_GNUC_CONST;
+
+PangoColor *pango_color_copy     (const PangoColor *src);
+void        pango_color_free     (PangoColor       *color);
+gboolean    pango_color_parse    (PangoColor       *color,
+				  const char       *spec);
+gchar      *pango_color_to_string(const PangoColor *color);
+
+
+/* Attributes */
+
+typedef struct _PangoAttribute    PangoAttribute;
+typedef struct _PangoAttrClass    PangoAttrClass;
+
+typedef struct _PangoAttrString   PangoAttrString;
+typedef struct _PangoAttrLanguage PangoAttrLanguage;
+typedef struct _PangoAttrInt      PangoAttrInt;
+typedef struct _PangoAttrSize     PangoAttrSize;
+typedef struct _PangoAttrFloat    PangoAttrFloat;
+typedef struct _PangoAttrColor    PangoAttrColor;
+typedef struct _PangoAttrFontDesc PangoAttrFontDesc;
+typedef struct _PangoAttrShape    PangoAttrShape;
+
+#define PANGO_TYPE_ATTR_LIST pango_attr_list_get_type ()
+typedef struct _PangoAttrList     PangoAttrList;
+typedef struct _PangoAttrIterator PangoAttrIterator;
+
+typedef enum
+{
+  PANGO_ATTR_INVALID,           /* 0 is an invalid attribute type */
+  PANGO_ATTR_LANGUAGE,		/* PangoAttrLanguage */
+  PANGO_ATTR_FAMILY,		/* PangoAttrString */
+  PANGO_ATTR_STYLE,		/* PangoAttrInt */
+  PANGO_ATTR_WEIGHT,		/* PangoAttrInt */
+  PANGO_ATTR_VARIANT,		/* PangoAttrInt */
+  PANGO_ATTR_STRETCH,		/* PangoAttrInt */
+  PANGO_ATTR_SIZE,		/* PangoAttrSize */
+  PANGO_ATTR_FONT_DESC,		/* PangoAttrFontDesc */
+  PANGO_ATTR_FOREGROUND,	/* PangoAttrColor */
+  PANGO_ATTR_BACKGROUND,	/* PangoAttrColor */
+  PANGO_ATTR_UNDERLINE,		/* PangoAttrInt */
+  PANGO_ATTR_STRIKETHROUGH,	/* PangoAttrInt */
+  PANGO_ATTR_RISE,		/* PangoAttrInt */
+  PANGO_ATTR_SHAPE,		/* PangoAttrShape */
+  PANGO_ATTR_SCALE,             /* PangoAttrFloat */
+  PANGO_ATTR_FALLBACK,          /* PangoAttrInt */
+  PANGO_ATTR_LETTER_SPACING,    /* PangoAttrInt */
+  PANGO_ATTR_UNDERLINE_COLOR,	/* PangoAttrColor */
+  PANGO_ATTR_STRIKETHROUGH_COLOR,/* PangoAttrColor */
+  PANGO_ATTR_ABSOLUTE_SIZE,	/* PangoAttrSize */
+  PANGO_ATTR_GRAVITY,		/* PangoAttrInt */
+  PANGO_ATTR_GRAVITY_HINT	/* PangoAttrInt */
+} PangoAttrType;
+
+typedef enum {
+  PANGO_UNDERLINE_NONE,
+  PANGO_UNDERLINE_SINGLE,
+  PANGO_UNDERLINE_DOUBLE,
+  PANGO_UNDERLINE_LOW,
+  PANGO_UNDERLINE_ERROR
+} PangoUnderline;
+
+#define PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING	0
+#define PANGO_ATTR_INDEX_TO_TEXT_END		G_MAXUINT
+
+struct _PangoAttribute
+{
+  const PangoAttrClass *klass;
+  guint start_index;	/* in bytes */
+  guint end_index;	/* in bytes. The character at this index is not included */
+};
+
+typedef gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute,
+					 gpointer        data);
+
+typedef gpointer (*PangoAttrDataCopyFunc) (gconstpointer data);
+
+struct _PangoAttrClass
+{
+  /*< public >*/
+  PangoAttrType type;
+  PangoAttribute * (*copy) (const PangoAttribute *attr);
+  void             (*destroy) (PangoAttribute *attr);
+  gboolean         (*equal) (const PangoAttribute *attr1, const PangoAttribute *attr2);
+};
+
+struct _PangoAttrString
+{
+  PangoAttribute attr;
+  char *value;
+};
+
+struct _PangoAttrLanguage
+{
+  PangoAttribute attr;
+  PangoLanguage *value;
+};
+
+struct _PangoAttrInt
+{
+  PangoAttribute attr;
+  int value;
+};
+
+struct _PangoAttrFloat
+{
+  PangoAttribute attr;
+  double value;
+};
+
+struct _PangoAttrColor
+{
+  PangoAttribute attr;
+  PangoColor color;
+};
+
+struct _PangoAttrSize
+{
+  PangoAttribute attr;
+  int size;
+  guint absolute : 1;
+};
+
+struct _PangoAttrShape
+{
+  PangoAttribute attr;
+  PangoRectangle ink_rect;
+  PangoRectangle logical_rect;
+
+  gpointer              data;
+  PangoAttrDataCopyFunc copy_func;
+  GDestroyNotify        destroy_func;
+};
+
+struct _PangoAttrFontDesc
+{
+  PangoAttribute attr;
+  PangoFontDescription *desc;
+};
+
+PangoAttrType         pango_attr_type_register (const gchar        *name);
+const char *          pango_attr_type_get_name (PangoAttrType       type) G_GNUC_CONST;
+
+void             pango_attribute_init        (PangoAttribute       *attr,
+					      const PangoAttrClass *klass);
+PangoAttribute * pango_attribute_copy        (const PangoAttribute *attr);
+void             pango_attribute_destroy     (PangoAttribute       *attr);
+gboolean         pango_attribute_equal       (const PangoAttribute *attr1,
+					      const PangoAttribute *attr2) G_GNUC_PURE;
+
+PangoAttribute *pango_attr_language_new      (PangoLanguage              *language);
+PangoAttribute *pango_attr_family_new        (const char                 *family);
+PangoAttribute *pango_attr_foreground_new    (guint16                     red,
+					      guint16                     green,
+					      guint16                     blue);
+PangoAttribute *pango_attr_background_new    (guint16                     red,
+					      guint16                     green,
+					      guint16                     blue);
+PangoAttribute *pango_attr_size_new          (int                         size);
+PangoAttribute *pango_attr_size_new_absolute (int                         size);
+PangoAttribute *pango_attr_style_new         (PangoStyle                  style);
+PangoAttribute *pango_attr_weight_new        (PangoWeight                 weight);
+PangoAttribute *pango_attr_variant_new       (PangoVariant                variant);
+PangoAttribute *pango_attr_stretch_new       (PangoStretch                stretch);
+PangoAttribute *pango_attr_font_desc_new     (const PangoFontDescription *desc);
+
+PangoAttribute *pango_attr_underline_new           (PangoUnderline underline);
+PangoAttribute *pango_attr_underline_color_new     (guint16        red,
+						    guint16        green,
+						    guint16        blue);
+PangoAttribute *pango_attr_strikethrough_new       (gboolean       strikethrough);
+PangoAttribute *pango_attr_strikethrough_color_new (guint16        red,
+						    guint16        green,
+						    guint16        blue);
+
+PangoAttribute *pango_attr_rise_new          (int                         rise);
+PangoAttribute *pango_attr_scale_new         (double                      scale_factor);
+PangoAttribute *pango_attr_fallback_new      (gboolean                    enable_fallback);
+PangoAttribute *pango_attr_letter_spacing_new (int                        letter_spacing);
+
+PangoAttribute *pango_attr_shape_new           (const PangoRectangle       *ink_rect,
+						const PangoRectangle       *logical_rect);
+PangoAttribute *pango_attr_shape_new_with_data (const PangoRectangle       *ink_rect,
+						const PangoRectangle       *logical_rect,
+						gpointer                    data,
+						PangoAttrDataCopyFunc       copy_func,
+						GDestroyNotify              destroy_func);
+
+PangoAttribute *pango_attr_gravity_new      (PangoGravity     gravity);
+PangoAttribute *pango_attr_gravity_hint_new (PangoGravityHint hint);
+
+GType              pango_attr_list_get_type      (void) G_GNUC_CONST;
+PangoAttrList *    pango_attr_list_new           (void);
+PangoAttrList *    pango_attr_list_ref           (PangoAttrList  *list);
+void               pango_attr_list_unref         (PangoAttrList  *list);
+PangoAttrList *    pango_attr_list_copy          (PangoAttrList  *list);
+void               pango_attr_list_insert        (PangoAttrList  *list,
+						  PangoAttribute *attr);
+void               pango_attr_list_insert_before (PangoAttrList  *list,
+						  PangoAttribute *attr);
+void               pango_attr_list_change        (PangoAttrList  *list,
+						  PangoAttribute *attr);
+void               pango_attr_list_splice        (PangoAttrList  *list,
+						  PangoAttrList  *other,
+						  gint            pos,
+						  gint            len);
+
+PangoAttrList *pango_attr_list_filter (PangoAttrList       *list,
+				       PangoAttrFilterFunc  func,
+				       gpointer             data);
+
+PangoAttrIterator *pango_attr_list_get_iterator  (PangoAttrList  *list);
+
+void               pango_attr_iterator_range    (PangoAttrIterator     *iterator,
+						 gint                  *start,
+						 gint                  *end);
+gboolean           pango_attr_iterator_next     (PangoAttrIterator     *iterator);
+PangoAttrIterator *pango_attr_iterator_copy     (PangoAttrIterator     *iterator);
+void               pango_attr_iterator_destroy  (PangoAttrIterator     *iterator);
+PangoAttribute *   pango_attr_iterator_get      (PangoAttrIterator     *iterator,
+						 PangoAttrType          type);
+void               pango_attr_iterator_get_font (PangoAttrIterator     *iterator,
+						 PangoFontDescription  *desc,
+						 PangoLanguage        **language,
+						 GSList               **extra_attrs);
+GSList *          pango_attr_iterator_get_attrs (PangoAttrIterator     *iterator);
+
+
+gboolean pango_parse_markup (const char                 *markup_text,
+			     int                         length,
+			     gunichar                    accel_marker,
+			     PangoAttrList             **attr_list,
+			     char                      **text,
+			     gunichar                   *accel_char,
+			     GError                    **error);
+
+G_END_DECLS
+
+#endif /* __PANGO_ATTRIBUTES_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-bidi-type.h b/gtk+-mingw/include/pango-1.0/pango/pango-bidi-type.h
new file mode 100644
index 0000000..21bb7e7
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-bidi-type.h
@@ -0,0 +1,136 @@
+/* Pango
+ * pango-bidi-type.h: Bidirectional Character Types
+ *
+ * Copyright (C) 2008 Jürg Billeter <j@bitron.ch>
+ *
+ * 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_BIDI_TYPE_H__
+#define __PANGO_BIDI_TYPE_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/**
+ * PangoBidiType:
+ * @PANGO_BIDI_TYPE_L: Left-to-Right
+ * @PANGO_BIDI_TYPE_LRE: Left-to-Right Embedding
+ * @PANGO_BIDI_TYPE_LRO: Left-to-Right Override
+ * @PANGO_BIDI_TYPE_R: Right-to-Left
+ * @PANGO_BIDI_TYPE_AL: Right-to-Left Arabic
+ * @PANGO_BIDI_TYPE_RLE: Right-to-Left Embedding
+ * @PANGO_BIDI_TYPE_RLO: Right-to-Left Override
+ * @PANGO_BIDI_TYPE_PDF: Pop Directional Format
+ * @PANGO_BIDI_TYPE_EN: European Number
+ * @PANGO_BIDI_TYPE_ES: European Number Separator
+ * @PANGO_BIDI_TYPE_ET: European Number Terminator
+ * @PANGO_BIDI_TYPE_AN: Arabic Number
+ * @PANGO_BIDI_TYPE_CS: Common Number Separator
+ * @PANGO_BIDI_TYPE_NSM: Nonspacing Mark
+ * @PANGO_BIDI_TYPE_BN: Boundary Neutral
+ * @PANGO_BIDI_TYPE_B: Paragraph Separator
+ * @PANGO_BIDI_TYPE_S: Segment Separator
+ * @PANGO_BIDI_TYPE_WS: Whitespace
+ * @PANGO_BIDI_TYPE_ON: Other Neutrals
+ *
+ * The #PangoBidiType type represents the bidirectional character
+ * type of a Unicode character as specified by the
+ * <ulink url="http://www.unicode.org/reports/tr9/">Unicode bidirectional algorithm</ulink>.
+ *
+ * Since: 1.22
+ **/
+typedef enum {
+  /* Strong types */
+  PANGO_BIDI_TYPE_L,
+  PANGO_BIDI_TYPE_LRE,
+  PANGO_BIDI_TYPE_LRO,
+  PANGO_BIDI_TYPE_R,
+  PANGO_BIDI_TYPE_AL,
+  PANGO_BIDI_TYPE_RLE,
+  PANGO_BIDI_TYPE_RLO,
+
+  /* Weak types */
+  PANGO_BIDI_TYPE_PDF,
+  PANGO_BIDI_TYPE_EN,
+  PANGO_BIDI_TYPE_ES,
+  PANGO_BIDI_TYPE_ET,
+  PANGO_BIDI_TYPE_AN,
+  PANGO_BIDI_TYPE_CS,
+  PANGO_BIDI_TYPE_NSM,
+  PANGO_BIDI_TYPE_BN,
+
+  /* Neutral types */
+  PANGO_BIDI_TYPE_B,
+  PANGO_BIDI_TYPE_S,
+  PANGO_BIDI_TYPE_WS,
+  PANGO_BIDI_TYPE_ON
+} PangoBidiType;
+
+PangoBidiType pango_bidi_type_for_unichar (gunichar ch) G_GNUC_CONST;
+
+/**
+ * PangoDirection:
+ * @PANGO_DIRECTION_LTR: A strong left-to-right direction
+ * @PANGO_DIRECTION_RTL: A strong right-to-left direction
+ * @PANGO_DIRECTION_TTB_LTR: Deprecated value; treated the
+ *   same as %PANGO_DIRECTION_RTL.
+ * @PANGO_DIRECTION_TTB_RTL: Deprecated value; treated the
+ *   same as %PANGO_DIRECTION_LTR
+ * @PANGO_DIRECTION_WEAK_LTR: A weak left-to-right direction
+ * @PANGO_DIRECTION_WEAK_RTL: A weak right-to-left direction
+ * @PANGO_DIRECTION_NEUTRAL: No direction specified
+ *
+ * The #PangoDirection type represents a direction in the
+ * Unicode bidirectional algorithm; not every value in this
+ * enumeration makes sense for every usage of #PangoDirection;
+ * for example, the return value of pango_unichar_direction()
+ * and pango_find_base_dir() cannot be %PANGO_DIRECTION_WEAK_LTR
+ * or %PANGO_DIRECTION_WEAK_RTL, since every character is either
+ * neutral or has a strong direction; on the other hand
+ * %PANGO_DIRECTION_NEUTRAL doesn't make sense to pass
+ * to pango_itemize_with_base_dir().
+ *
+ * The %PANGO_DIRECTION_TTB_LTR, %PANGO_DIRECTION_TTB_RTL
+ * values come from an earlier interpretation of this
+ * enumeration as the writing direction of a block of
+ * text and are no longer used; See #PangoGravity for how
+ * vertical text is handled in Pango.
+ **/
+typedef enum {
+  PANGO_DIRECTION_LTR,
+  PANGO_DIRECTION_RTL,
+  PANGO_DIRECTION_TTB_LTR,
+  PANGO_DIRECTION_TTB_RTL,
+  PANGO_DIRECTION_WEAK_LTR,
+  PANGO_DIRECTION_WEAK_RTL,
+  PANGO_DIRECTION_NEUTRAL
+} PangoDirection;
+
+PangoDirection pango_unichar_direction      (gunichar     ch) G_GNUC_CONST;
+PangoDirection pango_find_base_dir          (const gchar *text,
+					     gint         length);
+
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(g_unichar_get_mirror_char)
+gboolean       pango_get_mirror_char        (gunichar     ch,
+					     gunichar    *mirrored_ch);
+#endif
+
+G_END_DECLS
+
+#endif /* __PANGO_BIDI_TYPE_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-break.h b/gtk+-mingw/include/pango-1.0/pango/pango-break.h
new file mode 100644
index 0000000..5c326dd
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-break.h
@@ -0,0 +1,120 @@
+/* Pango
+ * pango-break.h:
+ *
+ * Copyright (C) 1999 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 __PANGO_BREAK_H__
+#define __PANGO_BREAK_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+#include <pango/pango-item.h>
+
+/* Logical attributes of a character.
+ */
+struct _PangoLogAttr
+{
+  guint is_line_break : 1;      /* Can break line in front of character */
+
+  guint is_mandatory_break : 1; /* Must break line in front of character */
+
+  guint is_char_break : 1;      /* Can break here when doing char wrap */
+
+  guint is_white : 1;           /* Whitespace character */
+
+  /* Cursor can appear in front of character (i.e. this is a grapheme
+   * boundary, or the first character in the text).
+   */
+  guint is_cursor_position : 1;
+
+  /* Note that in degenerate cases, you could have both start/end set on
+   * some text, most likely for sentences (e.g. no space after a period, so
+   * the next sentence starts right away).
+   */
+
+  guint is_word_start : 1;      /* first character in a word */
+  guint is_word_end   : 1;      /* is first non-word char after a word */
+
+  /* There are two ways to divide sentences. The first assigns all
+   * intersentence whitespace/control/format chars to some sentence,
+   * so all chars are in some sentence; is_sentence_boundary denotes
+   * the boundaries there. The second way doesn't assign
+   * between-sentence spaces, etc. to any sentence, so
+   * is_sentence_start/is_sentence_end mark the boundaries of those
+   * sentences.
+   */
+  guint is_sentence_boundary : 1;
+  guint is_sentence_start : 1;  /* first character in a sentence */
+  guint is_sentence_end : 1;    /* first non-sentence char after a sentence */
+
+  /* If set, backspace deletes one character rather than
+   * the entire grapheme cluster.
+   */
+  guint backspace_deletes_character : 1;
+
+  /* Only few space variants (U+0020 and U+00A0) have variable
+   * width during justification.
+   */
+  guint is_expandable_space : 1;
+
+  /* Word boundary as defined by UAX#29 */
+  guint is_word_boundary : 1;	/* is NOT in the middle of a word */
+};
+
+/* Determine information about cluster/word/line breaks in a string
+ * of Unicode text.
+ */
+void pango_break (const gchar   *text,
+		  int            length,
+		  PangoAnalysis *analysis,
+		  PangoLogAttr  *attrs,
+		  int            attrs_len);
+
+void pango_find_paragraph_boundary (const gchar *text,
+				    gint         length,
+				    gint        *paragraph_delimiter_index,
+				    gint        *next_paragraph_start);
+
+void pango_get_log_attrs (const char    *text,
+			  int            length,
+			  int            level,
+			  PangoLanguage *language,
+			  PangoLogAttr  *log_attrs,
+			  int            attrs_len);
+
+#ifdef PANGO_ENABLE_ENGINE
+
+/* This is the default break algorithm, used if no language
+ * engine overrides it. Normally you should use pango_break()
+ * instead; this function is mostly useful for chaining up
+ * from a language engine override.
+ */
+void pango_default_break (const gchar   *text,
+			  int            length,
+			  PangoAnalysis *analysis,
+			  PangoLogAttr  *attrs,
+			  int            attrs_len);
+
+#endif /* PANGO_ENABLE_ENGINE */
+
+G_END_DECLS
+
+#endif /* __PANGO_BREAK_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-context.h b/gtk+-mingw/include/pango-1.0/pango/pango-context.h
new file mode 100644
index 0000000..d85928a
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-context.h
@@ -0,0 +1,111 @@
+/* Pango
+ * pango-context.h: Rendering contexts
+ *
+ * Copyright (C) 2000 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 __PANGO_CONTEXT_H__
+#define __PANGO_CONTEXT_H__
+
+#include <pango/pango-font.h>
+#include <pango/pango-fontmap.h>
+#include <pango/pango-attributes.h>
+
+G_BEGIN_DECLS
+
+/* Sort of like a GC - application set information about how
+ * to handle scripts
+ */
+
+/* PangoContext typedefed in pango-fontmap.h */
+typedef struct _PangoContextClass PangoContextClass;
+
+#define PANGO_TYPE_CONTEXT              (pango_context_get_type ())
+#define PANGO_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CONTEXT, PangoContext))
+#define PANGO_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_CONTEXT, PangoContextClass))
+#define PANGO_IS_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CONTEXT))
+#define PANGO_IS_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_CONTEXT))
+#define PANGO_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_CONTEXT, PangoContextClass))
+
+
+/* The PangoContext and PangoContextClass structs are private; if you
+ * need to create a subclass of these, file a bug.
+ */
+
+GType         pango_context_get_type      (void) G_GNUC_CONST;
+
+PangoContext *pango_context_new           (void);
+void          pango_context_set_font_map  (PangoContext                 *context,
+					   PangoFontMap                 *font_map);
+PangoFontMap *pango_context_get_font_map  (PangoContext                 *context);
+
+void          pango_context_list_families (PangoContext                 *context,
+					   PangoFontFamily            ***families,
+					   int                          *n_families);
+PangoFont *   pango_context_load_font     (PangoContext                 *context,
+					   const PangoFontDescription   *desc);
+PangoFontset *pango_context_load_fontset  (PangoContext                 *context,
+					   const PangoFontDescription   *desc,
+					   PangoLanguage                *language);
+
+PangoFontMetrics *pango_context_get_metrics   (PangoContext                 *context,
+					       const PangoFontDescription   *desc,
+					       PangoLanguage                *language);
+
+void                      pango_context_set_font_description (PangoContext               *context,
+							      const PangoFontDescription *desc);
+PangoFontDescription *    pango_context_get_font_description (PangoContext               *context);
+PangoLanguage            *pango_context_get_language         (PangoContext               *context);
+void                      pango_context_set_language         (PangoContext               *context,
+							      PangoLanguage              *language);
+void                      pango_context_set_base_dir         (PangoContext               *context,
+							      PangoDirection              direction);
+PangoDirection            pango_context_get_base_dir         (PangoContext               *context);
+void                      pango_context_set_base_gravity     (PangoContext               *context,
+							      PangoGravity                gravity);
+PangoGravity              pango_context_get_base_gravity     (PangoContext               *context);
+PangoGravity              pango_context_get_gravity          (PangoContext               *context);
+void                      pango_context_set_gravity_hint     (PangoContext               *context,
+							      PangoGravityHint            hint);
+PangoGravityHint          pango_context_get_gravity_hint     (PangoContext               *context);
+
+void                      pango_context_set_matrix           (PangoContext      *context,
+						              const PangoMatrix *matrix);
+const PangoMatrix *       pango_context_get_matrix           (PangoContext      *context);
+
+/* Break a string of Unicode characters into segments with
+ * consistent shaping/language engine and bidrectional level.
+ * Returns a #GList of #PangoItem's
+ */
+GList *pango_itemize                (PangoContext      *context,
+				     const char        *text,
+				     int                start_index,
+				     int                length,
+				     PangoAttrList     *attrs,
+				     PangoAttrIterator *cached_iter);
+GList *pango_itemize_with_base_dir  (PangoContext      *context,
+				     PangoDirection     base_dir,
+				     const char        *text,
+				     int                start_index,
+				     int                length,
+				     PangoAttrList     *attrs,
+				     PangoAttrIterator *cached_iter);
+
+G_END_DECLS
+
+#endif /* __PANGO_CONTEXT_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-coverage.h b/gtk+-mingw/include/pango-1.0/pango/pango-coverage.h
new file mode 100644
index 0000000..e1e8d13
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-coverage.h
@@ -0,0 +1,58 @@
+/* Pango
+ * pango-coverage.h: Coverage sets for fonts
+ *
+ * Copyright (C) 2000 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 __PANGO_COVERAGE_H__
+#define __PANGO_COVERAGE_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoCoverage PangoCoverage;
+
+typedef enum {
+  PANGO_COVERAGE_NONE,
+  PANGO_COVERAGE_FALLBACK,
+  PANGO_COVERAGE_APPROXIMATE,
+  PANGO_COVERAGE_EXACT
+} PangoCoverageLevel;
+
+PangoCoverage *    pango_coverage_new     (void);
+PangoCoverage *    pango_coverage_ref     (PangoCoverage      *coverage);
+void               pango_coverage_unref   (PangoCoverage      *coverage);
+PangoCoverage *    pango_coverage_copy    (PangoCoverage      *coverage);
+PangoCoverageLevel pango_coverage_get     (PangoCoverage      *coverage,
+					   int                 index_);
+void               pango_coverage_set     (PangoCoverage      *coverage,
+					   int                 index_,
+					   PangoCoverageLevel  level);
+void               pango_coverage_max     (PangoCoverage      *coverage,
+					   PangoCoverage      *other);
+
+void           pango_coverage_to_bytes   (PangoCoverage  *coverage,
+					  guchar        **bytes,
+					  int            *n_bytes);
+PangoCoverage *pango_coverage_from_bytes (guchar         *bytes,
+					  int             n_bytes);
+
+G_END_DECLS
+
+#endif /* __PANGO_COVERAGE_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-engine.h b/gtk+-mingw/include/pango-1.0/pango/pango-engine.h
new file mode 100644
index 0000000..d14a982
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-engine.h
@@ -0,0 +1,381 @@
+/* Pango
+ * pango-engine.h: Engines for script and language specific processing
+ *
+ * Copyright (C) 2000,2003 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 __PANGO_ENGINE_H__
+#define __PANGO_ENGINE_H__
+
+#include <pango/pango-types.h>
+#include <pango/pango-item.h>
+#include <pango/pango-font.h>
+#include <pango/pango-glyph.h>
+#include <pango/pango-script.h>
+
+G_BEGIN_DECLS
+
+#ifdef PANGO_ENABLE_ENGINE
+
+/* Module API */
+
+#include <gmodule.h>
+
+#define PANGO_RENDER_TYPE_NONE "PangoRenderNone"
+
+#define PANGO_TYPE_ENGINE              (pango_engine_get_type ())
+#define PANGO_ENGINE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE, PangoEngine))
+#define PANGO_IS_ENGINE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE))
+#define PANGO_ENGINE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE, PangoEngineClass))
+#define PANGO_IS_ENGINE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE))
+#define PANGO_ENGINE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE, PangoEngineClass))
+
+typedef struct _PangoEngine PangoEngine;
+typedef struct _PangoEngineClass PangoEngineClass;
+
+/**
+ * PangoEngine:
+ *
+ * #PangoEngine is the base class for all types of language and
+ * script specific engines. It has no functionality by itself.
+ **/
+struct _PangoEngine
+{
+  /*< private >*/
+  GObject parent_instance;
+};
+
+/**
+ * PangoEngineClass:
+ *
+ * Class structure for #PangoEngine
+ **/
+struct _PangoEngineClass
+{
+  /*< private >*/
+  GObjectClass parent_class;
+};
+
+GType pango_engine_get_type (void) G_GNUC_CONST;
+
+#define PANGO_ENGINE_TYPE_LANG "PangoEngineLang"
+
+#define PANGO_TYPE_ENGINE_LANG              (pango_engine_lang_get_type ())
+#define PANGO_ENGINE_LANG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE_LANG, PangoEngineLang))
+#define PANGO_IS_ENGINE_LANG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE_LANG))
+#define PANGO_ENGINE_LANG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE_LANG, PangoEngineLangClass))
+#define PANGO_IS_ENGINE_LANG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE_LANG))
+#define PANGO_ENGINE_LANG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE_LANG, PangoEngineLangClass))
+
+typedef struct _PangoEngineLangClass PangoEngineLangClass;
+
+/**
+ * PangoEngineLang:
+ *
+ * The #PangoEngineLang class is implemented by engines that
+ * customize the rendering-system independent part of the
+ * Pango pipeline for a particular script or language. For
+ * instance, a custom #PangoEngineLang could be provided for
+ * Thai to implement the dictionary-based word boundary
+ * lookups needed for that language.
+ **/
+struct _PangoEngineLang
+{
+  /*< private >*/
+  PangoEngine parent_instance;
+};
+
+/**
+ * PangoEngineLangClass:
+ * @script_break: Provides a custom implementation of pango_break().
+ * If %NULL, pango_default_break() is used instead. If not %NULL, for
+ * Pango versions before 1.16 (module interface version before 1.6.0),
+ * this was called instead of pango_default_break(), but in newer versions,
+ * pango_default_break() is always called and this is called after that to
+ * allow tailoring the breaking results.
+ *
+ * Class structure for #PangoEngineLang
+ **/
+struct _PangoEngineLangClass
+{
+  /*< private >*/
+  PangoEngineClass parent_class;
+
+  /*< public >*/
+  void (*script_break) (PangoEngineLang *engine,
+			const char    *text,
+			int            len,
+			PangoAnalysis *analysis,
+			PangoLogAttr  *attrs,
+			int            attrs_len);
+};
+
+GType pango_engine_lang_get_type (void) G_GNUC_CONST;
+
+#define PANGO_ENGINE_TYPE_SHAPE "PangoEngineShape"
+
+#define PANGO_TYPE_ENGINE_SHAPE              (pango_engine_shape_get_type ())
+#define PANGO_ENGINE_SHAPE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE_SHAPE, PangoEngineShape))
+#define PANGO_IS_ENGINE_SHAPE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE_SHAPE))
+#define PANGO_ENGINE_SHAPE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE_SHAPE, PangoEngine_ShapeClass))
+#define PANGO_IS_ENGINE_SHAPE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE_SHAPE))
+#define PANGO_ENGINE_SHAPE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE_SHAPE, PangoEngineShapeClass))
+
+typedef struct _PangoEngineShapeClass PangoEngineShapeClass;
+
+/**
+ * PangoEngineShape
+ *
+ * The #PangoEngineShape class is implemented by engines that
+ * customize the rendering-system dependent part of the
+ * Pango pipeline for a particular script or language.
+ * A #PangoEngineShape implementation is then specific to both
+ * a particular rendering system or group of rendering systems
+ * and to a particular script. For instance, there is one
+ * #PangoEngineShape implementation to handle shaping Arabic
+ * for Fontconfig-based backends.
+ **/
+struct _PangoEngineShape
+{
+  PangoEngine parent_instance;
+};
+
+/**
+ * PangoEngineShapeClass:
+ * @script_shape: Given a font, a piece of text, and a #PangoAnalysis
+ *   structure, converts characters to glyphs and positions the
+ *   resulting glyphs. The results are stored in the #PangoGlyphString
+ *   that is passed in. (The implementation should resize it
+ *   appropriately using pango_glyph_string_set_size()). All fields
+ *   of the @log_clusters and @glyphs array must be filled in, with
+ *   the exception that Pango will automatically generate
+ *   <literal>glyphs->glyphs[i].attr.is_cluster_start</literal>
+ *   using the @log_clusters array. Each input character must occur in one
+ *   of the output logical clusters;
+ *   if no rendering is desired for a character, this may involve
+ *   inserting glyphs with the #PangoGlyph ID #PANGO_GLYPH_EMPTY, which
+ *   is guaranteed never to render. If the shaping fails for any reason,
+ *   the shaper should return with an empty (zero-size) glyph string.
+ *   If the shaper has not set the size on the glyph string yet, simply
+ *   returning signals the failure too.
+ * @covers: Returns the characters that this engine can cover
+ *   with a given font for a given language. If not overridden, the default
+ *   implementation simply returns the coverage information for the
+ *   font itself unmodified.
+ *
+ * Class structure for #PangoEngineShape
+ **/
+struct _PangoEngineShapeClass
+{
+  /*< private >*/
+  PangoEngineClass parent_class;
+
+  /*< public >*/
+  void (*script_shape) (PangoEngineShape *engine,
+			PangoFont        *font,
+			const char       *text,
+			int               length,
+			const PangoAnalysis *analysis,
+			PangoGlyphString *glyphs);
+  PangoCoverageLevel (*covers)   (PangoEngineShape *engine,
+				  PangoFont        *font,
+				  PangoLanguage    *language,
+				  gunichar          wc);
+};
+
+GType pango_engine_shape_get_type (void) G_GNUC_CONST;
+
+typedef struct _PangoEngineInfo PangoEngineInfo;
+typedef struct _PangoEngineScriptInfo PangoEngineScriptInfo;
+
+struct _PangoEngineScriptInfo
+{
+  PangoScript script;
+  const gchar *langs;
+};
+
+struct _PangoEngineInfo
+{
+  const gchar *id;
+  const gchar *engine_type;
+  const gchar *render_type;
+  PangoEngineScriptInfo *scripts;
+  gint n_scripts;
+};
+
+/**
+ * script_engine_list:
+ * @engines: location to store a pointer to an array of engines.
+ * @n_engines: location to store the number of elements in @engines.
+ *
+ * Function to be provided by a module to list the engines that the
+ * module supplies. The function stores a pointer to an array
+ * of #PangoEngineInfo structures and the length of that array in
+ * the given location.
+ *
+ * Note that script_engine_init() will not be called before this
+ * function.
+ **/
+void script_engine_list (PangoEngineInfo **engines,
+			 int              *n_engines);
+
+/**
+ * script_engine_init:
+ * @module: a #GTypeModule structure used to associate any
+ *  GObject types created in this module with the module.
+ *
+ * Function to be provided by a module to register any
+ * GObject types in the module.
+ **/
+void script_engine_init (GTypeModule *module);
+
+
+/**
+ * script_engine_exit:
+ *
+ * Function to be provided by the module that is called
+ * when the module is unloading. Frequently does nothing.
+ **/
+void script_engine_exit (void);
+
+/**
+ * script_engine_create:
+ * @id: the ID of an engine as reported by script_engine_list.
+ *
+ * Function to be provided by the module to create an instance
+ * of one of the engines implemented by the module.
+ *
+ * Return value: a newly created #PangoEngine of the specified
+ *  type, or %NULL if an error occurred. (In normal operation,
+ *  a module should not return %NULL. A %NULL return is only
+ *  acceptable in the case where system misconfiguration or
+ *  bugs in the driver routine are encountered.)
+ **/
+PangoEngine *script_engine_create (const char *id);
+
+/* Utility macro used by PANGO_ENGINE_LANG_DEFINE_TYPE and
+ * PANGO_ENGINE_LANG_DEFINE_TYPE
+ */
+#define PANGO_ENGINE_DEFINE_TYPE(name, prefix, class_init, instance_init, parent_type) \
+static GType prefix ## _type;						  \
+static void								  \
+prefix ## _register_type (GTypeModule *module)				  \
+{									  \
+  const GTypeInfo object_info =						  \
+    {									  \
+      sizeof (name ## Class),						  \
+      (GBaseInitFunc) NULL,						  \
+      (GBaseFinalizeFunc) NULL,						  \
+      (GClassInitFunc) class_init,					  \
+      (GClassFinalizeFunc) NULL,					  \
+      NULL,          /* class_data */					  \
+      sizeof (name),							  \
+      0,             /* n_prelocs */					  \
+      (GInstanceInitFunc) instance_init,				  \
+      NULL           /* value_table */					  \
+    };									  \
+									  \
+  prefix ## _type =  g_type_module_register_type (module, parent_type,	  \
+						  # name,		  \
+						  &object_info, 0);	  \
+}
+
+/**
+ * PANGO_ENGINE_LANG_DEFINE_TYPE:
+ * @name: Name of the the type to register (for example:, <literal>ArabicEngineFc</literal>
+ * @prefix: Prefix for symbols that will be defined (for example:, <literal>arabic_engine_fc</literal>
+ * @class_init: Class initialization function for the new type, or %NULL
+ * @instance_init: Instance initialization function for the new type, or %NULL
+ *
+ * Outputs the necessary code for GObject type registration for a
+ * #PangoEngineLang class defined in a module. Two static symbols
+ * are defined.
+ *
+ * <programlisting>
+ *  static GType <replaceable>prefix</replaceable>_type;
+ *  static void <replaceable>prefix</replaceable>_register_type (GTypeModule module);
+ * </programlisting>
+ *
+ * The <function><replaceable>prefix</replaceable>_register_type()</function>
+ * function should be called in your script_engine_init() function for
+ * each type that your module implements, and then your script_engine_create()
+ * function can create instances of the object as follows:
+ *
+ * <informalexample><programlisting>
+ *  PangoEngine *engine = g_object_new (<replaceable>prefix</replaceable>_type, NULL);
+ * </programlisting></informalexample>
+ **/
+#define PANGO_ENGINE_LANG_DEFINE_TYPE(name, prefix, class_init, instance_init)	\
+  PANGO_ENGINE_DEFINE_TYPE (name, prefix,				\
+			    class_init, instance_init,			\
+			    PANGO_TYPE_ENGINE_LANG)
+
+/**
+ * PANGO_ENGINE_SHAPE_DEFINE_TYPE:
+ * @name: Name of the the type to register (for example:, <literal>ArabicEngineFc</literal>
+ * @prefix: Prefix for symbols that will be defined (for example:, <literal>arabic_engine_fc</literal>
+ * @class_init: Class initialization function for the new type, or %NULL
+ * @instance_init: Instance initialization function for the new type, or %NULL
+ *
+ * Outputs the necessary code for GObject type registration for a
+ * #PangoEngineShape class defined in a module. Two static symbols
+ * are defined.
+ *
+ * <programlisting>
+ *  static GType <replaceable>prefix</replaceable>_type;
+ *  static void <replaceable>prefix</replaceable>_register_type (GTypeModule module);
+ * </programlisting>
+ *
+ * The <function><replaceable>prefix</replaceable>_register_type()</function>
+ * function should be called in your script_engine_init() function for
+ * each type that your module implements, and then your script_engine_create()
+ * function can create instances of the object as follows:
+ *
+ * <informalexample><programlisting>
+ *  PangoEngine *engine = g_object_new (<replaceable>prefix</replaceable>_type, NULL);
+ * </programlisting></informalexample>
+ **/
+#define PANGO_ENGINE_SHAPE_DEFINE_TYPE(name, prefix, class_init, instance_init)	\
+  PANGO_ENGINE_DEFINE_TYPE (name, prefix,				\
+			    class_init, instance_init,			\
+			    PANGO_TYPE_ENGINE_SHAPE)
+
+/* Macro used for possibly builtin Pango modules. Not useful
+ * for externally build modules. If we are compiling a module standalone,
+ * then we name the entry points script_engine_list, etc. But if we
+ * are compiling it for inclusion directly in Pango, then we need them to
+ * to have distinct names for this module, so we prepend a prefix.
+ *
+ * The two intermediate macros are to deal with details of the C
+ * preprocessor; token pasting tokens must be function arguments,
+ * and macro substitution isn't used on function arguments that
+ * are used for token pasting.
+ */
+#ifdef PANGO_MODULE_PREFIX
+#define PANGO_MODULE_ENTRY(func) _PANGO_MODULE_ENTRY2(PANGO_MODULE_PREFIX,func)
+#define _PANGO_MODULE_ENTRY2(prefix,func) _PANGO_MODULE_ENTRY3(prefix,func)
+#define _PANGO_MODULE_ENTRY3(prefix,func) prefix##_script_engine_##func
+#else
+#define PANGO_MODULE_ENTRY(func) script_engine_##func
+#endif
+
+#endif /* PANGO_ENABLE_ENGINE */
+
+G_END_DECLS
+
+#endif /* __PANGO_ENGINE_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-enum-types.h b/gtk+-mingw/include/pango-1.0/pango/pango-enum-types.h
new file mode 100644
index 0000000..6648263
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-enum-types.h
@@ -0,0 +1,60 @@
+
+
+
+#ifndef __PANGO_ENUM_TYPES_H__
+#define __PANGO_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+/* enumerations from "pango-attributes.h" */
+GType pango_attr_type_get_type (void);
+#define PANGO_TYPE_ATTR_TYPE (pango_attr_type_get_type())
+GType pango_underline_get_type (void);
+#define PANGO_TYPE_UNDERLINE (pango_underline_get_type())
+/* enumerations from "pango-bidi-type.h" */
+GType pango_bidi_type_get_type (void);
+#define PANGO_TYPE_BIDI_TYPE (pango_bidi_type_get_type())
+GType pango_direction_get_type (void);
+#define PANGO_TYPE_DIRECTION (pango_direction_get_type())
+/* enumerations from "pango-coverage.h" */
+GType pango_coverage_level_get_type (void);
+#define PANGO_TYPE_COVERAGE_LEVEL (pango_coverage_level_get_type())
+/* enumerations from "pango-font.h" */
+GType pango_style_get_type (void);
+#define PANGO_TYPE_STYLE (pango_style_get_type())
+GType pango_variant_get_type (void);
+#define PANGO_TYPE_VARIANT (pango_variant_get_type())
+GType pango_weight_get_type (void);
+#define PANGO_TYPE_WEIGHT (pango_weight_get_type())
+GType pango_stretch_get_type (void);
+#define PANGO_TYPE_STRETCH (pango_stretch_get_type())
+GType pango_font_mask_get_type (void);
+#define PANGO_TYPE_FONT_MASK (pango_font_mask_get_type())
+/* enumerations from "pango-gravity.h" */
+GType pango_gravity_get_type (void);
+#define PANGO_TYPE_GRAVITY (pango_gravity_get_type())
+GType pango_gravity_hint_get_type (void);
+#define PANGO_TYPE_GRAVITY_HINT (pango_gravity_hint_get_type())
+/* enumerations from "pango-layout.h" */
+GType pango_alignment_get_type (void);
+#define PANGO_TYPE_ALIGNMENT (pango_alignment_get_type())
+GType pango_wrap_mode_get_type (void);
+#define PANGO_TYPE_WRAP_MODE (pango_wrap_mode_get_type())
+GType pango_ellipsize_mode_get_type (void);
+#define PANGO_TYPE_ELLIPSIZE_MODE (pango_ellipsize_mode_get_type())
+/* enumerations from "pango-renderer.h" */
+GType pango_render_part_get_type (void);
+#define PANGO_TYPE_RENDER_PART (pango_render_part_get_type())
+/* enumerations from "pango-script.h" */
+GType pango_script_get_type (void);
+#define PANGO_TYPE_SCRIPT (pango_script_get_type())
+/* enumerations from "pango-tabs.h" */
+GType pango_tab_align_get_type (void);
+#define PANGO_TYPE_TAB_ALIGN (pango_tab_align_get_type())
+G_END_DECLS
+
+#endif /* __PANGO_ENUM_TYPES_H__ */
+
+
+
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-features.h b/gtk+-mingw/include/pango-1.0/pango/pango-features.h
new file mode 100644
index 0000000..cf20141
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-features.h
@@ -0,0 +1,12 @@
+/* Generated by configure. Do not edit */
+#ifndef PANGO_FEATURES_H
+#define PANGO_FEATURES_H
+
+#define PANGO_VERSION_MAJOR 1
+#define PANGO_VERSION_MINOR 30
+#define PANGO_VERSION_MICRO 0
+
+#define PANGO_VERSION_STRING "1.30.0"
+
+
+#endif
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-font.h b/gtk+-mingw/include/pango-1.0/pango/pango-font.h
new file mode 100644
index 0000000..eea27b4
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-font.h
@@ -0,0 +1,386 @@
+/* Pango
+ * pango-font.h: Font handling
+ *
+ * Copyright (C) 2000 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 __PANGO_FONT_H__
+#define __PANGO_FONT_H__
+
+#include <pango/pango-coverage.h>
+#include <pango/pango-types.h>
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoFontDescription PangoFontDescription;
+typedef struct _PangoFontMetrics PangoFontMetrics;
+
+/**
+ * PangoStyle:
+ * @PANGO_STYLE_NORMAL: the font is upright.
+ * @PANGO_STYLE_OBLIQUE: the font is slanted, but in a roman style.
+ * @PANGO_STYLE_ITALIC: the font is slanted in an italic style.
+ *
+ * An enumeration specifying the various slant styles possible for a font.
+ **/
+typedef enum {
+  PANGO_STYLE_NORMAL,
+  PANGO_STYLE_OBLIQUE,
+  PANGO_STYLE_ITALIC
+} PangoStyle;
+
+typedef enum {
+  PANGO_VARIANT_NORMAL,
+  PANGO_VARIANT_SMALL_CAPS
+} PangoVariant;
+
+typedef enum {
+  PANGO_WEIGHT_THIN = 100,
+  PANGO_WEIGHT_ULTRALIGHT = 200,
+  PANGO_WEIGHT_LIGHT = 300,
+  PANGO_WEIGHT_BOOK = 380,
+  PANGO_WEIGHT_NORMAL = 400,
+  PANGO_WEIGHT_MEDIUM = 500,
+  PANGO_WEIGHT_SEMIBOLD = 600,
+  PANGO_WEIGHT_BOLD = 700,
+  PANGO_WEIGHT_ULTRABOLD = 800,
+  PANGO_WEIGHT_HEAVY = 900,
+  PANGO_WEIGHT_ULTRAHEAVY = 1000
+} PangoWeight;
+
+typedef enum {
+  PANGO_STRETCH_ULTRA_CONDENSED,
+  PANGO_STRETCH_EXTRA_CONDENSED,
+  PANGO_STRETCH_CONDENSED,
+  PANGO_STRETCH_SEMI_CONDENSED,
+  PANGO_STRETCH_NORMAL,
+  PANGO_STRETCH_SEMI_EXPANDED,
+  PANGO_STRETCH_EXPANDED,
+  PANGO_STRETCH_EXTRA_EXPANDED,
+  PANGO_STRETCH_ULTRA_EXPANDED
+} PangoStretch;
+
+typedef enum {
+  PANGO_FONT_MASK_FAMILY  = 1 << 0,
+  PANGO_FONT_MASK_STYLE   = 1 << 1,
+  PANGO_FONT_MASK_VARIANT = 1 << 2,
+  PANGO_FONT_MASK_WEIGHT  = 1 << 3,
+  PANGO_FONT_MASK_STRETCH = 1 << 4,
+  PANGO_FONT_MASK_SIZE    = 1 << 5,
+  PANGO_FONT_MASK_GRAVITY = 1 << 6
+} PangoFontMask;
+
+/* CSS scale factors (1.2 factor between each size) */
+#define PANGO_SCALE_XX_SMALL ((double)0.5787037037037)
+#define PANGO_SCALE_X_SMALL  ((double)0.6444444444444)
+#define PANGO_SCALE_SMALL    ((double)0.8333333333333)
+#define PANGO_SCALE_MEDIUM   ((double)1.0)
+#define PANGO_SCALE_LARGE    ((double)1.2)
+#define PANGO_SCALE_X_LARGE  ((double)1.4399999999999)
+#define PANGO_SCALE_XX_LARGE ((double)1.728)
+
+/*
+ * PangoFontDescription
+ */
+
+#define PANGO_TYPE_FONT_DESCRIPTION (pango_font_description_get_type ())
+
+GType                 pango_font_description_get_type    (void) G_GNUC_CONST;
+PangoFontDescription *pango_font_description_new         (void);
+PangoFontDescription *pango_font_description_copy        (const PangoFontDescription  *desc);
+PangoFontDescription *pango_font_description_copy_static (const PangoFontDescription  *desc);
+guint                 pango_font_description_hash        (const PangoFontDescription  *desc) G_GNUC_PURE;
+gboolean              pango_font_description_equal       (const PangoFontDescription  *desc1,
+							  const PangoFontDescription  *desc2) G_GNUC_PURE;
+void                  pango_font_description_free        (PangoFontDescription        *desc);
+void                  pango_font_descriptions_free       (PangoFontDescription       **descs,
+							  int                          n_descs);
+
+void                 pango_font_description_set_family        (PangoFontDescription *desc,
+							       const char           *family);
+void                 pango_font_description_set_family_static (PangoFontDescription *desc,
+							       const char           *family);
+const char          *pango_font_description_get_family        (const PangoFontDescription *desc) G_GNUC_PURE;
+void                 pango_font_description_set_style         (PangoFontDescription *desc,
+							       PangoStyle            style);
+PangoStyle           pango_font_description_get_style         (const PangoFontDescription *desc) G_GNUC_PURE;
+void                 pango_font_description_set_variant       (PangoFontDescription *desc,
+							       PangoVariant          variant);
+PangoVariant         pango_font_description_get_variant       (const PangoFontDescription *desc) G_GNUC_PURE;
+void                 pango_font_description_set_weight        (PangoFontDescription *desc,
+							       PangoWeight           weight);
+PangoWeight          pango_font_description_get_weight        (const PangoFontDescription *desc) G_GNUC_PURE;
+void                 pango_font_description_set_stretch       (PangoFontDescription *desc,
+							       PangoStretch          stretch);
+PangoStretch         pango_font_description_get_stretch       (const PangoFontDescription *desc) G_GNUC_PURE;
+void                 pango_font_description_set_size          (PangoFontDescription *desc,
+							       gint                  size);
+gint                 pango_font_description_get_size          (const PangoFontDescription *desc) G_GNUC_PURE;
+void                 pango_font_description_set_absolute_size (PangoFontDescription *desc,
+							       double                size);
+gboolean             pango_font_description_get_size_is_absolute (const PangoFontDescription *desc) G_GNUC_PURE;
+void                 pango_font_description_set_gravity       (PangoFontDescription *desc,
+							       PangoGravity          gravity);
+PangoGravity         pango_font_description_get_gravity       (const PangoFontDescription *desc) G_GNUC_PURE;
+
+PangoFontMask pango_font_description_get_set_fields (const PangoFontDescription *desc) G_GNUC_PURE;
+void          pango_font_description_unset_fields   (PangoFontDescription       *desc,
+						     PangoFontMask               to_unset);
+
+void pango_font_description_merge        (PangoFontDescription       *desc,
+					  const PangoFontDescription *desc_to_merge,
+					  gboolean                    replace_existing);
+void pango_font_description_merge_static (PangoFontDescription       *desc,
+					  const PangoFontDescription *desc_to_merge,
+					  gboolean                    replace_existing);
+
+gboolean pango_font_description_better_match (const PangoFontDescription *desc,
+					      const PangoFontDescription *old_match,
+					      const PangoFontDescription *new_match) G_GNUC_PURE;
+
+PangoFontDescription *pango_font_description_from_string (const char                  *str);
+char *                pango_font_description_to_string   (const PangoFontDescription  *desc);
+char *                pango_font_description_to_filename (const PangoFontDescription  *desc);
+
+/*
+ * PangoFontMetrics
+ */
+
+#define PANGO_TYPE_FONT_METRICS  (pango_font_metrics_get_type ())
+GType             pango_font_metrics_get_type                    (void) G_GNUC_CONST;
+PangoFontMetrics *pango_font_metrics_ref                         (PangoFontMetrics *metrics);
+void              pango_font_metrics_unref                       (PangoFontMetrics *metrics);
+int               pango_font_metrics_get_ascent                  (PangoFontMetrics *metrics) G_GNUC_PURE;
+int               pango_font_metrics_get_descent                 (PangoFontMetrics *metrics) G_GNUC_PURE;
+int               pango_font_metrics_get_approximate_char_width  (PangoFontMetrics *metrics) G_GNUC_PURE;
+int               pango_font_metrics_get_approximate_digit_width (PangoFontMetrics *metrics) G_GNUC_PURE;
+int               pango_font_metrics_get_underline_position      (PangoFontMetrics *metrics) G_GNUC_PURE;
+int               pango_font_metrics_get_underline_thickness     (PangoFontMetrics *metrics) G_GNUC_PURE;
+int               pango_font_metrics_get_strikethrough_position  (PangoFontMetrics *metrics) G_GNUC_PURE;
+int               pango_font_metrics_get_strikethrough_thickness (PangoFontMetrics *metrics) G_GNUC_PURE;
+
+#ifdef PANGO_ENABLE_BACKEND
+
+PangoFontMetrics *pango_font_metrics_new (void);
+
+struct _PangoFontMetrics
+{
+  guint ref_count;
+
+  int ascent;
+  int descent;
+  int approximate_char_width;
+  int approximate_digit_width;
+  int underline_position;
+  int underline_thickness;
+  int strikethrough_position;
+  int strikethrough_thickness;
+};
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+/*
+ * PangoFontFamily
+ */
+
+#define PANGO_TYPE_FONT_FAMILY              (pango_font_family_get_type ())
+#define PANGO_FONT_FAMILY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FAMILY, PangoFontFamily))
+#define PANGO_IS_FONT_FAMILY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FAMILY))
+
+typedef struct _PangoFontFamily      PangoFontFamily;
+typedef struct _PangoFontFace        PangoFontFace;
+
+GType      pango_font_family_get_type       (void) G_GNUC_CONST;
+
+void                 pango_font_family_list_faces (PangoFontFamily  *family,
+						   PangoFontFace  ***faces,
+						   int              *n_faces);
+const char *pango_font_family_get_name   (PangoFontFamily  *family) G_GNUC_PURE;
+gboolean   pango_font_family_is_monospace         (PangoFontFamily  *family) G_GNUC_PURE;
+
+#ifdef PANGO_ENABLE_BACKEND
+
+#define PANGO_FONT_FAMILY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass))
+#define PANGO_IS_FONT_FAMILY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FAMILY))
+#define PANGO_FONT_FAMILY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass))
+
+typedef struct _PangoFontFamilyClass PangoFontFamilyClass;
+
+struct _PangoFontFamily
+{
+  GObject parent_instance;
+};
+
+struct _PangoFontFamilyClass
+{
+  GObjectClass parent_class;
+
+  /*< public >*/
+
+  void  (*list_faces)      (PangoFontFamily  *family,
+			    PangoFontFace  ***faces,
+			    int              *n_faces);
+  const char * (*get_name) (PangoFontFamily  *family);
+  gboolean (*is_monospace) (PangoFontFamily *family);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+/*
+ * PangoFontFace
+ */
+
+#define PANGO_TYPE_FONT_FACE              (pango_font_face_get_type ())
+#define PANGO_FONT_FACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FACE, PangoFontFace))
+#define PANGO_IS_FONT_FACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FACE))
+
+GType      pango_font_face_get_type       (void) G_GNUC_CONST;
+
+PangoFontDescription *pango_font_face_describe       (PangoFontFace  *face);
+const char           *pango_font_face_get_face_name  (PangoFontFace  *face) G_GNUC_PURE;
+void                  pango_font_face_list_sizes     (PangoFontFace  *face,
+						      int           **sizes,
+						      int            *n_sizes);
+gboolean              pango_font_face_is_synthesized (PangoFontFace  *face) G_GNUC_PURE;
+
+#ifdef PANGO_ENABLE_BACKEND
+
+#define PANGO_FONT_FACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FACE, PangoFontFaceClass))
+#define PANGO_IS_FONT_FACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FACE))
+#define PANGO_FONT_FACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FACE, PangoFontFaceClass))
+
+typedef struct _PangoFontFaceClass   PangoFontFaceClass;
+
+struct _PangoFontFace
+{
+  GObject parent_instance;
+};
+
+struct _PangoFontFaceClass
+{
+  GObjectClass parent_class;
+
+  /*< public >*/
+
+  const char           * (*get_face_name)  (PangoFontFace *face);
+  PangoFontDescription * (*describe)       (PangoFontFace *face);
+  void                   (*list_sizes)     (PangoFontFace  *face,
+					    int           **sizes,
+					    int            *n_sizes);
+  gboolean               (*is_synthesized) (PangoFontFace *face);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+/*
+ * PangoFont
+ */
+
+#define PANGO_TYPE_FONT              (pango_font_get_type ())
+#define PANGO_FONT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT, PangoFont))
+#define PANGO_IS_FONT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT))
+
+GType                 pango_font_get_type          (void) G_GNUC_CONST;
+
+PangoFontDescription *pango_font_describe          (PangoFont        *font);
+PangoFontDescription *pango_font_describe_with_absolute_size (PangoFont        *font);
+PangoCoverage *       pango_font_get_coverage      (PangoFont        *font,
+						    PangoLanguage    *language);
+PangoEngineShape *    pango_font_find_shaper       (PangoFont        *font,
+						    PangoLanguage    *language,
+						    guint32           ch);
+PangoFontMetrics *    pango_font_get_metrics       (PangoFont        *font,
+						    PangoLanguage    *language);
+void                  pango_font_get_glyph_extents (PangoFont        *font,
+						    PangoGlyph        glyph,
+						    PangoRectangle   *ink_rect,
+						    PangoRectangle   *logical_rect);
+PangoFontMap         *pango_font_get_font_map      (PangoFont        *font);
+
+#ifdef PANGO_ENABLE_BACKEND
+
+#define PANGO_FONT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT, PangoFontClass))
+#define PANGO_IS_FONT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT))
+#define PANGO_FONT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT, PangoFontClass))
+
+typedef struct _PangoFontClass       PangoFontClass;
+
+struct _PangoFont
+{
+  GObject parent_instance;
+};
+
+struct _PangoFontClass
+{
+  GObjectClass parent_class;
+
+  /*< public >*/
+
+  PangoFontDescription *(*describe)           (PangoFont      *font);
+  PangoCoverage *       (*get_coverage)       (PangoFont      *font,
+					       PangoLanguage  *lang);
+  PangoEngineShape *    (*find_shaper)        (PangoFont      *font,
+					       PangoLanguage  *lang,
+					       guint32         ch);
+  void                  (*get_glyph_extents)  (PangoFont      *font,
+					       PangoGlyph      glyph,
+					       PangoRectangle *ink_rect,
+					       PangoRectangle *logical_rect);
+  PangoFontMetrics *    (*get_metrics)        (PangoFont      *font,
+					       PangoLanguage  *language);
+  PangoFontMap *        (*get_font_map)       (PangoFont      *font);
+  PangoFontDescription *(*describe_absolute)  (PangoFont      *font);
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved1) (void);
+  void (*_pango_reserved2) (void);
+};
+
+/* used for very rare and miserable situtations that we cannot even
+ * draw a hexbox
+ */
+#define PANGO_UNKNOWN_GLYPH_WIDTH  10
+#define PANGO_UNKNOWN_GLYPH_HEIGHT 14
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+#define PANGO_GLYPH_EMPTY           ((PangoGlyph)0x0FFFFFFF)
+#define PANGO_GLYPH_INVALID_INPUT   ((PangoGlyph)0xFFFFFFFF)
+#define PANGO_GLYPH_UNKNOWN_FLAG    ((PangoGlyph)0x10000000)
+#define PANGO_GET_UNKNOWN_GLYPH(wc) ((PangoGlyph)(wc)|PANGO_GLYPH_UNKNOWN_FLAG)
+
+
+G_END_DECLS
+
+#endif /* __PANGO_FONT_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-fontmap.h b/gtk+-mingw/include/pango-1.0/pango/pango-fontmap.h
new file mode 100644
index 0000000..602ec9f
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-fontmap.h
@@ -0,0 +1,96 @@
+/* Pango
+ * pango-font.h: Font handling
+ *
+ * Copyright (C) 2000 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 __PANGO_FONTMAP_H__
+#define __PANGO_FONTMAP_H__
+
+#include <pango/pango-font.h>
+#include <pango/pango-fontset.h>
+
+G_BEGIN_DECLS
+
+#define PANGO_TYPE_FONT_MAP              (pango_font_map_get_type ())
+#define PANGO_FONT_MAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_MAP, PangoFontMap))
+#define PANGO_IS_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_MAP))
+
+typedef struct _PangoContext PangoContext;
+
+GType         pango_font_map_get_type       (void) G_GNUC_CONST;
+PangoContext * pango_font_map_create_context (PangoFontMap               *fontmap);
+PangoFont *   pango_font_map_load_font     (PangoFontMap                 *fontmap,
+					    PangoContext                 *context,
+					    const PangoFontDescription   *desc);
+PangoFontset *pango_font_map_load_fontset  (PangoFontMap                 *fontmap,
+					    PangoContext                 *context,
+					    const PangoFontDescription   *desc,
+					    PangoLanguage                *language);
+void          pango_font_map_list_families (PangoFontMap                 *fontmap,
+					    PangoFontFamily            ***families,
+					    int                          *n_families);
+
+#ifdef PANGO_ENABLE_BACKEND
+
+#define PANGO_FONT_MAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
+#define PANGO_IS_FONT_MAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_MAP))
+#define PANGO_FONT_MAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
+
+typedef struct _PangoFontMapClass PangoFontMapClass;
+
+struct _PangoFontMap
+{
+  GObject parent_instance;
+};
+
+struct _PangoFontMapClass
+{
+  GObjectClass parent_class;
+
+  /*< public >*/
+
+  PangoFont *   (*load_font)     (PangoFontMap               *fontmap,
+				  PangoContext               *context,
+				  const PangoFontDescription *desc);
+  void          (*list_families) (PangoFontMap               *fontmap,
+				  PangoFontFamily          ***families,
+				  int                        *n_families);
+  PangoFontset *(*load_fontset)  (PangoFontMap               *fontmap,
+				  PangoContext               *context,
+				  const PangoFontDescription *desc,
+				  PangoLanguage              *language);
+
+  const char *shape_engine_type;
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved1) (void);
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+const char   *pango_font_map_get_shape_engine_type (PangoFontMap *fontmap);
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+G_END_DECLS
+
+#endif /* __PANGO_FONTMAP_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-fontset.h b/gtk+-mingw/include/pango-1.0/pango/pango-fontset.h
new file mode 100644
index 0000000..5c6c748
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-fontset.h
@@ -0,0 +1,127 @@
+/* Pango
+ * pango-fontset.h: Font set handling
+ *
+ * Copyright (C) 2001 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 __PANGO_FONTSET_H__
+#define __PANGO_FONTSET_H__
+
+#include <pango/pango-coverage.h>
+#include <pango/pango-types.h>
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/*
+ * PangoFontset
+ */
+
+#define PANGO_TYPE_FONTSET              (pango_fontset_get_type ())
+#define PANGO_FONTSET(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONTSET, PangoFontset))
+#define PANGO_IS_FONTSET(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONTSET))
+
+GType pango_fontset_get_type (void) G_GNUC_CONST;
+
+typedef struct _PangoFontset        PangoFontset;
+
+/**
+ * PangoFontsetForeachFunc
+ * @fontset: a #PangoFontset
+ * @font: a font from @fontset
+ * @data: callback data
+ *
+ * A callback function used by pango_fontset_foreach() when enumerating
+ * the fonts in a fontset.
+ *
+ * Returns: if %TRUE, stop iteration and return immediately.
+ *
+ * Since: 1.4
+ **/
+typedef gboolean (*PangoFontsetForeachFunc) (PangoFontset  *fontset,
+					     PangoFont     *font,
+					     gpointer       data);
+
+PangoFont *       pango_fontset_get_font    (PangoFontset           *fontset,
+					     guint                   wc);
+PangoFontMetrics *pango_fontset_get_metrics (PangoFontset           *fontset);
+void              pango_fontset_foreach     (PangoFontset           *fontset,
+					     PangoFontsetForeachFunc func,
+					     gpointer                data);
+
+#ifdef PANGO_ENABLE_BACKEND
+
+typedef struct _PangoFontsetClass   PangoFontsetClass;
+
+#define PANGO_FONTSET_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONTSET, PangoFontsetClass))
+#define PANGO_IS_FONTSET_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONTSET))
+#define PANGO_FONTSET_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONTSET, PangoFontsetClass))
+
+struct _PangoFontset
+{
+  GObject parent_instance;
+};
+
+struct _PangoFontsetClass
+{
+  GObjectClass parent_class;
+
+  /*< public >*/
+
+  PangoFont *       (*get_font)     (PangoFontset     *fontset,
+				     guint             wc);
+
+  PangoFontMetrics *(*get_metrics)  (PangoFontset     *fontset);
+  PangoLanguage *   (*get_language) (PangoFontset     *fontset);
+  void              (*foreach)      (PangoFontset           *fontset,
+				     PangoFontsetForeachFunc func,
+				     gpointer                data);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved1) (void);
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+/*
+ * PangoFontsetSimple
+ */
+
+#define PANGO_TYPE_FONTSET_SIMPLE       (pango_fontset_simple_get_type ())
+#define PANGO_FONTSET_SIMPLE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONTSET_SIMPLE, PangoFontsetSimple))
+#define PANGO_IS_FONTSET_SIMPLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONTSET_SIMPLE))
+
+typedef struct _PangoFontsetSimple  PangoFontsetSimple;
+typedef struct _PangoFontsetSimpleClass  PangoFontsetSimpleClass;
+
+GType pango_fontset_simple_get_type (void) G_GNUC_CONST;
+
+PangoFontsetSimple * pango_fontset_simple_new    (PangoLanguage      *language);
+void                 pango_fontset_simple_append (PangoFontsetSimple *fontset,
+						  PangoFont          *font);
+int                  pango_fontset_simple_size   (PangoFontsetSimple *fontset);
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+G_END_DECLS
+
+#endif /* __PANGO_FONTSET_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-glyph-item.h b/gtk+-mingw/include/pango-1.0/pango/pango-glyph-item.h
new file mode 100644
index 0000000..71c4ab3
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-glyph-item.h
@@ -0,0 +1,94 @@
+/* Pango
+ * pango-glyph-item.h: Pair of PangoItem and a glyph string
+ *
+ * Copyright (C) 2002 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 __PANGO_GLYPH_ITEM_H__
+#define __PANGO_GLYPH_ITEM_H__
+
+#include <pango/pango-attributes.h>
+#include <pango/pango-break.h>
+#include <pango/pango-item.h>
+#include <pango/pango-glyph.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoGlyphItem PangoGlyphItem;
+
+struct _PangoGlyphItem
+{
+  PangoItem        *item;
+  PangoGlyphString *glyphs;
+};
+
+#define PANGO_TYPE_GLYPH_ITEM (pango_glyph_item_get_type ())
+
+GType pango_glyph_item_get_type (void) G_GNUC_CONST;
+
+PangoGlyphItem *pango_glyph_item_split        (PangoGlyphItem *orig,
+					       const char     *text,
+					       int             split_index);
+PangoGlyphItem *pango_glyph_item_copy         (PangoGlyphItem *orig);
+void            pango_glyph_item_free         (PangoGlyphItem *glyph_item);
+GSList *        pango_glyph_item_apply_attrs  (PangoGlyphItem *glyph_item,
+					       const char     *text,
+					       PangoAttrList  *list);
+void            pango_glyph_item_letter_space (PangoGlyphItem *glyph_item,
+					       const char     *text,
+					       PangoLogAttr   *log_attrs,
+					       int             letter_spacing);
+void 	  pango_glyph_item_get_logical_widths (PangoGlyphItem *glyph_item,
+					       const char     *text,
+					       int            *logical_widths);
+
+
+typedef struct _PangoGlyphItemIter PangoGlyphItemIter;
+
+struct _PangoGlyphItemIter
+{
+  PangoGlyphItem *glyph_item;
+  const gchar *text;
+
+  int start_glyph;
+  int start_index;
+  int start_char;
+
+  int end_glyph;
+  int end_index;
+  int end_char;
+};
+
+#define PANGO_TYPE_GLYPH_ITEM_ITER (pango_glyph_item_iter_get_type ())
+
+GType               pango_glyph_item_iter_get_type (void) G_GNUC_CONST;
+PangoGlyphItemIter *pango_glyph_item_iter_copy (PangoGlyphItemIter *orig);
+void                pango_glyph_item_iter_free (PangoGlyphItemIter *iter);
+
+gboolean pango_glyph_item_iter_init_start   (PangoGlyphItemIter *iter,
+					     PangoGlyphItem     *glyph_item,
+					     const char         *text);
+gboolean pango_glyph_item_iter_init_end     (PangoGlyphItemIter *iter,
+					     PangoGlyphItem     *glyph_item,
+					     const char         *text);
+gboolean pango_glyph_item_iter_next_cluster (PangoGlyphItemIter *iter);
+gboolean pango_glyph_item_iter_prev_cluster (PangoGlyphItemIter *iter);
+
+G_END_DECLS
+
+#endif /* __PANGO_GLYPH_ITEM_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-glyph.h b/gtk+-mingw/include/pango-1.0/pango/pango-glyph.h
new file mode 100644
index 0000000..4af63e7
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-glyph.h
@@ -0,0 +1,135 @@
+/* Pango
+ * pango-glyph.h: Glyph storage
+ *
+ * Copyright (C) 2000 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 __PANGO_GLYPH_H__
+#define __PANGO_GLYPH_H__
+
+#include <pango/pango-types.h>
+#include <pango/pango-item.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoGlyphGeometry PangoGlyphGeometry;
+typedef struct _PangoGlyphVisAttr PangoGlyphVisAttr;
+typedef struct _PangoGlyphInfo PangoGlyphInfo;
+typedef struct _PangoGlyphString PangoGlyphString;
+
+/* 1024ths of a device unit */
+typedef gint32 PangoGlyphUnit;
+
+/* Positioning information about a glyph
+ */
+struct _PangoGlyphGeometry
+{
+  PangoGlyphUnit width;
+  PangoGlyphUnit x_offset;
+  PangoGlyphUnit y_offset;
+};
+
+/* Visual attributes of a glyph
+ */
+struct _PangoGlyphVisAttr
+{
+  guint is_cluster_start : 1;
+};
+
+/* A single glyph
+ */
+struct _PangoGlyphInfo
+{
+  PangoGlyph    glyph;
+  PangoGlyphGeometry geometry;
+  PangoGlyphVisAttr  attr;
+};
+
+/* A string of glyphs with positional information and visual attributes -
+ * ready for drawing
+ */
+struct _PangoGlyphString {
+  gint num_glyphs;
+
+  PangoGlyphInfo *glyphs;
+
+  /* This is a memory inefficient way of representing the information
+   * here - each value gives the byte index within the text
+   * corresponding to the glyph string of the start of the cluster to
+   * which the glyph belongs.
+   */
+  gint *log_clusters;
+
+  /*< private >*/
+  gint space;
+};
+
+#define PANGO_TYPE_GLYPH_STRING (pango_glyph_string_get_type ())
+
+PangoGlyphString *pango_glyph_string_new      (void);
+void              pango_glyph_string_set_size (PangoGlyphString *string,
+					       gint              new_len);
+GType             pango_glyph_string_get_type (void) G_GNUC_CONST;
+PangoGlyphString *pango_glyph_string_copy     (PangoGlyphString *string);
+void              pango_glyph_string_free     (PangoGlyphString *string);
+void              pango_glyph_string_extents  (PangoGlyphString *glyphs,
+					       PangoFont        *font,
+					       PangoRectangle   *ink_rect,
+					       PangoRectangle   *logical_rect);
+int               pango_glyph_string_get_width(PangoGlyphString *glyphs);
+
+void              pango_glyph_string_extents_range  (PangoGlyphString *glyphs,
+						     int               start,
+						     int               end,
+						     PangoFont        *font,
+						     PangoRectangle   *ink_rect,
+						     PangoRectangle   *logical_rect);
+
+void pango_glyph_string_get_logical_widths (PangoGlyphString *glyphs,
+					    const char       *text,
+					    int               length,
+					    int               embedding_level,
+					    int              *logical_widths);
+
+void pango_glyph_string_index_to_x (PangoGlyphString *glyphs,
+				    char             *text,
+				    int               length,
+				    PangoAnalysis    *analysis,
+				    int               index_,
+				    gboolean          trailing,
+				    int              *x_pos);
+void pango_glyph_string_x_to_index (PangoGlyphString *glyphs,
+				    char             *text,
+				    int               length,
+				    PangoAnalysis    *analysis,
+				    int               x_pos,
+				    int              *index_,
+				    int              *trailing);
+
+/* Turn a string of characters into a string of glyphs
+ */
+void pango_shape (const gchar      *text,
+		  gint              length,
+		  const PangoAnalysis *analysis,
+		  PangoGlyphString *glyphs);
+
+GList *pango_reorder_items (GList *logical_items);
+
+G_END_DECLS
+
+#endif /* __PANGO_GLYPH_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-gravity.h b/gtk+-mingw/include/pango-1.0/pango/pango-gravity.h
new file mode 100644
index 0000000..d2fa964
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-gravity.h
@@ -0,0 +1,114 @@
+/* Pango
+ * pango-gravity.h: Gravity routines
+ *
+ * Copyright (C) 2006, 2007 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 __PANGO_GRAVITY_H__
+#define __PANGO_GRAVITY_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/**
+ * PangoGravity:
+ * @PANGO_GRAVITY_SOUTH: Glyphs stand upright (default)
+ * @PANGO_GRAVITY_EAST: Glyphs are rotated 90 degrees clockwise
+ * @PANGO_GRAVITY_NORTH: Glyphs are upside-down
+ * @PANGO_GRAVITY_WEST: Glyphs are rotated 90 degrees counter-clockwise
+ * @PANGO_GRAVITY_AUTO: Gravity is resolved from the context matrix
+ *
+ * The #PangoGravity type represents the orientation of glyphs in a segment
+ * of text.  This is useful when rendering vertical text layouts.  In
+ * those situations, the layout is rotated using a non-identity PangoMatrix,
+ * and then glyph orientation is controlled using #PangoGravity.
+ * Not every value in this enumeration makes sense for every usage of
+ * #PangoGravity; for example, %PANGO_GRAVITY_AUTO only can be passed to
+ * pango_context_set_base_gravity() and can only be returned by
+ * pango_context_get_base_gravity().
+ *
+ * See also: #PangoGravityHint
+ *
+ * Since: 1.16
+ **/
+typedef enum {
+  PANGO_GRAVITY_SOUTH,
+  PANGO_GRAVITY_EAST,
+  PANGO_GRAVITY_NORTH,
+  PANGO_GRAVITY_WEST,
+  PANGO_GRAVITY_AUTO
+} PangoGravity;
+
+/**
+ * PangoGravityHint:
+ * @PANGO_GRAVITY_HINT_NATURAL: scripts will take their natural gravity based
+ * on the base gravity and the script.  This is the default.
+ * @PANGO_GRAVITY_HINT_STRONG: always use the base gravity set, regardless of
+ * the script.
+ * @PANGO_GRAVITY_HINT_LINE: for scripts not in their natural direction (eg.
+ * Latin in East gravity), choose per-script gravity such that every script
+ * respects the line progression.  This means, Latin and Arabic will take
+ * opposite gravities and both flow top-to-bottom for example.
+ *
+ * The #PangoGravityHint defines how horizontal scripts should behave in a
+ * vertical context.  That is, English excerpt in a vertical paragraph for
+ * example.
+ *
+ * See #PangoGravity.
+ *
+ * Since: 1.16
+ **/
+typedef enum {
+  PANGO_GRAVITY_HINT_NATURAL,
+  PANGO_GRAVITY_HINT_STRONG,
+  PANGO_GRAVITY_HINT_LINE
+} PangoGravityHint;
+
+/**
+ * PANGO_GRAVITY_IS_VERTICAL:
+ * @gravity: the #PangoGravity to check
+ *
+ * Whether a #PangoGravity represents vertical writing directions.
+ *
+ * Returns: %TRUE if @gravity is %PANGO_GRAVITY_EAST or %PANGO_GRAVITY_WEST,
+ *          %FALSE otherwise.
+ *
+ * Since: 1.16
+ **/
+#define PANGO_GRAVITY_IS_VERTICAL(gravity) \
+	((gravity) == PANGO_GRAVITY_EAST || (gravity) == PANGO_GRAVITY_WEST)
+
+#include <pango/pango-matrix.h>
+#include <pango/pango-script.h>
+
+double       pango_gravity_to_rotation    (PangoGravity       gravity) G_GNUC_CONST;
+PangoGravity pango_gravity_get_for_matrix (const PangoMatrix *matrix) G_GNUC_PURE;
+PangoGravity pango_gravity_get_for_script (PangoScript        script,
+					   PangoGravity       base_gravity,
+					   PangoGravityHint   hint) G_GNUC_CONST;
+PangoGravity pango_gravity_get_for_script_and_width
+					  (PangoScript        script,
+					   gboolean           wide,
+					   PangoGravity       base_gravity,
+					   PangoGravityHint   hint) G_GNUC_CONST;
+
+
+G_END_DECLS
+
+#endif /* __PANGO_GRAVITY_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-item.h b/gtk+-mingw/include/pango-1.0/pango/pango-item.h
new file mode 100644
index 0000000..0775003
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-item.h
@@ -0,0 +1,72 @@
+/* Pango
+ * pango-item.h: Structure for storing run information
+ *
+ * Copyright (C) 2000 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 __PANGO_ITEM_H__
+#define __PANGO_ITEM_H__
+
+#include <pango/pango-types.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoAnalysis PangoAnalysis;
+typedef struct _PangoItem PangoItem;
+
+/* TODO: if more flags are needed, turn this into a real PangoAnalysisFlags enum */
+#define PANGO_ANALYSIS_FLAG_CENTERED_BASELINE (1 << 0)
+
+struct _PangoAnalysis
+{
+  PangoEngineShape *shape_engine;
+  PangoEngineLang  *lang_engine;
+  PangoFont *font;
+
+  guint8 level;
+  guint8 gravity; /* PangoGravity */
+  guint8 flags;
+
+  guint8 script; /* PangoScript */
+  PangoLanguage *language;
+
+  GSList *extra_attrs;
+};
+
+struct _PangoItem
+{
+  gint offset;
+  gint length;
+  gint num_chars;
+  PangoAnalysis analysis;
+};
+
+#define PANGO_TYPE_ITEM (pango_item_get_type ())
+
+GType pango_item_get_type (void) G_GNUC_CONST;
+
+PangoItem *pango_item_new   (void);
+PangoItem *pango_item_copy  (PangoItem  *item);
+void       pango_item_free  (PangoItem  *item);
+PangoItem *pango_item_split (PangoItem  *orig,
+			     int         split_index,
+			     int         split_offset);
+
+G_END_DECLS
+
+#endif /* __PANGO_ITEM_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-language.h b/gtk+-mingw/include/pango-1.0/pango/pango-language.h
new file mode 100644
index 0000000..31660ca
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-language.h
@@ -0,0 +1,56 @@
+/* Pango
+ * pango-language.h: Language handling routines
+ *
+ * Copyright (C) 1999 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 __PANGO_LANGUAGE_H__
+#define __PANGO_LANGUAGE_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoLanguage PangoLanguage;
+
+#define PANGO_TYPE_LANGUAGE (pango_language_get_type ())
+
+GType          pango_language_get_type    (void) G_GNUC_CONST;
+PangoLanguage *pango_language_from_string (const char *language);
+
+const char    *pango_language_to_string   (PangoLanguage *language) G_GNUC_CONST;
+/* For back compat.  Will have to keep indefinitely. */
+#define pango_language_to_string(language) ((const char *)language)
+
+const char    *pango_language_get_sample_string (PangoLanguage *language) G_GNUC_CONST;
+PangoLanguage *pango_language_get_default (void) G_GNUC_CONST;
+
+gboolean      pango_language_matches  (PangoLanguage *language,
+				       const char *range_list) G_GNUC_PURE;
+
+#include <pango/pango-script.h>
+
+gboolean		    pango_language_includes_script (PangoLanguage *language,
+							    PangoScript    script) G_GNUC_PURE;
+const PangoScript          *pango_language_get_scripts	   (PangoLanguage *language,
+							    int           *num_scripts);
+
+G_END_DECLS
+
+#endif /* __PANGO_LANGUAGE_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-layout.h b/gtk+-mingw/include/pango-1.0/pango/pango-layout.h
new file mode 100644
index 0000000..bb0a0cf
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-layout.h
@@ -0,0 +1,296 @@
+/* Pango
+ * pango-layout.h: High-level layout driver
+ *
+ * Copyright (C) 2000 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 __PANGO_LAYOUT_H__
+#define __PANGO_LAYOUT_H__
+
+#include <pango/pango-attributes.h>
+#include <pango/pango-context.h>
+#include <pango/pango-glyph-item.h>
+#include <pango/pango-tabs.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoLayout      PangoLayout;
+typedef struct _PangoLayoutClass PangoLayoutClass;
+typedef struct _PangoLayoutLine  PangoLayoutLine;
+
+typedef PangoGlyphItem PangoLayoutRun;
+
+typedef enum {
+  PANGO_ALIGN_LEFT,
+  PANGO_ALIGN_CENTER,
+  PANGO_ALIGN_RIGHT
+} PangoAlignment;
+
+typedef enum {
+  PANGO_WRAP_WORD,
+  PANGO_WRAP_CHAR,
+  PANGO_WRAP_WORD_CHAR
+} PangoWrapMode;
+
+/**
+ * PangoEllipsizeMode
+ * @PANGO_ELLIPSIZE_NONE: No ellipsization
+ * @PANGO_ELLIPSIZE_START: Omit characters at the start of the text
+ * @PANGO_ELLIPSIZE_MIDDLE: Omit characters in the middle of the text
+ * @PANGO_ELLIPSIZE_END: Omit characters at the end of the text
+ *
+ * The #PangoEllipsizeMode type describes what sort of (if any)
+ * ellipsization should be applied to a line of text. In
+ * the ellipsization process characters are removed from the
+ * text in order to make it fit to a given width and replaced
+ * with an ellipsis.
+ */
+typedef enum {
+  PANGO_ELLIPSIZE_NONE,
+  PANGO_ELLIPSIZE_START,
+  PANGO_ELLIPSIZE_MIDDLE,
+  PANGO_ELLIPSIZE_END
+} PangoEllipsizeMode;
+
+struct _PangoLayoutLine
+{
+  PangoLayout *layout;
+  gint         start_index;     /* start of line as byte index into layout->text */
+  gint         length;		/* length of line in bytes */
+  GSList      *runs;
+  guint        is_paragraph_start : 1;  /* TRUE if this is the first line of the paragraph */
+  guint        resolved_dir : 3;  /* Resolved PangoDirection of line */
+};
+
+#define PANGO_TYPE_LAYOUT              (pango_layout_get_type ())
+#define PANGO_LAYOUT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_LAYOUT, PangoLayout))
+#define PANGO_LAYOUT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_LAYOUT, PangoLayoutClass))
+#define PANGO_IS_LAYOUT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_LAYOUT))
+#define PANGO_IS_LAYOUT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_LAYOUT))
+#define PANGO_LAYOUT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_LAYOUT, PangoLayoutClass))
+
+/* The PangoLayout and PangoLayoutClass structs are private; if you
+ * need to create a subclass of these, file a bug.
+ */
+
+GType        pango_layout_get_type       (void) G_GNUC_CONST;
+PangoLayout *pango_layout_new            (PangoContext   *context);
+PangoLayout *pango_layout_copy           (PangoLayout    *src);
+
+PangoContext  *pango_layout_get_context    (PangoLayout    *layout);
+
+void           pango_layout_set_attributes (PangoLayout    *layout,
+					    PangoAttrList  *attrs);
+PangoAttrList *pango_layout_get_attributes (PangoLayout    *layout);
+
+void           pango_layout_set_text       (PangoLayout    *layout,
+					    const char     *text,
+					    int             length);
+const char    *pango_layout_get_text       (PangoLayout    *layout);
+
+gint           pango_layout_get_character_count (PangoLayout *layout);
+
+void           pango_layout_set_markup     (PangoLayout    *layout,
+					    const char     *markup,
+					    int             length);
+
+void           pango_layout_set_markup_with_accel (PangoLayout    *layout,
+						   const char     *markup,
+						   int             length,
+						   gunichar        accel_marker,
+						   gunichar       *accel_char);
+
+void           pango_layout_set_font_description (PangoLayout                *layout,
+						  const PangoFontDescription *desc);
+
+const PangoFontDescription *pango_layout_get_font_description (PangoLayout *layout);
+
+void           pango_layout_set_width            (PangoLayout                *layout,
+						  int                         width);
+int            pango_layout_get_width            (PangoLayout                *layout);
+void           pango_layout_set_height           (PangoLayout                *layout,
+						  int                         height);
+int            pango_layout_get_height           (PangoLayout                *layout);
+void           pango_layout_set_wrap             (PangoLayout                *layout,
+						  PangoWrapMode               wrap);
+PangoWrapMode  pango_layout_get_wrap             (PangoLayout                *layout);
+gboolean       pango_layout_is_wrapped           (PangoLayout                *layout);
+void           pango_layout_set_indent           (PangoLayout                *layout,
+						  int                         indent);
+int            pango_layout_get_indent           (PangoLayout                *layout);
+void           pango_layout_set_spacing          (PangoLayout                *layout,
+						  int                         spacing);
+int            pango_layout_get_spacing          (PangoLayout                *layout);
+void           pango_layout_set_justify          (PangoLayout                *layout,
+						  gboolean                    justify);
+gboolean       pango_layout_get_justify          (PangoLayout                *layout);
+void           pango_layout_set_auto_dir         (PangoLayout                *layout,
+						  gboolean                    auto_dir);
+gboolean       pango_layout_get_auto_dir         (PangoLayout                *layout);
+void           pango_layout_set_alignment        (PangoLayout                *layout,
+						  PangoAlignment              alignment);
+PangoAlignment pango_layout_get_alignment        (PangoLayout                *layout);
+
+void           pango_layout_set_tabs             (PangoLayout                *layout,
+						  PangoTabArray              *tabs);
+
+PangoTabArray* pango_layout_get_tabs             (PangoLayout                *layout);
+
+void           pango_layout_set_single_paragraph_mode (PangoLayout                *layout,
+						       gboolean                    setting);
+gboolean       pango_layout_get_single_paragraph_mode (PangoLayout                *layout);
+
+void               pango_layout_set_ellipsize (PangoLayout        *layout,
+					       PangoEllipsizeMode  ellipsize);
+PangoEllipsizeMode pango_layout_get_ellipsize (PangoLayout        *layout);
+gboolean           pango_layout_is_ellipsized (PangoLayout        *layout);
+
+int      pango_layout_get_unknown_glyphs_count (PangoLayout    *layout);
+
+void     pango_layout_context_changed (PangoLayout    *layout);
+
+void     pango_layout_get_log_attrs (PangoLayout    *layout,
+				     PangoLogAttr  **attrs,
+				     gint           *n_attrs);
+
+const PangoLogAttr *pango_layout_get_log_attrs_readonly (PangoLayout *layout,
+							 gint        *n_attrs);
+
+void     pango_layout_index_to_pos         (PangoLayout    *layout,
+					    int             index_,
+					    PangoRectangle *pos);
+void     pango_layout_index_to_line_x      (PangoLayout    *layout,
+					    int             index_,
+					    gboolean        trailing,
+					    int            *line,
+					    int            *x_pos);
+void     pango_layout_get_cursor_pos       (PangoLayout    *layout,
+					    int             index_,
+					    PangoRectangle *strong_pos,
+					    PangoRectangle *weak_pos);
+void     pango_layout_move_cursor_visually (PangoLayout    *layout,
+					    gboolean        strong,
+					    int             old_index,
+					    int             old_trailing,
+					    int             direction,
+					    int            *new_index,
+					    int            *new_trailing);
+gboolean pango_layout_xy_to_index          (PangoLayout    *layout,
+					    int             x,
+					    int             y,
+					    int            *index_,
+					    int            *trailing);
+void     pango_layout_get_extents          (PangoLayout    *layout,
+					    PangoRectangle *ink_rect,
+					    PangoRectangle *logical_rect);
+void     pango_layout_get_pixel_extents    (PangoLayout    *layout,
+					    PangoRectangle *ink_rect,
+					    PangoRectangle *logical_rect);
+void     pango_layout_get_size             (PangoLayout    *layout,
+					    int            *width,
+					    int            *height);
+void     pango_layout_get_pixel_size       (PangoLayout    *layout,
+					    int            *width,
+					    int            *height);
+int      pango_layout_get_baseline         (PangoLayout    *layout);
+
+int              pango_layout_get_line_count       (PangoLayout    *layout);
+PangoLayoutLine *pango_layout_get_line             (PangoLayout    *layout,
+						    int             line);
+PangoLayoutLine *pango_layout_get_line_readonly    (PangoLayout    *layout,
+						    int             line);
+GSList *         pango_layout_get_lines            (PangoLayout    *layout);
+GSList *         pango_layout_get_lines_readonly   (PangoLayout    *layout);
+
+
+#define PANGO_TYPE_LAYOUT_LINE (pango_layout_line_get_type ())
+
+GType    pango_layout_line_get_type     (void) G_GNUC_CONST;
+
+PangoLayoutLine *pango_layout_line_ref   (PangoLayoutLine *line);
+void             pango_layout_line_unref (PangoLayoutLine *line);
+
+gboolean pango_layout_line_x_to_index   (PangoLayoutLine  *line,
+					 int               x_pos,
+					 int              *index_,
+					 int              *trailing);
+void     pango_layout_line_index_to_x   (PangoLayoutLine  *line,
+					 int               index_,
+					 gboolean          trailing,
+					 int              *x_pos);
+void     pango_layout_line_get_x_ranges (PangoLayoutLine  *line,
+					 int               start_index,
+					 int               end_index,
+					 int             **ranges,
+					 int              *n_ranges);
+void     pango_layout_line_get_extents  (PangoLayoutLine  *line,
+					 PangoRectangle   *ink_rect,
+					 PangoRectangle   *logical_rect);
+void     pango_layout_line_get_pixel_extents (PangoLayoutLine *layout_line,
+					      PangoRectangle  *ink_rect,
+					      PangoRectangle  *logical_rect);
+
+typedef struct _PangoLayoutIter PangoLayoutIter;
+
+#define PANGO_TYPE_LAYOUT_ITER         (pango_layout_iter_get_type ())
+
+GType            pango_layout_iter_get_type (void) G_GNUC_CONST;
+
+PangoLayoutIter *pango_layout_get_iter  (PangoLayout     *layout);
+PangoLayoutIter *pango_layout_iter_copy (PangoLayoutIter *iter);
+void             pango_layout_iter_free (PangoLayoutIter *iter);
+
+int              pango_layout_iter_get_index  (PangoLayoutIter *iter);
+PangoLayoutRun  *pango_layout_iter_get_run    (PangoLayoutIter *iter);
+PangoLayoutRun  *pango_layout_iter_get_run_readonly   (PangoLayoutIter *iter);
+PangoLayoutLine *pango_layout_iter_get_line   (PangoLayoutIter *iter);
+PangoLayoutLine *pango_layout_iter_get_line_readonly  (PangoLayoutIter *iter);
+gboolean         pango_layout_iter_at_last_line (PangoLayoutIter *iter);
+PangoLayout     *pango_layout_iter_get_layout (PangoLayoutIter *iter);
+
+gboolean pango_layout_iter_next_char    (PangoLayoutIter *iter);
+gboolean pango_layout_iter_next_cluster (PangoLayoutIter *iter);
+gboolean pango_layout_iter_next_run     (PangoLayoutIter *iter);
+gboolean pango_layout_iter_next_line    (PangoLayoutIter *iter);
+
+void pango_layout_iter_get_char_extents    (PangoLayoutIter *iter,
+					    PangoRectangle  *logical_rect);
+void pango_layout_iter_get_cluster_extents (PangoLayoutIter *iter,
+					    PangoRectangle  *ink_rect,
+					    PangoRectangle  *logical_rect);
+void pango_layout_iter_get_run_extents     (PangoLayoutIter *iter,
+					    PangoRectangle  *ink_rect,
+					    PangoRectangle  *logical_rect);
+void pango_layout_iter_get_line_extents    (PangoLayoutIter *iter,
+					    PangoRectangle  *ink_rect,
+					    PangoRectangle  *logical_rect);
+/* All the yranges meet, unlike the logical_rect's (i.e. the yranges
+ * assign between-line spacing to the nearest line)
+ */
+void pango_layout_iter_get_line_yrange     (PangoLayoutIter *iter,
+					    int             *y0_,
+					    int             *y1_);
+void pango_layout_iter_get_layout_extents  (PangoLayoutIter *iter,
+					    PangoRectangle  *ink_rect,
+					    PangoRectangle  *logical_rect);
+int  pango_layout_iter_get_baseline        (PangoLayoutIter *iter);
+
+G_END_DECLS
+
+#endif /* __PANGO_LAYOUT_H__ */
+
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-matrix.h b/gtk+-mingw/include/pango-1.0/pango/pango-matrix.h
new file mode 100644
index 0000000..5909367
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-matrix.h
@@ -0,0 +1,117 @@
+/* Pango
+ * pango-matrix.h: Matrix manipulation routines
+ *
+ * Copyright (C) 2002, 2006 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 __PANGO_MATRIX_H__
+#define __PANGO_MATRIX_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoMatrix    PangoMatrix;
+
+/**
+ * PangoMatrix:
+ * @xx: 1st component of the transformation matrix
+ * @xy: 2nd component of the transformation matrix
+ * @yx: 3rd component of the transformation matrix
+ * @yy: 4th component of the transformation matrix
+ * @x0: x translation
+ * @y0: y translation
+ *
+ * A structure specifying a transformation between user-space
+ * coordinates and device coordinates. The transformation
+ * is given by
+ *
+ * <programlisting>
+ * x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
+ * y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
+ * </programlisting>
+ *
+ * Since: 1.6
+ **/
+struct _PangoMatrix
+{
+  double xx;
+  double xy;
+  double yx;
+  double yy;
+  double x0;
+  double y0;
+};
+
+/**
+ * PANGO_TYPE_MATRIX
+ *
+ * The GObject type for #PangoMatrix
+ **/
+#define PANGO_TYPE_MATRIX (pango_matrix_get_type ())
+
+/**
+ * PANGO_MATRIX_INIT
+ *
+ * Constant that can be used to initialize a PangoMatrix to
+ * the identity transform.
+ *
+ * <informalexample><programlisting>
+ * PangoMatrix matrix = PANGO_MATRIX_INIT;
+ * pango_matrix_rotate (&amp;matrix, 45.);
+ * </programlisting></informalexample>
+ *
+ * Since: 1.6
+ **/
+#define PANGO_MATRIX_INIT { 1., 0., 0., 1., 0., 0. }
+
+/* for PangoRectangle */
+#include <pango/pango-types.h>
+
+GType pango_matrix_get_type (void) G_GNUC_CONST;
+
+PangoMatrix *pango_matrix_copy   (const PangoMatrix *matrix);
+void         pango_matrix_free   (PangoMatrix *matrix);
+
+void pango_matrix_translate (PangoMatrix *matrix,
+			     double       tx,
+			     double       ty);
+void pango_matrix_scale     (PangoMatrix *matrix,
+			     double       scale_x,
+			     double       scale_y);
+void pango_matrix_rotate    (PangoMatrix *matrix,
+			     double       degrees);
+void pango_matrix_concat    (PangoMatrix       *matrix,
+			     const PangoMatrix *new_matrix);
+void pango_matrix_transform_point    (const PangoMatrix *matrix,
+				      double            *x,
+				      double            *y);
+void pango_matrix_transform_distance (const PangoMatrix *matrix,
+				      double            *dx,
+				      double            *dy);
+void pango_matrix_transform_rectangle (const PangoMatrix *matrix,
+				       PangoRectangle    *rect);
+void pango_matrix_transform_pixel_rectangle (const PangoMatrix *matrix,
+					     PangoRectangle    *rect);
+double pango_matrix_get_font_scale_factor (const PangoMatrix *matrix) G_GNUC_PURE;
+
+
+G_END_DECLS
+
+#endif /* __PANGO_MATRIX_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-modules.h b/gtk+-mingw/include/pango-1.0/pango/pango-modules.h
new file mode 100644
index 0000000..5dbcfe9
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-modules.h
@@ -0,0 +1,60 @@
+/* Pango
+ * pango-modules.h:
+ *
+ * Copyright (C) 1999 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 __PANGO_MODULES_H__
+#define __PANGO_MODULES_H__
+
+#include <pango/pango-engine.h>
+
+G_BEGIN_DECLS
+
+#ifdef PANGO_ENABLE_BACKEND
+
+typedef struct _PangoMap PangoMap;
+typedef struct _PangoMapEntry PangoMapEntry;
+
+typedef struct _PangoIncludedModule PangoIncludedModule;
+
+struct _PangoIncludedModule
+{
+  void (*list) (PangoEngineInfo **engines,
+		int              *n_engines);
+  void (*init) (GTypeModule      *module);
+  void (*exit) (void);
+  PangoEngine *(*create) (const char       *id);
+};
+
+PangoMap *     pango_find_map        (PangoLanguage       *language,
+				      guint                engine_type_id,
+				      guint                render_type_id);
+PangoEngine *  pango_map_get_engine  (PangoMap            *map,
+				      PangoScript          script);
+void           pango_map_get_engines (PangoMap            *map,
+				      PangoScript          script,
+				      GSList             **exact_engines,
+				      GSList             **fallback_engines);
+void           pango_module_register (PangoIncludedModule *module);
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+G_END_DECLS
+
+#endif /* __PANGO_MODULES_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-ot.h b/gtk+-mingw/include/pango-1.0/pango/pango-ot.h
new file mode 100644
index 0000000..6a436fc
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-ot.h
@@ -0,0 +1,197 @@
+/* Pango
+ * pango-ot.h:
+ *
+ * Copyright (C) 2000,2007 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 __PANGO_OT_H__
+#define __PANGO_OT_H__
+
+#include <pango/pangofc-font.h>
+#include <pango/pango-glyph.h>
+#include <pango/pango-font.h>
+#include <pango/pango-script.h>
+#include <pango/pango-language.h>
+
+G_BEGIN_DECLS
+
+#ifdef PANGO_ENABLE_ENGINE
+
+typedef guint32 PangoOTTag;
+
+#define PANGO_OT_TAG_MAKE(c1,c2,c3,c4)		((PangoOTTag) FT_MAKE_TAG (c1, c2, c3, c4))
+#define PANGO_OT_TAG_MAKE_FROM_STRING(s)	(PANGO_OT_TAG_MAKE(((const char *) s)[0], \
+								   ((const char *) s)[1], \
+								   ((const char *) s)[2], \
+								   ((const char *) s)[3]))
+
+typedef struct _PangoOTInfo       PangoOTInfo;
+typedef struct _PangoOTBuffer     PangoOTBuffer;
+typedef struct _PangoOTGlyph      PangoOTGlyph;
+typedef struct _PangoOTRuleset    PangoOTRuleset;
+typedef struct _PangoOTFeatureMap PangoOTFeatureMap;
+typedef struct _PangoOTRulesetDescription PangoOTRulesetDescription;
+
+typedef enum
+{
+  PANGO_OT_TABLE_GSUB,
+  PANGO_OT_TABLE_GPOS
+} PangoOTTableType;
+
+#define PANGO_OT_ALL_GLYPHS			((guint) 0xFFFF)
+#define PANGO_OT_NO_FEATURE			((guint) 0xFFFF)
+#define PANGO_OT_NO_SCRIPT			((guint) 0xFFFF)
+#define PANGO_OT_DEFAULT_LANGUAGE		((guint) 0xFFFF)
+
+#define PANGO_OT_TAG_DEFAULT_SCRIPT		PANGO_OT_TAG_MAKE ('D', 'F', 'L', 'T')
+#define PANGO_OT_TAG_DEFAULT_LANGUAGE		PANGO_OT_TAG_MAKE ('d', 'f', 'l', 't')
+
+/* Note that this must match hb_glyph_info_t */
+struct _PangoOTGlyph
+{
+  guint32  glyph;
+  guint    properties;
+  guint    cluster;
+  gushort  component;
+  gushort  ligID;
+
+  guint    internal;
+};
+
+struct _PangoOTFeatureMap
+{
+  char     feature_name[5];
+  gulong   property_bit;
+};
+
+struct _PangoOTRulesetDescription {
+  PangoScript               script;
+  PangoLanguage            *language;
+  const PangoOTFeatureMap  *static_gsub_features;
+  guint                   n_static_gsub_features;
+  const PangoOTFeatureMap  *static_gpos_features;
+  guint                   n_static_gpos_features;
+  const PangoOTFeatureMap  *other_features;
+  guint                   n_other_features;
+};
+
+
+#define PANGO_TYPE_OT_INFO              (pango_ot_info_get_type ())
+#define PANGO_OT_INFO(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_OT_INFO, PangoOTInfo))
+#define PANGO_IS_OT_INFO(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_OT_INFO))
+GType pango_ot_info_get_type (void) G_GNUC_CONST;
+
+#define PANGO_TYPE_OT_RULESET           (pango_ot_ruleset_get_type ())
+#define PANGO_OT_RULESET(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_OT_RULESET, PangoOTRuleset))
+#define PANGO_IS_OT_RULESET(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_OT_RULESET))
+GType pango_ot_ruleset_get_type (void) G_GNUC_CONST;
+
+
+PangoOTInfo *pango_ot_info_get (FT_Face face);
+
+gboolean pango_ot_info_find_script   (PangoOTInfo      *info,
+				      PangoOTTableType  table_type,
+				      PangoOTTag        script_tag,
+				      guint            *script_index);
+gboolean pango_ot_info_find_language (PangoOTInfo      *info,
+				      PangoOTTableType  table_type,
+				      guint             script_index,
+				      PangoOTTag        language_tag,
+				      guint            *language_index,
+				      guint            *required_feature_index);
+gboolean pango_ot_info_find_feature  (PangoOTInfo      *info,
+				      PangoOTTableType  table_type,
+				      PangoOTTag        feature_tag,
+				      guint             script_index,
+				      guint             language_index,
+				      guint            *feature_index);
+
+PangoOTTag *pango_ot_info_list_scripts   (PangoOTInfo      *info,
+					  PangoOTTableType  table_type);
+PangoOTTag *pango_ot_info_list_languages (PangoOTInfo      *info,
+					  PangoOTTableType  table_type,
+					  guint             script_index,
+					  PangoOTTag        language_tag);
+PangoOTTag *pango_ot_info_list_features  (PangoOTInfo      *info,
+					  PangoOTTableType  table_type,
+					  PangoOTTag        tag,
+					  guint             script_index,
+					  guint             language_index);
+
+PangoOTBuffer *pango_ot_buffer_new        (PangoFcFont       *font);
+void           pango_ot_buffer_destroy    (PangoOTBuffer     *buffer);
+void           pango_ot_buffer_clear      (PangoOTBuffer     *buffer);
+void           pango_ot_buffer_set_rtl    (PangoOTBuffer     *buffer,
+					   gboolean           rtl);
+void           pango_ot_buffer_add_glyph  (PangoOTBuffer     *buffer,
+					   guint              glyph,
+					   guint              properties,
+					   guint              cluster);
+void           pango_ot_buffer_get_glyphs (const PangoOTBuffer  *buffer,
+					   PangoOTGlyph        **glyphs,
+					   int                  *n_glyphs);
+void           pango_ot_buffer_output     (const PangoOTBuffer  *buffer,
+					   PangoGlyphString     *glyphs);
+
+void           pango_ot_buffer_set_zero_width_marks (PangoOTBuffer     *buffer,
+						     gboolean           zero_width_marks);
+
+const PangoOTRuleset *pango_ot_ruleset_get_for_description (PangoOTInfo                     *info,
+							    const PangoOTRulesetDescription *desc);
+PangoOTRuleset *pango_ot_ruleset_new (PangoOTInfo       *info);
+PangoOTRuleset *pango_ot_ruleset_new_for (PangoOTInfo       *info,
+					  PangoScript        script,
+					  PangoLanguage     *language);
+PangoOTRuleset *pango_ot_ruleset_new_from_description (PangoOTInfo                     *info,
+						       const PangoOTRulesetDescription *desc);
+void            pango_ot_ruleset_add_feature (PangoOTRuleset   *ruleset,
+					      PangoOTTableType  table_type,
+					      guint             feature_index,
+					      gulong            property_bit);
+gboolean        pango_ot_ruleset_maybe_add_feature (PangoOTRuleset   *ruleset,
+						    PangoOTTableType  table_type,
+						    PangoOTTag        feature_tag,
+						    gulong            property_bit);
+guint           pango_ot_ruleset_maybe_add_features (PangoOTRuleset          *ruleset,
+						     PangoOTTableType         table_type,
+						     const PangoOTFeatureMap *features,
+						     guint                    n_features);
+guint           pango_ot_ruleset_get_feature_count (const PangoOTRuleset   *ruleset,
+						    guint                  *n_gsub_features,
+						    guint                  *n_gpos_features);
+void            pango_ot_ruleset_substitute  (const PangoOTRuleset   *ruleset,
+					      PangoOTBuffer          *buffer);
+void            pango_ot_ruleset_position    (const PangoOTRuleset   *ruleset,
+					      PangoOTBuffer          *buffer);
+PangoScript     pango_ot_tag_to_script     (PangoOTTag     script_tag) G_GNUC_CONST;
+PangoOTTag      pango_ot_tag_from_script   (PangoScript    script) G_GNUC_CONST;
+PangoLanguage  *pango_ot_tag_to_language   (PangoOTTag     language_tag) G_GNUC_CONST;
+PangoOTTag      pango_ot_tag_from_language (PangoLanguage *language) G_GNUC_CONST;
+
+guint           pango_ot_ruleset_description_hash  (const PangoOTRulesetDescription *desc) G_GNUC_PURE;
+gboolean        pango_ot_ruleset_description_equal (const PangoOTRulesetDescription *desc1,
+						    const PangoOTRulesetDescription *desc2) G_GNUC_PURE;
+PangoOTRulesetDescription *pango_ot_ruleset_description_copy  (const PangoOTRulesetDescription *desc);
+void            pango_ot_ruleset_description_free  (PangoOTRulesetDescription       *desc);
+
+
+#endif /* PANGO_ENABLE_ENGINE */
+
+G_END_DECLS
+
+#endif /* __PANGO_OT_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-renderer.h b/gtk+-mingw/include/pango-1.0/pango/pango-renderer.h
new file mode 100644
index 0000000..5410a9f
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-renderer.h
@@ -0,0 +1,260 @@
+/* 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_shape: draw content for a glyph shaped with #PangoAttrShape.
+ *   @x, @y are the coordinates of the left edge of the baseline,
+ *   in user coordinates.
+ * @draw_trapezoid: draws a trapezoidal filled area
+ * @draw_glyph: draws a single glyph
+ * @part_changed: do renderer specific processing when rendering
+ *  attributes change
+ * @begin: Do renderer-specific initialization before drawing
+ * @end: Do renderer-specific cleanup after drawing
+ * @prepare_run: updates the renderer for a new run
+ * @draw_glyph_item: draws a #PangoGlyphItem
+ *
+ * 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);
+
+  /* Nothing is drawn for shaped glyphs unless this is implemented */
+  void (*draw_shape) (PangoRenderer  *renderer,
+		      PangoAttrShape *attr,
+		      int             x,
+		      int             y);
+
+  /* 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);
+
+  /* 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);
+
+  /* All of the following have default implementations
+   * and take as coordinates user coordinates in Pango units
+   */
+  void (*draw_glyph_item) (PangoRenderer     *renderer,
+			   const char        *text,
+			   PangoGlyphItem    *glyph_item,
+			   int                x,
+			   int                y);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+GType pango_renderer_get_type    (void) G_GNUC_CONST;
+
+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_glyph_item      (PangoRenderer    *renderer,
+					  const char       *text,
+					  PangoGlyphItem   *glyph_item,
+					  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,
+				      const PangoColor *color);
+PangoColor *pango_renderer_get_color (PangoRenderer    *renderer,
+				      PangoRenderPart   part);
+
+void                        pango_renderer_set_matrix (PangoRenderer     *renderer,
+						       const PangoMatrix *matrix);
+const PangoMatrix          *pango_renderer_get_matrix (PangoRenderer     *renderer);
+
+PangoLayout     *pango_renderer_get_layout      (PangoRenderer     *renderer);
+PangoLayoutLine *pango_renderer_get_layout_line (PangoRenderer     *renderer);
+
+G_END_DECLS
+
+#endif /* __PANGO_RENDERER_H_ */
+
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-script.h b/gtk+-mingw/include/pango-1.0/pango/pango-script.h
new file mode 100644
index 0000000..ef5f698
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-script.h
@@ -0,0 +1,144 @@
+/* Pango
+ * pango-script.h: Script tag handling
+ *
+ * Copyright (C) 2002 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 __PANGO_SCRIPT_H__
+#define __PANGO_SCRIPT_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/**
+ * PangoScriptIter:
+ *
+ * A #PangoScriptIter is used to iterate through a string
+ * and identify ranges in different scripts.
+ **/
+typedef struct _PangoScriptIter PangoScriptIter;
+
+typedef enum {                         /* ISO 15924 code */
+      PANGO_SCRIPT_INVALID_CODE = -1,
+      PANGO_SCRIPT_COMMON       = 0,   /* Zyyy */
+      PANGO_SCRIPT_INHERITED,          /* Qaai */
+      PANGO_SCRIPT_ARABIC,             /* Arab */
+      PANGO_SCRIPT_ARMENIAN,           /* Armn */
+      PANGO_SCRIPT_BENGALI,            /* Beng */
+      PANGO_SCRIPT_BOPOMOFO,           /* Bopo */
+      PANGO_SCRIPT_CHEROKEE,           /* Cher */
+      PANGO_SCRIPT_COPTIC,             /* Qaac */
+      PANGO_SCRIPT_CYRILLIC,           /* Cyrl (Cyrs) */
+      PANGO_SCRIPT_DESERET,            /* Dsrt */
+      PANGO_SCRIPT_DEVANAGARI,         /* Deva */
+      PANGO_SCRIPT_ETHIOPIC,           /* Ethi */
+      PANGO_SCRIPT_GEORGIAN,           /* Geor (Geon, Geoa) */
+      PANGO_SCRIPT_GOTHIC,             /* Goth */
+      PANGO_SCRIPT_GREEK,              /* Grek */
+      PANGO_SCRIPT_GUJARATI,           /* Gujr */
+      PANGO_SCRIPT_GURMUKHI,           /* Guru */
+      PANGO_SCRIPT_HAN,                /* Hani */
+      PANGO_SCRIPT_HANGUL,             /* Hang */
+      PANGO_SCRIPT_HEBREW,             /* Hebr */
+      PANGO_SCRIPT_HIRAGANA,           /* Hira */
+      PANGO_SCRIPT_KANNADA,            /* Knda */
+      PANGO_SCRIPT_KATAKANA,           /* Kana */
+      PANGO_SCRIPT_KHMER,              /* Khmr */
+      PANGO_SCRIPT_LAO,                /* Laoo */
+      PANGO_SCRIPT_LATIN,              /* Latn (Latf, Latg) */
+      PANGO_SCRIPT_MALAYALAM,          /* Mlym */
+      PANGO_SCRIPT_MONGOLIAN,          /* Mong */
+      PANGO_SCRIPT_MYANMAR,            /* Mymr */
+      PANGO_SCRIPT_OGHAM,              /* Ogam */
+      PANGO_SCRIPT_OLD_ITALIC,         /* Ital */
+      PANGO_SCRIPT_ORIYA,              /* Orya */
+      PANGO_SCRIPT_RUNIC,              /* Runr */
+      PANGO_SCRIPT_SINHALA,            /* Sinh */
+      PANGO_SCRIPT_SYRIAC,             /* Syrc (Syrj, Syrn, Syre) */
+      PANGO_SCRIPT_TAMIL,              /* Taml */
+      PANGO_SCRIPT_TELUGU,             /* Telu */
+      PANGO_SCRIPT_THAANA,             /* Thaa */
+      PANGO_SCRIPT_THAI,               /* Thai */
+      PANGO_SCRIPT_TIBETAN,            /* Tibt */
+      PANGO_SCRIPT_CANADIAN_ABORIGINAL, /* Cans */
+      PANGO_SCRIPT_YI,                 /* Yiii */
+      PANGO_SCRIPT_TAGALOG,            /* Tglg */
+      PANGO_SCRIPT_HANUNOO,            /* Hano */
+      PANGO_SCRIPT_BUHID,              /* Buhd */
+      PANGO_SCRIPT_TAGBANWA,           /* Tagb */
+
+      /* Unicode-4.0 additions */
+      PANGO_SCRIPT_BRAILLE,            /* Brai */
+      PANGO_SCRIPT_CYPRIOT,            /* Cprt */
+      PANGO_SCRIPT_LIMBU,              /* Limb */
+      PANGO_SCRIPT_OSMANYA,            /* Osma */
+      PANGO_SCRIPT_SHAVIAN,            /* Shaw */
+      PANGO_SCRIPT_LINEAR_B,           /* Linb */
+      PANGO_SCRIPT_TAI_LE,             /* Tale */
+      PANGO_SCRIPT_UGARITIC,           /* Ugar */
+
+      /* Unicode-4.1 additions */
+      PANGO_SCRIPT_NEW_TAI_LUE,        /* Talu */
+      PANGO_SCRIPT_BUGINESE,           /* Bugi */
+      PANGO_SCRIPT_GLAGOLITIC,         /* Glag */
+      PANGO_SCRIPT_TIFINAGH,           /* Tfng */
+      PANGO_SCRIPT_SYLOTI_NAGRI,       /* Sylo */
+      PANGO_SCRIPT_OLD_PERSIAN,        /* Xpeo */
+      PANGO_SCRIPT_KHAROSHTHI,         /* Khar */
+
+      /* Unicode-5.0 additions */
+      PANGO_SCRIPT_UNKNOWN,            /* Zzzz */
+      PANGO_SCRIPT_BALINESE,           /* Bali */
+      PANGO_SCRIPT_CUNEIFORM,          /* Xsux */
+      PANGO_SCRIPT_PHOENICIAN,         /* Phnx */
+      PANGO_SCRIPT_PHAGS_PA,           /* Phag */
+      PANGO_SCRIPT_NKO,                /* Nkoo */
+
+      /* Unicode-5.1 additions */
+      PANGO_SCRIPT_KAYAH_LI,           /* Kali */
+      PANGO_SCRIPT_LEPCHA,             /* Lepc */
+      PANGO_SCRIPT_REJANG,             /* Rjng */
+      PANGO_SCRIPT_SUNDANESE,          /* Sund */
+      PANGO_SCRIPT_SAURASHTRA,         /* Saur */
+      PANGO_SCRIPT_CHAM,               /* Cham */
+      PANGO_SCRIPT_OL_CHIKI,           /* Olck */
+      PANGO_SCRIPT_VAI,                /* Vaii */
+      PANGO_SCRIPT_CARIAN,             /* Cari */
+      PANGO_SCRIPT_LYCIAN,             /* Lyci */
+      PANGO_SCRIPT_LYDIAN              /* Lydi */
+} PangoScript;
+
+PangoScript pango_script_for_unichar         (gunichar             ch) G_GNUC_CONST;
+
+PangoScriptIter *pango_script_iter_new       (const char          *text,
+					      int                  length);
+void             pango_script_iter_get_range (PangoScriptIter     *iter,
+                                              const char         **start,
+                                              const char         **end,
+                                              PangoScript         *script);
+gboolean         pango_script_iter_next      (PangoScriptIter     *iter);
+void             pango_script_iter_free      (PangoScriptIter     *iter);
+
+#include <pango/pango-language.h>
+
+PangoLanguage *pango_script_get_sample_language (PangoScript    script) G_GNUC_PURE;
+
+G_END_DECLS
+
+#endif /* __PANGO_SCRIPT_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-tabs.h b/gtk+-mingw/include/pango-1.0/pango/pango-tabs.h
new file mode 100644
index 0000000..7f52d1d
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-tabs.h
@@ -0,0 +1,76 @@
+/* Pango
+ * pango-tabs.h: Tab-related stuff
+ *
+ * Copyright (C) 2000 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 __PANGO_TABS_H__
+#define __PANGO_TABS_H__
+
+#include <pango/pango-types.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoTabArray PangoTabArray;
+
+typedef enum
+{
+  PANGO_TAB_LEFT
+
+  /* These are not supported now, but may be in the
+   * future.
+   *
+   *  PANGO_TAB_RIGHT,
+   *  PANGO_TAB_CENTER,
+   *  PANGO_TAB_NUMERIC
+   */
+} PangoTabAlign;
+
+#define PANGO_TYPE_TAB_ARRAY (pango_tab_array_get_type ())
+
+PangoTabArray  *pango_tab_array_new                 (gint           initial_size,
+						     gboolean       positions_in_pixels);
+PangoTabArray  *pango_tab_array_new_with_positions  (gint           size,
+						     gboolean       positions_in_pixels,
+						     PangoTabAlign  first_alignment,
+						     gint           first_position,
+						     ...);
+GType           pango_tab_array_get_type            (void) G_GNUC_CONST;
+PangoTabArray  *pango_tab_array_copy                (PangoTabArray *src);
+void            pango_tab_array_free                (PangoTabArray *tab_array);
+gint            pango_tab_array_get_size            (PangoTabArray *tab_array);
+void            pango_tab_array_resize              (PangoTabArray *tab_array,
+						     gint           new_size);
+void            pango_tab_array_set_tab             (PangoTabArray *tab_array,
+						     gint           tab_index,
+						     PangoTabAlign  alignment,
+						     gint           location);
+void            pango_tab_array_get_tab             (PangoTabArray *tab_array,
+						     gint           tab_index,
+						     PangoTabAlign *alignment,
+						     gint          *location);
+void            pango_tab_array_get_tabs            (PangoTabArray *tab_array,
+						     PangoTabAlign **alignments,
+						     gint          **locations);
+
+gboolean        pango_tab_array_get_positions_in_pixels (PangoTabArray *tab_array);
+
+
+G_END_DECLS
+
+#endif /* __PANGO_TABS_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-types.h b/gtk+-mingw/include/pango-1.0/pango/pango-types.h
new file mode 100644
index 0000000..c4ef843
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-types.h
@@ -0,0 +1,100 @@
+/* Pango
+ * pango-types.h:
+ *
+ * Copyright (C) 1999 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 __PANGO_TYPES_H__
+#define __PANGO_TYPES_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef struct _PangoLogAttr PangoLogAttr;
+
+typedef struct _PangoEngineLang PangoEngineLang;
+typedef struct _PangoEngineShape PangoEngineShape;
+
+typedef struct _PangoFont    PangoFont;
+typedef struct _PangoFontMap PangoFontMap;
+
+typedef struct _PangoRectangle PangoRectangle;
+
+
+
+/* A index of a glyph into a font. Rendering system dependent */
+typedef guint32 PangoGlyph;
+
+
+
+#define PANGO_SCALE 1024
+#define PANGO_PIXELS(d) (((int)(d) + 512) >> 10)
+#define PANGO_PIXELS_FLOOR(d) (((int)(d)) >> 10)
+#define PANGO_PIXELS_CEIL(d) (((int)(d) + 1023) >> 10)
+/* The above expressions are just slightly wrong for floating point d;
+ * For example we'd expect PANGO_PIXELS(-512.5) => -1 but instead we get 0.
+ * That's unlikely to matter for practical use and the expression is much
+ * more compact and faster than alternatives that work exactly for both
+ * integers and floating point.
+ *
+ * PANGO_PIXELS also behaves differently for +512 and -512.
+ */
+
+#define PANGO_UNITS_ROUND(d)				\
+  (((d) + (PANGO_SCALE >> 1)) & ~(PANGO_SCALE - 1))
+
+
+int    pango_units_from_double (double d) G_GNUC_CONST;
+double pango_units_to_double (int i) G_GNUC_CONST;
+
+
+
+/* A rectangle. Used to store logical and physical extents of glyphs,
+ * runs, strings, etc.
+ */
+struct _PangoRectangle
+{
+  int x;
+  int y;
+  int width;
+  int height;
+};
+
+/* Macros to translate from extents rectangles to ascent/descent/lbearing/rbearing
+ */
+#define PANGO_ASCENT(rect) (-(rect).y)
+#define PANGO_DESCENT(rect) ((rect).y + (rect).height)
+#define PANGO_LBEARING(rect) ((rect).x)
+#define PANGO_RBEARING(rect) ((rect).x + (rect).width)
+
+void pango_extents_to_pixels (PangoRectangle *inclusive,
+			      PangoRectangle *nearest);
+
+
+#include <pango/pango-gravity.h>
+#include <pango/pango-language.h>
+#include <pango/pango-matrix.h>
+#include <pango/pango-script.h>
+#include <pango/pango-bidi-type.h>
+
+
+G_END_DECLS
+
+#endif /* __PANGO_TYPES_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango-utils.h b/gtk+-mingw/include/pango-1.0/pango/pango-utils.h
new file mode 100644
index 0000000..f86c662
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango-utils.h
@@ -0,0 +1,143 @@
+/* Pango
+ * pango-utils.c: Utilities for internal functions and modules
+ *
+ * Copyright (C) 2000 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 __PANGO_UTILS_H__
+#define __PANGO_UTILS_H__
+
+#include <stdio.h>
+#include <glib.h>
+#include <pango/pango-font.h>
+
+G_BEGIN_DECLS
+
+char **  pango_split_file_list (const char *str);
+
+char    *pango_trim_string     (const char *str);
+gint     pango_read_line      (FILE        *stream,
+			       GString     *str);
+gboolean pango_skip_space     (const char **pos);
+gboolean pango_scan_word      (const char **pos,
+			       GString     *out);
+gboolean pango_scan_string    (const char **pos,
+			       GString     *out);
+gboolean pango_scan_int       (const char **pos,
+			       int         *out);
+
+#ifdef PANGO_ENABLE_BACKEND
+char *   pango_config_key_get (const char  *key);
+void     pango_lookup_aliases (const char   *fontname,
+			       char       ***families,
+			       int          *n_families);
+#endif /* PANGO_ENABLE_BACKEND */
+
+gboolean pango_parse_enum     (GType       type,
+			       const char *str,
+			       int        *value,
+			       gboolean    warn,
+			       char      **possible_values);
+
+/* Functions for parsing textual representations
+ * of PangoFontDescription fields. They return TRUE if the input string
+ * contains a valid value, which then has been assigned to the corresponding
+ * field in the PangoFontDescription. If the warn parameter is TRUE,
+ * a warning is printed (with g_warning) if the string does not
+ * contain a valid value.
+ */
+gboolean pango_parse_style   (const char   *str,
+			      PangoStyle   *style,
+			      gboolean      warn);
+gboolean pango_parse_variant (const char   *str,
+			      PangoVariant *variant,
+			      gboolean      warn);
+gboolean pango_parse_weight  (const char   *str,
+			      PangoWeight  *weight,
+			      gboolean      warn);
+gboolean pango_parse_stretch (const char   *str,
+			      PangoStretch *stretch,
+			      gboolean      warn);
+
+#ifdef PANGO_ENABLE_BACKEND
+
+/* On Unix, return the name of the "pango" subdirectory of SYSCONFDIR
+ * (which is set at compile time). On Win32, return the Pango
+ * installation directory (which is set at installation time, and
+ * stored in the registry). The returned string should not be
+ * g_free'd.
+ */
+const char *   pango_get_sysconf_subdirectory (void) G_GNUC_PURE;
+
+/* Ditto for LIBDIR/pango. On Win32, use the same Pango
+ * installation directory. This returned string should not be
+ * g_free'd either.
+ */
+const char *   pango_get_lib_subdirectory (void) G_GNUC_PURE;
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+/* Hint line position and thickness.
+ */
+void pango_quantize_line_geometry (int *thickness,
+				   int *position);
+
+/* A routine from fribidi that we either wrap or provide ourselves.
+ */
+guint8 * pango_log2vis_get_embedding_levels (const gchar    *text,
+					     int             length,
+					     PangoDirection *pbase_dir);
+
+/* Unicode characters that are zero-width and should not be rendered
+ * normally.
+ */
+gboolean pango_is_zero_width (gunichar ch) G_GNUC_CONST;
+
+/* Pango version checking */
+
+/* Encode a Pango version as an integer */
+#define PANGO_VERSION_ENCODE(major, minor, micro) (     \
+	  ((major) * 10000)                             \
+	+ ((minor) *   100)                             \
+	+ ((micro) *     1))
+
+/* Encoded version of Pango at compile-time */
+#define PANGO_VERSION PANGO_VERSION_ENCODE(     \
+	PANGO_VERSION_MAJOR,                    \
+	PANGO_VERSION_MINOR,                    \
+	PANGO_VERSION_MICRO)
+
+/* Check that compile-time Pango is as new as required */
+#define PANGO_VERSION_CHECK(major,minor,micro)    \
+	(PANGO_VERSION >= PANGO_VERSION_ENCODE(major,minor,micro))
+
+
+/* Return encoded version of Pango at run-time */
+int pango_version (void) G_GNUC_CONST;
+
+/* Return run-time Pango version as an string */
+const char * pango_version_string (void) G_GNUC_CONST;
+
+/* Check that run-time Pango is as new as required */
+const char * pango_version_check (int required_major,
+                                  int required_minor,
+                                  int required_micro) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __PANGO_UTILS_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pango.h b/gtk+-mingw/include/pango-1.0/pango/pango.h
new file mode 100644
index 0000000..5cc6957
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pango.h
@@ -0,0 +1,48 @@
+/* Pango
+ * pango.h:
+ *
+ * Copyright (C) 1999 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 __PANGO_H__
+#define __PANGO_H__
+
+#include <pango/pango-attributes.h>
+#include <pango/pango-bidi-type.h>
+#include <pango/pango-break.h>
+#include <pango/pango-context.h>
+#include <pango/pango-coverage.h>
+#include <pango/pango-engine.h>
+#include <pango/pango-enum-types.h>
+#include <pango/pango-features.h>
+#include <pango/pango-font.h>
+#include <pango/pango-fontmap.h>
+#include <pango/pango-fontset.h>
+#include <pango/pango-glyph.h>
+#include <pango/pango-glyph-item.h>
+#include <pango/pango-gravity.h>
+#include <pango/pango-item.h>
+#include <pango/pango-layout.h>
+#include <pango/pango-matrix.h>
+#include <pango/pango-renderer.h>
+#include <pango/pango-script.h>
+#include <pango/pango-tabs.h>
+#include <pango/pango-types.h>
+#include <pango/pango-utils.h>
+
+#endif /* __PANGO_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pangocairo.h b/gtk+-mingw/include/pango-1.0/pango/pangocairo.h
new file mode 100644
index 0000000..81e842d
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pangocairo.h
@@ -0,0 +1,155 @@
+/* Pango
+ * pangocairo.h:
+ *
+ * Copyright (C) 1999, 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 __PANGOCAIRO_H__
+#define __PANGOCAIRO_H__
+
+#include <pango/pango.h>
+#include <cairo.h>
+
+G_BEGIN_DECLS
+
+/**
+ * PangoCairoFont:
+ *
+ * #PangoCairoFont is an interface exported by fonts for
+ * use with Cairo. The actual type of the font will depend
+ * on the particular font technology Cairo was compiled to use.
+ *
+ * Since: 1.18
+ **/
+typedef struct _PangoCairoFont      PangoCairoFont;
+#define PANGO_TYPE_CAIRO_FONT       (pango_cairo_font_get_type ())
+#define PANGO_CAIRO_FONT(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CAIRO_FONT, PangoCairoFont))
+#define PANGO_IS_CAIRO_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CAIRO_FONT))
+
+/**
+ * PangoCairoFontMap:
+ *
+ * #PangoCairoFontMap is an interface exported by font maps for
+ * use with Cairo. The actual type of the font map will depend
+ * on the particular font technology Cairo was compiled to use.
+ *
+ * Since: 1.10
+ **/
+typedef struct _PangoCairoFontMap        PangoCairoFontMap;
+#define PANGO_TYPE_CAIRO_FONT_MAP       (pango_cairo_font_map_get_type ())
+#define PANGO_CAIRO_FONT_MAP(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CAIRO_FONT_MAP, PangoCairoFontMap))
+#define PANGO_IS_CAIRO_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CAIRO_FONT_MAP))
+
+typedef void (* PangoCairoShapeRendererFunc) (cairo_t        *cr,
+					      PangoAttrShape *attr,
+					      gboolean        do_path,
+					      gpointer        data);
+
+/*
+ * PangoCairoFontMap
+ */
+GType         pango_cairo_font_map_get_type          (void) G_GNUC_CONST;
+
+PangoFontMap *pango_cairo_font_map_new               (void);
+PangoFontMap *pango_cairo_font_map_new_for_font_type (cairo_font_type_t fonttype);
+PangoFontMap *pango_cairo_font_map_get_default       (void);
+void          pango_cairo_font_map_set_default       (PangoCairoFontMap *fontmap);
+cairo_font_type_t pango_cairo_font_map_get_font_type (PangoCairoFontMap *fontmap);
+
+void          pango_cairo_font_map_set_resolution (PangoCairoFontMap *fontmap,
+						   double             dpi);
+double        pango_cairo_font_map_get_resolution (PangoCairoFontMap *fontmap);
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(pango_font_map_create_context)
+PangoContext *pango_cairo_font_map_create_context (PangoCairoFontMap *fontmap);
+#endif
+
+/*
+ * PangoCairoFont
+ */
+GType         pango_cairo_font_get_type               (void) G_GNUC_CONST;
+
+cairo_scaled_font_t *pango_cairo_font_get_scaled_font (PangoCairoFont *font);
+
+/* Update a Pango context for the current state of a cairo context
+ */
+void         pango_cairo_update_context (cairo_t      *cr,
+					 PangoContext *context);
+
+void                        pango_cairo_context_set_font_options (PangoContext               *context,
+								  const cairo_font_options_t *options);
+const cairo_font_options_t *pango_cairo_context_get_font_options (PangoContext               *context);
+
+void               pango_cairo_context_set_resolution     (PangoContext       *context,
+							   double              dpi);
+double             pango_cairo_context_get_resolution     (PangoContext       *context);
+
+void                        pango_cairo_context_set_shape_renderer (PangoContext                *context,
+								    PangoCairoShapeRendererFunc  func,
+								    gpointer                     data,
+								    GDestroyNotify               dnotify);
+PangoCairoShapeRendererFunc pango_cairo_context_get_shape_renderer (PangoContext                *context,
+								    gpointer                    *data);
+
+/* Convenience
+ */
+PangoContext *pango_cairo_create_context (cairo_t   *cr);
+PangoLayout *pango_cairo_create_layout (cairo_t     *cr);
+void         pango_cairo_update_layout (cairo_t     *cr,
+					PangoLayout *layout);
+
+/*
+ * Rendering
+ */
+void pango_cairo_show_glyph_string (cairo_t          *cr,
+				    PangoFont        *font,
+				    PangoGlyphString *glyphs);
+void pango_cairo_show_glyph_item   (cairo_t          *cr,
+				    const char       *text,
+				    PangoGlyphItem   *glyph_item);
+void pango_cairo_show_layout_line  (cairo_t          *cr,
+				    PangoLayoutLine  *line);
+void pango_cairo_show_layout       (cairo_t          *cr,
+				    PangoLayout      *layout);
+
+void pango_cairo_show_error_underline (cairo_t       *cr,
+				       double         x,
+				       double         y,
+				       double         width,
+				       double         height);
+
+/*
+ * Rendering to a path
+ */
+void pango_cairo_glyph_string_path (cairo_t          *cr,
+				    PangoFont        *font,
+				    PangoGlyphString *glyphs);
+void pango_cairo_layout_line_path  (cairo_t          *cr,
+				    PangoLayoutLine  *line);
+void pango_cairo_layout_path       (cairo_t          *cr,
+				    PangoLayout      *layout);
+
+void pango_cairo_error_underline_path (cairo_t       *cr,
+				       double         x,
+				       double         y,
+				       double         width,
+				       double         height);
+
+G_END_DECLS
+
+#endif /* __PANGOCAIRO_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pangofc-decoder.h b/gtk+-mingw/include/pango-1.0/pango/pangofc-decoder.h
new file mode 100644
index 0000000..8e34146
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pangofc-decoder.h
@@ -0,0 +1,110 @@
+/* Pango
+ * pangofc-decoder.h: Custom encoders/decoders on a per-font basis.
+ *
+ * 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 __PANGO_DECODER_H_
+#define __PANGO_DECODER_H_
+
+#include <pango/pangofc-font.h>
+
+G_BEGIN_DECLS
+
+#define PANGO_TYPE_FC_DECODER       (pango_fc_decoder_get_type())
+#define PANGO_FC_DECODER(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_DECODER, PangoFcDecoder))
+#define PANGO_IS_FC_DECODER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_DECODER))
+
+typedef struct _PangoFcDecoder      PangoFcDecoder;
+typedef struct _PangoFcDecoderClass PangoFcDecoderClass;
+
+#define PANGO_FC_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_DECODER, PangoFcDecoderClass))
+#define PANGO_IS_FC_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_DECODER))
+#define PANGO_FC_DECODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_DECODER, PangoFcDecoderClass))
+
+/**
+ * PangoFcDecoder:
+ *
+ * #PangoFcDecoder is a virtual base class that implementations will
+ * inherit from.  It's the interface that is used to define a custom
+ * encoding for a font.  These objects are created in your code from a
+ * function callback that was originally registered with
+ * pango_fc_font_map_add_decoder_find_func().  Pango requires
+ * information about the supported charset for a font as well as the
+ * individual character to glyph conversions.  Pango gets that
+ * information via the #get_charset and #get_glyph callbacks into your
+ * object implementation.
+ *
+ * Since: 1.6
+ **/
+struct _PangoFcDecoder
+{
+  /*< private >*/
+  GObject parent_instance;
+};
+
+/**
+ * PangoFcDecoderClass:
+ * @get_charset: This returns an #FcCharset given a #PangoFcFont that
+ *  includes a list of supported characters in the font.  The
+ *  #FcCharSet that is returned should be an internal reference to your
+ *  code.  Pango will not free this structure.  It is important that
+ *  you make this callback fast because this callback is called
+ *  separately for each character to determine Unicode coverage.
+ * @get_glyph: This returns a single #PangoGlyph for a given Unicode
+ *  code point.
+ *
+ * Class structure for #PangoFcDecoder.
+ *
+ * Since: 1.6
+ **/
+struct _PangoFcDecoderClass
+{
+  /*< private >*/
+  GObjectClass parent_class;
+
+  /* vtable - not signals */
+  /*< public >*/
+  FcCharSet  *(*get_charset) (PangoFcDecoder *decoder,
+			      PangoFcFont    *fcfont);
+  PangoGlyph  (*get_glyph)   (PangoFcDecoder *decoder,
+			      PangoFcFont    *fcfont,
+			      guint32         wc);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved1) (void);
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+GType      pango_fc_decoder_get_type    (void) G_GNUC_CONST;
+
+FcCharSet *pango_fc_decoder_get_charset (PangoFcDecoder *decoder,
+					 PangoFcFont    *fcfont);
+
+PangoGlyph pango_fc_decoder_get_glyph   (PangoFcDecoder *decoder,
+					 PangoFcFont    *fcfont,
+					 guint32         wc);
+
+G_END_DECLS
+
+#endif /* __PANGO_DECODER_H_ */
+
diff --git a/gtk+-mingw/include/pango-1.0/pango/pangofc-font.h b/gtk+-mingw/include/pango-1.0/pango/pangofc-font.h
new file mode 100644
index 0000000..de11d43
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pangofc-font.h
@@ -0,0 +1,152 @@
+/* Pango
+ * pangofc-font.h: Base fontmap type for fontconfig-based backends
+ *
+ * Copyright (C) 2003 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 __PANGO_FC_FONT_H__
+#define __PANGO_FC_FONT_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include <fontconfig/fontconfig.h>
+#include <pango/pango-font.h>
+#include <pango/pango-fontmap.h>
+#include <pango/pango-glyph.h>
+
+G_BEGIN_DECLS
+
+#define PANGO_TYPE_FC_FONT              (pango_fc_font_get_type ())
+#define PANGO_FC_FONT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_FONT, PangoFcFont))
+#define PANGO_IS_FC_FONT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT))
+
+typedef struct _PangoFcFont      PangoFcFont;
+typedef struct _PangoFcFontClass PangoFcFontClass;
+
+#if defined(PANGO_ENABLE_ENGINE) || defined(PANGO_ENABLE_BACKEND)
+
+/**
+ * PANGO_RENDER_TYPE_FC:
+ *
+ * A string constant used to identify shape engines that work
+ * with the fontconfig based backends. See the @engine_type field
+ * of #PangoEngineInfo.
+ **/
+#define PANGO_RENDER_TYPE_FC "PangoRenderFc"
+
+#ifdef PANGO_ENABLE_BACKEND
+
+#define PANGO_FC_FONT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_FONT, PangoFcFontClass))
+#define PANGO_IS_FC_FONT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_FONT))
+#define PANGO_FC_FONT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_FONT, PangoFcFontClass))
+
+/**
+ * PangoFcFont:
+ *
+ * #PangoFcFont is a base class for font implementations
+ * using the Fontconfig and FreeType libraries and is used in
+ * conjunction with #PangoFcFontMap. When deriving from this
+ * class, you need to implement all of its virtual functions
+ * other than shutdown() along with the get_glyph_extents()
+ * virtual function from #PangoFont.
+ **/
+struct _PangoFcFont
+{
+  PangoFont parent_instance;
+
+  FcPattern *font_pattern;	    /* fully resolved pattern */
+  PangoFontMap *fontmap;	    /* associated map */
+  gpointer priv;		    /* used internally */
+  PangoMatrix matrix;		    /* used internally */
+  PangoFontDescription *description;
+
+  GSList *metrics_by_lang;
+
+  guint is_hinted : 1;
+  guint is_transformed : 1;
+};
+
+/**
+ * PangoFcFontClass:
+ * @lock_face: Returns the FT_Face of the font and increases
+ *  the reference count for the face by one.
+ * @unlock_face: Decreases the reference count for the
+ *  FT_Face of the font by one. When the count is zero,
+ *  the #PangoFcFont subclass is allowed to free the
+ *  FT_Face.
+ * @has_char: Return %TRUE if the the font contains a glyph
+ *   corresponding to the specified character.
+ * @get_glyph: Gets the glyph that corresponds to the given
+ *   Unicode character.
+ * @get_unknown_glyph: Gets the glyph that should be used to
+ *   display an unknown-glyph indication for the specified
+ *   Unicode character.
+ *   May be %NULL.
+ * @shutdown: Performs any font-specific shutdown code that
+ *   needs to be done when pango_fc_font_map_shutdown is called.
+ *   May be %NULL.
+ *
+ * Class structure for #PangoFcFont.
+ **/
+struct _PangoFcFontClass
+{
+  /*< private >*/
+  PangoFontClass parent_class;
+
+  /*< public >*/
+  FT_Face    (*lock_face)         (PangoFcFont      *font);
+  void       (*unlock_face)       (PangoFcFont      *font);
+  gboolean   (*has_char)          (PangoFcFont      *font,
+				   gunichar          wc);
+  guint      (*get_glyph)         (PangoFcFont      *font,
+				   gunichar          wc);
+  PangoGlyph (*get_unknown_glyph) (PangoFcFont      *font,
+				   gunichar          wc);
+  void       (*shutdown)          (PangoFcFont      *font);
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved1) (void);
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+#endif /* PANGO_ENABLE_BACKEND */
+
+gboolean   pango_fc_font_has_char          (PangoFcFont      *font,
+					    gunichar          wc);
+guint      pango_fc_font_get_glyph         (PangoFcFont      *font,
+					    gunichar          wc);
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(PANGO_GET_UNKNOWN_GLYPH)
+PangoGlyph pango_fc_font_get_unknown_glyph (PangoFcFont      *font,
+					    gunichar          wc);
+#endif /* PANGO_DISABLE_DEPRECATED */
+void       pango_fc_font_kern_glyphs       (PangoFcFont      *font,
+					    PangoGlyphString *glyphs);
+
+#endif /* PANGO_ENABLE_ENGINE || PANGO_ENABLE_BACKEND */
+
+GType      pango_fc_font_get_type (void) G_GNUC_CONST;
+
+FT_Face    pango_fc_font_lock_face         (PangoFcFont      *font);
+void       pango_fc_font_unlock_face       (PangoFcFont      *font);
+
+G_END_DECLS
+#endif /* __PANGO_FC_FONT_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pangofc-fontmap.h b/gtk+-mingw/include/pango-1.0/pango/pangofc-fontmap.h
new file mode 100644
index 0000000..3809446
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pangofc-fontmap.h
@@ -0,0 +1,271 @@
+/* Pango
+ * pangofc-fontmap.h: Base fontmap type for fontconfig-based backends
+ *
+ * Copyright (C) 2003 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 __PANGO_FC_FONT_MAP_H__
+#define __PANGO_FC_FONT_MAP_H__
+
+#include <fontconfig/fontconfig.h>
+#include <pango/pango-fontmap.h>
+#include <pango/pangofc-decoder.h>
+#include <pango/pangofc-font.h>
+
+G_BEGIN_DECLS
+
+
+#ifdef PANGO_ENABLE_BACKEND
+
+/**
+ * PangoFcFontsetKey:
+ *
+ * An opaque structure containing all the information needed for
+ * loading a fontset with the PangoFc fontmap.
+ *
+ * Since: 1.24
+ **/
+typedef struct _PangoFcFontsetKey  PangoFcFontsetKey;
+
+PangoLanguage              *pango_fc_fontset_key_get_language      (const PangoFcFontsetKey *key);
+const PangoFontDescription *pango_fc_fontset_key_get_description   (const PangoFcFontsetKey *key);
+const PangoMatrix          *pango_fc_fontset_key_get_matrix        (const PangoFcFontsetKey *key);
+double                      pango_fc_fontset_key_get_absolute_size (const PangoFcFontsetKey *key);
+double                      pango_fc_fontset_key_get_resolution    (const PangoFcFontsetKey *key);
+gpointer                    pango_fc_fontset_key_get_context_key   (const PangoFcFontsetKey *key);
+
+/**
+ * PangoFcFontKey:
+ *
+ * An opaque structure containing all the information needed for
+ * loading a font with the PangoFc fontmap.
+ *
+ * Since: 1.24
+ **/
+typedef struct _PangoFcFontKey     PangoFcFontKey;
+
+const FcPattern   *pango_fc_font_key_get_pattern     (const PangoFcFontKey *key);
+const PangoMatrix *pango_fc_font_key_get_matrix      (const PangoFcFontKey *key);
+gpointer           pango_fc_font_key_get_context_key (const PangoFcFontKey *key);
+
+#endif
+
+
+/*
+ * PangoFcFontMap
+ */
+
+#define PANGO_TYPE_FC_FONT_MAP              (pango_fc_font_map_get_type ())
+#define PANGO_FC_FONT_MAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_FONT_MAP, PangoFcFontMap))
+#define PANGO_IS_FC_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT_MAP))
+
+typedef struct _PangoFcFontMap        PangoFcFontMap;
+typedef struct _PangoFcFontMapClass   PangoFcFontMapClass;
+typedef struct _PangoFcFontMapPrivate PangoFcFontMapPrivate;
+
+#ifdef PANGO_ENABLE_BACKEND
+
+#define PANGO_FC_FONT_MAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_FONT_MAP, PangoFcFontMapClass))
+#define PANGO_IS_FC_FONT_MAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_FONT_MAP))
+#define PANGO_FC_FONT_MAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_FONT_MAP, PangoFcFontMapClass))
+
+/**
+ * PangoFcFontMap:
+ *
+ * #PangoFcFontMap is a base class for font map implementations
+ * using the Fontconfig and FreeType libraries. To create a new
+ * backend using Fontconfig and FreeType, you derive from this class
+ * and implement a new_font() virtual function that creates an
+ * instance deriving from #PangoFcFont.
+ **/
+struct _PangoFcFontMap
+{
+  PangoFontMap parent_instance;
+
+  PangoFcFontMapPrivate *priv;
+};
+
+/**
+ * PangoFcFontMapClass:
+ * @default_substitute: Substitutes in default values for
+ *  unspecified fields in a #FcPattern. This will be called
+ *  prior to creating a font for the pattern. May be %NULL.
+ *  Deprecated in favor of @font_key_substitute().
+ * @new_font: Creates a new #PangoFcFont for the specified
+ *  pattern of the appropriate type for this font map. The
+ *  @pattern argument must be passed to the "pattern" property
+ *  of #PangoFcFont when you call g_object_new(). Deprecated
+ *  in favor of @create_font().
+ * @get_resolution: Gets the resolution (the scale factor
+ *  between logical and absolute font sizes) that the backend
+ *  will use for a particular fontmap and context. @context
+ *  may be null.
+ * @context_key_get: Gets an opaque key holding backend
+ *  specific options for the context that will affect
+ *  fonts created by create_font(). The result must point to
+ *  persistant storage owned by the fontmap. This key
+ *  is used to index hash tables used to look up fontsets
+ *  and fonts.
+ * @context_key_copy: Copies a context key. Pango uses this
+ *  to make a persistant copy of the value returned from
+ *  @context_key_get.
+ * @context_key_free: Frees a context key copied with
+ *  @context_key_copy.
+ * @context_key_hash: Gets a hash value for a context key
+ * @context_key_equal: Compares two context keys for equality.
+ * @fontset_key_substitute: Substitutes in default values for
+ *  unspecified fields in a #FcPattern. This will be called
+ *  prior to creating a font for the pattern. May be %NULL.
+ *  (Since: 1.24)
+ * @create_font: Creates a new #PangoFcFont for the specified
+ *  pattern of the appropriate type for this font map using
+ *  information from the font key that is passed in. The
+ *  @pattern member of @font_key can be retrieved using
+ *  pango_fc_font_key_get_pattern() and must be passed to
+ *  the "pattern" property of #PangoFcFont when you call
+ *  g_object_new().  If %NULL, new_font() is used.
+ *  (Since: 1.24)
+ *
+ * Class structure for #PangoFcFontMap.
+ **/
+struct _PangoFcFontMapClass
+{
+  /*< private >*/
+  PangoFontMapClass parent_class;
+
+  /*< public >*/
+  /* Deprecated in favor of fontset_key_substitute */
+  void         (*default_substitute) (PangoFcFontMap   *fontmap,
+				      FcPattern        *pattern);
+  /* Deprecated in favor of create_font */
+  PangoFcFont  *(*new_font)          (PangoFcFontMap  *fontmap,
+				      FcPattern       *pattern);
+
+  double       (*get_resolution)     (PangoFcFontMap             *fcfontmap,
+				      PangoContext               *context);
+
+  gconstpointer (*context_key_get)   (PangoFcFontMap             *fcfontmap,
+				      PangoContext               *context);
+  gpointer     (*context_key_copy)   (PangoFcFontMap             *fcfontmap,
+				      gconstpointer               key);
+  void         (*context_key_free)   (PangoFcFontMap             *fcfontmap,
+				      gpointer                    key);
+  guint32      (*context_key_hash)   (PangoFcFontMap             *fcfontmap,
+				      gconstpointer               key);
+  gboolean     (*context_key_equal)  (PangoFcFontMap             *fcfontmap,
+				      gconstpointer               key_a,
+				      gconstpointer               key_b);
+
+  void         (*fontset_key_substitute)(PangoFcFontMap             *fontmap,
+				      PangoFcFontsetKey          *fontsetkey,
+				      FcPattern                  *pattern);
+  PangoFcFont  *(*create_font)       (PangoFcFontMap             *fontmap,
+				      PangoFcFontKey             *fontkey);
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_pango_reserved1) (void);
+  void (*_pango_reserved2) (void);
+  void (*_pango_reserved3) (void);
+  void (*_pango_reserved4) (void);
+};
+
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(pango_font_map_create_context)
+PangoContext * pango_fc_font_map_create_context (PangoFcFontMap *fcfontmap);
+#endif
+void           pango_fc_font_map_shutdown       (PangoFcFontMap *fcfontmap);
+
+#endif
+
+GType pango_fc_font_map_get_type (void) G_GNUC_CONST;
+
+void           pango_fc_font_map_cache_clear    (PangoFcFontMap *fcfontmap);
+
+/**
+ * PangoFcDecoderFindFunc:
+ * @pattern: a fully resolved #FcPattern specifying the font on the system
+ * @user_data: user data passed to pango_fc_font_map_add_decoder_find_func()
+ *
+ * Callback function passed to pango_fc_font_map_add_decoder_find_func().
+ *
+ * Return value: a new reference to a custom decoder for this pattern,
+ *  or %NULL if the default decoder handling should be used.
+ **/
+typedef PangoFcDecoder * (*PangoFcDecoderFindFunc) (FcPattern *pattern,
+						    gpointer   user_data);
+
+void pango_fc_font_map_add_decoder_find_func (PangoFcFontMap        *fcfontmap,
+					      PangoFcDecoderFindFunc findfunc,
+					      gpointer               user_data,
+					      GDestroyNotify         dnotify);
+PangoFcDecoder *pango_fc_font_map_find_decoder (PangoFcFontMap *fcfontmap,
+					        FcPattern      *pattern);
+
+PangoFontDescription *pango_fc_font_description_from_pattern (FcPattern *pattern,
+							      gboolean   include_size);
+
+/**
+ * PANGO_FC_GRAVITY:
+ *
+ * String representing a fontconfig property name that Pango sets on any
+ * fontconfig pattern it passes to fontconfig if a #PangoGravity other
+ * than %PangoGravitySouth is desired.
+ *
+ * The property will have a #PangoGravity value as a string, like "east".
+ * This can be used to write fontconfig configuration rules to choose
+ * different fonts for horizontal and vertical writing directions.
+ *
+ * Since: 1.20
+ */
+#define PANGO_FC_GRAVITY "pangogravity"
+
+/**
+ * PANGO_FC_VERSION:
+ *
+ * String representing a fontconfig property name that Pango sets on any
+ * fontconfig pattern it passes to fontconfig.
+ *
+ * The property will have an integer value equal to what
+ * pango_version() returns.
+ * This can be used to write fontconfig configuration rules that only affect
+ * certain pango versions (or only pango-using applications, or only
+ * non-pango-using applications).
+ *
+ * Since: 1.20
+ */
+#define PANGO_FC_VERSION "pangoversion"
+
+/**
+ * PANGO_FC_PRGNAME:
+ *
+ * String representing a fontconfig property name that Pango sets on any
+ * fontconfig pattern it passes to fontconfig.
+ *
+ * The property will have a string equal to what
+ * g_get_prgname() returns.
+ * This can be used to write fontconfig configuration rules that only affect
+ * certain applications.
+ *
+ * Since: 1.24
+ */
+#define PANGO_FC_PRGNAME "pangoprgname"
+
+G_END_DECLS
+
+#endif /* __PANGO_FC_FONT_MAP_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pangoft2.h b/gtk+-mingw/include/pango-1.0/pango/pangoft2.h
new file mode 100644
index 0000000..d2ba13d
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pangoft2.h
@@ -0,0 +1,120 @@
+/* Pango
+ * pangoft2.h:
+ *
+ * Copyright (C) 1999 Red Hat Software
+ * Copyright (C) 2000 Tor Lillqvist
+ *
+ * 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 __PANGOFT2_H__
+#define __PANGOFT2_H__
+
+#include <fontconfig/fontconfig.h>
+
+#include <pango/pango-layout.h>
+#include <pango/pangofc-font.h>
+
+G_BEGIN_DECLS
+
+#ifndef PANGO_DISABLE_DEPRECATED
+#define PANGO_RENDER_TYPE_FT2 "PangoRenderFT2"
+#endif
+
+#define PANGO_TYPE_FT2_FONT_MAP              (pango_ft2_font_map_get_type ())
+#define PANGO_FT2_FONT_MAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FT2_FONT_MAP, PangoFT2FontMap))
+#define PANGO_FT2_IS_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FT2_FONT_MAP))
+
+typedef struct _PangoFT2FontMap      PangoFT2FontMap;
+
+typedef void (*PangoFT2SubstituteFunc) (FcPattern *pattern,
+					gpointer   data);
+
+/* Calls for applications */
+
+void pango_ft2_render             (FT_Bitmap         *bitmap,
+				   PangoFont         *font,
+				   PangoGlyphString  *glyphs,
+				   gint               x,
+				   gint               y);
+void pango_ft2_render_transformed (FT_Bitmap         *bitmap,
+				   const PangoMatrix *matrix,
+				   PangoFont         *font,
+				   PangoGlyphString  *glyphs,
+				   int                x,
+				   int                y);
+
+void pango_ft2_render_layout_line          (FT_Bitmap        *bitmap,
+					    PangoLayoutLine  *line,
+					    int               x,
+					    int               y);
+void pango_ft2_render_layout_line_subpixel (FT_Bitmap        *bitmap,
+					    PangoLayoutLine  *line,
+					    int               x,
+					    int               y);
+void pango_ft2_render_layout               (FT_Bitmap        *bitmap,
+					    PangoLayout      *layout,
+					    int               x,
+					    int               y);
+void pango_ft2_render_layout_subpixel      (FT_Bitmap        *bitmap,
+					    PangoLayout      *layout,
+					    int               x,
+					    int               y);
+
+GType pango_ft2_font_map_get_type (void) G_GNUC_CONST;
+
+PangoFontMap *pango_ft2_font_map_new                    (void);
+void          pango_ft2_font_map_set_resolution         (PangoFT2FontMap        *fontmap,
+							 double                  dpi_x,
+							 double                  dpi_y);
+void          pango_ft2_font_map_set_default_substitute (PangoFT2FontMap        *fontmap,
+							 PangoFT2SubstituteFunc  func,
+							 gpointer                data,
+							 GDestroyNotify          notify);
+void          pango_ft2_font_map_substitute_changed     (PangoFT2FontMap         *fontmap);
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(pango_font_map_create_context)
+PangoContext *pango_ft2_font_map_create_context         (PangoFT2FontMap         *fontmap);
+#endif
+
+
+/* API for rendering modules
+ */
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(pango_font_map_create_context)
+PangoContext      *pango_ft2_get_context          (double dpi_x,
+						   double dpi_y);
+G_DEPRECATED_FOR(pango_ft2_font_map_new)
+PangoFontMap      *pango_ft2_font_map_for_display (void);
+G_DEPRECATED
+void               pango_ft2_shutdown_display     (void);
+
+G_DEPRECATED_FOR(PANGO_GET_UNKNOWN_GLYPH)
+PangoGlyph     pango_ft2_get_unknown_glyph (PangoFont       *font);
+G_DEPRECATED_FOR(pango_fc_font_kern_glyphs)
+int            pango_ft2_font_get_kerning  (PangoFont       *font,
+					    PangoGlyph       left,
+					    PangoGlyph       right);
+G_DEPRECATED_FOR(pango_fc_font_lock_face)
+FT_Face        pango_ft2_font_get_face     (PangoFont       *font);
+G_DEPRECATED_FOR(pango_font_get_coverage)
+PangoCoverage *pango_ft2_font_get_coverage (PangoFont       *font,
+					    PangoLanguage   *language);
+#endif /* PANGO_DISABLE_DEPRECATED */
+
+G_END_DECLS
+
+#endif /* __PANGOFT2_H__ */
diff --git a/gtk+-mingw/include/pango-1.0/pango/pangowin32.h b/gtk+-mingw/include/pango-1.0/pango/pangowin32.h
new file mode 100644
index 0000000..a27c473
--- /dev/null
+++ b/gtk+-mingw/include/pango-1.0/pango/pangowin32.h
@@ -0,0 +1,122 @@
+/* Pango
+ * pangowin32.h:
+ *
+ * Copyright (C) 1999 Red Hat Software
+ * Copyright (C) 2000 Tor Lillqvist
+ * Copyright (C) 2001 Alexander Larsson
+ *
+ * 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 __PANGOWIN32_H__
+#define __PANGOWIN32_H__
+
+#include <glib.h>
+#include <pango/pango-font.h>
+#include <pango/pango-layout.h>
+
+G_BEGIN_DECLS
+
+#define STRICT
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501	/* To get ClearType-related macros */
+#endif
+#include <windows.h>
+#undef STRICT
+
+#define PANGO_RENDER_TYPE_WIN32 "PangoRenderWin32"
+
+/* Calls for applications
+ */
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(pango_font_map_create_context)
+PangoContext * pango_win32_get_context        (void);
+#endif
+
+void           pango_win32_render             (HDC               hdc,
+					       PangoFont        *font,
+					       PangoGlyphString *glyphs,
+					       gint              x,
+					       gint              y);
+void           pango_win32_render_layout_line (HDC               hdc,
+					       PangoLayoutLine  *line,
+					       int               x,
+					       int               y);
+void           pango_win32_render_layout      (HDC               hdc,
+					       PangoLayout      *layout,
+					       int               x,
+					       int               y);
+
+void           pango_win32_render_transformed (HDC         hdc,
+					       const PangoMatrix *matrix,
+					       PangoFont         *font,
+					       PangoGlyphString  *glyphs,
+					       int                x,
+					       int                y);
+
+#ifdef PANGO_ENABLE_ENGINE
+
+/* For shape engines
+ */
+
+#ifndef PANGO_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(PANGO_GET_UNKNOWN_GLYPH)
+PangoGlyph     pango_win32_get_unknown_glyph  (PangoFont        *font,
+					       gunichar          wc);
+#endif /* PANGO_DISABLE_DEPRECATED */
+gint	      pango_win32_font_get_glyph_index(PangoFont        *font,
+					       gunichar          wc);
+
+HDC            pango_win32_get_dc             (void);
+
+gboolean       pango_win32_get_debug_flag     (void);
+
+gboolean pango_win32_font_select_font        (PangoFont *font,
+					      HDC        hdc);
+void     pango_win32_font_done_font          (PangoFont *font);
+double   pango_win32_font_get_metrics_factor (PangoFont *font);
+
+#endif
+
+/* API for libraries that want to use PangoWin32 mixed with classic
+ * Win32 fonts.
+ */
+typedef struct _PangoWin32FontCache PangoWin32FontCache;
+
+PangoWin32FontCache *pango_win32_font_cache_new          (void);
+void                 pango_win32_font_cache_free         (PangoWin32FontCache *cache);
+
+HFONT                pango_win32_font_cache_load         (PangoWin32FontCache *cache,
+							  const LOGFONTA      *logfont);
+HFONT                pango_win32_font_cache_loadw        (PangoWin32FontCache *cache,
+							  const LOGFONTW      *logfont);
+void                 pango_win32_font_cache_unload       (PangoWin32FontCache *cache,
+							  HFONT                hfont);
+
+PangoFontMap        *pango_win32_font_map_for_display    (void);
+void                 pango_win32_shutdown_display        (void);
+PangoWin32FontCache *pango_win32_font_map_get_font_cache (PangoFontMap       *font_map);
+
+LOGFONTA            *pango_win32_font_logfont            (PangoFont          *font);
+LOGFONTW            *pango_win32_font_logfontw           (PangoFont          *font);
+
+PangoFontDescription *pango_win32_font_description_from_logfont (const LOGFONTA *lfp);
+
+PangoFontDescription *pango_win32_font_description_from_logfontw (const LOGFONTW *lfp);
+
+G_END_DECLS
+
+#endif /* __PANGOWIN32_H__ */