<STRUCT>
<NAME>PangoAttrIterator</NAME>
struct _PangoAttrIterator
{
  GPtrArray *attrs; /* From the list */
  guint n_attrs; /* Copied from the list */

  GPtrArray *attribute_stack;

  guint attr_index;
  guint start_index;
  guint end_index;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrList</NAME>
struct _PangoAttrList
{
  guint ref_count;
  GPtrArray *attributes;
};
</STRUCT>
<STRUCT>
<NAME>PangoColor</NAME>
struct _PangoColor
{
  guint16 red;
  guint16 green;
  guint16 blue;
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_COLOR</NAME>
#define PANGO_TYPE_COLOR pango_color_get_type ()
</MACRO>
<FUNCTION>
<NAME>pango_color_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_attribute_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_color_copy</NAME>
<RETURNS>PangoColor *</RETURNS>
const PangoColor *src
</FUNCTION>
<FUNCTION>
<NAME>pango_color_free</NAME>
<RETURNS>void</RETURNS>
PangoColor       *color
</FUNCTION>
<FUNCTION>
<NAME>pango_color_parse</NAME>
<RETURNS>gboolean</RETURNS>
PangoColor       *color, const char       *spec
</FUNCTION>
<FUNCTION>
<NAME>pango_color_parse_with_alpha</NAME>
<RETURNS>gboolean</RETURNS>
PangoColor       *color, guint16          *alpha, const char       *spec
</FUNCTION>
<FUNCTION>
<NAME>pango_color_to_string</NAME>
<RETURNS>gchar *</RETURNS>
const PangoColor *color
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_ATTR_LIST</NAME>
#define PANGO_TYPE_ATTR_LIST pango_attr_list_get_type ()
</MACRO>
<ENUM>
<NAME>PangoAttrType</NAME>
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 */
  PANGO_ATTR_FONT_FEATURES,	/* PangoAttrString */
  PANGO_ATTR_FOREGROUND_ALPHA,	/* PangoAttrInt */
  PANGO_ATTR_BACKGROUND_ALPHA,	/* PangoAttrInt */
  PANGO_ATTR_ALLOW_BREAKS,	/* PangoAttrInt */
  PANGO_ATTR_SHOW,		/* PangoAttrInt */
  PANGO_ATTR_INSERT_HYPHENS,	/* PangoAttrInt */
  PANGO_ATTR_OVERLINE,		/* PangoAttrInt */
  PANGO_ATTR_OVERLINE_COLOR,	/* PangoAttrColor */
} PangoAttrType;
</ENUM>
<ENUM>
<NAME>PangoUnderline</NAME>
typedef enum {
  PANGO_UNDERLINE_NONE,
  PANGO_UNDERLINE_SINGLE,
  PANGO_UNDERLINE_DOUBLE,
  PANGO_UNDERLINE_LOW,
  PANGO_UNDERLINE_ERROR,
  PANGO_UNDERLINE_SINGLE_LINE,
  PANGO_UNDERLINE_DOUBLE_LINE,
  PANGO_UNDERLINE_ERROR_LINE
} PangoUnderline;
</ENUM>
<ENUM>
<NAME>PangoOverline</NAME>
typedef enum {
  PANGO_OVERLINE_NONE,
  PANGO_OVERLINE_SINGLE
} PangoOverline;
</ENUM>
<MACRO>
<NAME>PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING</NAME>
#define PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING	0
</MACRO>
<MACRO>
<NAME>PANGO_ATTR_INDEX_TO_TEXT_END</NAME>
#define PANGO_ATTR_INDEX_TO_TEXT_END		G_MAXUINT
</MACRO>
<STRUCT>
<NAME>PangoAttribute</NAME>
struct _PangoAttribute
{
  const PangoAttrClass *klass;
  guint start_index;	/* in bytes */
  guint end_index;	/* in bytes. The character at this index is not included */
};
</STRUCT>
<USER_FUNCTION>
<NAME>PangoAttrFilterFunc</NAME>
<RETURNS>gboolean</RETURNS>
PangoAttribute *attribute, gpointer        user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>PangoAttrDataCopyFunc</NAME>
<RETURNS>gpointer</RETURNS>
gconstpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>PangoAttrClass</NAME>
struct _PangoAttrClass
{
  /*< public >*/
  PangoAttrType type;
  PangoAttribute * (*copy) (const PangoAttribute *attr);
  void             (*destroy) (PangoAttribute *attr);
  gboolean         (*equal) (const PangoAttribute *attr1, const PangoAttribute *attr2);
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrString</NAME>
struct _PangoAttrString
{
  PangoAttribute attr;
  char *value;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrLanguage</NAME>
struct _PangoAttrLanguage
{
  PangoAttribute attr;
  PangoLanguage *value;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrInt</NAME>
struct _PangoAttrInt
{
  PangoAttribute attr;
  int value;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrFloat</NAME>
struct _PangoAttrFloat
{
  PangoAttribute attr;
  double value;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrColor</NAME>
struct _PangoAttrColor
{
  PangoAttribute attr;
  PangoColor color;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrSize</NAME>
struct _PangoAttrSize
{
  PangoAttribute attr;
  int size;
  guint absolute : 1;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrShape</NAME>
struct _PangoAttrShape
{
  PangoAttribute attr;
  PangoRectangle ink_rect;
  PangoRectangle logical_rect;

  gpointer              data;
  PangoAttrDataCopyFunc copy_func;
  GDestroyNotify        destroy_func;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrFontDesc</NAME>
struct _PangoAttrFontDesc
{
  PangoAttribute attr;
  PangoFontDescription *desc;
};
</STRUCT>
<STRUCT>
<NAME>PangoAttrFontFeatures</NAME>
struct _PangoAttrFontFeatures
{
  PangoAttribute attr;
  gchar *features;
};
</STRUCT>
<FUNCTION>
<NAME>pango_attr_type_register</NAME>
<RETURNS>PangoAttrType</RETURNS>
const gchar        *name
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_type_get_name</NAME>
<RETURNS>const char *</RETURNS>
PangoAttrType       type
</FUNCTION>
<FUNCTION>
<NAME>pango_attribute_init</NAME>
<RETURNS>void</RETURNS>
PangoAttribute       *attr, const PangoAttrClass *klass
</FUNCTION>
<FUNCTION>
<NAME>pango_attribute_copy</NAME>
<RETURNS>PangoAttribute *</RETURNS>
const PangoAttribute *attr
</FUNCTION>
<FUNCTION>
<NAME>pango_attribute_destroy</NAME>
<RETURNS>void</RETURNS>
PangoAttribute       *attr
</FUNCTION>
<FUNCTION>
<NAME>pango_attribute_equal</NAME>
<RETURNS>gboolean</RETURNS>
const PangoAttribute *attr1, const PangoAttribute *attr2
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_language_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoLanguage              *language
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_family_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
const char                 *family
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_foreground_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
guint16                     red, guint16                     green, guint16                     blue
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_background_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
guint16                     red, guint16                     green, guint16                     blue
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_size_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
int                         size
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_size_new_absolute</NAME>
<RETURNS>PangoAttribute *</RETURNS>
int                         size
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_style_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoStyle                  style
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_weight_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoWeight                 weight
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_variant_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoVariant                variant
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_stretch_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoStretch                stretch
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_font_desc_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_underline_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoUnderline underline
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_underline_color_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
guint16        red, guint16        green, guint16        blue
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_strikethrough_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
gboolean       strikethrough
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_strikethrough_color_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
guint16        red, guint16        green, guint16        blue
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_rise_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
int                         rise
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_scale_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
double                      scale_factor
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_fallback_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
gboolean                    enable_fallback
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_letter_spacing_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
int                        letter_spacing
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_shape_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
const PangoRectangle       *ink_rect, const PangoRectangle       *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_shape_new_with_data</NAME>
<RETURNS>PangoAttribute *</RETURNS>
const PangoRectangle       *ink_rect, const PangoRectangle       *logical_rect, gpointer                    data, PangoAttrDataCopyFunc       copy_func, GDestroyNotify              destroy_func
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_gravity_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoGravity     gravity
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_gravity_hint_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoGravityHint hint
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_font_features_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
const gchar *features
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_foreground_alpha_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
guint16 alpha
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_background_alpha_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
guint16 alpha
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_allow_breaks_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
gboolean allow_breaks
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_insert_hyphens_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
gboolean insert_hyphens
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_overline_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoOverline overline
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_overline_color_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
guint16       red, guint16       green, guint16       blue
</FUNCTION>
<ENUM>
<NAME>PangoShowFlags</NAME>
typedef enum {
  PANGO_SHOW_NONE        = 0,
  PANGO_SHOW_SPACES      = 1 << 0,
  PANGO_SHOW_LINE_BREAKS = 1 << 1,
  PANGO_SHOW_IGNORABLES  = 1 << 2
} PangoShowFlags;
</ENUM>
<FUNCTION>
<NAME>pango_attr_show_new</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoShowFlags flags
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_new</NAME>
<RETURNS>PangoAttrList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_ref</NAME>
<RETURNS>PangoAttrList *</RETURNS>
PangoAttrList  *list
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_unref</NAME>
<RETURNS>void</RETURNS>
PangoAttrList  *list
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_copy</NAME>
<RETURNS>PangoAttrList *</RETURNS>
PangoAttrList  *list
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_insert</NAME>
<RETURNS>void</RETURNS>
PangoAttrList  *list, PangoAttribute *attr
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_insert_before</NAME>
<RETURNS>void</RETURNS>
PangoAttrList  *list, PangoAttribute *attr
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_change</NAME>
<RETURNS>void</RETURNS>
PangoAttrList  *list, PangoAttribute *attr
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_splice</NAME>
<RETURNS>void</RETURNS>
PangoAttrList  *list, PangoAttrList  *other, gint            pos, gint            len
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_update</NAME>
<RETURNS>void</RETURNS>
PangoAttrList  *list, int             pos, int             remove, int             add
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_filter</NAME>
<RETURNS>PangoAttrList *</RETURNS>
PangoAttrList       *list, PangoAttrFilterFunc  func, gpointer             data
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_get_attributes</NAME>
<RETURNS>GSList *</RETURNS>
PangoAttrList *list
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_equal</NAME>
<RETURNS>gboolean</RETURNS>
PangoAttrList *list, PangoAttrList *other_list
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_list_get_iterator</NAME>
<RETURNS>PangoAttrIterator *</RETURNS>
PangoAttrList  *list
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_range</NAME>
<RETURNS>void</RETURNS>
PangoAttrIterator     *iterator, gint                  *start, gint                  *end
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_next</NAME>
<RETURNS>gboolean</RETURNS>
PangoAttrIterator     *iterator
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_copy</NAME>
<RETURNS>PangoAttrIterator *</RETURNS>
PangoAttrIterator     *iterator
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_destroy</NAME>
<RETURNS>void</RETURNS>
PangoAttrIterator     *iterator
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_get</NAME>
<RETURNS>PangoAttribute *</RETURNS>
PangoAttrIterator     *iterator, PangoAttrType          type
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_get_font</NAME>
<RETURNS>void</RETURNS>
PangoAttrIterator     *iterator, PangoFontDescription  *desc, PangoLanguage        **language, GSList               **extra_attrs
</FUNCTION>
<FUNCTION>
<NAME>pango_attr_iterator_get_attrs</NAME>
<RETURNS>GSList *</RETURNS>
PangoAttrIterator     *iterator
</FUNCTION>
<FUNCTION>
<NAME>pango_parse_markup</NAME>
<RETURNS>gboolean</RETURNS>
const char                 *markup_text, int                         length, gunichar                    accel_marker, PangoAttrList             **attr_list, char                      **text, gunichar                   *accel_char, GError                    **error
</FUNCTION>
<FUNCTION>
<NAME>pango_markup_parser_new</NAME>
<RETURNS>GMarkupParseContext *</RETURNS>
gunichar               accel_marker
</FUNCTION>
<FUNCTION>
<NAME>pango_markup_parser_finish</NAME>
<RETURNS>gboolean</RETURNS>
GMarkupParseContext   *context, PangoAttrList        **attr_list, char                 **text, gunichar              *accel_char, GError               **error
</FUNCTION>
<STRUCT>
<NAME>PangoAttrIterator</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoAttrList</NAME>
</STRUCT>
<ENUM>
<NAME>PangoBidiType</NAME>
<DEPRECATED/>
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;
</ENUM>
<FUNCTION>
<NAME>pango_bidi_type_for_unichar</NAME>
<DEPRECATED/>
<RETURNS>PangoBidiType</RETURNS>
gunichar ch
</FUNCTION>
<FUNCTION>
<NAME>pango_unichar_direction</NAME>
<DEPRECATED/>
<RETURNS>PangoDirection</RETURNS>
gunichar     ch
</FUNCTION>
<FUNCTION>
<NAME>pango_find_base_dir</NAME>
<DEPRECATED/>
<RETURNS>PangoDirection</RETURNS>
const gchar *text, gint         length
</FUNCTION>
<FUNCTION>
<NAME>pango_get_mirror_char</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
gunichar     ch, gunichar    *mirrored_ch
</FUNCTION>
<STRUCT>
<NAME>PangoLogAttr</NAME>
struct _PangoLogAttr
{
  guint is_line_break               : 1;
  guint is_mandatory_break          : 1;
  guint is_char_break               : 1;
  guint is_white                    : 1;
  guint is_cursor_position          : 1;
  guint is_word_start               : 1;
  guint is_word_end                 : 1;
  guint is_sentence_boundary        : 1;
  guint is_sentence_start           : 1;
  guint is_sentence_end             : 1;
  guint backspace_deletes_character : 1;
  guint is_expandable_space         : 1;
  guint is_word_boundary            : 1;
};
</STRUCT>
<FUNCTION>
<NAME>pango_break</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
const gchar   *text, int            length, PangoAnalysis *analysis, PangoLogAttr  *attrs, int            attrs_len
</FUNCTION>
<FUNCTION>
<NAME>pango_find_paragraph_boundary</NAME>
<RETURNS>void</RETURNS>
const gchar *text, gint         length, gint        *paragraph_delimiter_index, gint        *next_paragraph_start
</FUNCTION>
<FUNCTION>
<NAME>pango_get_log_attrs</NAME>
<RETURNS>void</RETURNS>
const char    *text, int            length, int            level, PangoLanguage *language, PangoLogAttr  *log_attrs, int            attrs_len
</FUNCTION>
<FUNCTION>
<NAME>pango_default_break</NAME>
<RETURNS>void</RETURNS>
const gchar   *text, int            length, PangoAnalysis *analysis, PangoLogAttr  *attrs, int            attrs_len
</FUNCTION>
<FUNCTION>
<NAME>pango_tailor_break</NAME>
<RETURNS>void</RETURNS>
const char    *text, int            length, PangoAnalysis *analysis, int            offset, PangoLogAttr  *log_attrs, int            log_attrs_len
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_CONTEXT</NAME>
#define PANGO_TYPE_CONTEXT              (pango_context_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_CONTEXT</NAME>
#define PANGO_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CONTEXT, PangoContext))
</MACRO>
<MACRO>
<NAME>PANGO_CONTEXT_CLASS</NAME>
#define PANGO_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_CONTEXT, PangoContextClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_CONTEXT</NAME>
#define PANGO_IS_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CONTEXT))
</MACRO>
<MACRO>
<NAME>PANGO_IS_CONTEXT_CLASS</NAME>
#define PANGO_IS_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_CONTEXT))
</MACRO>
<MACRO>
<NAME>PANGO_CONTEXT_GET_CLASS</NAME>
#define PANGO_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_CONTEXT, PangoContextClass))
</MACRO>
<FUNCTION>
<NAME>pango_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_context_new</NAME>
<RETURNS>PangoContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_context_changed</NAME>
<RETURNS>void</RETURNS>
PangoContext                 *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_font_map</NAME>
<RETURNS>void</RETURNS>
PangoContext                 *context, PangoFontMap                 *font_map
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_font_map</NAME>
<RETURNS>PangoFontMap *</RETURNS>
PangoContext                 *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_serial</NAME>
<RETURNS>guint</RETURNS>
PangoContext                 *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_list_families</NAME>
<RETURNS>void</RETURNS>
PangoContext                 *context, PangoFontFamily            ***families, int                          *n_families
</FUNCTION>
<FUNCTION>
<NAME>pango_context_load_font</NAME>
<RETURNS>PangoFont *</RETURNS>
PangoContext                 *context, const PangoFontDescription   *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_context_load_fontset</NAME>
<RETURNS>PangoFontset *</RETURNS>
PangoContext                 *context, const PangoFontDescription   *desc, PangoLanguage                *language
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_metrics</NAME>
<RETURNS>PangoFontMetrics *</RETURNS>
PangoContext                 *context, const PangoFontDescription   *desc, PangoLanguage                *language
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_font_description</NAME>
<RETURNS>void</RETURNS>
PangoContext               *context, const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_font_description</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
PangoContext               *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_language</NAME>
<RETURNS>PangoLanguage *</RETURNS>
PangoContext               *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_language</NAME>
<RETURNS>void</RETURNS>
PangoContext               *context, PangoLanguage              *language
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_base_dir</NAME>
<RETURNS>void</RETURNS>
PangoContext               *context, PangoDirection              direction
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_base_dir</NAME>
<RETURNS>PangoDirection</RETURNS>
PangoContext               *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_base_gravity</NAME>
<RETURNS>void</RETURNS>
PangoContext               *context, PangoGravity                gravity
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_base_gravity</NAME>
<RETURNS>PangoGravity</RETURNS>
PangoContext               *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_gravity</NAME>
<RETURNS>PangoGravity</RETURNS>
PangoContext               *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_gravity_hint</NAME>
<RETURNS>void</RETURNS>
PangoContext               *context, PangoGravityHint            hint
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_gravity_hint</NAME>
<RETURNS>PangoGravityHint</RETURNS>
PangoContext               *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_matrix</NAME>
<RETURNS>void</RETURNS>
PangoContext      *context, const PangoMatrix *matrix
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_matrix</NAME>
<RETURNS>const PangoMatrix *</RETURNS>
PangoContext      *context
</FUNCTION>
<FUNCTION>
<NAME>pango_context_set_round_glyph_positions</NAME>
<RETURNS>void</RETURNS>
PangoContext *context, gboolean      round_positions
</FUNCTION>
<FUNCTION>
<NAME>pango_context_get_round_glyph_positions</NAME>
<RETURNS>gboolean</RETURNS>
PangoContext *context
</FUNCTION>
<FUNCTION>
<NAME>pango_itemize</NAME>
<RETURNS>GList *</RETURNS>
PangoContext      *context, const char        *text, int                start_index, int                length, PangoAttrList     *attrs, PangoAttrIterator *cached_iter
</FUNCTION>
<FUNCTION>
<NAME>pango_itemize_with_base_dir</NAME>
<RETURNS>GList *</RETURNS>
PangoContext      *context, PangoDirection     base_dir, const char        *text, int                start_index, int                length, PangoAttrList     *attrs, PangoAttrIterator *cached_iter
</FUNCTION>
<STRUCT>
<NAME>PangoContextClass</NAME>
</STRUCT>
<ENUM>
<NAME>PangoCoverageLevel</NAME>
typedef enum {
  PANGO_COVERAGE_NONE,
  PANGO_COVERAGE_FALLBACK,
  PANGO_COVERAGE_APPROXIMATE,
  PANGO_COVERAGE_EXACT
} PangoCoverageLevel;
</ENUM>
<FUNCTION>
<NAME>pango_coverage_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_new</NAME>
<RETURNS>PangoCoverage *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_ref</NAME>
<RETURNS>PangoCoverage *</RETURNS>
PangoCoverage      *coverage
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_unref</NAME>
<RETURNS>void</RETURNS>
PangoCoverage      *coverage
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_copy</NAME>
<RETURNS>PangoCoverage *</RETURNS>
PangoCoverage      *coverage
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_get</NAME>
<RETURNS>PangoCoverageLevel</RETURNS>
PangoCoverage      *coverage, int                 index_
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_set</NAME>
<RETURNS>void</RETURNS>
PangoCoverage      *coverage, int                 index_, PangoCoverageLevel  level
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_max</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoCoverage      *coverage, PangoCoverage      *other
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_to_bytes</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoCoverage  *coverage, guchar        **bytes, int            *n_bytes
</FUNCTION>
<FUNCTION>
<NAME>pango_coverage_from_bytes</NAME>
<DEPRECATED/>
<RETURNS>PangoCoverage *</RETURNS>
guchar         *bytes, int             n_bytes
</FUNCTION>
<STRUCT>
<NAME>PangoCoverage</NAME>
</STRUCT>
<ENUM>
<NAME>PangoDirection</NAME>
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;
</ENUM>
<STRUCT>
<NAME>Interval</NAME>
struct Interval {
  gunichar start, end;
};
</STRUCT>
<MACRO>
<NAME>PANGO_RENDER_TYPE_NONE</NAME>
<DEPRECATED/>
#define PANGO_RENDER_TYPE_NONE "PangoRenderNone"
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_ENGINE</NAME>
<DEPRECATED/>
#define PANGO_TYPE_ENGINE              (pango_engine_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE</NAME>
<DEPRECATED/>
#define PANGO_ENGINE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE, PangoEngine))
</MACRO>
<MACRO>
<NAME>PANGO_IS_ENGINE</NAME>
<DEPRECATED/>
#define PANGO_IS_ENGINE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE))
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_CLASS</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE, PangoEngineClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_ENGINE_CLASS</NAME>
<DEPRECATED/>
#define PANGO_IS_ENGINE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE))
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_GET_CLASS</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE, PangoEngineClass))
</MACRO>
<STRUCT>
<NAME>PangoEngine</NAME>
<DEPRECATED/>
struct _PangoEngine
{
  /*< private >*/
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoEngineClass</NAME>
<DEPRECATED/>
struct _PangoEngineClass
{
  /*< private >*/
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>pango_engine_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_ENGINE_TYPE_LANG</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_TYPE_LANG "PangoEngineLang"
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_ENGINE_LANG</NAME>
<DEPRECATED/>
#define PANGO_TYPE_ENGINE_LANG              (pango_engine_lang_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_LANG</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_LANG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE_LANG, PangoEngineLang))
</MACRO>
<MACRO>
<NAME>PANGO_IS_ENGINE_LANG</NAME>
<DEPRECATED/>
#define PANGO_IS_ENGINE_LANG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE_LANG))
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_LANG_CLASS</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_LANG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE_LANG, PangoEngineLangClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_ENGINE_LANG_CLASS</NAME>
<DEPRECATED/>
#define PANGO_IS_ENGINE_LANG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE_LANG))
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_LANG_GET_CLASS</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_LANG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE_LANG, PangoEngineLangClass))
</MACRO>
<STRUCT>
<NAME>PangoEngineLang</NAME>
<DEPRECATED/>
struct _PangoEngineLang
{
  /*< private >*/
  PangoEngine parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoEngineLangClass</NAME>
<DEPRECATED/>
struct _PangoEngineLangClass
{
  /*< private >*/
  PangoEngineClass parent_class;

