Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Imported existing code

Browse Source
This commit is contained in:
Hazim Gazov
2010-04-02 02:48:44 -03:00
parent 48fbc5ae91
commit 7a86d01598
13996 changed files with 2468699 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

233
libraries/i686-linux/include/pango-1.0/pango/pango-attributes.h Normal file
View File

@@ -0,0 +1,233 @@
/* 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);
/* Attributes */
typedef struct _PangoAttribute PangoAttribute;
typedef struct _PangoAttrClass PangoAttrClass;
typedef struct _PangoAttrString PangoAttrString;
typedef struct _PangoAttrLanguage PangoAttrLanguage;
typedef struct _PangoAttrInt PangoAttrInt;
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 */
} PangoAttrType;
typedef enum {
PANGO_UNDERLINE_NONE,
PANGO_UNDERLINE_SINGLE,
PANGO_UNDERLINE_DOUBLE,
PANGO_UNDERLINE_LOW,
PANGO_UNDERLINE_ERROR
} PangoUnderline;
struct _PangoAttribute
{
const PangoAttrClass *klass;
guint start_index; /* in bytes */
guint end_index; /* the character containing this byte is not included */
};
typedef gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute,
gpointer 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 _PangoAttrShape
{
PangoAttribute attr;
PangoRectangle ink_rect;
PangoRectangle logical_rect;
};
struct _PangoAttrFontDesc
{
PangoAttribute attr;
PangoFontDescription *desc;
};
PangoAttrType pango_attr_type_register (const gchar *name);
PangoAttribute * pango_attribute_copy (const PangoAttribute *attr);
void pango_attribute_destroy (PangoAttribute *attr);
gboolean pango_attribute_equal (const PangoAttribute *attr1,
const PangoAttribute *attr2);
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_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_strikethrough_new (gboolean strikethrough);
PangoAttribute *pango_attr_rise_new (int rise);
PangoAttribute *pango_attr_shape_new (const PangoRectangle *ink_rect,
const PangoRectangle *logical_rect);
PangoAttribute *pango_attr_scale_new (double scale_factor);
PangoAttribute *pango_attr_fallback_new (gboolean enable_fallback);
GType pango_attr_list_get_type (void) G_GNUC_CONST;
PangoAttrList * pango_attr_list_new (void);
void 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__ */

112
libraries/i686-linux/include/pango-1.0/pango/pango-break.h Normal file
View File

@@ -0,0 +1,112 @@
/* 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;
};
/* 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__ */

101
libraries/i686-linux/include/pango-1.0/pango/pango-context.h Normal file
View File

@@ -0,0 +1,101 @@
/* 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, mail otaylor@redhat.com
*/
GType pango_context_get_type (void) G_GNUC_CONST;
#ifdef PANGO_ENABLE_BACKEND
PangoContext *pango_context_new (void);
void pango_context_set_font_map (PangoContext *context,
PangoFontMap *font_map);
#endif /* PANGO_ENABLE_BACKEND */
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);
/* 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__ */

58
libraries/i686-linux/include/pango-1.0/pango/pango-coverage.h Normal file
View File

@@ -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__ */

371
libraries/i686-linux/include/pango-1.0/pango/pango-engine.h Normal file
View File

@@ -0,0 +1,371 @@
/* 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 */
#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 this is %NULL, pango_default_break() will be used.
*
* 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 handling 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 0, which is guaranteed never
* to render.
* @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,
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;
gchar *langs;
};
struct _PangoEngineInfo
{
gchar *id;
gchar *engine_type;
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) \
{ \
static 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, \
}; \
\
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 standaline,
* 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__ */

69
libraries/i686-linux/include/pango-1.0/pango/pango-enum-types.h Normal file
View File

@@ -0,0 +1,69 @@
/* Generated data (by glib-mkenums) */
#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-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-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())
/* 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())
/* enumerations from "pango-types.h" */
GType pango_direction_get_type (void);
#define PANGO_TYPE_DIRECTION (pango_direction_get_type())
G_END_DECLS
#endif /* __PANGO_ENUM_TYPES_H__ */
/* Generated data ends here */

