This file is indexed.

/usr/include/plank/plank.h is in libplank-dev 0.11.3-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

   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
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
/* plank.h generated by valac 0.34.4, the Vala compiler, do not modify */


#ifndef __PLANK_H__
#define __PLANK_H__

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gdk/gdk.h>
#include <gee.h>
#include <gtk/gtk.h>
#include <gio/gio.h>
#include <cairo.h>
#include <float.h>
#include <math.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <libbamf/libbamf.h>

G_BEGIN_DECLS


#define PLANK_TYPE_DBUS_MANAGER (plank_dbus_manager_get_type ())
#define PLANK_DBUS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DBUS_MANAGER, PlankDBusManager))
#define PLANK_DBUS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DBUS_MANAGER, PlankDBusManagerClass))
#define PLANK_IS_DBUS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DBUS_MANAGER))
#define PLANK_IS_DBUS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DBUS_MANAGER))
#define PLANK_DBUS_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DBUS_MANAGER, PlankDBusManagerClass))

typedef struct _PlankDBusManager PlankDBusManager;
typedef struct _PlankDBusManagerClass PlankDBusManagerClass;
typedef struct _PlankDBusManagerPrivate PlankDBusManagerPrivate;

#define PLANK_TYPE_DOCK_ELEMENT (plank_dock_element_get_type ())
#define PLANK_DOCK_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ELEMENT, PlankDockElement))
#define PLANK_DOCK_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ELEMENT, PlankDockElementClass))
#define PLANK_IS_DOCK_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ELEMENT))
#define PLANK_IS_DOCK_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ELEMENT))
#define PLANK_DOCK_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ELEMENT, PlankDockElementClass))

typedef struct _PlankDockElement PlankDockElement;
typedef struct _PlankDockElementClass PlankDockElementClass;

#define PLANK_TYPE_DOCK_CONTAINER (plank_dock_container_get_type ())
#define PLANK_DOCK_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_CONTAINER, PlankDockContainer))
#define PLANK_DOCK_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_CONTAINER, PlankDockContainerClass))
#define PLANK_IS_DOCK_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_CONTAINER))
#define PLANK_IS_DOCK_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_CONTAINER))
#define PLANK_DOCK_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_CONTAINER, PlankDockContainerClass))

typedef struct _PlankDockContainer PlankDockContainer;
typedef struct _PlankDockContainerClass PlankDockContainerClass;

#define PLANK_TYPE_DOCK_CONTROLLER (plank_dock_controller_get_type ())
#define PLANK_DOCK_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_CONTROLLER, PlankDockController))
#define PLANK_DOCK_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_CONTROLLER, PlankDockControllerClass))
#define PLANK_IS_DOCK_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_CONTROLLER))
#define PLANK_IS_DOCK_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_CONTROLLER))
#define PLANK_DOCK_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_CONTROLLER, PlankDockControllerClass))

typedef struct _PlankDockController PlankDockController;
typedef struct _PlankDockControllerClass PlankDockControllerClass;
typedef struct _PlankDockElementPrivate PlankDockElementPrivate;

#define PLANK_TYPE_POPUP_BUTTON (plank_popup_button_get_type ())

#define PLANK_TYPE_ANIMATION_TYPE (plank_animation_type_get_type ())
typedef struct _PlankDockContainerPrivate PlankDockContainerPrivate;
typedef struct _PlankDockControllerPrivate PlankDockControllerPrivate;

#define PLANK_TYPE_SETTINGS (plank_settings_get_type ())
#define PLANK_SETTINGS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SETTINGS, PlankSettings))
#define PLANK_SETTINGS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SETTINGS, PlankSettingsClass))
#define PLANK_IS_SETTINGS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SETTINGS))
#define PLANK_IS_SETTINGS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SETTINGS))
#define PLANK_SETTINGS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SETTINGS, PlankSettingsClass))

typedef struct _PlankSettings PlankSettings;
typedef struct _PlankSettingsClass PlankSettingsClass;

#define PLANK_TYPE_DOCK_PREFERENCES (plank_dock_preferences_get_type ())
#define PLANK_DOCK_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_PREFERENCES, PlankDockPreferences))
#define PLANK_DOCK_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_PREFERENCES, PlankDockPreferencesClass))
#define PLANK_IS_DOCK_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_PREFERENCES))
#define PLANK_IS_DOCK_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_PREFERENCES))
#define PLANK_DOCK_PREFERENCES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_PREFERENCES, PlankDockPreferencesClass))

typedef struct _PlankDockPreferences PlankDockPreferences;
typedef struct _PlankDockPreferencesClass PlankDockPreferencesClass;

#define PLANK_TYPE_DRAG_MANAGER (plank_drag_manager_get_type ())
#define PLANK_DRAG_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DRAG_MANAGER, PlankDragManager))
#define PLANK_DRAG_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DRAG_MANAGER, PlankDragManagerClass))
#define PLANK_IS_DRAG_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DRAG_MANAGER))
#define PLANK_IS_DRAG_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DRAG_MANAGER))
#define PLANK_DRAG_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DRAG_MANAGER, PlankDragManagerClass))

typedef struct _PlankDragManager PlankDragManager;
typedef struct _PlankDragManagerClass PlankDragManagerClass;

#define PLANK_TYPE_HIDE_MANAGER (plank_hide_manager_get_type ())
#define PLANK_HIDE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_HIDE_MANAGER, PlankHideManager))
#define PLANK_HIDE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_HIDE_MANAGER, PlankHideManagerClass))
#define PLANK_IS_HIDE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_HIDE_MANAGER))
#define PLANK_IS_HIDE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_HIDE_MANAGER))
#define PLANK_HIDE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_HIDE_MANAGER, PlankHideManagerClass))

typedef struct _PlankHideManager PlankHideManager;
typedef struct _PlankHideManagerClass PlankHideManagerClass;

#define PLANK_TYPE_POSITION_MANAGER (plank_position_manager_get_type ())
#define PLANK_POSITION_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_POSITION_MANAGER, PlankPositionManager))
#define PLANK_POSITION_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_POSITION_MANAGER, PlankPositionManagerClass))
#define PLANK_IS_POSITION_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_POSITION_MANAGER))
#define PLANK_IS_POSITION_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_POSITION_MANAGER))
#define PLANK_POSITION_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_POSITION_MANAGER, PlankPositionManagerClass))

typedef struct _PlankPositionManager PlankPositionManager;
typedef struct _PlankPositionManagerClass PlankPositionManagerClass;

#define PLANK_TYPE_RENDERER (plank_renderer_get_type ())
#define PLANK_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_RENDERER, PlankRenderer))
#define PLANK_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_RENDERER, PlankRendererClass))
#define PLANK_IS_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_RENDERER))
#define PLANK_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_RENDERER))
#define PLANK_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_RENDERER, PlankRendererClass))

typedef struct _PlankRenderer PlankRenderer;
typedef struct _PlankRendererClass PlankRendererClass;

#define PLANK_TYPE_DOCK_RENDERER (plank_dock_renderer_get_type ())
#define PLANK_DOCK_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_RENDERER, PlankDockRenderer))
#define PLANK_DOCK_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_RENDERER, PlankDockRendererClass))
#define PLANK_IS_DOCK_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_RENDERER))
#define PLANK_IS_DOCK_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_RENDERER))
#define PLANK_DOCK_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_RENDERER, PlankDockRendererClass))

typedef struct _PlankDockRenderer PlankDockRenderer;
typedef struct _PlankDockRendererClass PlankDockRendererClass;

#define PLANK_TYPE_COMPOSITED_WINDOW (plank_composited_window_get_type ())
#define PLANK_COMPOSITED_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_COMPOSITED_WINDOW, PlankCompositedWindow))
#define PLANK_COMPOSITED_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_COMPOSITED_WINDOW, PlankCompositedWindowClass))
#define PLANK_IS_COMPOSITED_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_COMPOSITED_WINDOW))
#define PLANK_IS_COMPOSITED_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_COMPOSITED_WINDOW))
#define PLANK_COMPOSITED_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_COMPOSITED_WINDOW, PlankCompositedWindowClass))

typedef struct _PlankCompositedWindow PlankCompositedWindow;
typedef struct _PlankCompositedWindowClass PlankCompositedWindowClass;

#define PLANK_TYPE_DOCK_WINDOW (plank_dock_window_get_type ())
#define PLANK_DOCK_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_WINDOW, PlankDockWindow))
#define PLANK_DOCK_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_WINDOW, PlankDockWindowClass))
#define PLANK_IS_DOCK_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_WINDOW))
#define PLANK_IS_DOCK_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_WINDOW))
#define PLANK_DOCK_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_WINDOW, PlankDockWindowClass))

typedef struct _PlankDockWindow PlankDockWindow;
typedef struct _PlankDockWindowClass PlankDockWindowClass;

#define PLANK_TYPE_HOVER_WINDOW (plank_hover_window_get_type ())
#define PLANK_HOVER_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_HOVER_WINDOW, PlankHoverWindow))
#define PLANK_HOVER_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_HOVER_WINDOW, PlankHoverWindowClass))
#define PLANK_IS_HOVER_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_HOVER_WINDOW))
#define PLANK_IS_HOVER_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_HOVER_WINDOW))
#define PLANK_HOVER_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_HOVER_WINDOW, PlankHoverWindowClass))

typedef struct _PlankHoverWindow PlankHoverWindow;
typedef struct _PlankHoverWindowClass PlankHoverWindowClass;

#define PLANK_TYPE_DOCK_ITEM_PROVIDER (plank_dock_item_provider_get_type ())
#define PLANK_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM_PROVIDER, PlankDockItemProvider))
#define PLANK_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM_PROVIDER, PlankDockItemProviderClass))
#define PLANK_IS_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM_PROVIDER))
#define PLANK_IS_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM_PROVIDER))
#define PLANK_DOCK_ITEM_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM_PROVIDER, PlankDockItemProviderClass))

typedef struct _PlankDockItemProvider PlankDockItemProvider;
typedef struct _PlankDockItemProviderClass PlankDockItemProviderClass;

#define PLANK_TYPE_DOCK_ITEM (plank_dock_item_get_type ())
#define PLANK_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM, PlankDockItem))
#define PLANK_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM, PlankDockItemClass))
#define PLANK_IS_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM))
#define PLANK_IS_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM))
#define PLANK_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM, PlankDockItemClass))

typedef struct _PlankDockItem PlankDockItem;
typedef struct _PlankDockItemClass PlankDockItemClass;
typedef struct _PlankSettingsPrivate PlankSettingsPrivate;
typedef struct _PlankDockPreferencesPrivate PlankDockPreferencesPrivate;

#define PLANK_TYPE_HIDE_TYPE (plank_hide_type_get_type ())
typedef struct _PlankRendererPrivate PlankRendererPrivate;
typedef struct _PlankDockRendererPrivate PlankDockRendererPrivate;

#define PLANK_TYPE_PREFERENCES (plank_preferences_get_type ())
#define PLANK_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PREFERENCES, PlankPreferences))
#define PLANK_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PREFERENCES, PlankPreferencesClass))
#define PLANK_IS_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PREFERENCES))
#define PLANK_IS_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PREFERENCES))
#define PLANK_PREFERENCES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PREFERENCES, PlankPreferencesClass))

typedef struct _PlankPreferences PlankPreferences;
typedef struct _PlankPreferencesClass PlankPreferencesClass;

#define PLANK_TYPE_THEME (plank_theme_get_type ())
#define PLANK_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_THEME, PlankTheme))
#define PLANK_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_THEME, PlankThemeClass))
#define PLANK_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_THEME))
#define PLANK_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_THEME))
#define PLANK_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_THEME, PlankThemeClass))

typedef struct _PlankTheme PlankTheme;
typedef struct _PlankThemeClass PlankThemeClass;

#define PLANK_TYPE_DOCK_THEME (plank_dock_theme_get_type ())
#define PLANK_DOCK_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_THEME, PlankDockTheme))
#define PLANK_DOCK_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_THEME, PlankDockThemeClass))
#define PLANK_IS_DOCK_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_THEME))
#define PLANK_IS_DOCK_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_THEME))
#define PLANK_DOCK_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_THEME, PlankDockThemeClass))

typedef struct _PlankDockTheme PlankDockTheme;
typedef struct _PlankDockThemeClass PlankDockThemeClass;
typedef struct _PlankDragManagerPrivate PlankDragManagerPrivate;
typedef struct _PlankHideManagerPrivate PlankHideManagerPrivate;
typedef struct _PlankPositionManagerPrivate PlankPositionManagerPrivate;

#define PLANK_TYPE_DOCK_ITEM_DRAW_VALUE (plank_dock_item_draw_value_get_type ())
#define PLANK_DOCK_ITEM_DRAW_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE, PlankDockItemDrawValue))
#define PLANK_DOCK_ITEM_DRAW_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE, PlankDockItemDrawValueClass))
#define PLANK_IS_DOCK_ITEM_DRAW_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE))
#define PLANK_IS_DOCK_ITEM_DRAW_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE))
#define PLANK_DOCK_ITEM_DRAW_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE, PlankDockItemDrawValueClass))

typedef struct _PlankDockItemDrawValue PlankDockItemDrawValue;
typedef struct _PlankDockItemDrawValueClass PlankDockItemDrawValueClass;

#define PLANK_TYPE_APPLICATION_DOCK_ITEM (plank_application_dock_item_get_type ())
#define PLANK_APPLICATION_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM, PlankApplicationDockItem))
#define PLANK_APPLICATION_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM, PlankApplicationDockItemClass))
#define PLANK_IS_APPLICATION_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM))
#define PLANK_IS_APPLICATION_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM))
#define PLANK_APPLICATION_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM, PlankApplicationDockItemClass))

typedef struct _PlankApplicationDockItem PlankApplicationDockItem;
typedef struct _PlankApplicationDockItemClass PlankApplicationDockItemClass;

#define PLANK_TYPE_DBUS_CLIENT (plank_dbus_client_get_type ())
#define PLANK_DBUS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DBUS_CLIENT, PlankDBusClient))
#define PLANK_DBUS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DBUS_CLIENT, PlankDBusClientClass))
#define PLANK_IS_DBUS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DBUS_CLIENT))
#define PLANK_IS_DBUS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DBUS_CLIENT))
#define PLANK_DBUS_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DBUS_CLIENT, PlankDBusClientClass))

