1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
// This file was generated by gir (89daf8f) from gir-files (71d73f0)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals)]

extern crate libc;
#[macro_use] extern crate bitflags;
extern crate glib_sys as glib;
extern crate gobject_sys as gobject;

#[allow(unused_imports)]
use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
    c_short, c_ushort, c_long, c_ulong,
    c_void, size_t, ssize_t, intptr_t, uintptr_t, time_t, FILE};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType, Volatile};

// Aliases
pub type PangoGlyph = u32;
pub type PangoGlyphUnit = i32;
pub type PangoLayoutRun = PangoGlyphItem;

// Enums
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoAlignment {
    Left = 0,
    Center = 1,
    Right = 2,
}
pub const PANGO_ALIGN_LEFT: PangoAlignment = PangoAlignment::Left;
pub const PANGO_ALIGN_CENTER: PangoAlignment = PangoAlignment::Center;
pub const PANGO_ALIGN_RIGHT: PangoAlignment = PangoAlignment::Right;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoAttrType {
    Invalid = 0,
    Language = 1,
    Family = 2,
    Style = 3,
    Weight = 4,
    Variant = 5,
    Stretch = 6,
    Size = 7,
    FontDesc = 8,
    Foreground = 9,
    Background = 10,
    Underline = 11,
    Strikethrough = 12,
    Rise = 13,
    Shape = 14,
    Scale = 15,
    Fallback = 16,
    LetterSpacing = 17,
    UnderlineColor = 18,
    StrikethroughColor = 19,
    AbsoluteSize = 20,
    Gravity = 21,
    GravityHint = 22,
    FontFeatures = 23,
    ForegroundAlpha = 24,
    BackgroundAlpha = 25,
}
pub const PANGO_ATTR_INVALID: PangoAttrType = PangoAttrType::Invalid;
pub const PANGO_ATTR_LANGUAGE: PangoAttrType = PangoAttrType::Language;
pub const PANGO_ATTR_FAMILY: PangoAttrType = PangoAttrType::Family;
pub const PANGO_ATTR_STYLE: PangoAttrType = PangoAttrType::Style;
pub const PANGO_ATTR_WEIGHT: PangoAttrType = PangoAttrType::Weight;
pub const PANGO_ATTR_VARIANT: PangoAttrType = PangoAttrType::Variant;
pub const PANGO_ATTR_STRETCH: PangoAttrType = PangoAttrType::Stretch;
pub const PANGO_ATTR_SIZE: PangoAttrType = PangoAttrType::Size;
pub const PANGO_ATTR_FONT_DESC: PangoAttrType = PangoAttrType::FontDesc;
pub const PANGO_ATTR_FOREGROUND: PangoAttrType = PangoAttrType::Foreground;
pub const PANGO_ATTR_BACKGROUND: PangoAttrType = PangoAttrType::Background;
pub const PANGO_ATTR_UNDERLINE: PangoAttrType = PangoAttrType::Underline;
pub const PANGO_ATTR_STRIKETHROUGH: PangoAttrType = PangoAttrType::Strikethrough;
pub const PANGO_ATTR_RISE: PangoAttrType = PangoAttrType::Rise;
pub const PANGO_ATTR_SHAPE: PangoAttrType = PangoAttrType::Shape;
pub const PANGO_ATTR_SCALE: PangoAttrType = PangoAttrType::Scale;
pub const PANGO_ATTR_FALLBACK: PangoAttrType = PangoAttrType::Fallback;
pub const PANGO_ATTR_LETTER_SPACING: PangoAttrType = PangoAttrType::LetterSpacing;
pub const PANGO_ATTR_UNDERLINE_COLOR: PangoAttrType = PangoAttrType::UnderlineColor;
pub const PANGO_ATTR_STRIKETHROUGH_COLOR: PangoAttrType = PangoAttrType::StrikethroughColor;
pub const PANGO_ATTR_ABSOLUTE_SIZE: PangoAttrType = PangoAttrType::AbsoluteSize;
pub const PANGO_ATTR_GRAVITY: PangoAttrType = PangoAttrType::Gravity;
pub const PANGO_ATTR_GRAVITY_HINT: PangoAttrType = PangoAttrType::GravityHint;
pub const PANGO_ATTR_FONT_FEATURES: PangoAttrType = PangoAttrType::FontFeatures;
pub const PANGO_ATTR_FOREGROUND_ALPHA: PangoAttrType = PangoAttrType::ForegroundAlpha;
pub const PANGO_ATTR_BACKGROUND_ALPHA: PangoAttrType = PangoAttrType::BackgroundAlpha;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoBidiType {
    L = 0,
    Lre = 1,
    Lro = 2,
    R = 3,
    Al = 4,
    Rle = 5,
    Rlo = 6,
    Pdf = 7,
    En = 8,
    Es = 9,
    Et = 10,
    An = 11,
    Cs = 12,
    Nsm = 13,
    Bn = 14,
    B = 15,
    S = 16,
    Ws = 17,
    On = 18,
}
pub const PANGO_BIDI_TYPE_L: PangoBidiType = PangoBidiType::L;
pub const PANGO_BIDI_TYPE_LRE: PangoBidiType = PangoBidiType::Lre;
pub const PANGO_BIDI_TYPE_LRO: PangoBidiType = PangoBidiType::Lro;
pub const PANGO_BIDI_TYPE_R: PangoBidiType = PangoBidiType::R;
pub const PANGO_BIDI_TYPE_AL: PangoBidiType = PangoBidiType::Al;
pub const PANGO_BIDI_TYPE_RLE: PangoBidiType = PangoBidiType::Rle;
pub const PANGO_BIDI_TYPE_RLO: PangoBidiType = PangoBidiType::Rlo;
pub const PANGO_BIDI_TYPE_PDF: PangoBidiType = PangoBidiType::Pdf;
pub const PANGO_BIDI_TYPE_EN: PangoBidiType = PangoBidiType::En;
pub const PANGO_BIDI_TYPE_ES: PangoBidiType = PangoBidiType::Es;
pub const PANGO_BIDI_TYPE_ET: PangoBidiType = PangoBidiType::Et;
pub const PANGO_BIDI_TYPE_AN: PangoBidiType = PangoBidiType::An;
pub const PANGO_BIDI_TYPE_CS: PangoBidiType = PangoBidiType::Cs;
pub const PANGO_BIDI_TYPE_NSM: PangoBidiType = PangoBidiType::Nsm;
pub const PANGO_BIDI_TYPE_BN: PangoBidiType = PangoBidiType::Bn;
pub const PANGO_BIDI_TYPE_B: PangoBidiType = PangoBidiType::B;
pub const PANGO_BIDI_TYPE_S: PangoBidiType = PangoBidiType::S;
pub const PANGO_BIDI_TYPE_WS: PangoBidiType = PangoBidiType::Ws;
pub const PANGO_BIDI_TYPE_ON: PangoBidiType = PangoBidiType::On;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoCoverageLevel {
    None = 0,
    Fallback = 1,
    Approximate = 2,
    Exact = 3,
}
pub const PANGO_COVERAGE_NONE: PangoCoverageLevel = PangoCoverageLevel::None;
pub const PANGO_COVERAGE_FALLBACK: PangoCoverageLevel = PangoCoverageLevel::Fallback;
pub const PANGO_COVERAGE_APPROXIMATE: PangoCoverageLevel = PangoCoverageLevel::Approximate;
pub const PANGO_COVERAGE_EXACT: PangoCoverageLevel = PangoCoverageLevel::Exact;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoDirection {
    Ltr = 0,
    Rtl = 1,
    TtbLtr = 2,
    TtbRtl = 3,
    WeakLtr = 4,
    WeakRtl = 5,
    Neutral = 6,
}
pub const PANGO_DIRECTION_LTR: PangoDirection = PangoDirection::Ltr;
pub const PANGO_DIRECTION_RTL: PangoDirection = PangoDirection::Rtl;
pub const PANGO_DIRECTION_TTB_LTR: PangoDirection = PangoDirection::TtbLtr;
pub const PANGO_DIRECTION_TTB_RTL: PangoDirection = PangoDirection::TtbRtl;
pub const PANGO_DIRECTION_WEAK_LTR: PangoDirection = PangoDirection::WeakLtr;
pub const PANGO_DIRECTION_WEAK_RTL: PangoDirection = PangoDirection::WeakRtl;
pub const PANGO_DIRECTION_NEUTRAL: PangoDirection = PangoDirection::Neutral;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoEllipsizeMode {
    None = 0,
    Start = 1,
    Middle = 2,
    End = 3,
}
pub const PANGO_ELLIPSIZE_NONE: PangoEllipsizeMode = PangoEllipsizeMode::None;
pub const PANGO_ELLIPSIZE_START: PangoEllipsizeMode = PangoEllipsizeMode::Start;
pub const PANGO_ELLIPSIZE_MIDDLE: PangoEllipsizeMode = PangoEllipsizeMode::Middle;
pub const PANGO_ELLIPSIZE_END: PangoEllipsizeMode = PangoEllipsizeMode::End;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoGravity {
    South = 0,
    East = 1,
    North = 2,
    West = 3,
    Auto = 4,
}
pub const PANGO_GRAVITY_SOUTH: PangoGravity = PangoGravity::South;
pub const PANGO_GRAVITY_EAST: PangoGravity = PangoGravity::East;
pub const PANGO_GRAVITY_NORTH: PangoGravity = PangoGravity::North;
pub const PANGO_GRAVITY_WEST: PangoGravity = PangoGravity::West;
pub const PANGO_GRAVITY_AUTO: PangoGravity = PangoGravity::Auto;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoGravityHint {
    Natural = 0,
    Strong = 1,
    Line = 2,
}
pub const PANGO_GRAVITY_HINT_NATURAL: PangoGravityHint = PangoGravityHint::Natural;
pub const PANGO_GRAVITY_HINT_STRONG: PangoGravityHint = PangoGravityHint::Strong;
pub const PANGO_GRAVITY_HINT_LINE: PangoGravityHint = PangoGravityHint::Line;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoRenderPart {
    Foreground = 0,
    Background = 1,
    Underline = 2,
    Strikethrough = 3,
}
pub const PANGO_RENDER_PART_FOREGROUND: PangoRenderPart = PangoRenderPart::Foreground;
pub const PANGO_RENDER_PART_BACKGROUND: PangoRenderPart = PangoRenderPart::Background;
pub const PANGO_RENDER_PART_UNDERLINE: PangoRenderPart = PangoRenderPart::Underline;
pub const PANGO_RENDER_PART_STRIKETHROUGH: PangoRenderPart = PangoRenderPart::Strikethrough;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoScript {
    InvalidCode = -1,
    Common = 0,
    Inherited = 1,
    Arabic = 2,
    Armenian = 3,
    Bengali = 4,
    Bopomofo = 5,
    Cherokee = 6,
    Coptic = 7,
    Cyrillic = 8,
    Deseret = 9,
    Devanagari = 10,
    Ethiopic = 11,
    Georgian = 12,
    Gothic = 13,
    Greek = 14,
    Gujarati = 15,
    Gurmukhi = 16,
    Han = 17,
    Hangul = 18,
    Hebrew = 19,
    Hiragana = 20,
    Kannada = 21,
    Katakana = 22,
    Khmer = 23,
    Lao = 24,
    Latin = 25,
    Malayalam = 26,
    Mongolian = 27,
    Myanmar = 28,
    Ogham = 29,
    OldItalic = 30,
    Oriya = 31,
    Runic = 32,
    Sinhala = 33,
    Syriac = 34,
    Tamil = 35,
    Telugu = 36,
    Thaana = 37,
    Thai = 38,
    Tibetan = 39,
    CanadianAboriginal = 40,
    Yi = 41,
    Tagalog = 42,
    Hanunoo = 43,
    Buhid = 44,
    Tagbanwa = 45,
    Braille = 46,
    Cypriot = 47,
    Limbu = 48,
    Osmanya = 49,
    Shavian = 50,
    LinearB = 51,
    TaiLe = 52,
    Ugaritic = 53,
    NewTaiLue = 54,
    Buginese = 55,
    Glagolitic = 56,
    Tifinagh = 57,
    SylotiNagri = 58,
    OldPersian = 59,
    Kharoshthi = 60,
    Unknown = 61,
    Balinese = 62,
    Cuneiform = 63,
    Phoenician = 64,
    PhagsPa = 65,
    Nko = 66,
    KayahLi = 67,
    Lepcha = 68,
    Rejang = 69,
    Sundanese = 70,
    Saurashtra = 71,
    Cham = 72,
    OlChiki = 73,
    Vai = 74,
    Carian = 75,
    Lycian = 76,
    Lydian = 77,
    Batak = 78,
    Brahmi = 79,
    Mandaic = 80,
    Chakma = 81,
    MeroiticCursive = 82,
    MeroiticHieroglyphs = 83,
    Miao = 84,
    Sharada = 85,
    SoraSompeng = 86,
    Takri = 87,
    BassaVah = 88,
    CaucasianAlbanian = 89,
    Duployan = 90,
    Elbasan = 91,
    Grantha = 92,
    Khojki = 93,
    Khudawadi = 94,
    LinearA = 95,
    Mahajani = 96,
    Manichaean = 97,
    MendeKikakui = 98,
    Modi = 99,
    Mro = 100,
    Nabataean = 101,
    OldNorthArabian = 102,
    OldPermic = 103,
    PahawhHmong = 104,
    Palmyrene = 105,
    PauCinHau = 106,
    PsalterPahlavi = 107,
    Siddham = 108,
    Tirhuta = 109,
    WarangCiti = 110,
    Ahom = 111,
    AnatolianHieroglyphs = 112,
    Hatran = 113,
    Multani = 114,
    OldHungarian = 115,
    Signwriting = 116,
}
pub const PANGO_SCRIPT_INVALID_CODE: PangoScript = PangoScript::InvalidCode;
pub const PANGO_SCRIPT_COMMON: PangoScript = PangoScript::Common;
pub const PANGO_SCRIPT_INHERITED: PangoScript = PangoScript::Inherited;
pub const PANGO_SCRIPT_ARABIC: PangoScript = PangoScript::Arabic;
pub const PANGO_SCRIPT_ARMENIAN: PangoScript = PangoScript::Armenian;
pub const PANGO_SCRIPT_BENGALI: PangoScript = PangoScript::Bengali;
pub const PANGO_SCRIPT_BOPOMOFO: PangoScript = PangoScript::Bopomofo;
pub const PANGO_SCRIPT_CHEROKEE: PangoScript = PangoScript::Cherokee;
pub const PANGO_SCRIPT_COPTIC: PangoScript = PangoScript::Coptic;
pub const PANGO_SCRIPT_CYRILLIC: PangoScript = PangoScript::Cyrillic;
pub const PANGO_SCRIPT_DESERET: PangoScript = PangoScript::Deseret;
pub const PANGO_SCRIPT_DEVANAGARI: PangoScript = PangoScript::Devanagari;
pub const PANGO_SCRIPT_ETHIOPIC: PangoScript = PangoScript::Ethiopic;
pub const PANGO_SCRIPT_GEORGIAN: PangoScript = PangoScript::Georgian;
pub const PANGO_SCRIPT_GOTHIC: PangoScript = PangoScript::Gothic;
pub const PANGO_SCRIPT_GREEK: PangoScript = PangoScript::Greek;
pub const PANGO_SCRIPT_GUJARATI: PangoScript = PangoScript::Gujarati;
pub const PANGO_SCRIPT_GURMUKHI: PangoScript = PangoScript::Gurmukhi;
pub const PANGO_SCRIPT_HAN: PangoScript = PangoScript::Han;
pub const PANGO_SCRIPT_HANGUL: PangoScript = PangoScript::Hangul;
pub const PANGO_SCRIPT_HEBREW: PangoScript = PangoScript::Hebrew;
pub const PANGO_SCRIPT_HIRAGANA: PangoScript = PangoScript::Hiragana;
pub const PANGO_SCRIPT_KANNADA: PangoScript = PangoScript::Kannada;
pub const PANGO_SCRIPT_KATAKANA: PangoScript = PangoScript::Katakana;
pub const PANGO_SCRIPT_KHMER: PangoScript = PangoScript::Khmer;
pub const PANGO_SCRIPT_LAO: PangoScript = PangoScript::Lao;
pub const PANGO_SCRIPT_LATIN: PangoScript = PangoScript::Latin;
pub const PANGO_SCRIPT_MALAYALAM: PangoScript = PangoScript::Malayalam;
pub const PANGO_SCRIPT_MONGOLIAN: PangoScript = PangoScript::Mongolian;
pub const PANGO_SCRIPT_MYANMAR: PangoScript = PangoScript::Myanmar;
pub const PANGO_SCRIPT_OGHAM: PangoScript = PangoScript::Ogham;
pub const PANGO_SCRIPT_OLD_ITALIC: PangoScript = PangoScript::OldItalic;
pub const PANGO_SCRIPT_ORIYA: PangoScript = PangoScript::Oriya;
pub const PANGO_SCRIPT_RUNIC: PangoScript = PangoScript::Runic;
pub const PANGO_SCRIPT_SINHALA: PangoScript = PangoScript::Sinhala;
pub const PANGO_SCRIPT_SYRIAC: PangoScript = PangoScript::Syriac;
pub const PANGO_SCRIPT_TAMIL: PangoScript = PangoScript::Tamil;
pub const PANGO_SCRIPT_TELUGU: PangoScript = PangoScript::Telugu;
pub const PANGO_SCRIPT_THAANA: PangoScript = PangoScript::Thaana;
pub const PANGO_SCRIPT_THAI: PangoScript = PangoScript::Thai;
pub const PANGO_SCRIPT_TIBETAN: PangoScript = PangoScript::Tibetan;
pub const PANGO_SCRIPT_CANADIAN_ABORIGINAL: PangoScript = PangoScript::CanadianAboriginal;
pub const PANGO_SCRIPT_YI: PangoScript = PangoScript::Yi;
pub const PANGO_SCRIPT_TAGALOG: PangoScript = PangoScript::Tagalog;
pub const PANGO_SCRIPT_HANUNOO: PangoScript = PangoScript::Hanunoo;
pub const PANGO_SCRIPT_BUHID: PangoScript = PangoScript::Buhid;
pub const PANGO_SCRIPT_TAGBANWA: PangoScript = PangoScript::Tagbanwa;
pub const PANGO_SCRIPT_BRAILLE: PangoScript = PangoScript::Braille;
pub const PANGO_SCRIPT_CYPRIOT: PangoScript = PangoScript::Cypriot;
pub const PANGO_SCRIPT_LIMBU: PangoScript = PangoScript::Limbu;
pub const PANGO_SCRIPT_OSMANYA: PangoScript = PangoScript::Osmanya;
pub const PANGO_SCRIPT_SHAVIAN: PangoScript = PangoScript::Shavian;
pub const PANGO_SCRIPT_LINEAR_B: PangoScript = PangoScript::LinearB;
pub const PANGO_SCRIPT_TAI_LE: PangoScript = PangoScript::TaiLe;
pub const PANGO_SCRIPT_UGARITIC: PangoScript = PangoScript::Ugaritic;
pub const PANGO_SCRIPT_NEW_TAI_LUE: PangoScript = PangoScript::NewTaiLue;
pub const PANGO_SCRIPT_BUGINESE: PangoScript = PangoScript::Buginese;
pub const PANGO_SCRIPT_GLAGOLITIC: PangoScript = PangoScript::Glagolitic;
pub const PANGO_SCRIPT_TIFINAGH: PangoScript = PangoScript::Tifinagh;
pub const PANGO_SCRIPT_SYLOTI_NAGRI: PangoScript = PangoScript::SylotiNagri;
pub const PANGO_SCRIPT_OLD_PERSIAN: PangoScript = PangoScript::OldPersian;
pub const PANGO_SCRIPT_KHAROSHTHI: PangoScript = PangoScript::Kharoshthi;
pub const PANGO_SCRIPT_UNKNOWN: PangoScript = PangoScript::Unknown;
pub const PANGO_SCRIPT_BALINESE: PangoScript = PangoScript::Balinese;
pub const PANGO_SCRIPT_CUNEIFORM: PangoScript = PangoScript::Cuneiform;
pub const PANGO_SCRIPT_PHOENICIAN: PangoScript = PangoScript::Phoenician;
pub const PANGO_SCRIPT_PHAGS_PA: PangoScript = PangoScript::PhagsPa;
pub const PANGO_SCRIPT_NKO: PangoScript = PangoScript::Nko;
pub const PANGO_SCRIPT_KAYAH_LI: PangoScript = PangoScript::KayahLi;
pub const PANGO_SCRIPT_LEPCHA: PangoScript = PangoScript::Lepcha;
pub const PANGO_SCRIPT_REJANG: PangoScript = PangoScript::Rejang;
pub const PANGO_SCRIPT_SUNDANESE: PangoScript = PangoScript::Sundanese;
pub const PANGO_SCRIPT_SAURASHTRA: PangoScript = PangoScript::Saurashtra;
pub const PANGO_SCRIPT_CHAM: PangoScript = PangoScript::Cham;
pub const PANGO_SCRIPT_OL_CHIKI: PangoScript = PangoScript::OlChiki;
pub const PANGO_SCRIPT_VAI: PangoScript = PangoScript::Vai;
pub const PANGO_SCRIPT_CARIAN: PangoScript = PangoScript::Carian;
pub const PANGO_SCRIPT_LYCIAN: PangoScript = PangoScript::Lycian;
pub const PANGO_SCRIPT_LYDIAN: PangoScript = PangoScript::Lydian;
pub const PANGO_SCRIPT_BATAK: PangoScript = PangoScript::Batak;
pub const PANGO_SCRIPT_BRAHMI: PangoScript = PangoScript::Brahmi;
pub const PANGO_SCRIPT_MANDAIC: PangoScript = PangoScript::Mandaic;
pub const PANGO_SCRIPT_CHAKMA: PangoScript = PangoScript::Chakma;
pub const PANGO_SCRIPT_MEROITIC_CURSIVE: PangoScript = PangoScript::MeroiticCursive;
pub const PANGO_SCRIPT_MEROITIC_HIEROGLYPHS: PangoScript = PangoScript::MeroiticHieroglyphs;
pub const PANGO_SCRIPT_MIAO: PangoScript = PangoScript::Miao;
pub const PANGO_SCRIPT_SHARADA: PangoScript = PangoScript::Sharada;
pub const PANGO_SCRIPT_SORA_SOMPENG: PangoScript = PangoScript::SoraSompeng;
pub const PANGO_SCRIPT_TAKRI: PangoScript = PangoScript::Takri;
pub const PANGO_SCRIPT_BASSA_VAH: PangoScript = PangoScript::BassaVah;
pub const PANGO_SCRIPT_CAUCASIAN_ALBANIAN: PangoScript = PangoScript::CaucasianAlbanian;
pub const PANGO_SCRIPT_DUPLOYAN: PangoScript = PangoScript::Duployan;
pub const PANGO_SCRIPT_ELBASAN: PangoScript = PangoScript::Elbasan;
pub const PANGO_SCRIPT_GRANTHA: PangoScript = PangoScript::Grantha;
pub const PANGO_SCRIPT_KHOJKI: PangoScript = PangoScript::Khojki;
pub const PANGO_SCRIPT_KHUDAWADI: PangoScript = PangoScript::Khudawadi;
pub const PANGO_SCRIPT_LINEAR_A: PangoScript = PangoScript::LinearA;
pub const PANGO_SCRIPT_MAHAJANI: PangoScript = PangoScript::Mahajani;
pub const PANGO_SCRIPT_MANICHAEAN: PangoScript = PangoScript::Manichaean;
pub const PANGO_SCRIPT_MENDE_KIKAKUI: PangoScript = PangoScript::MendeKikakui;
pub const PANGO_SCRIPT_MODI: PangoScript = PangoScript::Modi;
pub const PANGO_SCRIPT_MRO: PangoScript = PangoScript::Mro;
pub const PANGO_SCRIPT_NABATAEAN: PangoScript = PangoScript::Nabataean;
pub const PANGO_SCRIPT_OLD_NORTH_ARABIAN: PangoScript = PangoScript::OldNorthArabian;
pub const PANGO_SCRIPT_OLD_PERMIC: PangoScript = PangoScript::OldPermic;
pub const PANGO_SCRIPT_PAHAWH_HMONG: PangoScript = PangoScript::PahawhHmong;
pub const PANGO_SCRIPT_PALMYRENE: PangoScript = PangoScript::Palmyrene;
pub const PANGO_SCRIPT_PAU_CIN_HAU: PangoScript = PangoScript::PauCinHau;
pub const PANGO_SCRIPT_PSALTER_PAHLAVI: PangoScript = PangoScript::PsalterPahlavi;
pub const PANGO_SCRIPT_SIDDHAM: PangoScript = PangoScript::Siddham;
pub const PANGO_SCRIPT_TIRHUTA: PangoScript = PangoScript::Tirhuta;
pub const PANGO_SCRIPT_WARANG_CITI: PangoScript = PangoScript::WarangCiti;
pub const PANGO_SCRIPT_AHOM: PangoScript = PangoScript::Ahom;
pub const PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS: PangoScript = PangoScript::AnatolianHieroglyphs;
pub const PANGO_SCRIPT_HATRAN: PangoScript = PangoScript::Hatran;
pub const PANGO_SCRIPT_MULTANI: PangoScript = PangoScript::Multani;
pub const PANGO_SCRIPT_OLD_HUNGARIAN: PangoScript = PangoScript::OldHungarian;
pub const PANGO_SCRIPT_SIGNWRITING: PangoScript = PangoScript::Signwriting;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoStretch {
    UltraCondensed = 0,
    ExtraCondensed = 1,
    Condensed = 2,
    SemiCondensed = 3,
    Normal = 4,
    SemiExpanded = 5,
    Expanded = 6,
    ExtraExpanded = 7,
    UltraExpanded = 8,
}
pub const PANGO_STRETCH_ULTRA_CONDENSED: PangoStretch = PangoStretch::UltraCondensed;
pub const PANGO_STRETCH_EXTRA_CONDENSED: PangoStretch = PangoStretch::ExtraCondensed;
pub const PANGO_STRETCH_CONDENSED: PangoStretch = PangoStretch::Condensed;
pub const PANGO_STRETCH_SEMI_CONDENSED: PangoStretch = PangoStretch::SemiCondensed;
pub const PANGO_STRETCH_NORMAL: PangoStretch = PangoStretch::Normal;
pub const PANGO_STRETCH_SEMI_EXPANDED: PangoStretch = PangoStretch::SemiExpanded;
pub const PANGO_STRETCH_EXPANDED: PangoStretch = PangoStretch::Expanded;
pub const PANGO_STRETCH_EXTRA_EXPANDED: PangoStretch = PangoStretch::ExtraExpanded;
pub const PANGO_STRETCH_ULTRA_EXPANDED: PangoStretch = PangoStretch::UltraExpanded;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoStyle {
    Normal = 0,
    Oblique = 1,
    Italic = 2,
}
pub const PANGO_STYLE_NORMAL: PangoStyle = PangoStyle::Normal;
pub const PANGO_STYLE_OBLIQUE: PangoStyle = PangoStyle::Oblique;
pub const PANGO_STYLE_ITALIC: PangoStyle = PangoStyle::Italic;

