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