351
libraries/i686-linux/include/pango-1.0/pango/pango-font.h Normal file
View File

@@ -0,0 +1,351 @@
/* 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_ULTRALIGHT = 200,
PANGO_WEIGHT_LIGHT = 300,
PANGO_WEIGHT_NORMAL = 400,
PANGO_WEIGHT_BOLD = 700,
PANGO_WEIGHT_ULTRABOLD = 800,
PANGO_WEIGHT_HEAVY = 900
} 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
} 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);
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);
gboolean pango_font_description_equal (const PangoFontDescription *desc1,
const PangoFontDescription *desc2);
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);
G_CONST_RETURN char *pango_font_description_get_family (const PangoFontDescription *desc);
void pango_font_description_set_style (PangoFontDescription *desc,
PangoStyle style);
PangoStyle pango_font_description_get_style (const PangoFontDescription *desc);
void pango_font_description_set_variant (PangoFontDescription *desc,
PangoVariant variant);
PangoVariant pango_font_description_get_variant (const PangoFontDescription *desc);
void pango_font_description_set_weight (PangoFontDescription *desc,
PangoWeight weight);
PangoWeight pango_font_description_get_weight (const PangoFontDescription *desc);
void pango_font_description_set_stretch (PangoFontDescription *desc,
PangoStretch stretch);
PangoStretch pango_font_description_get_stretch (const PangoFontDescription *desc);
void pango_font_description_set_size (PangoFontDescription *desc,
gint size);
gint pango_font_description_get_size (const PangoFontDescription *desc);
PangoFontMask pango_font_description_get_set_fields (const PangoFontDescription *desc);
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);
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);
PangoFontMetrics *pango_font_metrics_ref (PangoFontMetrics *metrics);
void pango_font_metrics_unref (PangoFontMetrics *metrics);
int pango_font_metrics_get_ascent (PangoFontMetrics *metrics);
int pango_font_metrics_get_descent (PangoFontMetrics *metrics);
int pango_font_metrics_get_approximate_char_width (PangoFontMetrics *metrics);
int pango_font_metrics_get_approximate_digit_width (PangoFontMetrics *metrics);
#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;
};
#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);
G_CONST_RETURN char *pango_font_family_get_name (PangoFontFamily *family);
gboolean pango_font_family_is_monospace (PangoFontFamily *family);
#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);
G_CONST_RETURN char *pango_font_face_get_face_name (PangoFontFace *face);
void pango_font_face_list_sizes (PangoFontFace *face,
int **sizes,
int *n_sizes);
#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);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved2) (void);
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);
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);
#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);
/*< 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 */
G_END_DECLS
#endif /* __PANGO_FONT_H__ */

96
libraries/i686-linux/include/pango-1.0/pango/pango-fontmap.h Normal file
View File

@@ -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;
typedef struct _PangoFontMap PangoFontMap;
GType pango_font_map_get_type (void) G_GNUC_CONST;
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__ */

127
libraries/i686-linux/include/pango-1.0/pango/pango-fontset.h Normal file
View File

@@ -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__ */

49
libraries/i686-linux/include/pango-1.0/pango/pango-glyph-item.h Normal file
View File

@@ -0,0 +1,49 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* 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-item.h>
#include <pango/pango-glyph.h>
G_BEGIN_DECLS
typedef struct _PangoGlyphItem PangoGlyphItem;
struct _PangoGlyphItem
{
PangoItem *item;
PangoGlyphString *glyphs;
};
PangoGlyphItem *pango_glyph_item_split (PangoGlyphItem *orig,
const char *text,
int split_index);
GSList * pango_glyph_item_apply_attrs (PangoGlyphItem *glyph_item,
const char *text,
PangoAttrList *list);
G_END_DECLS
#endif /* __PANGO_GLYPH_ITEM_H__ */

134
libraries/i686-linux/include/pango-1.0/pango/pango-glyph.h Normal file
View File

@@ -0,0 +1,134 @@
/* 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;
/* 1000ths 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);
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);
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,
PangoAnalysis *analysis,
PangoGlyphString *glyphs);
GList *pango_reorder_items (GList *logical_items);
G_END_DECLS
#endif /* __PANGO_GLYPH_H__ */