  /*< public >*/
  void (*script_break) (PangoEngineLang *engine,
			const char    *text,
			int            len,
			PangoAnalysis *analysis,
			PangoLogAttr  *attrs,
			int            attrs_len);
};
</STRUCT>
<FUNCTION>
<NAME>pango_engine_lang_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_ENGINE_TYPE_SHAPE</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_TYPE_SHAPE "PangoEngineShape"
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_ENGINE_SHAPE</NAME>
<DEPRECATED/>
#define PANGO_TYPE_ENGINE_SHAPE              (pango_engine_shape_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_SHAPE</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_SHAPE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE_SHAPE, PangoEngineShape))
</MACRO>
<MACRO>
<NAME>PANGO_IS_ENGINE_SHAPE</NAME>
<DEPRECATED/>
#define PANGO_IS_ENGINE_SHAPE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE_SHAPE))
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_SHAPE_CLASS</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_SHAPE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE_SHAPE, PangoEngine_ShapeClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_ENGINE_SHAPE_CLASS</NAME>
<DEPRECATED/>
#define PANGO_IS_ENGINE_SHAPE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE_SHAPE))
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_SHAPE_GET_CLASS</NAME>
<DEPRECATED/>
#define PANGO_ENGINE_SHAPE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE_SHAPE, PangoEngineShapeClass))
</MACRO>
<STRUCT>
<NAME>PangoEngineShape</NAME>
<DEPRECATED/>
struct _PangoEngineShape
{
  PangoEngine parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoEngineShapeClass</NAME>
<DEPRECATED/>
struct _PangoEngineShapeClass
{
  /*< private >*/
  PangoEngineClass parent_class;

  /*< public >*/
  void (*script_shape) (PangoEngineShape    *engine,
			PangoFont           *font,
			const char          *item_text,
			unsigned int         item_length,
			const PangoAnalysis *analysis,
			PangoGlyphString    *glyphs,
			const char          *paragraph_text,
			unsigned int         paragraph_length);
  PangoCoverageLevel (*covers)   (PangoEngineShape *engine,
				  PangoFont        *font,
				  PangoLanguage    *language,
				  gunichar          wc);
};
</STRUCT>
<FUNCTION>
<NAME>pango_engine_shape_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PangoEngineScriptInfo</NAME>
<DEPRECATED/>
struct _PangoEngineScriptInfo
{
  PangoScript script;
  const gchar *langs;
};
</STRUCT>
<STRUCT>
<NAME>PangoEngineInfo</NAME>
<DEPRECATED/>
struct _PangoEngineInfo
{
  const gchar *id;
  const gchar *engine_type;
  const gchar *render_type;
  PangoEngineScriptInfo *scripts;
  gint n_scripts;
};
</STRUCT>
<FUNCTION>
<NAME>script_engine_list</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoEngineInfo **engines, int              *n_engines
</FUNCTION>
<FUNCTION>
<NAME>script_engine_init</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
GTypeModule *module
</FUNCTION>
<FUNCTION>
<NAME>script_engine_exit</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>script_engine_create</NAME>
<DEPRECATED/>
<RETURNS>PangoEngine *</RETURNS>
const char *id
</FUNCTION>
<MACRO>
<NAME>PANGO_ENGINE_DEFINE_TYPE</NAME>
<DEPRECATED/>
#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);	  \
}
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_LANG_DEFINE_TYPE</NAME>
<DEPRECATED/>
#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)
</MACRO>
<MACRO>
<NAME>PANGO_ENGINE_SHAPE_DEFINE_TYPE</NAME>
<DEPRECATED/>
#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>
<MACRO>
<NAME>PANGO_MODULE_ENTRY</NAME>
<DEPRECATED/>
#define PANGO_MODULE_ENTRY(func) _PANGO_MODULE_ENTRY2(PANGO_MODULE_PREFIX,func)
</MACRO>
<ENUM>
<NAME>PangoStyle</NAME>
typedef enum {
  PANGO_STYLE_NORMAL,
  PANGO_STYLE_OBLIQUE,
  PANGO_STYLE_ITALIC
} PangoStyle;
</ENUM>
<ENUM>
<NAME>PangoVariant</NAME>
typedef enum {
  PANGO_VARIANT_NORMAL,
  PANGO_VARIANT_SMALL_CAPS
} PangoVariant;
</ENUM>
<ENUM>
<NAME>PangoWeight</NAME>
typedef enum {
  PANGO_WEIGHT_THIN = 100,
  PANGO_WEIGHT_ULTRALIGHT = 200,
  PANGO_WEIGHT_LIGHT = 300,
  PANGO_WEIGHT_SEMILIGHT = 350,
  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;
</ENUM>
<ENUM>
<NAME>PangoStretch</NAME>
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;
</ENUM>
<ENUM>
<NAME>PangoFontMask</NAME>
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,
  PANGO_FONT_MASK_VARIATIONS = 1 << 7,
} PangoFontMask;
</ENUM>
<MACRO>
<NAME>PANGO_SCALE_XX_SMALL</NAME>
#define PANGO_SCALE_XX_SMALL ((double)0.5787037037037)
</MACRO>
<MACRO>
<NAME>PANGO_SCALE_X_SMALL</NAME>
#define PANGO_SCALE_X_SMALL  ((double)0.6944444444444)
</MACRO>
<MACRO>
<NAME>PANGO_SCALE_SMALL</NAME>
#define PANGO_SCALE_SMALL    ((double)0.8333333333333)
</MACRO>
<MACRO>
<NAME>PANGO_SCALE_MEDIUM</NAME>
#define PANGO_SCALE_MEDIUM   ((double)1.0)
</MACRO>
<MACRO>
<NAME>PANGO_SCALE_LARGE</NAME>
#define PANGO_SCALE_LARGE    ((double)1.2)
</MACRO>
<MACRO>
<NAME>PANGO_SCALE_X_LARGE</NAME>
#define PANGO_SCALE_X_LARGE  ((double)1.44)
</MACRO>
<MACRO>
<NAME>PANGO_SCALE_XX_LARGE</NAME>
#define PANGO_SCALE_XX_LARGE ((double)1.728)
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_FONT_DESCRIPTION</NAME>
#define PANGO_TYPE_FONT_DESCRIPTION (pango_font_description_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_font_description_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_new</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_copy</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
const PangoFontDescription  *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_copy_static</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
const PangoFontDescription  *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_hash</NAME>
<RETURNS>guint</RETURNS>
const PangoFontDescription  *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_equal</NAME>
<RETURNS>gboolean</RETURNS>
const PangoFontDescription  *desc1, const PangoFontDescription  *desc2
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_free</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription        *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_descriptions_free</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription       **descs, int                          n_descs
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_family</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, const char           *family
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_family_static</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, const char           *family
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_family</NAME>
<RETURNS>const char *</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_style</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, PangoStyle            style
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_style</NAME>
<RETURNS>PangoStyle</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_variant</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, PangoVariant          variant
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_variant</NAME>
<RETURNS>PangoVariant</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_weight</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, PangoWeight           weight
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_weight</NAME>
<RETURNS>PangoWeight</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_stretch</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, PangoStretch          stretch
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_stretch</NAME>
<RETURNS>PangoStretch</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_size</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, gint                  size
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_size</NAME>
<RETURNS>gint</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_absolute_size</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, double                size
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_size_is_absolute</NAME>
<RETURNS>gboolean</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_gravity</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription *desc, PangoGravity          gravity
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_gravity</NAME>
<RETURNS>PangoGravity</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_variations_static</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription       *desc, const char                 *variations
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_set_variations</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription       *desc, const char                 *variations
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_variations</NAME>
<RETURNS>const char *</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_get_set_fields</NAME>
<RETURNS>PangoFontMask</RETURNS>
const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_unset_fields</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription       *desc, PangoFontMask               to_unset
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_merge</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription       *desc, const PangoFontDescription *desc_to_merge, gboolean                    replace_existing
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_merge_static</NAME>
<RETURNS>void</RETURNS>
PangoFontDescription       *desc, const PangoFontDescription *desc_to_merge, gboolean                    replace_existing
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_better_match</NAME>
<RETURNS>gboolean</RETURNS>
const PangoFontDescription *desc, const PangoFontDescription *old_match, const PangoFontDescription *new_match
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_from_string</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
const char                  *str
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_to_string</NAME>
<RETURNS>char *</RETURNS>
const PangoFontDescription  *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_description_to_filename</NAME>
<RETURNS>char *</RETURNS>
const PangoFontDescription  *desc
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_FONT_METRICS</NAME>
#define PANGO_TYPE_FONT_METRICS  (pango_font_metrics_get_type ())
</MACRO>
<STRUCT>
<NAME>PangoFontMetrics</NAME>
struct _PangoFontMetrics
{
  /* <private> */
  guint ref_count;

  int ascent;
  int descent;
  int height;
  int approximate_char_width;
  int approximate_digit_width;
  int underline_position;
  int underline_thickness;
  int strikethrough_position;
  int strikethrough_thickness;
};
</STRUCT>
<FUNCTION>
<NAME>pango_font_metrics_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_ref</NAME>
<RETURNS>PangoFontMetrics *</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_unref</NAME>
<RETURNS>void</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_ascent</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_descent</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_height</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_approximate_char_width</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_approximate_digit_width</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_underline_position</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_underline_thickness</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_strikethrough_position</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>pango_font_metrics_get_strikethrough_thickness</NAME>
<RETURNS>int</RETURNS>
PangoFontMetrics *metrics
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_FONT_FAMILY</NAME>
#define PANGO_TYPE_FONT_FAMILY              (pango_font_family_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FONT_FAMILY</NAME>
#define PANGO_FONT_FAMILY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FAMILY, PangoFontFamily))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT_FAMILY</NAME>
#define PANGO_IS_FONT_FAMILY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FAMILY))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_FAMILY_CLASS</NAME>
#define PANGO_FONT_FAMILY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT_FAMILY_CLASS</NAME>
#define PANGO_IS_FONT_FAMILY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FAMILY))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_FAMILY_GET_CLASS</NAME>
#define PANGO_FONT_FAMILY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass))
</MACRO>
<STRUCT>
<NAME>PangoFontFamily</NAME>
<DEPRECATED/>
struct _PangoFontFamily
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoFontFamilyClass</NAME>
<DEPRECATED/>
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);
  gboolean (*is_variable)  (PangoFontFamily *family);

  PangoFontFace * (*get_face) (PangoFontFamily *family,
                               const char      *name);


  /*< private >*/

  /* Padding for future expansion */
  void (*_pango_reserved2) (void);
};
</STRUCT>
<FUNCTION>
<NAME>pango_font_family_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_font_family_list_faces</NAME>
<RETURNS>void</RETURNS>
PangoFontFamily  *family, PangoFontFace  ***faces, int              *n_faces
</FUNCTION>
<FUNCTION>
<NAME>pango_font_family_get_name</NAME>
<RETURNS>const char *</RETURNS>
PangoFontFamily  *family
</FUNCTION>
<FUNCTION>
<NAME>pango_font_family_is_monospace</NAME>
<RETURNS>gboolean</RETURNS>
PangoFontFamily  *family
</FUNCTION>
<FUNCTION>
<NAME>pango_font_family_is_variable</NAME>
<RETURNS>gboolean</RETURNS>
PangoFontFamily  *family
</FUNCTION>
<FUNCTION>
<NAME>pango_font_family_get_face</NAME>
<RETURNS>PangoFontFace *</RETURNS>
PangoFontFamily *family, const char      *name
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_FONT_FACE</NAME>
#define PANGO_TYPE_FONT_FACE              (pango_font_face_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FONT_FACE</NAME>
#define PANGO_FONT_FACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FACE, PangoFontFace))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT_FACE</NAME>
#define PANGO_IS_FONT_FACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FACE))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_FACE_CLASS</NAME>
#define PANGO_FONT_FACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FACE, PangoFontFaceClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT_FACE_CLASS</NAME>
#define PANGO_IS_FONT_FACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FACE))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_FACE_GET_CLASS</NAME>
#define PANGO_FONT_FACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FACE, PangoFontFaceClass))
</MACRO>
<STRUCT>
<NAME>PangoFontFace</NAME>
<DEPRECATED/>
struct _PangoFontFace
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoFontFaceClass</NAME>
<DEPRECATED/>
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);
  PangoFontFamily *      (*get_family)     (PangoFontFace *face);