pub type TabAlign = c_int;
pub const PANGO_TAB_LEFT: TabAlign = 0;
pub type PangoTabAlign = TabAlign;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoUnderline {
    None = 0,
    Single = 1,
    Double = 2,
    Low = 3,
    Error = 4,
}
pub const PANGO_UNDERLINE_NONE: PangoUnderline = PangoUnderline::None;
pub const PANGO_UNDERLINE_SINGLE: PangoUnderline = PangoUnderline::Single;
pub const PANGO_UNDERLINE_DOUBLE: PangoUnderline = PangoUnderline::Double;
pub const PANGO_UNDERLINE_LOW: PangoUnderline = PangoUnderline::Low;
pub const PANGO_UNDERLINE_ERROR: PangoUnderline = PangoUnderline::Error;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoVariant {
    Normal = 0,
    SmallCaps = 1,
}
pub const PANGO_VARIANT_NORMAL: PangoVariant = PangoVariant::Normal;
pub const PANGO_VARIANT_SMALL_CAPS: PangoVariant = PangoVariant::SmallCaps;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoWeight {
    Thin = 100,
    Ultralight = 200,
    Light = 300,
    Semilight = 350,
    Book = 380,
    Normal = 400,
    Medium = 500,
    Semibold = 600,
    Bold = 700,
    Ultrabold = 800,
    Heavy = 900,
    Ultraheavy = 1000,
}
pub const PANGO_WEIGHT_THIN: PangoWeight = PangoWeight::Thin;
pub const PANGO_WEIGHT_ULTRALIGHT: PangoWeight = PangoWeight::Ultralight;
pub const PANGO_WEIGHT_LIGHT: PangoWeight = PangoWeight::Light;
pub const PANGO_WEIGHT_SEMILIGHT: PangoWeight = PangoWeight::Semilight;
pub const PANGO_WEIGHT_BOOK: PangoWeight = PangoWeight::Book;
pub const PANGO_WEIGHT_NORMAL: PangoWeight = PangoWeight::Normal;
pub const PANGO_WEIGHT_MEDIUM: PangoWeight = PangoWeight::Medium;
pub const PANGO_WEIGHT_SEMIBOLD: PangoWeight = PangoWeight::Semibold;
pub const PANGO_WEIGHT_BOLD: PangoWeight = PangoWeight::Bold;
pub const PANGO_WEIGHT_ULTRABOLD: PangoWeight = PangoWeight::Ultrabold;
pub const PANGO_WEIGHT_HEAVY: PangoWeight = PangoWeight::Heavy;
pub const PANGO_WEIGHT_ULTRAHEAVY: PangoWeight = PangoWeight::Ultraheavy;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum PangoWrapMode {
    Word = 0,
    Char = 1,
    WordChar = 2,
}
pub const PANGO_WRAP_WORD: PangoWrapMode = PangoWrapMode::Word;
pub const PANGO_WRAP_CHAR: PangoWrapMode = PangoWrapMode::Char;
pub const PANGO_WRAP_WORD_CHAR: PangoWrapMode = PangoWrapMode::WordChar;