typedef struct _PlankDBusClient PlankDBusClient;
typedef struct _PlankDBusClientClass PlankDBusClientClass;
typedef struct _PlankDBusClientPrivate PlankDBusClientPrivate;

#define PLANK_TYPE_DOCKLET (plank_docklet_get_type ())
#define PLANK_DOCKLET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCKLET, PlankDocklet))
#define PLANK_IS_DOCKLET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCKLET))
#define PLANK_DOCKLET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PLANK_TYPE_DOCKLET, PlankDockletIface))

typedef struct _PlankDocklet PlankDocklet;
typedef struct _PlankDockletIface PlankDockletIface;
typedef struct _PlankDockItemPrivate PlankDockItemPrivate;

#define PLANK_TYPE_SURFACE (plank_surface_get_type ())
#define PLANK_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SURFACE, PlankSurface))
#define PLANK_SURFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SURFACE, PlankSurfaceClass))
#define PLANK_IS_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SURFACE))
#define PLANK_IS_SURFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SURFACE))
#define PLANK_SURFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SURFACE, PlankSurfaceClass))

typedef struct _PlankSurface PlankSurface;
typedef struct _PlankSurfaceClass PlankSurfaceClass;

#define PLANK_TYPE_DOCKLET_ITEM (plank_docklet_item_get_type ())
#define PLANK_DOCKLET_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCKLET_ITEM, PlankDockletItem))
#define PLANK_DOCKLET_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCKLET_ITEM, PlankDockletItemClass))
#define PLANK_IS_DOCKLET_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCKLET_ITEM))
#define PLANK_IS_DOCKLET_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCKLET_ITEM))
#define PLANK_DOCKLET_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCKLET_ITEM, PlankDockletItemClass))

typedef struct _PlankDockletItem PlankDockletItem;
typedef struct _PlankDockletItemClass PlankDockletItemClass;
typedef struct _PlankDockletItemPrivate PlankDockletItemPrivate;

#define PLANK_TYPE_DOCKLET_MANAGER (plank_docklet_manager_get_type ())
#define PLANK_DOCKLET_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCKLET_MANAGER, PlankDockletManager))
#define PLANK_DOCKLET_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCKLET_MANAGER, PlankDockletManagerClass))
#define PLANK_IS_DOCKLET_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCKLET_MANAGER))
#define PLANK_IS_DOCKLET_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCKLET_MANAGER))
#define PLANK_DOCKLET_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCKLET_MANAGER, PlankDockletManagerClass))

typedef struct _PlankDockletManager PlankDockletManager;
typedef struct _PlankDockletManagerClass PlankDockletManagerClass;
typedef struct _PlankDockletManagerPrivate PlankDockletManagerPrivate;

#define PLANK_TYPE_COLOR (plank_color_get_type ())
typedef GdkRGBA PlankColor;

#define PLANK_TYPE_DRAWING_SERVICE (plank_drawing_service_get_type ())
#define PLANK_DRAWING_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DRAWING_SERVICE, PlankDrawingService))
#define PLANK_DRAWING_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DRAWING_SERVICE, PlankDrawingServiceClass))
#define PLANK_IS_DRAWING_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DRAWING_SERVICE))
#define PLANK_IS_DRAWING_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DRAWING_SERVICE))
#define PLANK_DRAWING_SERVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DRAWING_SERVICE, PlankDrawingServiceClass))

typedef struct _PlankDrawingService PlankDrawingService;
typedef struct _PlankDrawingServiceClass PlankDrawingServiceClass;
typedef struct _PlankDrawingServicePrivate PlankDrawingServicePrivate;
typedef struct _PlankPreferencesPrivate PlankPreferencesPrivate;
typedef struct _PlankThemePrivate PlankThemePrivate;
typedef struct _PlankDockThemePrivate PlankDockThemePrivate;

#define PLANK_TYPE_ANIMATION_MODE (plank_animation_mode_get_type ())
typedef struct _PlankSurfacePrivate PlankSurfacePrivate;

#define PLANK_TYPE_SURFACE_CACHE_FLAGS (plank_surface_cache_flags_get_type ())

#define PLANK_TYPE_SURFACE_CACHE (plank_surface_cache_get_type ())
#define PLANK_SURFACE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SURFACE_CACHE, PlankSurfaceCache))
#define PLANK_SURFACE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SURFACE_CACHE, PlankSurfaceCacheClass))
#define PLANK_IS_SURFACE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SURFACE_CACHE))
#define PLANK_IS_SURFACE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SURFACE_CACHE))
#define PLANK_SURFACE_CACHE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SURFACE_CACHE, PlankSurfaceCacheClass))

typedef struct _PlankSurfaceCache PlankSurfaceCache;
typedef struct _PlankSurfaceCacheClass PlankSurfaceCacheClass;
typedef struct _PlankSurfaceCachePrivate PlankSurfaceCachePrivate;

#define PLANK_TYPE_ABSTRACT_MAIN (plank_abstract_main_get_type ())
#define PLANK_ABSTRACT_MAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_ABSTRACT_MAIN, PlankAbstractMain))
#define PLANK_ABSTRACT_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_ABSTRACT_MAIN, PlankAbstractMainClass))
#define PLANK_IS_ABSTRACT_MAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_ABSTRACT_MAIN))
#define PLANK_IS_ABSTRACT_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_ABSTRACT_MAIN))
#define PLANK_ABSTRACT_MAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_ABSTRACT_MAIN, PlankAbstractMainClass))

typedef struct _PlankAbstractMain PlankAbstractMain;
typedef struct _PlankAbstractMainClass PlankAbstractMainClass;
typedef struct _PlankAbstractMainPrivate PlankAbstractMainPrivate;

#define PLANK_TYPE_FACTORY (plank_factory_get_type ())
#define PLANK_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_FACTORY, PlankFactory))
#define PLANK_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_FACTORY, PlankFactoryClass))
#define PLANK_IS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_FACTORY))
#define PLANK_IS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_FACTORY))
#define PLANK_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_FACTORY, PlankFactoryClass))

typedef struct _PlankFactory PlankFactory;
typedef struct _PlankFactoryClass PlankFactoryClass;
typedef struct _PlankFactoryPrivate PlankFactoryPrivate;

#define PLANK_TYPE_ITEM_FACTORY (plank_item_factory_get_type ())
#define PLANK_ITEM_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_ITEM_FACTORY, PlankItemFactory))
#define PLANK_ITEM_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_ITEM_FACTORY, PlankItemFactoryClass))
#define PLANK_IS_ITEM_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_ITEM_FACTORY))
#define PLANK_IS_ITEM_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_ITEM_FACTORY))
#define PLANK_ITEM_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_ITEM_FACTORY, PlankItemFactoryClass))

typedef struct _PlankItemFactory PlankItemFactory;
typedef struct _PlankItemFactoryClass PlankItemFactoryClass;
typedef struct _PlankItemFactoryPrivate PlankItemFactoryPrivate;
typedef struct _PlankApplicationDockItemPrivate PlankApplicationDockItemPrivate;
typedef struct _PlankDockItemProviderPrivate PlankDockItemProviderPrivate;

#define PLANK_TYPE_UNITY_CLIENT (plank_unity_client_get_type ())
#define PLANK_UNITY_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_UNITY_CLIENT, PlankUnityClient))
#define PLANK_IS_UNITY_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_UNITY_CLIENT))
#define PLANK_UNITY_CLIENT_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PLANK_TYPE_UNITY_CLIENT, PlankUnityClientIface))

typedef struct _PlankUnityClient PlankUnityClient;
typedef struct _PlankUnityClientIface PlankUnityClientIface;

#define PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER (plank_application_dock_item_provider_get_type ())
#define PLANK_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER, PlankApplicationDockItemProvider))
#define PLANK_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER, PlankApplicationDockItemProviderClass))
#define PLANK_IS_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_IS_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_APPLICATION_DOCK_ITEM_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER, PlankApplicationDockItemProviderClass))

typedef struct _PlankApplicationDockItemProvider PlankApplicationDockItemProvider;
typedef struct _PlankApplicationDockItemProviderClass PlankApplicationDockItemProviderClass;
typedef struct _PlankApplicationDockItemProviderPrivate PlankApplicationDockItemProviderPrivate;

#define PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER (plank_default_application_dock_item_provider_get_type ())
#define PLANK_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER, PlankDefaultApplicationDockItemProvider))
#define PLANK_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER, PlankDefaultApplicationDockItemProviderClass))
#define PLANK_IS_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_IS_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER, PlankDefaultApplicationDockItemProviderClass))

typedef struct _PlankDefaultApplicationDockItemProvider PlankDefaultApplicationDockItemProvider;
typedef struct _PlankDefaultApplicationDockItemProviderClass PlankDefaultApplicationDockItemProviderClass;
typedef struct _PlankDefaultApplicationDockItemProviderPrivate PlankDefaultApplicationDockItemProviderPrivate;

#define PLANK_TYPE_PLACEHOLDER_DOCK_ITEM (plank_placeholder_dock_item_get_type ())
#define PLANK_PLACEHOLDER_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM, PlankPlaceholderDockItem))
#define PLANK_PLACEHOLDER_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM, PlankPlaceholderDockItemClass))
#define PLANK_IS_PLACEHOLDER_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM))
#define PLANK_IS_PLACEHOLDER_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM))
#define PLANK_PLACEHOLDER_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM, PlankPlaceholderDockItemClass))

typedef struct _PlankPlaceholderDockItem PlankPlaceholderDockItem;
typedef struct _PlankPlaceholderDockItemClass PlankPlaceholderDockItemClass;

#define PLANK_TYPE_ITEM_STATE (plank_item_state_get_type ())

#define PLANK_TYPE_INDICATOR_STATE (plank_indicator_state_get_type ())

#define PLANK_TYPE_DOCK_ITEM_PREFERENCES (plank_dock_item_preferences_get_type ())
#define PLANK_DOCK_ITEM_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM_PREFERENCES, PlankDockItemPreferences))
#define PLANK_DOCK_ITEM_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM_PREFERENCES, PlankDockItemPreferencesClass))
#define PLANK_IS_DOCK_ITEM_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM_PREFERENCES))
#define PLANK_IS_DOCK_ITEM_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM_PREFERENCES))
#define PLANK_DOCK_ITEM_PREFERENCES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM_PREFERENCES, PlankDockItemPreferencesClass))

typedef struct _PlankDockItemPreferences PlankDockItemPreferences;
typedef struct _PlankDockItemPreferencesClass PlankDockItemPreferencesClass;

#define PLANK_TYPE_POINT_D (plank_point_d_get_type ())
typedef struct _PlankPointD PlankPointD;
typedef struct _PlankDockItemDrawValuePrivate PlankDockItemDrawValuePrivate;
typedef struct _PlankDockItemPreferencesPrivate PlankDockItemPreferencesPrivate;

#define PLANK_TYPE_FILE_DOCK_ITEM (plank_file_dock_item_get_type ())
#define PLANK_FILE_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_FILE_DOCK_ITEM, PlankFileDockItem))
#define PLANK_FILE_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_FILE_DOCK_ITEM, PlankFileDockItemClass))
#define PLANK_IS_FILE_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_FILE_DOCK_ITEM))
#define PLANK_IS_FILE_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_FILE_DOCK_ITEM))
#define PLANK_FILE_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_FILE_DOCK_ITEM, PlankFileDockItemClass))

typedef struct _PlankFileDockItem PlankFileDockItem;
typedef struct _PlankFileDockItemClass PlankFileDockItemClass;
typedef struct _PlankFileDockItemPrivate PlankFileDockItemPrivate;
typedef struct _PlankPlaceholderDockItemPrivate PlankPlaceholderDockItemPrivate;

#define PLANK_TYPE_PLANK_DOCK_ITEM (plank_plank_dock_item_get_type ())
#define PLANK_PLANK_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PLANK_DOCK_ITEM, PlankPlankDockItem))
#define PLANK_PLANK_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PLANK_DOCK_ITEM, PlankPlankDockItemClass))
#define PLANK_IS_PLANK_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PLANK_DOCK_ITEM))
#define PLANK_IS_PLANK_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PLANK_DOCK_ITEM))
#define PLANK_PLANK_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PLANK_DOCK_ITEM, PlankPlankDockItemClass))

typedef struct _PlankPlankDockItem PlankPlankDockItem;
typedef struct _PlankPlankDockItemClass PlankPlankDockItemClass;
typedef struct _PlankPlankDockItemPrivate PlankPlankDockItemPrivate;

#define PLANK_TYPE_TRANSIENT_DOCK_ITEM (plank_transient_dock_item_get_type ())
#define PLANK_TRANSIENT_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_TRANSIENT_DOCK_ITEM, PlankTransientDockItem))
#define PLANK_TRANSIENT_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_TRANSIENT_DOCK_ITEM, PlankTransientDockItemClass))
#define PLANK_IS_TRANSIENT_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_TRANSIENT_DOCK_ITEM))
#define PLANK_IS_TRANSIENT_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_TRANSIENT_DOCK_ITEM))
#define PLANK_TRANSIENT_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_TRANSIENT_DOCK_ITEM, PlankTransientDockItemClass))

typedef struct _PlankTransientDockItem PlankTransientDockItem;
typedef struct _PlankTransientDockItemClass PlankTransientDockItemClass;
typedef struct _PlankTransientDockItemPrivate PlankTransientDockItemPrivate;

#define PLANK_TYPE_XDG_SESSION_CLASS (plank_xdg_session_class_get_type ())

#define PLANK_TYPE_XDG_SESSION_DESKTOP (plank_xdg_session_desktop_get_type ())

#define PLANK_TYPE_XDG_SESSION_TYPE (plank_xdg_session_type_get_type ())

#define PLANK_TYPE_LOG_LEVEL (plank_log_level_get_type ())

#define PLANK_TYPE_LOGGER (plank_logger_get_type ())
#define PLANK_LOGGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_LOGGER, PlankLogger))
#define PLANK_LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_LOGGER, PlankLoggerClass))
#define PLANK_IS_LOGGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_LOGGER))
#define PLANK_IS_LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_LOGGER))
#define PLANK_LOGGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_LOGGER, PlankLoggerClass))

typedef struct _PlankLogger PlankLogger;
typedef struct _PlankLoggerClass PlankLoggerClass;
typedef struct _PlankLoggerPrivate PlankLoggerPrivate;