  /*< private >*/

  /* Padding for future expansion */
  void (*_pango_reserved3) (void);
  void (*_pango_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>pango_font_face_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_font_face_describe</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
PangoFontFace  *face
</FUNCTION>
<FUNCTION>
<NAME>pango_font_face_get_face_name</NAME>
<RETURNS>const char *</RETURNS>
PangoFontFace  *face
</FUNCTION>
<FUNCTION>
<NAME>pango_font_face_list_sizes</NAME>
<RETURNS>void</RETURNS>
PangoFontFace  *face, int           **sizes, int            *n_sizes
</FUNCTION>
<FUNCTION>
<NAME>pango_font_face_is_synthesized</NAME>
<RETURNS>gboolean</RETURNS>
PangoFontFace  *face
</FUNCTION>
<FUNCTION>
<NAME>pango_font_face_get_family</NAME>
<RETURNS>PangoFontFamily *</RETURNS>
PangoFontFace  *face
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_FONT</NAME>
#define PANGO_TYPE_FONT              (pango_font_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FONT</NAME>
#define PANGO_FONT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT, PangoFont))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT</NAME>
#define PANGO_IS_FONT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_CLASS</NAME>
#define PANGO_FONT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT, PangoFontClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT_CLASS</NAME>
#define PANGO_IS_FONT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_GET_CLASS</NAME>
#define PANGO_FONT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT, PangoFontClass))
</MACRO>
<STRUCT>
<NAME>PangoFont</NAME>
<DEPRECATED/>
struct _PangoFont
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoFontClass</NAME>
<DEPRECATED/>
struct _PangoFontClass
{
  GObjectClass parent_class;

  /*< public >*/

  PangoFontDescription *(*describe)           (PangoFont      *font);
  PangoCoverage *       (*get_coverage)       (PangoFont      *font,
                                               PangoLanguage  *language);
  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);
  void                  (*get_features)       (PangoFont      *font,
                                               hb_feature_t   *features,
                                               guint           len,
                                               guint          *num_features);
  hb_font_t *           (*create_hb_font)     (PangoFont      *font);
};
</STRUCT>
<FUNCTION>
<NAME>pango_font_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_font_describe</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
PangoFont        *font
</FUNCTION>
<FUNCTION>
<NAME>pango_font_describe_with_absolute_size</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
PangoFont        *font
</FUNCTION>
<FUNCTION>
<NAME>pango_font_get_coverage</NAME>
<RETURNS>PangoCoverage *</RETURNS>
PangoFont        *font, PangoLanguage    *language
</FUNCTION>
<FUNCTION>
<NAME>pango_font_find_shaper</NAME>
<DEPRECATED/>
<RETURNS>PangoEngineShape *</RETURNS>
PangoFont        *font, PangoLanguage    *language, guint32           ch
</FUNCTION>
<FUNCTION>
<NAME>pango_font_get_metrics</NAME>
<RETURNS>PangoFontMetrics *</RETURNS>
PangoFont        *font, PangoLanguage    *language
</FUNCTION>
<FUNCTION>
<NAME>pango_font_get_glyph_extents</NAME>
<RETURNS>void</RETURNS>
PangoFont        *font, PangoGlyph        glyph, PangoRectangle   *ink_rect, PangoRectangle   *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_font_get_font_map</NAME>
<RETURNS>PangoFontMap *</RETURNS>
PangoFont        *font
</FUNCTION>
<FUNCTION>
<NAME>pango_font_get_face</NAME>
<RETURNS>PangoFontFace *</RETURNS>
PangoFont        *font
</FUNCTION>
<FUNCTION>
<NAME>pango_font_has_char</NAME>
<RETURNS>gboolean</RETURNS>
PangoFont        *font, gunichar          wc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_get_features</NAME>
<RETURNS>void</RETURNS>
PangoFont        *font, hb_feature_t     *features, guint             len, guint            *num_features
</FUNCTION>
<FUNCTION>
<NAME>pango_font_get_hb_font</NAME>
<RETURNS>hb_font_t *</RETURNS>
PangoFont        *font
</FUNCTION>
<MACRO>
<NAME>PANGO_GLYPH_EMPTY</NAME>
#define PANGO_GLYPH_EMPTY           ((PangoGlyph)0x0FFFFFFF)
</MACRO>
<MACRO>
<NAME>PANGO_GLYPH_INVALID_INPUT</NAME>
#define PANGO_GLYPH_INVALID_INPUT   ((PangoGlyph)0xFFFFFFFF)
</MACRO>
<MACRO>
<NAME>PANGO_GLYPH_UNKNOWN_FLAG</NAME>
#define PANGO_GLYPH_UNKNOWN_FLAG    ((PangoGlyph)0x10000000)
</MACRO>
<MACRO>
<NAME>PANGO_GET_UNKNOWN_GLYPH</NAME>
#define PANGO_GET_UNKNOWN_GLYPH(wc) ((PangoGlyph)(wc)|PANGO_GLYPH_UNKNOWN_FLAG)
</MACRO>
<MACRO>
<NAME>PANGO_UNKNOWN_GLYPH_WIDTH</NAME>
<DEPRECATED/>
#define PANGO_UNKNOWN_GLYPH_WIDTH  10
</MACRO>
<MACRO>
<NAME>PANGO_UNKNOWN_GLYPH_HEIGHT</NAME>
<DEPRECATED/>
#define PANGO_UNKNOWN_GLYPH_HEIGHT 14
</MACRO>
<STRUCT>
<NAME>PangoFontDescription</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_FONT_MAP</NAME>
#define PANGO_TYPE_FONT_MAP              (pango_font_map_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FONT_MAP</NAME>
#define PANGO_FONT_MAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_MAP, PangoFontMap))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT_MAP</NAME>
#define PANGO_IS_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_MAP))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_MAP_CLASS</NAME>
#define PANGO_FONT_MAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONT_MAP_CLASS</NAME>
#define PANGO_IS_FONT_MAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_MAP))
</MACRO>
<MACRO>
<NAME>PANGO_FONT_MAP_GET_CLASS</NAME>
#define PANGO_FONT_MAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
</MACRO>
<STRUCT>
<NAME>PangoFontMap</NAME>
struct _PangoFontMap
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoFontMapClass</NAME>
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;

  guint         (*get_serial)    (PangoFontMap               *fontmap);
  void          (*changed)       (PangoFontMap               *fontmap);

  PangoFontFamily * (*get_family) (PangoFontMap               *fontmap,
                                   const char                 *name);

  PangoFontFace *   (*get_face)   (PangoFontMap               *fontmap,
                                   PangoFont                  *font);
};
</STRUCT>
<FUNCTION>
<NAME>pango_font_map_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_font_map_create_context</NAME>
<RETURNS>PangoContext *</RETURNS>
PangoFontMap               *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_font_map_load_font</NAME>
<RETURNS>PangoFont *</RETURNS>
PangoFontMap                 *fontmap, PangoContext                 *context, const PangoFontDescription   *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_font_map_load_fontset</NAME>
<RETURNS>PangoFontset *</RETURNS>
PangoFontMap                 *fontmap, PangoContext                 *context, const PangoFontDescription   *desc, PangoLanguage                *language
</FUNCTION>
<FUNCTION>
<NAME>pango_font_map_list_families</NAME>
<RETURNS>void</RETURNS>
PangoFontMap                 *fontmap, PangoFontFamily            ***families, int                          *n_families
</FUNCTION>
<FUNCTION>
<NAME>pango_font_map_get_serial</NAME>
<RETURNS>guint</RETURNS>
PangoFontMap                 *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_font_map_changed</NAME>
<RETURNS>void</RETURNS>
PangoFontMap                 *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_font_map_get_family</NAME>
<RETURNS>PangoFontFamily *</RETURNS>
PangoFontMap                 *fontmap, const char                   *name
</FUNCTION>
<STRUCT>
<NAME>PangoContext</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_FONTSET</NAME>
#define PANGO_TYPE_FONTSET              (pango_fontset_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FONTSET</NAME>
#define PANGO_FONTSET(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONTSET, PangoFontset))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONTSET</NAME>
#define PANGO_IS_FONTSET(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONTSET))
</MACRO>
<MACRO>
<NAME>PANGO_FONTSET_CLASS</NAME>
#define PANGO_FONTSET_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONTSET, PangoFontsetClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONTSET_CLASS</NAME>
#define PANGO_IS_FONTSET_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONTSET))
</MACRO>
<MACRO>
<NAME>PANGO_FONTSET_GET_CLASS</NAME>
#define PANGO_FONTSET_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONTSET, PangoFontsetClass))
</MACRO>
<FUNCTION>
<NAME>pango_fontset_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>PangoFontsetForeachFunc</NAME>
<RETURNS>gboolean</RETURNS>
PangoFontset  *fontset, PangoFont     *font, gpointer       user_data
</USER_FUNCTION>
<STRUCT>
<NAME>PangoFontset</NAME>
struct _PangoFontset
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoFontsetClass</NAME>
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);
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_FONTSET_SIMPLE</NAME>
#define PANGO_TYPE_FONTSET_SIMPLE       (pango_fontset_simple_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FONTSET_SIMPLE</NAME>
#define PANGO_FONTSET_SIMPLE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONTSET_SIMPLE, PangoFontsetSimple))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FONTSET_SIMPLE</NAME>
#define PANGO_IS_FONTSET_SIMPLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONTSET_SIMPLE))
</MACRO>
<FUNCTION>
<NAME>pango_fontset_simple_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_fontset_simple_new</NAME>
<RETURNS>PangoFontsetSimple *</RETURNS>
PangoLanguage      *language
</FUNCTION>
<FUNCTION>
<NAME>pango_fontset_simple_append</NAME>
<RETURNS>void</RETURNS>
PangoFontsetSimple *fontset, PangoFont          *font
</FUNCTION>
<FUNCTION>
<NAME>pango_fontset_simple_size</NAME>
<RETURNS>int</RETURNS>
PangoFontsetSimple *fontset
</FUNCTION>
<FUNCTION>
<NAME>pango_fontset_get_font</NAME>
<RETURNS>PangoFont *</RETURNS>
PangoFontset           *fontset, guint                   wc
</FUNCTION>
<FUNCTION>
<NAME>pango_fontset_get_metrics</NAME>
<RETURNS>PangoFontMetrics *</RETURNS>
PangoFontset           *fontset
</FUNCTION>
<FUNCTION>
<NAME>pango_fontset_foreach</NAME>
<RETURNS>void</RETURNS>
PangoFontset           *fontset, PangoFontsetForeachFunc func, gpointer                data
</FUNCTION>
<STRUCT>
<NAME>PangoFontsetSimple</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoFontsetSimpleClass</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoGlyphItem</NAME>
struct _PangoGlyphItem
{
  PangoItem        *item;
  PangoGlyphString *glyphs;
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_GLYPH_ITEM</NAME>
#define PANGO_TYPE_GLYPH_ITEM (pango_glyph_item_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_glyph_item_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_split</NAME>
<RETURNS>PangoGlyphItem *</RETURNS>
PangoGlyphItem *orig, const char     *text, int             split_index
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_copy</NAME>
<RETURNS>PangoGlyphItem *</RETURNS>
PangoGlyphItem *orig
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_free</NAME>
<RETURNS>void</RETURNS>
PangoGlyphItem *glyph_item
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_apply_attrs</NAME>
<RETURNS>GSList *</RETURNS>
PangoGlyphItem *glyph_item, const char     *text, PangoAttrList  *list
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_letter_space</NAME>
<RETURNS>void</RETURNS>
PangoGlyphItem *glyph_item, const char     *text, PangoLogAttr   *log_attrs, int             letter_spacing
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_get_logical_widths</NAME>
<RETURNS>void</RETURNS>
PangoGlyphItem *glyph_item, const char     *text, int            *logical_widths
</FUNCTION>
<STRUCT>
<NAME>PangoGlyphItemIter</NAME>
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;
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_GLYPH_ITEM_ITER</NAME>
#define PANGO_TYPE_GLYPH_ITEM_ITER (pango_glyph_item_iter_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_glyph_item_iter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_iter_copy</NAME>
<RETURNS>PangoGlyphItemIter *</RETURNS>
PangoGlyphItemIter *orig
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_iter_free</NAME>
<RETURNS>void</RETURNS>
PangoGlyphItemIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_iter_init_start</NAME>
<RETURNS>gboolean</RETURNS>
PangoGlyphItemIter *iter, PangoGlyphItem     *glyph_item, const char         *text
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_iter_init_end</NAME>
<RETURNS>gboolean</RETURNS>
PangoGlyphItemIter *iter, PangoGlyphItem     *glyph_item, const char         *text
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_iter_next_cluster</NAME>
<RETURNS>gboolean</RETURNS>
PangoGlyphItemIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_item_iter_prev_cluster</NAME>
<RETURNS>gboolean</RETURNS>
PangoGlyphItemIter *iter
</FUNCTION>
<TYPEDEF>
<NAME>PangoGlyphUnit</NAME>
typedef gint32 PangoGlyphUnit;
</TYPEDEF>
<STRUCT>
<NAME>PangoGlyphGeometry</NAME>
struct _PangoGlyphGeometry
{
  PangoGlyphUnit width;
  PangoGlyphUnit x_offset;
  PangoGlyphUnit y_offset;
};
</STRUCT>
<STRUCT>
<NAME>PangoGlyphVisAttr</NAME>
struct _PangoGlyphVisAttr
{
  guint is_cluster_start : 1;
};
</STRUCT>
<STRUCT>
<NAME>PangoGlyphInfo</NAME>
struct _PangoGlyphInfo
{
  PangoGlyph    glyph;
  PangoGlyphGeometry geometry;
  PangoGlyphVisAttr  attr;
};
</STRUCT>
<STRUCT>
<NAME>PangoGlyphString</NAME>
struct _PangoGlyphString {
  gint num_glyphs;

  PangoGlyphInfo *glyphs;
  gint *log_clusters;

  /*< private >*/
  gint space;
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_GLYPH_STRING</NAME>
#define PANGO_TYPE_GLYPH_STRING (pango_glyph_string_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_glyph_string_new</NAME>
<RETURNS>PangoGlyphString *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_set_size</NAME>
<RETURNS>void</RETURNS>
PangoGlyphString *string, gint              new_len
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_copy</NAME>
<RETURNS>PangoGlyphString *</RETURNS>
PangoGlyphString *string
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_free</NAME>
<RETURNS>void</RETURNS>
PangoGlyphString *string
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_extents</NAME>
<RETURNS>void</RETURNS>
PangoGlyphString *glyphs, PangoFont        *font, PangoRectangle   *ink_rect, PangoRectangle   *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_get_width</NAME>
<RETURNS>int</RETURNS>
PangoGlyphString *glyphs
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_extents_range</NAME>
<RETURNS>void</RETURNS>
PangoGlyphString *glyphs, int               start, int               end, PangoFont        *font, PangoRectangle   *ink_rect, PangoRectangle   *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_get_logical_widths</NAME>
<RETURNS>void</RETURNS>
PangoGlyphString *glyphs, const char       *text, int               length, int               embedding_level, int              *logical_widths
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_index_to_x</NAME>
<RETURNS>void</RETURNS>
PangoGlyphString *glyphs, char             *text, int               length, PangoAnalysis    *analysis, int               index_, gboolean          trailing, int              *x_pos
</FUNCTION>
<FUNCTION>
<NAME>pango_glyph_string_x_to_index</NAME>
<RETURNS>void</RETURNS>
PangoGlyphString *glyphs, char             *text, int               length, PangoAnalysis    *analysis, int               x_pos, int              *index_, int              *trailing
</FUNCTION>
<FUNCTION>
<NAME>pango_shape</NAME>
<RETURNS>void</RETURNS>
const char          *text, int                  length, const PangoAnalysis *analysis, PangoGlyphString    *glyphs
</FUNCTION>
<FUNCTION>
<NAME>pango_shape_full</NAME>
<RETURNS>void</RETURNS>
const char          *item_text, int                  item_length, const char          *paragraph_text, int                  paragraph_length, const PangoAnalysis *analysis, PangoGlyphString    *glyphs
</FUNCTION>
<ENUM>
<NAME>PangoShapeFlags</NAME>
typedef enum {
  PANGO_SHAPE_NONE            = 0,
  PANGO_SHAPE_ROUND_POSITIONS = 1 << 0,
} PangoShapeFlags;
</ENUM>
<FUNCTION>
<NAME>pango_shape_with_flags</NAME>
<RETURNS>void</RETURNS>
const char          *item_text, int                  item_length, const char          *paragraph_text, int                  paragraph_length, const PangoAnalysis *analysis, PangoGlyphString    *glyphs, PangoShapeFlags      flags
</FUNCTION>
<FUNCTION>
<NAME>pango_reorder_items</NAME>
<RETURNS>GList *</RETURNS>
GList *logical_items
</FUNCTION>
<ENUM>
<NAME>PangoGravity</NAME>
typedef enum {
  PANGO_GRAVITY_SOUTH,
  PANGO_GRAVITY_EAST,
  PANGO_GRAVITY_NORTH,
  PANGO_GRAVITY_WEST,
  PANGO_GRAVITY_AUTO
} PangoGravity;
</ENUM>
<ENUM>
<NAME>PangoGravityHint</NAME>
typedef enum {
  PANGO_GRAVITY_HINT_NATURAL,
  PANGO_GRAVITY_HINT_STRONG,
  PANGO_GRAVITY_HINT_LINE
} PangoGravityHint;
</ENUM>
<MACRO>
<NAME>PANGO_GRAVITY_IS_VERTICAL</NAME>
#define PANGO_GRAVITY_IS_VERTICAL(gravity) \
	((gravity) == PANGO_GRAVITY_EAST || (gravity) == PANGO_GRAVITY_WEST)
</MACRO>
<MACRO>
<NAME>PANGO_GRAVITY_IS_IMPROPER</NAME>
#define PANGO_GRAVITY_IS_IMPROPER(gravity) \
	((gravity) == PANGO_GRAVITY_WEST || (gravity) == PANGO_GRAVITY_NORTH)
</MACRO>
<FUNCTION>
<NAME>pango_gravity_to_rotation</NAME>
<RETURNS>double</RETURNS>
PangoGravity       gravity
</FUNCTION>
<FUNCTION>
<NAME>pango_gravity_get_for_matrix</NAME>
<RETURNS>PangoGravity</RETURNS>
const PangoMatrix *matrix
</FUNCTION>
<FUNCTION>
<NAME>pango_gravity_get_for_script</NAME>
<RETURNS>PangoGravity</RETURNS>
PangoScript        script, PangoGravity       base_gravity, PangoGravityHint   hint
</FUNCTION>
<FUNCTION>
<NAME>pango_gravity_get_for_script_and_width</NAME>
<RETURNS>PangoGravity</RETURNS>
PangoScript        script, gboolean           wide, PangoGravity       base_gravity, PangoGravityHint   hint
</FUNCTION>
<MACRO>
<NAME>PANGO_ANALYSIS_FLAG_CENTERED_BASELINE</NAME>
#define PANGO_ANALYSIS_FLAG_CENTERED_BASELINE (1 << 0)
</MACRO>
<MACRO>
<NAME>PANGO_ANALYSIS_FLAG_IS_ELLIPSIS</NAME>
#define PANGO_ANALYSIS_FLAG_IS_ELLIPSIS (1 << 1)
</MACRO>
<MACRO>
<NAME>PANGO_ANALYSIS_FLAG_NEED_HYPHEN</NAME>
#define PANGO_ANALYSIS_FLAG_NEED_HYPHEN (1 << 2)
</MACRO>
<STRUCT>
<NAME>PangoAnalysis</NAME>
struct _PangoAnalysis
{
  PangoEngineShape *shape_engine;
  PangoEngineLang  *lang_engine;
  PangoFont *font;