89
libraries/i686-linux/include/pango-1.0/pango/pango-indic.h Normal file
View File

@@ -0,0 +1,89 @@
/* Pango
* pango-indic.h: Library for Indic script rendering
*
* Copyright (C) 2000 SuSE Linux Ltd.
*
* Author: Robert Brady <rwb197@zepler.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Licence as published by the Free Software Foundation; either
* version 2 of the Licence, 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 Licence for more details.
*
* You should have received a copy of the GNU Library General Public
* Licence along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* This library is basically internal
*
* Don't use it, unless you are me, or are in contact with me,
* or like living dangerously.
*/
#ifndef __PANGO_INDIC_H__
#define __PANGO_INDIC_H__
#include <pango-glyph.h>
G_BEGIN_DECLS
#ifdef PANGO_ENABLE_ENGINE
#define PANGO_ZERO_WIDTH_NON_JOINER 0x200c
#define PANGO_ZERO_WIDTH_JOINER 0x200d
typedef struct _PangoIndicScript PangoIndicScript;
struct _PangoIndicScript {
/* Compulsory */
gchar *name;
/* Compulsory */
gboolean (*is_prefixing_vowel) (gunichar what);
/* Compulsory */
gboolean (*is_vowel_sign) (gunichar what);
/* Optional */
gunichar (*vowel_sign_to_matra) (gunichar what);
/* Optional */
gboolean (*is_vowel_half) (gunichar what);
/* Optional */
gboolean (*vowel_split) (gunichar what,
gunichar *prefix,
gunichar *suffix);
};
void pango_indic_shift_vowels (PangoIndicScript *script,
gunichar *chars,
gunichar *end);
void pango_indic_compact (PangoIndicScript *script,
int *num,
gunichar *chars,
int *cluster);
void pango_indic_convert_vowels (PangoIndicScript *script,
gboolean in_middle,
int *num,
gunichar *chars,
gboolean has_standalone_vowels);
void pango_indic_split_out_characters (PangoIndicScript *script,
const gchar *text,
int n_chars,
gunichar **wc,
int *n_glyph,
PangoGlyphString *glyphs);
#endif /* PANGO_ENABLE_ENGINE */
G_END_DECLS
#endif /* __PANGO_INDIC_H */

59
libraries/i686-linux/include/pango-1.0/pango/pango-item.h Normal file
View File

@@ -0,0 +1,59 @@
/* 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;
struct _PangoAnalysis
{
PangoEngineShape *shape_engine;
PangoEngineLang *lang_engine;
PangoFont *font;
guint8 level;
PangoLanguage *language;
GSList *extra_attrs;
};
struct _PangoItem
{
gint offset;
gint length;
gint num_chars;
PangoAnalysis analysis;
};
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__ */

236
libraries/i686-linux/include/pango-1.0/pango/pango-layout.h Normal file
View File

