1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19  
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 module gtkc.pangotypes;
25 
26 
27 public import gtkc.cairotypes;
28 public import gtkc.glibtypes;
29 public import gtkc.gobjecttypes;
30 
31 ///* The pango Basic Types */
32 public alias void FcPattern;
33 public alias void FcCharSet;
34 public alias void FT_Face;
35 
36 
37 const int PANGO_SCALE = 1024;
38 const double PANGO_SCALE_XX_SMALL = 0.5787037037037;	/// The scale factor for three shrinking steps (1 / (1.2 * 1.2 * 1.2)).
39 const double PANGO_SCALE_X_SMALL  = 0.6444444444444;	/// The scale factor for two shrinking steps (1 / (1.2 * 1.2)).
40 const double PANGO_SCALE_SMALL    = 0.8333333333333;	/// The scale factor for one shrinking step (1 / 1.2).
41 const double PANGO_SCALE_MEDIUM   = 1.0;	/// The scale factor for normal size (1.0).
42 const double PANGO_SCALE_LARGE    = 1.2;	/// The scale factor for one magnification step (1.2)
43 const double PANGO_SCALE_X_LARGE  = 1.4399999999999;	/// The scale factor for two magnification steps (1.2 * 1.2).
44 const double PANGO_SCALE_XX_LARGE = 1.728;	/// The scale factor for three magnification steps (1.2 * 1.2 * 1.2).
45 
46 
47 /**
48  * typedef guint32 PangoGlyph;
49  * A PangoGlyph represents a single glyph in the output form of a string.
50  */
51 public alias uint PangoGlyph;
52 
53 /**
54  * typedef gint32 PangoGlyphUnit;
55  * The PangoGlyphUnit type is used to store dimensions within
56  * Pango. Dimensions are stored in 1/PANGO_SCALE of a device unit.
57  * (A device unit might be a pixel for screen display, or
58  * a point on a printer.) PANGO_SCALE is currently 1024, and
59  * may change in the future (unlikely though), but you should not
60  * depend on its exact value. The PANGO_PIXELS() macro can be used
61  * to convert from glyph units into device units with correct rounding.
62  */
63 public alias int PangoGlyphUnit;
64 
65 /**
66  * typedef PangoGlyphItem PangoLayoutRun;
67  * The PangoLayoutRun structure represents a single run within
68  * a PangoLayoutLine; it is simply an alternate name for
69  * PangoGlyphItem.
70  * See the PangoGlyphItem docs for details on the fields.
71  */
72 public alias PangoGlyphItem PangoLayoutRun;
73 /**
74  * The PangoDirection type represents a direction in the
75  * Unicode bidirectional algorithm; not every value in this
76  * enumeration makes sense for every usage of PangoDirection;
77  * for example, the return value of pango_unichar_direction()
78  * and pango_find_base_dir() cannot be PANGO_DIRECTION_WEAK_LTR
79  * or PANGO_DIRECTION_WEAK_RTL, since every character is either
80  * neutral or has a strong direction; on the other hand
81  * PANGO_DIRECTION_NEUTRAL doesn't make sense to pass
82  * to pango_itemize_with_base_dir().
83  * The PANGO_DIRECTION_TTB_LTR, PANGO_DIRECTION_TTB_RTL
84  * values come from an earlier interpretation of this
85  * enumeration as the writing direction of a block of
86  * text and are no longer used; See PangoGravity for how
87  * vertical text is handled in Pango.
88  * PANGO_DIRECTION_LTR
89  * A strong left-to-right direction
90  * PANGO_DIRECTION_RTL
91  * A strong right-to-left direction
92  * PANGO_DIRECTION_TTB_LTR
93  * Deprecated value; treated the
94  *  same as PANGO_DIRECTION_RTL.
95  * PANGO_DIRECTION_TTB_RTL
96  * Deprecated value; treated the
97  *  same as PANGO_DIRECTION_LTR
98  * PANGO_DIRECTION_WEAK_LTR
99  * A weak left-to-right direction
100  * PANGO_DIRECTION_WEAK_RTL
101  * A weak right-to-left direction
102  * PANGO_DIRECTION_NEUTRAL
103  * No direction specified
104  */
105 public enum PangoDirection
106 {
107 	LTR,
108 	RTL,
109 	TTB_LTR,
110 	TTB_RTL,
111 	WEAK_LTR,
112 	WEAK_RTL,
113 	NEUTRAL
114 }
115 /**
116  * The PangoBidiType type represents the bidirectional character
117  * type of a Unicode character as specified by the
118  * Unicode bidirectional algorithm.
119  * PANGO_BIDI_TYPE_L
120  * Left-to-Right
121  * PANGO_BIDI_TYPE_LRE
122  * Left-to-Right Embedding
123  * PANGO_BIDI_TYPE_LRO
124  * Left-to-Right Override
125  * PANGO_BIDI_TYPE_R
126  * Right-to-Left
127  * PANGO_BIDI_TYPE_AL
128  * Right-to-Left Arabic
129  * PANGO_BIDI_TYPE_RLE
130  * Right-to-Left Embedding
131  * PANGO_BIDI_TYPE_RLO
132  * Right-to-Left Override
133  * PANGO_BIDI_TYPE_PDF
134  * Pop Directional Format
135  * PANGO_BIDI_TYPE_EN
136  * European Number
137  * PANGO_BIDI_TYPE_ES
138  * European Number Separator
139  * PANGO_BIDI_TYPE_ET
140  * European Number Terminator
141  * PANGO_BIDI_TYPE_AN
142  * Arabic Number
143  * PANGO_BIDI_TYPE_CS
144  * Common Number Separator
145  * PANGO_BIDI_TYPE_NSM
146  * Nonspacing Mark
147  * PANGO_BIDI_TYPE_BN
148  * Boundary Neutral
149  * PANGO_BIDI_TYPE_B
150  * Paragraph Separator
151  * PANGO_BIDI_TYPE_S
152  * Segment Separator
153  * PANGO_BIDI_TYPE_WS
154  * Whitespace
155  * PANGO_BIDI_TYPE_ON
156  * Other Neutrals
157  * Since 1.22
158  */
159 public enum PangoBidiType
160 {
161 	/+* Strong types +/
162 	TYPE_L,
163 	TYPE_LRE,
164 	TYPE_LRO,
165 	TYPE_R,
166 	TYPE_AL,
167 	TYPE_RLE,
168 	TYPE_RLO,
169 	/+* Weak types +/
170 	TYPE_PDF,
171 	TYPE_EN,
172 	TYPE_ES,
173 	TYPE_ET,
174 	TYPE_AN,
175 	TYPE_CS,
176 	TYPE_NSM,
177 	TYPE_BN,
178 	/+* Neutral types +/
179 	TYPE_B,
180 	TYPE_S,
181 	TYPE_WS,
182 	TYPE_ON
183 }
184 /**
185  * An enumeration specifying the various slant styles possible for a font.
186  * PANGO_STYLE_NORMAL
187  * the font is upright.
188  * PANGO_STYLE_OBLIQUE
189  * the font is slanted, but in a roman style.
190  * PANGO_STYLE_ITALIC
191  * the font is slanted in an italic style.
192  */
193 public enum PangoStyle
194 {
195 	NORMAL,
196 	OBLIQUE,
197 	ITALIC
198 }
199 /**
200  * An enumeration specifying the weight (boldness) of a font. This is a numerical
201  * value ranging from 100 to 900, but there are some predefined values:
202  * PANGO_WEIGHT_THIN
203  * the thin weight (= 100; Since: 1.24)
204  * PANGO_WEIGHT_ULTRALIGHT
205  * the ultralight weight (= 200)
206  * PANGO_WEIGHT_LIGHT
207  * the light weight (= 300)
208  * PANGO_WEIGHT_BOOK
209  * the book weight (= 380; Since: 1.24)
210  * PANGO_WEIGHT_NORMAL
211  * the default weight (= 400)
212  * PANGO_WEIGHT_MEDIUM
213  * the normal weight (= 500; Since: 1.24)
214  * PANGO_WEIGHT_SEMIBOLD
215  * the semibold weight (= 600)
216  * PANGO_WEIGHT_BOLD
217  * the bold weight (= 700)
218  * PANGO_WEIGHT_ULTRABOLD
219  * the ultrabold weight (= 800)
220  * PANGO_WEIGHT_HEAVY
221  * the heavy weight (= 900)
222  * PANGO_WEIGHT_ULTRAHEAVY
223  * the ultraheavy weight (= 1000; Since: 1.24)
224  */
225 public enum PangoWeight
226 {
227 	THIN = 100,
228 	ULTRALIGHT = 200,
229 	LIGHT = 300,
230 	BOOK = 380,
231 	NORMAL = 400,
232 	MEDIUM = 500,
233 	SEMIBOLD = 600,
234 	BOLD = 700,
235 	ULTRABOLD = 800,
236 	HEAVY = 900,
237 	ULTRAHEAVY = 1000
238 }
239 /**
240  * An enumeration specifying capitalization variant of the font.
241  * PANGO_VARIANT_NORMAL
242  * A normal font.
243  * PANGO_VARIANT_SMALL_CAPS
244  * A font with the lower case characters
245  *  replaced by smaller variants of the capital characters.
246  */
247 public enum PangoVariant
248 {
249 	NORMAL,
250 	SMALL_CAPS
251 }
252 /**
253  * An enumeration specifying the width of the font relative to other designs
254  * within a family.
255  * PANGO_STRETCH_ULTRA_CONDENSED
256  * ultra condensed width
257  * PANGO_STRETCH_EXTRA_CONDENSED
258  * extra condensed width
259  * PANGO_STRETCH_CONDENSED
260  * condensed width
261  * PANGO_STRETCH_SEMI_CONDENSED
262  * semi condensed width
263  * PANGO_STRETCH_NORMAL
264  * the normal width
265  * PANGO_STRETCH_SEMI_EXPANDED
266  * semi expanded width
267  * PANGO_STRETCH_EXPANDED
268  * expanded width
269  * PANGO_STRETCH_EXTRA_EXPANDED
270  * extra expanded width
271  * PANGO_STRETCH_ULTRA_EXPANDED
272  * ultra expanded width
273  */
274 public enum PangoStretch
275 {
276 	ULTRA_CONDENSED,
277 	EXTRA_CONDENSED,
278 	CONDENSED,
279 	SEMI_CONDENSED,
280 	NORMAL,
281 	SEMI_EXPANDED,
282 	EXPANDED,
283 	EXTRA_EXPANDED,
284 	ULTRA_EXPANDED
285 }
286 /**
287  * The bits in a PangoFontMask correspond to fields in a
288  * PangoFontDescription that have been set.
289  * PANGO_FONT_MASK_FAMILY
290  * the font family is specified.
291  * PANGO_FONT_MASK_STYLE
292  * the font style is specified.
293  * PANGO_FONT_MASK_VARIANT
294  * the font variant is specified.
295  * PANGO_FONT_MASK_WEIGHT
296  * the font weight is specified.
297  * PANGO_FONT_MASK_STRETCH
298  * the font stretch is specified.
299  * PANGO_FONT_MASK_SIZE
300  * the font size is specified.
301  * PANGO_FONT_MASK_GRAVITY
302  * the font gravity is specified (Since: 1.16.)
303  */
304 public enum PangoFontMask
305 {
306 	FAMILY = 1 << 0,
307 	STYLE = 1 << 1,
308 	VARIANT = 1 << 2,
309 	WEIGHT = 1 << 3,
310 	STRETCH = 1 << 4,
311 	SIZE = 1 << 5,
312 	GRAVITY = 1 << 6
313 }
314 /**
315  * The PangoAttrType
316  * distinguishes between different types of attributes. Along with the
317  * predefined values, it is possible to allocate additional values
318  * for custom attributes using pango_attr_type_register(). The predefined
319  * values are given below. The type of structure used to store the
320  * attribute is listed in parentheses after the description.
321  * PANGO_ATTR_INVALID
322  * does not happen
323  * PANGO_ATTR_LANGUAGE
324  * language (PangoAttrLanguage)
325  * PANGO_ATTR_FAMILY
326  * font family name list (PangoAttrString)
327  * PANGO_ATTR_STYLE
328  * font slant style (PangoAttrInt)
329  * PANGO_ATTR_WEIGHT
330  * font weight (PangoAttrInt)
331  * PANGO_ATTR_VARIANT
332  * font variant (normal or small caps) (PangoAttrInt)
333  * PANGO_ATTR_STRETCH
334  * font stretch (PangoAttrInt)
335  * PANGO_ATTR_SIZE
336  * font size in points scaled by PANGO_SCALE (PangoAttrInt)
337  * PANGO_ATTR_FONT_DESC
338  * font description (PangoAttrFontDesc)
339  * PANGO_ATTR_FOREGROUND
340  * foreground color (PangoAttrColor)
341  * PANGO_ATTR_BACKGROUND
342  * background color (PangoAttrColor)
343  * PANGO_ATTR_UNDERLINE
344  * whether the text has an underline (PangoAttrInt)
345  * PANGO_ATTR_STRIKETHROUGH
346  * whether the text is struck-through (PangoAttrInt)
347  * PANGO_ATTR_RISE
348  * baseline displacement (PangoAttrInt)
349  * PANGO_ATTR_SHAPE
350  * shape (PangoAttrShape)
351  * PANGO_ATTR_SCALE
352  * font size scale factor (PangoAttrFloat)
353  * PANGO_ATTR_FALLBACK
354  * whether fallback is enabled (PangoAttrInt)
355  * PANGO_ATTR_LETTER_SPACING
356  * letter spacing (PangoAttrInt)
357  * PANGO_ATTR_UNDERLINE_COLOR
358  * underline color (PangoAttrColor)
359  * PANGO_ATTR_STRIKETHROUGH_COLOR
360  * strikethrough color (PangoAttrColor)
361  * PANGO_ATTR_ABSOLUTE_SIZE
362  * font size in pixels scaled by PANGO_SCALE (PangoAttrInt)
363  * PANGO_ATTR_GRAVITY
364  * base text gravity (PangoAttrInt)
365  * PANGO_ATTR_GRAVITY_HINT
366  * gravity hint (PangoAttrInt)
367  */
368 public enum PangoAttrType
369 {
370 	INVALID, /+* 0 is an invalid attribute type +/
371 	LANGUAGE, /+* PangoAttrLanguage +/
372 	FAMILY, /+* PangoAttrString +/
373 	STYLE, /+* PangoAttrInt +/
374 	WEIGHT, /+* PangoAttrInt +/
375 	VARIANT, /+* PangoAttrInt +/
376 	STRETCH, /+* PangoAttrInt +/
377 	SIZE, /+* PangoAttrSize +/
378 	FONT_DESC, /+* PangoAttrFontDesc +/
379 	FOREGROUND, /+* PangoAttrColor +/
380 	BACKGROUND, /+* PangoAttrColor +/
381 	UNDERLINE, /+* PangoAttrInt +/
382 	STRIKETHROUGH, /+* PangoAttrInt +/
383 	RISE, /+* PangoAttrInt +/
384 	SHAPE, /+* PangoAttrShape +/
385 	SCALE, /+* PangoAttrFloat +/
386 	FALLBACK, /+* PangoAttrInt +/
387 	LETTER_SPACING, /+* PangoAttrInt +/
388 	UNDERLINE_COLOR, /+* PangoAttrColor +/
389 	STRIKETHROUGH_COLOR,/+* PangoAttrColor +/
390 	ABSOLUTE_SIZE, /+* PangoAttrSize +/
391 	GRAVITY, /+* PangoAttrInt +/
392 	GRAVITY_HINT /+* PangoAttrInt +/
393 }
394 /**
395  * the PangoUnderline enumeration is used to specify
396  * whether text should be underlined, and if so, the type
397  * of underlining.
398  * PANGO_UNDERLINE_NONE
399  * no underline should be drawn
400  * PANGO_UNDERLINE_SINGLE
401  * a single underline should be drawn
402  * PANGO_UNDERLINE_DOUBLE
403  * a double underline should be drawn
404  * PANGO_UNDERLINE_LOW
405  * a single underline should be drawn at a position
406  *  beneath the ink extents of the text being
407  *  underlined. This should be used only for underlining
408  *  single characters, such as for keyboard
409  *  accelerators. PANGO_UNDERLINE_SINGLE should
410  *  be used for extended portions of text.
411  * PANGO_UNDERLINE_ERROR
412  * a wavy underline should be drawn below.
413  *  This underline is typically used to indicate
414  *  an error such as a possilble mispelling; in some
415  *  cases a contrasting color may automatically
416  *  be used. This type of underlining is available
417  *  since Pango 1.4.
418  */
419 public enum PangoUnderline
420 {
421 	NONE,
422 	SINGLE,
423 	DOUBLE,
424 	LOW,
425 	ERROR
426 }
427 /**
428  * A PangoTabAlign specifies where a tab stop appears relative to the text.
429  * PANGO_TAB_LEFT
430  * the tab stop appears to the left of the text.
431  */
432 public enum PangoTabAlign
433 {
434 	LEFT
435 	/+* These are not supported now, but may be inn the
436 	 * future.
437 	 *
438 	 * RIGHT,
439 	 * CENTER,
440 	 * NUMERIC
441 	+/
442 }
443 /**
444  * A PangoWrapMode describes how to wrap the lines of a PangoLayout to the desired width.
445  * PANGO_WRAP_WORD
446  * wrap lines at word boundaries.
447  * PANGO_WRAP_CHAR
448  * wrap lines at character boundaries.
449  * PANGO_WRAP_WORD_CHAR
450  * wrap lines at word boundaries, but fall back to character boundaries if there is not
451  * enough space for a full word.
452  */
453 public enum PangoWrapMode
454 {
455 	WORD,
456 	CHAR,
457 	WORD_CHAR
458 }
459 /**
460  * The PangoEllipsizeMode type describes what sort of (if any)
461  * ellipsization should be applied to a line of text. In
462  * the ellipsization process characters are removed from the
463  * text in order to make it fit to a given width and replaced
464  * with an ellipsis.
465  * PANGO_ELLIPSIZE_NONE
466  * No ellipsization
467  * PANGO_ELLIPSIZE_START
468  * Omit characters at the start of the text
469  * PANGO_ELLIPSIZE_MIDDLE
470  * Omit characters in the middle of the text
471  * PANGO_ELLIPSIZE_END
472  * Omit characters at the end of the text
473  */
474 public enum PangoEllipsizeMode
475 {
476 	NONE,
477 	START,
478 	MIDDLE,
479 	END
480 }
481 /**
482  * A PangoAlignment describes how to align the lines of a PangoLayout within the
483  * available space. If the PangoLayout is set to justify
484  * using pango_layout_set_justify(), this only has effect for partial lines.
485  * PANGO_ALIGN_LEFT
486  * Put all available space on the right
487  * PANGO_ALIGN_CENTER
488  * Center the line within the available space
489  * PANGO_ALIGN_RIGHT
490  * Put all available space on the left
491  */
492 public enum PangoAlignment
493 {
494 	LEFT,
495 	CENTER,
496 	RIGHT
497 }
498 /**
499  * The PangoScript enumeration identifies different writing
500  * systems. The values correspond to the names as defined in the
501  * Unicode standard.
502  * Note that new types may be added in the future. Applications should be ready
503  * to handle unknown values. This enumeration is interchangeable with
504  * GUnicodeScript. See Unicode Standard Annex
505  * #24: Script names.
506  * PANGO_SCRIPT_INVALID_CODE
507  * a value never returned from pango_script_for_unichar()
508  * PANGO_SCRIPT_COMMON
509  * a character used by multiple different scripts
510  * PANGO_SCRIPT_INHERITED
511  * a mark glyph that takes its script from the
512  *  base glyph to which it is attached
513  * PANGO_SCRIPT_ARABIC
514  * 	Arabic
515  * PANGO_SCRIPT_ARMENIAN
516  * Armenian
517  * PANGO_SCRIPT_BENGALI
518  * 	Bengali
519  * PANGO_SCRIPT_BOPOMOFO
520  * Bopomofo
521  * PANGO_SCRIPT_CHEROKEE
522  * 	Cherokee
523  * PANGO_SCRIPT_COPTIC
524  * 	Coptic
525  * PANGO_SCRIPT_CYRILLIC
526  * 	Cyrillic
527  * PANGO_SCRIPT_DESERET
528  * 	Deseret
529  * PANGO_SCRIPT_DEVANAGARI
530  * 	Devanagari
531  * PANGO_SCRIPT_ETHIOPIC
532  * 	Ethiopic
533  * PANGO_SCRIPT_GEORGIAN
534  * 	Georgian
535  * PANGO_SCRIPT_GOTHIC
536  * 	Gothic
537  * PANGO_SCRIPT_GREEK
538  * 	Greek
539  * PANGO_SCRIPT_GUJARATI
540  * 	Gujarati
541  * PANGO_SCRIPT_GURMUKHI
542  * 	Gurmukhi
543  * PANGO_SCRIPT_HAN
544  * 	Han
545  * PANGO_SCRIPT_HANGUL
546  * 	Hangul
547  * PANGO_SCRIPT_HEBREW
548  * 	Hebrew
549  * PANGO_SCRIPT_HIRAGANA
550  * 	Hiragana
551  * PANGO_SCRIPT_KANNADA
552  * 	Kannada
553  * PANGO_SCRIPT_KATAKANA
554  * 	Katakana
555  * PANGO_SCRIPT_KHMER
556  * 	Khmer
557  * PANGO_SCRIPT_LAO
558  * 	Lao
559  * PANGO_SCRIPT_LATIN
560  * 	Latin
561  * PANGO_SCRIPT_MALAYALAM
562  * 	Malayalam
563  * PANGO_SCRIPT_MONGOLIAN
564  * 	Mongolian
565  * PANGO_SCRIPT_MYANMAR
566  * 	Myanmar
567  * PANGO_SCRIPT_OGHAM
568  * 	Ogham
569  * PANGO_SCRIPT_OLD_ITALIC
570  * 	Old Italic
571  * PANGO_SCRIPT_ORIYA
572  * 	Oriya
573  * PANGO_SCRIPT_RUNIC
574  * 	Runic
575  * PANGO_SCRIPT_SINHALA
576  * 	Sinhala
577  * PANGO_SCRIPT_SYRIAC
578  * 	Syriac
579  * PANGO_SCRIPT_TAMIL
580  * 	Tamil
581  * PANGO_SCRIPT_TELUGU
582  * 	Telugu
583  * PANGO_SCRIPT_THAANA
584  * 	Thaana
585  * PANGO_SCRIPT_THAI
586  * 	Thai
587  * PANGO_SCRIPT_TIBETAN
588  * 	Tibetan
589  * PANGO_SCRIPT_CANADIAN_ABORIGINAL
590  * 	Canadian Aboriginal
591  * PANGO_SCRIPT_YI
592  * 	Yi
593  * PANGO_SCRIPT_TAGALOG
594  * 	Tagalog
595  * PANGO_SCRIPT_HANUNOO
596  * 	Hanunoo
597  * PANGO_SCRIPT_BUHID
598  * 	Buhid
599  * PANGO_SCRIPT_TAGBANWA
600  * 	Tagbanwa
601  * PANGO_SCRIPT_BRAILLE
602  * 	Braille
603  * PANGO_SCRIPT_CYPRIOT
604  * 	Cypriot
605  * PANGO_SCRIPT_LIMBU
606  * 	Limbu
607  * PANGO_SCRIPT_OSMANYA
608  * 	Osmanya
609  * PANGO_SCRIPT_SHAVIAN
610  * 	Shavian
611  * PANGO_SCRIPT_LINEAR_B
612  * 	Linear B
613  * PANGO_SCRIPT_TAI_LE
614  * 	Tai Le
615  * PANGO_SCRIPT_UGARITIC
616  * 	Ugaritic
617  * PANGO_SCRIPT_NEW_TAI_LUE
618  * 	New Tai Lue. Since 1.10
619  * PANGO_SCRIPT_BUGINESE
620  * 	Buginese. Since 1.10
621  * PANGO_SCRIPT_GLAGOLITIC
622  * 	Glagolitic. Since 1.10
623  * PANGO_SCRIPT_TIFINAGH
624  * 	Tifinagh. Since 1.10
625  * PANGO_SCRIPT_SYLOTI_NAGRI
626  * 	Syloti Nagri. Since 1.10
627  * PANGO_SCRIPT_OLD_PERSIAN
628  * 	Old Persian. Since 1.10
629  * PANGO_SCRIPT_KHAROSHTHI
630  * 	Kharoshthi. Since 1.10
631  * PANGO_SCRIPT_UNKNOWN
632  * 		an unassigned code point. Since 1.14
633  * PANGO_SCRIPT_BALINESE
634  * 		Balinese. Since 1.14
635  * PANGO_SCRIPT_CUNEIFORM
636  * 	Cuneiform. Since 1.14
637  * PANGO_SCRIPT_PHOENICIAN
638  * 	Phoenician. Since 1.14
639  * PANGO_SCRIPT_PHAGS_PA
640  * 		Phags-pa. Since 1.14
641  * PANGO_SCRIPT_NKO
642  * 		N'Ko. Since 1.14
643  * PANGO_SCRIPT_KAYAH_LI
644  *  Kayah Li. Since 1.20.1
645  * PANGO_SCRIPT_LEPCHA
646  *  Lepcha. Since 1.20.1
647  * PANGO_SCRIPT_REJANG
648  *  Rejang. Since 1.20.1
649  * PANGO_SCRIPT_SUNDANESE
650  *  Sundanese. Since 1.20.1
651  * PANGO_SCRIPT_SAURASHTRA
652  * Saurashtra. Since 1.20.1
653  * PANGO_SCRIPT_CHAM
654  *  Cham. Since 1.20.1
655  * PANGO_SCRIPT_OL_CHIKI
656  *  Ol Chiki. Since 1.20.1
657  * PANGO_SCRIPT_VAI
658  *  Vai. Since 1.20.1
659  * PANGO_SCRIPT_CARIAN
660  *  Carian. Since 1.20.1
661  * PANGO_SCRIPT_LYCIAN
662  *  Lycian. Since 1.20.1
663  * PANGO_SCRIPT_LYDIAN
664  *  Lydian. Since 1.20.1
665  */
666 public enum PangoScript
667 {
668 	INVALID_CODE = -1,
669 	COMMON = 0, /+* Zyyy +/
670 	INHERITED, /+* Qaai +/
671 	ARABIC, /+* Arab +/
672 	ARMENIAN, /+* Armn +/
673 	BENGALI, /+* Beng +/
674 	BOPOMOFO, /+* Bopo +/
675 	CHEROKEE, /+* Cher +/
676 	COPTIC, /+* Qaac +/
677 	CYRILLIC, /+* Cyrl (Cyrs) +/
678 	DESERET, /+* Dsrt +/
679 	DEVANAGARI, /+* Deva +/
680 	ETHIOPIC, /+* Ethi +/
681 	GEORGIAN, /+* Geor (Geon, Geoa) +/
682 	GOTHIC, /+* Goth +/
683 	GREEK, /+* Grek +/
684 	GUJARATI, /+* Gujr +/
685 	GURMUKHI, /+* Guru +/
686 	HAN, /+* Hani +/
687 	HANGUL, /+* Hang +/
688 	HEBREW, /+* Hebr +/
689 	HIRAGANA, /+* Hira +/
690 	KANNADA, /+* Knda +/
691 	KATAKANA, /+* Kana +/
692 	KHMER, /+* Khmr +/
693 	LAO, /+* Laoo +/
694 	LATIN, /+* Latn (Latf, Latg) +/
695 	MALAYALAM, /+* Mlym +/
696 	MONGOLIAN, /+* Mong +/
697 	MYANMAR, /+* Mymr +/
698 	OGHAM, /+* Ogam +/
699 	OLD_ITALIC, /+* Ital +/
700 	ORIYA, /+* Orya +/
701 	RUNIC, /+* Runr +/
702 	SINHALA, /+* Sinh +/
703 	SYRIAC, /+* Syrc (Syrj, Syrn, Syre) +/
704 	TAMIL, /+* Taml +/
705 	TELUGU, /+* Telu +/
706 	THAANA, /+* Thaa +/
707 	THAI, /+* Thai +/
708 	TIBETAN, /+* Tibt +/
709 	CANADIAN_ABORIGINAL, /+* Cans +/
710 	YI, /+* Yiii +/
711 	TAGALOG, /+* Tglg +/
712 	HANUNOO, /+* Hano +/
713 	BUHID, /+* Buhd +/
714 	TAGBANWA, /+* Tagb +/
715 	/+* Unicode-4.0 additions +/
716 	BRAILLE, /+* Brai +/
717 	CYPRIOT, /+* Cprt +/
718 	LIMBU, /+* Limb +/
719 	OSMANYA, /+* Osma +/
720 	SHAVIAN, /+* Shaw +/
721 	LINEAR_B, /+* Linb +/
722 	TAI_LE, /+* Tale +/
723 	UGARITIC, /+* Ugar +/
724 	/+* Unicode-4.1 additions +/
725 	NEW_TAI_LUE, /+* Talu +/
726 	BUGINESE, /+* Bugi +/
727 	GLAGOLITIC, /+* Glag +/
728 	TIFINAGH, /+* Tfng +/
729 	SYLOTI_NAGRI, /+* Sylo +/
730 	OLD_PERSIAN, /+* Xpeo +/
731 	KHAROSHTHI, /+* Khar +/
732 	/+* Unicode-5.0 additions +/
733 	UNKNOWN, /+* Zzzz +/
734 	BALINESE, /+* Bali +/
735 	CUNEIFORM, /+* Xsux +/
736 	PHOENICIAN, /+* Phnx +/
737 	PHAGS_PA, /+* Phag +/
738 	NKO, /+* Nkoo +/
739 	/+* Unicode-5.1 additions +/
740 	KAYAH_LI, /+* Kali +/
741 	LEPCHA, /+* Lepc +/
742 	REJANG, /+* Rjng +/
743 	SUNDANESE, /+* Sund +/
744 	SAURASHTRA, /+* Saur +/
745 	CHAM, /+* Cham +/
746 	OL_CHIKI, /+* Olck +/
747 	VAI, /+* Vaii +/
748 	CARIAN, /+* Cari +/
749 	LYCIAN, /+* Lyci +/
750 	LYDIAN /+* Lydi +/
751 }
752 /**
753  * The PangoGravity type represents the orientation of glyphs in a segment
754  * of text. This is useful when rendering vertical text layouts. In
755  * those situations, the layout is rotated using a non-identity PangoMatrix,
756  * and then glyph orientation is controlled using PangoGravity.
757  * Not every value in this enumeration makes sense for every usage of
758  * PangoGravity; for example, PANGO_GRAVITY_AUTO only can be passed to
759  * pango_context_set_base_gravity() and can only be returned by
760  * pango_context_get_base_gravity().
761  * See also: PangoGravityHint
762  * PANGO_GRAVITY_SOUTH
763  * Glyphs stand upright (default)
764  * PANGO_GRAVITY_EAST
765  * Glyphs are rotated 90 degrees clockwise
766  * PANGO_GRAVITY_NORTH
767  * Glyphs are upside-down
768  * PANGO_GRAVITY_WEST
769  * Glyphs are rotated 90 degrees counter-clockwise
770  * PANGO_GRAVITY_AUTO
771  * Gravity is resolved from the context matrix
772  * Since 1.16
773  */
774 public enum PangoGravity
775 {
776 	SOUTH,
777 	EAST,
778 	NORTH,
779 	WEST,
780 	AUTO
781 }
782 /**
783  * The PangoGravityHint defines how horizontal scripts should behave in a
784  * vertical context. That is, English excerpt in a vertical paragraph for
785  * example.
786  * See PangoGravity.
787  * PANGO_GRAVITY_HINT_NATURAL
788  * scripts will take their natural gravity based
789  * on the base gravity and the script. This is the default.
790  * PANGO_GRAVITY_HINT_STRONG
791  * always use the base gravity set, regardless of
792  * the script.
793  * PANGO_GRAVITY_HINT_LINE
794  * for scripts not in their natural direction (eg.
795  * Latin in East gravity), choose per-script gravity such that every script
796  * respects the line progression. This means, Latin and Arabic will take
797  * opposite gravities and both flow top-to-bottom for example.
798  * Since 1.16
799  */
800 public enum PangoGravityHint
801 {
802 	NATURAL,
803 	STRONG,
804 	LINE
805 }
806 /**
807  * PangoRenderPart defines different items to render for such
808  * purposes as setting colors.
809  * PANGO_RENDER_PART_FOREGROUND
810  * the text itself
811  * PANGO_RENDER_PART_BACKGROUND
812  * the area behind the text
813  * PANGO_RENDER_PART_UNDERLINE
814  * underlines
815  * PANGO_RENDER_PART_STRIKETHROUGH
816  * strikethrough lines
817  * Since 1.8
818  */
819 public enum PangoRenderPart
820 {
821 	FOREGROUND,
822 	BACKGROUND,
823 	UNDERLINE,
824 	STRIKETHROUGH
825 }
826 /**
827  * Used to indicate how well a font can represent a particular Unicode
828  * character point for a particular script.
829  * PANGO_COVERAGE_NONE
830  * The character is not representable with the font.
831  * PANGO_COVERAGE_FALLBACK
832  * The character is represented in a way that may be
833  *  comprehensible but is not the correct graphical form.
834  *  For instance, a Hangul character represented as a
835  *  a sequence of Jamos, or a Latin transliteration of
836  *  a Cyrillic word.
837  * PANGO_COVERAGE_APPROXIMATE
838  * The character is represented as basically the correct
839  *  graphical form, but with a stylistic variant inappropriate for
840  *  the current script.
841  * PANGO_COVERAGE_EXACT
842  * The character is represented as the correct graphical form.
843  */
844 public enum PangoCoverageLevel
845 {
846 	NONE,
847 	FALLBACK,
848 	APPROXIMATE,
849 	EXACT
850 }
851 
852 /**
853  * Main Gtk struct.
854  * The PangoContext structure stores global information
855  * used to control the itemization process.
856  */
857 public struct PangoContext{}
858 
859 
860 /**
861  * The PangoItem structure stores information about
862  * a segment of text. It contains the following fields:
863  * gint offset;
864  * the offset of the segment from the beginning of the
865  */
866 public struct PangoItem
867 {
868 	int offset;
869 	int length;
870 	int numChars;
871 	PangoAnalysis analysis;
872 }
873 
874 
875 /**
876  * The PangoAnalysis structure stores information about
877  * the properties of a segment of text. It has the following
878  * fields:
879  * PangoEngineShape *shape_engine;
880  * the engine for doing rendering-system-dependent processing.
881  * PangoEngineLang *lang_engine;
882  * the engine for doing rendering-system-independent processing.
883  * PangoFont *font;
884  * the font for this segment.
885  * guint8 level;
886  * the bidirectional level for this segment.
887  * guint8 gravity;
888  * the glyph orientation for this segment (A PangoGravity).
889  * guint8 flags;
890  * boolean flags for this segment (currently only one) (Since: 1.16).
891  * guint8 script;
892  * the detected script for this segment (A PangoScript) (Since: 1.18).
893  * PangoLanguage *language;
894  * the detected language for this segment.
895  * GSList *extra_attrs;
896  * extra attributes for this segment.
897  */
898 public struct PangoAnalysis
899 {
900 	PangoEngineShape *shapeEngine;
901 	PangoEngineLang *langEngine;
902 	PangoFont *font;
903 	ubyte level;
904 	ubyte gravity; /+* PangoGravity +/
905 	ubyte flags;
906 	ubyte script; /+* PangoScript +/
907 	PangoLanguage *language;
908 	GSList *extraAttrs;
909 }
910 
911 
912 /**
913  * The PangoLogAttr structure stores information
914  * about the attributes of a single character.
915  * guint is_line_break : 1;
916  * if set, can break line in front of character
917  * guint is_mandatory_break : 1;
918  * if set, must break line in front of character
919  * guint is_char_break : 1;
920  * if set, can break here when doing character wrapping
921  * guint is_white : 1;
922  * is whitespace character
923  * guint is_cursor_position : 1;
924  * if set, cursor can appear in front of character.
925  */
926 public struct PangoLogAttr
927 {
928 	uint bitfield0;
929 	//uint isLineBreak : 1; /+* Can break line inn front of character +/
930 	//uint isMandatoryBreak : 1; /+* Must break line inn front of character +/
931 	//uint isCharBreak : 1; /+* Can break here when doing char wrap +/
932 	//uint isWhite : 1; /+* Whitespace character +/
933 	/+* Cursor can appear inn front of character (i.e. this is a grapheme
934 	 * boundary, or the first character inn the text).
935 	+/
936 	//uint isCursorPosition : 1;
937 	/+* Note that inn degenerate cases, you could have both start/end set on
938 	 * some text, most likely for sentences (e.g. no space after a period, so
939 	 * the next sentence starts right away).
940 	+/
941 	//uint isWordStart : 1; /+* first character inn a word +/
942 	//uint isWordEnd : 1; /+* is first non-word char after a word +/
943 	/+* There are two ways to divide sentences. The first assigns all
944 	 * intersentence whitespace/control/format chars to some sentence,
945 	 * so all chars are inn some sentence; isSentenceBoundary denotes
946 	 * the boundaries there. The second way doesn't assign
947 	 * between-sentence spaces, etc. to any sentence, so
948 	 * isSentenceStart/isSentenceEnd mark the boundaries of those
949 	 * sentences.
950 	+/
951 	//uint isSentenceBoundary : 1;
952 	//uint isSentenceStart : 1; /+* first character inn a sentence +/
953 	//uint isSentenceEnd : 1; /+* first non-sentence char after a sentence +/
954 	/+* If set, backspace deletes one character rather than
955 	 * the entire grapheme cluster.
956 	+/
957 	//uint backspaceDeletesCharacter : 1;
958 	/+* Only few space variants (U+0020 and U+00A0) have variable
959 	 * width during justification.
960 	+/
961 	//uint isExpandableSpace : 1;
962 	/+* Word boundary as defined by UAX#29 +/
963 	//uint isWordBoundary : 1; /+* is NOT inn the middle of a word +/
964 }
965 
966 
967 /**
968  * The PangoRectangle structure represents a rectangle. It is frequently
969  * used to represent the logical or ink extents of a single glyph or section
970  * of text. (See, for instance, pango_font_get_glyph_extents())
971  * int x;
972  * X coordinate of the left side of the rectangle.
973  * int y;
974  * Y coordinate of the the top side of the rectangle.
975  * int width;
976  * width of the rectangle.
977  * int height;
978  * height of the rectangle.
979  */
980 public struct PangoRectangle
981 {
982 	int x;
983 	int y;
984 	int width;
985 	int height;
986 }
987 
988 
989 /**
990  * Main Gtk struct.
991  * A structure specifying a transformation between user-space
992  * coordinates and device coordinates. The transformation
993  * is given by
994  * x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
995  * y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
996  * double xx;
997  * 1st component of the transformation matrix
998  * double xy;
999  * 2nd component of the transformation matrix
1000  * double yx;
1001  * 3rd component of the transformation matrix
1002  * double yy;
1003  * 4th component of the transformation matrix
1004  * double x0;
1005  * x translation
1006  * double y0;
1007  * y translation
1008  * Since 1.6
1009  */
1010 public struct PangoMatrix
1011 {
1012 	double xx;
1013 	double xy;
1014 	double yx;
1015 	double yy;
1016 	double x0;
1017 	double y0;
1018 }
1019 
1020 
1021 /**
1022  * The PangoGlyphInfo structure represents a single glyph together with
1023  * positioning information and visual attributes.
1024  * It contains the following fields.
1025  * PangoGlyph glyph;
1026  * the glyph itself.
1027  * PangoGlyphGeometry geometry;
1028  * the positional information about the glyph.
1029  * PangoGlyphVisAttr attr;
1030  * the visual attributes of the glyph.
1031  */
1032 public struct PangoGlyphInfo
1033 {
1034 	PangoGlyph glyph;
1035 	PangoGlyphGeometry geometry;
1036 	PangoGlyphVisAttr attr;
1037 }
1038 
1039 
1040 /**
1041  * The PangoGlyphGeometry structure contains width and positioning
1042  * information for a single glyph.
1043  * PangoGlyphUnit width;
1044  * the logical width to use for the the character.
1045  * PangoGlyphUnit x_offset;
1046  * horizontal offset from nominal character position.
1047  * PangoGlyphUnit y_offset;
1048  * vertical offset from nominal character position.
1049  */
1050 public struct PangoGlyphGeometry
1051 {
1052 	PangoGlyphUnit width;
1053 	PangoGlyphUnit xOffset;
1054 	PangoGlyphUnit yOffset;
1055 }
1056 
1057 
1058 /**
1059  * The PangoGlyphVisAttr is used to communicate information between
1060  * the shaping phase and the rendering phase. More attributes may be
1061  * added in the future.
1062  * guint is_cluster_start : 1;
1063  * set for the first logical glyph in each cluster. (Clusters
1064  */
1065 public struct PangoGlyphVisAttr
1066 {
1067 	uint bitfield0;
1068 	//uint isClusterStart : 1;
1069 }
1070 
1071 
1072 /**
1073  * The PangoGlyphString structure is used to store strings
1074  * of glyphs with geometry and visual attribute information.
1075  * The storage for the glyph information is owned
1076  * by the structure which simplifies memory management.
1077  * gint num_glyphs;
1078  * the number of glyphs in the string.
1079  * PangoGlyphInfo *glyphs;
1080  * an array of PangoGlyphInfo structures of length num_glyphs.
1081  * gint *log_clusters;
1082  * for each glyph, byte index of the starting character for the
1083  * cluster. The indices are relative to the start of the text
1084  * corresponding to the PangoGlyphString.
1085  */
1086 public struct PangoGlyphString
1087 {
1088 	int numGlyphs;
1089 	PangoGlyphInfo *glyphs;
1090 	/+* This is a memory inefficient way of representing the information
1091 	 * here - each value gives the byte index within the text
1092 	 * corresponding to the glyph string of the start of the cluster to
1093 	 * which the glyph belongs.
1094 	+/
1095 	int *logClusters;
1096 }
1097 
1098 
1099 /**
1100  * A PangoGlyphItem is a pair of a PangoItem and the glyphs
1101  * resulting from shaping the text corresponding to an item.
1102  * As an example of the usage of PangoGlyphItem, the results
1103  * of shaping text with PangoLayout is a list of PangoLayoutLine,
1104  * each of which contains a list of PangoGlyphItem.
1105  * PangoItem *item;
1106  * a PangoItem structure that provides information
1107  */
1108 public struct PangoGlyphItem
1109 {
1110 	PangoItem *item;
1111 	PangoGlyphString *glyphs;
1112 }
1113 
1114 
1115 /**
1116  * A PangoGlyphItemIter is an iterator over the clusters in a
1117  * PangoGlyphItem. The forward direction of the
1118  * iterator is the logical direction of text. That is, with increasing
1119  * start_index and start_char values. If glyph_item is right-to-left
1120  * (that is, if glyph_item->item->analysis.level is odd),
1121  * then start_glyph decreases as the iterator moves forward. Moreover,
1122  * in right-to-left cases, start_glyph is greater than end_glyph.
1123  * An iterator should be initialized using either of
1124  * pango_glyph_item_iter_init_start() and
1125  * pango_glyph_item_iter_init_end(), for forward and backward iteration
1126  * respectively, and walked over using any desired mixture of
1127  * pango_glyph_item_iter_next_cluster() and
1128  * pango_glyph_item_iter_prev_cluster(). A common idiom for doing a
1129  * forward iteration over the clusters is:
1130  * PangoGlyphItemIter cluster_iter;
1131  * gboolean have_cluster;
1132  * for (have_cluster = pango_glyph_item_iter_init_start (cluster_iter,
1133  */
1134 public struct PangoGlyphItemIter
1135 {
1136 	PangoGlyphItem *glyphItem;
1137 	char *text;
1138 	int startGlyph;
1139 	int startIndex;
1140 	int startChar;
1141 	int endGlyph;
1142 	int endIndex;
1143 	int endChar;
1144 }
1145 
1146 
1147 /**
1148  * The PangoFontDescription structure represents the description
1149  * of an ideal font. These structures are used both to list
1150  * what fonts are available on the system and also for specifying
1151  * the characteristics of a font to load.
1152  */
1153 public struct PangoFontDescription{}
1154 
1155 
1156 /**
1157  * A PangoFontMetrics structure holds the overall metric information
1158  * for a font (possibly restricted to a script). The fields of this
1159  * structure are private to implementations of a font backend. See
1160  * the documentation of the corresponding getters for documentation
1161  * of their meaning.
1162  * guint ref_count;
1163  * reference count. Used internally. See pango_font_metrics_ref()
1164  */
1165 public struct PangoFontMetrics
1166 {
1167 	uint refCount;
1168 	int ascent;
1169 	int descent;
1170 	int approximateCharWidth;
1171 	int approximateDigitWidth;
1172 	int underlinePosition;
1173 	int underlineThickness;
1174 	int strikethroughPosition;
1175 	int strikethroughThickness;
1176 }
1177 
1178 
1179 /**
1180  * Main Gtk struct.
1181  * The PangoFont structure is used to represent
1182  * a font in a rendering-system-independent matter.
1183  * To create an implementation of a PangoFont,
1184  * the rendering-system specific code should allocate
1185  * a larger structure that contains a nested
1186  * PangoFont, fill in the klass member of
1187  * the nested PangoFont with a pointer to
1188  * a appropriate PangoFontClass, then call
1189  * pango_font_init() on the structure.
1190  * The PangoFont structure contains one member
1191  * which the implementation fills in.
1192  */
1193 public struct PangoFont{}
1194 
1195 
1196 /**
1197  * The PangoFontFamily structure is used to represent a family of related
1198  * font faces. The faces in a family share a common design, but differ in
1199  * slant, weight, width and other aspects.
1200  */
1201 public struct PangoFontFamily{}
1202 
1203 
1204 /**
1205  * The PangoFontFace structure is used to represent a group of fonts with
1206  * the same family, slant, weight, width, but varying sizes.
1207  */
1208 public struct PangoFontFace{}
1209 
1210 
1211 /**
1212  * The PangoFontMap represents the set of fonts available for a
1213  * particular rendering system. This is a virtual object with
1214  * implementations being specific to particular rendering systems. To
1215  * create an implementation of a PangoFontMap, the rendering-system
1216  * specific code should allocate a larger structure that contains a nested
1217  * PangoFontMap, fill in the klass member of the nested PangoFontMap with a
1218  * pointer to a appropriate PangoFontMapClass, then call
1219  * pango_font_map_init() on the structure.
1220  * The PangoFontMap structure contains one member which the implementation
1221  * fills in.
1222  */
1223 public struct PangoFontMap{}
1224 
1225 
1226 /**
1227  * The PangoFontMapClass structure holds the virtual functions for
1228  * a particular PangoFontMap implementation.
1229  * GObjectClass parent_class;
1230  * parent GObjectClass.
1231  * load_font ()
1232  * a function to load a font with a given description. See
1233  */
1234 public struct PangoFontMapClass
1235 {
1236 	GObjectClass parentClass;
1237 	extern(C) PangoFont * function(PangoFontMap* fontmap, PangoContext* context, PangoFontDescription* desc) loadFont;
1238 	extern(C) void function(PangoFontMap* fontmap, PangoFontFamily*** families, int* nFamilies) listFamilies;
1239 	extern(C) PangoFontset * function(PangoFontMap* fontmap, PangoContext* context, PangoFontDescription* desc, PangoLanguage* language) loadFontset;
1240 	char *shapeEngineType;
1241 }
1242 
1243 
1244 /**
1245  * A PangoFontset represents a set of PangoFont to use
1246  * when rendering text. It is the result of resolving a
1247  * PangoFontDescription against a particular PangoContext.
1248  * It has operations for finding the component font for
1249  * a particular Unicode character, and for finding a composite
1250  * set of metrics for the entire fontset.
1251  */
1252 public struct PangoFontset{}
1253 
1254 
1255 /**
1256  * The PangoFontsetClass structure holds the virtual functions for
1257  * a particular PangoFontset implementation.
1258  * GObjectClass parent_class;
1259  * parent GObjectClass.
1260  * get_font ()
1261  * a function to get the font in the fontset that contains the
1262  */
1263 public struct PangoFontsetClass
1264 {
1265 	GObjectClass parentClass;
1266 	extern(C) PangoFont * function(PangoFontset* fontset, uint wc) getFont;
1267 	extern(C) PangoFontMetrics * function(PangoFontset* fontset) getMetrics;
1268 	extern(C) PangoLanguage * function(PangoFontset* fontset) getLanguage;
1269 	extern(C) void function(PangoFontset* fontset, PangoFontsetForeachFunc func, void* data) foreac;
1270 }
1271 
1272 
1273 /**
1274  * PangoFontsetSimple is a implementation of the abstract
1275  * PangoFontset base class in terms of an array of fonts,
1276  * which the creator provides when constructing the
1277  * PangoFontsetSimple.
1278  */
1279 public struct PangoFontsetSimple{}
1280 
1281 
1282 /**
1283  * The PangoAttrClass structure stores the type and operations for
1284  * a particular type of attribute. The functions in this structure should
1285  * not be called directly. Instead, one should use the wrapper functions
1286  * provided for PangoAttribute.
1287  * PangoAttrType type;
1288  * the type ID for this attribute
1289  * copy ()
1290  * function to duplicate an attribute of this type (see pango_attribute_copy())
1291  * destroy ()
1292  * function to free an attribute of this type (see pango_attribute_destroy())
1293  * equal ()
1294  * function to check two attributes of this type for equality (see pango_attribute_equal())
1295  */
1296 public struct PangoAttrClass
1297 {
1298 	PangoAttrType type;
1299 	extern(C) PangoAttribute * function(PangoAttribute* attr) copy;
1300 	extern(C) void function(PangoAttribute* attr) destroy;
1301 	extern(C) int function(PangoAttribute* attr1, PangoAttribute* attr2) equal;
1302 }
1303 
1304 
1305 /**
1306  * Main Gtk struct.
1307  * The PangoAttribute structure represents the common portions of all
1308  * attributes. Particular types of attributes include this structure
1309  * as their initial portion. The common portion of the attribute holds
1310  * the range to which the value in the type-specific part of the attribute
1311  * applies and should be initialized using pango_attribute_init().
1312  * By default an attribute will have an all-inclusive range of [0,G_MAXUINT].
1313  * const PangoAttrClass *klass;
1314  * the class structure holding information about the type of the attribute
1315  * guint start_index;
1316  * the start index of the range (in bytes).
1317  * guint end_index;
1318  * end index of the range (in bytes). The character at this index
1319  */
1320 public struct PangoAttribute
1321 {
1322 	PangoAttrClass *klass;
1323 	uint startIndex; /+* inn bytes +/
1324 	uint endIndex; /+* inn bytes. The character at this index is not included +/
1325 }
1326 
1327 
1328 /**
1329  * The PangoAttrString structure is used to represent attributes with
1330  * a string value.
1331  * PangoAttribute attr;
1332  * the common portion of the attribute
1333  * char *value;
1334  * the string which is the value of the attribute
1335  */
1336 public struct PangoAttrString
1337 {
1338 	PangoAttribute attr;
1339 	char *value;
1340 }
1341 
1342 
1343 /**
1344  * The PangoAttrLanguage structure is used to represent attributes that
1345  * are languages.
1346  * PangoAttribute attr;
1347  * the common portion of the attribute
1348  * PangoLanguage *value;
1349  * the PangoLanguage which is the value of the attribute
1350  */
1351 public struct PangoAttrLanguage
1352 {
1353 	PangoAttribute attr;
1354 	PangoLanguage *value;
1355 }
1356 
1357 
1358 /**
1359  * The PangoAttrColor structure is used to represent attributes that
1360  * are colors.
1361  * PangoAttribute attr;
1362  * the common portion of the attribute
1363  * PangoColor color;
1364  * the PangoColor which is the value of the attribute
1365  */
1366 public struct PangoAttrColor
1367 {
1368 	PangoAttribute attr;
1369 	PangoColor color;
1370 }
1371 
1372 
1373 /**
1374  * The PangoAttrInt structure is used to represent attributes with
1375  * an integer or enumeration value.
1376  * PangoAttribute attr;
1377  * the common portion of the attribute
1378  * int value;
1379  * the value of the attribute
1380  */
1381 public struct PangoAttrInt
1382 {
1383 	PangoAttribute attr;
1384 	int value;
1385 }
1386 
1387 
1388 /**
1389  * The PangoAttrFloat structure is used to represent attributes with
1390  * a float or double value.
1391  * PangoAttribute attr;
1392  * the common portion of the attribute
1393  * double value;
1394  * the value of the attribute
1395  */
1396 public struct PangoAttrFloat
1397 {
1398 	PangoAttribute attr;
1399 	double value;
1400 }
1401 
1402 
1403 /**
1404  * The PangoAttrFontDesc structure is used to store an attribute that
1405  * sets all aspects of the font description at once.
1406  * PangoAttribute attr;
1407  * the common portion of the attribute
1408  * PangoFontDescription *desc;
1409  * the font description which is the value of this attribute
1410  */
1411 public struct PangoAttrFontDesc
1412 {
1413 	PangoAttribute attr;
1414 	PangoFontDescription *desc;
1415 }
1416 
1417 
1418 /**
1419  * The PangoAttrShape structure is used to represent attributes which
1420  * impose shape restrictions.
1421  * PangoAttribute attr;
1422  * the common portion of the attribute
1423  * PangoRectangle ink_rect;
1424  * the ink rectangle to restrict to
1425  * PangoRectangle logical_rect;
1426  * the logical rectangle to restrict to
1427  * gpointer data;
1428  * user data set (see pango_attr_shape_new_with_data())
1429  * PangoAttrDataCopyFunc copy_func;
1430  * copy function for the user data
1431  * GDestroyNotify destroy_func;
1432  * destroy function for the user data
1433  */
1434 public struct PangoAttrShape
1435 {
1436 	PangoAttribute attr;
1437 	PangoRectangle inkRect;
1438 	PangoRectangle logicalRect;
1439 	void* data;
1440 	PangoAttrDataCopyFunc copyFunc;
1441 	GDestroyNotify destroyFunc;
1442 }
1443 
1444 
1445 /**
1446  * The PangoAttrShape structure is used to represent attributes which
1447  * set font size.
1448  * PangoAttribute attr;
1449  * the common portion of the attribute
1450  * int size;
1451  * size of font, in units of 1/PANGO_SCALE of a point (for
1452  */
1453 public struct PangoAttrSize
1454 {
1455 	PangoAttribute attr;
1456 	int size;
1457 	uint bitfield0;
1458 	//uint absolute : 1;
1459 }
1460 
1461 
1462 /**
1463  * The PangoColor structure is used to
1464  * represent a color in an uncalibrated RGB color-space.
1465  * guint16 red;
1466  * The red component of the color. This is a value between 0 and 65535,
1467  */
1468 public struct PangoColor
1469 {
1470 	ushort red;
1471 	ushort green;
1472 	ushort blue;
1473 }
1474 
1475 
1476 /**
1477  * The PangoAttrList structure represents a list of attributes
1478  * that apply to a section of text. The attributes are, in general,
1479  * allowed to overlap in an arbitrary fashion, however, if the
1480  * attributes are manipulated only through pango_attr_list_change(),
1481  * the overlap between properties will meet stricter criteria.
1482  * Since the PangoAttrList structure is stored as a linear list,
1483  * it is not suitable for storing attributes for large amounts
1484  * of text. In general, you should not use a single PangoAttrList
1485  * for more than one paragraph of text.
1486  */
1487 public struct PangoAttrList{}
1488 
1489 
1490 /**
1491  * The PangoAttrIterator structure is used to represent an
1492  * iterator through a PangoAttrList. A new iterator is created
1493  * with pango_attr_list_get_iterator(). Once the iterator
1494  * is created, it can be advanced through the style changes
1495  * in the text using pango_attr_iterator_next(). At each
1496  * style change, the range of the current style segment and the
1497  * attributes currently in effect can be queried.
1498  */
1499 public struct PangoAttrIterator{}
1500 
1501 
1502 /**
1503  * Main Gtk struct.
1504  * A PangoTabArray struct contains an array
1505  * of tab stops. Each tab stop has an alignment and a position.
1506  */
1507 public struct PangoTabArray{}
1508 
1509 
1510 /**
1511  * Main Gtk struct.
1512  * The PangoLayout structure represents an entire paragraph
1513  * of text. It is initialized with a PangoContext, UTF-8 string
1514  * and set of attributes for that string. Once that is done, the
1515  * set of formatted lines can be extracted from the object,
1516  * the layout can be rendered, and conversion between logical
1517  * character positions within the layout's text, and the physical
1518  * position of the resulting glyphs can be made.
1519  * There are also a number of parameters to adjust the formatting
1520  * of a PangoLayout, which are illustrated in Figure 1, “Adjustable parameters for a PangoLayout”.
1521  * It is possible, as well, to ignore the 2-D setup, and simply
1522  * treat the results of a PangoLayout as a list of lines.
1523  * Figure 1. Adjustable parameters for a PangoLayout
1524  * The PangoLayout structure is opaque, and has no user-visible
1525  * fields.
1526  */
1527 public struct PangoLayout{}
1528 
1529 
1530 /**
1531  * A PangoLayoutIter structure can be used to
1532  * iterate over the visual extents of a PangoLayout.
1533  * The PangoLayoutIter structure is opaque, and
1534  * has no user-visible fields.
1535  */
1536 public struct PangoLayoutIter{}
1537 
1538 
1539 /**
1540  * The PangoLayoutLine structure represents one of the lines resulting
1541  * from laying out a paragraph via PangoLayout. PangoLayoutLine
1542  * structures are obtained by calling pango_layout_get_line() and
1543  * are only valid until the text, attributes, or settings of the
1544  * parent PangoLayout are modified.
1545  * Routines for rendering PangoLayout objects are provided in
1546  * code specific to each rendering system.
1547  * PangoLayout *layout;
1548  * the parent layout for this line
1549  * gint start_index;
1550  * the start of the line as byte index into layout->text
1551  * gint length;
1552  * the length of the line in bytes
1553  * GSList *runs;
1554  * a list containing the runs of the line in visual order
1555  * guint is_paragraph_start : 1;
1556  * TRUE if this is the first line of the paragraph
1557  * guint resolved_dir : 3;
1558  * the resolved PangoDirection of the line
1559  */
1560 public struct PangoLayoutLine
1561 {
1562 	PangoLayout *layout;
1563 	int startIndex; /+* start of line as byte index into layout->text +/
1564 	int length; /+* length of line inn bytes +/
1565 	GSList *runs;
1566 	uint bitfield0;
1567 	//uint isParagraphStart : 1; /+* TRUE if this is the first line of the paragraph +/
1568 	//uint resolvedDir : 3; /+* Resolved PangoDirection of line +/
1569 }
1570 
1571 
1572 /**
1573  * A PangoScriptIter is used to iterate through a string
1574  * and identify ranges in different scripts.
1575  */
1576 public struct PangoScriptIter{}
1577 
1578 
1579 /**
1580  * The PangoLanguage structure is used to
1581  * represent a language.
1582  * PangoLanguage pointers can be efficiently
1583  * copied and compared with each other.
1584  */
1585 public struct PangoLanguage{}
1586 
1587 
1588 /**
1589  * PangoCairoFont is an interface exported by fonts for
1590  * use with Cairo. The actual type of the font will depend
1591  * on the particular font technology Cairo was compiled to use.
1592  * Since 1.18
1593  */
1594 public struct PangoCairoFont{}
1595 
1596 
1597 /**
1598  * PangoCairoFontMap is an interface exported by font maps for
1599  * use with Cairo. The actual type of the font map will depend
1600  * on the particular font technology Cairo was compiled to use.
1601  * Since 1.10
1602  */
1603 public struct PangoCairoFontMap{}
1604 
1605 
1606 /**
1607  * Main Gtk struct.
1608  * PangoRenderer is a base class for objects that are used to
1609  * render Pango objects such as PangoGlyphString and
1610  * PangoLayout.
1611  * PangoMatrix *matrix;
1612  * the current transformation matrix for the Renderer; may
1613  */
1614 public struct PangoRenderer
1615 {
1616 	PangoMatrix *matrix; /+* May be NULL +/
1617 }
1618 
1619 
1620 /**
1621  * Class structure for PangoRenderer.
1622  * draw_glyphs ()
1623  * draws a PangoGlyphString
1624  * draw_rectangle ()
1625  * draws a rectangle
1626  * draw_error_underline ()
1627  * draws a squiggly line that approximately
1628  * covers the given rectangle in the style of an underline used to
1629  * indicate a spelling error.
1630  * draw_shape ()
1631  * draw content for a glyph shaped with PangoAttrShape.
1632  */
1633 public struct PangoRendererClass
1634 {
1635 	/+* All of the following have defaulx implementations
1636 	 * and take as coordinates user coordinates inn Pango units
1637 	+/
1638 	extern(C) void function(PangoRenderer* renderer, PangoFont* font, PangoGlyphString* glyphs, int x, int y) drawGlyphs;
1639 	extern(C) void function(PangoRenderer* renderer, PangoRenderPart part, int x, int y, int width, int height) drawRectangle;
1640 	extern(C) void function(PangoRenderer* renderer, int x, int y, int width, int height) drawErrorUnderline;
1641 	/+* Nothing is drawn for shaped glyphs unless this is implemented +/
1642 	extern(C) void function(PangoRenderer* renderer, PangoAttrShape* attr, int x, int y) drawShape;
1643 	/+* These two must be implemented and take coordinates inn
1644 	 * device space as doubles.
1645 	+/
1646 	extern(C) void function(PangoRenderer* renderer, PangoRenderPart part, double y1_, double x11, double x21, double y2, double x12, double x22) drawTrapezoid;
1647 	extern(C) void function(PangoRenderer* renderer, PangoFont* font, PangoGlyph glyph, double x, double y) drawGlyph;
1648 	/+* Notification of change inn rendering attributes
1649 	+/
1650 	extern(C) void function(PangoRenderer* renderer, PangoRenderPart part) partChanged;
1651 	/+* Paired around drawing operations
1652 	+/
1653 	extern(C) void function(PangoRenderer* renderer) begin;
1654 	extern(C) void function(PangoRenderer* renderer) end;
1655 	/+* Hooks into the details of layout rendering
1656 	+/
1657 	extern(C) void function(PangoRenderer* renderer, PangoLayoutRun* run) prepareRun;
1658 	/+* All of the following have defaulx implementations
1659 	 * and take as coordinates user coordinates inn Pango units
1660 	+/
1661 	extern(C) void function(PangoRenderer* renderer, char* text, PangoGlyphItem* glyphItem, int x, int y) drawGlyphItem;
1662 }
1663 
1664 
1665 /**
1666  * Main Gtk struct.
1667  * The PangoCoverage structure represents a map from Unicode characters
1668  * to PangoCoverageLevel. It is an opaque structure with no public fields.
1669  */
1670 public struct PangoCoverage{}
1671 
1672 
1673 /**
1674  * The PangoEngineInfo structure contains information about a particular
1675  * engine. It contains the following fields:
1676  * const gchar *id;
1677  * a unique string ID for the engine.
1678  * const gchar *engine_type;
1679  * a string identifying the engine type.
1680  * const gchar *render_type;
1681  * a string identifying the render type.
1682  * PangoEngineScriptInfo *scripts;
1683  * array of scripts this engine supports.
1684  * gint n_scripts;
1685  * number of items in scripts.
1686  */
1687 public struct PangoEngineInfo
1688 {
1689 	char *id;
1690 	char *engineType;
1691 	char *renderType;
1692 	PangoEngineScriptInfo *scripts;
1693 	int nScripts;
1694 }
1695 
1696 
1697 /**
1698  * The PangoEngineScriptInfo structure contains
1699  * information about how the shaper covers a particular
1700  * script.
1701  * PangoScript script;
1702  * a PangoScript. The value PANGO_SCRIPT_COMMON has
1703  */
1704 public struct PangoEngineScriptInfo
1705 {
1706 	PangoScript script;
1707 	char *langs;
1708 }
1709 
1710 
1711 /**
1712  * Main Gtk struct.
1713  * PangoEngine is the base class for all types of language and
1714  * script specific engines. It has no functionality by itself.
1715  */
1716 public struct PangoEngine{}
1717 
1718 
1719 /**
1720  * Class structure for PangoEngine
1721  */
1722 public struct PangoEngineClass{}
1723 
1724 
1725 /**
1726  * Main Gtk struct.
1727  * The PangoEngineLang class is implemented by engines that
1728  * customize the rendering-system independent part of the
1729  * Pango pipeline for a particular script or language. For
1730  * instance, a custom PangoEngineLang could be provided for
1731  * Thai to implement the dictionary-based word boundary
1732  * lookups needed for that language.
1733  */
1734 public struct PangoEngineLang{}
1735 
1736 
1737 /**
1738  * Class structure for PangoEngineLang
1739  * script_break ()
1740  * Provides a custom implementation of pango_break().
1741  * If NULL, pango_default_break() is used instead. If not NULL, for
1742  * Pango versions before 1.16 (module interface version before 1.6.0),
1743  * this was called instead of pango_default_break(), but in newer versions,
1744  * pango_default_break() is always called and this is called after that to
1745  * allow tailoring the breaking results.
1746  */
1747 public struct PangoEngineLangClass
1748 {
1749 	extern(C) void function(PangoEngineLang* engine, char* text, int len, PangoAnalysis* analysis, PangoLogAttr* attrs, int attrsLen) scriptBreak;
1750 }
1751 
1752 
1753 /**
1754  * Main Gtk struct.
1755  * The PangoEngineShape class is implemented by engines that
1756  * customize the rendering-system dependent part of the
1757  * Pango pipeline for a particular script or language.
1758  * A PangoEngineShape implementation is then specific to both
1759  * a particular rendering system or group of rendering systems
1760  * and to a particular script. For instance, there is one
1761  * PangoEngineShape implementation to handle shaping Arabic
1762  * for Fontconfig-based backends.
1763  */
1764 public struct PangoEngineShape{}
1765 
1766 
1767 /**
1768  * Class structure for PangoEngineShape
1769  * script_shape ()
1770  * Given a font, a piece of text, and a PangoAnalysis
1771  */
1772 public struct PangoEngineShapeClass
1773 {
1774 	extern(C) void function(PangoEngineShape* engine, PangoFont* font, char* text, int length, PangoAnalysis* analysis, PangoGlyphString* glyphs) scriptShape;
1775 	extern(C) PangoCoverageLevel function(PangoEngineShape* engine, PangoFont* font, PangoLanguage* language, gunichar wc) covers;
1776 }
1777 
1778 
1779 /*
1780  * Converts a dimension to device units by rounding.
1781  * d :
1782  * a dimension in Pango units.
1783  * Returns :
1784  * rounded dimension in device units.
1785  */
1786 // TODO
1787 // #define PANGO_PIXELS(d) (((int)(d) + 512) >> 10)
1788 
1789 /*
1790  * Converts a dimension to device units by flooring.
1791  * d :
1792  * a dimension in Pango units.
1793  * Returns :
1794  * floored dimension in device units.
1795  * Since 1.14
1796  */
1797 // TODO
1798 // #define PANGO_PIXELS_FLOOR(d) (((int)(d)) >> 10)
1799 
1800 /*
1801  * Converts a dimension to device units by ceiling.
1802  * d :
1803  * a dimension in Pango units.
1804  * Returns :
1805  * ceiled dimension in device units.
1806  * Since 1.14
1807  */
1808 // TODO
1809 // #define PANGO_PIXELS_CEIL(d) (((int)(d) + 1023) >> 10)
1810 
1811 /*
1812  * Rounds a dimension to whole device units, but does not
1813  * convert it to device units.
1814  * d :
1815  * a dimension in Pango units.
1816  * Returns :
1817  * rounded dimension in Pango units.
1818  * Since 1.18
1819  */
1820 // TODO
1821 // #define PANGO_UNITS_ROUND(d)
1822 
1823 /*
1824  * Extracts the ascent from a PangoRectangle
1825  * representing glyph extents. The ascent is the distance from the
1826  * baseline to the highest point of the character. This is positive if the
1827  * glyph ascends above the baseline.
1828  * rect :
1829  * a PangoRectangle
1830  */
1831 // TODO
1832 // #define PANGO_ASCENT(rect) (-(rect).y)
1833 
1834 /*
1835  * Extracts the descent from a PangoRectangle
1836  * representing glyph extents. The descent is the distance from the
1837  * baseline to the lowest point of the character. This is positive if the
1838  * glyph descends below the baseline.
1839  * rect :
1840  * a PangoRectangle
1841  */
1842 // TODO
1843 // #define PANGO_DESCENT(rect) ((rect).y + (rect).height)
1844 
1845 /*
1846  * Extracts the left bearing from a PangoRectangle
1847  * representing glyph extents. The left bearing is the distance from the
1848  * horizontal origin to the farthest left point of the character.
1849  * This is positive for characters drawn completely to the right of the
1850  * glyph origin.
1851  * rect :
1852  * a PangoRectangle
1853  */
1854 // TODO
1855 // #define PANGO_LBEARING(rect) ((rect).x)
1856 
1857 /*
1858  * Extracts the right bearing from a PangoRectangle
1859  * representing glyph extents. The right bearing is the distance from the
1860  * horizontal origin to the farthest right point of the character.
1861  * This is positive except for characters drawn completely to the left of the
1862  * horizontal origin.
1863  * rect :
1864  * a PangoRectangle
1865  */
1866 // TODO
1867 // #define PANGO_RBEARING(rect) ((rect).x + (rect).width)
1868 
1869 /*
1870  * Returns a PangoGlyph value that means no glyph was found for wc.
1871  * The way this unknown glyphs are rendered is backend specific. For example,
1872  * a box with the hexadecimal Unicode code-point of the character written in it
1873  * is what is done in the most common backends.
1874  * wc :
1875  * a Unicode character
1876  */
1877 // TODO
1878 // #define PANGO_GET_UNKNOWN_GLYPH(wc) ((PangoGlyph)(wc)|PANGO_GLYPH_UNKNOWN_FLAG)
1879 
1880 /*
1881  * Casts a GObject to a PangoFont.
1882  * object :
1883  * a GObject.
1884  */
1885 // TODO
1886 // #define PANGO_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT, PangoFont))
1887 
1888 /*
1889  * Returns TRUE if object is a PangoFont.
1890  * object :
1891  * a GObject.
1892  */
1893 // TODO
1894 // #define PANGO_IS_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT))
1895 
1896 /*
1897  * Casts a GObject to a PangoFontFamily.
1898  * object :
1899  * a GObject.
1900  */
1901 // TODO
1902 // #define PANGO_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FAMILY, PangoFontFamily))
1903 
1904 /*
1905  * Returns TRUE if object is a PangoFontFamily.
1906  * object :
1907  * a GObject.
1908  */
1909 // TODO
1910 // #define PANGO_IS_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FAMILY))
1911 
1912 /*
1913  * Casts a GObject to a PangoFontFace.
1914  * object :
1915  * a GObject.
1916  */
1917 // TODO
1918 // #define PANGO_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FACE, PangoFontFace))
1919 
1920 /*
1921  * Returns TRUE if object is a PangoFontFace.
1922  * object :
1923  * a GObject.
1924  */
1925 // TODO
1926 // #define PANGO_IS_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FACE))
1927 
1928 /*
1929  * Casts a GObject to a PangoFontMap.
1930  * object :
1931  * a GObject.
1932  */
1933 // TODO
1934 // #define PANGO_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_MAP, PangoFontMap))
1935 
1936 /*
1937  * Returns TRUE if object is a PangoFontMap.
1938  * object :
1939  * a GObject.
1940  */
1941 // TODO
1942 // #define PANGO_IS_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_MAP))
1943 
1944 /*
1945  * Casts a GObject to a PangoFontMapClass.
1946  * klass :
1947  * a GObject.
1948  */
1949 // TODO
1950 // #define PANGO_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
1951 
1952 /*
1953  * Returns TRUE if klass is a subtype of PangoFontMapClass.
1954  * klass :
1955  * a GObject.
1956  */
1957 // TODO
1958 // #define PANGO_IS_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_MAP))
1959 
1960 /*
1961  * Returns the type of a PangoFontMap.
1962  * obj :
1963  * a PangoFontMap.
1964  */
1965 // TODO
1966 // #define PANGO_FONT_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
1967 
1968 /*
1969  * Whether a PangoGravity represents vertical writing directions.
1970  * gravity :
1971  * the PangoGravity to check
1972  * Returns :
1973  *  TRUE if gravity is PANGO_GRAVITY_EAST or PANGO_GRAVITY_WEST,
1974  *  FALSE otherwise.
1975  * Since 1.16
1976  */
1977 // TODO
1978 // #define PANGO_GRAVITY_IS_VERTICAL(gravity)
1979 
1980 /*
1981  * Outputs the necessary code for GObject type registration for a
1982  * PangoEngineLang class defined in a module. Two static symbols
1983  * are defined.
1984  *  static GType prefix_type;
1985  *  static void prefix_register_type (GTypeModule module);
1986  * The prefix, _register_type()
1987  * function should be called in your script_engine_init() function for
1988  * each type that your module implements, and then your script_engine_create()
1989  * function can create instances of the object as follows:
1990  * $(DDOC_COMMENT example)
1991  * name :
1992  * Name of the the type to register (for example:, ArabicEngineFc
1993  * prefix :
1994  * Prefix for symbols that will be defined (for example:, arabic_engine_fc
1995  * class_init :
1996  * Class initialization function for the new type, or NULL
1997  * instance_init :
1998  * Instance initialization function for the new type, or NULL
1999  */
2000 // TODO
2001 // #define PANGO_ENGINE_LANG_DEFINE_TYPE(name, prefix, class_init, instance_init)
2002 
2003 /*
2004  * Outputs the necessary code for GObject type registration for a
2005  * PangoEngineShape class defined in a module. Two static symbols
2006  * are defined.
2007  *  static GType prefix_type;
2008  *  static void prefix_register_type (GTypeModule module);
2009  * The prefix, _register_type()
2010  * function should be called in your script_engine_init() function for
2011  * each type that your module implements, and then your script_engine_create()
2012  * function can create instances of the object as follows:
2013  * $(DDOC_COMMENT example)
2014  * name :
2015  * Name of the the type to register (for example:, ArabicEngineFc
2016  * prefix :
2017  * Prefix for symbols that will be defined (for example:, arabic_engine_fc
2018  * class_init :
2019  * Class initialization function for the new type, or NULL
2020  * instance_init :
2021  * Instance initialization function for the new type, or NULL
2022  */
2023 // TODO
2024 // #define PANGO_ENGINE_SHAPE_DEFINE_TYPE(name, prefix, class_init, instance_init)
2025 
2026 /*
2027  * This macro encodes the given Pango version into an integer. The numbers
2028  * returned by PANGO_VERSION and pango_version() are encoded using this macro.
2029  * Two encoded version numbers can be compared as integers.
2030  * major :
2031  * the major component of the version number
2032  * minor :
2033  * the minor component of the version number
2034  * micro :
2035  * the micro component of the version number
2036  */
2037 // TODO
2038 // #define PANGO_VERSION_ENCODE(major, minor, micro)
2039 
2040 /*
2041  * Checks that the version of Pango available at compile-time is not older than
2042  * the provided version number.
2043  * major :
2044  * the major component of the version number
2045  * minor :
2046  * the minor component of the version number
2047  * micro :
2048  * the micro component of the version number
2049  */
2050 // TODO
2051 // #define PANGO_VERSION_CHECK(major,minor,micro)
2052 
2053 /*
2054  * A callback function used by pango_fontset_foreach() when enumerating
2055  * the fonts in a fontset.
2056  * fontset :
2057  * a PangoFontset
2058  * font :
2059  * a font from fontset
2060  * data :
2061  * callback data
2062  * Returns :
2063  *  if TRUE, stop iteration and return immediately.
2064  * Since 1.4
2065  */
2066 // gboolean (*PangoFontsetForeachFunc) (PangoFontset *fontset,  PangoFont *font,  gpointer data);
2067 public alias extern(C) int function(PangoFontset* fontset, PangoFont* font, void* data) PangoFontsetForeachFunc;
2068 
2069 /*
2070  * A copy function passed to attribute new functions that take
2071  * user data.
2072  * data :
2073  * the user data
2074  * Returns :
2075  * a new copy of data.
2076  */
2077 // gpointer (*PangoAttrDataCopyFunc) (gconstpointer data);
2078 public alias extern(C) void* function(void* data) PangoAttrDataCopyFunc;
2079 
2080 /*
2081  * A predicate function used by pango_attr_list_filter()
2082  * to filter out a subset of attributes for a list.
2083  * attribute :
2084  * a PangoAttribute
2085  * data :
2086  * callback data passed to pango_attr_list_filter()
2087  * Returns :
2088  * TRUE if the attribute should be filtered out
2089  */
2090 // gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute,  gpointer data);
2091 public alias extern(C) int function(PangoAttribute* attribute, void* data) PangoAttrFilterFunc;
2092 
2093 /*
2094  * Function type for rendering attributes of type PANGO_ATTR_SHAPE
2095  * with Pango's Cairo renderer.
2096  * cr :
2097  * a Cairo context with current point set to where the shape should
2098  *  be rendered
2099  * attr :
2100  * the PANGO_ATTR_SHAPE to render
2101  * do_path :
2102  * whether only the shape path should be appended to current
2103  *  path of cr and no filling/stroking done. This will be set
2104  * 	 to TRUE when called from pango_cairo_layout_path() and
2105  * 	 pango_cairo_layout_line_path() rendering functions.
2106  * data :
2107  * user data passed to pango_cairo_context_set_shape_renderer()
2108  */
2109 // void (*PangoCairoShapeRendererFunc) (cairo_t *cr,  PangoAttrShape *attr,  gboolean do_path,  gpointer data);
2110 public alias extern(C) void function(cairo_t* cr, PangoAttrShape* attr, int doPath, void* data) PangoCairoShapeRendererFunc;