  guint8 level;
  guint8 gravity;
  guint8 flags;

  guint8 script;
  PangoLanguage *language;

  GSList *extra_attrs;
};
</STRUCT>
<STRUCT>
<NAME>PangoItem</NAME>
struct _PangoItem
{
  gint offset;
  gint length;
  gint num_chars;
  PangoAnalysis analysis;
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_ITEM</NAME>
#define PANGO_TYPE_ITEM (pango_item_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_item_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_item_new</NAME>
<RETURNS>PangoItem *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_item_copy</NAME>
<RETURNS>PangoItem *</RETURNS>
PangoItem  *item
</FUNCTION>
<FUNCTION>
<NAME>pango_item_free</NAME>
<RETURNS>void</RETURNS>
PangoItem  *item
</FUNCTION>
<FUNCTION>
<NAME>pango_item_split</NAME>
<RETURNS>PangoItem *</RETURNS>
PangoItem  *orig, int         split_index, int         split_offset
</FUNCTION>
<FUNCTION>
<NAME>pango_item_apply_attrs</NAME>
<RETURNS>void</RETURNS>
PangoItem         *item, PangoAttrIterator *iter
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_LANGUAGE</NAME>
#define PANGO_TYPE_LANGUAGE (pango_language_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_language_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_language_from_string</NAME>
<RETURNS>PangoLanguage *</RETURNS>
const char *language
</FUNCTION>
<FUNCTION>
<NAME>pango_language_to_string</NAME>
<RETURNS>const char *</RETURNS>
PangoLanguage *language
</FUNCTION>
<FUNCTION>
<NAME>pango_language_get_sample_string</NAME>
<RETURNS>const char *</RETURNS>
PangoLanguage *language
</FUNCTION>
<FUNCTION>
<NAME>pango_language_get_default</NAME>
<RETURNS>PangoLanguage *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_language_matches</NAME>
<RETURNS>gboolean</RETURNS>
PangoLanguage *language, const char *range_list
</FUNCTION>
<FUNCTION>
<NAME>pango_language_includes_script</NAME>
<RETURNS>gboolean</RETURNS>
PangoLanguage *language, PangoScript    script
</FUNCTION>
<FUNCTION>
<NAME>pango_language_get_scripts</NAME>
<RETURNS>const PangoScript *</RETURNS>
PangoLanguage *language, int           *num_scripts
</FUNCTION>
<STRUCT>
<NAME>PangoLanguage</NAME>
</STRUCT>
<TYPEDEF>
<NAME>PangoLayoutRun</NAME>
typedef PangoGlyphItem PangoLayoutRun;
</TYPEDEF>
<ENUM>
<NAME>PangoAlignment</NAME>
typedef enum {
  PANGO_ALIGN_LEFT,
  PANGO_ALIGN_CENTER,
  PANGO_ALIGN_RIGHT
} PangoAlignment;
</ENUM>
<ENUM>
<NAME>PangoWrapMode</NAME>
typedef enum {
  PANGO_WRAP_WORD,
  PANGO_WRAP_CHAR,
  PANGO_WRAP_WORD_CHAR
} PangoWrapMode;
</ENUM>
<ENUM>
<NAME>PangoEllipsizeMode</NAME>
typedef enum {
  PANGO_ELLIPSIZE_NONE,
  PANGO_ELLIPSIZE_START,
  PANGO_ELLIPSIZE_MIDDLE,
  PANGO_ELLIPSIZE_END
} PangoEllipsizeMode;
</ENUM>
<STRUCT>
<NAME>PangoLayoutLine</NAME>
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 */
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_LAYOUT</NAME>
#define PANGO_TYPE_LAYOUT              (pango_layout_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_LAYOUT</NAME>
#define PANGO_LAYOUT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_LAYOUT, PangoLayout))
</MACRO>
<MACRO>
<NAME>PANGO_LAYOUT_CLASS</NAME>
#define PANGO_LAYOUT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_LAYOUT, PangoLayoutClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_LAYOUT</NAME>
#define PANGO_IS_LAYOUT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_LAYOUT))
</MACRO>
<MACRO>
<NAME>PANGO_IS_LAYOUT_CLASS</NAME>
#define PANGO_IS_LAYOUT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_LAYOUT))
</MACRO>
<MACRO>
<NAME>PANGO_LAYOUT_GET_CLASS</NAME>
#define PANGO_LAYOUT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_LAYOUT, PangoLayoutClass))
</MACRO>
<FUNCTION>
<NAME>pango_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_new</NAME>
<RETURNS>PangoLayout *</RETURNS>
PangoContext   *context
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_copy</NAME>
<RETURNS>PangoLayout *</RETURNS>
PangoLayout    *src
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_context</NAME>
<RETURNS>PangoContext *</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_attributes</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, PangoAttrList  *attrs
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_attributes</NAME>
<RETURNS>PangoAttrList *</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_text</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, const char     *text, int             length
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_text</NAME>
<RETURNS>const char *</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_character_count</NAME>
<RETURNS>gint</RETURNS>
PangoLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_markup</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, const char     *markup, int             length
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_markup_with_accel</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, const char     *markup, int             length, gunichar        accel_marker, gunichar       *accel_char
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_font_description</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, const PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_font_description</NAME>
<RETURNS>const PangoFontDescription *</RETURNS>
PangoLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_width</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, int                         width
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_width</NAME>
<RETURNS>int</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_height</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, int                         height
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_height</NAME>
<RETURNS>int</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_wrap</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, PangoWrapMode               wrap
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_wrap</NAME>
<RETURNS>PangoWrapMode</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_is_wrapped</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_indent</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, int                         indent
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_indent</NAME>
<RETURNS>int</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_spacing</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, int                         spacing
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_spacing</NAME>
<RETURNS>int</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_line_spacing</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, float                       factor
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_line_spacing</NAME>
<RETURNS>float</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_justify</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, gboolean                    justify
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_justify</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_auto_dir</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, gboolean                    auto_dir
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_auto_dir</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_alignment</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, PangoAlignment              alignment
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_alignment</NAME>
<RETURNS>PangoAlignment</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_tabs</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, PangoTabArray              *tabs
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_tabs</NAME>
<RETURNS>PangoTabArray *</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_single_paragraph_mode</NAME>
<RETURNS>void</RETURNS>
PangoLayout                *layout, gboolean                    setting
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_single_paragraph_mode</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayout                *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_set_ellipsize</NAME>
<RETURNS>void</RETURNS>
PangoLayout        *layout, PangoEllipsizeMode  ellipsize
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_ellipsize</NAME>
<RETURNS>PangoEllipsizeMode</RETURNS>
PangoLayout        *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_is_ellipsized</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayout        *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_unknown_glyphs_count</NAME>
<RETURNS>int</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_direction</NAME>
<RETURNS>PangoDirection</RETURNS>
PangoLayout *layout, int          index
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_context_changed</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_serial</NAME>
<RETURNS>guint</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_log_attrs</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, PangoLogAttr  **attrs, gint           *n_attrs
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_log_attrs_readonly</NAME>
<RETURNS>const PangoLogAttr *</RETURNS>
PangoLayout *layout, gint        *n_attrs
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_index_to_pos</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, int             index_, PangoRectangle *pos
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_index_to_line_x</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, int             index_, gboolean        trailing, int            *line, int            *x_pos
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_cursor_pos</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, int             index_, PangoRectangle *strong_pos, PangoRectangle *weak_pos
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_move_cursor_visually</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, gboolean        strong, int             old_index, int             old_trailing, int             direction, int            *new_index, int            *new_trailing
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_xy_to_index</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayout    *layout, int             x, int             y, int            *index_, int            *trailing
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, PangoRectangle *ink_rect, PangoRectangle *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_pixel_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, PangoRectangle *ink_rect, PangoRectangle *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_size</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, int            *width, int            *height
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_pixel_size</NAME>
<RETURNS>void</RETURNS>
PangoLayout    *layout, int            *width, int            *height
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_baseline</NAME>
<RETURNS>int</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_line_count</NAME>
<RETURNS>int</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_line</NAME>
<RETURNS>PangoLayoutLine *</RETURNS>
PangoLayout    *layout, int             line
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_line_readonly</NAME>
<RETURNS>PangoLayoutLine *</RETURNS>
PangoLayout    *layout, int             line
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_lines</NAME>
<RETURNS>GSList *</RETURNS>
PangoLayout    *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_lines_readonly</NAME>
<RETURNS>GSList *</RETURNS>
PangoLayout    *layout
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_LAYOUT_LINE</NAME>
#define PANGO_TYPE_LAYOUT_LINE (pango_layout_line_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_layout_line_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_ref</NAME>
<RETURNS>PangoLayoutLine *</RETURNS>
PangoLayoutLine *line
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_unref</NAME>
<RETURNS>void</RETURNS>
PangoLayoutLine *line
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_x_to_index</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayoutLine  *line, int               x_pos, int              *index_, int              *trailing
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_index_to_x</NAME>
<RETURNS>void</RETURNS>
PangoLayoutLine  *line, int               index_, gboolean          trailing, int              *x_pos
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_get_x_ranges</NAME>
<RETURNS>void</RETURNS>
PangoLayoutLine  *line, int               start_index, int               end_index, int             **ranges, int              *n_ranges
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_get_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayoutLine  *line, PangoRectangle   *ink_rect, PangoRectangle   *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_get_height</NAME>
<RETURNS>void</RETURNS>
PangoLayoutLine  *line, int              *height
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_line_get_pixel_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayoutLine *layout_line, PangoRectangle  *ink_rect, PangoRectangle  *logical_rect
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_LAYOUT_ITER</NAME>
#define PANGO_TYPE_LAYOUT_ITER         (pango_layout_iter_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_layout_iter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_get_iter</NAME>
<RETURNS>PangoLayoutIter *</RETURNS>
PangoLayout     *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_copy</NAME>
<RETURNS>PangoLayoutIter *</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_free</NAME>
<RETURNS>void</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_index</NAME>
<RETURNS>int</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_run</NAME>
<RETURNS>PangoLayoutRun *</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_run_readonly</NAME>
<RETURNS>PangoLayoutRun *</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_line</NAME>
<RETURNS>PangoLayoutLine *</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_line_readonly</NAME>
<RETURNS>PangoLayoutLine *</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_at_last_line</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_next_char</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_next_cluster</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_next_run</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_next_line</NAME>
<RETURNS>gboolean</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_char_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayoutIter *iter, PangoRectangle  *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_cluster_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayoutIter *iter, PangoRectangle  *ink_rect, PangoRectangle  *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_run_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayoutIter *iter, PangoRectangle  *ink_rect, PangoRectangle  *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_line_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayoutIter *iter, PangoRectangle  *ink_rect, PangoRectangle  *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_line_yrange</NAME>
<RETURNS>void</RETURNS>
PangoLayoutIter *iter, int             *y0_, int             *y1_
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_layout_extents</NAME>
<RETURNS>void</RETURNS>
PangoLayoutIter *iter, PangoRectangle  *ink_rect, PangoRectangle  *logical_rect
</FUNCTION>
<FUNCTION>
<NAME>pango_layout_iter_get_baseline</NAME>
<RETURNS>int</RETURNS>
PangoLayoutIter *iter
</FUNCTION>
<STRUCT>
<NAME>PangoLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoLayoutClass</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoLayoutIter</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoMatrix</NAME>
struct _PangoMatrix
{
  double xx;
  double xy;
  double yx;
  double yy;
  double x0;
  double y0;
};
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_MATRIX</NAME>
#define PANGO_TYPE_MATRIX (pango_matrix_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_MATRIX_INIT</NAME>
#define PANGO_MATRIX_INIT { 1., 0., 0., 1., 0., 0. }
</MACRO>
<FUNCTION>
<NAME>pango_matrix_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_copy</NAME>
<RETURNS>PangoMatrix *</RETURNS>
const PangoMatrix *matrix
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_free</NAME>
<RETURNS>void</RETURNS>
PangoMatrix *matrix
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_translate</NAME>
<RETURNS>void</RETURNS>
PangoMatrix *matrix, double       tx, double       ty
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_scale</NAME>
<RETURNS>void</RETURNS>
PangoMatrix *matrix, double       scale_x, double       scale_y
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_rotate</NAME>
<RETURNS>void</RETURNS>
PangoMatrix *matrix, double       degrees
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_concat</NAME>
<RETURNS>void</RETURNS>
PangoMatrix       *matrix, const PangoMatrix *new_matrix
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_transform_point</NAME>
<RETURNS>void</RETURNS>
const PangoMatrix *matrix, double            *x, double            *y
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_transform_distance</NAME>
<RETURNS>void</RETURNS>
const PangoMatrix *matrix, double            *dx, double            *dy
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_transform_rectangle</NAME>
<RETURNS>void</RETURNS>
const PangoMatrix *matrix, PangoRectangle    *rect
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_transform_pixel_rectangle</NAME>
<RETURNS>void</RETURNS>
const PangoMatrix *matrix, PangoRectangle    *rect
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_get_font_scale_factor</NAME>
<RETURNS>double</RETURNS>
const PangoMatrix *matrix
</FUNCTION>
<FUNCTION>
<NAME>pango_matrix_get_font_scale_factors</NAME>
<RETURNS>void</RETURNS>
const PangoMatrix *matrix, double *xscale, double *yscale
</FUNCTION>
<STRUCT>
<NAME>PangoIncludedModule</NAME>
<DEPRECATED/>
struct _PangoIncludedModule
{
  void (*list) (PangoEngineInfo **engines,
		int              *n_engines);
  void (*init) (GTypeModule      *module);
  void (*exit) (void);
  PangoEngine *(*create) (const char       *id);
};
</STRUCT>
<FUNCTION>
<NAME>pango_find_map</NAME>
<DEPRECATED/>
<RETURNS>PangoMap *</RETURNS>
PangoLanguage       *language, guint                engine_type_id, guint                render_type_id
</FUNCTION>
<FUNCTION>
<NAME>pango_map_get_engine</NAME>
<DEPRECATED/>
<RETURNS>PangoEngine *</RETURNS>
PangoMap            *map, PangoScript          script
</FUNCTION>
<FUNCTION>
<NAME>pango_map_get_engines</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoMap            *map, PangoScript          script, GSList             **exact_engines, GSList             **fallback_engines
</FUNCTION>
<FUNCTION>
<NAME>pango_module_register</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoIncludedModule *module
</FUNCTION>
<STRUCT>
<NAME>PangoMap</NAME>
<DEPRECATED/>
</STRUCT>
<STRUCT>
<NAME>PangoMapEntry</NAME>
<DEPRECATED/>
</STRUCT>
<TYPEDEF>
<NAME>PangoOTTag</NAME>
<DEPRECATED/>
typedef guint32 PangoOTTag;
</TYPEDEF>
<MACRO>
<NAME>PANGO_OT_TAG_MAKE</NAME>
<DEPRECATED/>
#define PANGO_OT_TAG_MAKE(c1,c2,c3,c4)		((PangoOTTag) FT_MAKE_TAG (c1, c2, c3, c4))
</MACRO>
<MACRO>
<NAME>PANGO_OT_TAG_MAKE_FROM_STRING</NAME>
<DEPRECATED/>
#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]))
</MACRO>
<ENUM>
<NAME>PangoOTTableType</NAME>
<DEPRECATED/>
typedef enum
{
  PANGO_OT_TABLE_GSUB,
  PANGO_OT_TABLE_GPOS
} PangoOTTableType;
</ENUM>
<MACRO>
<NAME>PANGO_OT_ALL_GLYPHS</NAME>
<DEPRECATED/>
#define PANGO_OT_ALL_GLYPHS			((guint) 0xFFFF)
</MACRO>
<MACRO>
<NAME>PANGO_OT_NO_FEATURE</NAME>
<DEPRECATED/>
#define PANGO_OT_NO_FEATURE			((guint) 0xFFFF)
</MACRO>
<MACRO>
<NAME>PANGO_OT_NO_SCRIPT</NAME>
<DEPRECATED/>
#define PANGO_OT_NO_SCRIPT			((guint) 0xFFFF)
</MACRO>
<MACRO>
<NAME>PANGO_OT_DEFAULT_LANGUAGE</NAME>
<DEPRECATED/>
#define PANGO_OT_DEFAULT_LANGUAGE		((guint) 0xFFFF)
</MACRO>
<MACRO>
<NAME>PANGO_OT_TAG_DEFAULT_SCRIPT</NAME>
<DEPRECATED/>
#define PANGO_OT_TAG_DEFAULT_SCRIPT		PANGO_OT_TAG_MAKE ('D', 'F', 'L', 'T')
</MACRO>
<MACRO>
<NAME>PANGO_OT_TAG_DEFAULT_LANGUAGE</NAME>
<DEPRECATED/>
#define PANGO_OT_TAG_DEFAULT_LANGUAGE		PANGO_OT_TAG_MAKE ('d', 'f', 'l', 't')
</MACRO>
<STRUCT>
<NAME>PangoOTGlyph</NAME>
<DEPRECATED/>
struct _PangoOTGlyph
{
  guint32  glyph;
  guint    properties;
  guint    cluster;
  gushort  component;
  gushort  ligID;

