--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/pangotypes.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,1706 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.pangotypes;
+
+public import dwt.internal.gtk.c.glibtypes;
+public import dwt.internal.gtk.c.gobjecttypes;
+
+/******************************************************************************
+
+******************************************************************************/
+
+///* The pango Basic Types */
+public alias void FcPattern;
+public alias void FcCharSet;
+//public alias void LOGFONT;
+//struct Display;
+//struct FT_Bitmap;
+struct FT_Face;
+//struct XftDraw;
+//struct XftColor;
+
+
+const int PANGO_SCALE = 1024;
+const double PANGO_SCALE_XX_SMALL = 0.5787037037037;	/// The scale factor for three shrinking steps (1 / (1.2 * 1.2 * 1.2)).
+const double PANGO_SCALE_X_SMALL  = 0.6444444444444;	/// The scale factor for two shrinking steps (1 / (1.2 * 1.2)).
+const double PANGO_SCALE_SMALL    = 0.8333333333333;	/// The scale factor for one shrinking step (1 / 1.2).
+const double PANGO_SCALE_MEDIUM   = 1.0;	/// The scale factor for normal size (1.0).
+const double PANGO_SCALE_LARGE    = 1.2;	/// The scale factor for one magnification step (1.2)
+const double PANGO_SCALE_X_LARGE  = 1.4399999999999;	/// The scale factor for two magnification steps (1.2 * 1.2).
+const double PANGO_SCALE_XX_LARGE = 1.728;	/// The scale factor for three magnification steps (1.2 * 1.2 * 1.2).
+
+
+/**
+ * typedef guint32 PangoGlyph;
+ * A PangoGlyph represents a single glyph in the output form of a string.
+ */
+public alias uint PangoGlyph;
+
+/**
+ * typedef gint32 PangoGlyphUnit;
+ * The PangoGlyphUnit type is used to store dimensions within
+ * Pango. Dimensions are stored in 1/PANGO_SCALE of a device unit.
+ * (A device unit might be a pixel for screen display, or
+ * a point on a printer.) PANGO_SCALE is currently 1024, and
+ * may change in the future (unlikely though), but you should not
+ * depend on its exact value. The PANGO_PIXELS() macro can be used
+ * to convert from glyph units into device units with correct rounding.
+ */
+public alias int PangoGlyphUnit;
+
+/**
+ * typedef PangoGlyphItem PangoLayoutRun;
+ * The PangoLayoutRun structure represents a single run within
+ * a PangoLayoutLine; it is simply an alternate name for
+ * PangoGlyphItem, present for backwards compatibility.
+ * See the PangoGlyphItem docs for details on the fields.
+ */
+public alias PangoGlyphItem PangoLayoutRun;
+/**
+ * The PangoDirection type represents a direction in the
+ * Unicode bidirectional algorithm; not every value in this
+ * enumeration makes sense for every usage of PangoDirection;
+ * for example, the return value of pango_unichar_direction()
+ * and pango_find_base_dir() cannot be PANGO_DIRECTION_WEAK_LTR
+ * or PANGO_DIRECTION_WEAK_RTL, since every character is either
+ * neutral or has a strong direction; on the other hand
+ * PANGO_DIRECTION_NEUTRAL doesn't make sense to pass
+ * to pango_itemize_with_base_dir().
+ * The PANGO_DIRECTION_TTB_LTR, PANGO_DIRECTION_TTB_RTL
+ * values come from an earlier interpretation of this
+ * enumeration as the writing direction of a block of
+ * text and are no longer used; See PangoGravity for how
+ * vertical text is handled in Pango.
+ * PANGO_DIRECTION_LTR
+ */
+public enum PangoDirection
+{
+	LTR,
+	RTL,
+	TTB_LTR,
+	TTB_RTL,
+	WEAK_LTR,
+	WEAK_RTL,
+	NEUTRAL
+}
+/**
+ * An enumeration specifying the various slant styles possible for a font.
+ * PANGO_STYLE_NORMAL
+ */
+public enum PangoStyle
+{
+	NORMAL,
+	OBLIQUE,
+	ITALIC
+}
+/**
+ * An enumeration specifying the weight (boldness) of a font. This is a numerical
+ * value ranging from 100 to 900, but there are some predefined values:
+ * PANGO_WEIGHT_ULTRALIGHT
+ * the ultralight weight (= 200)
+ * PANGO_WEIGHT_LIGHT
+ */
+public enum PangoWeight
+{
+	ULTRALIGHT = 200,
+	LIGHT = 300,
+	NORMAL = 400,
+	SEMIBOLD = 600,
+	BOLD = 700,
+	ULTRABOLD = 800,
+	HEAVY = 900
+}
+/**
+ * An enumeration specifying capitalization variant of the font.
+ * PANGO_VARIANT_NORMAL
+ * A normal font.
+ * PANGO_VARIANT_SMALL_CAPS
+ * A font with the lower case characters
+ */
+public enum PangoVariant
+{
+	NORMAL,
+	SMALL_CAPS
+}
+/**
+ * An enumeration specifying the width of the font relative to other designs
+ * within a family.
+ * PANGO_STRETCH_ULTRA_CONDENSED
+ * ultra condensed width
+ * PANGO_STRETCH_EXTRA_CONDENSED
+ * extra condensed width
+ * PANGO_STRETCH_CONDENSED
+ * condensed width
+ * PANGO_STRETCH_SEMI_CONDENSED
+ * semi condensed width
+ * PANGO_STRETCH_NORMAL
+ * the normal width
+ * PANGO_STRETCH_SEMI_EXPANDED
+ * semi expanded width
+ * PANGO_STRETCH_EXPANDED
+ * expanded width
+ * PANGO_STRETCH_EXTRA_EXPANDED
+ * extra expanded width
+ * PANGO_STRETCH_ULTRA_EXPANDED
+ * ultra expanded width
+ */
+public enum PangoStretch
+{
+	ULTRA_CONDENSED,
+	EXTRA_CONDENSED,
+	CONDENSED,
+	SEMI_CONDENSED,
+	NORMAL,
+	SEMI_EXPANDED,
+	EXPANDED,
+	EXTRA_EXPANDED,
+	ULTRA_EXPANDED
+}
+/**
+ * The bits in a PangoFontMask correspond to fields in a
+ * PangoFontDescription that have been set.
+ * PANGO_FONT_MASK_FAMILY
+ * the font family is specified.
+ * PANGO_FONT_MASK_STYLE
+ * the font style is specified.
+ * PANGO_FONT_MASK_VARIANT
+ * the font variant is specified.
+ * PANGO_FONT_MASK_WEIGHT
+ * the font weight is specified.
+ * PANGO_FONT_MASK_STRETCH
+ * the font stretch is specified.
+ * PANGO_FONT_MASK_SIZE
+ * the font size is specified.
+ * PANGO_FONT_MASK_GRAVITY
+ * the font gravity is specified (Since: 1.16.)
+ */
+public enum PangoFontMask
+{
+	FAMILY = 1 << 0,
+	STYLE = 1 << 1,
+	VARIANT = 1 << 2,
+	WEIGHT = 1 << 3,
+	STRETCH = 1 << 4,
+	SIZE = 1 << 5,
+	GRAVITY = 1 << 6
+}
+/**
+ * The PangoAttrType
+ * distinguishes between different types of attributes. Along with the
+ * predefined values, it is possible to allocate additional values
+ * for custom attributes using pango_attr_type_register(). The predefined
+ * values are given below. The type of structure used to store the
+ * attribute is listed in parentheses after the description.
+ * PANGO_ATTR_INVALID
+ * does not happen
+ * PANGO_ATTR_LANGUAGE
+ * language (PangoAttrLanguage)
+ * PANGO_ATTR_FAMILY
+ * font family name list (PangoAttrString)
+ * PANGO_ATTR_STYLE
+ * font slant style (PangoAttrInt)
+ * PANGO_ATTR_WEIGHT
+ * font weight (PangoAttrInt)
+ * PANGO_ATTR_VARIANT
+ * font variant (normal or small caps) (PangoAttrInt)
+ * PANGO_ATTR_STRETCH
+ * font stretch (PangoAttrInt)
+ * PANGO_ATTR_SIZE
+ * font size in points scaled by PANGO_SCALE (PangoAttrInt)
+ * PANGO_ATTR_FONT_DESC
+ * font description (PangoAttrFontDesc)
+ * PANGO_ATTR_FOREGROUND
+ * foreground color (PangoAttrColor)
+ * PANGO_ATTR_BACKGROUND
+ * background color (PangoAttrColor)
+ * PANGO_ATTR_UNDERLINE
+ * whether the text has an underline (PangoAttrInt)
+ * PANGO_ATTR_STRIKETHROUGH
+ * whether the text is struck-through (PangoAttrInt)
+ * PANGO_ATTR_RISE
+ * baseline displacement (PangoAttrInt)
+ * PANGO_ATTR_SHAPE
+ * shape (PangoAttrShape)
+ * PANGO_ATTR_SCALE
+ * font size scale factor (PangoAttrFloat)
+ * PANGO_ATTR_FALLBACK
+ * whether fallback is enabled (PangoAttrInt)
+ * PANGO_ATTR_LETTER_SPACING
+ * letter spacing (PangoAttrInt)
+ * PANGO_ATTR_UNDERLINE_COLOR
+ * underline color (PangoAttrColor)
+ * PANGO_ATTR_STRIKETHROUGH_COLOR
+ * strikethrough color (PangoAttrColor)
+ * PANGO_ATTR_ABSOLUTE_SIZE
+ * font size in pixels scaled by PANGO_SCALE (PangoAttrInt)
+ * PANGO_ATTR_GRAVITY
+ * base text gravity (PangoAttrInt)
+ * PANGO_ATTR_GRAVITY_HINT
+ * gravity hint (PangoAttrInt)
+ */
+public enum PangoAttrType
+{
+	INVALID, /+* 0 is an invalid attribute type +/
+	LANGUAGE, /+* PangoAttrLanguage +/
+	FAMILY, /+* PangoAttrString +/
+	STYLE, /+* PangoAttrInt +/
+	WEIGHT, /+* PangoAttrInt +/
+	VARIANT, /+* PangoAttrInt +/
+	STRETCH, /+* PangoAttrInt +/
+	SIZE, /+* PangoAttrSize +/
+	FONT_DESC, /+* PangoAttrFontDesc +/
+	FOREGROUND, /+* PangoAttrColor +/
+	BACKGROUND, /+* PangoAttrColor +/
+	UNDERLINE, /+* PangoAttrInt +/
+	STRIKETHROUGH, /+* PangoAttrInt +/
+	RISE, /+* PangoAttrInt +/
+	SHAPE, /+* PangoAttrShape +/
+	SCALE, /+* PangoAttrFloat +/
+	FALLBACK, /+* PangoAttrInt +/
+	LETTER_SPACING, /+* PangoAttrInt +/
+	UNDERLINE_COLOR, /+* PangoAttrColor +/
+	STRIKETHROUGH_COLOR,/+* PangoAttrColor +/
+	ABSOLUTE_SIZE, /+* PangoAttrSize +/
+	GRAVITY, /+* PangoAttrInt +/
+	GRAVITY_HINT /+* PangoAttrInt +/
+}
+/**
+ * the PangoUnderline enumeration is used to specify
+ * whether text should be underlined, and if so, the type
+ * of underlining.
+ * PANGO_UNDERLINE_NONE
+ * no underline should be drawn
+ * PANGO_UNDERLINE_SINGLE
+ * a single underline should be drawn
+ * PANGO_UNDERLINE_DOUBLE
+ * a double underline should be drawn
+ * PANGO_UNDERLINE_LOW
+ * a single underline should be drawn at a position
+ */
+public enum PangoUnderline
+{
+	NONE,
+	SINGLE,
+	DOUBLE,
+	LOW,
+	ERROR
+}
+/**
+ * A PangoTabAlign specifies where a tab stop appears relative to the text.
+ * PANGO_TAB_LEFT
+ * the tab stop appears to the left of the text.
+ */
+public enum PangoTabAlign
+{
+	LEFT
+	/+* These are not supported now, but may be inn the
+	 * future.
+	 *
+	 * RIGHT,
+	 * CENTER,
+	 * NUMERIC
+	+/
+}
+/**
+ * A PangoWrapMode describes how to wrap the lines of a PangoLayout to the desired width.
+ * PANGO_WRAP_WORD
+ * wrap lines at word boundaries.
+ * PANGO_WRAP_CHAR
+ * wrap lines at character boundaries.
+ * PANGO_WRAP_WORD_CHAR
+ * wrap lines at word boundaries, but fall back to character boundaries if there is not
+ * enough space for a full word.
+ */
+public enum PangoWrapMode
+{
+	WORD,
+	CHAR,
+	WORD_CHAR
+}
+/**
+ * The PangoEllipsizeMode type describes what sort of (if any)
+ * ellipsization should be applied to a line of text. In
+ * the ellipsization process characters are removed from the
+ * text in order to make it fit to a given width and replaced
+ * with an ellipsis.
+ * PANGO_ELLIPSIZE_NONE
+ */
+public enum PangoEllipsizeMode
+{
+	NONE,
+	START,
+	MIDDLE,
+	END
+}
+/**
+ * A PangoAlignment describes how to align the lines of a PangoLayout within the
+ * available space. If the PangoLayout is set to justify
+ * using pango_layout_set_justify(), this only has effect for partial lines.
+ * PANGO_ALIGN_LEFT
+ * Put all available space on the right
+ * PANGO_ALIGN_CENTER
+ * Center the line within the available space
+ * PANGO_ALIGN_RIGHT
+ * Put all available space on the left
+ */
+public enum PangoAlignment
+{
+	LEFT,
+	CENTER,
+	RIGHT
+}
+/**
+ * The PangoScript enumeration identifies different writing
+ * systems. The values correspond to the names as defined in the
+ * Unicode standard.
+ * Note that new types may be added in the future. Applications should be ready
+ * to handle unknown values. This enumeration is interchangeable with
+ * GUnicodeScript. See Unicode Standard Annex
+ * 24: Script names.
+ * PANGO_SCRIPT_INVALID_CODE
+ * a value never returned from pango_script_for_unichar()
+ * PANGO_SCRIPT_COMMON
+ * a character used by multiple different scripts
+ * PANGO_SCRIPT_INHERITED
+ * a mark glyph that takes its script from the
+ */
+public enum PangoScript
+{
+	INVALID_CODE = -1,
+	COMMON = 0, /+* Zyyy +/
+	INHERITED, /+* Qaai +/
+	ARABIC, /+* Arab +/
+	ARMENIAN, /+* Armn +/
+	BENGALI, /+* Beng +/
+	BOPOMOFO, /+* Bopo +/
+	CHEROKEE, /+* Cher +/
+	COPTIC, /+* Qaac +/
+	CYRILLIC, /+* Cyrl (Cyrs) +/
+	DESERET, /+* Dsrt +/
+	DEVANAGARI, /+* Deva +/
+	ETHIOPIC, /+* Ethi +/
+	GEORGIAN, /+* Geor (Geon, Geoa) +/
+	GOTHIC, /+* Goth +/
+	GREEK, /+* Grek +/
+	GUJARATI, /+* Gujr +/
+	GURMUKHI, /+* Guru +/
+	HAN, /+* Hani +/
+	HANGUL, /+* Hang +/
+	HEBREW, /+* Hebr +/
+	HIRAGANA, /+* Hira +/
+	KANNADA, /+* Knda +/
+	KATAKANA, /+* Kana +/
+	KHMER, /+* Khmr +/
+	LAO, /+* Laoo +/
+	LATIN, /+* Latn (Latf, Latg) +/
+	MALAYALAM, /+* Mlym +/
+	MONGOLIAN, /+* Mong +/
+	MYANMAR, /+* Mymr +/
+	OGHAM, /+* Ogam +/
+	OLD_ITALIC, /+* Ital +/
+	ORIYA, /+* Orya +/
+	RUNIC, /+* Runr +/
+	SINHALA, /+* Sinh +/
+	SYRIAC, /+* Syrc (Syrj, Syrn, Syre) +/
+	TAMIL, /+* Taml +/
+	TELUGU, /+* Telu +/
+	THAANA, /+* Thaa +/
+	THAI, /+* Thai +/
+	TIBETAN, /+* Tibt +/
+	CANADIAN_ABORIGINAL, /+* Cans +/
+	YI, /+* Yiii +/
+	TAGALOG, /+* Tglg +/
+	HANUNOO, /+* Hano +/
+	BUHID, /+* Buhd +/
+	TAGBANWA, /+* Tagb +/
+	/+* Unicode-4.0 additions +/
+	BRAILLE, /+* Brai +/
+	CYPRIOT, /+* Cprt +/
+	LIMBU, /+* Limb +/
+	OSMANYA, /+* Osma +/
+	SHAVIAN, /+* Shaw +/
+	LINEAR_B, /+* Linb +/
+	TAI_LE, /+* Tale +/
+	UGARITIC, /+* Ugar +/
+	/+* Unicode-4.1 additions +/
+	NEW_TAI_LUE, /+* Talu +/
+	BUGINESE, /+* Bugi +/
+	GLAGOLITIC, /+* Glag +/
+	TIFINAGH, /+* Tfng +/
+	SYLOTI_NAGRI, /+* Sylo +/
+	OLD_PERSIAN, /+* Xpeo +/
+	KHAROSHTHI, /+* Khar +/
+	/+* Unicode-5.0 additions +/
+	UNKNOWN, /+* Zzzz +/
+	BALINESE, /+* Bali +/
+	CUNEIFORM, /+* Xsux +/
+	PHOENICIAN, /+* Phnx +/
+	PHAGS_PA, /+* Phag +/
+	NKO /+* Nkoo +/
+}
+/**
+ * Used to indicate how well a font can represent a particular Unicode
+ * character point for a particular script.
+ * PANGO_COVERAGE_NONE
+ * The character is not representable with the font.
+ * PANGO_COVERAGE_FALLBACK
+ * The character is represented in a way that may be
+ */
+public enum PangoCoverageLevel
+{
+	NONE,
+	FALLBACK,
+	APPROXIMATE,
+	EXACT
+}
+/**
+ * The PangoGravity type represents the orientation of glyphs in a segment
+ * of text. This is useful when rendering vertical text layouts. In
+ * those situations, the layout is rotated using a non-identity PangoMatrix,
+ * and then glyph orientation is controlled using PangoGravity.
+ * Not every value in this enumeration makes sense for every usage of
+ * PangoGravity; for example, PANGO_GRAVITY_AUTO only can be passed to
+ * pango_context_set_base_gravity() and can only be returned by
+ * pango_context_get_base_gravity().
+ * See also: PangoGravityHint
+ * PANGO_GRAVITY_SOUTH
+ */
+public enum PangoGravity
+{
+	SOUTH,
+	EAST,
+	NORTH,
+	WEST,
+	AUTO
+}
+/**
+ * The PangoGravityHint defines how horizontal scripts should behave in a
+ * vertical context. That is, English excerpt in a vertical paragraph for
+ * example.
+ * See PangoGravity.
+ * PANGO_GRAVITY_HINT_NATURAL
+ */
+public enum PangoGravityHint
+{
+	NATURAL,
+	STRONG,
+	LINE
+}
+
+/**
+ * Main Gtk struct.
+ * The PangoContext structure stores global information
+ * used to control the itemization process.
+ */
+public struct PangoContext{}
+
+
+/**
+ * The PangoItem structure stores information about
+ * a segment of text. It contains the following fields:
+ * gintoffset;
+ * the offset of the segment from the beginning of the
+ */
+public struct PangoItem{}
+// int offset;
+// pango-Text-Processing.html
+// int length;
+// pango-Text-Processing.html
+// int numChars;
+// pango-Text-Processing.html
+// PangoAnalysis analysis;
+// pango-Text-Processing.html
+
+
+/**
+ * The PangoAnalysis structure stores information about
+ * the properties of a segment of text. It has the following
+ * fields:
+ * PangoEngineShape*shape_engine;
+ * the engine for doing rendering-system-dependent processing.
+ * PangoEngineLang*lang_engine;
+ * the engine for doing rendering-system-independent processing.
+ * PangoFont*font;
+ * the font for this segment.
+ * guint8level;
+ * the bidirectional level for this segment.
+ * guint8gravity;
+ * the glyph orientation for this segment (A PangoGravity).
+ * guint8flags;
+ * boolean flags for this segment (currently only one) (Since: 1.16).
+ * guint8script;
+ * the detected script for this segment (A PangoScript) (Since: 1.18).
+ * PangoLanguage*language;
+ * the detected language for this segment.
+ * GSList*extra_attrs;
+ * extra attributes for this segment.
+ */
+public struct PangoAnalysis{}
+// PangoEngineShape *shapeEngine;
+// pango-Text-Processing.html
+// PangoEngineLang *langEngine;
+// pango-Text-Processing.html
+// PangoFont *font;
+// pango-Text-Processing.html
+// byte level;
+// pango-Text-Processing.html
+// byte gravity; /+* PangoGravity +/
+// pango-Text-Processing.html
+// byte flags;
+// pango-Text-Processing.html
+// byte script; /+* PangoScript +/
+// pango-Text-Processing.html
+// PangoLanguage *language;
+// pango-Text-Processing.html
+// GSList *extraAttrs;
+// pango-Text-Processing.html
+
+
+/**
+ * The PangoLogAttr structure stores information
+ * about the attributes of a single character.
+ * guintis_line_break:1;
+ * if set, can break line in front of character
+ * guintis_mandatory_break:1;
+ * if set, must break line in front of character
+ * guintis_char_break:1;
+ * if set, can break here when doing character wrapping
+ * guintis_white:1;
+ * is whitespace character
+ * guintis_cursor_position:1;
+ * if set, cursor can appear in front of character.
+ */
+public struct PangoLogAttr{}
+// uint isLineBreak : 1; /+* Can break line inn front of character +/
+// pango-Text-Processing.html
+// uint isMandatoryBreak : 1; /+* Must break line inn front of character +/
+// pango-Text-Processing.html
+// uint isCharBreak : 1; /+* Can break here when doing char wrap +/
+// pango-Text-Processing.html
+// uint isWhite : 1; /+* Whitespace character +/
+// pango-Text-Processing.html
+// /+* Cursor can appear inn front of character (i.e. this is a grapheme
+// pango-Text-Processing.html
+// * boundary, or the first character inn the text).
+// pango-Text-Processing.html
+// +/
+// pango-Text-Processing.html
+// uint isCursorPosition : 1;
+// pango-Text-Processing.html
+// /+* Note that inn degenerate cases, you could have both start/end set on
+// pango-Text-Processing.html
+// * some text, most likely for sentences (e.g. no space after a period, so
+// pango-Text-Processing.html
+// * the next sentence starts right away).
+// pango-Text-Processing.html
+// +/
+// pango-Text-Processing.html
+// uint isWordStart : 1; /+* first character inn a word +/
+// pango-Text-Processing.html
+// uint isWordEnd : 1; /+* is first non-word char after a word +/
+// pango-Text-Processing.html
+// /+* There are two ways to divide sentences. The first assigns all
+// pango-Text-Processing.html
+// * intersentence whitespace/control/format chars to some sentence,
+// pango-Text-Processing.html
+// * so all chars are inn some sentence; isSentenceBoundary denotes
+// pango-Text-Processing.html
+// * the boundaries there. The second way doesn't assign
+// pango-Text-Processing.html
+// * between-sentence spaces, etc. to any sentence, so
+// pango-Text-Processing.html
+// * isSentenceStart/isSentenceEnd mark the boundaries of those
+// pango-Text-Processing.html
+// * sentences.
+// pango-Text-Processing.html
+// +/
+// pango-Text-Processing.html
+// uint isSentenceBoundary : 1;
+// pango-Text-Processing.html
+// uint isSentenceStart : 1; /+* first character inn a sentence +/
+// pango-Text-Processing.html
+// uint isSentenceEnd : 1; /+* first non-sentence char after a sentence +/
+// pango-Text-Processing.html
+// /+* If set, backspace deletes one character rather than
+// pango-Text-Processing.html
+// * the entire grapheme cluster.
+// pango-Text-Processing.html
+// +/
+// pango-Text-Processing.html
+// uint backspaceDeletesCharacter : 1;
+// pango-Text-Processing.html
+// /+* Only few space variants (U+0020 and U+00A0) have variable
+// pango-Text-Processing.html
+// * width during justification.
+// pango-Text-Processing.html
+// +/
+// pango-Text-Processing.html
+// uint isExpandableSpace : 1;
+// pango-Text-Processing.html
+
+
+/**
+ * The PangoRectangle structure represents a rectangle. It is frequently
+ * used to represent the logical or ink extents of a single glyph or section
+ * of text. (See, for instance, pango_font_get_glyph_extents())
+ * intx;
+ * X coordinate of the left side of the rectangle.
+ * inty;
+ * Y coordinate of the the top side of the rectangle.
+ * intwidth;
+ * width of the rectangle.
+ * intheight;
+ * height of the rectangle.
+ */
+public struct PangoRectangle{}
+// int x;
+// pango-Glyph-Storage.html
+// int y;
+// pango-Glyph-Storage.html
+// int width;
+// pango-Glyph-Storage.html
+// int height;
+// pango-Glyph-Storage.html
+
+
+/**
+ * A structure specifying a transformation between user-space
+ * coordinates and device coordinates. The transformation
+ * is given by
+ * x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
+ * y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
+ * doublexx;
+ */
+public struct PangoMatrix{}
+// double xx;
+// pango-Glyph-Storage.html
+// double xy;
+// pango-Glyph-Storage.html
+// double yx;
+// pango-Glyph-Storage.html
+// double yy;
+// pango-Glyph-Storage.html
+// double x0;
+// pango-Glyph-Storage.html
+// double y0;
+// pango-Glyph-Storage.html
+
+
+/**
+ * The PangoGlyphInfo structure represents a single glyph together with
+ * positioning information and visual attributes.
+ * It contains the following fields.
+ * PangoGlyphglyph;
+ * the glyph itself.
+ * PangoGlyphGeometrygeometry;
+ * the positional information about the glyph.
+ * PangoGlyphVisAttrattr;
+ * the visual attributes of the glyph.
+ */
+public struct PangoGlyphInfo{}
+// PangoGlyph glyph;
+// pango-Glyph-Storage.html
+// PangoGlyphGeometry geometry;
+// pango-Glyph-Storage.html
+// PangoGlyphVisAttr attr;
+// pango-Glyph-Storage.html
+
+
+/**
+ * The PangoGlyphGeometry structure contains width and positioning
+ * information for a single glyph.
+ * PangoGlyphUnitwidth;
+ * the logical width to use for the the character.
+ * PangoGlyphUnitx_offset;
+ * horizontal offset from nominal character position.
+ * PangoGlyphUnity_offset;
+ * vertical offset from nominal character position.
+ */
+public struct PangoGlyphGeometry{}
+// PangoGlyphUnit width;
+// pango-Glyph-Storage.html
+// PangoGlyphUnit xOffset;
+// pango-Glyph-Storage.html
+// PangoGlyphUnit yOffset;
+// pango-Glyph-Storage.html
+
+
+/**
+ * The PangoGlyphVisAttr is used to communicate information between
+ * the shaping phase and the rendering phase. More attributes may be
+ * added in the future.
+ * guintis_cluster_start:1;
+ * set for the first logical glyph in each cluster. (Clusters
+ */
+public struct PangoGlyphVisAttr
+{
+	uint bitfield;
+	//uint isClusterStart : 1;
+}
+
+
+/**
+ * Main Gtk struct.
+ * The PangoGlyphString structure is used to store strings
+ * of glyphs with geometry and visual attribute information.
+ * The storage for the glyph information is owned
+ * by the structure which simplifies memory management.
+ * gintnum_glyphs;
+ * the number of glyphs in the string.
+ * PangoGlyphInfo*glyphs;
+ * an array of PangoGlyphInfo structures of length num_glyphs.
+ * gint*log_clusters;
+ * for each glyph, byte index of the starting character for the
+ * cluster. The indices are relative to the start of the text
+ * corresponding to the PangoGlyphString.
+ */
+public struct PangoGlyphString{}
+// int numGlyphs;
+// pango-Glyph-Storage.html
+// PangoGlyphInfo *glyphs;
+// pango-Glyph-Storage.html
+// /+* This is a memory inefficient way of representing the information
+// pango-Glyph-Storage.html
+// * here - each value gives the byte index within the text
+// pango-Glyph-Storage.html
+// * corresponding to the glyph string of the start of the cluster to
+// pango-Glyph-Storage.html
+// * which the glyph belongs.
+// pango-Glyph-Storage.html
+// +/
+// pango-Glyph-Storage.html
+// int *logClusters;
+// pango-Glyph-Storage.html
+
+
+/**
+ * A PangoGlyphItem is a pair of a PangoItem and the glyphs
+ * resulting from shaping the text corresponding to an item.
+ * As an example of the usage of PangoGlyphItem, the results
+ * of shaping text with PangoLayout is a list of PangoLayoutLine,
+ * each of which contains a list of PangoGlyphItem.
+ * PangoItem*item;
+ * a PangoItem structure that provides information
+ */
+public struct PangoGlyphItem{}
+// PangoItem *item;
+// pango-Glyph-Storage.html
+// PangoGlyphString *glyphs;
+// pango-Glyph-Storage.html
+
+
+/**
+ * Main Gtk struct.
+ * The PangoFontDescription structure represents the description
+ * of an ideal font. These structures are used both to list
+ * what fonts are available on the system and also for specifying
+ * the characteristics of a font to load.
+ */
+public struct PangoFontDescription{}
+
+
+/**
+ * A PangoFontMetrics structure holds the overall metric information
+ * for a font (possibly restricted to a script). The fields of this
+ * structure are private to implementations of a font backend. See
+ * the documentation of the corresponding getters for documentation
+ * of their meaning.
+ * guintref_count;
+ * reference count. Used internally. See pango_font_metrics_ref()
+ */
+public struct PangoFontMetrics{}
+// uint refCount;
+// pango-Fonts.html
+// int ascent;
+// pango-Fonts.html
+// int descent;
+// pango-Fonts.html
+// int approximateCharWidth;
+// pango-Fonts.html
+// int approximateDigitWidth;
+// pango-Fonts.html
+// int underlinePosition;
+// pango-Fonts.html
+// int underlineThickness;
+// pango-Fonts.html
+// int strikethroughPosition;
+// pango-Fonts.html
+// int strikethroughThickness;
+// pango-Fonts.html
+
+
+/**
+ * The PangoFont structure is used to represent
+ * a font in a rendering-system-independent matter.
+ * To create an implementation of a PangoFont,
+ * the rendering-system specific code should allocate
+ * a larger structure that contains a nested
+ * PangoFont, fill in the klass member of
+ * the nested PangoFont with a pointer to
+ * a appropriate PangoFontClass, then call
+ * pango_font_init() on the structure.
+ * The PangoFont structure contains one member
+ * which the implementation fills in.
+ */
+public struct PangoFont{}
+
+
+/**
+ * The PangoFontFamily structure is used to represent a family of related
+ * font faces. The faces in a family share a common design, but differ in
+ * slant, weight, width and other aspects.
+ */
+public struct PangoFontFamily{}
+
+
+/**
+ * The PangoFontFace structure is used to represent a group of fonts with
+ * the same family, slant, weight, width, but varying sizes.
+ */
+public struct PangoFontFace{}
+
+
+/**
+ * The PangoFontMap represents the set of fonts available for a
+ * particular rendering system. This is a virtual object with
+ * implementations being specific to particular rendering systems. To
+ * create an implementation of a PangoFontMap, the rendering-system
+ * specific code should allocate a larger structure that contains a nested
+ * PangoFontMap, fill in the klass member of the nested PangoFontMap with a
+ * pointer to a appropriate PangoFontMapClass, then call
+ * pango_font_map_init() on the structure.
+ * The PangoFontMap structure contains one member which the implementation
+ * fills in.
+ */
+public struct PangoFontMap{}
+
+
+/**
+ * The PangoFontMapClass structure holds the virtual functions for
+ * a particular PangoFontMap implementation.
+ * GObjectClassparent_class;
+ * parent GObjectClass.
+ * load_font()
+ * a function to load a font with a given description. See
+ */
+public struct PangoFontMapClass{}
+// GObjectClass parentClass;
+// pango-Fonts.html
+// PangoFont * (*loadFont) (PangoFontMap *fontmap,
+// pango-Fonts.html
+// PangoContext *context,
+// pango-Fonts.html
+// PangoFontDescription *desc);
+// pango-Fonts.html
+// void (*listFamilies) (PangoFontMap *fontmap,
+// pango-Fonts.html
+// PangoFontFamily ***families,
+// pango-Fonts.html
+// int *nFamilies);
+// pango-Fonts.html
+// PangoFontset *(*loadFontset) (PangoFontMap *fontmap,
+// pango-Fonts.html
+// PangoContext *context,
+// pango-Fonts.html
+// PangoFontDescription *desc,
+// pango-Fonts.html
+// PangoLanguage *language);
+// pango-Fonts.html
+// char *shapeEngineType;
+// pango-Fonts.html
+
+
+/**
+ * A PangoFontset represents a set of PangoFont to use
+ * when rendering text. It is the result of resolving a
+ * PangoFontDescription against a particular PangoContext.
+ * It has operations for finding the component font for
+ * a particular Unicode character, and for finding a composite
+ * set of metrics for the entire fontset.
+ */
+public struct PangoFontset{}
+
+
+/**
+ * The PangoFontsetClass structure holds the virtual functions for
+ * a particular PangoFontset implementation.
+ * GObjectClassparent_class;
+ * parent GObjectClass.
+ * get_font()
+ * a function to get the font in the fontset that contains the
+ */
+public struct PangoFontsetClass{}
+// GObjectClass parentClass;
+// pango-Fonts.html
+// PangoFont * (*getFont) (PangoFontset *fontset,
+// pango-Fonts.html
+// uint wc);
+// pango-Fonts.html
+// PangoFontMetrics *(*getMetrics) (PangoFontset *fontset);
+// pango-Fonts.html
+// PangoLanguage * (*getLanguage) (PangoFontset *fontset);
+// pango-Fonts.html
+// void (*foreac) (PangoFontset *fontset,
+// pango-Fonts.html
+// PangoFontsetForeachFunc func,
+// pango-Fonts.html
+// void* data);
+// pango-Fonts.html
+
+
+/**
+ * PangoFontsetSimple is a implementation of the abstract
+ * PangoFontset base class in terms of an array of fonts,
+ * which the creator provides when constructing the
+ * PangoFontsetSimple.
+ */
+public struct PangoFontsetSimple{}
+
+
+/**
+ * The PangoAttrClass structure stores the type and operations for
+ * a particular type of attribute. The functions in this structure should
+ * not be called directly. Instead, one should use the wrapper functions
+ * provided for PangoAttribute.
+ * PangoAttrTypetype;
+ * the type ID for this attribute
+ * copy()
+ * function to duplicate an attribute of this type (see pango_attribute_copy())
+ * destroy()
+ * function to free an attribute of this type (see pango_attribute_destroy())
+ * equal()
+ * function to check two attributes of this type for equality (see pango_attribute_equal())
+ */
+public struct PangoAttrClass{}
+// PangoAttrType type;
+// pango-Text-Attributes.html
+// PangoAttribute * (*copy) ( PangoAttribute *attr);
+// pango-Text-Attributes.html
+// void (*destroy) (PangoAttribute *attr);
+// pango-Text-Attributes.html
+// int (*equal) ( PangoAttribute *attr1, PangoAttribute *attr2);
+// pango-Text-Attributes.html
+
+
+/**
+ * Main Gtk struct.
+ * The PangoAttribute structure represents the common portions of all
+ * attributes. Particular types of attributes include this structure
+ * as their initial portion. The common portion of the attribute holds
+ * the range to which the value in the type-specific part of the attribute
+ * applies.
+ * constPangoAttrClass*klass;
+ * the class structure holding information about the type of the attribute
+ * guintstart_index;
+ * the start index of the range (in bytes).
+ * guintend_index;
+ * end index of the range (in bytes). The character at this index
+ */
+public struct PangoAttribute
+{
+	PangoAttrClass *klass;
+	uint startIndex; /+* inn bytes +/
+	uint endIndex; /+* inn bytes. The character at this index is not included +/
+}
+
+
+/**
+ * The PangoAttrString structure is used to represent attributes with
+ * a string value.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * char*value;
+ * the string which is the value of the attribute
+ */
+public struct PangoAttrString{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// char *value;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoAttrLanguage structure is used to represent attributes that
+ * are languages.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * PangoLanguage*value;
+ * the PangoLanguage which is the value of the attribute
+ */
+public struct PangoAttrLanguage{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// PangoLanguage *value;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoAttrColor structure is used to represent attributes that
+ * are colors.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * PangoColorcolor;
+ * the PangoColor which is the value of the attribute
+ */
+public struct PangoAttrColor{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// PangoColor color;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoAttrInt structure is used to represent attributes with
+ * an integer or enumeration value.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * intvalue;
+ * the value of the attribute
+ */
+public struct PangoAttrInt{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// int value;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoAttrFloat structure is used to represent attributes with
+ * a float or double value.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * doublevalue;
+ * the value of the attribute
+ */
+public struct PangoAttrFloat{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// double value;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoAttrFontDesc structure is used to store an attribute that
+ * sets all aspects of the font description at once.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * PangoFontDescription*desc;
+ * the font description which is the value of this attribute
+ */
+public struct PangoAttrFontDesc{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// PangoFontDescription *desc;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoAttrShape structure is used to represent attributes which
+ * impose shape restrictions.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * PangoRectangleink_rect;
+ * the ink rectangle to restrict to
+ * PangoRectanglelogical_rect;
+ * the logical rectangle to restrict to
+ * gpointerdata;
+ * user data set (see pango_attr_shape_new_with_data())
+ * PangoAttrDataCopyFunccopy_func;
+ * copy function for the user data
+ * GDestroyNotifydestroy_func;
+ * destroy function for the user data
+ */
+public struct PangoAttrShape{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// PangoRectangle inkRect;
+// pango-Text-Attributes.html
+// PangoRectangle logicalRect;
+// pango-Text-Attributes.html
+// void* data;
+// pango-Text-Attributes.html
+// PangoAttrDataCopyFunc copyFunc;
+// pango-Text-Attributes.html
+// GDestroyNotify destroyFunc;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoAttrShape structure is used to represent attributes which
+ * set font size.
+ * PangoAttributeattr;
+ * the common portion of the attribute
+ * intsize;
+ * size of font, in units of 1/PANGO_SCALE of a point (for
+ */
+public struct PangoAttrSize{}
+// PangoAttribute attr;
+// pango-Text-Attributes.html
+// int size;
+// pango-Text-Attributes.html
+// uint absolute : 1;
+// pango-Text-Attributes.html
+
+
+/**
+ * The PangoColor structure is used to
+ * represent a color in an uncalibrated RGB color-space.
+ * guint16red;
+ * The red component of the color. This is a value between 0 and 65535,
+ */
+public struct PangoColor
+{
+	ushort red;
+	ushort green;
+	ushort blue;
+}
+
+
+/**
+ * The PangoLanguage structure is used to
+ * represent a language.
+ * PangoLanguage pointers can be efficiently
+ * copied and compared with each other.
+ */
+public struct PangoLanguage{}
+
+
+/**
+ * The PangoAttrList structure represents a list of attributes
+ * that apply to a section of text. The attributes are, in general,
+ * allowed to overlap in an arbitrary fashion, however, if the
+ * attributes are manipulated only through pango_attr_list_change(),
+ * the overlap between properties will meet stricter criteria.
+ * Since the PangoAttrList structure is stored as a linear list,
+ * it is not suitable for storing attributes for large amounts
+ * of text. In general, you should not use a single PangoAttrList
+ * for more than one paragraph of text.
+ */
+public struct PangoAttrList{}
+
+
+/**
+ * The PangoAttrIterator structure is used to represent an
+ * iterator through a PangoAttrList. A new iterator is created
+ * with pango_attr_list_get_iterator(). Once the iterator
+ * is created, it can be advanced through the style changes
+ * in the text using pango_attr_iterator_next(). At each
+ * style change, the range of the current style segment and the
+ * attributes currently in effect can be queried.
+ */
+public struct PangoAttrIterator{}
+
+
+/**
+ * Main Gtk struct.
+ * A PangoTabArray struct contains an array
+ * of tab stops. Each tab stop has an alignment and a position.
+ */
+public struct PangoTabArray{}
+
+
+/**
+ * Main Gtk struct.
+ * The PangoLayout structure represents and entire paragraph
+ * of text. It is initialized with a PangoContext, UTF-8 string
+ * and set of attributes for that string. Once that is done, the
+ * set of formatted lines can be extracted from the object,
+ * the layout can be rendered, and conversion between logical
+ * character positions within the layout's text, and the physical
+ * position of the resulting glyphs can be made.
+ * There are also a number of parameters to adjust the formatting
+ * of a PangoLayout, which are illustrated in Figure1, Adjustable parameters for a PangoLayout.
+ * It is possible, as well, to ignore the 2-D setup, and simply
+ * treat the results of a PangoLayout as a list of lines.
+ * Figure1.Adjustable parameters for a PangoLayout
+ * The PangoLayout structure is opaque, and has no user-visible
+ * fields.
+ */
+public struct PangoLayout{}
+
+
+/**
+ * A PangoLayoutIter structure can be used to
+ * iterate over the visual extents of a PangoLayout.
+ * The PangoLayoutIter structure is opaque, and
+ * has no user-visible fields.
+ */
+public struct PangoLayoutIter{}
+
+
+/**
+ * The PangoLayoutLine structure represents one of the lines resulting
+ * from laying out a paragraph via PangoLayout. PangoLayoutLine
+ * structures are obtained by calling pango_layout_get_line() and
+ * are only valid until the text, attributes, or settings of the
+ * parent PangoLayout are modified.
+ * Routines for rendering PangoLayout objects are provided in
+ * code specific to each rendering system.
+ * PangoLayout*layout;
+ * the parent layout for this line
+ * gintstart_index;
+ * the start of the line as byte index into layout->text
+ * gintlength;
+ * the length of the line in bytes
+ * GSList*runs;
+ * a list containing the runs of the line in visual order
+ * guintis_paragraph_start:1;
+ * TRUE if this is the first line of the paragraph
+ * guintresolved_dir:3;
+ * the resolved PangoDirection of the line
+ */
+public struct PangoLayoutLine{}
+// PangoLayout *layout;
+// pango-Layout-Objects.html
+// int startIndex; /+* start of line as byte index into layout->text +/
+// pango-Layout-Objects.html
+// int length; /+* length of line inn bytes +/
+// pango-Layout-Objects.html
+// GSList *runs;
+// pango-Layout-Objects.html
+// uint isParagraphStart : 1; /+* TRUE if this is the first line of the paragraph +/
+// pango-Layout-Objects.html
+// uint resolvedDir : 3; /+* Resolved PangoDirection of line +/
+// pango-Layout-Objects.html
+
+
+/**
+ * Main Gtk struct.
+ * A PangoScriptIter is used to iterate through a string
+ * and identify ranges in different scripts.
+ */
+public struct PangoScriptIter{}
+
+
+/**
+ * The PangoCoverage structure represents a map from Unicode characters
+ * to PangoCoverageLevel. It is an opaque structure with no public fields.
+ */
+public struct PangoCoverage{}
+
+
+/**
+ * The PangoEngineInfo structure contains information about a particular
+ * engine. It contains the following fields:
+ * constgchar*id;
+ * a unique string ID for the engine.
+ * constgchar*engine_type;
+ * a string identifying the engine type.
+ * constgchar*render_type;
+ * a string identifying the render type.
+ * PangoEngineScriptInfo*scripts;
+ * array of scripts this engine supports.
+ * gintn_scripts;
+ * number of items in scripts.
+ */
+public struct PangoEngineInfo{}
+// char *id;
+// pango-Engines.html
+// char *engineType;
+// pango-Engines.html
+// char *renderType;
+// pango-Engines.html
+// PangoEngineScriptInfo *scripts;
+// pango-Engines.html
+// int nScripts;
+// pango-Engines.html
+
+
+/**
+ * The PangoEngineScriptInfo structure contains
+ * information about how the shaper covers a particular
+ * script.
+ * PangoScriptscript;
+ * a PangoScript. The value PANGO_SCRIPT_COMMON has
+ */
+public struct PangoEngineScriptInfo{}
+// PangoScript script;
+// pango-Engines.html
+// char *langs;
+// pango-Engines.html
+
+
+/**
+ * PangoEngine is the base class for all types of language and
+ * script specific engines. It has no functionality by itself.
+ */
+public struct PangoEngine{}
+
+
+/**
+ * Class structure for PangoEngine
+ */
+public struct PangoEngineClass{}
+
+
+/**
+ * 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.
+ */
+public struct PangoEngineLang{}
+
+
+/**
+ * Class structure for PangoEngineLang
+ * script_break()
+ */
+public struct PangoEngineLangClass{}
+// void (*scriptBreak) (PangoEngineLang *engine,
+// PangoEngineLang.html
+// char *text,
+// PangoEngineLang.html
+// int len,
+// PangoEngineLang.html
+// PangoAnalysis *analysis,
+// PangoEngineLang.html
+// PangoLogAttr *attrs,
+// PangoEngineLang.html
+// int attrsLen);
+// PangoEngineLang.html
+
+
+/**
+ * The PangoEngineShape class is implemented by engines that
+ * customize the rendering-system dependent part of the
+ * Pango pipeline for a particular script or language.
+ * A PangoEngineShape implementation is then specific to both
+ * a particular rendering system or group of rendering systems
+ * and to a particular script. For instance, there is one
+ * PangoEngineShape implementation to handle shaping Arabic
+ * for Fontconfig-based backends.
+ */
+public struct PangoEngineShape{}
+
+
+/**
+ * Class structure for PangoEngineShape
+ * script_shape()
+ */
+public struct PangoEngineShapeClass{}
+// void (*scriptShape) (PangoEngineShape *engine,
+// PangoEngineShape.html
+// PangoFont *font,
+// PangoEngineShape.html
+// char *text,
+// PangoEngineShape.html
+// int length,
+// PangoEngineShape.html
+// PangoAnalysis *analysis,
+// PangoEngineShape.html
+// PangoGlyphString *glyphs);
+// PangoEngineShape.html
+// PangoCoverageLevel (*covers) (PangoEngineShape *engine,
+// PangoEngineShape.html
+// PangoFont *font,
+// PangoEngineShape.html
+// PangoLanguage *language,
+// PangoEngineShape.html
+// gunichar wc);
+// PangoEngineShape.html
+
+
+/*
+ * Converts a dimension to device units by rounding.
+ * d:
+ * a dimension in Pango units.
+ * Returns:
+ * rounded dimension in device units.
+ */
+// TODO
+// #define PANGO_PIXELS(d) (((int)(d) + 512) >> 10)
+
+/*
+ * Converts a dimension to device units by flooring.
+ * d:
+ * a dimension in Pango units.
+ * Returns:
+ * floored dimension in device units.
+ * Since 1.14
+ */
+// TODO
+// #define PANGO_PIXELS_FLOOR(d) (((int)(d)) >> 10)
+
+/*
+ * Converts a dimension to device units by ceiling.
+ * d:
+ * a dimension in Pango units.
+ * Returns:
+ * ceiled dimension in device units.
+ * Since 1.14
+ */
+// TODO
+// #define PANGO_PIXELS_CEIL(d) (((int)(d) + 1023) >> 10)
+
+/*
+ * Rounds a dimension to whole device units, but does not
+ * convert it to device units.
+ * d:
+ * a dimension in Pango units.
+ * Returns:
+ * rounded dimension in Pango units.
+ * Since 1.18
+ */
+// TODO
+// #define PANGO_UNITS_ROUND(d)
+
+/*
+ * Extracts the ascent from a PangoRectangle
+ * representing glyph extents. The ascent is the distance from the
+ * baseline to the highest point of the character. This is positive if the
+ * glyph ascends above the baseline.
+ * rect:
+ * a PangoRectangle
+ */
+// TODO
+// #define PANGO_ASCENT(rect) (-(rect).y)
+
+/*
+ * Extracts the descent from a PangoRectangle
+ * representing glyph extents. The descent is the distance from the
+ * baseline to the lowest point of the character. This is positive if the
+ * glyph descends below the baseline.
+ * rect:
+ * a PangoRectangle
+ */
+// TODO
+// #define PANGO_DESCENT(rect) ((rect).y + (rect).height)
+
+/*
+ * Extracts the left bearing from a PangoRectangle
+ * representing glyph extents. The left bearing is the distance from the
+ * horizontal origin to the farthest left point of the character.
+ * This is positive for characters drawn completely to the right of the
+ * glyph origin.
+ * rect:
+ * a PangoRectangle
+ */
+// TODO
+// #define PANGO_LBEARING(rect) ((rect).x)
+
+/*
+ * Extracts the right bearing from a PangoRectangle
+ * representing glyph extents. The right bearing is the distance from the
+ * horizontal origin to the farthest right point of the character.
+ * This is positive except for characters drawn completely to the left of the
+ * horizontal origin.
+ * rect:
+ * a PangoRectangle
+ */
+// TODO
+// #define PANGO_RBEARING(rect) ((rect).x + (rect).width)
+
+/*
+ * Returns a PangoGlyph value that means no glyph was found for wc.
+ * The way this unknown glyphs are rendered is backend specific. For example,
+ * a box with the hexadecimal Unicode code-point of the character written in it
+ * is what is done in the most common backends.
+ * wc:
+ * a Unicode character
+ */
+// TODO
+// #define PANGO_GET_UNKNOWN_GLYPH(wc) ((PangoGlyph)(wc)|PANGO_GLYPH_UNKNOWN_FLAG)
+
+/*
+ * Casts a GObject to a PangoFont.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT, PangoFont))
+
+/*
+ * Returns TRUE if object is a PangoFont.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_IS_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT))
+
+/*
+ * Casts a GObject to a PangoFontFamily.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FAMILY, PangoFontFamily))
+
+/*
+ * Returns TRUE if object is a PangoFontFamily.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_IS_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FAMILY))
+
+/*
+ * Casts a GObject to a PangoFontFace.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FACE, PangoFontFace))
+
+/*
+ * Returns TRUE if object is a PangoFontFace.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_IS_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FACE))
+
+/*
+ * Casts a GObject to a PangoFontMap.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_MAP, PangoFontMap))
+
+/*
+ * Returns TRUE if object is a PangoFontMap.
+ * object:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_IS_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_MAP))
+
+/*
+ * Casts a GObject to a PangoFontMapClass.
+ * klass:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
+
+/*
+ * Returns TRUE if klass is a subtype of PangoFontMapClass.
+ * klass:
+ * a GObject.
+ */
+// TODO
+// #define PANGO_IS_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_MAP))
+
+/*
+ * Returns the type of a PangoFontMap.
+ * obj:
+ * a PangoFontMap.
+ */
+// TODO
+// #define PANGO_FONT_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
+
+/*
+ * Outputs the necessary code for GObject type registration for a
+ * PangoEngineLang class defined in a module. Two static symbols
+ * are defined.
+ *  static GType prefix_type;
+ *  static void prefix_register_type (GTypeModule module);
+ * The prefix, _register_type()
+ * 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:
+ *  PangoEngine *engine = g_object_new (prefix_type, NULL);
+ * name:
+ *  Name of the the type to register (for example:, ArabicEngineFc
+ * prefix:
+ *  Prefix for symbols that will be defined (for example:, arabic_engine_fc
+ * class_init:
+ *  Class initialization function for the new type, or NULL
+ * instance_init:
+ *  Instance initialization function for the new type, or NULL
+ */
+// TODO
+// #define PANGO_ENGINE_LANG_DEFINE_TYPE(name, prefix, class_init, instance_init)
+
+/*
+ * Outputs the necessary code for GObject type registration for a
+ * PangoEngineShape class defined in a module. Two static symbols
+ * are defined.
+ *  static GType prefix_type;
+ *  static void prefix_register_type (GTypeModule module);
+ * The prefix, _register_type()
+ * 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:
+ *  PangoEngine *engine = g_object_new (prefix_type, NULL);
+ * name:
+ *  Name of the the type to register (for example:, ArabicEngineFc
+ * prefix:
+ *  Prefix for symbols that will be defined (for example:, arabic_engine_fc
+ * class_init:
+ *  Class initialization function for the new type, or NULL
+ * instance_init:
+ *  Instance initialization function for the new type, or NULL
+ */
+// TODO
+// #define PANGO_ENGINE_SHAPE_DEFINE_TYPE(name, prefix, class_init, instance_init)
+
+/*
+ * Whether a PangoGravity represents vertical writing directions.
+ * gravity:
+ *  the PangoGravity to check
+ * Since 1.16
+ */
+// TODO
+// #define PANGO_GRAVITY_IS_VERTICAL(gravity)
+
+/*
+ * A callback function used by pango_fontset_foreach() when enumerating
+ * the fonts in a fontset.
+ * fontset:
+ *  a PangoFontset
+ * font:
+ *  a font from fontset
+ * data:
+ *  callback data
+ * Returns:
+ *  if TRUE, stop iteration and return immediately.
+ * Since 1.4
+ */
+// gboolean (*PangoFontsetForeachFunc) (PangoFontset *fontset,  PangoFont *font,  gpointer data);
+public typedef extern(C) int  function (PangoFontset*, PangoFont*, void*) PangoFontsetForeachFunc;
+
+/*
+ * A copy function passed to attribute new functions that take
+ * user data.
+ * data:
+ * the user data
+ * Returns:
+ * a new copy of data.
+ */
+// gpointer (*PangoAttrDataCopyFunc) (gconstpointer data);
+public typedef extern(C) void*  function (void*) PangoAttrDataCopyFunc;
+
+/*
+ * A predicate function used by pango_attr_list_filter()
+ * to filter out a subset of attributes for a list.
+ * attribute:
+ * a PangoAttribute
+ * data:
+ * callback data passed to pango_attr_list_filter()
+ * Returns:
+ * TRUE if the attribute should be filtered out
+ */
+// gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute,  gpointer data);
+public typedef extern(C) int  function (PangoAttribute*, void*) PangoAttrFilterFunc;