// Constants
pub const PANGO_ANALYSIS_FLAG_CENTERED_BASELINE: c_int = 1;
pub const PANGO_ANALYSIS_FLAG_IS_ELLIPSIS: c_int = 2;
pub const PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING: c_int = 0;
pub const PANGO_ENGINE_TYPE_LANG: *const c_char = b"PangoEngineLang\0" as *const u8 as *const c_char;
pub const PANGO_ENGINE_TYPE_SHAPE: *const c_char = b"PangoEngineShape\0" as *const u8 as *const c_char;
pub const PANGO_GLYPH_EMPTY: PangoGlyph = 268435455;
pub const PANGO_GLYPH_INVALID_INPUT: PangoGlyph = 4294967295;
pub const PANGO_GLYPH_UNKNOWN_FLAG: PangoGlyph = 268435456;
pub const PANGO_RENDER_TYPE_NONE: *const c_char = b"PangoRenderNone\0" as *const u8 as *const c_char;
pub const PANGO_SCALE: c_int = 1024;
pub const PANGO_UNKNOWN_GLYPH_HEIGHT: c_int = 14;
pub const PANGO_UNKNOWN_GLYPH_WIDTH: c_int = 10;
pub const PANGO_VERSION_MIN_REQUIRED: c_int = 2;

// Flags
bitflags! {
    #[repr(C)]
    pub struct PangoFontMask: c_uint {
        const PANGO_FONT_MASK_FAMILY = 1;
        const PANGO_FONT_MASK_STYLE = 2;
        const PANGO_FONT_MASK_VARIANT = 4;
        const PANGO_FONT_MASK_WEIGHT = 8;
        const PANGO_FONT_MASK_STRETCH = 16;
        const PANGO_FONT_MASK_SIZE = 32;
        const PANGO_FONT_MASK_GRAVITY = 64;
    }
}

// Callbacks
pub type PangoAttrDataCopyFunc = Option<unsafe extern "C" fn(gconstpointer) -> gpointer>;
pub type PangoAttrFilterFunc = Option<unsafe extern "C" fn(*mut PangoAttribute, gpointer) -> gboolean>;
pub type PangoFontsetForeachFunc = Option<unsafe extern "C" fn(*mut PangoFontset, *mut PangoFont, gpointer) -> gboolean>;

// Records
#[repr(C)]
pub struct PangoAnalysis {
    pub shape_engine: *mut PangoEngineShape,
    pub lang_engine: *mut PangoEngineLang,
    pub font: *mut PangoFont,
    pub level: u8,
    pub gravity: u8,
    pub flags: u8,
    pub script: u8,
    pub language: *mut PangoLanguage,
    pub extra_attrs: *mut glib::GSList,
}

#[repr(C)]
pub struct PangoAttrClass {
    pub type_: PangoAttrType,
    pub copy: Option<unsafe extern "C" fn(*const PangoAttribute) -> *mut PangoAttribute>,
    pub destroy: Option<unsafe extern "C" fn(*mut PangoAttribute)>,
    pub equal: Option<unsafe extern "C" fn(*const PangoAttribute, *const PangoAttribute) -> gboolean>,
}

#[repr(C)]
pub struct PangoAttrColor {
    pub attr: PangoAttribute,
    pub color: PangoColor,
}

#[repr(C)]
pub struct PangoAttrFloat {
    pub attr: PangoAttribute,
    pub value: c_double,
}

#[repr(C)]
pub struct PangoAttrFontDesc {
    pub attr: PangoAttribute,
    pub desc: *mut PangoFontDescription,
}

#[repr(C)]
pub struct PangoAttrFontFeatures {
    pub attr: PangoAttribute,
    pub features: *mut c_char,
}

#[repr(C)]
pub struct PangoAttrInt {
    pub attr: PangoAttribute,
    pub value: c_int,
}

#[repr(C)]
pub struct PangoAttrIterator(c_void);

#[repr(C)]
pub struct PangoAttrLanguage {
    pub attr: PangoAttribute,
    pub value: *mut PangoLanguage,
}

#[repr(C)]
pub struct PangoAttrList(c_void);

#[repr(C)]
pub struct PangoAttrShape {
    pub attr: PangoAttribute,
    pub ink_rect: PangoRectangle,
    pub logical_rect: PangoRectangle,
    pub data: gpointer,
    pub copy_func: PangoAttrDataCopyFunc,
    pub destroy_func: glib::GDestroyNotify,
}