  guint    internal;
};
</STRUCT>
<STRUCT>
<NAME>PangoOTFeatureMap</NAME>
<DEPRECATED/>
struct _PangoOTFeatureMap
{
  char     feature_name[5];
  gulong   property_bit;
};
</STRUCT>
<STRUCT>
<NAME>PangoOTRulesetDescription</NAME>
<DEPRECATED/>
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;
};
</STRUCT>
<MACRO>
<NAME>PANGO_OT_TYPE_INFO</NAME>
<DEPRECATED/>
#define PANGO_OT_TYPE_INFO              (pango_ot_info_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_OT_INFO</NAME>
<DEPRECATED/>
#define PANGO_OT_INFO(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_OT_TYPE_INFO, PangoOTInfo))
</MACRO>
<MACRO>
<NAME>PANGO_OT_IS_INFO</NAME>
<DEPRECATED/>
#define PANGO_OT_IS_INFO(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_OT_TYPE_INFO))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_OT_INFO</NAME>
<DEPRECATED/>
#define PANGO_TYPE_OT_INFO              (pango_ot_info_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_IS_OT_INFO</NAME>
<DEPRECATED/>
#define PANGO_IS_OT_INFO(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_OT_INFO))
</MACRO>
<FUNCTION>
<NAME>pango_ot_info_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_OT_TYPE_RULESET</NAME>
<DEPRECATED/>
#define PANGO_OT_TYPE_RULESET           (pango_ot_ruleset_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_OT_RULESET</NAME>
<DEPRECATED/>
#define PANGO_OT_RULESET(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_OT_TYPE_RULESET, PangoOTRuleset))
</MACRO>
<MACRO>
<NAME>PANGO_OT_IS_RULESET</NAME>
<DEPRECATED/>
#define PANGO_OT_IS_RULESET(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_OT_TYPE_RULESET))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_OT_RULESET</NAME>
<DEPRECATED/>
#define PANGO_TYPE_OT_RULESET           (pango_ot_ruleset_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_IS_OT_RULESET</NAME>
<DEPRECATED/>
#define PANGO_IS_OT_RULESET(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_OT_RULESET))
</MACRO>
<FUNCTION>
<NAME>pango_ot_ruleset_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_info_get</NAME>
<DEPRECATED/>
<RETURNS>PangoOTInfo *</RETURNS>
FT_Face face
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_info_find_script</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
PangoOTInfo      *info, PangoOTTableType  table_type, PangoOTTag        script_tag, guint            *script_index
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_info_find_language</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
PangoOTInfo      *info, PangoOTTableType  table_type, guint             script_index, PangoOTTag        language_tag, guint            *language_index, guint            *required_feature_index
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_info_find_feature</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
PangoOTInfo      *info, PangoOTTableType  table_type, PangoOTTag        feature_tag, guint             script_index, guint             language_index, guint            *feature_index
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_info_list_scripts</NAME>
<DEPRECATED/>
<RETURNS>PangoOTTag *</RETURNS>
PangoOTInfo      *info, PangoOTTableType  table_type
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_info_list_languages</NAME>
<DEPRECATED/>
<RETURNS>PangoOTTag *</RETURNS>
PangoOTInfo      *info, PangoOTTableType  table_type, guint             script_index, PangoOTTag        language_tag
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_info_list_features</NAME>
<DEPRECATED/>
<RETURNS>PangoOTTag *</RETURNS>
PangoOTInfo      *info, PangoOTTableType  table_type, PangoOTTag        tag, guint             script_index, guint             language_index
</FUNCTION>
<MACRO>
<NAME>PANGO_OT_TYPE_BUFFER</NAME>
<DEPRECATED/>
#define PANGO_OT_TYPE_BUFFER (pango_ot_buffer_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_OT_BUFFER</NAME>
<DEPRECATED/>
#define PANGO_TYPE_OT_BUFFER (pango_ot_buffer_get_type())
</MACRO>
<FUNCTION>
<NAME>pango_ot_buffer_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_new</NAME>
<DEPRECATED/>
<RETURNS>PangoOTBuffer *</RETURNS>
PangoFcFont       *font
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_destroy</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoOTBuffer     *buffer
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_clear</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoOTBuffer     *buffer
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_set_rtl</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoOTBuffer     *buffer, gboolean           rtl
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_add_glyph</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoOTBuffer     *buffer, guint              glyph, guint              properties, guint              cluster
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_get_glyphs</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
const PangoOTBuffer  *buffer, PangoOTGlyph        **glyphs, int                  *n_glyphs
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_output</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
const PangoOTBuffer  *buffer, PangoGlyphString     *glyphs
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_buffer_set_zero_width_marks</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoOTBuffer     *buffer, gboolean           zero_width_marks
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_get_for_description</NAME>
<DEPRECATED/>
<RETURNS>const PangoOTRuleset *</RETURNS>
PangoOTInfo                     *info, const PangoOTRulesetDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_new</NAME>
<DEPRECATED/>
<RETURNS>PangoOTRuleset *</RETURNS>
PangoOTInfo       *info
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_new_for</NAME>
<DEPRECATED/>
<RETURNS>PangoOTRuleset *</RETURNS>
PangoOTInfo       *info, PangoScript        script, PangoLanguage     *language
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_new_from_description</NAME>
<DEPRECATED/>
<RETURNS>PangoOTRuleset *</RETURNS>
PangoOTInfo                     *info, const PangoOTRulesetDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_add_feature</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoOTRuleset   *ruleset, PangoOTTableType  table_type, guint             feature_index, gulong            property_bit
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_maybe_add_feature</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
PangoOTRuleset   *ruleset, PangoOTTableType  table_type, PangoOTTag        feature_tag, gulong            property_bit
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_maybe_add_features</NAME>
<DEPRECATED/>
<RETURNS>guint</RETURNS>
PangoOTRuleset          *ruleset, PangoOTTableType         table_type, const PangoOTFeatureMap *features, guint                    n_features
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_get_feature_count</NAME>
<DEPRECATED/>
<RETURNS>guint</RETURNS>
const PangoOTRuleset   *ruleset, guint                  *n_gsub_features, guint                  *n_gpos_features
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_substitute</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
const PangoOTRuleset   *ruleset, PangoOTBuffer          *buffer
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_position</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
const PangoOTRuleset   *ruleset, PangoOTBuffer          *buffer
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_tag_to_script</NAME>
<DEPRECATED/>
<RETURNS>PangoScript</RETURNS>
PangoOTTag     script_tag
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_tag_from_script</NAME>
<DEPRECATED/>
<RETURNS>PangoOTTag</RETURNS>
PangoScript    script
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_tag_to_language</NAME>
<DEPRECATED/>
<RETURNS>PangoLanguage *</RETURNS>
PangoOTTag     language_tag
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_tag_from_language</NAME>
<DEPRECATED/>
<RETURNS>PangoOTTag</RETURNS>
PangoLanguage *language
</FUNCTION>
<MACRO>
<NAME>PANGO_OT_TYPE_RULESET_DESCRIPTION</NAME>
<DEPRECATED/>
#define PANGO_OT_TYPE_RULESET_DESCRIPTION (pango_ot_ruleset_description_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_OT_RULESET_DESCRIPTION</NAME>
<DEPRECATED/>
#define PANGO_TYPE_OT_RULESET_DESCRIPTION (pango_ot_ruleset_description_get_type())
</MACRO>
<FUNCTION>
<NAME>pango_ot_ruleset_description_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_description_hash</NAME>
<DEPRECATED/>
<RETURNS>guint</RETURNS>
const PangoOTRulesetDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_description_equal</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
const PangoOTRulesetDescription *desc1, const PangoOTRulesetDescription *desc2
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_description_copy</NAME>
<DEPRECATED/>
<RETURNS>PangoOTRulesetDescription *</RETURNS>
const PangoOTRulesetDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>pango_ot_ruleset_description_free</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoOTRulesetDescription       *desc
</FUNCTION>
<STRUCT>
<NAME>PangoOTBuffer</NAME>
<DEPRECATED/>
</STRUCT>
<STRUCT>
<NAME>PangoOTInfo</NAME>
<DEPRECATED/>
</STRUCT>
<STRUCT>
<NAME>PangoOTRuleset</NAME>
<DEPRECATED/>
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_RENDERER</NAME>
#define PANGO_TYPE_RENDERER            (pango_renderer_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_RENDERER</NAME>
#define PANGO_RENDERER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_RENDERER, PangoRenderer))
</MACRO>
<MACRO>
<NAME>PANGO_IS_RENDERER</NAME>
#define PANGO_IS_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_RENDERER))
</MACRO>
<MACRO>
<NAME>PANGO_RENDERER_CLASS</NAME>
#define PANGO_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_RENDERER, PangoRendererClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_RENDERER_CLASS</NAME>
#define PANGO_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_RENDERER))
</MACRO>
<MACRO>
<NAME>PANGO_RENDERER_GET_CLASS</NAME>
#define PANGO_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_RENDERER, PangoRendererClass))
</MACRO>
<ENUM>
<NAME>PangoRenderPart</NAME>
typedef enum
{
  PANGO_RENDER_PART_FOREGROUND,
  PANGO_RENDER_PART_BACKGROUND,
  PANGO_RENDER_PART_UNDERLINE,
  PANGO_RENDER_PART_STRIKETHROUGH,
  PANGO_RENDER_PART_OVERLINE
} PangoRenderPart;
</ENUM>
<STRUCT>
<NAME>PangoRenderer</NAME>
struct _PangoRenderer
{
  /*< private >*/
  GObject parent_instance;

  PangoUnderline underline;
  gboolean strikethrough;
  int active_count;

  /*< public >*/
  PangoMatrix *matrix;          /* May be NULL */

  /*< private >*/
  PangoRendererPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>PangoRendererClass</NAME>
struct _PangoRendererClass
{
  /*< private >*/
  GObjectClass parent_class;

  /* vtable - not signals */
  /*< public >*/

  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);
  void (*draw_shape)           (PangoRenderer    *renderer,
                                PangoAttrShape   *attr,
                                int               x,
                                int               y);

  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);

  void (*part_changed)         (PangoRenderer    *renderer,
                                PangoRenderPart   part);

  void (*begin)                (PangoRenderer    *renderer);
  void (*end)                  (PangoRenderer    *renderer);

  void (*prepare_run)          (PangoRenderer    *renderer,
                                PangoLayoutRun   *run);

  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);
};
</STRUCT>
<FUNCTION>
<NAME>pango_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_layout</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoLayout      *layout, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_layout_line</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoLayoutLine  *line, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_glyphs</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoFont        *font, PangoGlyphString *glyphs, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_glyph_item</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, const char       *text, PangoGlyphItem   *glyph_item, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_rectangle</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoRenderPart   part, int               x, int               y, int               width, int               height
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_error_underline</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, int               x, int               y, int               width, int               height
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_trapezoid</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoRenderPart   part, double            y1_, double            x11, double            x21, double            y2, double            x12, double            x22
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_draw_glyph</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoFont        *font, PangoGlyph        glyph, double            x, double            y
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_activate</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_deactivate</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_part_changed</NAME>
<RETURNS>void</RETURNS>
PangoRenderer   *renderer, PangoRenderPart  part
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_set_color</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoRenderPart   part, const PangoColor *color
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_get_color</NAME>
<RETURNS>PangoColor *</RETURNS>
PangoRenderer    *renderer, PangoRenderPart   part
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_set_alpha</NAME>
<RETURNS>void</RETURNS>
PangoRenderer    *renderer, PangoRenderPart   part, guint16           alpha
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_get_alpha</NAME>
<RETURNS>guint16</RETURNS>
PangoRenderer    *renderer, PangoRenderPart   part
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_set_matrix</NAME>
<RETURNS>void</RETURNS>
PangoRenderer     *renderer, const PangoMatrix *matrix
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_get_matrix</NAME>
<RETURNS>const PangoMatrix *</RETURNS>
PangoRenderer     *renderer
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_get_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
PangoRenderer     *renderer
</FUNCTION>
<FUNCTION>
<NAME>pango_renderer_get_layout_line</NAME>
<RETURNS>PangoLayoutLine *</RETURNS>
PangoRenderer     *renderer
</FUNCTION>
<STRUCT>
<NAME>PangoRendererPrivate</NAME>
</STRUCT>
<ENUM>
<NAME>PangoScript</NAME>
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 */

      /* Unicode-6.0 additions */
      PANGO_SCRIPT_BATAK,              /* Batk */
      PANGO_SCRIPT_BRAHMI,             /* Brah */
      PANGO_SCRIPT_MANDAIC,            /* Mand */

      /* Unicode-6.1 additions */
      PANGO_SCRIPT_CHAKMA,             /* Cakm */
      PANGO_SCRIPT_MEROITIC_CURSIVE,   /* Merc */
      PANGO_SCRIPT_MEROITIC_HIEROGLYPHS,/* Mero */
      PANGO_SCRIPT_MIAO,               /* Plrd */
      PANGO_SCRIPT_SHARADA,            /* Shrd */
      PANGO_SCRIPT_SORA_SOMPENG,       /* Sora */
      PANGO_SCRIPT_TAKRI,              /* Takr */

      /* Unicode 7.0 additions */
      PANGO_SCRIPT_BASSA_VAH,              /* Bass */
      PANGO_SCRIPT_CAUCASIAN_ALBANIAN,     /* Aghb */
      PANGO_SCRIPT_DUPLOYAN,               /* Dupl */
      PANGO_SCRIPT_ELBASAN,                /* Elba */
      PANGO_SCRIPT_GRANTHA,                /* Gran */
      PANGO_SCRIPT_KHOJKI,                 /* Khoj */
      PANGO_SCRIPT_KHUDAWADI,              /* Sind */
      PANGO_SCRIPT_LINEAR_A,               /* Lina */
      PANGO_SCRIPT_MAHAJANI,               /* Mahj */
      PANGO_SCRIPT_MANICHAEAN,             /* Manu */
      PANGO_SCRIPT_MENDE_KIKAKUI,          /* Mend */
      PANGO_SCRIPT_MODI,                   /* Modi */
      PANGO_SCRIPT_MRO,                    /* Mroo */
      PANGO_SCRIPT_NABATAEAN,              /* Nbat */
      PANGO_SCRIPT_OLD_NORTH_ARABIAN,      /* Narb */
      PANGO_SCRIPT_OLD_PERMIC,             /* Perm */
      PANGO_SCRIPT_PAHAWH_HMONG,           /* Hmng */
      PANGO_SCRIPT_PALMYRENE,              /* Palm */
      PANGO_SCRIPT_PAU_CIN_HAU,            /* Pauc */
      PANGO_SCRIPT_PSALTER_PAHLAVI,        /* Phlp */
      PANGO_SCRIPT_SIDDHAM,                /* Sidd */
      PANGO_SCRIPT_TIRHUTA,                /* Tirh */
      PANGO_SCRIPT_WARANG_CITI,            /* Wara */