#define PLANK_TYPE_PATHS (plank_paths_get_type ())
#define PLANK_PATHS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PATHS, PlankPaths))
#define PLANK_PATHS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PATHS, PlankPathsClass))
#define PLANK_IS_PATHS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PATHS))
#define PLANK_IS_PATHS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PATHS))
#define PLANK_PATHS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PATHS, PlankPathsClass))

typedef struct _PlankPaths PlankPaths;
typedef struct _PlankPathsClass PlankPathsClass;
typedef struct _PlankPathsPrivate PlankPathsPrivate;

#define PLANK_TYPE_SERIALIZABLE (plank_serializable_get_type ())
#define PLANK_SERIALIZABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SERIALIZABLE, PlankSerializable))
#define PLANK_IS_SERIALIZABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SERIALIZABLE))
#define PLANK_SERIALIZABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PLANK_TYPE_SERIALIZABLE, PlankSerializableIface))

typedef struct _PlankSerializable PlankSerializable;
typedef struct _PlankSerializableIface PlankSerializableIface;

#define PLANK_TYPE_SYSTEM (plank_system_get_type ())
#define PLANK_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SYSTEM, PlankSystem))
#define PLANK_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SYSTEM, PlankSystemClass))
#define PLANK_IS_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SYSTEM))
#define PLANK_IS_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SYSTEM))
#define PLANK_SYSTEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SYSTEM, PlankSystemClass))

typedef struct _PlankSystem PlankSystem;
typedef struct _PlankSystemClass PlankSystemClass;
typedef struct _PlankSystemPrivate PlankSystemPrivate;

#define PLANK_TYPE_UNITY (plank_unity_get_type ())
#define PLANK_UNITY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_UNITY, PlankUnity))
#define PLANK_UNITY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_UNITY, PlankUnityClass))
#define PLANK_IS_UNITY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_UNITY))
#define PLANK_IS_UNITY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_UNITY))
#define PLANK_UNITY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_UNITY, PlankUnityClass))

typedef struct _PlankUnity PlankUnity;
typedef struct _PlankUnityClass PlankUnityClass;
typedef struct _PlankUnityPrivate PlankUnityPrivate;

#define PLANK_TYPE_TASK_PRIORITY (plank_task_priority_get_type ())

#define PLANK_TYPE_WORKER (plank_worker_get_type ())
#define PLANK_WORKER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_WORKER, PlankWorker))
#define PLANK_WORKER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_WORKER, PlankWorkerClass))
#define PLANK_IS_WORKER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_WORKER))
#define PLANK_IS_WORKER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_WORKER))
#define PLANK_WORKER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_WORKER, PlankWorkerClass))

typedef struct _PlankWorker PlankWorker;
typedef struct _PlankWorkerClass PlankWorkerClass;
typedef struct _PlankWorkerPrivate PlankWorkerPrivate;
typedef struct _PlankCompositedWindowPrivate PlankCompositedWindowPrivate;
typedef struct _PlankDockWindowPrivate PlankDockWindowPrivate;
typedef struct _PlankHoverWindowPrivate PlankHoverWindowPrivate;

#define PLANK_TYPE_POOF_WINDOW (plank_poof_window_get_type ())
#define PLANK_POOF_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_POOF_WINDOW, PlankPoofWindow))
#define PLANK_POOF_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_POOF_WINDOW, PlankPoofWindowClass))
#define PLANK_IS_POOF_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_POOF_WINDOW))
#define PLANK_IS_POOF_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_POOF_WINDOW))
#define PLANK_POOF_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_POOF_WINDOW, PlankPoofWindowClass))

typedef struct _PlankPoofWindow PlankPoofWindow;
typedef struct _PlankPoofWindowClass PlankPoofWindowClass;
typedef struct _PlankPoofWindowPrivate PlankPoofWindowPrivate;

#define PLANK_TYPE_PREFERENCES_WINDOW (plank_preferences_window_get_type ())
#define PLANK_PREFERENCES_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PREFERENCES_WINDOW, PlankPreferencesWindow))
#define PLANK_PREFERENCES_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PREFERENCES_WINDOW, PlankPreferencesWindowClass))
#define PLANK_IS_PREFERENCES_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PREFERENCES_WINDOW))
#define PLANK_IS_PREFERENCES_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PREFERENCES_WINDOW))
#define PLANK_PREFERENCES_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PREFERENCES_WINDOW, PlankPreferencesWindowClass))

typedef struct _PlankPreferencesWindow PlankPreferencesWindow;
typedef struct _PlankPreferencesWindowClass PlankPreferencesWindowClass;
typedef struct _PlankPreferencesWindowPrivate PlankPreferencesWindowPrivate;

#define PLANK_TYPE_TITLED_SEPARATOR_MENU_ITEM (plank_titled_separator_menu_item_get_type ())
#define PLANK_TITLED_SEPARATOR_MENU_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_TITLED_SEPARATOR_MENU_ITEM, PlankTitledSeparatorMenuItem))
#define PLANK_TITLED_SEPARATOR_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_TITLED_SEPARATOR_MENU_ITEM, PlankTitledSeparatorMenuItemClass))
#define PLANK_IS_TITLED_SEPARATOR_MENU_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_TITLED_SEPARATOR_MENU_ITEM))
#define PLANK_IS_TITLED_SEPARATOR_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_TITLED_SEPARATOR_MENU_ITEM))
#define PLANK_TITLED_SEPARATOR_MENU_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_TITLED_SEPARATOR_MENU_ITEM, PlankTitledSeparatorMenuItemClass))

typedef struct _PlankTitledSeparatorMenuItem PlankTitledSeparatorMenuItem;
typedef struct _PlankTitledSeparatorMenuItemClass PlankTitledSeparatorMenuItemClass;
typedef struct _PlankTitledSeparatorMenuItemPrivate PlankTitledSeparatorMenuItemPrivate;

struct _PlankDBusManager {
	GObject parent_instance;
	PlankDBusManagerPrivate * priv;
};

struct _PlankDBusManagerClass {
	GObjectClass parent_class;
};

typedef enum  {
	PLANK_POPUP_BUTTON_NONE = 1 << 0,
	PLANK_POPUP_BUTTON_LEFT = 1 << 1,
	PLANK_POPUP_BUTTON_MIDDLE = 1 << 2,
	PLANK_POPUP_BUTTON_RIGHT = 1 << 3
} PlankPopupButton;

typedef enum  {
	PLANK_ANIMATION_TYPE_NONE,
	PLANK_ANIMATION_TYPE_BOUNCE,
	PLANK_ANIMATION_TYPE_DARKEN,
	PLANK_ANIMATION_TYPE_LIGHTEN
} PlankAnimationType;

struct _PlankDockElement {
	GObject parent_instance;
	PlankDockElementPrivate * priv;
};

struct _PlankDockElementClass {
	GObjectClass parent_class;
	PlankAnimationType (*on_clicked) (PlankDockElement* self, PlankPopupButton button, GdkModifierType mod, guint32 event_time);
	PlankAnimationType (*on_hovered) (PlankDockElement* self);
	PlankAnimationType (*on_scrolled) (PlankDockElement* self, GdkScrollDirection direction, GdkModifierType mod, guint32 event_time);
	GeeArrayList* (*get_menu_items) (PlankDockElement* self);
	gchar* (*get_drop_text) (PlankDockElement* self);
	gboolean (*can_be_removed) (PlankDockElement* self);
	gboolean (*can_accept_drop) (PlankDockElement* self, GeeArrayList* uris);
	gboolean (*accept_drop) (PlankDockElement* self, GeeArrayList* uris);
	gchar* (*unique_id) (PlankDockElement* self);
	void (*reset_buffers) (PlankDockElement* self);
};

struct _PlankDockContainer {
	PlankDockElement parent_instance;
	PlankDockContainerPrivate * priv;
	GeeArrayList* visible_elements;
	GeeArrayList* internal_elements;
};

struct _PlankDockContainerClass {
	PlankDockElementClass parent_class;
	void (*prepare) (PlankDockContainer* self);
	void (*update_visible_elements) (PlankDockContainer* self);
	gboolean (*move_to) (PlankDockContainer* self, PlankDockElement* move, PlankDockElement* target);
	gboolean (*replace) (PlankDockContainer* self, PlankDockElement* new_element, PlankDockElement* old_element);
	void (*connect_element) (PlankDockContainer* self, PlankDockElement* element);
	void (*disconnect_element) (PlankDockContainer* self, PlankDockElement* element);
};

struct _PlankDockController {
	PlankDockContainer parent_instance;
	PlankDockControllerPrivate * priv;
};

struct _PlankDockControllerClass {
	PlankDockContainerClass parent_class;
};

struct _PlankSettings {
	GObject parent_instance;
	PlankSettingsPrivate * priv;
};

struct _PlankSettingsClass {
	GObjectClass parent_class;
	void (*verify) (PlankSettings* self, const gchar* name);
};

struct _PlankDockPreferences {
	PlankSettings parent_instance;
	PlankDockPreferencesPrivate * priv;
};

struct _PlankDockPreferencesClass {
	PlankSettingsClass parent_class;
};

typedef enum  {
	PLANK_HIDE_TYPE_NONE,
	PLANK_HIDE_TYPE_INTELLIGENT,
	PLANK_HIDE_TYPE_AUTO,
	PLANK_HIDE_TYPE_DODGE_MAXIMIZED,
	PLANK_HIDE_TYPE_WINDOW_DODGE,
	PLANK_HIDE_TYPE_DODGE_ACTIVE
} PlankHideType;

struct _PlankRenderer {
	GObject parent_instance;
	PlankRendererPrivate * priv;
};

struct _PlankRendererClass {
	GObjectClass parent_class;
	gboolean (*animation_needed) (PlankRenderer* self, gint64 frame_time);
	void (*initialize_frame) (PlankRenderer* self, gint64 frame_time);
	void (*draw) (PlankRenderer* self, cairo_t* cr, gint64 frame_time);
};

struct _PlankDockRenderer {
	PlankRenderer parent_instance;
	PlankDockRendererPrivate * priv;
};

struct _PlankDockRendererClass {
	PlankRendererClass parent_class;
};

struct _PlankDragManager {
	GObject parent_instance;
	PlankDragManagerPrivate * priv;
};

struct _PlankDragManagerClass {
	GObjectClass parent_class;
};

struct _PlankHideManager {
	GObject parent_instance;
	PlankHideManagerPrivate * priv;
};

struct _PlankHideManagerClass {
	GObjectClass parent_class;
};

struct _PlankPositionManager {
	GObject parent_instance;
	PlankPositionManagerPrivate * priv;
};

struct _PlankPositionManagerClass {
	GObjectClass parent_class;
};

typedef void (*PlankDrawValueFunc) (PlankDockItem* item, PlankDockItemDrawValue* draw_value, void* user_data);
typedef void (*PlankDrawValuesFunc) (GeeHashMap* draw_values, void* user_data);
struct _PlankDBusClient {
	GObject parent_instance;
	PlankDBusClientPrivate * priv;
};

struct _PlankDBusClientClass {
	GObjectClass parent_class;
};

struct _PlankDockletIface {
	GTypeInterface parent_iface;
	const gchar* (*get_id) (PlankDocklet* self);
	const gchar* (*get_name) (PlankDocklet* self);
	const gchar* (*get_description) (PlankDocklet* self);
	const gchar* (*get_icon) (PlankDocklet* self);
	gboolean (*is_supported) (PlankDocklet* self);
	PlankDockElement* (*make_element) (PlankDocklet* self, const gchar* launcher, GFile* file);
};

struct _PlankDockItem {
	PlankDockElement parent_instance;
	PlankDockItemPrivate * priv;
};

struct _PlankDockItemClass {
	PlankDockElementClass parent_class;
	void (*load_from_launcher) (PlankDockItem* self);
	void (*draw_icon) (PlankDockItem* self, PlankSurface* surface);
	void (*draw_icon_fast) (PlankDockItem* self, PlankSurface* surface);
	gboolean (*is_valid) (PlankDockItem* self);
};

struct _PlankDockletItem {
	PlankDockItem parent_instance;
	PlankDockletItemPrivate * priv;
};

struct _PlankDockletItemClass {
	PlankDockItemClass parent_class;
};

typedef void (*PlankDockletInitFunc) (PlankDockletManager* manager, void* user_data);
struct _PlankDockletManager {
	GObject parent_instance;
	PlankDockletManagerPrivate * priv;
};

struct _PlankDockletManagerClass {
	GObjectClass parent_class;
};

struct _PlankDrawingService {
	GObject parent_instance;
	PlankDrawingServicePrivate * priv;
};

struct _PlankDrawingServiceClass {
	GObjectClass parent_class;
};

struct _PlankPreferences {
	GObject parent_instance;
	PlankPreferencesPrivate * priv;
};

struct _PlankPreferencesClass {
	GObjectClass parent_class;
	void (*verify) (PlankPreferences* self, const gchar* prop);
	void (*reset_properties) (PlankPreferences* self);
};

struct _PlankTheme {
	PlankPreferences parent_instance;
	PlankThemePrivate * priv;
};

struct _PlankThemeClass {
	PlankPreferencesClass parent_class;
};

struct _PlankDockTheme {
	PlankTheme parent_instance;
	PlankDockThemePrivate * priv;
};

struct _PlankDockThemeClass {
	PlankThemeClass parent_class;
};

typedef enum  {
	PLANK_ANIMATION_MODE_CUSTOM = 0,
	PLANK_ANIMATION_MODE_LINEAR,
	PLANK_ANIMATION_MODE_EASE_IN_QUAD,
	PLANK_ANIMATION_MODE_EASE_OUT_QUAD,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_QUAD,
	PLANK_ANIMATION_MODE_EASE_IN_CUBIC,
	PLANK_ANIMATION_MODE_EASE_OUT_CUBIC,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_CUBIC,
	PLANK_ANIMATION_MODE_EASE_IN_QUART,
	PLANK_ANIMATION_MODE_EASE_OUT_QUART,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_QUART,
	PLANK_ANIMATION_MODE_EASE_IN_QUINT,
	PLANK_ANIMATION_MODE_EASE_OUT_QUINT,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_QUINT,
	PLANK_ANIMATION_MODE_EASE_IN_SINE,
	PLANK_ANIMATION_MODE_EASE_OUT_SINE,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_SINE,
	PLANK_ANIMATION_MODE_EASE_IN_EXPO,
	PLANK_ANIMATION_MODE_EASE_OUT_EXPO,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_EXPO,
	PLANK_ANIMATION_MODE_EASE_IN_CIRC,
	PLANK_ANIMATION_MODE_EASE_OUT_CIRC,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_CIRC,
	PLANK_ANIMATION_MODE_EASE_IN_ELASTIC,
	PLANK_ANIMATION_MODE_EASE_OUT_ELASTIC,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_ELASTIC,
	PLANK_ANIMATION_MODE_EASE_IN_BACK,
	PLANK_ANIMATION_MODE_EASE_OUT_BACK,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_BACK,
	PLANK_ANIMATION_MODE_EASE_IN_BOUNCE,
	PLANK_ANIMATION_MODE_EASE_OUT_BOUNCE,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_BOUNCE,
	PLANK_ANIMATION_MODE_LAST
} PlankAnimationMode;