#[repr(C)]
pub struct PangoAttrSize {
    pub attr: PangoAttribute,
    pub size: c_int,
    _truncated_record_marker: c_void,
    //absolute: guint: 1,
}

#[repr(C)]
pub struct PangoAttrString {
    pub attr: PangoAttribute,
    pub value: *mut c_char,
}

#[repr(C)]
pub struct PangoAttribute {
    pub klass: *const PangoAttrClass,
    pub start_index: c_uint,
    pub end_index: c_uint,
}

#[repr(C)]
pub struct PangoColor {
    pub red: u16,
    pub green: u16,
    pub blue: u16,
}

#[repr(C)]
pub struct PangoContextClass(c_void);

#[repr(C)]
pub struct PangoCoverage(c_void);

#[repr(C)]
pub struct PangoEngineClass {
    pub parent_class: gobject::GObjectClass,
}

#[repr(C)]
pub struct PangoEngineInfo {
    pub id: *const c_char,
    pub engine_type: *const c_char,
    pub render_type: *const c_char,
    pub scripts: *mut PangoEngineScriptInfo,
    pub n_scripts: c_int,
}

#[repr(C)]
pub struct PangoEngineLangClass {
    pub parent_class: PangoEngineClass,
    pub script_break: Option<unsafe extern "C" fn(*mut PangoEngineLang, *const c_char, c_int, *mut PangoAnalysis, *mut PangoLogAttr, c_int)>,
}

#[repr(C)]
pub struct PangoEngineScriptInfo {
    pub script: PangoScript,
    pub langs: *const c_char,
}

#[repr(C)]
pub struct PangoEngineShapeClass {
    pub parent_class: PangoEngineClass,
    pub script_shape: Option<unsafe extern "C" fn(*mut PangoEngineShape, *mut PangoFont, *const c_char, c_uint, *const PangoAnalysis, *mut PangoGlyphString, *const c_char, c_uint)>,
    pub covers: Option<unsafe extern "C" fn(*mut PangoEngineShape, *mut PangoFont, *mut PangoLanguage, u32) -> PangoCoverageLevel>,
}

#[repr(C)]
pub struct PangoFontClass {
    pub parent_class: gobject::GObjectClass,
    pub describe: Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontDescription>,
    pub get_coverage: Option<unsafe extern "C" fn(*mut PangoFont, *mut PangoLanguage) -> *mut PangoCoverage>,
    pub find_shaper: Option<unsafe extern "C" fn(*mut PangoFont, *mut PangoLanguage, u32) -> *mut PangoEngineShape>,
    pub get_glyph_extents: Option<unsafe extern "C" fn(*mut PangoFont, PangoGlyph, *mut PangoRectangle, *mut PangoRectangle)>,
    pub get_metrics: Option<unsafe extern "C" fn(*mut PangoFont, *mut PangoLanguage) -> *mut PangoFontMetrics>,
    pub get_font_map: Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontMap>,
    pub describe_absolute: Option<unsafe extern "C" fn(*mut PangoFont) -> *mut PangoFontDescription>,
    pub _pango_reserved1: Option<unsafe extern "C" fn()>,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
}

#[repr(C)]
pub struct PangoFontDescription(c_void);

#[repr(C)]
pub struct PangoFontFaceClass {
    pub parent_class: gobject::GObjectClass,
    pub get_face_name: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *const c_char>,
    pub describe: Option<unsafe extern "C" fn(*mut PangoFontFace) -> *mut PangoFontDescription>,
    pub list_sizes: Option<unsafe extern "C" fn(*mut PangoFontFace, *mut *mut c_int, *mut c_int)>,
    pub is_synthesized: Option<unsafe extern "C" fn(*mut PangoFontFace) -> gboolean>,
    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
}

#[repr(C)]
pub struct PangoFontFamilyClass {
    pub parent_class: gobject::GObjectClass,
    pub list_faces: Option<unsafe extern "C" fn(*mut PangoFontFamily, *mut *mut *mut PangoFontFace, *mut c_int)>,
    pub get_name: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> *const c_char>,
    pub is_monospace: Option<unsafe extern "C" fn(*mut PangoFontFamily) -> gboolean>,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
}

#[repr(C)]
pub struct PangoFontMapClass {
    pub parent_class: gobject::GObjectClass,
    pub load_font: Option<unsafe extern "C" fn(*mut PangoFontMap, *mut PangoContext, *const PangoFontDescription) -> *mut PangoFont>,
    pub list_families: Option<unsafe extern "C" fn(*mut PangoFontMap, *mut *mut *mut PangoFontFamily, *mut c_int)>,
    pub load_fontset: Option<unsafe extern "C" fn(*mut PangoFontMap, *mut PangoContext, *const PangoFontDescription, *mut PangoLanguage) -> *mut PangoFontset>,
    pub shape_engine_type: *const c_char,
    pub get_serial: Option<unsafe extern "C" fn(*mut PangoFontMap) -> c_uint>,
    pub changed: Option<unsafe extern "C" fn(*mut PangoFontMap)>,
    pub _pango_reserved1: Option<unsafe extern "C" fn()>,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
}

#[repr(C)]
pub struct PangoFontMetrics {
    pub ref_count: c_uint,
    pub ascent: c_int,
    pub descent: c_int,
    pub approximate_char_width: c_int,
    pub approximate_digit_width: c_int,
    pub underline_position: c_int,
    pub underline_thickness: c_int,
    pub strikethrough_position: c_int,
    pub strikethrough_thickness: c_int,
}

#[repr(C)]
pub struct PangoFontsetClass {
    pub parent_class: gobject::GObjectClass,
    pub get_font: Option<unsafe extern "C" fn(*mut PangoFontset, c_uint) -> *mut PangoFont>,
    pub get_metrics: Option<unsafe extern "C" fn(*mut PangoFontset) -> *mut PangoFontMetrics>,
    pub get_language: Option<unsafe extern "C" fn(*mut PangoFontset) -> *mut PangoLanguage>,
    pub foreach: Option<unsafe extern "C" fn(*mut PangoFontset, PangoFontsetForeachFunc, gpointer)>,
    pub _pango_reserved1: Option<unsafe extern "C" fn()>,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
}

#[repr(C)]
pub struct PangoFontsetSimpleClass(c_void);

#[repr(C)]
pub struct PangoGlyphGeometry {
    pub width: PangoGlyphUnit,
    pub x_offset: PangoGlyphUnit,
    pub y_offset: PangoGlyphUnit,
}

#[repr(C)]
pub struct PangoGlyphInfo {
    pub glyph: PangoGlyph,
    pub geometry: PangoGlyphGeometry,
    pub attr: PangoGlyphVisAttr,
}

#[repr(C)]
pub struct PangoGlyphItem {
    pub item: *mut PangoItem,
    pub glyphs: *mut PangoGlyphString,
}

#[repr(C)]
pub struct PangoGlyphItemIter {
    pub glyph_item: *mut PangoGlyphItem,
    pub text: *const c_char,
    pub start_glyph: c_int,
    pub start_index: c_int,
    pub start_char: c_int,
    pub end_glyph: c_int,
    pub end_index: c_int,
    pub end_char: c_int,
}

#[repr(C)]
pub struct PangoGlyphString {
    pub num_glyphs: c_int,
    pub glyphs: *mut PangoGlyphInfo,
    pub log_clusters: *mut c_int,
    pub space: c_int,
}

#[repr(C)]
pub struct PangoGlyphVisAttr {
    _truncated_record_marker: c_void,
    //is_cluster_start: guint: 1,
}

#[repr(C)]
pub struct PangoIncludedModule {
    pub list: Option<unsafe extern "C" fn(*mut *mut PangoEngineInfo, *mut c_int)>,
    pub init: Option<unsafe extern "C" fn(*mut gobject::GTypeModule)>,
    pub exit: Option<unsafe extern "C" fn()>,
    pub create: Option<unsafe extern "C" fn(*const c_char) -> *mut PangoEngine>,
}

#[repr(C)]
pub struct PangoItem {
    pub offset: c_int,
    pub length: c_int,
    pub num_chars: c_int,
    pub analysis: PangoAnalysis,
}

#[repr(C)]
pub struct PangoLanguage(c_void);

#[repr(C)]
pub struct PangoLayoutClass(c_void);

#[repr(C)]
pub struct PangoLayoutIter(c_void);

#[repr(C)]
pub struct PangoLayoutLine {
    pub layout: *mut PangoLayout,
    pub start_index: c_int,
    pub length: c_int,
    pub runs: *mut glib::GSList,
    _truncated_record_marker: c_void,
    //is_paragraph_start: guint: 1,
    //resolved_dir: guint: 3,
}

#[repr(C)]
pub struct PangoLogAttr {
    _truncated_record_marker: c_void,
    //is_line_break: guint: 1,
    //is_mandatory_break: guint: 1,
    //is_char_break: guint: 1,
    //is_white: guint: 1,
    //is_cursor_position: guint: 1,
    //is_word_start: guint: 1,
    //is_word_end: guint: 1,
    //is_sentence_boundary: guint: 1,
    //is_sentence_start: guint: 1,
    //is_sentence_end: guint: 1,
    //backspace_deletes_character: guint: 1,
    //is_expandable_space: guint: 1,
    //is_word_boundary: guint: 1,
}

#[repr(C)]
pub struct PangoMap(c_void);

#[repr(C)]
pub struct PangoMapEntry(c_void);

#[repr(C)]
pub struct PangoMatrix {
    pub xx: c_double,
    pub xy: c_double,
    pub yx: c_double,
    pub yy: c_double,
    pub x0: c_double,
    pub y0: c_double,
}

#[repr(C)]
pub struct PangoRectangle {
    pub x: c_int,
    pub y: c_int,
    pub width: c_int,
    pub height: c_int,
}

#[repr(C)]
pub struct PangoRendererClass {
    pub parent_class: gobject::GObjectClass,
    pub draw_glyphs: Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoFont, *mut PangoGlyphString, c_int, c_int)>,
    pub draw_rectangle: Option<unsafe extern "C" fn(*mut PangoRenderer, PangoRenderPart, c_int, c_int, c_int, c_int)>,
    pub draw_error_underline: Option<unsafe extern "C" fn(*mut PangoRenderer, c_int, c_int, c_int, c_int)>,
    pub draw_shape: Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoAttrShape, c_int, c_int)>,
    pub draw_trapezoid: Option<unsafe extern "C" fn(*mut PangoRenderer, PangoRenderPart, c_double, c_double, c_double, c_double, c_double, c_double)>,
    pub draw_glyph: Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoFont, PangoGlyph, c_double, c_double)>,
    pub part_changed: Option<unsafe extern "C" fn(*mut PangoRenderer, PangoRenderPart)>,
    pub begin: Option<unsafe extern "C" fn(*mut PangoRenderer)>,
    pub end: Option<unsafe extern "C" fn(*mut PangoRenderer)>,
    pub prepare_run: Option<unsafe extern "C" fn(*mut PangoRenderer, *mut PangoLayoutRun)>,
    pub draw_glyph_item: Option<unsafe extern "C" fn(*mut PangoRenderer, *const c_char, *mut PangoGlyphItem, c_int, c_int)>,
    pub _pango_reserved2: Option<unsafe extern "C" fn()>,
    pub _pango_reserved3: Option<unsafe extern "C" fn()>,
    pub _pango_reserved4: Option<unsafe extern "C" fn()>,
}

#[repr(C)]
pub struct PangoRendererPrivate(c_void);

#[repr(C)]
pub struct PangoScriptForLang {
    pub lang: [c_char; 7],
    pub scripts: [PangoScript; 3],
}

#[repr(C)]
pub struct PangoScriptIter(c_void);

#[repr(C)]
pub struct PangoTabArray(c_void);