      /* Unicode 8.0 additions */
      PANGO_SCRIPT_AHOM,                   /* Ahom */
      PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS,  /* Hluw */
      PANGO_SCRIPT_HATRAN,                 /* Hatr */
      PANGO_SCRIPT_MULTANI,                /* Mult */
      PANGO_SCRIPT_OLD_HUNGARIAN,          /* Hung */
      PANGO_SCRIPT_SIGNWRITING             /* Sgnw */
} PangoScript;
</ENUM>
<FUNCTION>
<NAME>pango_script_for_unichar</NAME>
<DEPRECATED/>
<RETURNS>PangoScript</RETURNS>
gunichar             ch
</FUNCTION>
<FUNCTION>
<NAME>pango_script_iter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_script_iter_new</NAME>
<RETURNS>PangoScriptIter *</RETURNS>
const char          *text, int                  length
</FUNCTION>
<FUNCTION>
<NAME>pango_script_iter_get_range</NAME>
<RETURNS>void</RETURNS>
PangoScriptIter     *iter, const char         **start, const char         **end, PangoScript         *script
</FUNCTION>
<FUNCTION>
<NAME>pango_script_iter_next</NAME>
<RETURNS>gboolean</RETURNS>
PangoScriptIter     *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_script_iter_free</NAME>
<RETURNS>void</RETURNS>
PangoScriptIter     *iter
</FUNCTION>
<FUNCTION>
<NAME>pango_script_get_sample_language</NAME>
<RETURNS>PangoLanguage *</RETURNS>
PangoScript    script
</FUNCTION>
<STRUCT>
<NAME>PangoScriptIter</NAME>
</STRUCT>
<ENUM>
<NAME>PangoTabAlign</NAME>
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;
</ENUM>
<MACRO>
<NAME>PANGO_TYPE_TAB_ARRAY</NAME>
#define PANGO_TYPE_TAB_ARRAY (pango_tab_array_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_tab_array_new</NAME>
<RETURNS>PangoTabArray *</RETURNS>
gint           initial_size, gboolean       positions_in_pixels
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_new_with_positions</NAME>
<RETURNS>PangoTabArray *</RETURNS>
gint           size, gboolean       positions_in_pixels, PangoTabAlign  first_alignment, gint           first_position, ...
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_copy</NAME>
<RETURNS>PangoTabArray *</RETURNS>
PangoTabArray *src
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_free</NAME>
<RETURNS>void</RETURNS>
PangoTabArray *tab_array
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_get_size</NAME>
<RETURNS>gint</RETURNS>
PangoTabArray *tab_array
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_resize</NAME>
<RETURNS>void</RETURNS>
PangoTabArray *tab_array, gint           new_size
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_set_tab</NAME>
<RETURNS>void</RETURNS>
PangoTabArray *tab_array, gint           tab_index, PangoTabAlign  alignment, gint           location
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_get_tab</NAME>
<RETURNS>void</RETURNS>
PangoTabArray *tab_array, gint           tab_index, PangoTabAlign *alignment, gint          *location
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_get_tabs</NAME>
<RETURNS>void</RETURNS>
PangoTabArray *tab_array, PangoTabAlign **alignments, gint          **locations
</FUNCTION>
<FUNCTION>
<NAME>pango_tab_array_get_positions_in_pixels</NAME>
<RETURNS>gboolean</RETURNS>
PangoTabArray *tab_array
</FUNCTION>
<STRUCT>
<NAME>PangoTabArray</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_TRACE_CURRENT_TIME</NAME>
#define PANGO_TRACE_CURRENT_TIME SYSPROF_CAPTURE_CURRENT_TIME
</MACRO>
<FUNCTION>
<NAME>pango_trace_mark</NAME>
<RETURNS>void</RETURNS>
gint64       begin_time, const gchar *name, const gchar *message_format, ...
</FUNCTION>
<MACRO>
<NAME>g_trace_mark</NAME>
#define g_trace_mark(b, n, m, ...)
</MACRO>
<TYPEDEF>
<NAME>PangoGlyph</NAME>
typedef guint32 PangoGlyph;
</TYPEDEF>
<MACRO>
<NAME>PANGO_SCALE</NAME>
#define PANGO_SCALE 1024
</MACRO>
<MACRO>
<NAME>PANGO_PIXELS</NAME>
#define PANGO_PIXELS(d) (((int)(d) + 512) >> 10)
</MACRO>
<MACRO>
<NAME>PANGO_PIXELS_FLOOR</NAME>
#define PANGO_PIXELS_FLOOR(d) (((int)(d)) >> 10)
</MACRO>
<MACRO>
<NAME>PANGO_PIXELS_CEIL</NAME>
#define PANGO_PIXELS_CEIL(d) (((int)(d) + 1023) >> 10)
</MACRO>
<MACRO>
<NAME>PANGO_UNITS_ROUND</NAME>
#define PANGO_UNITS_ROUND(d)				\
  (((d) + (PANGO_SCALE >> 1)) & ~(PANGO_SCALE - 1))
</MACRO>
<FUNCTION>
<NAME>pango_units_from_double</NAME>
<RETURNS>int</RETURNS>
double d
</FUNCTION>
<FUNCTION>
<NAME>pango_units_to_double</NAME>
<RETURNS>double</RETURNS>
int i
</FUNCTION>
<STRUCT>
<NAME>PangoRectangle</NAME>
struct _PangoRectangle
{
  int x;
  int y;
  int width;
  int height;
};
</STRUCT>
<MACRO>
<NAME>PANGO_ASCENT</NAME>
#define PANGO_ASCENT(rect) (-(rect).y)
</MACRO>
<MACRO>
<NAME>PANGO_DESCENT</NAME>
#define PANGO_DESCENT(rect) ((rect).y + (rect).height)
</MACRO>
<MACRO>
<NAME>PANGO_LBEARING</NAME>
#define PANGO_LBEARING(rect) ((rect).x)
</MACRO>
<MACRO>
<NAME>PANGO_RBEARING</NAME>
#define PANGO_RBEARING(rect) ((rect).x + (rect).width)
</MACRO>
<FUNCTION>
<NAME>pango_extents_to_pixels</NAME>
<RETURNS>void</RETURNS>
PangoRectangle *inclusive, PangoRectangle *nearest
</FUNCTION>
<STRUCT>
<NAME>PangoEngineLang</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoEngineShape</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoFont</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoFontMap</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoLogAttr</NAME>
</STRUCT>
<FUNCTION>
<NAME>pango_parse_flags</NAME>
<RETURNS>gboolean</RETURNS>
GType       type, const char *str, int        *value, char      **possible_values
</FUNCTION>
<FUNCTION>
<NAME>pango_split_file_list</NAME>
<DEPRECATED/>
<RETURNS>char **</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>pango_trim_string</NAME>
<DEPRECATED/>
<RETURNS>char *</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>pango_read_line</NAME>
<DEPRECATED/>
<RETURNS>gint</RETURNS>
FILE        *stream, GString     *str
</FUNCTION>
<FUNCTION>
<NAME>pango_skip_space</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
const char **pos
</FUNCTION>
<FUNCTION>
<NAME>pango_scan_word</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
const char **pos, GString     *out
</FUNCTION>
<FUNCTION>
<NAME>pango_scan_string</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
const char **pos, GString     *out
</FUNCTION>
<FUNCTION>
<NAME>pango_scan_int</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
const char **pos, int         *out
</FUNCTION>
<FUNCTION>
<NAME>pango_parse_enum</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
GType       type, const char *str, int        *value, gboolean    warn, char      **possible_values
</FUNCTION>
<FUNCTION>
<NAME>pango_parse_style</NAME>
<RETURNS>gboolean</RETURNS>
const char   *str, PangoStyle   *style, gboolean      warn
</FUNCTION>
<FUNCTION>
<NAME>pango_parse_variant</NAME>
<RETURNS>gboolean</RETURNS>
const char   *str, PangoVariant *variant, gboolean      warn
</FUNCTION>
<FUNCTION>
<NAME>pango_parse_weight</NAME>
<RETURNS>gboolean</RETURNS>
const char   *str, PangoWeight  *weight, gboolean      warn
</FUNCTION>
<FUNCTION>
<NAME>pango_parse_stretch</NAME>
<RETURNS>gboolean</RETURNS>
const char   *str, PangoStretch *stretch, gboolean      warn
</FUNCTION>
<FUNCTION>
<NAME>pango_quantize_line_geometry</NAME>
<RETURNS>void</RETURNS>
int *thickness, int *position
</FUNCTION>
<FUNCTION>
<NAME>pango_log2vis_get_embedding_levels</NAME>
<RETURNS>guint8 *</RETURNS>
const gchar    *text, int             length, PangoDirection *pbase_dir
</FUNCTION>
<FUNCTION>
<NAME>pango_is_zero_width</NAME>
<RETURNS>gboolean</RETURNS>
gunichar ch
</FUNCTION>
<MACRO>
<NAME>PANGO_VERSION_ENCODE</NAME>
#define PANGO_VERSION_ENCODE(major, minor, micro) (     \
	  ((major) * 10000)                             \
	+ ((minor) *   100)                             \
	+ ((micro) *     1))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION</NAME>
#define PANGO_VERSION PANGO_VERSION_ENCODE(     \
	PANGO_VERSION_MAJOR,                    \
	PANGO_VERSION_MINOR,                    \
	PANGO_VERSION_MICRO)
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_CHECK</NAME>
#define PANGO_VERSION_CHECK(major,minor,micro)    \
	(PANGO_VERSION >= PANGO_VERSION_ENCODE(major,minor,micro))
</MACRO>
<FUNCTION>
<NAME>pango_version</NAME>
<RETURNS>int</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_version_string</NAME>
<RETURNS>const char *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_version_check</NAME>
<RETURNS>const char *</RETURNS>
int required_major, int required_minor, int required_micro
</FUNCTION>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_ALL</NAME>
#define PANGO_AVAILABLE_IN_ALL                   _PANGO_EXTERN
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_2</NAME>
#define PANGO_VERSION_1_2        (G_ENCODE_VERSION (1, 2))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_4</NAME>
#define PANGO_VERSION_1_4        (G_ENCODE_VERSION (1, 4))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_6</NAME>
#define PANGO_VERSION_1_6        (G_ENCODE_VERSION (1, 6))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_8</NAME>
#define PANGO_VERSION_1_8        (G_ENCODE_VERSION (1, 8))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_10</NAME>
#define PANGO_VERSION_1_10       (G_ENCODE_VERSION (1, 10))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_12</NAME>
#define PANGO_VERSION_1_12       (G_ENCODE_VERSION (1, 12))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_14</NAME>
#define PANGO_VERSION_1_14       (G_ENCODE_VERSION (1, 14))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_16</NAME>
#define PANGO_VERSION_1_16       (G_ENCODE_VERSION (1, 16))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_18</NAME>
#define PANGO_VERSION_1_18       (G_ENCODE_VERSION (1, 18))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_20</NAME>
#define PANGO_VERSION_1_20       (G_ENCODE_VERSION (1, 20))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_22</NAME>
#define PANGO_VERSION_1_22       (G_ENCODE_VERSION (1, 22))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_24</NAME>
#define PANGO_VERSION_1_24       (G_ENCODE_VERSION (1, 24))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_26</NAME>
#define PANGO_VERSION_1_26       (G_ENCODE_VERSION (1, 26))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_28</NAME>
#define PANGO_VERSION_1_28       (G_ENCODE_VERSION (1, 28))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_30</NAME>
#define PANGO_VERSION_1_30       (G_ENCODE_VERSION (1, 30))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_32</NAME>
#define PANGO_VERSION_1_32       (G_ENCODE_VERSION (1, 32))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_34</NAME>
#define PANGO_VERSION_1_34       (G_ENCODE_VERSION (1, 34))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_36</NAME>
#define PANGO_VERSION_1_36       (G_ENCODE_VERSION (1, 36))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_38</NAME>
#define PANGO_VERSION_1_38       (G_ENCODE_VERSION (1, 38))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_40</NAME>
#define PANGO_VERSION_1_40       (G_ENCODE_VERSION (1, 40))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_42</NAME>
#define PANGO_VERSION_1_42       (G_ENCODE_VERSION (1, 42))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_44</NAME>
#define PANGO_VERSION_1_44       (G_ENCODE_VERSION (1, 44))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_1_46</NAME>
#define PANGO_VERSION_1_46       (G_ENCODE_VERSION (1, 46))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_CUR_STABLE</NAME>
#define PANGO_VERSION_CUR_STABLE         (G_ENCODE_VERSION (PANGO_VERSION_MAJOR, PANGO_VERSION_MINOR + 1))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_PREV_STABLE</NAME>
#define PANGO_VERSION_PREV_STABLE        (G_ENCODE_VERSION (PANGO_VERSION_MAJOR, PANGO_VERSION_MINOR - 1))
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_MIN_REQUIRED</NAME>
# define PANGO_VERSION_MIN_REQUIRED      (PANGO_VERSION_CUR_STABLE)
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_MAX_ALLOWED</NAME>
# define PANGO_VERSION_MAX_ALLOWED      (PANGO_VERSION_CUR_STABLE)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED</NAME>
# define PANGO_DEPRECATED                       _PANGO_EXTERN
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_FOR</NAME>
# define PANGO_DEPRECATED_FOR(f)                _PANGO_EXTERN
</MACRO>
<MACRO>
<NAME>PANGO_UNAVAILABLE</NAME>
# define PANGO_UNAVAILABLE(maj,min)             _PANGO_EXTERN
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_2</NAME>
# define PANGO_DEPRECATED_IN_1_2                PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_2_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_2_FOR(f)         PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_2</NAME>
# define PANGO_AVAILABLE_IN_1_2                 PANGO_UNAVAILABLE(1, 2)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_4</NAME>
# define PANGO_DEPRECATED_IN_1_4                PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_4_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_4_FOR(f)         PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_4</NAME>
# define PANGO_AVAILABLE_IN_1_4                 PANGO_UNAVAILABLE(1, 4)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_6</NAME>
# define PANGO_DEPRECATED_IN_1_6                PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_6_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_6_FOR(f)         PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_6</NAME>
# define PANGO_AVAILABLE_IN_1_6                 PANGO_UNAVAILABLE(1, 6)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_8</NAME>
# define PANGO_DEPRECATED_IN_1_8                PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_8_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_8_FOR(f)         PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_8</NAME>
# define PANGO_AVAILABLE_IN_1_8                 PANGO_UNAVAILABLE(1, 8)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_10</NAME>
# define PANGO_DEPRECATED_IN_1_10               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_10_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_10_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_10</NAME>
# define PANGO_AVAILABLE_IN_1_10                PANGO_UNAVAILABLE(1, 10)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_12</NAME>
# define PANGO_AVAILABLE_IN_1_12                PANGO_UNAVAILABLE(1, 12)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_12</NAME>
# define PANGO_DEPRECATED_IN_1_12               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_12_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_12_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_14</NAME>
# define PANGO_AVAILABLE_IN_1_14                PANGO_UNAVAILABLE(1, 14)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_14</NAME>
# define PANGO_DEPRECATED_IN_1_14               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_14_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_14_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_16</NAME>
# define PANGO_AVAILABLE_IN_1_16                PANGO_UNAVAILABLE(1, 16)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_16</NAME>
# define PANGO_DEPRECATED_IN_1_16               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_16_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_16_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_18</NAME>
# define PANGO_DEPRECATED_IN_1_18               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_18_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_18_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_18</NAME>
# define PANGO_AVAILABLE_IN_1_18                PANGO_UNAVAILABLE(1, 18)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_20</NAME>
# define PANGO_DEPRECATED_IN_1_20               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_20_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_20_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_20</NAME>
# define PANGO_AVAILABLE_IN_1_20                PANGO_UNAVAILABLE(1, 20)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_22</NAME>
# define PANGO_DEPRECATED_IN_1_22               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_22_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_22_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_22</NAME>
# define PANGO_AVAILABLE_IN_1_22                PANGO_UNAVAILABLE(1, 22)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_24</NAME>
# define PANGO_DEPRECATED_IN_1_24               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_24_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_24_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_24</NAME>
# define PANGO_AVAILABLE_IN_1_24                PANGO_UNAVAILABLE(1, 24)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_26</NAME>
# define PANGO_DEPRECATED_IN_1_26               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_26_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_26_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_26</NAME>
# define PANGO_AVAILABLE_IN_1_26                PANGO_UNAVAILABLE(1, 26)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_28</NAME>
# define PANGO_DEPRECATED_IN_1_28               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_28_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_28_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_28</NAME>
# define PANGO_AVAILABLE_IN_1_28                PANGO_UNAVAILABLE(1, 28)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_30</NAME>
# define PANGO_DEPRECATED_IN_1_30               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_30_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_30_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_30</NAME>
# define PANGO_AVAILABLE_IN_1_30                PANGO_UNAVAILABLE(1, 30)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_32</NAME>
# define PANGO_DEPRECATED_IN_1_32               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_32_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_32_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_32</NAME>
# define PANGO_AVAILABLE_IN_1_32                PANGO_UNAVAILABLE(1, 32)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_34</NAME>
# define PANGO_DEPRECATED_IN_1_34               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_34_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_34_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_34</NAME>
# define PANGO_AVAILABLE_IN_1_34                PANGO_UNAVAILABLE(1, 34)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_36</NAME>
# define PANGO_DEPRECATED_IN_1_36               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_36_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_36_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_36</NAME>
# define PANGO_AVAILABLE_IN_1_36                PANGO_UNAVAILABLE(1, 36)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_38</NAME>
# define PANGO_DEPRECATED_IN_1_38               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_38_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_38_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_38</NAME>
# define PANGO_AVAILABLE_IN_1_38                PANGO_UNAVAILABLE(1, 38)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_40</NAME>
# define PANGO_DEPRECATED_IN_1_40               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_40_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_40_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_40</NAME>
# define PANGO_AVAILABLE_IN_1_40                PANGO_UNAVAILABLE(1, 40)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_42</NAME>
# define PANGO_DEPRECATED_IN_1_42               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_42_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_42_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_42</NAME>
# define PANGO_AVAILABLE_IN_1_42                PANGO_UNAVAILABLE(1, 42)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_44</NAME>
# define PANGO_DEPRECATED_IN_1_44               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_44_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_44_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_44</NAME>
# define PANGO_AVAILABLE_IN_1_44                PANGO_UNAVAILABLE(1, 44)
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_46</NAME>
# define PANGO_DEPRECATED_IN_1_46               PANGO_DEPRECATED
</MACRO>
<MACRO>
<NAME>PANGO_DEPRECATED_IN_1_46_FOR</NAME>
# define PANGO_DEPRECATED_IN_1_46_FOR(f)        PANGO_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>PANGO_AVAILABLE_IN_1_46</NAME>
# define PANGO_AVAILABLE_IN_1_46                PANGO_UNAVAILABLE(1, 46)
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_CAIRO_CORE_TEXT_FONT_MAP</NAME>
#define PANGO_TYPE_CAIRO_CORE_TEXT_FONT_MAP       (pango_cairo_core_text_font_map_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_CORE_TEXT_FONT_MAP</NAME>
#define PANGO_CAIRO_CORE_TEXT_FONT_MAP(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CAIRO_CORE_TEXT_FONT_MAP, PangoCairoCoreTextFontMap))
</MACRO>
<MACRO>
<NAME>PANGO_IS_CAIRO_CORE_TEXT_FONT_MAP</NAME>
#define PANGO_IS_CAIRO_CORE_TEXT_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CAIRO_CORE_TEXT_FONT_MAP))
</MACRO>
<STRUCT>
<NAME>PangoCairoCoreTextFontMap</NAME>
struct _PangoCairoCoreTextFontMap
{
  PangoCoreTextFontMap parent_instance;

