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;