// Classes
#[repr(C)]
pub struct PangoContext(c_void);

#[repr(C)]
pub struct PangoEngine {
    pub parent_instance: gobject::GObject,
}

#[repr(C)]
pub struct PangoEngineLang {
    pub parent_instance: PangoEngine,
}

#[repr(C)]
pub struct PangoEngineShape {
    pub parent_instance: PangoEngine,
}

#[repr(C)]
pub struct PangoFont {
    pub parent_instance: gobject::GObject,
}

#[repr(C)]
pub struct PangoFontFace {
    pub parent_instance: gobject::GObject,
}

#[repr(C)]
pub struct PangoFontFamily {
    pub parent_instance: gobject::GObject,
}

#[repr(C)]
pub struct PangoFontMap {
    pub parent_instance: gobject::GObject,
}

#[repr(C)]
pub struct PangoFontset {
    pub parent_instance: gobject::GObject,
}

#[repr(C)]
pub struct PangoFontsetSimple(c_void);

#[repr(C)]
pub struct PangoLayout(c_void);

#[repr(C)]
pub struct PangoRenderer {
    pub parent_instance: gobject::GObject,
    pub underline: PangoUnderline,
    pub strikethrough: gboolean,
    pub active_count: c_int,
    pub matrix: *mut PangoMatrix,
    pub priv_: *mut PangoRendererPrivate,
}