  guint serial;
  gdouble dpi;
};
</STRUCT>
<FUNCTION>
<NAME>pango_cairo_core_text_font_map_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_CAIRO_CORE_TEXT_FONT</NAME>
#define PANGO_TYPE_CAIRO_CORE_TEXT_FONT            (pango_cairo_core_text_font_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_CORE_TEXT_FONT</NAME>
#define PANGO_CAIRO_CORE_TEXT_FONT(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CAIRO_CORE_TEXT_FONT, PangoCairoCoreTextFont))
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_CORE_TEXT_FONT_CLASS</NAME>
#define PANGO_CAIRO_CORE_TEXT_FONT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_CAIRO_CORE_TEXT_FONT, PangoCairoCoreTextFontClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_CAIRO_CORE_TEXT_FONT_CLASS</NAME>
#define PANGO_IS_CAIRO_CORE_TEXT_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_CAIRO_CORE_TEXT_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_CORE_TEXT_FONT_GET_CLASS</NAME>
#define PANGO_CAIRO_CORE_TEXT_FONT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_CAIRO_CORE_TEXT_FONT, PangoCairoCoreTextFontClass))
</MACRO>
<FUNCTION>
<NAME>pango_cairo_core_text_font_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PangoCairoCoreTextFont</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoCairoCoreTextFontClass</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_CAIRO_TYPE_FONT</NAME>
#define PANGO_CAIRO_TYPE_FONT           (pango_cairo_font_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_FONT</NAME>
#define PANGO_CAIRO_FONT(obj)           (G_TYPE_CHECK_INSTANCE_CAST ((obj), PANGO_CAIRO_TYPE_FONT, PangoCairoFont))
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_IS_FONT</NAME>
#define PANGO_CAIRO_IS_FONT(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PANGO_CAIRO_TYPE_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_CAIRO_FONT</NAME>
#define PANGO_TYPE_CAIRO_FONT           (pango_cairo_font_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_IS_CAIRO_FONT</NAME>
#define PANGO_IS_CAIRO_FONT(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CAIRO_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_TYPE_FONT_MAP</NAME>
#define PANGO_CAIRO_TYPE_FONT_MAP       (pango_cairo_font_map_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_FONT_MAP</NAME>
#define PANGO_CAIRO_FONT_MAP(obj)       (G_TYPE_CHECK_INSTANCE_CAST ((obj), PANGO_CAIRO_TYPE_FONT_MAP, PangoCairoFontMap))
</MACRO>
<MACRO>
<NAME>PANGO_CAIRO_IS_FONT_MAP</NAME>
#define PANGO_CAIRO_IS_FONT_MAP(obj)    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PANGO_CAIRO_TYPE_FONT_MAP))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_CAIRO_FONT_MAP</NAME>
#define PANGO_TYPE_CAIRO_FONT_MAP       (pango_cairo_font_map_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_IS_CAIRO_FONT_MAP</NAME>
#define PANGO_IS_CAIRO_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CAIRO_FONT_MAP))
</MACRO>
<USER_FUNCTION>
<NAME>PangoCairoShapeRendererFunc</NAME>
<RETURNS>void</RETURNS>
cairo_t        *cr, PangoAttrShape *attr, gboolean        do_path, gpointer        data
</USER_FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_new</NAME>
<RETURNS>PangoFontMap *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_new_for_font_type</NAME>
<RETURNS>PangoFontMap *</RETURNS>
cairo_font_type_t fonttype
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_get_default</NAME>
<RETURNS>PangoFontMap *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_set_default</NAME>
<RETURNS>void</RETURNS>
PangoCairoFontMap *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_get_font_type</NAME>
<RETURNS>cairo_font_type_t</RETURNS>
PangoCairoFontMap *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_set_resolution</NAME>
<RETURNS>void</RETURNS>
PangoCairoFontMap *fontmap, double             dpi
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_get_resolution</NAME>
<RETURNS>double</RETURNS>
PangoCairoFontMap *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_map_create_context</NAME>
<DEPRECATED/>
<RETURNS>PangoContext *</RETURNS>
PangoCairoFontMap *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_font_get_scaled_font</NAME>
<RETURNS>cairo_scaled_font_t *</RETURNS>
PangoCairoFont *font
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_update_context</NAME>
<RETURNS>void</RETURNS>
cairo_t      *cr, PangoContext *context
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_context_set_font_options</NAME>
<RETURNS>void</RETURNS>
PangoContext               *context, const cairo_font_options_t *options
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_context_get_font_options</NAME>
<RETURNS>const cairo_font_options_t *</RETURNS>
PangoContext               *context
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_context_set_resolution</NAME>
<RETURNS>void</RETURNS>
PangoContext       *context, double              dpi
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_context_get_resolution</NAME>
<RETURNS>double</RETURNS>
PangoContext       *context
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_context_set_shape_renderer</NAME>
<RETURNS>void</RETURNS>
PangoContext                *context, PangoCairoShapeRendererFunc  func, gpointer                     data, GDestroyNotify               dnotify
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_context_get_shape_renderer</NAME>
<RETURNS>PangoCairoShapeRendererFunc</RETURNS>
PangoContext                *context, gpointer                    *data
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_create_context</NAME>
<RETURNS>PangoContext *</RETURNS>
cairo_t   *cr
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_create_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
cairo_t     *cr
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_update_layout</NAME>
<RETURNS>void</RETURNS>
cairo_t     *cr, PangoLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_show_glyph_string</NAME>
<RETURNS>void</RETURNS>
cairo_t          *cr, PangoFont        *font, PangoGlyphString *glyphs
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_show_glyph_item</NAME>
<RETURNS>void</RETURNS>
cairo_t          *cr, const char       *text, PangoGlyphItem   *glyph_item
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_show_layout_line</NAME>
<RETURNS>void</RETURNS>
cairo_t          *cr, PangoLayoutLine  *line
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_show_layout</NAME>
<RETURNS>void</RETURNS>
cairo_t          *cr, PangoLayout      *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_show_error_underline</NAME>
<RETURNS>void</RETURNS>
cairo_t       *cr, double         x, double         y, double         width, double         height
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_glyph_string_path</NAME>
<RETURNS>void</RETURNS>
cairo_t          *cr, PangoFont        *font, PangoGlyphString *glyphs
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_layout_line_path</NAME>
<RETURNS>void</RETURNS>
cairo_t          *cr, PangoLayoutLine  *line
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_layout_path</NAME>
<RETURNS>void</RETURNS>
cairo_t          *cr, PangoLayout      *layout
</FUNCTION>
<FUNCTION>
<NAME>pango_cairo_error_underline_path</NAME>
<RETURNS>void</RETURNS>
cairo_t       *cr, double         x, double         y, double         width, double         height
</FUNCTION>
<STRUCT>
<NAME>PangoCairoFont</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoCairoFontMap</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_TYPE_CORE_TEXT_FONT</NAME>
#define PANGO_TYPE_CORE_TEXT_FONT       (pango_core_text_font_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_CORE_TEXT_FONT</NAME>
#define PANGO_CORE_TEXT_FONT(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CORE_TEXT_FONT, PangoCoreTextFont))
</MACRO>
<MACRO>
<NAME>PANGO_IS_CORE_TEXT_FONT</NAME>
#define PANGO_IS_CORE_TEXT_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CORE_TEXT_FONT))
</MACRO>
<FUNCTION>
<NAME>pango_core_text_font_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_core_text_font_get_ctfont</NAME>
<RETURNS>CTFontRef</RETURNS>
PangoCoreTextFont *font
</FUNCTION>
<STRUCT>
<NAME>PangoCoreTextFont</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoCoreTextFontClass</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_FC_TYPE_DECODER</NAME>
#define PANGO_FC_TYPE_DECODER                   (pango_fc_decoder_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_FC_DECODER</NAME>
#define PANGO_FC_DECODER(object)                (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_FC_TYPE_DECODER, PangoFcDecoder))
</MACRO>
<MACRO>
<NAME>PANGO_FC_IS_DECODER</NAME>
#define PANGO_FC_IS_DECODER(object)             (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_FC_TYPE_DECODER))
</MACRO>
<MACRO>
<NAME>PANGO_FC_DECODER_CLASS</NAME>
#define PANGO_FC_DECODER_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_FC_TYPE_DECODER, PangoFcDecoderClass))
</MACRO>
<MACRO>
<NAME>PANGO_FC_IS_DECODER_CLASS</NAME>
#define PANGO_FC_IS_DECODER_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_FC_TYPE_DECODER))
</MACRO>
<MACRO>
<NAME>PANGO_FC_DECODER_GET_CLASS</NAME>
#define PANGO_FC_DECODER_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_FC_TYPE_DECODER, PangoFcDecoderClass))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_FC_DECODER</NAME>
#define PANGO_TYPE_FC_DECODER                   (pango_fc_decoder_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_IS_FC_DECODER</NAME>
#define PANGO_IS_FC_DECODER(object)             (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_DECODER))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FC_DECODER_CLASS</NAME>
#define PANGO_IS_FC_DECODER_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_DECODER))
</MACRO>
<STRUCT>
<NAME>PangoFcDecoder</NAME>
struct _PangoFcDecoder
{
  /*< private >*/
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>PangoFcDecoderClass</NAME>
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);
};
</STRUCT>
<FUNCTION>
<NAME>pango_fc_decoder_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_decoder_get_charset</NAME>
<RETURNS>FcCharSet *</RETURNS>
PangoFcDecoder *decoder, PangoFcFont    *fcfont
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_decoder_get_glyph</NAME>
<RETURNS>PangoGlyph</RETURNS>
PangoFcDecoder *decoder, PangoFcFont    *fcfont, guint32         wc
</FUNCTION>
<MACRO>
<NAME>PANGO_RENDER_TYPE_FC</NAME>
#define PANGO_RENDER_TYPE_FC "PangoRenderFc"
</MACRO>
<MACRO>
<NAME>PANGO_FC_FONT_CLASS</NAME>
#define PANGO_FC_FONT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_FONT, PangoFcFontClass))
</MACRO>
<MACRO>
<NAME>PANGO_IS_FC_FONT_CLASS</NAME>
#define PANGO_IS_FC_FONT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_FC_FONT_GET_CLASS</NAME>
#define PANGO_FC_FONT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_FONT, PangoFcFontClass))
</MACRO>
<STRUCT>
<NAME>PangoFcFontClass</NAME>
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);
};
</STRUCT>
<MACRO>
<NAME>PANGO_FC_TYPE_FONT</NAME>
#define PANGO_FC_TYPE_FONT              (pango_fc_font_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FC_FONT</NAME>
#define PANGO_FC_FONT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_FC_TYPE_FONT, PangoFcFont))
</MACRO>
<MACRO>
<NAME>PANGO_FC_IS_FONT</NAME>
#define PANGO_FC_IS_FONT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_FC_TYPE_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_FC_FONT</NAME>
#define PANGO_TYPE_FC_FONT              (pango_fc_font_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_IS_FC_FONT</NAME>
#define PANGO_IS_FC_FONT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT))
</MACRO>
<STRUCT>
<NAME>PangoFcFont</NAME>
<DEPRECATED/>
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;
};
</STRUCT>
<FUNCTION>
<NAME>pango_fc_font_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_has_char</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
PangoFcFont      *font, gunichar          wc
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_get_glyph</NAME>
<RETURNS>guint</RETURNS>
PangoFcFont      *font, gunichar          wc
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_get_unknown_glyph</NAME>
<DEPRECATED/>
<RETURNS>PangoGlyph</RETURNS>
PangoFcFont      *font, gunichar          wc
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_kern_glyphs</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoFcFont      *font, PangoGlyphString *glyphs
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_lock_face</NAME>
<DEPRECATED/>
<RETURNS>FT_Face</RETURNS>
PangoFcFont      *font
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_unlock_face</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoFcFont      *font
</FUNCTION>
<STRUCT>
<NAME>PangoFcFontClass</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_FC_TYPE_FONT_MAP</NAME>
#define PANGO_FC_TYPE_FONT_MAP              (pango_fc_font_map_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FC_FONT_MAP</NAME>
#define PANGO_FC_FONT_MAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_FC_TYPE_FONT_MAP, PangoFcFontMap))
</MACRO>
<MACRO>
<NAME>PANGO_FC_IS_FONT_MAP</NAME>
#define PANGO_FC_IS_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_FC_TYPE_FONT_MAP))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_FC_FONT_MAP</NAME>
#define PANGO_TYPE_FC_FONT_MAP              (pango_fc_font_map_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_IS_FC_FONT_MAP</NAME>
#define PANGO_IS_FC_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT_MAP))
</MACRO>
<FUNCTION>
<NAME>pango_fc_font_map_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_cache_clear</NAME>
<RETURNS>void</RETURNS>
PangoFcFontMap *fcfontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_config_changed</NAME>
<RETURNS>void</RETURNS>
PangoFcFontMap *fcfontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_set_config</NAME>
<RETURNS>void</RETURNS>
PangoFcFontMap *fcfontmap, FcConfig       *fcconfig
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_get_config</NAME>
<RETURNS>FcConfig *</RETURNS>
PangoFcFontMap *fcfontmap
</FUNCTION>
<USER_FUNCTION>
<NAME>PangoFcDecoderFindFunc</NAME>
<RETURNS>PangoFcDecoder *</RETURNS>
FcPattern *pattern, gpointer   user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_add_decoder_find_func</NAME>
<RETURNS>void</RETURNS>
PangoFcFontMap        *fcfontmap, PangoFcDecoderFindFunc findfunc, gpointer               user_data, GDestroyNotify         dnotify
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_find_decoder</NAME>
<RETURNS>PangoFcDecoder *</RETURNS>
PangoFcFontMap *fcfontmap, FcPattern      *pattern
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_description_from_pattern</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
FcPattern *pattern, gboolean   include_size
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_create_context</NAME>
<DEPRECATED/>
<RETURNS>PangoContext *</RETURNS>
PangoFcFontMap *fcfontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_shutdown</NAME>
<RETURNS>void</RETURNS>
PangoFcFontMap *fcfontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_fc_font_map_get_hb_face</NAME>
<RETURNS>hb_face_t *</RETURNS>
PangoFcFontMap *fcfontmap, PangoFcFont    *fcfont
</FUNCTION>
<MACRO>
<NAME>PANGO_FC_GRAVITY</NAME>
#define PANGO_FC_GRAVITY "pangogravity"
</MACRO>
<MACRO>
<NAME>PANGO_FC_VERSION</NAME>
#define PANGO_FC_VERSION "pangoversion"
</MACRO>
<MACRO>
<NAME>PANGO_FC_PRGNAME</NAME>
#define PANGO_FC_PRGNAME "prgname"
</MACRO>
<MACRO>
<NAME>PANGO_FC_FONT_FEATURES</NAME>
#define PANGO_FC_FONT_FEATURES "fontfeatures"
</MACRO>
<MACRO>
<NAME>PANGO_FC_FONT_VARIATIONS</NAME>
#define PANGO_FC_FONT_VARIATIONS "fontvariations"
</MACRO>
<STRUCT>
<NAME>PangoFcFontMap</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoFcFontMapClass</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoFcFontMapPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_RENDER_TYPE_FT2</NAME>
<DEPRECATED/>
#define PANGO_RENDER_TYPE_FT2 "PangoRenderFT2"
</MACRO>
<MACRO>
<NAME>PANGO_FT2_TYPE_FONT_MAP</NAME>
#define PANGO_FT2_TYPE_FONT_MAP              (pango_ft2_font_map_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_FT2_FONT_MAP</NAME>
#define PANGO_FT2_FONT_MAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_FT2_TYPE_FONT_MAP, PangoFT2FontMap))
</MACRO>
<MACRO>
<NAME>PANGO_FT2_IS_FONT_MAP</NAME>
#define PANGO_FT2_IS_FONT_MAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_FT2_TYPE_FONT_MAP))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_FT2_FONT_MAP</NAME>
#define PANGO_TYPE_FT2_FONT_MAP              (pango_ft2_font_map_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>PangoFT2SubstituteFunc</NAME>
<RETURNS>void</RETURNS>
FcPattern *pattern, gpointer   data
</USER_FUNCTION>
<FUNCTION>
<NAME>pango_ft2_render</NAME>
<RETURNS>void</RETURNS>
FT_Bitmap         *bitmap, PangoFont         *font, PangoGlyphString  *glyphs, gint               x, gint               y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_render_transformed</NAME>
<RETURNS>void</RETURNS>
FT_Bitmap         *bitmap, const PangoMatrix *matrix, PangoFont         *font, PangoGlyphString  *glyphs, int                x, int                y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_render_layout_line</NAME>
<RETURNS>void</RETURNS>
FT_Bitmap        *bitmap, PangoLayoutLine  *line, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_render_layout_line_subpixel</NAME>
<RETURNS>void</RETURNS>
FT_Bitmap        *bitmap, PangoLayoutLine  *line, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_render_layout</NAME>
<RETURNS>void</RETURNS>
FT_Bitmap        *bitmap, PangoLayout      *layout, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_render_layout_subpixel</NAME>
<RETURNS>void</RETURNS>
FT_Bitmap        *bitmap, PangoLayout      *layout, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_map_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_map_new</NAME>
<RETURNS>PangoFontMap *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_map_set_resolution</NAME>
<RETURNS>void</RETURNS>
PangoFT2FontMap        *fontmap, double                  dpi_x, double                  dpi_y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_map_set_default_substitute</NAME>
<RETURNS>void</RETURNS>
PangoFT2FontMap        *fontmap, PangoFT2SubstituteFunc  func, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_map_substitute_changed</NAME>
<RETURNS>void</RETURNS>
PangoFT2FontMap         *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_map_create_context</NAME>
<DEPRECATED/>
<RETURNS>PangoContext *</RETURNS>
PangoFT2FontMap         *fontmap
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_get_context</NAME>
<DEPRECATED/>
<RETURNS>PangoContext *</RETURNS>
double dpi_x, double dpi_y
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_map_for_display</NAME>
<DEPRECATED/>
<RETURNS>PangoFontMap *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_shutdown_display</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_get_unknown_glyph</NAME>
<DEPRECATED/>
<RETURNS>PangoGlyph</RETURNS>
PangoFont       *font
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_get_kerning</NAME>
<DEPRECATED/>
<RETURNS>int</RETURNS>
PangoFont       *font, PangoGlyph       left, PangoGlyph       right
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_get_face</NAME>
<DEPRECATED/>
<RETURNS>FT_Face</RETURNS>
PangoFont       *font
</FUNCTION>
<FUNCTION>
<NAME>pango_ft2_font_get_coverage</NAME>
<DEPRECATED/>
<RETURNS>PangoCoverage *</RETURNS>
PangoFont       *font, PangoLanguage   *language
</FUNCTION>
<STRUCT>
<NAME>PangoFT2FontMap</NAME>
</STRUCT>
<FUNCTION>
<NAME>pango_hb_shape</NAME>
<RETURNS>void</RETURNS>
PangoFont           *font, const char          *item_text, unsigned int         item_length, const PangoAnalysis *analysis, PangoGlyphString    *glyphs, const char          *paragraph_text, unsigned int         paragraph_length
</FUNCTION>
<MACRO>
<NAME>STRICT</NAME>
#define STRICT
</MACRO>
<MACRO>
<NAME>PANGO_RENDER_TYPE_WIN32</NAME>
#define PANGO_RENDER_TYPE_WIN32 "PangoRenderWin32"
</MACRO>
<FUNCTION>
<NAME>pango_win32_get_context</NAME>
<DEPRECATED/>
<RETURNS>PangoContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_render</NAME>
<RETURNS>void</RETURNS>
HDC               hdc, PangoFont        *font, PangoGlyphString *glyphs, gint              x, gint              y
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_render_layout_line</NAME>
<RETURNS>void</RETURNS>
HDC               hdc, PangoLayoutLine  *line, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_render_layout</NAME>
<RETURNS>void</RETURNS>
HDC               hdc, PangoLayout      *layout, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_render_transformed</NAME>
<RETURNS>void</RETURNS>
HDC         hdc, const PangoMatrix *matrix, PangoFont         *font, PangoGlyphString  *glyphs, int                x, int                y
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_get_unknown_glyph</NAME>
<DEPRECATED/>
<RETURNS>PangoGlyph</RETURNS>
PangoFont        *font, gunichar          wc
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_get_glyph_index</NAME>
<DEPRECATED/>
<RETURNS>gint</RETURNS>
PangoFont        *font, gunichar          wc
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_get_dc</NAME>
<DEPRECATED/>
<RETURNS>HDC</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_get_debug_flag</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_select_font</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
PangoFont *font, HDC        hdc
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_done_font</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoFont *font
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_get_metrics_factor</NAME>
<DEPRECATED/>
<RETURNS>double</RETURNS>
PangoFont *font
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_cache_new</NAME>
<RETURNS>PangoWin32FontCache *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_cache_free</NAME>
<RETURNS>void</RETURNS>
PangoWin32FontCache *cache
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_cache_load</NAME>
<RETURNS>HFONT</RETURNS>
PangoWin32FontCache *cache, const LOGFONTA      *logfont
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_cache_loadw</NAME>
<RETURNS>HFONT</RETURNS>
PangoWin32FontCache *cache, const LOGFONTW      *logfont
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_cache_unload</NAME>
<RETURNS>void</RETURNS>
PangoWin32FontCache *cache, HFONT                hfont
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_map_for_display</NAME>
<RETURNS>PangoFontMap *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_shutdown_display</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_map_get_font_cache</NAME>
<RETURNS>PangoWin32FontCache *</RETURNS>
PangoFontMap       *font_map
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_logfont</NAME>
<RETURNS>LOGFONTA *</RETURNS>
PangoFont          *font
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_logfontw</NAME>
<RETURNS>LOGFONTW *</RETURNS>
PangoFont          *font
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_description_from_logfont</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
const LOGFONTA *lfp
</FUNCTION>
<FUNCTION>
<NAME>pango_win32_font_description_from_logfontw</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
const LOGFONTW *lfp
</FUNCTION>
<STRUCT>
<NAME>PangoWin32FontCache</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_XFT_TYPE_RENDERER</NAME>
#define PANGO_XFT_TYPE_RENDERER            (pango_xft_renderer_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_XFT_RENDERER</NAME>
#define PANGO_XFT_RENDERER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_XFT_TYPE_RENDERER, PangoXftRenderer))
</MACRO>
<MACRO>
<NAME>PANGO_XFT_IS_RENDERER</NAME>
#define PANGO_XFT_IS_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_XFT_TYPE_RENDERER))
</MACRO>
<MACRO>
<NAME>PANGO_XFT_RENDERER_CLASS</NAME>
#define PANGO_XFT_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_XFT_TYPE_RENDERER, PangoXftRendererClass))
</MACRO>
<MACRO>
<NAME>PANGO_XFT_IS_RENDERER_CLASS</NAME>
#define PANGO_XFT_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_XFT_TYPE_RENDERER))
</MACRO>
<MACRO>
<NAME>PANGO_XFT_RENDERER_GET_CLASS</NAME>
#define PANGO_XFT_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_XFT_TYPE_RENDERER, PangoXftRendererClass))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_XFT_RENDERER</NAME>
#define PANGO_TYPE_XFT_RENDERER            (pango_xft_renderer_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_IS_XFT_RENDERER</NAME>
#define PANGO_IS_XFT_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_RENDERER))
</MACRO>
<MACRO>
<NAME>PANGO_IS_XFT_RENDERER_CLASS</NAME>
#define PANGO_IS_XFT_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_XFT_RENDERER))
</MACRO>
<STRUCT>
<NAME>PangoXftRenderer</NAME>
struct _PangoXftRenderer
{
  /*< private >*/
  PangoRenderer parent_instance;