@@ -0,0 +1,236 @@
/* Pango
* pango-layout.h: Highlevel 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;
/* For backwards compatiblity */
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;
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 direction 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, mail otaylor@redhat.com
*/
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);
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);
void pango_layout_set_width (PangoLayout *layout,
int width);
int pango_layout_get_width (PangoLayout *layout);
void pango_layout_set_wrap (PangoLayout *layout,
PangoWrapMode wrap);
PangoWrapMode pango_layout_get_wrap (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_context_changed (PangoLayout *layout);
void pango_layout_get_log_attrs (PangoLayout *layout,
PangoLogAttr **attrs,
gint *n_attrs);
void pango_layout_index_to_pos (PangoLayout *layout,
int index_,
PangoRectangle *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_line_count (PangoLayout *layout);
PangoLayoutLine *pango_layout_get_line (PangoLayout *layout,
int line);
GSList * pango_layout_get_lines (PangoLayout *layout);
void 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;
PangoLayoutIter *pango_layout_get_iter (PangoLayout *layout);
void pango_layout_iter_free (PangoLayoutIter *iter);
int pango_layout_iter_get_index (PangoLayoutIter *iter);
PangoLayoutRun *pango_layout_iter_get_run (PangoLayoutIter *iter);
PangoLayoutLine *pango_layout_iter_get_line (PangoLayoutIter *iter);
gboolean pango_layout_iter_at_last_line (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__ */

60
libraries/i686-linux/include/pango-1.0/pango/pango-modules.h Normal file
View File

@@ -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__ */

120
libraries/i686-linux/include/pango-1.0/pango/pango-ot.h Normal file
View File

@@ -0,0 +1,120 @@
/* Pango
* pango-ot.h:
*
* 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_OT_H__
#define __PANGO_OT_H__
#include <pango/pangofc-font.h>
#include <pango/pango-glyph.h>
#include <pango/pango-font.h>
G_BEGIN_DECLS
#ifdef PANGO_ENABLE_ENGINE
typedef guint32 PangoOTTag;
typedef struct _PangoOTInfo PangoOTInfo;
typedef struct _PangoOTBuffer PangoOTBuffer;
typedef struct _PangoOTGlyph PangoOTGlyph;
typedef struct _PangoOTRuleset PangoOTRuleset;
typedef enum
{
PANGO_OT_TABLE_GSUB,
PANGO_OT_TABLE_GPOS
} PangoOTTableType;
/* Note that this much match OTLGlyphItem */
struct _PangoOTGlyph
{
guint glyph;
guint properties;
guint cluster;
gushort component;
gushort ligID;
};
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_index,
guint properties,
guint cluster);
void pango_ot_buffer_get_glyphs (PangoOTBuffer *buffer,
PangoOTGlyph **glyphs,
int *n_glyphs);
void pango_ot_buffer_output (PangoOTBuffer *buffer,
PangoGlyphString *glyphs);
void pango_ot_buffer_set_zero_width_marks (PangoOTBuffer *buffer,
gboolean zero_width_marks);
PangoOTRuleset *pango_ot_ruleset_new (PangoOTInfo *info);
void pango_ot_ruleset_add_feature (PangoOTRuleset *ruleset,
PangoOTTableType table_type,
guint feature_index,
gulong property_bit);
void pango_ot_ruleset_substitute (PangoOTRuleset *ruleset,
PangoOTBuffer *buffer);
void pango_ot_ruleset_position (PangoOTRuleset *ruleset,
PangoOTBuffer *buffer);
#endif /* PANGO_ENABLE_ENGINE */
G_END_DECLS
#endif /* __PANGO_OT_H__ */

117
libraries/i686-linux/include/pango-1.0/pango/pango-script.h Normal file
View File

@@ -0,0 +1,117 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* 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>
#include <pango/pango-types.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 */
} PangoScript;
PangoScript pango_script_for_unichar (gunichar ch);
PangoScriptIter *pango_script_iter_new (const char *text,
int length);
void pango_script_iter_get_range (PangoScriptIter *iter,
G_CONST_RETURN char **start,
G_CONST_RETURN char **end,
PangoScript *script);
gboolean pango_script_iter_next (PangoScriptIter *iter);
void pango_script_iter_free (PangoScriptIter *iter);
PangoLanguage *pango_script_get_sample_language (PangoScript script);
gboolean pango_language_includes_script (PangoLanguage *language,
PangoScript script);
G_END_DECLS
#endif /* __PANGO_SCRIPT_H__ */

76
libraries/i686-linux/include/pango-1.0/pango/pango-tabs.h Normal file
View File

@@ -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);
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__ */

127
libraries/i686-linux/include/pango-1.0/pango/pango-types.h Normal file
View File