extern "C" {

    //=========================================================================
    // PangoAttrType
    //=========================================================================
    pub fn pango_attr_type_get_name(type_: PangoAttrType) -> *const c_char;
    pub fn pango_attr_type_register(name: *const c_char) -> PangoAttrType;

    //=========================================================================
    // PangoBidiType
    //=========================================================================
    pub fn pango_bidi_type_for_unichar(ch: u32) -> PangoBidiType;

    //=========================================================================
    // PangoGravity
    //=========================================================================
    pub fn pango_gravity_get_for_matrix(matrix: *const PangoMatrix) -> PangoGravity;
    pub fn pango_gravity_get_for_script(script: PangoScript, base_gravity: PangoGravity, hint: PangoGravityHint) -> PangoGravity;
    pub fn pango_gravity_get_for_script_and_width(script: PangoScript, wide: gboolean, base_gravity: PangoGravity, hint: PangoGravityHint) -> PangoGravity;
    pub fn pango_gravity_to_rotation(gravity: PangoGravity) -> c_double;

    //=========================================================================
    // PangoScript
    //=========================================================================
    pub fn pango_script_for_unichar(ch: u32) -> PangoScript;
    pub fn pango_script_get_sample_language(script: PangoScript) -> *mut PangoLanguage;

    //=========================================================================
    // PangoAttrFontDesc
    //=========================================================================
    pub fn pango_attr_font_desc_new(desc: *const PangoFontDescription) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrFontFeatures
    //=========================================================================
    #[cfg(feature = "v1_38")]
    pub fn pango_attr_font_features_new(features: *const c_char) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrIterator
    //=========================================================================
    pub fn pango_attr_iterator_copy(iterator: *mut PangoAttrIterator) -> *mut PangoAttrIterator;
    pub fn pango_attr_iterator_destroy(iterator: *mut PangoAttrIterator);
    pub fn pango_attr_iterator_get(iterator: *mut PangoAttrIterator, type_: PangoAttrType) -> *mut PangoAttribute;
    pub fn pango_attr_iterator_get_attrs(iterator: *mut PangoAttrIterator) -> *mut glib::GSList;
    pub fn pango_attr_iterator_get_font(iterator: *mut PangoAttrIterator, desc: *mut PangoFontDescription, language: *mut *mut PangoLanguage, extra_attrs: *mut *mut glib::GSList);
    pub fn pango_attr_iterator_next(iterator: *mut PangoAttrIterator) -> gboolean;
    pub fn pango_attr_iterator_range(iterator: *mut PangoAttrIterator, start: *mut c_int, end: *mut c_int);

    //=========================================================================
    // PangoAttrLanguage
    //=========================================================================
    pub fn pango_attr_language_new(language: *mut PangoLanguage) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrList
    //=========================================================================
    pub fn pango_attr_list_get_type() -> GType;
    pub fn pango_attr_list_new() -> *mut PangoAttrList;
    pub fn pango_attr_list_change(list: *mut PangoAttrList, attr: *mut PangoAttribute);
    pub fn pango_attr_list_copy(list: *mut PangoAttrList) -> *mut PangoAttrList;
    pub fn pango_attr_list_filter(list: *mut PangoAttrList, func: PangoAttrFilterFunc, data: gpointer) -> *mut PangoAttrList;
    pub fn pango_attr_list_get_iterator(list: *mut PangoAttrList) -> *mut PangoAttrIterator;
    pub fn pango_attr_list_insert(list: *mut PangoAttrList, attr: *mut PangoAttribute);
    pub fn pango_attr_list_insert_before(list: *mut PangoAttrList, attr: *mut PangoAttribute);
    pub fn pango_attr_list_ref(list: *mut PangoAttrList) -> *mut PangoAttrList;
    pub fn pango_attr_list_splice(list: *mut PangoAttrList, other: *mut PangoAttrList, pos: c_int, len: c_int);
    pub fn pango_attr_list_unref(list: *mut PangoAttrList);

    //=========================================================================
    // PangoAttrShape
    //=========================================================================
    pub fn pango_attr_shape_new(ink_rect: *const PangoRectangle, logical_rect: *const PangoRectangle) -> *mut PangoAttribute;
    pub fn pango_attr_shape_new_with_data(ink_rect: *const PangoRectangle, logical_rect: *const PangoRectangle, data: gpointer, copy_func: PangoAttrDataCopyFunc, destroy_func: glib::GDestroyNotify) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttrSize
    //=========================================================================
    pub fn pango_attr_size_new(size: c_int) -> *mut PangoAttribute;
    pub fn pango_attr_size_new_absolute(size: c_int) -> *mut PangoAttribute;

    //=========================================================================
    // PangoAttribute
    //=========================================================================
    pub fn pango_attribute_copy(attr: *const PangoAttribute) -> *mut PangoAttribute;
    pub fn pango_attribute_destroy(attr: *mut PangoAttribute);
    pub fn pango_attribute_equal(attr1: *const PangoAttribute, attr2: *const PangoAttribute) -> gboolean;
    pub fn pango_attribute_init(attr: *mut PangoAttribute, klass: *const PangoAttrClass);

    //=========================================================================
    // PangoColor
    //=========================================================================
    pub fn pango_color_get_type() -> GType;
    pub fn pango_color_copy(src: *const PangoColor) -> *mut PangoColor;
    pub fn pango_color_free(color: *mut PangoColor);
    pub fn pango_color_parse(color: *mut PangoColor, spec: *const c_char) -> gboolean;
    pub fn pango_color_to_string(color: *const PangoColor) -> *mut c_char;

    //=========================================================================
    // PangoCoverage
    //=========================================================================
    pub fn pango_coverage_copy(coverage: *mut PangoCoverage) -> *mut PangoCoverage;
    pub fn pango_coverage_get(coverage: *mut PangoCoverage, index_: c_int) -> PangoCoverageLevel;
    pub fn pango_coverage_max(coverage: *mut PangoCoverage, other: *mut PangoCoverage);
    pub fn pango_coverage_ref(coverage: *mut PangoCoverage) -> *mut PangoCoverage;
    pub fn pango_coverage_set(coverage: *mut PangoCoverage, index_: c_int, level: PangoCoverageLevel);
    pub fn pango_coverage_to_bytes(coverage: *mut PangoCoverage, bytes: *mut *mut u8, n_bytes: *mut c_int);
    pub fn pango_coverage_unref(coverage: *mut PangoCoverage);
    pub fn pango_coverage_from_bytes(bytes: *mut u8, n_bytes: c_int) -> *mut PangoCoverage;
    pub fn pango_coverage_new() -> *mut PangoCoverage;

    //=========================================================================
    // PangoFontDescription
    //=========================================================================
    pub fn pango_font_description_get_type() -> GType;
    pub fn pango_font_description_new() -> *mut PangoFontDescription;
    pub fn pango_font_description_better_match(desc: *const PangoFontDescription, old_match: *const PangoFontDescription, new_match: *const PangoFontDescription) -> gboolean;
    pub fn pango_font_description_copy(desc: *const PangoFontDescription) -> *mut PangoFontDescription;
    pub fn pango_font_description_copy_static(desc: *const PangoFontDescription) -> *mut PangoFontDescription;
    pub fn pango_font_description_equal(desc1: *const PangoFontDescription, desc2: *const PangoFontDescription) -> gboolean;
    pub fn pango_font_description_free(desc: *mut PangoFontDescription);
    pub fn pango_font_description_get_family(desc: *const PangoFontDescription) -> *const c_char;
    pub fn pango_font_description_get_gravity(desc: *const PangoFontDescription) -> PangoGravity;
    pub fn pango_font_description_get_set_fields(desc: *const PangoFontDescription) -> PangoFontMask;
    pub fn pango_font_description_get_size(desc: *const PangoFontDescription) -> c_int;
    pub fn pango_font_description_get_size_is_absolute(desc: *const PangoFontDescription) -> gboolean;
    pub fn pango_font_description_get_stretch(desc: *const PangoFontDescription) -> PangoStretch;
    pub fn pango_font_description_get_style(desc: *const PangoFontDescription) -> PangoStyle;
    pub fn pango_font_description_get_variant(desc: *const PangoFontDescription) -> PangoVariant;
    pub fn pango_font_description_get_weight(desc: *const PangoFontDescription) -> PangoWeight;
    pub fn pango_font_description_hash(desc: *const PangoFontDescription) -> c_uint;
    pub fn pango_font_description_merge(desc: *mut PangoFontDescription, desc_to_merge: *const PangoFontDescription, replace_existing: gboolean);
    pub fn pango_font_description_merge_static(desc: *mut PangoFontDescription, desc_to_merge: *const PangoFontDescription, replace_existing: gboolean);
    pub fn pango_font_description_set_absolute_size(desc: *mut PangoFontDescription, size: c_double);
    pub fn pango_font_description_set_family(desc: *mut PangoFontDescription, family: *const c_char);
    pub fn pango_font_description_set_family_static(desc: *mut PangoFontDescription, family: *const c_char);
    pub fn pango_font_description_set_gravity(desc: *mut PangoFontDescription, gravity: PangoGravity);
    pub fn pango_font_description_set_size(desc: *mut PangoFontDescription, size: c_int);
    pub fn pango_font_description_set_stretch(desc: *mut PangoFontDescription, stretch: PangoStretch);
    pub fn pango_font_description_set_style(desc: *mut PangoFontDescription, style: PangoStyle);
    pub fn pango_font_description_set_variant(desc: *mut PangoFontDescription, variant: PangoVariant);
    pub fn pango_font_description_set_weight(desc: *mut PangoFontDescription, weight: PangoWeight);
    pub fn pango_font_description_to_filename(desc: *const PangoFontDescription) -> *mut c_char;
    pub fn pango_font_description_to_string(desc: *const PangoFontDescription) -> *mut c_char;
    pub fn pango_font_description_unset_fields(desc: *mut PangoFontDescription, to_unset: PangoFontMask);
    pub fn pango_font_description_from_string(str: *const c_char) -> *mut PangoFontDescription;

    //=========================================================================
    // PangoFontMetrics
    //=========================================================================
    pub fn pango_font_metrics_get_type() -> GType;
    pub fn pango_font_metrics_new() -> *mut PangoFontMetrics;
    pub fn pango_font_metrics_get_approximate_char_width(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_approximate_digit_width(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_ascent(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_descent(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_strikethrough_position(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_strikethrough_thickness(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_underline_position(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_get_underline_thickness(metrics: *mut PangoFontMetrics) -> c_int;
    pub fn pango_font_metrics_ref(metrics: *mut PangoFontMetrics) -> *mut PangoFontMetrics;
    pub fn pango_font_metrics_unref(metrics: *mut PangoFontMetrics);

    //=========================================================================
    // PangoGlyphItem
    //=========================================================================
    pub fn pango_glyph_item_get_type() -> GType;
    pub fn pango_glyph_item_apply_attrs(glyph_item: *mut PangoGlyphItem, text: *const c_char, list: *mut PangoAttrList) -> *mut glib::GSList;
    pub fn pango_glyph_item_copy(orig: *mut PangoGlyphItem) -> *mut PangoGlyphItem;
    pub fn pango_glyph_item_free(glyph_item: *mut PangoGlyphItem);
    pub fn pango_glyph_item_get_logical_widths(glyph_item: *mut PangoGlyphItem, text: *const c_char, logical_widths: *mut c_int);
    pub fn pango_glyph_item_letter_space(glyph_item: *mut PangoGlyphItem, text: *const c_char, log_attrs: *mut PangoLogAttr, letter_spacing: c_int);
    pub fn pango_glyph_item_split(orig: *mut PangoGlyphItem, text: *const c_char, split_index: c_int) -> *mut PangoGlyphItem;

    //=========================================================================
    // PangoGlyphItemIter
    //=========================================================================
    pub fn pango_glyph_item_iter_get_type() -> GType;
    pub fn pango_glyph_item_iter_copy(orig: *mut PangoGlyphItemIter) -> *mut PangoGlyphItemIter;
    pub fn pango_glyph_item_iter_free(iter: *mut PangoGlyphItemIter);
    pub fn pango_glyph_item_iter_init_end(iter: *mut PangoGlyphItemIter, glyph_item: *mut PangoGlyphItem, text: *const c_char) -> gboolean;
    pub fn pango_glyph_item_iter_init_start(iter: *mut PangoGlyphItemIter, glyph_item: *mut PangoGlyphItem, text: *const c_char) -> gboolean;
    pub fn pango_glyph_item_iter_next_cluster(iter: *mut PangoGlyphItemIter) -> gboolean;
    pub fn pango_glyph_item_iter_prev_cluster(iter: *mut PangoGlyphItemIter) -> gboolean;

    //=========================================================================
    // PangoGlyphString
    //=========================================================================
    pub fn pango_glyph_string_get_type() -> GType;
    pub fn pango_glyph_string_new() -> *mut PangoGlyphString;
    pub fn pango_glyph_string_copy(string: *mut PangoGlyphString) -> *mut PangoGlyphString;
    pub fn pango_glyph_string_extents(glyphs: *mut PangoGlyphString, font: *mut PangoFont, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_glyph_string_extents_range(glyphs: *mut PangoGlyphString, start: c_int, end: c_int, font: *mut PangoFont, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_glyph_string_free(string: *mut PangoGlyphString);
    pub fn pango_glyph_string_get_logical_widths(glyphs: *mut PangoGlyphString, text: *const c_char, length: c_int, embedding_level: c_int, logical_widths: *mut c_int);
    pub fn pango_glyph_string_get_width(glyphs: *mut PangoGlyphString) -> c_int;
    pub fn pango_glyph_string_index_to_x(glyphs: *mut PangoGlyphString, text: *mut c_char, length: c_int, analysis: *mut PangoAnalysis, index_: c_int, trailing: gboolean, x_pos: *mut c_int);
    pub fn pango_glyph_string_set_size(string: *mut PangoGlyphString, new_len: c_int);
    pub fn pango_glyph_string_x_to_index(glyphs: *mut PangoGlyphString, text: *mut c_char, length: c_int, analysis: *mut PangoAnalysis, x_pos: c_int, index_: *mut c_int, trailing: *mut c_int);

    //=========================================================================
    // PangoItem
    //=========================================================================
    pub fn pango_item_get_type() -> GType;
    pub fn pango_item_new() -> *mut PangoItem;
    pub fn pango_item_copy(item: *mut PangoItem) -> *mut PangoItem;
    pub fn pango_item_free(item: *mut PangoItem);
    pub fn pango_item_split(orig: *mut PangoItem, split_index: c_int, split_offset: c_int) -> *mut PangoItem;

    //=========================================================================
    // PangoLanguage
    //=========================================================================
    pub fn pango_language_get_type() -> GType;
    pub fn pango_language_get_sample_string(language: *mut PangoLanguage) -> *const c_char;
    pub fn pango_language_get_scripts(language: *mut PangoLanguage, num_scripts: *mut c_int) -> *mut PangoScript;
    pub fn pango_language_includes_script(language: *mut PangoLanguage, script: PangoScript) -> gboolean;
    pub fn pango_language_matches(language: *mut PangoLanguage, range_list: *const c_char) -> gboolean;
    pub fn pango_language_to_string(language: *mut PangoLanguage) -> *const c_char;
    pub fn pango_language_from_string(language: *const c_char) -> *mut PangoLanguage;
    pub fn pango_language_get_default() -> *mut PangoLanguage;

    //=========================================================================
    // PangoLayoutIter
    //=========================================================================
    pub fn pango_layout_iter_get_type() -> GType;
    pub fn pango_layout_iter_at_last_line(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_copy(iter: *mut PangoLayoutIter) -> *mut PangoLayoutIter;
    pub fn pango_layout_iter_free(iter: *mut PangoLayoutIter);
    pub fn pango_layout_iter_get_baseline(iter: *mut PangoLayoutIter) -> c_int;
    pub fn pango_layout_iter_get_char_extents(iter: *mut PangoLayoutIter, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_iter_get_cluster_extents(iter: *mut PangoLayoutIter, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_iter_get_index(iter: *mut PangoLayoutIter) -> c_int;
    pub fn pango_layout_iter_get_layout(iter: *mut PangoLayoutIter) -> *mut PangoLayout;
    pub fn pango_layout_iter_get_layout_extents(iter: *mut PangoLayoutIter, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_iter_get_line(iter: *mut PangoLayoutIter) -> *mut PangoLayoutLine;
    pub fn pango_layout_iter_get_line_extents(iter: *mut PangoLayoutIter, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_iter_get_line_readonly(iter: *mut PangoLayoutIter) -> *mut PangoLayoutLine;
    pub fn pango_layout_iter_get_line_yrange(iter: *mut PangoLayoutIter, y0_: *mut c_int, y1_: *mut c_int);
    pub fn pango_layout_iter_get_run(iter: *mut PangoLayoutIter) -> *mut PangoLayoutRun;
    pub fn pango_layout_iter_get_run_extents(iter: *mut PangoLayoutIter, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_iter_get_run_readonly(iter: *mut PangoLayoutIter) -> *mut PangoLayoutRun;
    pub fn pango_layout_iter_next_char(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_next_cluster(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_next_line(iter: *mut PangoLayoutIter) -> gboolean;
    pub fn pango_layout_iter_next_run(iter: *mut PangoLayoutIter) -> gboolean;

    //=========================================================================
    // PangoLayoutLine
    //=========================================================================
    pub fn pango_layout_line_get_type() -> GType;
    pub fn pango_layout_line_get_extents(line: *mut PangoLayoutLine, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_line_get_pixel_extents(layout_line: *mut PangoLayoutLine, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_line_get_x_ranges(line: *mut PangoLayoutLine, start_index: c_int, end_index: c_int, ranges: *mut *mut c_int, n_ranges: *mut c_int);
    pub fn pango_layout_line_index_to_x(line: *mut PangoLayoutLine, index_: c_int, trailing: gboolean, x_pos: *mut c_int);
    pub fn pango_layout_line_ref(line: *mut PangoLayoutLine) -> *mut PangoLayoutLine;
    pub fn pango_layout_line_unref(line: *mut PangoLayoutLine);
    pub fn pango_layout_line_x_to_index(line: *mut PangoLayoutLine, x_pos: c_int, index_: *mut c_int, trailing: *mut c_int) -> gboolean;

    //=========================================================================
    // PangoMap
    //=========================================================================
    pub fn pango_map_get_engine(map: *mut PangoMap, script: PangoScript) -> *mut PangoEngine;
    pub fn pango_map_get_engines(map: *mut PangoMap, script: PangoScript, exact_engines: *mut *mut glib::GSList, fallback_engines: *mut *mut glib::GSList);

    //=========================================================================
    // PangoMatrix
    //=========================================================================
    pub fn pango_matrix_get_type() -> GType;
    pub fn pango_matrix_concat(matrix: *mut PangoMatrix, new_matrix: *const PangoMatrix);
    pub fn pango_matrix_copy(matrix: *const PangoMatrix) -> *mut PangoMatrix;
    pub fn pango_matrix_free(matrix: *mut PangoMatrix);
    pub fn pango_matrix_get_font_scale_factor(matrix: *const PangoMatrix) -> c_double;
    #[cfg(feature = "v1_38")]
    pub fn pango_matrix_get_font_scale_factors(matrix: *const PangoMatrix, xscale: *mut c_double, yscale: *mut c_double);
    pub fn pango_matrix_rotate(matrix: *mut PangoMatrix, degrees: c_double);
    pub fn pango_matrix_scale(matrix: *mut PangoMatrix, scale_x: c_double, scale_y: c_double);
    pub fn pango_matrix_transform_distance(matrix: *const PangoMatrix, dx: *mut c_double, dy: *mut c_double);
    pub fn pango_matrix_transform_pixel_rectangle(matrix: *const PangoMatrix, rect: *mut PangoRectangle);
    pub fn pango_matrix_transform_point(matrix: *const PangoMatrix, x: *mut c_double, y: *mut c_double);
    pub fn pango_matrix_transform_rectangle(matrix: *const PangoMatrix, rect: *mut PangoRectangle);
    pub fn pango_matrix_translate(matrix: *mut PangoMatrix, tx: c_double, ty: c_double);

    //=========================================================================
    // PangoScriptIter
    //=========================================================================
    pub fn pango_script_iter_free(iter: *mut PangoScriptIter);
    pub fn pango_script_iter_get_range(iter: *mut PangoScriptIter, start: *mut *const c_char, end: *mut *const c_char, script: *mut PangoScript);
    pub fn pango_script_iter_next(iter: *mut PangoScriptIter) -> gboolean;
    pub fn pango_script_iter_new(text: *const c_char, length: c_int) -> *mut PangoScriptIter;

    //=========================================================================
    // PangoTabArray
    //=========================================================================
    pub fn pango_tab_array_get_type() -> GType;
    pub fn pango_tab_array_new(initial_size: c_int, positions_in_pixels: gboolean) -> *mut PangoTabArray;
    pub fn pango_tab_array_new_with_positions(size: c_int, positions_in_pixels: gboolean, first_alignment: PangoTabAlign, first_position: c_int, ...) -> *mut PangoTabArray;
    pub fn pango_tab_array_copy(src: *mut PangoTabArray) -> *mut PangoTabArray;
    pub fn pango_tab_array_free(tab_array: *mut PangoTabArray);
    pub fn pango_tab_array_get_positions_in_pixels(tab_array: *mut PangoTabArray) -> gboolean;
    pub fn pango_tab_array_get_size(tab_array: *mut PangoTabArray) -> c_int;
    pub fn pango_tab_array_get_tab(tab_array: *mut PangoTabArray, tab_index: c_int, alignment: *mut PangoTabAlign, location: *mut c_int);
    pub fn pango_tab_array_get_tabs(tab_array: *mut PangoTabArray, alignments: *mut *mut PangoTabAlign, locations: *mut *mut c_int);
    pub fn pango_tab_array_resize(tab_array: *mut PangoTabArray, new_size: c_int);
    pub fn pango_tab_array_set_tab(tab_array: *mut PangoTabArray, tab_index: c_int, alignment: PangoTabAlign, location: c_int);

    //=========================================================================
    // PangoContext
    //=========================================================================
    pub fn pango_context_get_type() -> GType;
    pub fn pango_context_new() -> *mut PangoContext;
    #[cfg(feature = "v1_32_4")]
    pub fn pango_context_changed(context: *mut PangoContext);
    pub fn pango_context_get_base_dir(context: *mut PangoContext) -> PangoDirection;
    pub fn pango_context_get_base_gravity(context: *mut PangoContext) -> PangoGravity;
    pub fn pango_context_get_font_description(context: *mut PangoContext) -> *mut PangoFontDescription;
    pub fn pango_context_get_font_map(context: *mut PangoContext) -> *mut PangoFontMap;
    pub fn pango_context_get_gravity(context: *mut PangoContext) -> PangoGravity;
    pub fn pango_context_get_gravity_hint(context: *mut PangoContext) -> PangoGravityHint;
    pub fn pango_context_get_language(context: *mut PangoContext) -> *mut PangoLanguage;
    pub fn pango_context_get_matrix(context: *mut PangoContext) -> *const PangoMatrix;
    pub fn pango_context_get_metrics(context: *mut PangoContext, desc: *const PangoFontDescription, language: *mut PangoLanguage) -> *mut PangoFontMetrics;
    #[cfg(feature = "v1_32_4")]
    pub fn pango_context_get_serial(context: *mut PangoContext) -> c_uint;
    pub fn pango_context_list_families(context: *mut PangoContext, families: *mut *mut *mut PangoFontFamily, n_families: *mut c_int);
    pub fn pango_context_load_font(context: *mut PangoContext, desc: *const PangoFontDescription) -> *mut PangoFont;
    pub fn pango_context_load_fontset(context: *mut PangoContext, desc: *const PangoFontDescription, language: *mut PangoLanguage) -> *mut PangoFontset;
    pub fn pango_context_set_base_dir(context: *mut PangoContext, direction: PangoDirection);
    pub fn pango_context_set_base_gravity(context: *mut PangoContext, gravity: PangoGravity);
    pub fn pango_context_set_font_description(context: *mut PangoContext, desc: *const PangoFontDescription);
    pub fn pango_context_set_font_map(context: *mut PangoContext, font_map: *mut PangoFontMap);
    pub fn pango_context_set_gravity_hint(context: *mut PangoContext, hint: PangoGravityHint);
    pub fn pango_context_set_language(context: *mut PangoContext, language: *mut PangoLanguage);
    pub fn pango_context_set_matrix(context: *mut PangoContext, matrix: *const PangoMatrix);

    //=========================================================================
    // PangoEngine
    //=========================================================================
    pub fn pango_engine_get_type() -> GType;

    //=========================================================================
    // PangoEngineLang
    //=========================================================================
    pub fn pango_engine_lang_get_type() -> GType;

    //=========================================================================
    // PangoEngineShape
    //=========================================================================
    pub fn pango_engine_shape_get_type() -> GType;

    //=========================================================================
    // PangoFont
    //=========================================================================
    pub fn pango_font_get_type() -> GType;
    pub fn pango_font_descriptions_free(descs: *mut *mut PangoFontDescription, n_descs: c_int);
    pub fn pango_font_describe(font: *mut PangoFont) -> *mut PangoFontDescription;
    pub fn pango_font_describe_with_absolute_size(font: *mut PangoFont) -> *mut PangoFontDescription;
    pub fn pango_font_find_shaper(font: *mut PangoFont, language: *mut PangoLanguage, ch: u32) -> *mut PangoEngineShape;
    pub fn pango_font_get_coverage(font: *mut PangoFont, language: *mut PangoLanguage) -> *mut PangoCoverage;
    pub fn pango_font_get_font_map(font: *mut PangoFont) -> *mut PangoFontMap;
    pub fn pango_font_get_glyph_extents(font: *mut PangoFont, glyph: PangoGlyph, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_font_get_metrics(font: *mut PangoFont, language: *mut PangoLanguage) -> *mut PangoFontMetrics;

    //=========================================================================
    // PangoFontFace
    //=========================================================================
    pub fn pango_font_face_get_type() -> GType;
    pub fn pango_font_face_describe(face: *mut PangoFontFace) -> *mut PangoFontDescription;
    pub fn pango_font_face_get_face_name(face: *mut PangoFontFace) -> *const c_char;
    pub fn pango_font_face_is_synthesized(face: *mut PangoFontFace) -> gboolean;
    pub fn pango_font_face_list_sizes(face: *mut PangoFontFace, sizes: *mut *mut c_int, n_sizes: *mut c_int);

    //=========================================================================
    // PangoFontFamily
    //=========================================================================
    pub fn pango_font_family_get_type() -> GType;
    pub fn pango_font_family_get_name(family: *mut PangoFontFamily) -> *const c_char;
    pub fn pango_font_family_is_monospace(family: *mut PangoFontFamily) -> gboolean;
    pub fn pango_font_family_list_faces(family: *mut PangoFontFamily, faces: *mut *mut *mut PangoFontFace, n_faces: *mut c_int);

    //=========================================================================
    // PangoFontMap
    //=========================================================================
    pub fn pango_font_map_get_type() -> GType;
    #[cfg(feature = "v1_34")]
    pub fn pango_font_map_changed(fontmap: *mut PangoFontMap);
    pub fn pango_font_map_create_context(fontmap: *mut PangoFontMap) -> *mut PangoContext;
    #[cfg(feature = "v1_32_4")]
    pub fn pango_font_map_get_serial(fontmap: *mut PangoFontMap) -> c_uint;
    pub fn pango_font_map_get_shape_engine_type(fontmap: *mut PangoFontMap) -> *const c_char;
    pub fn pango_font_map_list_families(fontmap: *mut PangoFontMap, families: *mut *mut *mut PangoFontFamily, n_families: *mut c_int);
    pub fn pango_font_map_load_font(fontmap: *mut PangoFontMap, context: *mut PangoContext, desc: *const PangoFontDescription) -> *mut PangoFont;
    pub fn pango_font_map_load_fontset(fontmap: *mut PangoFontMap, context: *mut PangoContext, desc: *const PangoFontDescription, language: *mut PangoLanguage) -> *mut PangoFontset;

    //=========================================================================
    // PangoFontset
    //=========================================================================
    pub fn pango_fontset_get_type() -> GType;
    pub fn pango_fontset_foreach(fontset: *mut PangoFontset, func: PangoFontsetForeachFunc, data: gpointer);
    pub fn pango_fontset_get_font(fontset: *mut PangoFontset, wc: c_uint) -> *mut PangoFont;
    pub fn pango_fontset_get_metrics(fontset: *mut PangoFontset) -> *mut PangoFontMetrics;

    //=========================================================================
    // PangoFontsetSimple
    //=========================================================================
    pub fn pango_fontset_simple_get_type() -> GType;
    pub fn pango_fontset_simple_new(language: *mut PangoLanguage) -> *mut PangoFontsetSimple;
    pub fn pango_fontset_simple_append(fontset: *mut PangoFontsetSimple, font: *mut PangoFont);
    pub fn pango_fontset_simple_size(fontset: *mut PangoFontsetSimple) -> c_int;

    //=========================================================================
    // PangoLayout
    //=========================================================================
    pub fn pango_layout_get_type() -> GType;
    pub fn pango_layout_new(context: *mut PangoContext) -> *mut PangoLayout;
    pub fn pango_layout_context_changed(layout: *mut PangoLayout);
    pub fn pango_layout_copy(src: *mut PangoLayout) -> *mut PangoLayout;
    pub fn pango_layout_get_alignment(layout: *mut PangoLayout) -> PangoAlignment;
    pub fn pango_layout_get_attributes(layout: *mut PangoLayout) -> *mut PangoAttrList;
    pub fn pango_layout_get_auto_dir(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_get_baseline(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_character_count(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_context(layout: *mut PangoLayout) -> *mut PangoContext;
    pub fn pango_layout_get_cursor_pos(layout: *mut PangoLayout, index_: c_int, strong_pos: *mut PangoRectangle, weak_pos: *mut PangoRectangle);
    pub fn pango_layout_get_ellipsize(layout: *mut PangoLayout) -> PangoEllipsizeMode;
    pub fn pango_layout_get_extents(layout: *mut PangoLayout, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_get_font_description(layout: *mut PangoLayout) -> *const PangoFontDescription;
    pub fn pango_layout_get_height(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_indent(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_iter(layout: *mut PangoLayout) -> *mut PangoLayoutIter;
    pub fn pango_layout_get_justify(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_get_line(layout: *mut PangoLayout, line: c_int) -> *mut PangoLayoutLine;
    pub fn pango_layout_get_line_count(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_line_readonly(layout: *mut PangoLayout, line: c_int) -> *mut PangoLayoutLine;
    pub fn pango_layout_get_lines(layout: *mut PangoLayout) -> *mut glib::GSList;
    pub fn pango_layout_get_lines_readonly(layout: *mut PangoLayout) -> *mut glib::GSList;
    pub fn pango_layout_get_log_attrs(layout: *mut PangoLayout, attrs: *mut *mut PangoLogAttr, n_attrs: *mut c_int);
    pub fn pango_layout_get_log_attrs_readonly(layout: *mut PangoLayout, n_attrs: *mut c_int) -> *mut PangoLogAttr;
    pub fn pango_layout_get_pixel_extents(layout: *mut PangoLayout, ink_rect: *mut PangoRectangle, logical_rect: *mut PangoRectangle);
    pub fn pango_layout_get_pixel_size(layout: *mut PangoLayout, width: *mut c_int, height: *mut c_int);
    #[cfg(feature = "v1_32_4")]
    pub fn pango_layout_get_serial(layout: *mut PangoLayout) -> c_uint;
    pub fn pango_layout_get_single_paragraph_mode(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_get_size(layout: *mut PangoLayout, width: *mut c_int, height: *mut c_int);
    pub fn pango_layout_get_spacing(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_tabs(layout: *mut PangoLayout) -> *mut PangoTabArray;
    pub fn pango_layout_get_text(layout: *mut PangoLayout) -> *const c_char;
    pub fn pango_layout_get_unknown_glyphs_count(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_width(layout: *mut PangoLayout) -> c_int;
    pub fn pango_layout_get_wrap(layout: *mut PangoLayout) -> PangoWrapMode;
    pub fn pango_layout_index_to_line_x(layout: *mut PangoLayout, index_: c_int, trailing: gboolean, line: *mut c_int, x_pos: *mut c_int);
    pub fn pango_layout_index_to_pos(layout: *mut PangoLayout, index_: c_int, pos: *mut PangoRectangle);
    pub fn pango_layout_is_ellipsized(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_is_wrapped(layout: *mut PangoLayout) -> gboolean;
    pub fn pango_layout_move_cursor_visually(layout: *mut PangoLayout, strong: gboolean, old_index: c_int, old_trailing: c_int, direction: c_int, new_index: *mut c_int, new_trailing: *mut c_int);
    pub fn pango_layout_set_alignment(layout: *mut PangoLayout, alignment: PangoAlignment);
    pub fn pango_layout_set_attributes(layout: *mut PangoLayout, attrs: *mut PangoAttrList);
    pub fn pango_layout_set_auto_dir(layout: *mut PangoLayout, auto_dir: gboolean);
    pub fn pango_layout_set_ellipsize(layout: *mut PangoLayout, ellipsize: PangoEllipsizeMode);
    pub fn pango_layout_set_font_description(layout: *mut PangoLayout, desc: *const PangoFontDescription);
    pub fn pango_layout_set_height(layout: *mut PangoLayout, height: c_int);
    pub fn pango_layout_set_indent(layout: *mut PangoLayout, indent: c_int);
    pub fn pango_layout_set_justify(layout: *mut PangoLayout, justify: gboolean);
    pub fn pango_layout_set_markup(layout: *mut PangoLayout, markup: *const c_char, length: c_int);
    pub fn pango_layout_set_markup_with_accel(layout: *mut PangoLayout, markup: *const c_char, length: c_int, accel_marker: u32, accel_char: *mut u32);
    pub fn pango_layout_set_single_paragraph_mode(layout: *mut PangoLayout, setting: gboolean);
    pub fn pango_layout_set_spacing(layout: *mut PangoLayout, spacing: c_int);
    pub fn pango_layout_set_tabs(layout: *mut PangoLayout, tabs: *mut PangoTabArray);
    pub fn pango_layout_set_text(layout: *mut PangoLayout, text: *const c_char, length: c_int);
    pub fn pango_layout_set_width(layout: *mut PangoLayout, width: c_int);
    pub fn pango_layout_set_wrap(layout: *mut PangoLayout, wrap: PangoWrapMode);
    pub fn pango_layout_xy_to_index(layout: *mut PangoLayout, x: c_int, y: c_int, index_: *mut c_int, trailing: *mut c_int) -> gboolean;

    //=========================================================================
    // PangoRenderer
    //=========================================================================
    pub fn pango_renderer_get_type() -> GType;
    pub fn pango_renderer_activate(renderer: *mut PangoRenderer);
    pub fn pango_renderer_deactivate(renderer: *mut PangoRenderer);
    pub fn pango_renderer_draw_error_underline(renderer: *mut PangoRenderer, x: c_int, y: c_int, width: c_int, height: c_int);
    pub fn pango_renderer_draw_glyph(renderer: *mut PangoRenderer, font: *mut PangoFont, glyph: PangoGlyph, x: c_double, y: c_double);
    pub fn pango_renderer_draw_glyph_item(renderer: *mut PangoRenderer, text: *const c_char, glyph_item: *mut PangoGlyphItem, x: c_int, y: c_int);
    pub fn pango_renderer_draw_glyphs(renderer: *mut PangoRenderer, font: *mut PangoFont, glyphs: *mut PangoGlyphString, x: c_int, y: c_int);
    pub fn pango_renderer_draw_layout(renderer: *mut PangoRenderer, layout: *mut PangoLayout, x: c_int, y: c_int);
    pub fn pango_renderer_draw_layout_line(renderer: *mut PangoRenderer, line: *mut PangoLayoutLine, x: c_int, y: c_int);
    pub fn pango_renderer_draw_rectangle(renderer: *mut PangoRenderer, part: PangoRenderPart, x: c_int, y: c_int, width: c_int, height: c_int);
    pub fn pango_renderer_draw_trapezoid(renderer: *mut PangoRenderer, part: PangoRenderPart, y1_: c_double, x11: c_double, x21: c_double, y2: c_double, x12: c_double, x22: c_double);
    #[cfg(feature = "v1_38")]
    pub fn pango_renderer_get_alpha(renderer: *mut PangoRenderer, part: PangoRenderPart) -> u16;
    pub fn pango_renderer_get_color(renderer: *mut PangoRenderer, part: PangoRenderPart) -> *mut PangoColor;
    pub fn pango_renderer_get_layout(renderer: *mut PangoRenderer) -> *mut PangoLayout;
    pub fn pango_renderer_get_layout_line(renderer: *mut PangoRenderer) -> *mut PangoLayoutLine;
    pub fn pango_renderer_get_matrix(renderer: *mut PangoRenderer) -> *const PangoMatrix;
    pub fn pango_renderer_part_changed(renderer: *mut PangoRenderer, part: PangoRenderPart);
    #[cfg(feature = "v1_38")]
    pub fn pango_renderer_set_alpha(renderer: *mut PangoRenderer, part: PangoRenderPart, alpha: u16);
    pub fn pango_renderer_set_color(renderer: *mut PangoRenderer, part: PangoRenderPart, color: *const PangoColor);
    pub fn pango_renderer_set_matrix(renderer: *mut PangoRenderer, matrix: *const PangoMatrix);

    //=========================================================================
    // Other functions
    //=========================================================================
    #[cfg(feature = "v1_38")]
    pub fn pango_attr_background_alpha_new(alpha: u16) -> *mut PangoAttribute;
    pub fn pango_attr_background_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    pub fn pango_attr_fallback_new(enable_fallback: gboolean) -> *mut PangoAttribute;
    pub fn pango_attr_family_new(family: *const c_char) -> *mut PangoAttribute;
    #[cfg(feature = "v1_38")]
    pub fn pango_attr_foreground_alpha_new(alpha: u16) -> *mut PangoAttribute;
    pub fn pango_attr_foreground_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    pub fn pango_attr_gravity_hint_new(hint: PangoGravityHint) -> *mut PangoAttribute;
    pub fn pango_attr_gravity_new(gravity: PangoGravity) -> *mut PangoAttribute;
    pub fn pango_attr_letter_spacing_new(letter_spacing: c_int) -> *mut PangoAttribute;
    pub fn pango_attr_rise_new(rise: c_int) -> *mut PangoAttribute;
    pub fn pango_attr_scale_new(scale_factor: c_double) -> *mut PangoAttribute;
    pub fn pango_attr_stretch_new(stretch: PangoStretch) -> *mut PangoAttribute;
    pub fn pango_attr_strikethrough_color_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    pub fn pango_attr_strikethrough_new(strikethrough: gboolean) -> *mut PangoAttribute;
    pub fn pango_attr_style_new(style: PangoStyle) -> *mut PangoAttribute;
    pub fn pango_attr_underline_color_new(red: u16, green: u16, blue: u16) -> *mut PangoAttribute;
    pub fn pango_attr_underline_new(underline: PangoUnderline) -> *mut PangoAttribute;
    pub fn pango_attr_variant_new(variant: PangoVariant) -> *mut PangoAttribute;
    pub fn pango_attr_weight_new(weight: PangoWeight) -> *mut PangoAttribute;
    pub fn pango_break(text: *const c_char, length: c_int, analysis: *mut PangoAnalysis, attrs: *mut PangoLogAttr, attrs_len: c_int);
    pub fn pango_config_key_get(key: *const c_char) -> *mut c_char;
    pub fn pango_config_key_get_system(key: *const c_char) -> *mut c_char;
    pub fn pango_default_break(text: *const c_char, length: c_int, analysis: *mut PangoAnalysis, attrs: *mut PangoLogAttr, attrs_len: c_int);
    pub fn pango_extents_to_pixels(inclusive: *mut PangoRectangle, nearest: *mut PangoRectangle);
    pub fn pango_find_base_dir(text: *const c_char, length: c_int) -> PangoDirection;
    pub fn pango_find_map(language: *mut PangoLanguage, engine_type_id: c_uint, render_type_id: c_uint) -> *mut PangoMap;
    pub fn pango_find_paragraph_boundary(text: *const c_char, length: c_int, paragraph_delimiter_index: *mut c_int, next_paragraph_start: *mut c_int);
    pub fn pango_get_lib_subdirectory() -> *const c_char;
    pub fn pango_get_log_attrs(text: *const c_char, length: c_int, level: c_int, language: *mut PangoLanguage, log_attrs: *mut PangoLogAttr, attrs_len: c_int);
    pub fn pango_get_mirror_char(ch: u32, mirrored_ch: *mut u32) -> gboolean;
    pub fn pango_get_sysconf_subdirectory() -> *const c_char;
    pub fn pango_is_zero_width(ch: u32) -> gboolean;
    pub fn pango_itemize(context: *mut PangoContext, text: *const c_char, start_index: c_int, length: c_int, attrs: *mut PangoAttrList, cached_iter: *mut PangoAttrIterator) -> *mut glib::GList;
    pub fn pango_itemize_with_base_dir(context: *mut PangoContext, base_dir: PangoDirection, text: *const c_char, start_index: c_int, length: c_int, attrs: *mut PangoAttrList, cached_iter: *mut PangoAttrIterator) -> *mut glib::GList;
    pub fn pango_log2vis_get_embedding_levels(text: *const c_char, length: c_int, pbase_dir: *mut PangoDirection) -> *mut u8;
    pub fn pango_lookup_aliases(fontname: *const c_char, families: *mut *mut *mut c_char, n_families: *mut c_int);
    #[cfg(feature = "v1_31")]
    pub fn pango_markup_parser_finish(context: *mut glib::GMarkupParseContext, attr_list: *mut *mut PangoAttrList, text: *mut *mut c_char, accel_char: *mut u32, error: *mut *mut glib::GError) -> gboolean;
    #[cfg(feature = "v1_31")]
    pub fn pango_markup_parser_new(accel_marker: u32) -> *mut glib::GMarkupParseContext;
    pub fn pango_module_register(module: *mut PangoIncludedModule);
    pub fn pango_parse_enum(type_: GType, str: *const c_char, value: *mut c_int, warn: gboolean, possible_values: *mut *mut c_char) -> gboolean;
    pub fn pango_parse_markup(markup_text: *const c_char, length: c_int, accel_marker: u32, attr_list: *mut *mut PangoAttrList, text: *mut *mut c_char, accel_char: *mut u32, error: *mut *mut glib::GError) -> gboolean;
    pub fn pango_parse_stretch(str: *const c_char, stretch: *mut PangoStretch, warn: gboolean) -> gboolean;
    pub fn pango_parse_style(str: *const c_char, style: *mut PangoStyle, warn: gboolean) -> gboolean;
    pub fn pango_parse_variant(str: *const c_char, variant: *mut PangoVariant, warn: gboolean) -> gboolean;
    pub fn pango_parse_weight(str: *const c_char, weight: *mut PangoWeight, warn: gboolean) -> gboolean;
    pub fn pango_quantize_line_geometry(thickness: *mut c_int, position: *mut c_int);
    pub fn pango_read_line(stream: *mut FILE, str: *mut glib::GString) -> c_int;
    pub fn pango_reorder_items(logical_items: *mut glib::GList) -> *mut glib::GList;
    pub fn pango_scan_int(pos: *mut *const c_char, out: *mut c_int) -> gboolean;
    pub fn pango_scan_string(pos: *mut *const c_char, out: *mut glib::GString) -> gboolean;
    pub fn pango_scan_word(pos: *mut *const c_char, out: *mut glib::GString) -> gboolean;
    pub fn pango_shape(text: *const c_char, length: c_int, analysis: *const PangoAnalysis, glyphs: *mut PangoGlyphString);
    #[cfg(feature = "v1_32")]
    pub fn pango_shape_full(item_text: *const c_char, item_length: c_int, paragraph_text: *const c_char, paragraph_length: c_int, analysis: *const PangoAnalysis, glyphs: *mut PangoGlyphString);
    pub fn pango_skip_space(pos: *mut *const c_char) -> gboolean;
    pub fn pango_split_file_list(str: *const c_char) -> *mut *mut c_char;
    pub fn pango_trim_string(str: *const c_char) -> *mut c_char;
    pub fn pango_unichar_direction(ch: u32) -> PangoDirection;
    pub fn pango_units_from_double(d: c_double) -> c_int;
    pub fn pango_units_to_double(i: c_int) -> c_double;
    pub fn pango_version() -> c_int;
    pub fn pango_version_check(required_major: c_int, required_minor: c_int, required_micro: c_int) -> *const c_char;
    pub fn pango_version_string() -> *const c_char;

}