struct _PlankSurface {
	GObject parent_instance;
	PlankSurfacePrivate * priv;
};

struct _PlankSurfaceClass {
	GObjectClass parent_class;
};

typedef PlankSurface* (*PlankDrawDataFunc) (gint width, gint height, PlankSurface* model, gconstpointer data, void* user_data);
typedef PlankSurface* (*PlankDrawFunc) (gint width, gint height, PlankSurface* model, PlankDrawDataFunc draw_data_func, void* draw_data_func_target, void* user_data);
typedef enum  {
	PLANK_SURFACE_CACHE_FLAGS_NONE = 0,
	PLANK_SURFACE_CACHE_FLAGS_ALLOW_DOWNSCALE = 1 << 0,
	PLANK_SURFACE_CACHE_FLAGS_ALLOW_UPSCALE = 1 << 1,
	PLANK_SURFACE_CACHE_FLAGS_ALLOW_SCALE = PLANK_SURFACE_CACHE_FLAGS_ALLOW_UPSCALE | PLANK_SURFACE_CACHE_FLAGS_ALLOW_DOWNSCALE,
	PLANK_SURFACE_CACHE_FLAGS_ADAPTIVE_SCALE = 1 << 2
} PlankSurfaceCacheFlags;

struct _PlankSurfaceCache {
	GObject parent_instance;
	PlankSurfaceCachePrivate * priv;
};

struct _PlankSurfaceCacheClass {
	GObjectClass parent_class;
};

struct _PlankAbstractMain {
	GtkApplication parent_instance;
	PlankAbstractMainPrivate * priv;
};

struct _PlankAbstractMainClass {
	GtkApplicationClass parent_class;
	void (*initialize) (PlankAbstractMain* self);
	void (*create_docks) (PlankAbstractMain* self);
	void (*create_actions) (PlankAbstractMain* self);
};

struct _PlankFactory {
	GObject parent_instance;
	PlankFactoryPrivate * priv;
};

struct _PlankFactoryClass {
	GObjectClass parent_class;
};

struct _PlankItemFactory {
	GObject parent_instance;
	PlankItemFactoryPrivate * priv;
	GFile* launchers_dir;
};

struct _PlankItemFactoryClass {
	GObjectClass parent_class;
	PlankDockElement* (*make_element) (PlankItemFactory* self, GFile* file);
	PlankDockItem* (*get_item_for_dock) (PlankItemFactory* self);
};

struct _PlankApplicationDockItem {
	PlankDockItem parent_instance;
	PlankApplicationDockItemPrivate * priv;
};

struct _PlankApplicationDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankDockItemProvider {
	PlankDockContainer parent_instance;
	PlankDockItemProviderPrivate * priv;
};

struct _PlankDockItemProviderClass {
	PlankDockContainerClass parent_class;
	gboolean (*item_exists_for_uri) (PlankDockItemProvider* self, const gchar* uri);
	PlankDockItem* (*item_for_uri) (PlankDockItemProvider* self, const gchar* uri);
	gboolean (*add_item_with_uri) (PlankDockItemProvider* self, const gchar* uri, PlankDockItem* target);
	void (*handle_item_deleted) (PlankDockItemProvider* self, PlankDockItem* item);
	gchar** (*get_dockitem_filenames) (PlankDockItemProvider* self, int* result_length1);
};

struct _PlankUnityClientIface {
	GTypeInterface parent_iface;
	void (*update_launcher_entry) (PlankUnityClient* self, const gchar* sender_name, GVariant* parameters, gboolean is_retry);
	void (*remove_launcher_entry) (PlankUnityClient* self, const gchar* sender_name);
};

struct _PlankApplicationDockItemProvider {
	PlankDockItemProvider parent_instance;
	PlankApplicationDockItemProviderPrivate * priv;
};

struct _PlankApplicationDockItemProviderClass {
	PlankDockItemProviderClass parent_class;
	void (*app_opened) (PlankApplicationDockItemProvider* self, BamfApplication* app);
};

struct _PlankDefaultApplicationDockItemProvider {
	PlankApplicationDockItemProvider parent_instance;
	PlankDefaultApplicationDockItemProviderPrivate * priv;
};

struct _PlankDefaultApplicationDockItemProviderClass {
	PlankApplicationDockItemProviderClass parent_class;
};

typedef enum  {
	PLANK_ITEM_STATE_NORMAL = 1 << 0,
	PLANK_ITEM_STATE_ACTIVE = 1 << 1,
	PLANK_ITEM_STATE_URGENT = 1 << 2,
	PLANK_ITEM_STATE_MOVE = 1 << 3,
	PLANK_ITEM_STATE_INVALID = 1 << 4
} PlankItemState;

typedef enum  {
	PLANK_INDICATOR_STATE_NONE,
	PLANK_INDICATOR_STATE_SINGLE,
	PLANK_INDICATOR_STATE_SINGLE_PLUS
} PlankIndicatorState;

struct _PlankPointD {
	gdouble x;
	gdouble y;
};

struct _PlankDockItemDrawValue {
	GTypeInstance parent_instance;
	volatile int ref_count;
	PlankDockItemDrawValuePrivate * priv;
	PlankPointD center;
	PlankPointD static_center;
	gdouble icon_size;
	GdkRectangle hover_region;
	GdkRectangle draw_region;
	GdkRectangle background_region;
	gdouble zoom;
	gdouble opacity;
	gdouble darken;
	gdouble lighten;
	gboolean show_indicator;
};

struct _PlankDockItemDrawValueClass {
	GTypeClass parent_class;
	void (*finalize) (PlankDockItemDrawValue *self);
};

struct _PlankDockItemPreferences {
	PlankPreferences parent_instance;
	PlankDockItemPreferencesPrivate * priv;
};

struct _PlankDockItemPreferencesClass {
	PlankPreferencesClass parent_class;
};

struct _PlankFileDockItem {
	PlankDockItem parent_instance;
	PlankFileDockItemPrivate * priv;
};

struct _PlankFileDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankPlaceholderDockItem {
	PlankDockItem parent_instance;
	PlankPlaceholderDockItemPrivate * priv;
};

struct _PlankPlaceholderDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankPlankDockItem {
	PlankDockItem parent_instance;
	PlankPlankDockItemPrivate * priv;
};

struct _PlankPlankDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankTransientDockItem {
	PlankApplicationDockItem parent_instance;
	PlankTransientDockItemPrivate * priv;
};

struct _PlankTransientDockItemClass {
	PlankApplicationDockItemClass parent_class;
};

typedef enum  {
	PLANK_XDG_SESSION_CLASS_USER,
	PLANK_XDG_SESSION_CLASS_GREETER,
	PLANK_XDG_SESSION_CLASS_LOCK_SCREEN,
	PLANK_XDG_SESSION_CLASS_BACKGROUND
} PlankXdgSessionClass;

typedef enum  {
	PLANK_XDG_SESSION_DESKTOP_GNOME = 1 << 0,
	PLANK_XDG_SESSION_DESKTOP_KDE = 1 << 1,
	PLANK_XDG_SESSION_DESKTOP_LXDE = 1 << 2,
	PLANK_XDG_SESSION_DESKTOP_MATE = 1 << 3,
	PLANK_XDG_SESSION_DESKTOP_RAZOR = 1 << 4,
	PLANK_XDG_SESSION_DESKTOP_ROX = 1 << 5,
	PLANK_XDG_SESSION_DESKTOP_TDE = 1 << 6,
	PLANK_XDG_SESSION_DESKTOP_UNITY = 1 << 7,
	PLANK_XDG_SESSION_DESKTOP_XFCE = 1 << 8,
	PLANK_XDG_SESSION_DESKTOP_EDE = 1 << 9,
	PLANK_XDG_SESSION_DESKTOP_CINNAMON = 1 << 10,
	PLANK_XDG_SESSION_DESKTOP_PANTHEON = 1 << 11,
	PLANK_XDG_SESSION_DESKTOP_OLD = 1 << 12
} PlankXdgSessionDesktop;

typedef enum  {
	PLANK_XDG_SESSION_TYPE_UNSPECIFIED,
	PLANK_XDG_SESSION_TYPE_TTY,
	PLANK_XDG_SESSION_TYPE_X11,
	PLANK_XDG_SESSION_TYPE_WAYLAND,
	PLANK_XDG_SESSION_TYPE_MIR
} PlankXdgSessionType;

typedef enum  {
	PLANK_LOG_LEVEL_VERBOSE,
	PLANK_LOG_LEVEL_DEBUG,
	PLANK_LOG_LEVEL_INFO,
	PLANK_LOG_LEVEL_NOTIFY,
	PLANK_LOG_LEVEL_WARN,
	PLANK_LOG_LEVEL_CRITICAL,
	PLANK_LOG_LEVEL_ERROR
} PlankLogLevel;

struct _PlankLogger {
	GObject parent_instance;
	PlankLoggerPrivate * priv;
};

struct _PlankLoggerClass {
	GObjectClass parent_class;
};

struct _PlankPaths {
	GObject parent_instance;
	PlankPathsPrivate * priv;
};

struct _PlankPathsClass {
	GObjectClass parent_class;
};

struct _PlankSerializableIface {
	GTypeInterface parent_iface;
	gchar* (*serialize) (PlankSerializable* self);
	void (*deserialize) (PlankSerializable* self, const gchar* s);
};

struct _PlankSystem {
	GObject parent_instance;
	PlankSystemPrivate * priv;
};

struct _PlankSystemClass {
	GObjectClass parent_class;
};

struct _PlankUnity {
	GObject parent_instance;
	PlankUnityPrivate * priv;
};

struct _PlankUnityClass {
	GObjectClass parent_class;
};

typedef enum  {
	PLANK_TASK_PRIORITY_LOW,
	PLANK_TASK_PRIORITY_DEFAULT,
	PLANK_TASK_PRIORITY_HIGH
} PlankTaskPriority;

typedef gpointer (*PlankTaskFunc) (void* user_data, GError** error);
struct _PlankWorker {
	GObject parent_instance;
	PlankWorkerPrivate * priv;
};

struct _PlankWorkerClass {
	GObjectClass parent_class;
};

struct _PlankCompositedWindow {
	GtkWindow parent_instance;
	PlankCompositedWindowPrivate * priv;
};

struct _PlankCompositedWindowClass {
	GtkWindowClass parent_class;
};

struct _PlankDockWindow {
	PlankCompositedWindow parent_instance;
	PlankDockWindowPrivate * priv;
};

struct _PlankDockWindowClass {
	PlankCompositedWindowClass parent_class;
};

struct _PlankHoverWindow {
	GtkWindow parent_instance;
	PlankHoverWindowPrivate * priv;
};

struct _PlankHoverWindowClass {
	GtkWindowClass parent_class;
};

struct _PlankPoofWindow {
	PlankCompositedWindow parent_instance;
	PlankPoofWindowPrivate * priv;
};

struct _PlankPoofWindowClass {
	PlankCompositedWindowClass parent_class;
};

struct _PlankPreferencesWindow {
	GtkWindow parent_instance;
	PlankPreferencesWindowPrivate * priv;
};

struct _PlankPreferencesWindowClass {
	GtkWindowClass parent_class;
};

struct _PlankTitledSeparatorMenuItem {
	GtkSeparatorMenuItem parent_instance;
	PlankTitledSeparatorMenuItemPrivate * priv;
};

struct _PlankTitledSeparatorMenuItemClass {
	GtkSeparatorMenuItemClass parent_class;
};