  Display *display;
  int screen;
  XftDraw *draw;

  PangoXftRendererPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>PangoXftRendererClass</NAME>
struct _PangoXftRendererClass
{
  /*< private >*/
  PangoRendererClass parent_class;

  /*< public >*/
  void (*composite_trapezoids) (PangoXftRenderer *xftrenderer,
				PangoRenderPart   part,
				XTrapezoid       *trapezoids,
				int               n_trapezoids);
  void (*composite_glyphs)     (PangoXftRenderer *xftrenderer,
				XftFont          *xft_font,
				XftGlyphSpec     *glyphs,
				int               n_glyphs);
};
</STRUCT>
<FUNCTION>
<NAME>pango_xft_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_renderer_new</NAME>
<RETURNS>PangoRenderer *</RETURNS>
Display          *display, int               screen
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_renderer_set_draw</NAME>
<RETURNS>void</RETURNS>
PangoXftRenderer *xftrenderer, XftDraw          *draw
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_renderer_set_default_color</NAME>
<RETURNS>void</RETURNS>
PangoXftRenderer *xftrenderer, PangoColor       *default_color
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_render</NAME>
<RETURNS>void</RETURNS>
XftDraw          *draw, XftColor         *color, PangoFont        *font, PangoGlyphString *glyphs, gint              x, gint              y
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_picture_render</NAME>
<RETURNS>void</RETURNS>
Display          *display, Picture           src_picture, Picture           dest_picture, PangoFont        *font, PangoGlyphString *glyphs, gint              x, gint              y
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_render_transformed</NAME>
<RETURNS>void</RETURNS>
XftDraw          *draw, XftColor         *color, PangoMatrix      *matrix, PangoFont        *font, PangoGlyphString *glyphs, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_render_layout_line</NAME>
<RETURNS>void</RETURNS>
XftDraw          *draw, XftColor         *color, PangoLayoutLine  *line, int               x, int               y
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_render_layout</NAME>
<RETURNS>void</RETURNS>
XftDraw          *draw, XftColor         *color, PangoLayout      *layout, int               x, int               y
</FUNCTION>
<STRUCT>
<NAME>PangoXftRendererPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>PANGO_RENDER_TYPE_XFT</NAME>
<DEPRECATED/>
#define PANGO_RENDER_TYPE_XFT "PangoRenderXft"
</MACRO>
<MACRO>
<NAME>PANGO_XFT_TYPE_FONT_MAP</NAME>
#define PANGO_XFT_TYPE_FONT_MAP         (pango_xft_font_map_get_type())
</MACRO>
<MACRO>
<NAME>PANGO_XFT_FONT_MAP</NAME>
#define PANGO_XFT_FONT_MAP(obj)         (G_TYPE_CHECK_INSTANCE_CAST ((obj), PANGO_XFT_TYPE_FONT_MAP, PangoXftFontMap))
</MACRO>
<MACRO>
<NAME>PANGO_XFT_IS_FONT_MAP</NAME>
#define PANGO_XFT_IS_FONT_MAP(obj)      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PANGO_XFT_TYPE_FONT_MAP))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_XFT_FONT_MAP</NAME>
#define PANGO_TYPE_XFT_FONT_MAP         (pango_xft_font_map_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>PangoXftSubstituteFunc</NAME>
<RETURNS>void</RETURNS>
FcPattern *pattern, gpointer   data
</USER_FUNCTION>
<FUNCTION>
<NAME>pango_xft_get_font_map</NAME>
<RETURNS>PangoFontMap *</RETURNS>
Display *display, int      screen
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_get_context</NAME>
<DEPRECATED/>
<RETURNS>PangoContext *</RETURNS>
Display *display, int      screen
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_shutdown_display</NAME>
<RETURNS>void</RETURNS>
Display *display, int      screen
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_set_default_substitute</NAME>
<RETURNS>void</RETURNS>
Display                *display, int                     screen, PangoXftSubstituteFunc  func, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_substitute_changed</NAME>
<RETURNS>void</RETURNS>
Display                *display, int                     screen
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_map_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_XFT_TYPE_FONT</NAME>
#define PANGO_XFT_TYPE_FONT              (pango_xft_font_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_XFT_FONT</NAME>
#define PANGO_XFT_FONT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_XFT_TYPE_FONT, PangoXftFont))
</MACRO>
<MACRO>
<NAME>PANGO_XFT_IS_FONT</NAME>
#define PANGO_XFT_IS_FONT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_XFT_TYPE_FONT))
</MACRO>
<MACRO>
<NAME>PANGO_TYPE_XFT_FONT</NAME>
#define PANGO_TYPE_XFT_FONT              (pango_xft_font_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_xft_font_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_get_font</NAME>
<DEPRECATED/>
<RETURNS>XftFont *</RETURNS>
PangoFont *font
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_get_display</NAME>
<DEPRECATED/>
<RETURNS>Display *</RETURNS>
PangoFont *font
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_lock_face</NAME>
<DEPRECATED/>
<RETURNS>FT_Face</RETURNS>
PangoFont *font
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_unlock_face</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
PangoFont *font
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_get_glyph</NAME>
<DEPRECATED/>
<RETURNS>guint</RETURNS>
PangoFont *font, gunichar   wc
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_has_char</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
PangoFont *font, gunichar   wc
</FUNCTION>
<FUNCTION>
<NAME>pango_xft_font_get_unknown_glyph</NAME>
<DEPRECATED/>
<RETURNS>PangoGlyph</RETURNS>
PangoFont *font, gunichar   wc
</FUNCTION>
<STRUCT>
<NAME>PangoXftFont</NAME>
</STRUCT>
<STRUCT>
<NAME>PangoXftFontMap</NAME>
</STRUCT>
<FUNCTION>
<NAME>pango_attr_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_ATTR_TYPE</NAME>
#define PANGO_TYPE_ATTR_TYPE (pango_attr_type_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_underline_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_UNDERLINE</NAME>
#define PANGO_TYPE_UNDERLINE (pango_underline_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_overline_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_OVERLINE</NAME>
#define PANGO_TYPE_OVERLINE (pango_overline_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_show_flags_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_SHOW_FLAGS</NAME>
#define PANGO_TYPE_SHOW_FLAGS (pango_show_flags_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_bidi_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_BIDI_TYPE</NAME>
#define PANGO_TYPE_BIDI_TYPE (pango_bidi_type_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_coverage_level_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_COVERAGE_LEVEL</NAME>
#define PANGO_TYPE_COVERAGE_LEVEL (pango_coverage_level_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_direction_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_DIRECTION</NAME>
#define PANGO_TYPE_DIRECTION (pango_direction_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_style_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_STYLE</NAME>
#define PANGO_TYPE_STYLE (pango_style_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_variant_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_VARIANT</NAME>
#define PANGO_TYPE_VARIANT (pango_variant_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_weight_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_WEIGHT</NAME>
#define PANGO_TYPE_WEIGHT (pango_weight_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_stretch_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_STRETCH</NAME>
#define PANGO_TYPE_STRETCH (pango_stretch_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_font_mask_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_FONT_MASK</NAME>
#define PANGO_TYPE_FONT_MASK (pango_font_mask_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_shape_flags_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_SHAPE_FLAGS</NAME>
#define PANGO_TYPE_SHAPE_FLAGS (pango_shape_flags_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_gravity_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_GRAVITY</NAME>
#define PANGO_TYPE_GRAVITY (pango_gravity_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_gravity_hint_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_GRAVITY_HINT</NAME>
#define PANGO_TYPE_GRAVITY_HINT (pango_gravity_hint_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_alignment_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_ALIGNMENT</NAME>
#define PANGO_TYPE_ALIGNMENT (pango_alignment_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_wrap_mode_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_WRAP_MODE</NAME>
#define PANGO_TYPE_WRAP_MODE (pango_wrap_mode_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_ellipsize_mode_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_ELLIPSIZE_MODE</NAME>
#define PANGO_TYPE_ELLIPSIZE_MODE (pango_ellipsize_mode_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_render_part_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_RENDER_PART</NAME>
#define PANGO_TYPE_RENDER_PART (pango_render_part_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_script_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_SCRIPT</NAME>
#define PANGO_TYPE_SCRIPT (pango_script_get_type ())
</MACRO>
<FUNCTION>
<NAME>pango_tab_align_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>PANGO_TYPE_TAB_ALIGN</NAME>
#define PANGO_TYPE_TAB_ALIGN (pango_tab_align_get_type ())
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_MAJOR</NAME>
#define PANGO_VERSION_MAJOR 1
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_MINOR</NAME>
#define PANGO_VERSION_MINOR 46
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_MICRO</NAME>
#define PANGO_VERSION_MICRO 1
</MACRO>
<MACRO>
<NAME>PANGO_VERSION_STRING</NAME>
#define PANGO_VERSION_STRING "1.46.1"
</MACRO>