@@ -0,0 +1,127 @@
/* 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 _PangoRectangle PangoRectangle;
/* Dummy typedef - internally it's a 'const char *' */
typedef struct _PangoLanguage PangoLanguage;
/* A index of a glyph into a font. Rendering system dependent
*/
typedef guint32 PangoGlyph;
/* A rectangle. Used to store logical and physical extents of glyphs,
* runs, strings, etc.
*/
struct _PangoRectangle
{
int x;
int y;
int width;
int height;
};
#define PANGO_SCALE 1024
#define PANGO_PIXELS(d) (((d) >= 0) ? \
((d) + PANGO_SCALE / 2) / PANGO_SCALE : \
((d) - PANGO_SCALE / 2) / PANGO_SCALE)
/* 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)
/**
* 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_direction() 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_log2vis_get_embedding_levels().
*
* 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 the Text module of the
* CSS3 spec for how vertical text is planned to be handled
* in a future version of Pango. The explanation of why
* %PANGO_DIRECTION_TTB_LTR is treated as %PANGO_DIRECTION_RTL
* can be found there as well.
**/
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;
#define PANGO_TYPE_LANGUAGE (pango_language_get_type ())
GType pango_language_get_type (void);
PangoLanguage *pango_language_from_string (const char *language);
#define pango_language_to_string(language) ((const char *)language)
gboolean pango_language_matches (PangoLanguage *language,
const char *range_list);
gboolean pango_get_mirror_char (gunichar ch,
gunichar *mirrored_ch);
PangoDirection pango_unichar_direction (gunichar ch);
PangoDirection pango_find_base_dir (const gchar *text,
gint length);
G_END_DECLS
#endif /* __PANGO_TYPES_H__ */

101
libraries/i686-linux/include/pango-1.0/pango/pango-utils.h Normal file
View File

@@ -0,0 +1,101 @@
/* 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 */
/* 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.
*/
G_CONST_RETURN char * pango_get_sysconf_subdirectory (void);
/* Ditto for LIBDIR/pango. On Win32, use the same Pango
* installation directory. This returned string should not be
* g_free'd either.
*/
G_CONST_RETURN char * pango_get_lib_subdirectory (void);
#endif /* PANGO_ENABLE_BACKEND */
/* A couple of routines from fribidi that we either wrap or
* provide ourselves.
*/
gboolean pango_log2vis_get_embedding_levels (gunichar *str,
int len,
PangoDirection *pbase_dir,
guint8 *embedding_level_list);
G_CONST_RETURN char *pango_language_get_sample_string (PangoLanguage *language);
G_END_DECLS
#endif /* __PANGO_UTILS_H__ */

39
libraries/i686-linux/include/pango-1.0/pango/pango.h Normal file
View File

@@ -0,0 +1,39 @@
/* 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-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-font.h>
#include <pango/pango-fontmap.h>
#include <pango/pango-glyph.h>
#include <pango/pango-item.h>
#include <pango/pango-layout.h>
#include <pango/pango-script.h>
#include <pango/pango-types.h>
#endif /* __PANGO_H__ */

143
libraries/i686-linux/include/pango-1.0/pango/pangofc-font.h Normal file
View File

@@ -0,0 +1,143 @@
/* 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:
*
* #PangoFcFontMap 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 */
PangoFontDescription *description;
GSList *metrics_by_lang;
};
/**
* 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.
* @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 */
FT_Face pango_fc_font_lock_face (PangoFcFont *font);
void pango_fc_font_unlock_face (PangoFcFont *font);
gboolean pango_fc_font_has_char (PangoFcFont *font,
gunichar wc);
guint pango_fc_font_get_glyph (PangoFcFont *font,
gunichar wc);
PangoGlyph pango_fc_font_get_unknown_glyph (PangoFcFont *font,
gunichar wc);
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_END_DECLS
#endif /* __PANGO_FC_FONT_H__ */

106
libraries/i686-linux/include/pango-1.0/pango/pangofc-fontmap.h Normal file
View File