GType plank_dbus_manager_get_type (void) G_GNUC_CONST;
GType plank_dock_element_get_type (void) G_GNUC_CONST;
GType plank_dock_container_get_type (void) G_GNUC_CONST;
GType plank_dock_controller_get_type (void) G_GNUC_CONST;
PlankDBusManager* plank_dbus_manager_new (PlankDockController* controller);
PlankDBusManager* plank_dbus_manager_construct (GType object_type, PlankDockController* controller);
#define PLANK_G_RESOURCE_PATH "/net/launchpad/plank"
GType plank_popup_button_get_type (void) G_GNUC_CONST;
GType plank_animation_type_get_type (void) G_GNUC_CONST;
PlankDockController* plank_dock_controller_new (const gchar* dock_name, GFile* config_folder);
PlankDockController* plank_dock_controller_construct (GType object_type, const gchar* dock_name, GFile* config_folder);
void plank_dock_controller_initialize (PlankDockController* self);
void plank_dock_controller_add_default_provider (PlankDockController* self);
const gchar* plank_dock_controller_get_name (PlankDockController* self);
GFile* plank_dock_controller_get_config_folder (PlankDockController* self);
GFile* plank_dock_controller_get_launchers_folder (PlankDockController* self);
GType plank_settings_get_type (void) G_GNUC_CONST;
GType plank_dock_preferences_get_type (void) G_GNUC_CONST;
PlankDockPreferences* plank_dock_controller_get_prefs (PlankDockController* self);
GType plank_drag_manager_get_type (void) G_GNUC_CONST;
PlankDragManager* plank_dock_controller_get_drag_manager (PlankDockController* self);
void plank_dock_controller_set_drag_manager (PlankDockController* self, PlankDragManager* value);
GType plank_hide_manager_get_type (void) G_GNUC_CONST;
PlankHideManager* plank_dock_controller_get_hide_manager (PlankDockController* self);
void plank_dock_controller_set_hide_manager (PlankDockController* self, PlankHideManager* value);
GType plank_position_manager_get_type (void) G_GNUC_CONST;
PlankPositionManager* plank_dock_controller_get_position_manager (PlankDockController* self);
void plank_dock_controller_set_position_manager (PlankDockController* self, PlankPositionManager* value);
GType plank_renderer_get_type (void) G_GNUC_CONST;
GType plank_dock_renderer_get_type (void) G_GNUC_CONST;
PlankDockRenderer* plank_dock_controller_get_renderer (PlankDockController* self);
void plank_dock_controller_set_renderer (PlankDockController* self, PlankDockRenderer* value);
GType plank_composited_window_get_type (void) G_GNUC_CONST;
GType plank_dock_window_get_type (void) G_GNUC_CONST;
PlankDockWindow* plank_dock_controller_get_window (PlankDockController* self);
void plank_dock_controller_set_window (PlankDockController* self, PlankDockWindow* value);
GType plank_hover_window_get_type (void) G_GNUC_CONST;
PlankHoverWindow* plank_dock_controller_get_hover (PlankDockController* self);
void plank_dock_controller_set_hover (PlankDockController* self, PlankHoverWindow* value);
GType plank_dock_item_provider_get_type (void) G_GNUC_CONST;
PlankDockItemProvider* plank_dock_controller_get_default_provider (PlankDockController* self);
GType plank_dock_item_get_type (void) G_GNUC_CONST;
GeeArrayList* plank_dock_controller_get_Items (PlankDockController* self);
GeeArrayList* plank_dock_controller_get_VisibleItems (PlankDockController* self);
#define PLANK_DOCK_PREFERENCES_MIN_ICON_SIZE 24
#define PLANK_DOCK_PREFERENCES_MAX_ICON_SIZE 128
#define PLANK_DOCK_PREFERENCES_MIN_ICON_ZOOM 100
#define PLANK_DOCK_PREFERENCES_MAX_ICON_ZOOM 200
PlankDockPreferences* plank_dock_preferences_new (const gchar* name);
PlankDockPreferences* plank_dock_preferences_construct (GType object_type, const gchar* name);
void plank_dock_preferences_increase_icon_size (PlankDockPreferences* self);
void plank_dock_preferences_decrease_icon_size (PlankDockPreferences* self);
gboolean plank_dock_preferences_is_horizontal_dock (PlankDockPreferences* self);
gboolean plank_dock_preferences_get_CurrentWorkspaceOnly (PlankDockPreferences* self);
void plank_dock_preferences_set_CurrentWorkspaceOnly (PlankDockPreferences* self, gboolean value);
gint plank_dock_preferences_get_IconSize (PlankDockPreferences* self);
void plank_dock_preferences_set_IconSize (PlankDockPreferences* self, gint value);
GType plank_hide_type_get_type (void) G_GNUC_CONST;
PlankHideType plank_dock_preferences_get_HideMode (PlankDockPreferences* self);
void plank_dock_preferences_set_HideMode (PlankDockPreferences* self, PlankHideType value);
guint plank_dock_preferences_get_UnhideDelay (PlankDockPreferences* self);
void plank_dock_preferences_set_UnhideDelay (PlankDockPreferences* self, guint value);
guint plank_dock_preferences_get_HideDelay (PlankDockPreferences* self);
void plank_dock_preferences_set_HideDelay (PlankDockPreferences* self, guint value);
const gchar* plank_dock_preferences_get_Monitor (PlankDockPreferences* self);
void plank_dock_preferences_set_Monitor (PlankDockPreferences* self, const gchar* value);
gchar** plank_dock_preferences_get_DockItems (PlankDockPreferences* self, int* result_length1);
void plank_dock_preferences_set_DockItems (PlankDockPreferences* self, gchar** value, int value_length1);
GtkPositionType plank_dock_preferences_get_Position (PlankDockPreferences* self);
void plank_dock_preferences_set_Position (PlankDockPreferences* self, GtkPositionType value);
gint plank_dock_preferences_get_Offset (PlankDockPreferences* self);
void plank_dock_preferences_set_Offset (PlankDockPreferences* self, gint value);
const gchar* plank_dock_preferences_get_Theme (PlankDockPreferences* self);
void plank_dock_preferences_set_Theme (PlankDockPreferences* self, const gchar* value);
GtkAlign plank_dock_preferences_get_Alignment (PlankDockPreferences* self);
void plank_dock_preferences_set_Alignment (PlankDockPreferences* self, GtkAlign value);
GtkAlign plank_dock_preferences_get_ItemsAlignment (PlankDockPreferences* self);
void plank_dock_preferences_set_ItemsAlignment (PlankDockPreferences* self, GtkAlign value);
gboolean plank_dock_preferences_get_LockItems (PlankDockPreferences* self);
void plank_dock_preferences_set_LockItems (PlankDockPreferences* self, gboolean value);
gboolean plank_dock_preferences_get_PressureReveal (PlankDockPreferences* self);
void plank_dock_preferences_set_PressureReveal (PlankDockPreferences* self, gboolean value);
gboolean plank_dock_preferences_get_PinnedOnly (PlankDockPreferences* self);
void plank_dock_preferences_set_PinnedOnly (PlankDockPreferences* self, gboolean value);
gboolean plank_dock_preferences_get_AutoPinning (PlankDockPreferences* self);
void plank_dock_preferences_set_AutoPinning (PlankDockPreferences* self, gboolean value);
gboolean plank_dock_preferences_get_ShowDockItem (PlankDockPreferences* self);
void plank_dock_preferences_set_ShowDockItem (PlankDockPreferences* self, gboolean value);
gboolean plank_dock_preferences_get_ZoomEnabled (PlankDockPreferences* self);
void plank_dock_preferences_set_ZoomEnabled (PlankDockPreferences* self, gboolean value);
guint plank_dock_preferences_get_ZoomPercent (PlankDockPreferences* self);
void plank_dock_preferences_set_ZoomPercent (PlankDockPreferences* self, guint value);
gboolean plank_dock_preferences_get_TooltipsEnabled (PlankDockPreferences* self);
void plank_dock_preferences_set_TooltipsEnabled (PlankDockPreferences* self, gboolean value);
PlankDockRenderer* plank_dock_renderer_new (PlankDockController* controller, GtkWindow* window);
PlankDockRenderer* plank_dock_renderer_construct (GType object_type, PlankDockController* controller, GtkWindow* window);
void plank_dock_renderer_initialize (PlankDockRenderer* self);
void plank_dock_renderer_reset_buffers (PlankDockRenderer* self);
void plank_dock_renderer_update_local_cursor (PlankDockRenderer* self, gint x, gint y);
void plank_dock_renderer_animate_items (PlankDockRenderer* self, GeeList* elements);
GType plank_preferences_get_type (void) G_GNUC_CONST;
GType plank_theme_get_type (void) G_GNUC_CONST;
GType plank_dock_theme_get_type (void) G_GNUC_CONST;
PlankDockTheme* plank_dock_renderer_get_theme (PlankDockRenderer* self);
gdouble plank_dock_renderer_get_hide_progress (PlankDockRenderer* self);
gdouble plank_dock_renderer_get_zoom_in_progress (PlankDockRenderer* self);
void plank_dock_renderer_get_local_cursor (PlankDockRenderer* self, GdkPoint* result);
PlankDragManager* plank_drag_manager_new (PlankDockController* controller);
PlankDragManager* plank_drag_manager_construct (GType object_type, PlankDockController* controller);
void plank_drag_manager_initialize (PlankDragManager* self);
gboolean plank_drag_manager_drop_is_accepted_by (PlankDragManager* self, PlankDockItem* item);
void plank_drag_manager_ensure_proxy (PlankDragManager* self);
gboolean plank_drag_manager_get_InternalDragActive (PlankDragManager* self);
PlankDockItem* plank_drag_manager_get_DragItem (PlankDragManager* self);
gboolean plank_drag_manager_get_DragNeedsCheck (PlankDragManager* self);
gboolean plank_drag_manager_get_ExternalDragActive (PlankDragManager* self);
gboolean plank_drag_manager_get_RepositionMode (PlankDragManager* self);
PlankHideManager* plank_hide_manager_new (PlankDockController* controller);
PlankHideManager* plank_hide_manager_construct (GType object_type, PlankDockController* controller);
void plank_hide_manager_initialize (PlankHideManager* self);
void plank_hide_manager_update_hovered (PlankHideManager* self);
void plank_hide_manager_update_hovered_with_coords (PlankHideManager* self, gint x, gint y);
void plank_hide_manager_update_barrier (PlankHideManager* self);
gboolean plank_hide_manager_get_Hidden (PlankHideManager* self);
gboolean plank_hide_manager_get_Disabled (PlankHideManager* self);
gboolean plank_hide_manager_get_Hovered (PlankHideManager* self);
PlankPositionManager* plank_position_manager_new (PlankDockController* controller);
PlankPositionManager* plank_position_manager_construct (GType object_type, PlankDockController* controller);
void plank_position_manager_initialize (PlankPositionManager* self);
gchar** plank_position_manager_get_monitor_plug_names (GdkScreen* screen, int* result_length1);
void plank_position_manager_update (PlankPositionManager* self, PlankDockTheme* theme);
gboolean plank_position_manager_is_horizontal_dock (PlankPositionManager* self);
void plank_position_manager_get_cursor_region (PlankPositionManager* self, GdkRectangle* result);
void plank_position_manager_get_static_dock_region (PlankPositionManager* self, GdkRectangle* result);
void plank_position_manager_update_regions (PlankPositionManager* self);
gpointer plank_dock_item_draw_value_ref (gpointer instance);
void plank_dock_item_draw_value_unref (gpointer instance);
GParamSpec* plank_param_spec_dock_item_draw_value (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void plank_value_set_dock_item_draw_value (GValue* value, gpointer v_object);
void plank_value_take_dock_item_draw_value (GValue* value, gpointer v_object);
gpointer plank_value_get_dock_item_draw_value (const GValue* value);
GType plank_dock_item_draw_value_get_type (void) G_GNUC_CONST;
PlankDockItemDrawValue* plank_position_manager_get_draw_value_for_item (PlankPositionManager* self, PlankDockItem* item);
void plank_position_manager_update_draw_values (PlankPositionManager* self, GeeArrayList* items, PlankDrawValueFunc func, void* func_target, PlankDrawValuesFunc post_func, void* post_func_target);
void plank_position_manager_get_hover_region_for_element (PlankPositionManager* self, PlankDockElement* element, GdkRectangle* result);
PlankDockItem* plank_position_manager_get_nearest_item_at (PlankPositionManager* self, gint x, gint y, PlankDockContainer* container);
PlankDockItem* plank_position_manager_get_current_target_item (PlankPositionManager* self, PlankDockContainer* container);
void plank_position_manager_get_menu_position (PlankPositionManager* self, PlankDockItem* hovered, GtkRequisition* requisition, gint* x, gint* y);
void plank_position_manager_get_hover_position (PlankPositionManager* self, PlankDockItem* hovered, gint* x, gint* y);
void plank_position_manager_get_hover_position_at (PlankPositionManager* self, gint* x, gint* y);
void plank_position_manager_get_urgent_glow_position (PlankPositionManager* self, PlankDockItem* item, gint* x, gint* y);
void plank_position_manager_update_dock_position (PlankPositionManager* self);
void plank_position_manager_get_dock_draw_position (PlankPositionManager* self, gint* x, gint* y);
void plank_position_manager_get_dock_window_region (PlankPositionManager* self, GdkRectangle* result);
void plank_position_manager_get_background_padding (PlankPositionManager* self, gint* x, gint* y);
void plank_position_manager_get_background_region (PlankPositionManager* self, GdkRectangle* result);
GType plank_application_dock_item_get_type (void) G_GNUC_CONST;
void plank_position_manager_get_icon_geometry (PlankPositionManager* self, PlankApplicationDockItem* item, gboolean for_hidden, GdkRectangle* result);
void plank_position_manager_get_struts (PlankPositionManager* self, gulong** struts, int* struts_length1);
void plank_position_manager_get_barrier (PlankPositionManager* self, GdkRectangle* result);
gboolean plank_position_manager_get_screen_is_composited (PlankPositionManager* self);
gint plank_position_manager_get_LineWidth (PlankPositionManager* self);
gint plank_position_manager_get_IconSize (PlankPositionManager* self);
gint plank_position_manager_get_ZoomIconSize (PlankPositionManager* self);
GtkPositionType plank_position_manager_get_Position (PlankPositionManager* self);
GtkAlign plank_position_manager_get_Alignment (PlankPositionManager* self);
GtkAlign plank_position_manager_get_ItemsAlignment (PlankPositionManager* self);
gint plank_position_manager_get_Offset (PlankPositionManager* self);
gint plank_position_manager_get_IndicatorSize (PlankPositionManager* self);
gint plank_position_manager_get_IconShadowSize (PlankPositionManager* self);
gint plank_position_manager_get_GlowSize (PlankPositionManager* self);
gint plank_position_manager_get_HorizPadding (PlankPositionManager* self);
gint plank_position_manager_get_TopPadding (PlankPositionManager* self);
gint plank_position_manager_get_BottomPadding (PlankPositionManager* self);
gint plank_position_manager_get_ItemPadding (PlankPositionManager* self);
gint plank_position_manager_get_UrgentBounceHeight (PlankPositionManager* self);
gint plank_position_manager_get_LaunchBounceHeight (PlankPositionManager* self);
gint plank_position_manager_get_MaxItemCount (PlankPositionManager* self);
GType plank_dbus_client_get_type (void) G_GNUC_CONST;
PlankDBusClient* plank_dbus_client_get_instance (void);
gboolean plank_dbus_client_add_item (PlankDBusClient* self, const gchar* uri);
gboolean plank_dbus_client_remove_item (PlankDBusClient* self, const gchar* uri);
gint plank_dbus_client_get_items_count (PlankDBusClient* self);
gchar** plank_dbus_client_get_persistent_applications (PlankDBusClient* self, int* result_length1);
gchar** plank_dbus_client_get_transient_applications (PlankDBusClient* self, int* result_length1);
gboolean plank_dbus_client_get_is_connected (PlankDBusClient* self);
GType plank_docklet_get_type (void) G_GNUC_CONST;
const gchar* plank_docklet_get_id (PlankDocklet* self);
const gchar* plank_docklet_get_name (PlankDocklet* self);
const gchar* plank_docklet_get_description (PlankDocklet* self);
const gchar* plank_docklet_get_icon (PlankDocklet* self);
gboolean plank_docklet_is_supported (PlankDocklet* self);
PlankDockElement* plank_docklet_make_element (PlankDocklet* self, const gchar* launcher, GFile* file);
GType plank_surface_get_type (void) G_GNUC_CONST;
GType plank_docklet_item_get_type (void) G_GNUC_CONST;
PlankDockletItem* plank_docklet_item_construct (GType object_type);
#define PLANK_DOCKLET_ENTRY_POINT "docklet_init"
GType plank_docklet_manager_get_type (void) G_GNUC_CONST;
PlankDockletManager* plank_docklet_manager_get_default (void);
void plank_docklet_manager_load_docklets (PlankDockletManager* self);
void plank_docklet_manager_register_docklet (PlankDockletManager* self, GType type);
PlankDocklet* plank_docklet_manager_get_docklet_by_id (PlankDockletManager* self, const gchar* id);
PlankDocklet* plank_docklet_manager_get_docklet_by_uri (PlankDockletManager* self, const gchar* uri);
GeeCollection* plank_docklet_manager_list_docklets (PlankDockletManager* self);
GType plank_color_get_type (void) G_GNUC_CONST;
PlankColor* plank_color_dup (const PlankColor* self);
void plank_color_free (PlankColor* self);
void plank_color_from_hsv (gdouble h, gdouble s, gdouble v, PlankColor* result);
void plank_color_from_hsl (gdouble h, gdouble s, gdouble l, PlankColor* result);
void plank_color_set_hsv (PlankColor *self, gdouble h, gdouble s, gdouble v);
void plank_color_set_hue (PlankColor *self, gdouble hue);
void plank_color_set_sat (PlankColor *self, gdouble sat);
void plank_color_set_val (PlankColor *self, gdouble val);
void plank_color_get_hsv (PlankColor *self, gdouble* h, gdouble* s, gdouble* v);
gdouble plank_color_get_hue (PlankColor *self);
gdouble plank_color_get_sat (PlankColor *self);
gdouble plank_color_get_val (PlankColor *self);
void plank_color_add_hue (PlankColor *self, gdouble val);
void plank_color_set_min_sat (PlankColor *self, gdouble sat);
void plank_color_set_min_val (PlankColor *self, gdouble val);
void plank_color_set_max_sat (PlankColor *self, gdouble sat);
void plank_color_set_max_val (PlankColor *self, gdouble val);
void plank_color_multiply_sat (PlankColor *self, gdouble amount);
void plank_color_brighten_val (PlankColor *self, gdouble amount);
void plank_color_darken_val (PlankColor *self, gdouble amount);
void plank_color_darken_by_sat (PlankColor *self, gdouble amount);
void plank_color_get_hsl (PlankColor *self, gdouble* h, gdouble* s, gdouble* l);
void plank_color_set_hsl (PlankColor *self, gdouble h, gdouble s, gdouble v);
gchar* plank_color_to_prefs_string (PlankColor *self);
void plank_color_from_prefs_string (const gchar* s, PlankColor* result);
GType plank_drawing_service_get_type (void) G_GNUC_CONST;
GtkIconTheme* plank_drawing_service_get_icon_theme (void);
gchar* plank_drawing_service_get_icon_from_file (GFile* file);
gchar* plank_drawing_service_get_icon_from_gicon (GIcon* icon);
GdkPixbuf* plank_drawing_service_load_icon (const gchar* names, gint width, gint height);
GFile* plank_drawing_service_try_get_icon_file (const gchar* name);
cairo_surface_t* plank_drawing_service_load_icon_for_scale (const gchar* names, gint width, gint height, gint scale);
GdkPixbuf* plank_drawing_service_ar_scale (GdkPixbuf* source, gint width, gint height);
void plank_drawing_service_average_color (GdkPixbuf* source, PlankColor* result);
PlankDockTheme* plank_dock_theme_new (const gchar* name);
PlankDockTheme* plank_dock_theme_construct (GType object_type, const gchar* name);
PlankSurface* plank_dock_theme_create_background (PlankDockTheme* self, gint width, gint height, GtkPositionType position, PlankSurface* model);
PlankSurface* plank_dock_theme_create_indicator (PlankDockTheme* self, gint size, PlankColor* color, PlankSurface* model);
PlankSurface* plank_dock_theme_create_urgent_glow (PlankDockTheme* self, gint size, PlankColor* color, PlankSurface* model);
void plank_dock_theme_draw_active_glow (PlankDockTheme* self, PlankSurface* surface, GdkRectangle* clip_rect, GdkRectangle* rect, PlankColor* color, gdouble opacity, GtkPositionType pos);
void plank_dock_theme_draw_item_count (PlankDockTheme* self, PlankSurface* surface, gint icon_size, PlankColor* color, gint64 count);
void plank_dock_theme_draw_item_progress (PlankDockTheme* self, PlankSurface* surface, gint icon_size, PlankColor* color, gdouble progress);
gdouble plank_dock_theme_get_HorizPadding (PlankDockTheme* self);
void plank_dock_theme_set_HorizPadding (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_TopPadding (PlankDockTheme* self);
void plank_dock_theme_set_TopPadding (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_BottomPadding (PlankDockTheme* self);
void plank_dock_theme_set_BottomPadding (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_ItemPadding (PlankDockTheme* self);
void plank_dock_theme_set_ItemPadding (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_IndicatorSize (PlankDockTheme* self);
void plank_dock_theme_set_IndicatorSize (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_IconShadowSize (PlankDockTheme* self);
void plank_dock_theme_set_IconShadowSize (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_UrgentBounceHeight (PlankDockTheme* self);
void plank_dock_theme_set_UrgentBounceHeight (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_LaunchBounceHeight (PlankDockTheme* self);
void plank_dock_theme_set_LaunchBounceHeight (PlankDockTheme* self, gdouble value);
gdouble plank_dock_theme_get_FadeOpacity (PlankDockTheme* self);
void plank_dock_theme_set_FadeOpacity (PlankDockTheme* self, gdouble value);
gint plank_dock_theme_get_ClickTime (PlankDockTheme* self);
void plank_dock_theme_set_ClickTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_UrgentBounceTime (PlankDockTheme* self);
void plank_dock_theme_set_UrgentBounceTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_LaunchBounceTime (PlankDockTheme* self);
void plank_dock_theme_set_LaunchBounceTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_ActiveTime (PlankDockTheme* self);
void plank_dock_theme_set_ActiveTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_SlideTime (PlankDockTheme* self);
void plank_dock_theme_set_SlideTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_FadeTime (PlankDockTheme* self);
void plank_dock_theme_set_FadeTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_HideTime (PlankDockTheme* self);
void plank_dock_theme_set_HideTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_GlowSize (PlankDockTheme* self);
void plank_dock_theme_set_GlowSize (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_GlowTime (PlankDockTheme* self);
void plank_dock_theme_set_GlowTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_GlowPulseTime (PlankDockTheme* self);
void plank_dock_theme_set_GlowPulseTime (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_UrgentHueShift (PlankDockTheme* self);
void plank_dock_theme_set_UrgentHueShift (PlankDockTheme* self, gint value);
gint plank_dock_theme_get_ItemMoveTime (PlankDockTheme* self);
void plank_dock_theme_set_ItemMoveTime (PlankDockTheme* self, gint value);
gboolean plank_dock_theme_get_CascadeHide (PlankDockTheme* self);
void plank_dock_theme_set_CascadeHide (PlankDockTheme* self, gboolean value);
GType plank_animation_mode_get_type (void) G_GNUC_CONST;
gdouble plank_easing_for_mode (PlankAnimationMode mode, gdouble t, gdouble d);
PlankRenderer* plank_renderer_construct (GType object_type, GtkWidget* widget);
gboolean plank_renderer_animation_needed (PlankRenderer* self, gint64 frame_time);
void plank_renderer_initialize_frame (PlankRenderer* self, gint64 frame_time);
void plank_renderer_draw (PlankRenderer* self, cairo_t* cr, gint64 frame_time);
void plank_renderer_force_frame_time_update (PlankRenderer* self);
void plank_renderer_animated_draw (PlankRenderer* self);
GtkWidget* plank_renderer_get_widget (PlankRenderer* self);
gint64 plank_renderer_get_frame_time (PlankRenderer* self);
PlankSurface* plank_surface_new (gint width, gint height);
PlankSurface* plank_surface_construct (GType object_type, gint width, gint height);
PlankSurface* plank_surface_new_with_cairo_surface (gint width, gint height, cairo_surface_t* model);
PlankSurface* plank_surface_construct_with_cairo_surface (GType object_type, gint width, gint height, cairo_surface_t* model);
PlankSurface* plank_surface_new_with_surface (gint width, gint height, PlankSurface* model);
PlankSurface* plank_surface_construct_with_surface (GType object_type, gint width, gint height, PlankSurface* model);
PlankSurface* plank_surface_new_with_internal (cairo_surface_t* image);
PlankSurface* plank_surface_construct_with_internal (GType object_type, cairo_surface_t* image);
void plank_surface_clear (PlankSurface* self);
PlankSurface* plank_surface_copy (PlankSurface* self);
PlankSurface* plank_surface_scaled_copy (PlankSurface* self, gint width, gint height);
GdkPixbuf* plank_surface_to_pixbuf (PlankSurface* self);
PlankSurface* plank_surface_create_mask (PlankSurface* self, gdouble threshold, GdkRectangle* extent);
void plank_surface_average_color (PlankSurface* self, PlankColor* result);
void plank_surface_fast_blur (PlankSurface* self, gint radius, gint process_count);
void plank_surface_exponential_blur (PlankSurface* self, gint radius);
void plank_surface_gaussian_blur (PlankSurface* self, gint radius);
cairo_surface_t* plank_surface_get_Internal (PlankSurface* self);
gint plank_surface_get_Width (PlankSurface* self);
gint plank_surface_get_Height (PlankSurface* self);
cairo_t* plank_surface_get_Context (PlankSurface* self);
GType plank_surface_cache_flags_get_type (void) G_GNUC_CONST;
GType plank_surface_cache_get_type (void) G_GNUC_CONST;
PlankSurfaceCache* plank_surface_cache_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, PlankSurfaceCacheFlags flags);
PlankSurfaceCache* plank_surface_cache_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, PlankSurfaceCacheFlags flags);
PlankSurface* plank_surface_cache_get_surface (PlankSurfaceCache* self, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gint width, gint height, PlankSurface* model, PlankDrawFunc draw_func, void* draw_func_target, PlankDrawDataFunc draw_data_func, void* draw_data_func_target);
void plank_surface_cache_clear (PlankSurfaceCache* self);
PlankSurfaceCacheFlags plank_surface_cache_get_flags (PlankSurfaceCache* self);
void plank_surface_cache_set_flags (PlankSurfaceCache* self, PlankSurfaceCacheFlags value);
#define PLANK_THEME_DEFAULT_NAME "Default"
#define PLANK_THEME_GTK_THEME_NAME "Gtk+"
GtkStyleContext* plank_theme_create_style_context (GType widget_type, GtkStyleContext* parent_style, GtkCssProvider* provider, const gchar* object_name, const gchar* first_class, ...);
PlankTheme* plank_theme_construct (GType object_type);
PlankTheme* plank_theme_construct_with_name (GType object_type, const gchar* name);
GtkStyleContext* plank_theme_get_style_context (PlankTheme* self);
void plank_theme_load (PlankTheme* self, const gchar* type);
gint plank_theme_get_top_offset (PlankTheme* self);
gint plank_theme_get_bottom_offset (PlankTheme* self);
void plank_theme_draw_background (PlankTheme* self, PlankSurface* surface);
void plank_theme_draw_inner_rect (PlankTheme* self, cairo_t* cr, gint width, gint height);
void plank_theme_draw_rounded_rect (cairo_t* cr, gdouble x, gdouble y, gdouble width, gdouble height, gdouble top_radius, gdouble bottom_radius, gdouble line_width);
void plank_theme_draw_rounded_line (cairo_t* cr, gdouble x, gdouble y, gdouble width, gdouble height, gboolean is_round_left, gboolean is_round_right, cairo_pattern_t* stroke, cairo_pattern_t* fill);
gchar** plank_theme_get_theme_list (int* result_length1);
GFile* plank_theme_get_theme_folder (const gchar* name);
gint plank_theme_get_TopRoundness (PlankTheme* self);
void plank_theme_set_TopRoundness (PlankTheme* self, gint value);
gint plank_theme_get_BottomRoundness (PlankTheme* self);
void plank_theme_set_BottomRoundness (PlankTheme* self, gint value);
gint plank_theme_get_LineWidth (PlankTheme* self);
void plank_theme_set_LineWidth (PlankTheme* self, gint value);
void plank_theme_get_OuterStrokeColor (PlankTheme* self, PlankColor* result);
void plank_theme_set_OuterStrokeColor (PlankTheme* self, PlankColor* value);
void plank_theme_get_FillStartColor (PlankTheme* self, PlankColor* result);
void plank_theme_set_FillStartColor (PlankTheme* self, PlankColor* value);
void plank_theme_get_FillEndColor (PlankTheme* self, PlankColor* result);
void plank_theme_set_FillEndColor (PlankTheme* self, PlankColor* value);
void plank_theme_get_InnerStrokeColor (PlankTheme* self, PlankColor* result);
void plank_theme_set_InnerStrokeColor (PlankTheme* self, PlankColor* value);
GType plank_abstract_main_get_type (void) G_GNUC_CONST;
void plank_abstract_main_initialize (PlankAbstractMain* self);
void plank_abstract_main_create_docks (PlankAbstractMain* self);
void plank_abstract_main_create_actions (PlankAbstractMain* self);
gboolean plank_abstract_main_is_launcher_for_dock (PlankAbstractMain* self, const gchar* launcher);
PlankAbstractMain* plank_abstract_main_construct (GType object_type);
const gchar* plank_abstract_main_get_build_data_dir (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_pkg_data_dir (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_release_name (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_version (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_version_info (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_program_name (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_exec_name (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_copyright (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_dbus (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_icon (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_launcher (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_main_url (PlankAbstractMain* self);
void plank_abstract_main_set_main_url (PlankAbstractMain* self, const gchar* value);
const gchar* plank_abstract_main_get_help_url (PlankAbstractMain* self);
void plank_abstract_main_set_help_url (PlankAbstractMain* self, const gchar* value);
const gchar* plank_abstract_main_get_translate_url (PlankAbstractMain* self);
void plank_abstract_main_set_translate_url (PlankAbstractMain* self, const gchar* value);
gchar** plank_abstract_main_get_about_authors (PlankAbstractMain* self, int* result_length1);
void plank_abstract_main_set_about_authors (PlankAbstractMain* self, gchar** value, int value_length1);
gchar** plank_abstract_main_get_about_documenters (PlankAbstractMain* self, int* result_length1);
void plank_abstract_main_set_about_documenters (PlankAbstractMain* self, gchar** value, int value_length1);
gchar** plank_abstract_main_get_about_artists (PlankAbstractMain* self, int* result_length1);
void plank_abstract_main_set_about_artists (PlankAbstractMain* self, gchar** value, int value_length1);
const gchar* plank_abstract_main_get_about_translators (PlankAbstractMain* self);
void plank_abstract_main_set_about_translators (PlankAbstractMain* self, const gchar* value);
GtkLicense plank_abstract_main_get_about_license_type (PlankAbstractMain* self);
void plank_abstract_main_set_about_license_type (PlankAbstractMain* self, GtkLicense value);
GType plank_factory_get_type (void) G_GNUC_CONST;
extern PlankAbstractMain* plank_factory_main;
GType plank_item_factory_get_type (void) G_GNUC_CONST;
extern PlankItemFactory* plank_factory_item_factory;
void plank_factory_init (PlankAbstractMain* main_class, PlankItemFactory* item);
PlankFactory* plank_factory_new (void);
PlankFactory* plank_factory_construct (GType object_type);
PlankDockElement* plank_item_factory_make_element (PlankItemFactory* self, GFile* file);
PlankDockItem* plank_item_factory_get_item_for_dock (PlankItemFactory* self);
PlankDockElement* plank_item_factory_default_make_element (PlankItemFactory* self, GFile* file, const gchar* launcher);
gchar* plank_item_factory_get_launcher_from_dockitem (PlankItemFactory* self, GFile* file);
GeeArrayList* plank_item_factory_load_elements (PlankItemFactory* self, GFile* source_dir, gchar** ordering, int ordering_length1);
void plank_item_factory_make_default_items (PlankItemFactory* self);
GFile* plank_item_factory_make_dock_item (PlankItemFactory* self, const gchar* uri, GFile* target_dir);
PlankItemFactory* plank_item_factory_new (void);
PlankItemFactory* plank_item_factory_construct (GType object_type);
PlankApplicationDockItem* plank_application_dock_item_new_with_dockitem_file (GFile* file);
PlankApplicationDockItem* plank_application_dock_item_construct_with_dockitem_file (GType object_type, GFile* file);
PlankApplicationDockItem* plank_application_dock_item_new_with_dockitem_filename (const gchar* filename);
PlankApplicationDockItem* plank_application_dock_item_construct_with_dockitem_filename (GType object_type, const gchar* filename);
gboolean plank_application_dock_item_is_running (PlankApplicationDockItem* self);
gboolean plank_application_dock_item_is_window (PlankApplicationDockItem* self);
void plank_application_dock_item_set_urgent (PlankApplicationDockItem* self, gboolean is_urgent);
void plank_application_dock_item_parse_launcher (const gchar* launcher, gchar** icon, gchar** text, GeeArrayList* actions, GeeMap* actions_map, GeeArrayList* mimes);
const gchar* plank_application_dock_item_get_unity_application_uri (PlankApplicationDockItem* self);
const gchar* plank_application_dock_item_get_unity_dbusname (PlankApplicationDockItem* self);
gboolean plank_application_dock_item_has_unity_info (PlankApplicationDockItem* self);
void plank_application_dock_item_unity_update (PlankApplicationDockItem* self, const gchar* sender_name, GVariantIter* prop_iter);
void plank_application_dock_item_unity_reset (PlankApplicationDockItem* self);
PlankApplicationDockItem* plank_application_dock_item_new (void);
PlankApplicationDockItem* plank_application_dock_item_construct (GType object_type);
GType plank_unity_client_get_type (void) G_GNUC_CONST;
GType plank_application_dock_item_provider_get_type (void) G_GNUC_CONST;
PlankApplicationDockItemProvider* plank_application_dock_item_provider_new (GFile* launchers_dir);
PlankApplicationDockItemProvider* plank_application_dock_item_provider_construct (GType object_type, GFile* launchers_dir);
PlankApplicationDockItem* plank_application_dock_item_provider_item_for_application (PlankApplicationDockItemProvider* self, BamfApplication* app);
void plank_application_dock_item_provider_app_opened (PlankApplicationDockItemProvider* self, BamfApplication* app);
void plank_application_dock_item_provider_delay_items_monitor (PlankApplicationDockItemProvider* self);
void plank_application_dock_item_provider_resume_items_monitor (PlankApplicationDockItemProvider* self);
GFile* plank_application_dock_item_provider_get_LaunchersDir (PlankApplicationDockItemProvider* self);
GType plank_default_application_dock_item_provider_get_type (void) G_GNUC_CONST;
PlankDefaultApplicationDockItemProvider* plank_default_application_dock_item_provider_new (PlankDockPreferences* prefs, GFile* launchers_dir);
PlankDefaultApplicationDockItemProvider* plank_default_application_dock_item_provider_construct (GType object_type, PlankDockPreferences* prefs, GFile* launchers_dir);
void plank_default_application_dock_item_provider_pin_item (PlankDefaultApplicationDockItemProvider* self, PlankDockItem* item);
PlankDockPreferences* plank_default_application_dock_item_provider_get_Prefs (PlankDefaultApplicationDockItemProvider* self);
GType plank_placeholder_dock_item_get_type (void) G_GNUC_CONST;
extern PlankPlaceholderDockItem* plank_dock_container_placeholder_item;
PlankDockContainer* plank_dock_container_construct (GType object_type);
void plank_dock_container_prepare (PlankDockContainer* self);
gboolean plank_dock_container_add (PlankDockContainer* self, PlankDockElement* element, PlankDockElement* target);
void plank_dock_container_prepend (PlankDockContainer* self, PlankDockElement* element);
gboolean plank_dock_container_add_all (PlankDockContainer* self, GeeArrayList* elements);
gboolean plank_dock_container_remove (PlankDockContainer* self, PlankDockElement* element);
gboolean plank_dock_container_remove_all (PlankDockContainer* self, GeeArrayList* elements);
gboolean plank_dock_container_clear (PlankDockContainer* self);
void plank_dock_container_update_visible_elements (PlankDockContainer* self);
gboolean plank_dock_container_move_to (PlankDockContainer* self, PlankDockElement* move, PlankDockElement* target);
gboolean plank_dock_container_replace (PlankDockContainer* self, PlankDockElement* new_element, PlankDockElement* old_element);
void plank_dock_container_connect_element (PlankDockContainer* self, PlankDockElement* element);
void plank_dock_container_disconnect_element (PlankDockContainer* self, PlankDockElement* element);
void plank_dock_container_move_element (GeeList* elements, gint from, gint to, GeeList* moved);
GeeArrayList* plank_dock_container_get_VisibleElements (PlankDockContainer* self);
GeeArrayList* plank_dock_container_get_Elements (PlankDockContainer* self);
PlankDockItem* plank_dock_item_construct (GType object_type);
void plank_dock_item_load_from_launcher (PlankDockItem* self);
void plank_dock_item_delete (PlankDockItem* self);
void plank_dock_item_reset_icon_buffer (PlankDockItem* self);
void plank_dock_item_unset_move_state (PlankDockItem* self);
PlankSurface* plank_dock_item_get_surface (PlankDockItem* self, gint width, gint height, PlankSurface* model);
PlankSurface* plank_dock_item_get_background_surface (PlankDockItem* self, gint width, gint height, PlankSurface* model, PlankDrawDataFunc draw_data_func, void* draw_data_func_target);
PlankSurface* plank_dock_item_get_foreground_surface (PlankDockItem* self, gint width, gint height, PlankSurface* model, PlankDrawDataFunc draw_data_func, void* draw_data_func_target);
PlankSurface* plank_dock_item_get_surface_copy (PlankDockItem* self, gint width, gint height, PlankSurface* model);
void plank_dock_item_draw_icon (PlankDockItem* self, PlankSurface* surface);
void plank_dock_item_draw_icon_fast (PlankDockItem* self, PlankSurface* surface);
gboolean plank_dock_item_is_valid (PlankDockItem* self);
void plank_dock_item_copy_values_to (PlankDockItem* self, PlankDockItem* target);
const gchar* plank_dock_item_get_Icon (PlankDockItem* self);
void plank_dock_item_set_Icon (PlankDockItem* self, const gchar* value);
GdkPixbuf* plank_dock_item_get_ForcePixbuf (PlankDockItem* self);
void plank_dock_item_set_ForcePixbuf (PlankDockItem* self, GdkPixbuf* value);
gint64 plank_dock_item_get_Count (PlankDockItem* self);
void plank_dock_item_set_Count (PlankDockItem* self, gint64 value);
gboolean plank_dock_item_get_CountVisible (PlankDockItem* self);
void plank_dock_item_set_CountVisible (PlankDockItem* self, gboolean value);
gdouble plank_dock_item_get_Progress (PlankDockItem* self);
void plank_dock_item_set_Progress (PlankDockItem* self, gdouble value);
gboolean plank_dock_item_get_ProgressVisible (PlankDockItem* self);
void plank_dock_item_set_ProgressVisible (PlankDockItem* self, gboolean value);
gint plank_dock_item_get_Position (PlankDockItem* self);
void plank_dock_item_set_Position (PlankDockItem* self, gint value);
gint plank_dock_item_get_LastPosition (PlankDockItem* self);
void plank_dock_item_set_LastPosition (PlankDockItem* self, gint value);
GType plank_item_state_get_type (void) G_GNUC_CONST;
PlankItemState plank_dock_item_get_State (PlankDockItem* self);
void plank_dock_item_set_State (PlankDockItem* self, PlankItemState value);
GType plank_indicator_state_get_type (void) G_GNUC_CONST;
PlankIndicatorState plank_dock_item_get_Indicator (PlankDockItem* self);
void plank_dock_item_set_Indicator (PlankDockItem* self, PlankIndicatorState value);
void plank_dock_item_get_AverageIconColor (PlankDockItem* self, PlankColor* result);
void plank_dock_item_set_AverageIconColor (PlankDockItem* self, PlankColor* value);
gchar* plank_dock_item_get_DockItemFilename (PlankDockItem* self);
const gchar* plank_dock_item_get_Launcher (PlankDockItem* self);
GType plank_dock_item_preferences_get_type (void) G_GNUC_CONST;
PlankDockItemPreferences* plank_dock_item_get_Prefs (PlankDockItem* self);
GType plank_point_d_get_type (void) G_GNUC_CONST;
PlankPointD* plank_point_d_dup (const PlankPointD* self);
void plank_point_d_free (PlankPointD* self);
void plank_dock_item_draw_value_move_in (PlankDockItemDrawValue* self, GtkPositionType position, gdouble damount);
void plank_dock_item_draw_value_move_right (PlankDockItemDrawValue* self, GtkPositionType position, gdouble damount);
PlankDockItemDrawValue* plank_dock_item_draw_value_new (void);
PlankDockItemDrawValue* plank_dock_item_draw_value_construct (GType object_type);
PlankDockItemProvider* plank_dock_item_provider_new (void);
PlankDockItemProvider* plank_dock_item_provider_construct (GType object_type);
gboolean plank_dock_item_provider_item_exists_for_uri (PlankDockItemProvider* self, const gchar* uri);
PlankDockItem* plank_dock_item_provider_item_for_uri (PlankDockItemProvider* self, const gchar* uri);
gboolean plank_dock_item_provider_add_item_with_uri (PlankDockItemProvider* self, const gchar* uri, PlankDockItem* target);
void plank_dock_item_provider_handle_item_deleted (PlankDockItemProvider* self, PlankDockItem* item);
gchar** plank_dock_item_provider_get_dockitem_filenames (PlankDockItemProvider* self, int* result_length1);
PlankDockItemPreferences* plank_dock_item_preferences_new_with_launcher (const gchar* launcher);
PlankDockItemPreferences* plank_dock_item_preferences_construct_with_launcher (GType object_type, const gchar* launcher);
PlankDockItemPreferences* plank_dock_item_preferences_new_with_file (GFile* file);
PlankDockItemPreferences* plank_dock_item_preferences_construct_with_file (GType object_type, GFile* file);
PlankDockItemPreferences* plank_dock_item_preferences_new_with_filename (const gchar* filename);
PlankDockItemPreferences* plank_dock_item_preferences_construct_with_filename (GType object_type, const gchar* filename);
PlankDockItemPreferences* plank_dock_item_preferences_new (void);
PlankDockItemPreferences* plank_dock_item_preferences_construct (GType object_type);
const gchar* plank_dock_item_preferences_get_Launcher (PlankDockItemPreferences* self);
void plank_dock_item_preferences_set_Launcher (PlankDockItemPreferences* self, const gchar* value);
void plank_dock_element_clicked (PlankDockElement* self, PlankPopupButton button, GdkModifierType mod, guint32 event_time);
PlankAnimationType plank_dock_element_on_clicked (PlankDockElement* self, PlankPopupButton button, GdkModifierType mod, guint32 event_time);
void plank_dock_element_hovered (PlankDockElement* self);
PlankAnimationType plank_dock_element_on_hovered (PlankDockElement* self);
void plank_dock_element_scrolled (PlankDockElement* self, GdkScrollDirection direction, GdkModifierType mod, guint32 event_time);
PlankAnimationType plank_dock_element_on_scrolled (PlankDockElement* self, GdkScrollDirection direction, GdkModifierType mod, guint32 event_time);
PlankDockController* plank_dock_element_get_dock (PlankDockElement* self);
GeeArrayList* plank_dock_element_get_menu_items (PlankDockElement* self);
gchar* plank_dock_element_get_drop_text (PlankDockElement* self);
gboolean plank_dock_element_can_be_removed (PlankDockElement* self);
gboolean plank_dock_element_can_accept_drop (PlankDockElement* self, GeeArrayList* uris);
gboolean plank_dock_element_accept_drop (PlankDockElement* self, GeeArrayList* uris);
gchar* plank_dock_element_unique_id (PlankDockElement* self);
gchar* plank_dock_element_as_uri (PlankDockElement* self);
void plank_dock_element_reset_buffers (PlankDockElement* self);
GtkMenuItem* plank_dock_element_create_menu_item (const gchar* title, const gchar* icon, gboolean force_show_icon);
GtkMenuItem* plank_dock_element_create_menu_item_with_pixbuf (const gchar* title, GdkPixbuf* pixbuf, gboolean force_show_icon);
PlankDockElement* plank_dock_element_construct (GType object_type);
PlankDockContainer* plank_dock_element_get_Container (PlankDockElement* self);
void plank_dock_element_set_Container (PlankDockElement* self, PlankDockContainer* value);
const gchar* plank_dock_element_get_Text (PlankDockElement* self);
void plank_dock_element_set_Text (PlankDockElement* self, const gchar* value);
gboolean plank_dock_element_get_IsAttached (PlankDockElement* self);
void plank_dock_element_set_IsAttached (PlankDockElement* self, gboolean value);
gboolean plank_dock_element_get_IsVisible (PlankDockElement* self);
void plank_dock_element_set_IsVisible (PlankDockElement* self, gboolean value);
PlankPopupButton plank_dock_element_get_Button (PlankDockElement* self);
void plank_dock_element_set_Button (PlankDockElement* self, PlankPopupButton value);
PlankAnimationType plank_dock_element_get_ClickedAnimation (PlankDockElement* self);
void plank_dock_element_set_ClickedAnimation (PlankDockElement* self, PlankAnimationType value);
PlankAnimationType plank_dock_element_get_HoveredAnimation (PlankDockElement* self);
void plank_dock_element_set_HoveredAnimation (PlankDockElement* self, PlankAnimationType value);
PlankAnimationType plank_dock_element_get_ScrolledAnimation (PlankDockElement* self);
void plank_dock_element_set_ScrolledAnimation (PlankDockElement* self, PlankAnimationType value);
gint64 plank_dock_element_get_AddTime (PlankDockElement* self);
void plank_dock_element_set_AddTime (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_RemoveTime (PlankDockElement* self);
void plank_dock_element_set_RemoveTime (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_LastClicked (PlankDockElement* self);
void plank_dock_element_set_LastClicked (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_LastHovered (PlankDockElement* self);
void plank_dock_element_set_LastHovered (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_LastScrolled (PlankDockElement* self);
void plank_dock_element_set_LastScrolled (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_LastUrgent (PlankDockElement* self);
void plank_dock_element_set_LastUrgent (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_LastActive (PlankDockElement* self);
void plank_dock_element_set_LastActive (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_LastMove (PlankDockElement* self);
void plank_dock_element_set_LastMove (PlankDockElement* self, gint64 value);
gint64 plank_dock_element_get_LastValid (PlankDockElement* self);
void plank_dock_element_set_LastValid (PlankDockElement* self, gint64 value);
PlankPopupButton plank_popup_button_from_event_button (GdkEventButton* event);
GType plank_file_dock_item_get_type (void) G_GNUC_CONST;
PlankFileDockItem* plank_file_dock_item_new_with_file (GFile* file);
PlankFileDockItem* plank_file_dock_item_construct_with_file (GType object_type, GFile* file);
PlankFileDockItem* plank_file_dock_item_new_with_dockitem_file (GFile* file);
PlankFileDockItem* plank_file_dock_item_construct_with_dockitem_file (GType object_type, GFile* file);
PlankFileDockItem* plank_file_dock_item_new_with_dockitem_filename (const gchar* filename);
PlankFileDockItem* plank_file_dock_item_construct_with_dockitem_filename (GType object_type, const gchar* filename);
void plank_file_dock_item_launch (PlankFileDockItem* self);
PlankFileDockItem* plank_file_dock_item_new (void);
PlankFileDockItem* plank_file_dock_item_construct (GType object_type);
GFile* plank_file_dock_item_get_OwnedFile (PlankFileDockItem* self);
void plank_file_dock_item_set_OwnedFile (PlankFileDockItem* self, GFile* value);
PlankPlaceholderDockItem* plank_placeholder_dock_item_new (void);
PlankPlaceholderDockItem* plank_placeholder_dock_item_construct (GType object_type);
GType plank_plank_dock_item_get_type (void) G_GNUC_CONST;
PlankPlankDockItem* plank_plank_dock_item_get_instance (void);
GType plank_transient_dock_item_get_type (void) G_GNUC_CONST;
PlankTransientDockItem* plank_transient_dock_item_new_with_launcher (const gchar* launcher_uri);
PlankTransientDockItem* plank_transient_dock_item_construct_with_launcher (GType object_type, const gchar* launcher_uri);
PlankTransientDockItem* plank_transient_dock_item_new (void);
PlankTransientDockItem* plank_transient_dock_item_construct (GType object_type);
GType plank_xdg_session_class_get_type (void) G_GNUC_CONST;
PlankXdgSessionClass plank_xdg_session_class_from_string (const gchar* s);
GType plank_xdg_session_desktop_get_type (void) G_GNUC_CONST;
PlankXdgSessionDesktop plank_xdg_session_desktop_from_string (const gchar* s);
GType plank_xdg_session_type_get_type (void) G_GNUC_CONST;
PlankXdgSessionType plank_xdg_session_type_from_string (const gchar* s);
void plank_environment_initialize (void);
gboolean plank_environment_is_session_class (PlankXdgSessionClass type);
gboolean plank_environment_is_session_desktop (PlankXdgSessionDesktop type);
gboolean plank_environment_is_session_type (PlankXdgSessionType type);
GType plank_log_level_get_type (void) G_GNUC_CONST;
GType plank_logger_get_type (void) G_GNUC_CONST;
void plank_logger_initialize (const gchar* app_name);
void plank_logger_notification (const gchar* msg, const gchar* icon);
void plank_logger_verbose (const gchar* msg, ...);
PlankLogLevel plank_logger_get_DisplayLevel (void);
void plank_logger_set_DisplayLevel (PlankLogLevel value);
GType plank_paths_get_type (void) G_GNUC_CONST;
void plank_paths_initialize (const gchar* app_name, const gchar* data_folder);
gboolean plank_paths_ensure_directory_exists (GFile* dir);
GFile* plank_paths_get_HomeFolder (void);
void plank_paths_set_HomeFolder (GFile* value);
GFile* plank_paths_get_DataFolder (void);
void plank_paths_set_DataFolder (GFile* value);
GFile* plank_paths_get_ThemeFolder (void);
void plank_paths_set_ThemeFolder (GFile* value);
GFile* plank_paths_get_ConfigHomeFolder (void);
void plank_paths_set_ConfigHomeFolder (GFile* value);
GFile* plank_paths_get_DataHomeFolder (void);
void plank_paths_set_DataHomeFolder (GFile* value);
GFile* plank_paths_get_CacheHomeFolder (void);
void plank_paths_set_CacheHomeFolder (GFile* value);
GeeArrayList* plank_paths_get_DataDirFolders (void);
void plank_paths_set_DataDirFolders (GeeArrayList* value);
GFile* plank_paths_get_AppConfigFolder (void);
void plank_paths_set_AppConfigFolder (GFile* value);
GFile* plank_paths_get_AppDataFolder (void);
void plank_paths_set_AppDataFolder (GFile* value);
GFile* plank_paths_get_AppThemeFolder (void);
void plank_paths_set_AppThemeFolder (GFile* value);
GFile* plank_paths_get_AppCacheFolder (void);
void plank_paths_set_AppCacheFolder (GFile* value);
const gchar* plank_paths_get_AppName (void);
void plank_paths_set_AppName (const gchar* value);
GType plank_serializable_get_type (void) G_GNUC_CONST;
gchar* plank_serializable_serialize (PlankSerializable* self);
void plank_serializable_deserialize (PlankSerializable* self, const gchar* s);
PlankPreferences* plank_preferences_construct (GType object_type);
void plank_preferences_verify (PlankPreferences* self, const gchar* prop);
void plank_preferences_reset_properties (PlankPreferences* self);
PlankPreferences* plank_preferences_construct_with_file (GType object_type, GFile* file);
PlankPreferences* plank_preferences_construct_with_filename (GType object_type, const gchar* filename);
void plank_preferences_init_from_file (PlankPreferences* self, GFile* file);
void plank_preferences_init_from_filename (PlankPreferences* self, const gchar* filename);
void plank_preferences_delay (PlankPreferences* self);
void plank_preferences_apply (PlankPreferences* self);
gchar* plank_preferences_get_filename (PlankPreferences* self);
GFile* plank_preferences_get_backing_file (PlankPreferences* self);
void plank_preferences_delete (PlankPreferences* self);
PlankSettings* plank_settings_construct (GType object_type, const gchar* schema);
PlankSettings* plank_settings_construct_with_path (GType object_type, const gchar* schema, const gchar* path);
void plank_settings_verify (PlankSettings* self, const gchar* name);
void plank_settings_reset_all (PlankSettings* self);
void plank_settings_delay (PlankSettings* self);
void plank_settings_apply (PlankSettings* self);
GSettings* plank_settings_get_settings (PlankSettings* self);
GSettingsBindFlags plank_settings_get_bind_flags (PlankSettings* self);
GType plank_system_get_type (void) G_GNUC_CONST;
PlankSystem* plank_system_get_default (void);
PlankSystem* plank_system_new (GAppLaunchContext* context);
PlankSystem* plank_system_construct (GType object_type, GAppLaunchContext* context);
void plank_system_open_uri (PlankSystem* self, const gchar* uri);
void plank_system_open (PlankSystem* self, GFile* file);
void plank_system_open_files (PlankSystem* self, GFile** files, int files_length1);
void plank_system_launch (PlankSystem* self, GFile* app);
void plank_system_launch_with_files (PlankSystem* self, GFile* app, GFile** files, int files_length1);
GAppLaunchContext* plank_system_get_context (PlankSystem* self);
void plank_unity_client_update_launcher_entry (PlankUnityClient* self, const gchar* sender_name, GVariant* parameters, gboolean is_retry);
void plank_unity_client_remove_launcher_entry (PlankUnityClient* self, const gchar* sender_name);
GType plank_unity_get_type (void) G_GNUC_CONST;
PlankUnity* plank_unity_get_default (void);
void plank_unity_add_client (PlankUnity* self, PlankUnityClient* client);
void plank_unity_remove_client (PlankUnity* self, PlankUnityClient* client);
GType plank_task_priority_get_type (void) G_GNUC_CONST;
GType plank_worker_get_type (void) G_GNUC_CONST;
PlankWorker* plank_worker_get_default (void);
void plank_worker_add_task (PlankWorker* self, GThreadFunc func, void* func_target, PlankTaskPriority priority);
void plank_worker_add_task_with_result (PlankWorker* self, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, PlankTaskFunc func, void* func_target, GDestroyNotify func_target_destroy_notify, PlankTaskPriority priority, GAsyncReadyCallback _callback_, gpointer _user_data_);
gpointer plank_worker_add_task_with_result_finish (PlankWorker* self, GAsyncResult* _res_, GError** error);
PlankCompositedWindow* plank_composited_window_new (void);
PlankCompositedWindow* plank_composited_window_construct (GType object_type);
PlankCompositedWindow* plank_composited_window_new_with_type (GtkWindowType window_type);
PlankCompositedWindow* plank_composited_window_construct_with_type (GType object_type, GtkWindowType window_type);
PlankDockWindow* plank_dock_window_new (PlankDockController* controller);
PlankDockWindow* plank_dock_window_construct (GType object_type, PlankDockController* controller);
gboolean plank_dock_window_update_hovered (PlankDockWindow* self, gint x, gint y);
void plank_dock_window_update_size_and_position (PlankDockWindow* self);
void plank_dock_window_update_icon_regions (PlankDockWindow* self);
void plank_dock_window_update_icon_region (PlankDockWindow* self, PlankApplicationDockItem* appitem);
gboolean plank_dock_window_menu_is_visible (PlankDockWindow* self);
PlankDockItem* plank_dock_window_get_HoveredItem (PlankDockWindow* self);
PlankDockItemProvider* plank_dock_window_get_HoveredItemProvider (PlankDockWindow* self);
PlankHoverWindow* plank_hover_window_new (void);
PlankHoverWindow* plank_hover_window_construct (GType object_type);
void plank_hover_window_show_at (PlankHoverWindow* self, gint x, gint y, GtkPositionType position);
void plank_hover_window_set_text (PlankHoverWindow* self, const gchar* text);
GType plank_poof_window_get_type (void) G_GNUC_CONST;
PlankPoofWindow* plank_poof_window_get_default (void);
PlankPoofWindow* plank_poof_window_new (void);
PlankPoofWindow* plank_poof_window_construct (GType object_type);
void plank_poof_window_show_at (PlankPoofWindow* self, gint x, gint y);
GType plank_preferences_window_get_type (void) G_GNUC_CONST;
PlankPreferencesWindow* plank_preferences_window_new (PlankDockController* controller);
PlankPreferencesWindow* plank_preferences_window_construct (GType object_type, PlankDockController* controller);
PlankDockController* plank_preferences_window_get_controller (PlankPreferencesWindow* self);
void plank_preferences_window_set_controller (PlankPreferencesWindow* self, PlankDockController* value);
GType plank_titled_separator_menu_item_get_type (void) G_GNUC_CONST;
PlankTitledSeparatorMenuItem* plank_titled_separator_menu_item_new (const gchar* text);
PlankTitledSeparatorMenuItem* plank_titled_separator_menu_item_construct (GType object_type, const gchar* text);
PlankTitledSeparatorMenuItem* plank_titled_separator_menu_item_new_no_line (const gchar* text);
PlankTitledSeparatorMenuItem* plank_titled_separator_menu_item_construct_no_line (GType object_type, const gchar* text);
#define PLANK_MAJOR_VERSION 0
#define PLANK_MINOR_VERSION 11
#define PLANK_MICRO_VERSION 3
#define PLANK_NANO_VERSION 0
guint plank_get_major_version (void);
guint plank_get_minor_version (void);
guint plank_get_micro_version (void);
guint plank_get_nano_version (void);
const gchar* plank_check_version (guint required_major, guint required_minor, guint required_micro);


G_END_DECLS

#endif