@@ -0,0 +1,106 @@
/* 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-font.h>
G_BEGIN_DECLS
#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.
* @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()
*
* Class structure for #PangoFcFontMap.
**/
struct _PangoFcFontMapClass
{
/*< private >*/
PangoFontMapClass parent_class;
/*< public >*/
void (*default_substitute) (PangoFcFontMap *fontmap,
FcPattern *pattern);
PangoFcFont *(*new_font) (PangoFcFontMap *fontmap,
FcPattern *pattern);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
PangoContext * pango_fc_font_map_create_context (PangoFcFontMap *fcfontmap);
void pango_fc_font_map_cache_clear (PangoFcFontMap *fcfontmap);
void pango_fc_font_map_shutdown (PangoFcFontMap *fcfontmap);
#endif
GType pango_fc_font_map_get_type (void);
PangoFontDescription *pango_fc_font_description_from_pattern (FcPattern *pattern,
gboolean include_size);
G_END_DECLS
#endif /* __PANGO_FC_FONT_MAP_H__ */

100
libraries/i686-linux/include/pango-1.0/pango/pangoft2.h Normal file
View File

@@ -0,0 +1,100 @@
/* 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_layout_line (FT_Bitmap *bitmap,
PangoLayoutLine *line,
int x,
int y);
void pango_ft2_render_layout (FT_Bitmap *bitmap,
PangoLayout *layout,
int x,
int y);
GType pango_ft2_font_map_get_type (void);
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);
PangoContext *pango_ft2_font_map_create_context (PangoFT2FontMap *fontmap);
/* API for rendering modules
*/
#ifndef PANGO_DISABLE_DEPRECATED
PangoContext *pango_ft2_get_context (double dpi_x,
double dpi_y);
PangoFontMap *pango_ft2_font_map_for_display (void);
void pango_ft2_shutdown_display (void);
PangoGlyph pango_ft2_get_unknown_glyph (PangoFont *font);
int pango_ft2_font_get_kerning (PangoFont *font,
PangoGlyph left,
PangoGlyph right);
PangoCoverage *pango_ft2_font_get_coverage (PangoFont *font,
PangoLanguage *language);
#endif /* PANGO_DISABLE_DEPRECATED */
/* Temporarily undeprecated, will be deprecated in favour
* of pango_fc_font_lock_face() in 1.6
*/
FT_Face pango_ft2_font_get_face (PangoFont *font);
G_END_DECLS
#endif /* __PANGOFT2_H__ */

131
libraries/i686-linux/include/pango-1.0/pango/pangox.h Normal file
View File

@@ -0,0 +1,131 @@
/* Pango
* pangox.h:
*
* Copyright (C) 1999 Red Hat Software
* Copyright (C) 2000 SuSE Linux Ltd
*
* 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 __PANGOX_H__
#define __PANGOX_H__
#include <glib.h>
#include <pango/pango-layout.h>
G_BEGIN_DECLS
#include <X11/Xlib.h>
#ifndef PANGO_DISABLE_DEPRECATED
#define PANGO_RENDER_TYPE_X "PangoRenderX"
typedef GC (*PangoGetGCFunc) (PangoContext *context, PangoColor *color, GC base_gc);
typedef void (*PangoFreeGCFunc) (PangoContext *context, GC gc);
/* Calls for applications
*/
PangoContext * pango_x_get_context (Display *display);
void pango_x_context_set_funcs (PangoContext *context,
PangoGetGCFunc get_gc_func,
PangoFreeGCFunc free_gc_func);
PangoFont * pango_x_load_font (Display *display,
const gchar *spec);
void pango_x_render (Display *display,
Drawable d,
GC gc,
PangoFont *font,
PangoGlyphString *glyphs,
gint x,
gint y);
void pango_x_render_layout_line (Display *display,
Drawable drawable,
GC gc,
PangoLayoutLine *line,
int x,
int y);
void pango_x_render_layout (Display *display,
Drawable drawable,
GC gc,
PangoLayout *layout,
int x,
int y);
/* API for rendering modules
*/
typedef guint16 PangoXSubfont;
#define PANGO_X_MAKE_GLYPH(subfont,index_) ((subfont)<<16 | (index_))
#define PANGO_X_GLYPH_SUBFONT(glyph) ((glyph)>>16)
#define PANGO_X_GLYPH_INDEX(glyph) ((glyph) & 0xffff)
int pango_x_list_subfonts (PangoFont *font,
char **charsets,
int n_charsets,
PangoXSubfont **subfont_ids,
int **subfont_charsets);
gboolean pango_x_has_glyph (PangoFont *font,
PangoGlyph glyph);
PangoGlyph pango_x_get_unknown_glyph (PangoFont *font);
#ifdef PANGO_ENABLE_ENGINE
PangoGlyph pango_x_font_get_unknown_glyph (PangoFont *font,
gunichar wc);
#endif /* PANGO_ENABLE_ENGINE */
/* API for libraries that want to use PangoX mixed with classic X fonts.
*/
typedef struct _PangoXFontCache PangoXFontCache;
PangoXFontCache *pango_x_font_cache_new (Display *display);
void pango_x_font_cache_free (PangoXFontCache *cache);
XFontStruct * pango_x_font_cache_load (PangoXFontCache *cache,
const char *xlfd);
void pango_x_font_cache_unload (PangoXFontCache *cache,
XFontStruct *fs);
PangoFontMap * pango_x_font_map_for_display (Display *display);
void pango_x_shutdown_display (Display *display);
PangoXFontCache *pango_x_font_map_get_font_cache (PangoFontMap *font_map);
char *pango_x_font_subfont_xlfd (PangoFont *font,
PangoXSubfont subfont_id);
gboolean pango_x_find_first_subfont (PangoFont *font,
char **charsets,
int n_charsets,
PangoXSubfont *rfont);
void pango_x_fallback_shape (PangoFont *font,
PangoGlyphString *glyphs,
const char *text,
int n_chars);
gboolean pango_x_apply_ligatures (PangoFont *font,
PangoXSubfont subfont,
gunichar **glyphs,
int *n_glyphs,
int **clusters);
#endif /* PANGO_DISABLE_DEPRECATED */
G_END_DECLS
#endif /* __PANGOX_H__ */

104
libraries/i686-linux/include/pango-1.0/pango/pangoxft.h Normal file
View File

@@ -0,0 +1,104 @@
/* Pango
* pangox.h:
*
* Copyright (C) 1999 Red Hat Software
* Copyright (C) 2000 SuSE Linux Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGOXFT_H__
#define __PANGOXFT_H__
#include <pango/pango-context.h>
#include <pango/pango-ot.h>
#include <pango/pangofc-font.h>
G_BEGIN_DECLS
#define _XFT_NO_COMPAT
#define _XFTCOMPAT_H_
#include <X11/Xlib.h>
#include <X11/Xft/Xft.h>
#if defined(XftVersion) && XftVersion >= 20000
#else
#error "must have Xft version 2 or newer"
#endif
#ifndef PANGO_DISABLE_DEPRECATED
#define PANGO_RENDER_TYPE_XFT "PangoRenderXft"
#endif
typedef void (*PangoXftSubstituteFunc) (FcPattern *pattern,
gpointer data);
/* Calls for applications
*/
PangoFontMap *pango_xft_get_font_map (Display *display,
int screen);
PangoContext *pango_xft_get_context (Display *display,
int screen);
void pango_xft_shutdown_display (Display *display,
int screen);
void pango_xft_render (XftDraw *draw,
XftColor *color,
PangoFont *font,
PangoGlyphString *glyphs,
gint x,
gint y);
void pango_xft_picture_render (Display *display,
Picture src_picture,
Picture dest_picture,
PangoFont *font,
PangoGlyphString *glyphs,
gint x,
gint y);
void pango_xft_set_default_substitute (Display *display,
int screen,
PangoXftSubstituteFunc func,
gpointer data,
GDestroyNotify notify);
void pango_xft_substitute_changed (Display *display,
int screen);
#define PANGO_TYPE_XFT_FONT (pango_xft_font_get_type ())
#define PANGO_XFT_IS_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_FONT))
GType pango_xft_font_get_type (void);
/* For shape engines
*/
#ifdef PANGO_ENABLE_ENGINE
XftFont * pango_xft_font_get_font (PangoFont *font);
Display * pango_xft_font_get_display (PangoFont *font);
#ifndef PANGO_DISABLE_DEPRECATED
FT_Face pango_xft_font_lock_face (PangoFont *font);
void pango_xft_font_unlock_face (PangoFont *font);
guint pango_xft_font_get_glyph (PangoFont *font,
gunichar wc);
gboolean pango_xft_font_has_char (PangoFont *font,
gunichar wc);
PangoGlyph pango_xft_font_get_unknown_glyph (PangoFont *font,
gunichar wc);
#endif /* PANGO_DISABLE_DEPRECATED */
#endif /* PANGO_ENABLE_ENGINE */
G_END_DECLS
#endif /* __PANGOXFT_H__ */