File: presenter.h

package info (click to toggle)
pdf-presenter-console 3.1-1
  • links: PTS, VCS
  • area: main
  • in suites: wheezy
  • size: 1,660 kB
  • sloc: ansic: 18,202; makefile: 6
file content (1211 lines) | stat: -rw-r--r-- 73,581 bytes parent folder | download
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
/* presenter.h generated by valac 0.16.0, the Vala compiler, do not modify */


#ifndef __C_SRC_PRESENTER_H__
#define __C_SRC_PRESENTER_H__

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include <gdk/gdk.h>
#include <gtk/gtk.h>
#include <poppler.h>
#include <gee.h>
#include <time.h>

G_BEGIN_DECLS


#define PDFPC_VIEW_BEHAVIOUR_TYPE_DECORATABLE (pdfpc_view_behaviour_decoratable_get_type ())
#define PDFPC_VIEW_BEHAVIOUR_DECORATABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_BEHAVIOUR_TYPE_DECORATABLE, pdfpcViewBehaviourDecoratable))
#define PDFPC_VIEW_BEHAVIOUR_IS_DECORATABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_BEHAVIOUR_TYPE_DECORATABLE))
#define PDFPC_VIEW_BEHAVIOUR_DECORATABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PDFPC_VIEW_BEHAVIOUR_TYPE_DECORATABLE, pdfpcViewBehaviourDecoratableIface))

typedef struct _pdfpcViewBehaviourDecoratable pdfpcViewBehaviourDecoratable;
typedef struct _pdfpcViewBehaviourDecoratableIface pdfpcViewBehaviourDecoratableIface;

#define PDFPC_VIEW_BEHAVIOUR_TYPE_BASE (pdfpc_view_behaviour_base_get_type ())
#define PDFPC_VIEW_BEHAVIOUR_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_BEHAVIOUR_TYPE_BASE, pdfpcViewBehaviourBase))
#define PDFPC_VIEW_BEHAVIOUR_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_VIEW_BEHAVIOUR_TYPE_BASE, pdfpcViewBehaviourBaseClass))
#define PDFPC_VIEW_BEHAVIOUR_IS_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_BEHAVIOUR_TYPE_BASE))
#define PDFPC_VIEW_BEHAVIOUR_IS_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_VIEW_BEHAVIOUR_TYPE_BASE))
#define PDFPC_VIEW_BEHAVIOUR_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_VIEW_BEHAVIOUR_TYPE_BASE, pdfpcViewBehaviourBaseClass))

typedef struct _pdfpcViewBehaviourBase pdfpcViewBehaviourBase;
typedef struct _pdfpcViewBehaviourBaseClass pdfpcViewBehaviourBaseClass;

#define PDFPC_VIEW_TYPE_PRERENDERING (pdfpc_view_prerendering_get_type ())
#define PDFPC_VIEW_PRERENDERING(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_TYPE_PRERENDERING, pdfpcViewPrerendering))
#define PDFPC_VIEW_IS_PRERENDERING(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_TYPE_PRERENDERING))
#define PDFPC_VIEW_PRERENDERING_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PDFPC_VIEW_TYPE_PRERENDERING, pdfpcViewPrerenderingIface))

typedef struct _pdfpcViewPrerendering pdfpcViewPrerendering;
typedef struct _pdfpcViewPrerenderingIface pdfpcViewPrerenderingIface;

#define PDFPC_TYPE_CONTROLLABLE (pdfpc_controllable_get_type ())
#define PDFPC_CONTROLLABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_CONTROLLABLE, pdfpcControllable))
#define PDFPC_IS_CONTROLLABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_CONTROLLABLE))
#define PDFPC_CONTROLLABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PDFPC_TYPE_CONTROLLABLE, pdfpcControllableIface))

typedef struct _pdfpcControllable pdfpcControllable;
typedef struct _pdfpcControllableIface pdfpcControllableIface;

#define PDFPC_TYPE_PRESENTATION_CONTROLLER (pdfpc_presentation_controller_get_type ())
#define PDFPC_PRESENTATION_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_PRESENTATION_CONTROLLER, pdfpcPresentationController))
#define PDFPC_PRESENTATION_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_PRESENTATION_CONTROLLER, pdfpcPresentationControllerClass))
#define PDFPC_IS_PRESENTATION_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_PRESENTATION_CONTROLLER))
#define PDFPC_IS_PRESENTATION_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_PRESENTATION_CONTROLLER))
#define PDFPC_PRESENTATION_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_PRESENTATION_CONTROLLER, pdfpcPresentationControllerClass))

typedef struct _pdfpcPresentationController pdfpcPresentationController;
typedef struct _pdfpcPresentationControllerClass pdfpcPresentationControllerClass;

#define PDFPC_RENDERER_TYPE_CACHING (pdfpc_renderer_caching_get_type ())
#define PDFPC_RENDERER_CACHING(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_TYPE_CACHING, pdfpcRendererCaching))
#define PDFPC_RENDERER_IS_CACHING(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_TYPE_CACHING))
#define PDFPC_RENDERER_CACHING_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PDFPC_RENDERER_TYPE_CACHING, pdfpcRendererCachingIface))

typedef struct _pdfpcRendererCaching pdfpcRendererCaching;
typedef struct _pdfpcRendererCachingIface pdfpcRendererCachingIface;

#define PDFPC_RENDERER_CACHE_TYPE_BASE (pdfpc_renderer_cache_base_get_type ())
#define PDFPC_RENDERER_CACHE_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_CACHE_TYPE_BASE, pdfpcRendererCacheBase))
#define PDFPC_RENDERER_CACHE_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_RENDERER_CACHE_TYPE_BASE, pdfpcRendererCacheBaseClass))
#define PDFPC_RENDERER_CACHE_IS_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_CACHE_TYPE_BASE))
#define PDFPC_RENDERER_CACHE_IS_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_RENDERER_CACHE_TYPE_BASE))
#define PDFPC_RENDERER_CACHE_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_RENDERER_CACHE_TYPE_BASE, pdfpcRendererCacheBaseClass))

typedef struct _pdfpcRendererCacheBase pdfpcRendererCacheBase;
typedef struct _pdfpcRendererCacheBaseClass pdfpcRendererCacheBaseClass;

#define PDFPC_TYPE_APPLICATION (pdfpc_application_get_type ())
#define PDFPC_APPLICATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_APPLICATION, pdfpcApplication))
#define PDFPC_APPLICATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_APPLICATION, pdfpcApplicationClass))
#define PDFPC_IS_APPLICATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_APPLICATION))
#define PDFPC_IS_APPLICATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_APPLICATION))
#define PDFPC_APPLICATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_APPLICATION, pdfpcApplicationClass))

typedef struct _pdfpcApplication pdfpcApplication;
typedef struct _pdfpcApplicationClass pdfpcApplicationClass;
typedef struct _pdfpcApplicationPrivate pdfpcApplicationPrivate;

#define PDFPC_TYPE_SCALER (pdfpc_scaler_get_type ())
#define PDFPC_SCALER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_SCALER, pdfpcScaler))
#define PDFPC_SCALER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_SCALER, pdfpcScalerClass))
#define PDFPC_IS_SCALER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_SCALER))
#define PDFPC_IS_SCALER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_SCALER))
#define PDFPC_SCALER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_SCALER, pdfpcScalerClass))

typedef struct _pdfpcScaler pdfpcScaler;
typedef struct _pdfpcScalerClass pdfpcScalerClass;
typedef struct _pdfpcScalerPrivate pdfpcScalerPrivate;

#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_SIGNAL_PROVIDER (pdfpc_view_behaviour_pdf_link_signal_provider_get_type ())
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_SIGNAL_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_SIGNAL_PROVIDER, pdfpcViewBehaviourPdfLinkSignalProvider))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_SIGNAL_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_SIGNAL_PROVIDER, pdfpcViewBehaviourPdfLinkSignalProviderClass))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_IS_SIGNAL_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_SIGNAL_PROVIDER))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_IS_SIGNAL_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_SIGNAL_PROVIDER))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_SIGNAL_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_SIGNAL_PROVIDER, pdfpcViewBehaviourPdfLinkSignalProviderClass))

typedef struct _pdfpcViewBehaviourPdfLinkSignalProvider pdfpcViewBehaviourPdfLinkSignalProvider;
typedef struct _pdfpcViewBehaviourPdfLinkSignalProviderClass pdfpcViewBehaviourPdfLinkSignalProviderClass;
typedef struct _pdfpcViewBehaviourPdfLinkSignalProviderPrivate pdfpcViewBehaviourPdfLinkSignalProviderPrivate;

#define PDFPC_VIEW_TYPE_BASE (pdfpc_view_base_get_type ())
#define PDFPC_VIEW_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_TYPE_BASE, pdfpcViewBase))
#define PDFPC_VIEW_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_VIEW_TYPE_BASE, pdfpcViewBaseClass))
#define PDFPC_VIEW_IS_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_TYPE_BASE))
#define PDFPC_VIEW_IS_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_VIEW_TYPE_BASE))
#define PDFPC_VIEW_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_VIEW_TYPE_BASE, pdfpcViewBaseClass))

typedef struct _pdfpcViewBase pdfpcViewBase;
typedef struct _pdfpcViewBaseClass pdfpcViewBaseClass;

#define PDFPC_VIEW_TYPE_DEFAULT (pdfpc_view_default_get_type ())
#define PDFPC_VIEW_DEFAULT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_TYPE_DEFAULT, pdfpcViewDefault))
#define PDFPC_VIEW_DEFAULT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_VIEW_TYPE_DEFAULT, pdfpcViewDefaultClass))
#define PDFPC_VIEW_IS_DEFAULT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_TYPE_DEFAULT))
#define PDFPC_VIEW_IS_DEFAULT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_VIEW_TYPE_DEFAULT))
#define PDFPC_VIEW_DEFAULT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_VIEW_TYPE_DEFAULT, pdfpcViewDefaultClass))

typedef struct _pdfpcViewDefault pdfpcViewDefault;
typedef struct _pdfpcViewDefaultClass pdfpcViewDefaultClass;

#define PDFPC_VIEW_TYPE_PDF (pdfpc_view_pdf_get_type ())
#define PDFPC_VIEW_PDF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_TYPE_PDF, pdfpcViewPdf))
#define PDFPC_VIEW_PDF_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_VIEW_TYPE_PDF, pdfpcViewPdfClass))
#define PDFPC_VIEW_IS_PDF(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_TYPE_PDF))
#define PDFPC_VIEW_IS_PDF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_VIEW_TYPE_PDF))
#define PDFPC_VIEW_PDF_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_VIEW_TYPE_PDF, pdfpcViewPdfClass))

typedef struct _pdfpcViewPdf pdfpcViewPdf;
typedef struct _pdfpcViewPdfClass pdfpcViewPdfClass;
typedef struct _pdfpcViewBehaviourBasePrivate pdfpcViewBehaviourBasePrivate;

#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_IMPLEMENTATION (pdfpc_view_behaviour_pdf_link_implementation_get_type ())
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_IMPLEMENTATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_IMPLEMENTATION, pdfpcViewBehaviourPdfLinkImplementation))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_IMPLEMENTATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_IMPLEMENTATION, pdfpcViewBehaviourPdfLinkImplementationClass))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_IS_IMPLEMENTATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_IMPLEMENTATION))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_IS_IMPLEMENTATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_IMPLEMENTATION))
#define PDFPC_VIEW_BEHAVIOUR_PDF_LINK_IMPLEMENTATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_VIEW_BEHAVIOUR_PDF_LINK_TYPE_IMPLEMENTATION, pdfpcViewBehaviourPdfLinkImplementationClass))

typedef struct _pdfpcViewBehaviourPdfLinkImplementation pdfpcViewBehaviourPdfLinkImplementation;
typedef struct _pdfpcViewBehaviourPdfLinkImplementationClass pdfpcViewBehaviourPdfLinkImplementationClass;
typedef struct _pdfpcViewBehaviourPdfLinkImplementationPrivate pdfpcViewBehaviourPdfLinkImplementationPrivate;
typedef struct _pdfpcViewBasePrivate pdfpcViewBasePrivate;

#define PDFPC_RENDERER_TYPE_BASE (pdfpc_renderer_base_get_type ())
#define PDFPC_RENDERER_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_TYPE_BASE, pdfpcRendererBase))
#define PDFPC_RENDERER_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_RENDERER_TYPE_BASE, pdfpcRendererBaseClass))
#define PDFPC_RENDERER_IS_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_TYPE_BASE))
#define PDFPC_RENDERER_IS_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_RENDERER_TYPE_BASE))
#define PDFPC_RENDERER_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_RENDERER_TYPE_BASE, pdfpcRendererBaseClass))

typedef struct _pdfpcRendererBase pdfpcRendererBase;
typedef struct _pdfpcRendererBaseClass pdfpcRendererBaseClass;
typedef struct _pdfpcViewDefaultPrivate pdfpcViewDefaultPrivate;
typedef struct _pdfpcViewPdfPrivate pdfpcViewPdfPrivate;

#define PDFPC_RENDERER_TYPE_PDF (pdfpc_renderer_pdf_get_type ())
#define PDFPC_RENDERER_PDF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_TYPE_PDF, pdfpcRendererPdf))
#define PDFPC_RENDERER_PDF_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_RENDERER_TYPE_PDF, pdfpcRendererPdfClass))
#define PDFPC_RENDERER_IS_PDF(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_TYPE_PDF))
#define PDFPC_RENDERER_IS_PDF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_RENDERER_TYPE_PDF))
#define PDFPC_RENDERER_PDF_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_RENDERER_TYPE_PDF, pdfpcRendererPdfClass))

typedef struct _pdfpcRendererPdf pdfpcRendererPdf;
typedef struct _pdfpcRendererPdfClass pdfpcRendererPdfClass;

#define PDFPC_METADATA_TYPE_BASE (pdfpc_metadata_base_get_type ())
#define PDFPC_METADATA_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_METADATA_TYPE_BASE, pdfpcMetadataBase))
#define PDFPC_METADATA_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_METADATA_TYPE_BASE, pdfpcMetadataBaseClass))
#define PDFPC_METADATA_IS_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_METADATA_TYPE_BASE))
#define PDFPC_METADATA_IS_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_METADATA_TYPE_BASE))
#define PDFPC_METADATA_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_METADATA_TYPE_BASE, pdfpcMetadataBaseClass))

typedef struct _pdfpcMetadataBase pdfpcMetadataBase;
typedef struct _pdfpcMetadataBaseClass pdfpcMetadataBaseClass;

#define PDFPC_METADATA_TYPE_PDF (pdfpc_metadata_pdf_get_type ())
#define PDFPC_METADATA_PDF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_METADATA_TYPE_PDF, pdfpcMetadataPdf))
#define PDFPC_METADATA_PDF_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_METADATA_TYPE_PDF, pdfpcMetadataPdfClass))
#define PDFPC_METADATA_IS_PDF(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_METADATA_TYPE_PDF))
#define PDFPC_METADATA_IS_PDF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_METADATA_TYPE_PDF))
#define PDFPC_METADATA_PDF_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_METADATA_TYPE_PDF, pdfpcMetadataPdfClass))

typedef struct _pdfpcMetadataPdf pdfpcMetadataPdf;
typedef struct _pdfpcMetadataPdfClass pdfpcMetadataPdfClass;
typedef struct _pdfpcPresentationControllerPrivate pdfpcPresentationControllerPrivate;

#define PDFPC_WINDOW_TYPE_OVERVIEW (pdfpc_window_overview_get_type ())
#define PDFPC_WINDOW_OVERVIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_WINDOW_TYPE_OVERVIEW, pdfpcWindowOverview))
#define PDFPC_WINDOW_OVERVIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_WINDOW_TYPE_OVERVIEW, pdfpcWindowOverviewClass))
#define PDFPC_WINDOW_IS_OVERVIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_WINDOW_TYPE_OVERVIEW))
#define PDFPC_WINDOW_IS_OVERVIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_WINDOW_TYPE_OVERVIEW))
#define PDFPC_WINDOW_OVERVIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_WINDOW_TYPE_OVERVIEW, pdfpcWindowOverviewClass))

typedef struct _pdfpcWindowOverview pdfpcWindowOverview;
typedef struct _pdfpcWindowOverviewClass pdfpcWindowOverviewClass;

#define PDFPC_TYPE_TIMER_LABEL (pdfpc_timer_label_get_type ())
#define PDFPC_TIMER_LABEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_TIMER_LABEL, pdfpcTimerLabel))
#define PDFPC_TIMER_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_TIMER_LABEL, pdfpcTimerLabelClass))
#define PDFPC_IS_TIMER_LABEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_TIMER_LABEL))
#define PDFPC_IS_TIMER_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_TIMER_LABEL))
#define PDFPC_TIMER_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_TIMER_LABEL, pdfpcTimerLabelClass))

typedef struct _pdfpcTimerLabel pdfpcTimerLabel;
typedef struct _pdfpcTimerLabelClass pdfpcTimerLabelClass;

#define PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_ACTION (pdfpc_presentation_controller_key_action_get_type ())
#define PDFPC_PRESENTATION_CONTROLLER_KEY_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_ACTION, pdfpcPresentationControllerKeyAction))
#define PDFPC_PRESENTATION_CONTROLLER_KEY_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_ACTION, pdfpcPresentationControllerKeyActionClass))
#define PDFPC_PRESENTATION_CONTROLLER_IS_KEY_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_ACTION))
#define PDFPC_PRESENTATION_CONTROLLER_IS_KEY_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_ACTION))
#define PDFPC_PRESENTATION_CONTROLLER_KEY_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_ACTION, pdfpcPresentationControllerKeyActionClass))

typedef struct _pdfpcPresentationControllerKeyAction pdfpcPresentationControllerKeyAction;
typedef struct _pdfpcPresentationControllerKeyActionClass pdfpcPresentationControllerKeyActionClass;

#define PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_DEF (pdfpc_presentation_controller_key_def_get_type ())
#define PDFPC_PRESENTATION_CONTROLLER_KEY_DEF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_DEF, pdfpcPresentationControllerKeyDef))
#define PDFPC_PRESENTATION_CONTROLLER_KEY_DEF_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_DEF, pdfpcPresentationControllerKeyDefClass))
#define PDFPC_PRESENTATION_CONTROLLER_IS_KEY_DEF(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_DEF))
#define PDFPC_PRESENTATION_CONTROLLER_IS_KEY_DEF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_DEF))
#define PDFPC_PRESENTATION_CONTROLLER_KEY_DEF_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_PRESENTATION_CONTROLLER_TYPE_KEY_DEF, pdfpcPresentationControllerKeyDefClass))

typedef struct _pdfpcPresentationControllerKeyDef pdfpcPresentationControllerKeyDef;
typedef struct _pdfpcPresentationControllerKeyDefClass pdfpcPresentationControllerKeyDefClass;
typedef struct _pdfpcPresentationControllerKeyActionPrivate pdfpcPresentationControllerKeyActionPrivate;
typedef struct _pdfpcPresentationControllerKeyDefPrivate pdfpcPresentationControllerKeyDefPrivate;

#define PDFPC_TYPE_MUTEX_LOCKS (pdfpc_mutex_locks_get_type ())
#define PDFPC_MUTEX_LOCKS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_MUTEX_LOCKS, pdfpcMutexLocks))
#define PDFPC_MUTEX_LOCKS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_MUTEX_LOCKS, pdfpcMutexLocksClass))
#define PDFPC_IS_MUTEX_LOCKS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_MUTEX_LOCKS))
#define PDFPC_IS_MUTEX_LOCKS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_MUTEX_LOCKS))
#define PDFPC_MUTEX_LOCKS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_MUTEX_LOCKS, pdfpcMutexLocksClass))

typedef struct _pdfpcMutexLocks pdfpcMutexLocks;
typedef struct _pdfpcMutexLocksClass pdfpcMutexLocksClass;
typedef struct _pdfpcMutexLocksPrivate pdfpcMutexLocksPrivate;
typedef struct _pdfpcRendererBasePrivate pdfpcRendererBasePrivate;
typedef struct _pdfpcRendererPdfPrivate pdfpcRendererPdfPrivate;

#define PDFPC_RENDERER_CACHE_TYPE_OPTION_FACTORY (pdfpc_renderer_cache_option_factory_get_type ())
#define PDFPC_RENDERER_CACHE_OPTION_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_CACHE_TYPE_OPTION_FACTORY, pdfpcRendererCacheOptionFactory))
#define PDFPC_RENDERER_CACHE_OPTION_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_RENDERER_CACHE_TYPE_OPTION_FACTORY, pdfpcRendererCacheOptionFactoryClass))
#define PDFPC_RENDERER_CACHE_IS_OPTION_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_CACHE_TYPE_OPTION_FACTORY))
#define PDFPC_RENDERER_CACHE_IS_OPTION_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_RENDERER_CACHE_TYPE_OPTION_FACTORY))
#define PDFPC_RENDERER_CACHE_OPTION_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_RENDERER_CACHE_TYPE_OPTION_FACTORY, pdfpcRendererCacheOptionFactoryClass))

typedef struct _pdfpcRendererCacheOptionFactory pdfpcRendererCacheOptionFactory;
typedef struct _pdfpcRendererCacheOptionFactoryClass pdfpcRendererCacheOptionFactoryClass;
typedef struct _pdfpcRendererCacheOptionFactoryPrivate pdfpcRendererCacheOptionFactoryPrivate;
typedef struct _pdfpcRendererCacheBasePrivate pdfpcRendererCacheBasePrivate;

#define PDFPC_RENDERER_CACHE_SIMPLE_TYPE_ENGINE (pdfpc_renderer_cache_simple_engine_get_type ())
#define PDFPC_RENDERER_CACHE_SIMPLE_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_CACHE_SIMPLE_TYPE_ENGINE, pdfpcRendererCacheSimpleEngine))
#define PDFPC_RENDERER_CACHE_SIMPLE_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_RENDERER_CACHE_SIMPLE_TYPE_ENGINE, pdfpcRendererCacheSimpleEngineClass))
#define PDFPC_RENDERER_CACHE_SIMPLE_IS_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_CACHE_SIMPLE_TYPE_ENGINE))
#define PDFPC_RENDERER_CACHE_SIMPLE_IS_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_RENDERER_CACHE_SIMPLE_TYPE_ENGINE))
#define PDFPC_RENDERER_CACHE_SIMPLE_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_RENDERER_CACHE_SIMPLE_TYPE_ENGINE, pdfpcRendererCacheSimpleEngineClass))

typedef struct _pdfpcRendererCacheSimpleEngine pdfpcRendererCacheSimpleEngine;
typedef struct _pdfpcRendererCacheSimpleEngineClass pdfpcRendererCacheSimpleEngineClass;
typedef struct _pdfpcRendererCacheSimpleEnginePrivate pdfpcRendererCacheSimpleEnginePrivate;

#define PDFPC_RENDERER_CACHE_PNG_TYPE_ITEM (pdfpc_renderer_cache_png_item_get_type ())
#define PDFPC_RENDERER_CACHE_PNG_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_CACHE_PNG_TYPE_ITEM, pdfpcRendererCachePNGItem))
#define PDFPC_RENDERER_CACHE_PNG_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_RENDERER_CACHE_PNG_TYPE_ITEM, pdfpcRendererCachePNGItemClass))
#define PDFPC_RENDERER_CACHE_PNG_IS_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_CACHE_PNG_TYPE_ITEM))
#define PDFPC_RENDERER_CACHE_PNG_IS_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_RENDERER_CACHE_PNG_TYPE_ITEM))
#define PDFPC_RENDERER_CACHE_PNG_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_RENDERER_CACHE_PNG_TYPE_ITEM, pdfpcRendererCachePNGItemClass))

typedef struct _pdfpcRendererCachePNGItem pdfpcRendererCachePNGItem;
typedef struct _pdfpcRendererCachePNGItemClass pdfpcRendererCachePNGItemClass;
typedef struct _pdfpcRendererCachePNGItemPrivate pdfpcRendererCachePNGItemPrivate;

#define PDFPC_RENDERER_CACHE_PNG_TYPE_ENGINE (pdfpc_renderer_cache_png_engine_get_type ())
#define PDFPC_RENDERER_CACHE_PNG_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_RENDERER_CACHE_PNG_TYPE_ENGINE, pdfpcRendererCachePNGEngine))
#define PDFPC_RENDERER_CACHE_PNG_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_RENDERER_CACHE_PNG_TYPE_ENGINE, pdfpcRendererCachePNGEngineClass))
#define PDFPC_RENDERER_CACHE_PNG_IS_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_RENDERER_CACHE_PNG_TYPE_ENGINE))
#define PDFPC_RENDERER_CACHE_PNG_IS_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_RENDERER_CACHE_PNG_TYPE_ENGINE))
#define PDFPC_RENDERER_CACHE_PNG_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_RENDERER_CACHE_PNG_TYPE_ENGINE, pdfpcRendererCachePNGEngineClass))

typedef struct _pdfpcRendererCachePNGEngine pdfpcRendererCachePNGEngine;
typedef struct _pdfpcRendererCachePNGEngineClass pdfpcRendererCachePNGEngineClass;
typedef struct _pdfpcRendererCachePNGEnginePrivate pdfpcRendererCachePNGEnginePrivate;
typedef struct _pdfpcTimerLabelPrivate pdfpcTimerLabelPrivate;

#define PDFPC_TYPE_COUNTDOWN_TIMER (pdfpc_countdown_timer_get_type ())
#define PDFPC_COUNTDOWN_TIMER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_COUNTDOWN_TIMER, pdfpcCountdownTimer))
#define PDFPC_COUNTDOWN_TIMER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_COUNTDOWN_TIMER, pdfpcCountdownTimerClass))
#define PDFPC_IS_COUNTDOWN_TIMER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_COUNTDOWN_TIMER))
#define PDFPC_IS_COUNTDOWN_TIMER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_COUNTDOWN_TIMER))
#define PDFPC_COUNTDOWN_TIMER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_COUNTDOWN_TIMER, pdfpcCountdownTimerClass))

typedef struct _pdfpcCountdownTimer pdfpcCountdownTimer;
typedef struct _pdfpcCountdownTimerClass pdfpcCountdownTimerClass;
typedef struct _pdfpcCountdownTimerPrivate pdfpcCountdownTimerPrivate;

#define PDFPC_TYPE_END_TIME_TIMER (pdfpc_end_time_timer_get_type ())
#define PDFPC_END_TIME_TIMER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_END_TIME_TIMER, pdfpcEndTimeTimer))
#define PDFPC_END_TIME_TIMER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_END_TIME_TIMER, pdfpcEndTimeTimerClass))
#define PDFPC_IS_END_TIME_TIMER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_END_TIME_TIMER))
#define PDFPC_IS_END_TIME_TIMER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_END_TIME_TIMER))
#define PDFPC_END_TIME_TIMER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_END_TIME_TIMER, pdfpcEndTimeTimerClass))

typedef struct _pdfpcEndTimeTimer pdfpcEndTimeTimer;
typedef struct _pdfpcEndTimeTimerClass pdfpcEndTimeTimerClass;
typedef struct _pdfpcEndTimeTimerPrivate pdfpcEndTimeTimerPrivate;

#define PDFPC_TYPE_COUNTUP_TIMER (pdfpc_countup_timer_get_type ())
#define PDFPC_COUNTUP_TIMER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_COUNTUP_TIMER, pdfpcCountupTimer))
#define PDFPC_COUNTUP_TIMER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_COUNTUP_TIMER, pdfpcCountupTimerClass))
#define PDFPC_IS_COUNTUP_TIMER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_COUNTUP_TIMER))
#define PDFPC_IS_COUNTUP_TIMER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_COUNTUP_TIMER))
#define PDFPC_COUNTUP_TIMER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_COUNTUP_TIMER, pdfpcCountupTimerClass))

typedef struct _pdfpcCountupTimer pdfpcCountupTimer;
typedef struct _pdfpcCountupTimerClass pdfpcCountupTimerClass;
typedef struct _pdfpcCountupTimerPrivate pdfpcCountupTimerPrivate;

#define PDFPC_TYPE_OPTIONS (pdfpc_options_get_type ())
#define PDFPC_OPTIONS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_OPTIONS, pdfpcOptions))
#define PDFPC_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_OPTIONS, pdfpcOptionsClass))
#define PDFPC_IS_OPTIONS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_OPTIONS))
#define PDFPC_IS_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_OPTIONS))
#define PDFPC_OPTIONS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_OPTIONS, pdfpcOptionsClass))

typedef struct _pdfpcOptions pdfpcOptions;
typedef struct _pdfpcOptionsClass pdfpcOptionsClass;
typedef struct _pdfpcOptionsPrivate pdfpcOptionsPrivate;

#define PDFPC_TYPE_CACHE_STATUS (pdfpc_cache_status_get_type ())
#define PDFPC_CACHE_STATUS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_CACHE_STATUS, pdfpcCacheStatus))
#define PDFPC_CACHE_STATUS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_CACHE_STATUS, pdfpcCacheStatusClass))
#define PDFPC_IS_CACHE_STATUS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_CACHE_STATUS))
#define PDFPC_IS_CACHE_STATUS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_CACHE_STATUS))
#define PDFPC_CACHE_STATUS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_CACHE_STATUS, pdfpcCacheStatusClass))

typedef struct _pdfpcCacheStatus pdfpcCacheStatus;
typedef struct _pdfpcCacheStatusClass pdfpcCacheStatusClass;
typedef struct _pdfpcCacheStatusPrivate pdfpcCacheStatusPrivate;
typedef struct _pdfpcWindowOverviewPrivate pdfpcWindowOverviewPrivate;

#define PDFPC_WINDOW_TYPE_FULLSCREEN (pdfpc_window_fullscreen_get_type ())
#define PDFPC_WINDOW_FULLSCREEN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_WINDOW_TYPE_FULLSCREEN, pdfpcWindowFullscreen))
#define PDFPC_WINDOW_FULLSCREEN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_WINDOW_TYPE_FULLSCREEN, pdfpcWindowFullscreenClass))
#define PDFPC_WINDOW_IS_FULLSCREEN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_WINDOW_TYPE_FULLSCREEN))
#define PDFPC_WINDOW_IS_FULLSCREEN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_WINDOW_TYPE_FULLSCREEN))
#define PDFPC_WINDOW_FULLSCREEN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_WINDOW_TYPE_FULLSCREEN, pdfpcWindowFullscreenClass))

typedef struct _pdfpcWindowFullscreen pdfpcWindowFullscreen;
typedef struct _pdfpcWindowFullscreenClass pdfpcWindowFullscreenClass;

#define PDFPC_WINDOW_TYPE_PRESENTER (pdfpc_window_presenter_get_type ())
#define PDFPC_WINDOW_PRESENTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_WINDOW_TYPE_PRESENTER, pdfpcWindowPresenter))
#define PDFPC_WINDOW_PRESENTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_WINDOW_TYPE_PRESENTER, pdfpcWindowPresenterClass))
#define PDFPC_WINDOW_IS_PRESENTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_WINDOW_TYPE_PRESENTER))
#define PDFPC_WINDOW_IS_PRESENTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_WINDOW_TYPE_PRESENTER))
#define PDFPC_WINDOW_PRESENTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_WINDOW_TYPE_PRESENTER, pdfpcWindowPresenterClass))

typedef struct _pdfpcWindowPresenter pdfpcWindowPresenter;
typedef struct _pdfpcWindowPresenterClass pdfpcWindowPresenterClass;

#define PDFPC_WINDOW_TYPE_CELL_RENDERER_HIGHLIGHT (pdfpc_window_cell_renderer_highlight_get_type ())
#define PDFPC_WINDOW_CELL_RENDERER_HIGHLIGHT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_WINDOW_TYPE_CELL_RENDERER_HIGHLIGHT, pdfpcWindowCellRendererHighlight))
#define PDFPC_WINDOW_CELL_RENDERER_HIGHLIGHT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_WINDOW_TYPE_CELL_RENDERER_HIGHLIGHT, pdfpcWindowCellRendererHighlightClass))
#define PDFPC_WINDOW_IS_CELL_RENDERER_HIGHLIGHT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_WINDOW_TYPE_CELL_RENDERER_HIGHLIGHT))
#define PDFPC_WINDOW_IS_CELL_RENDERER_HIGHLIGHT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_WINDOW_TYPE_CELL_RENDERER_HIGHLIGHT))
#define PDFPC_WINDOW_CELL_RENDERER_HIGHLIGHT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_WINDOW_TYPE_CELL_RENDERER_HIGHLIGHT, pdfpcWindowCellRendererHighlightClass))

typedef struct _pdfpcWindowCellRendererHighlight pdfpcWindowCellRendererHighlight;
typedef struct _pdfpcWindowCellRendererHighlightClass pdfpcWindowCellRendererHighlightClass;
typedef struct _pdfpcWindowCellRendererHighlightPrivate pdfpcWindowCellRendererHighlightPrivate;
typedef struct _pdfpcWindowFullscreenPrivate pdfpcWindowFullscreenPrivate;

#define PDFPC_WINDOW_TYPE_PRESENTATION (pdfpc_window_presentation_get_type ())
#define PDFPC_WINDOW_PRESENTATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_WINDOW_TYPE_PRESENTATION, pdfpcWindowPresentation))
#define PDFPC_WINDOW_PRESENTATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_WINDOW_TYPE_PRESENTATION, pdfpcWindowPresentationClass))
#define PDFPC_WINDOW_IS_PRESENTATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_WINDOW_TYPE_PRESENTATION))
#define PDFPC_WINDOW_IS_PRESENTATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_WINDOW_TYPE_PRESENTATION))
#define PDFPC_WINDOW_PRESENTATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_WINDOW_TYPE_PRESENTATION, pdfpcWindowPresentationClass))

typedef struct _pdfpcWindowPresentation pdfpcWindowPresentation;
typedef struct _pdfpcWindowPresentationClass pdfpcWindowPresentationClass;
typedef struct _pdfpcWindowPresentationPrivate pdfpcWindowPresentationPrivate;
typedef struct _pdfpcWindowPresenterPrivate pdfpcWindowPresenterPrivate;
typedef struct _pdfpcMetadataBasePrivate pdfpcMetadataBasePrivate;
typedef struct _pdfpcMetadataPdfPrivate pdfpcMetadataPdfPrivate;

#define PDFPC_TYPE_SLIDES_NOTES (pdfpc_slides_notes_get_type ())
#define PDFPC_SLIDES_NOTES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDFPC_TYPE_SLIDES_NOTES, pdfpcslides_notes))
#define PDFPC_SLIDES_NOTES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PDFPC_TYPE_SLIDES_NOTES, pdfpcslides_notesClass))
#define PDFPC_IS_SLIDES_NOTES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PDFPC_TYPE_SLIDES_NOTES))
#define PDFPC_IS_SLIDES_NOTES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PDFPC_TYPE_SLIDES_NOTES))
#define PDFPC_SLIDES_NOTES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PDFPC_TYPE_SLIDES_NOTES, pdfpcslides_notesClass))

typedef struct _pdfpcslides_notes pdfpcslides_notes;
typedef struct _pdfpcslides_notesClass pdfpcslides_notesClass;
typedef struct _pdfpcslides_notesPrivate pdfpcslides_notesPrivate;

struct _pdfpcViewBehaviourDecoratableIface {
	GTypeInterface parent_iface;
	void (*associate_behaviour) (pdfpcViewBehaviourDecoratable* self, pdfpcViewBehaviourBase* behaviour);
};

struct _pdfpcViewPrerenderingIface {
	GTypeInterface parent_iface;
};

struct _pdfpcControllableIface {
	GTypeInterface parent_iface;
	pdfpcPresentationController* (*get_controller) (pdfpcControllable* self);
	void (*update) (pdfpcControllable* self);
	void (*edit_note) (pdfpcControllable* self);
	void (*ask_goto_page) (pdfpcControllable* self);
	void (*show_overview) (pdfpcControllable* self);
	void (*hide_overview) (pdfpcControllable* self);
};

struct _pdfpcRendererCachingIface {
	GTypeInterface parent_iface;
	void (*set_cache) (pdfpcRendererCaching* self, pdfpcRendererCacheBase* cache);
	pdfpcRendererCacheBase* (*get_cache) (pdfpcRendererCaching* self);
};

struct _pdfpcApplication {
	GObject parent_instance;
	pdfpcApplicationPrivate * priv;
};

struct _pdfpcApplicationClass {
	GObjectClass parent_class;
};

struct _pdfpcScaler {
	GObject parent_instance;
	pdfpcScalerPrivate * priv;
	gdouble initial_width;
	gdouble initial_height;
};

struct _pdfpcScalerClass {
	GObjectClass parent_class;
};

struct _pdfpcViewBehaviourPdfLinkSignalProvider {
	GObject parent_instance;
	pdfpcViewBehaviourPdfLinkSignalProviderPrivate * priv;
	pdfpcViewPdf* target;
	PopplerLinkMapping* active_mapping;
	GList* page_link_mappings;
	GdkRectangle* precalculated_mapping_rectangles;
	gint precalculated_mapping_rectangles_length1;
};

struct _pdfpcViewBehaviourPdfLinkSignalProviderClass {
	GObjectClass parent_class;
};

typedef enum  {
	PDFPC_VIEW_BEHAVIOUR_ASSOCIATION_ERROR_BEHAVIOUR_ALREADY_ASSOCIATED,
	PDFPC_VIEW_BEHAVIOUR_ASSOCIATION_ERROR_VIEW_NOT_SUPPORTED
} pdfpcViewBehaviourAssociationError;
#define PDFPC_VIEW_BEHAVIOUR_ASSOCIATION_ERROR pdfpc_view_behaviour_association_error_quark ()
struct _pdfpcViewBehaviourBase {
	GObject parent_instance;
	pdfpcViewBehaviourBasePrivate * priv;
	pdfpcViewBase* target;
};

struct _pdfpcViewBehaviourBaseClass {
	GObjectClass parent_class;
	void (*associate) (pdfpcViewBehaviourBase* self, pdfpcViewBase* target, GError** error);
};

struct _pdfpcViewBehaviourPdfLinkImplementation {
	pdfpcViewBehaviourBase parent_instance;
	pdfpcViewBehaviourPdfLinkImplementationPrivate * priv;
	pdfpcViewBehaviourPdfLinkSignalProvider* signal_provider;
	pdfpcPresentationController* presentation_controller;
};

struct _pdfpcViewBehaviourPdfLinkImplementationClass {
	pdfpcViewBehaviourBaseClass parent_class;
};

typedef enum  {
	PDFPC_RENDERER_RENDER_ERROR_SLIDE_DOES_NOT_EXIST
} pdfpcRendererRenderError;
#define PDFPC_RENDERER_RENDER_ERROR pdfpc_renderer_render_error_quark ()
struct _pdfpcViewBase {
	GtkDrawingArea parent_instance;
	pdfpcViewBasePrivate * priv;
	pdfpcRendererBase* renderer;
};

struct _pdfpcViewBaseClass {
	GtkDrawingAreaClass parent_class;
	void (*display) (pdfpcViewBase* self, gint slide_number, gboolean force_redraw, GError** error);
	void (*fade_to_black) (pdfpcViewBase* self);
	void (*redraw) (pdfpcViewBase* self, GError** error);
	gint (*get_current_slide_number) (pdfpcViewBase* self);
};

struct _pdfpcViewDefault {
	pdfpcViewBase parent_instance;
	pdfpcViewDefaultPrivate * priv;
	gint current_slide_number;
	GdkPixmap* current_slide;
	gint n_slides;
	gint slide_limit;
	GList* behaviours;
};

struct _pdfpcViewDefaultClass {
	pdfpcViewBaseClass parent_class;
};

struct _pdfpcViewPdf {
	pdfpcViewDefault parent_instance;
	pdfpcViewPdfPrivate * priv;
};

struct _pdfpcViewPdfClass {
	pdfpcViewDefaultClass parent_class;
};

struct _pdfpcPresentationController {
	GObject parent_instance;
	pdfpcPresentationControllerPrivate * priv;
	gint current_slide_number;
	gint current_user_slide_number;
	gboolean faded_to_black;
	gboolean frozen;
	gboolean black_on_end;
	gint n_slides;
	GList* controllables;
	gboolean ignore_keyboard_events;
	gboolean ignore_mouse_events;
	pdfpcMetadataPdf* metadata;
	pdfpcWindowOverview* overview;
	gboolean overview_shown;
	guint last_key_event;
	pdfpcTimerLabel* timer;
	GeeHashMap* actionNames;
	GeeHashMap* keyBindings;
	GeeHashMap* mouseBindings;
};

struct _pdfpcPresentationControllerClass {
	GObjectClass parent_class;
};

typedef void (*pdfpcPresentationControllerKeyActionKeyActionDelegate) (void* user_data);
struct _pdfpcPresentationControllerKeyAction {
	GTypeInstance parent_instance;
	volatile int ref_count;
	pdfpcPresentationControllerKeyActionPrivate * priv;
	pdfpcPresentationControllerKeyActionKeyActionDelegate d;
	gpointer d_target;
	GDestroyNotify d_target_destroy_notify;
};

struct _pdfpcPresentationControllerKeyActionClass {
	GTypeClass parent_class;
	void (*finalize) (pdfpcPresentationControllerKeyAction *self);
};

struct _pdfpcPresentationControllerKeyDef {
	GTypeInstance parent_instance;
	volatile int ref_count;
	pdfpcPresentationControllerKeyDefPrivate * priv;
};

struct _pdfpcPresentationControllerKeyDefClass {
	GTypeClass parent_class;
	void (*finalize) (pdfpcPresentationControllerKeyDef *self);
};

struct _pdfpcMutexLocks {
	GObject parent_instance;
	pdfpcMutexLocksPrivate * priv;
};

struct _pdfpcMutexLocksClass {
	GObjectClass parent_class;
};

struct _pdfpcRendererBase {
	GObject parent_instance;
	pdfpcRendererBasePrivate * priv;
	pdfpcMetadataBase* metadata;
	gint width;
	gint height;
};

struct _pdfpcRendererBaseClass {
	GObjectClass parent_class;
	GdkPixmap* (*render_to_pixmap) (pdfpcRendererBase* self, gint slide_number, GError** error);
	GdkPixmap* (*fade_to_black) (pdfpcRendererBase* self);
};

struct _pdfpcRendererPdf {
	pdfpcRendererBase parent_instance;
	pdfpcRendererPdfPrivate * priv;
	gdouble scaling_factor;
	pdfpcRendererCacheBase* cache;
};

struct _pdfpcRendererPdfClass {
	pdfpcRendererBaseClass parent_class;
};

struct _pdfpcRendererCacheOptionFactory {
	GObject parent_instance;
	pdfpcRendererCacheOptionFactoryPrivate * priv;
};

struct _pdfpcRendererCacheOptionFactoryClass {
	GObjectClass parent_class;
};

struct _pdfpcRendererCacheBase {
	GObject parent_instance;
	pdfpcRendererCacheBasePrivate * priv;
	pdfpcMetadataBase* metadata;
};

struct _pdfpcRendererCacheBaseClass {
	GObjectClass parent_class;
	void (*store) (pdfpcRendererCacheBase* self, guint index, GdkPixmap* pixmap);
	GdkPixmap* (*retrieve) (pdfpcRendererCacheBase* self, guint index);
};

struct _pdfpcRendererCacheSimpleEngine {
	pdfpcRendererCacheBase parent_instance;
	pdfpcRendererCacheSimpleEnginePrivate * priv;
	GdkPixmap** storage;
	gint storage_length1;
	GMutex* mutex;
};

struct _pdfpcRendererCacheSimpleEngineClass {
	pdfpcRendererCacheBaseClass parent_class;
};

struct _pdfpcRendererCachePNGItem {
	GObject parent_instance;
	pdfpcRendererCachePNGItemPrivate * priv;
	guint8* data;
	gint data_length1;
};

struct _pdfpcRendererCachePNGItemClass {
	GObjectClass parent_class;
};

struct _pdfpcRendererCachePNGEngine {
	pdfpcRendererCacheBase parent_instance;
	pdfpcRendererCachePNGEnginePrivate * priv;
	pdfpcRendererCachePNGItem** storage;
	gint storage_length1;
	GMutex* mutex;
};

struct _pdfpcRendererCachePNGEngineClass {
	pdfpcRendererCacheBaseClass parent_class;
};

struct _pdfpcTimerLabel {
	GtkLabel parent_instance;
	pdfpcTimerLabelPrivate * priv;
	gint time;
	time_t start_time;
	guint timeout;
	GdkColor normal_color;
	GdkColor pretalk_color;
};

struct _pdfpcTimerLabelClass {
	GtkLabelClass parent_class;
	void (*start) (pdfpcTimerLabel* self);
	void (*stop) (pdfpcTimerLabel* self);
	void (*reset) (pdfpcTimerLabel* self);
	gboolean (*on_timeout) (pdfpcTimerLabel* self);
	void (*format_time) (pdfpcTimerLabel* self);
};

struct _pdfpcCountdownTimer {
	pdfpcTimerLabel parent_instance;
	pdfpcCountdownTimerPrivate * priv;
	gint duration;
	guint last_minutes;
	GdkColor last_minutes_color;
	GdkColor negative_color;
};

struct _pdfpcCountdownTimerClass {
	pdfpcTimerLabelClass parent_class;
};

struct _pdfpcEndTimeTimer {
	pdfpcCountdownTimer parent_instance;
	pdfpcEndTimeTimerPrivate * priv;
	time_t end_time;
	struct tm end_time_object;
};

struct _pdfpcEndTimeTimerClass {
	pdfpcCountdownTimerClass parent_class;
};

struct _pdfpcCountupTimer {
	pdfpcTimerLabel parent_instance;
	pdfpcCountupTimerPrivate * priv;
};

struct _pdfpcCountupTimerClass {
	pdfpcTimerLabelClass parent_class;
};

struct _pdfpcOptions {
	GObject parent_instance;
	pdfpcOptionsPrivate * priv;
};

struct _pdfpcOptionsClass {
	GObjectClass parent_class;
};

struct _pdfpcCacheStatus {
	GTypeInstance parent_instance;
	volatile int ref_count;
	pdfpcCacheStatusPrivate * priv;
	gint current_value;
	gint max_value;
};

struct _pdfpcCacheStatusClass {
	GTypeClass parent_class;
	void (*finalize) (pdfpcCacheStatus *self);
};

typedef void (*pdfpcCacheStatusUpdateFunction) (gdouble progress, void* user_data);
typedef void (*pdfpcCacheStatusUpdateComplete) (void* user_data);
struct _pdfpcWindowOverview {
	GtkScrolledWindow parent_instance;
	pdfpcWindowOverviewPrivate * priv;
	GtkListStore* slides;
	GtkIconView* slides_view;
	pdfpcMetadataPdf* metadata;
	gint n_slides;
	gint last_structure_n_slides;
	gint target_width;
	gint target_height;
	gint next_undone_preview;
	guint idle_id;
	pdfpcRendererCacheBase* cache;
	pdfpcPresentationController* presentation_controller;
	pdfpcWindowPresenter* presenter;
	gdouble aspect_ratio;
	gint max_width;
	gint max_height;
};

struct _pdfpcWindowOverviewClass {
	GtkScrolledWindowClass parent_class;
};

struct _pdfpcWindowCellRendererHighlight {
	GtkCellRendererPixbuf parent_instance;
	pdfpcWindowCellRendererHighlightPrivate * priv;
};

struct _pdfpcWindowCellRendererHighlightClass {
	GtkCellRendererPixbufClass parent_class;
};

struct _pdfpcWindowFullscreen {
	GtkWindow parent_instance;
	pdfpcWindowFullscreenPrivate * priv;
	GdkRectangle screen_geometry;
	guint hide_cursor_timeout;
	gboolean faded_to_black;
	gboolean frozen;
};

struct _pdfpcWindowFullscreenClass {
	GtkWindowClass parent_class;
};

struct _pdfpcWindowPresentation {
	pdfpcWindowFullscreen parent_instance;
	pdfpcWindowPresentationPrivate * priv;
	pdfpcPresentationController* presentation_controller;
	pdfpcViewBase* view;
};

struct _pdfpcWindowPresentationClass {
	pdfpcWindowFullscreenClass parent_class;
};

struct _pdfpcWindowPresenter {
	pdfpcWindowFullscreen parent_instance;
	pdfpcWindowPresenterPrivate * priv;
	pdfpcPresentationController* presentation_controller;
	pdfpcViewBase* current_view;
	pdfpcViewBase* next_view;
	pdfpcViewBase* strict_next_view;
	pdfpcViewBase* strict_prev_view;
	pdfpcTimerLabel* timer;
	GtkEntry* slide_progress;
	GtkProgressBar* prerender_progress;
	GtkImage* blank_icon;
	GtkImage* frozen_icon;
	GtkImage* pause_icon;
	GtkTextView* notes_view;
	GtkHBox* slideViews;
	pdfpcWindowOverview* overview;
	GtkAlignment* centered_overview;
	gboolean overview_added;
	GtkVBox* fullLayout;
	guint slide_count;
	pdfpcMetadataPdf* metadata;
	GdkColor black;
	GdkColor white;
};

struct _pdfpcWindowPresenterClass {
	pdfpcWindowFullscreenClass parent_class;
};

struct _pdfpcMetadataBase {
	GObject parent_instance;
	pdfpcMetadataBasePrivate * priv;
	gchar* fname;
	gchar* url;
};

struct _pdfpcMetadataBaseClass {
	GObjectClass parent_class;
	guint (*get_slide_count) (pdfpcMetadataBase* self);
};

struct _pdfpcMetadataPdf {
	pdfpcMetadataBase parent_instance;
	pdfpcMetadataPdfPrivate * priv;
	gchar* pdf_fname;
	gchar* pdf_url;
	gchar* pdfpc_url;
	PopplerDocument* document;
	gdouble page_width;
	gdouble page_height;
	guint page_count;
	pdfpcslides_notes* notes;
	gboolean skips_by_user;
	guint duration;
};

struct _pdfpcMetadataPdfClass {
	pdfpcMetadataBaseClass parent_class;
};

struct _pdfpcslides_notes {
	GObject parent_instance;
	pdfpcslides_notesPrivate * priv;
	gchar** notes;
	gint notes_length1;
};

struct _pdfpcslides_notesClass {
	GObjectClass parent_class;
};


GType pdfpc_view_behaviour_base_get_type (void) G_GNUC_CONST;
GType pdfpc_view_behaviour_decoratable_get_type (void) G_GNUC_CONST;
void pdfpc_view_behaviour_decoratable_associate_behaviour (pdfpcViewBehaviourDecoratable* self, pdfpcViewBehaviourBase* behaviour);
GType pdfpc_view_prerendering_get_type (void) G_GNUC_CONST;
GType pdfpc_presentation_controller_get_type (void) G_GNUC_CONST;
GType pdfpc_controllable_get_type (void) G_GNUC_CONST;
pdfpcPresentationController* pdfpc_controllable_get_controller (pdfpcControllable* self);
void pdfpc_controllable_update (pdfpcControllable* self);
void pdfpc_controllable_edit_note (pdfpcControllable* self);
void pdfpc_controllable_ask_goto_page (pdfpcControllable* self);
void pdfpc_controllable_show_overview (pdfpcControllable* self);
void pdfpc_controllable_hide_overview (pdfpcControllable* self);
GType pdfpc_renderer_cache_base_get_type (void) G_GNUC_CONST;
GType pdfpc_renderer_caching_get_type (void) G_GNUC_CONST;
void pdfpc_renderer_caching_set_cache (pdfpcRendererCaching* self, pdfpcRendererCacheBase* cache);
pdfpcRendererCacheBase* pdfpc_renderer_caching_get_cache (pdfpcRendererCaching* self);
GType pdfpc_application_get_type (void) G_GNUC_CONST;
gchar* pdfpc_application_parse_command_line_options (pdfpcApplication* self, gchar** args, int args_length1);
void pdfpc_application_run (pdfpcApplication* self, gchar** args, int args_length1);
gint pdfpc_application_main (gchar** args, int args_length1);
pdfpcApplication* pdfpc_application_new (void);
pdfpcApplication* pdfpc_application_construct (GType object_type);
GType pdfpc_scaler_get_type (void) G_GNUC_CONST;
pdfpcScaler* pdfpc_scaler_new (gdouble width, gdouble height);
pdfpcScaler* pdfpc_scaler_construct (GType object_type, gdouble width, gdouble height);
void pdfpc_scaler_scale_to (pdfpcScaler* self, gint width, gint height, gboolean centered, gboolean allow_cutoff, GdkRectangle* result);
GType pdfpc_view_behaviour_pdf_link_signal_provider_get_type (void) G_GNUC_CONST;
GType pdfpc_view_base_get_type (void) G_GNUC_CONST;
GType pdfpc_view_default_get_type (void) G_GNUC_CONST;
GType pdfpc_view_pdf_get_type (void) G_GNUC_CONST;
void pdfpc_view_behaviour_pdf_link_signal_provider_attach (pdfpcViewBehaviourPdfLinkSignalProvider* self, pdfpcViewPdf* view);
PopplerLinkMapping* pdfpc_view_behaviour_pdf_link_signal_provider_get_link_mapping_by_coordinates (pdfpcViewBehaviourPdfLinkSignalProvider* self, gdouble x, gdouble y);
void pdfpc_view_behaviour_pdf_link_signal_provider_handle_link_mapping (pdfpcViewBehaviourPdfLinkSignalProvider* self, PopplerLinkMapping* mapping);
void pdfpc_view_behaviour_pdf_link_signal_provider_convert_poppler_rectangle_to_gdk_rectangle (pdfpcViewBehaviourPdfLinkSignalProvider* self, PopplerRectangle* poppler_rectangle, GdkRectangle* result);
gboolean pdfpc_view_behaviour_pdf_link_signal_provider_on_button_press (pdfpcViewBehaviourPdfLinkSignalProvider* self, GtkWidget* source, GdkEventButton* e);
gboolean pdfpc_view_behaviour_pdf_link_signal_provider_on_mouse_move (pdfpcViewBehaviourPdfLinkSignalProvider* self, GtkWidget* source, GdkEventMotion* event);
void pdfpc_view_behaviour_pdf_link_signal_provider_on_entering_slide (pdfpcViewBehaviourPdfLinkSignalProvider* self, pdfpcViewBase* source, gint page_number);
void pdfpc_view_behaviour_pdf_link_signal_provider_on_leaving_slide (pdfpcViewBehaviourPdfLinkSignalProvider* self, pdfpcViewBase* source, gint from, gint to);
pdfpcViewBehaviourPdfLinkSignalProvider* pdfpc_view_behaviour_pdf_link_signal_provider_new (void);
pdfpcViewBehaviourPdfLinkSignalProvider* pdfpc_view_behaviour_pdf_link_signal_provider_construct (GType object_type);
GQuark pdfpc_view_behaviour_association_error_quark (void);
GType pdfpc_view_behaviour_pdf_link_implementation_get_type (void) G_GNUC_CONST;
pdfpcViewBehaviourPdfLinkImplementation* pdfpc_view_behaviour_pdf_link_implementation_new (pdfpcPresentationController* presentation_controller);
pdfpcViewBehaviourPdfLinkImplementation* pdfpc_view_behaviour_pdf_link_implementation_construct (GType object_type, pdfpcPresentationController* presentation_controller);
gboolean pdfpc_view_behaviour_pdf_link_implementation_is_supported (pdfpcViewBehaviourPdfLinkImplementation* self, pdfpcViewBase* target);
void pdfpc_view_behaviour_pdf_link_implementation_on_link_mouse_enter (pdfpcViewBehaviourPdfLinkImplementation* self, GdkRectangle* link_rect, PopplerLinkMapping* mapping);
void pdfpc_view_behaviour_pdf_link_implementation_on_link_mouse_leave (pdfpcViewBehaviourPdfLinkImplementation* self, GdkRectangle* link_rect, PopplerLinkMapping* mapping);
void pdfpc_view_behaviour_pdf_link_implementation_on_clicked_internal_link (pdfpcViewBehaviourPdfLinkImplementation* self, GdkRectangle* link_rect, guint source_page_number, guint target_page_number);
void pdfpc_view_behaviour_pdf_link_implementation_on_clicked_external_command (pdfpcViewBehaviourPdfLinkImplementation* self, GdkRectangle* link_rect, guint source_page_number, const gchar* command, const gchar* arguments);
pdfpcViewBehaviourBase* pdfpc_view_behaviour_base_construct (GType object_type);
pdfpcViewBase* pdfpc_view_behaviour_base_get_target (pdfpcViewBehaviourBase* self);
void pdfpc_view_behaviour_base_enforce_exclusive_association (pdfpcViewBehaviourBase* self, pdfpcViewBase* target, GError** error);
void pdfpc_view_behaviour_base_associate (pdfpcViewBehaviourBase* self, pdfpcViewBase* target, GError** error);
gboolean pdfpc_view_behaviour_base_is_supported (pdfpcViewBehaviourBase* self, pdfpcViewBase* target);
GQuark pdfpc_renderer_render_error_quark (void);
GType pdfpc_renderer_base_get_type (void) G_GNUC_CONST;
GType pdfpc_renderer_pdf_get_type (void) G_GNUC_CONST;
pdfpcViewPdf* pdfpc_view_pdf_new (pdfpcRendererPdf* renderer, gboolean allow_black_on_end, pdfpcPresentationController* presentation_controller);
pdfpcViewPdf* pdfpc_view_pdf_construct (GType object_type, pdfpcRendererPdf* renderer, gboolean allow_black_on_end, pdfpcPresentationController* presentation_controller);
GType pdfpc_metadata_base_get_type (void) G_GNUC_CONST;
GType pdfpc_metadata_pdf_get_type (void) G_GNUC_CONST;
pdfpcViewPdf* pdfpc_view_pdf_from_metadata (pdfpcMetadataPdf* metadata, gint width, gint height, gboolean allow_black_on_end, pdfpcPresentationController* presentation_controller, GdkRectangle* scale_rect);
pdfpcRendererPdf* pdfpc_view_pdf_get_renderer (pdfpcViewPdf* self);
pdfpcViewBase* pdfpc_view_base_construct (GType object_type, pdfpcRendererBase* renderer);
pdfpcRendererBase* pdfpc_view_base_get_renderer (pdfpcViewBase* self);
void pdfpc_view_base_display (pdfpcViewBase* self, gint slide_number, gboolean force_redraw, GError** error);
void pdfpc_view_base_fade_to_black (pdfpcViewBase* self);
void pdfpc_view_base_redraw (pdfpcViewBase* self, GError** error);
gint pdfpc_view_base_get_current_slide_number (pdfpcViewBase* self);
pdfpcViewDefault* pdfpc_view_default_new (pdfpcRendererBase* renderer);
pdfpcViewDefault* pdfpc_view_default_construct (GType object_type, pdfpcRendererBase* renderer);
void pdfpc_view_default_register_prerendering (pdfpcViewDefault* self);
GType pdfpc_window_overview_get_type (void) G_GNUC_CONST;
GType pdfpc_timer_label_get_type (void) G_GNUC_CONST;
gpointer pdfpc_presentation_controller_key_action_ref (gpointer instance);
void pdfpc_presentation_controller_key_action_unref (gpointer instance);
GParamSpec* pdfpc_presentation_controller_param_spec_key_action (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void pdfpc_presentation_controller_value_set_key_action (GValue* value, gpointer v_object);
void pdfpc_presentation_controller_value_take_key_action (GValue* value, gpointer v_object);
gpointer pdfpc_presentation_controller_value_get_key_action (const GValue* value);
GType pdfpc_presentation_controller_key_action_get_type (void) G_GNUC_CONST;
gpointer pdfpc_presentation_controller_key_def_ref (gpointer instance);
void pdfpc_presentation_controller_key_def_unref (gpointer instance);
GParamSpec* pdfpc_presentation_controller_param_spec_key_def (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void pdfpc_presentation_controller_value_set_key_def (GValue* value, gpointer v_object);
void pdfpc_presentation_controller_value_take_key_def (GValue* value, gpointer v_object);
gpointer pdfpc_presentation_controller_value_get_key_def (const GValue* value);
GType pdfpc_presentation_controller_key_def_get_type (void) G_GNUC_CONST;
pdfpcPresentationController* pdfpc_presentation_controller_new (pdfpcMetadataPdf* metadata, gboolean allow_black_on_end);
pdfpcPresentationController* pdfpc_presentation_controller_construct (GType object_type, pdfpcMetadataPdf* metadata, gboolean allow_black_on_end);
void pdfpc_presentation_controller_set_overview (pdfpcPresentationController* self, pdfpcWindowOverview* o);
void pdfpc_presentation_controller_fillActionNames (pdfpcPresentationController* self);
gchar** pdfpc_presentation_controller_getActionDescriptions (int* result_length1);
void pdfpc_presentation_controller_bind (pdfpcPresentationController* self, guint keycode, guint modMask, const gchar* function);
void pdfpc_presentation_controller_unbind (pdfpcPresentationController* self, guint keycode, guint modMask);
void pdfpc_presentation_controller_unbindAll (pdfpcPresentationController* self);
void pdfpc_presentation_controller_bindMouse (pdfpcPresentationController* self, guint button, guint modMask, const gchar* function);
void pdfpc_presentation_controller_unbindMouse (pdfpcPresentationController* self, guint keycode, guint modMask);
void pdfpc_presentation_controller_unbindAllMouse (pdfpcPresentationController* self);
gboolean pdfpc_presentation_controller_key_press (pdfpcPresentationController* self, GdkEventKey* key);
gboolean pdfpc_presentation_controller_button_press (pdfpcPresentationController* self, GdkEventButton* button);
void pdfpc_presentation_controller_scroll (pdfpcPresentationController* self, GdkEventScroll* scroll);
gint pdfpc_presentation_controller_get_current_slide_number (pdfpcPresentationController* self);
gint pdfpc_presentation_controller_get_current_user_slide_number (pdfpcPresentationController* self);
gboolean pdfpc_presentation_controller_skip_previous (pdfpcPresentationController* self);
gboolean pdfpc_presentation_controller_skip_next (pdfpcPresentationController* self);
gint pdfpc_presentation_controller_get_n_slide (pdfpcPresentationController* self);
gint pdfpc_presentation_controller_get_user_n_slides (pdfpcPresentationController* self);
gint pdfpc_presentation_controller_get_end_user_slide (pdfpcPresentationController* self);
void pdfpc_presentation_controller_set_end_user_slide (pdfpcPresentationController* self);
void pdfpc_presentation_controller_set_end_user_slide_overview (pdfpcPresentationController* self);
void pdfpc_presentation_controller_page_change_request (pdfpcPresentationController* self, gint page_number);
void pdfpc_presentation_controller_set_ignore_input_events (pdfpcPresentationController* self, gboolean v);
void pdfpc_presentation_controller_set_ignore_mouse_events (pdfpcPresentationController* self, gboolean v);
pdfpcTimerLabel* pdfpc_presentation_controller_getTimer (pdfpcPresentationController* self);
gboolean pdfpc_presentation_controller_register_controllable (pdfpcPresentationController* self, pdfpcControllable* controllable);
void pdfpc_presentation_controller_next_page (pdfpcPresentationController* self);
void pdfpc_presentation_controller_next_user_page (pdfpcPresentationController* self);
void pdfpc_presentation_controller_previous_page (pdfpcPresentationController* self);
void pdfpc_presentation_controller_previous_user_page (pdfpcPresentationController* self);
void pdfpc_presentation_controller_goto_first (pdfpcPresentationController* self);
void pdfpc_presentation_controller_goto_last (pdfpcPresentationController* self);
void pdfpc_presentation_controller_jump10 (pdfpcPresentationController* self);
void pdfpc_presentation_controller_back10 (pdfpcPresentationController* self);
void pdfpc_presentation_controller_goto_user_page (pdfpcPresentationController* self, gint page_number);
void pdfpc_presentation_controller_history_back (pdfpcPresentationController* self);
void pdfpc_presentation_controller_controllables_update (pdfpcPresentationController* self);
void pdfpc_presentation_controller_controllables_reset (pdfpcPresentationController* self);
void pdfpc_presentation_controller_toggle_overview (pdfpcPresentationController* self);
void pdfpc_presentation_controller_controllables_show_overview (pdfpcPresentationController* self);
void pdfpc_presentation_controller_controllables_hide_overview (pdfpcPresentationController* self);
void pdfpc_presentation_controller_fade_to_black (pdfpcPresentationController* self);
gboolean pdfpc_presentation_controller_is_faded_to_black (pdfpcPresentationController* self);
void pdfpc_presentation_controller_controllables_edit_note (pdfpcPresentationController* self);
void pdfpc_presentation_controller_controllables_ask_goto_page (pdfpcPresentationController* self);
void pdfpc_presentation_controller_toggle_freeze (pdfpcPresentationController* self);
gboolean pdfpc_presentation_controller_is_frozen (pdfpcPresentationController* self);
void pdfpc_presentation_controller_toggle_skip (pdfpcPresentationController* self);
void pdfpc_presentation_controller_start (pdfpcPresentationController* self);
void pdfpc_presentation_controller_toggle_pause (pdfpcPresentationController* self);
void pdfpc_presentation_controller_reset_timer (pdfpcPresentationController* self);
void pdfpc_presentation_controller_exit_state (pdfpcPresentationController* self);
void pdfpc_presentation_controller_quit (pdfpcPresentationController* self);
guint pdfpc_presentation_controller_get_accepted_key_mods (pdfpcPresentationController* self);
void pdfpc_presentation_controller_set_accepted_key_mods (pdfpcPresentationController* self, guint value);
pdfpcPresentationControllerKeyAction* pdfpc_presentation_controller_key_action_new (pdfpcPresentationControllerKeyActionKeyActionDelegate d, void* d_target);
pdfpcPresentationControllerKeyAction* pdfpc_presentation_controller_key_action_construct (GType object_type, pdfpcPresentationControllerKeyActionKeyActionDelegate d, void* d_target);
pdfpcPresentationControllerKeyDef* pdfpc_presentation_controller_key_def_new (guint k, guint m);
pdfpcPresentationControllerKeyDef* pdfpc_presentation_controller_key_def_construct (GType object_type, guint k, guint m);
guint pdfpc_presentation_controller_key_def_hash (void* _a);
gboolean pdfpc_presentation_controller_key_def_equal (void* _a, void* _b);
guint pdfpc_presentation_controller_key_def_get_keycode (pdfpcPresentationControllerKeyDef* self);
void pdfpc_presentation_controller_key_def_set_keycode (pdfpcPresentationControllerKeyDef* self, guint value);
guint pdfpc_presentation_controller_key_def_get_modMask (pdfpcPresentationControllerKeyDef* self);
void pdfpc_presentation_controller_key_def_set_modMask (pdfpcPresentationControllerKeyDef* self, guint value);
GType pdfpc_mutex_locks_get_type (void) G_GNUC_CONST;
extern GMutex* pdfpc_mutex_locks_poppler;
void pdfpc_mutex_locks_init (void);
pdfpcMutexLocks* pdfpc_mutex_locks_new (void);
pdfpcMutexLocks* pdfpc_mutex_locks_construct (GType object_type);
pdfpcRendererPdf* pdfpc_renderer_pdf_new (pdfpcMetadataPdf* metadata, gint width, gint height);
pdfpcRendererPdf* pdfpc_renderer_pdf_construct (GType object_type, pdfpcMetadataPdf* metadata, gint width, gint height);
GType pdfpc_renderer_cache_option_factory_get_type (void) G_GNUC_CONST;
pdfpcRendererCacheBase* pdfpc_renderer_cache_option_factory_create (pdfpcMetadataBase* metadata);
pdfpcRendererCacheBase* pdfpc_renderer_cache_base_construct (GType object_type, pdfpcMetadataBase* metadata);
gboolean pdfpc_renderer_cache_base_allows_prerendering (pdfpcRendererCacheBase* self);
void pdfpc_renderer_cache_base_store (pdfpcRendererCacheBase* self, guint index, GdkPixmap* pixmap);
GdkPixmap* pdfpc_renderer_cache_base_retrieve (pdfpcRendererCacheBase* self, guint index);
GType pdfpc_renderer_cache_simple_engine_get_type (void) G_GNUC_CONST;
pdfpcRendererCacheSimpleEngine* pdfpc_renderer_cache_simple_engine_new (pdfpcMetadataBase* metadata);
pdfpcRendererCacheSimpleEngine* pdfpc_renderer_cache_simple_engine_construct (GType object_type, pdfpcMetadataBase* metadata);
GType pdfpc_renderer_cache_png_item_get_type (void) G_GNUC_CONST;
pdfpcRendererCachePNGItem* pdfpc_renderer_cache_png_item_new (guint8* data, int data_length1);
pdfpcRendererCachePNGItem* pdfpc_renderer_cache_png_item_construct (GType object_type, guint8* data, int data_length1);
guint8* pdfpc_renderer_cache_png_item_get_png_data (pdfpcRendererCachePNGItem* self, int* result_length1);
gint pdfpc_renderer_cache_png_item_get_length (pdfpcRendererCachePNGItem* self);
GType pdfpc_renderer_cache_png_engine_get_type (void) G_GNUC_CONST;
pdfpcRendererCachePNGEngine* pdfpc_renderer_cache_png_engine_new (pdfpcMetadataBase* metadata);
pdfpcRendererCachePNGEngine* pdfpc_renderer_cache_png_engine_construct (GType object_type, pdfpcMetadataBase* metadata);
pdfpcRendererBase* pdfpc_renderer_base_construct (GType object_type, pdfpcMetadataBase* metadata, gint width, gint height);
pdfpcMetadataBase* pdfpc_renderer_base_get_metadata (pdfpcRendererBase* self);
gint pdfpc_renderer_base_get_width (pdfpcRendererBase* self);
gint pdfpc_renderer_base_get_height (pdfpcRendererBase* self);
GdkPixmap* pdfpc_renderer_base_render_to_pixmap (pdfpcRendererBase* self, gint slide_number, GError** error);
GdkPixmap* pdfpc_renderer_base_fade_to_black (pdfpcRendererBase* self);
pdfpcTimerLabel* pdfpc_timer_label_construct (GType object_type, time_t start_time);
void pdfpc_timer_label_start (pdfpcTimerLabel* self);
void pdfpc_timer_label_stop (pdfpcTimerLabel* self);
gboolean pdfpc_timer_label_pause (pdfpcTimerLabel* self);
gboolean pdfpc_timer_label_is_paused (pdfpcTimerLabel* self);
void pdfpc_timer_label_reset (pdfpcTimerLabel* self);
gint pdfpc_timer_label_calculate_countdown (pdfpcTimerLabel* self);
gboolean pdfpc_timer_label_on_timeout (pdfpcTimerLabel* self);
void pdfpc_timer_label_format_time (pdfpcTimerLabel* self);
void pdfpc_timer_label_show_time (pdfpcTimerLabel* self, guint timeInSecs, const gchar* prefix);
GType pdfpc_countdown_timer_get_type (void) G_GNUC_CONST;
pdfpcCountdownTimer* pdfpc_countdown_timer_new (gint duration, guint last_minutes, time_t start_time);
pdfpcCountdownTimer* pdfpc_countdown_timer_construct (GType object_type, gint duration, guint last_minutes, time_t start_time);
GType pdfpc_end_time_timer_get_type (void) G_GNUC_CONST;
pdfpcEndTimeTimer* pdfpc_end_time_timer_new (time_t end_time, guint last_minutes, time_t start_time);
pdfpcEndTimeTimer* pdfpc_end_time_timer_construct (GType object_type, time_t end_time, guint last_minutes, time_t start_time);
GType pdfpc_countup_timer_get_type (void) G_GNUC_CONST;
pdfpcCountupTimer* pdfpc_countup_timer_new (time_t start_time);
pdfpcCountupTimer* pdfpc_countup_timer_construct (GType object_type, time_t start_time);
GType pdfpc_options_get_type (void) G_GNUC_CONST;
extern gboolean pdfpc_options_display_switch;
extern gboolean pdfpc_options_single_screen;
extern gboolean pdfpc_options_windowed;
extern gboolean pdfpc_options_disable_caching;
extern gboolean pdfpc_options_disable_cache_compression;
extern guint pdfpc_options_duration;
extern guint pdfpc_options_last_minutes;
extern guint pdfpc_options_current_size;
extern gint pdfpc_options_min_overview_width;
extern gchar* pdfpc_options_start_time;
extern gchar* pdfpc_options_end_time;
extern gboolean pdfpc_options_black_on_end;
extern gboolean pdfpc_options_list_actions;
pdfpcOptions* pdfpc_options_new (void);
pdfpcOptions* pdfpc_options_construct (GType object_type);
gpointer pdfpc_cache_status_ref (gpointer instance);
void pdfpc_cache_status_unref (gpointer instance);
GParamSpec* pdfpc_param_spec_cache_status (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void pdfpc_value_set_cache_status (GValue* value, gpointer v_object);
void pdfpc_value_take_cache_status (GValue* value, gpointer v_object);
gpointer pdfpc_value_get_cache_status (const GValue* value);
GType pdfpc_cache_status_get_type (void) G_GNUC_CONST;
void pdfpc_cache_status_register_update (pdfpcCacheStatus* self, pdfpcCacheStatusUpdateFunction update, void* update_target, pdfpcCacheStatusUpdateComplete complete, void* complete_target);
void pdfpc_cache_status_update (pdfpcCacheStatus* self);
void pdfpc_cache_status_monitor_view (pdfpcCacheStatus* self, pdfpcViewPrerendering* view);
pdfpcCacheStatus* pdfpc_cache_status_new (void);
pdfpcCacheStatus* pdfpc_cache_status_construct (GType object_type);
GType pdfpc_window_fullscreen_get_type (void) G_GNUC_CONST;
GType pdfpc_window_presenter_get_type (void) G_GNUC_CONST;
void pdfpc_window_overview_on_selection_changed (pdfpcWindowOverview* self, GtkWidget* source);
pdfpcWindowOverview* pdfpc_window_overview_new (pdfpcMetadataPdf* metadata, pdfpcPresentationController* presentation_controller, pdfpcWindowPresenter* presenter);
pdfpcWindowOverview* pdfpc_window_overview_construct (GType object_type, pdfpcMetadataPdf* metadata, pdfpcPresentationController* presentation_controller, pdfpcWindowPresenter* presenter);
void pdfpc_window_overview_set_available_space (pdfpcWindowOverview* self, gint width, gint height);
void pdfpc_window_overview_on_parent_set (pdfpcWindowOverview* self, GtkWidget* old_parent);
void pdfpc_window_overview_on_show (pdfpcWindowOverview* self);
void pdfpc_window_overview_on_hide (pdfpcWindowOverview* self);
void pdfpc_window_overview_fill_structure (pdfpcWindowOverview* self);
void pdfpc_window_overview_fill_previews (pdfpcWindowOverview* self);
gboolean _pdfpc_window_overview_fill_previews (pdfpcWindowOverview* self);
void pdfpc_window_overview_set_cache (pdfpcWindowOverview* self, pdfpcRendererCacheBase* cache);
void pdfpc_window_overview_set_n_slides (pdfpcWindowOverview* self, gint n);
void pdfpc_window_overview_remove_current (pdfpcWindowOverview* self, gint newn);
gboolean pdfpc_window_overview_on_key_press (pdfpcWindowOverview* self, GtkWidget* source, GdkEventKey* key);
gboolean pdfpc_window_overview_on_mouse_move (pdfpcWindowOverview* self, GtkWidget* source, GdkEventMotion* event);
gboolean pdfpc_window_overview_on_mouse_release (pdfpcWindowOverview* self, GdkEventButton* event);
gint pdfpc_window_overview_get_current_slide (pdfpcWindowOverview* self);
void pdfpc_window_overview_set_current_slide (pdfpcWindowOverview* self, gint value);
GType pdfpc_window_cell_renderer_highlight_get_type (void) G_GNUC_CONST;
pdfpcWindowCellRendererHighlight* pdfpc_window_cell_renderer_highlight_new (void);
pdfpcWindowCellRendererHighlight* pdfpc_window_cell_renderer_highlight_construct (GType object_type);
pdfpcWindowFullscreen* pdfpc_window_fullscreen_new (gint screen_num);
pdfpcWindowFullscreen* pdfpc_window_fullscreen_construct (GType object_type, gint screen_num);
gboolean pdfpc_window_fullscreen_on_configure (pdfpcWindowFullscreen* self, GdkEventConfigure* e);
void pdfpc_window_fullscreen_on_size_allocate (pdfpcWindowFullscreen* self, GtkWidget* source, GdkRectangle* r);
gboolean pdfpc_window_fullscreen_on_mouse_move (pdfpcWindowFullscreen* self, GtkWidget* source, GdkEventMotion* event);
void pdfpc_window_fullscreen_restart_hide_cursor_timer (pdfpcWindowFullscreen* self);
gboolean pdfpc_window_fullscreen_on_hide_cursor_timeout (pdfpcWindowFullscreen* self);
GType pdfpc_window_presentation_get_type (void) G_GNUC_CONST;
pdfpcWindowPresentation* pdfpc_window_presentation_new (pdfpcMetadataPdf* metadata, gint screen_num, pdfpcPresentationController* presentation_controller);
pdfpcWindowPresentation* pdfpc_window_presentation_construct (GType object_type, pdfpcMetadataPdf* metadata, gint screen_num, pdfpcPresentationController* presentation_controller);
gboolean pdfpc_window_presentation_on_key_pressed (pdfpcWindowPresentation* self, GdkEventKey* key);
gboolean pdfpc_window_presentation_on_button_press (pdfpcWindowPresentation* self, GdkEventButton* button);
gboolean pdfpc_window_presentation_on_scroll (pdfpcWindowPresentation* self, GtkWidget* source, GdkEventScroll* scroll);
void pdfpc_window_presentation_set_controller (pdfpcWindowPresentation* self, pdfpcPresentationController* controller);
void pdfpc_window_presentation_set_cache_observer (pdfpcWindowPresentation* self, pdfpcCacheStatus* observer);
pdfpcWindowPresenter* pdfpc_window_presenter_new (pdfpcMetadataPdf* metadata, gint screen_num, pdfpcPresentationController* presentation_controller);
pdfpcWindowPresenter* pdfpc_window_presenter_construct (GType object_type, pdfpcMetadataPdf* metadata, gint screen_num, pdfpcPresentationController* presentation_controller);
void pdfpc_window_presenter_build_layout (pdfpcWindowPresenter* self);
gboolean pdfpc_window_presenter_on_key_pressed (pdfpcWindowPresenter* self, GtkWidget* source, GdkEventKey* key);
gboolean pdfpc_window_presenter_on_button_press (pdfpcWindowPresenter* self, GtkWidget* source, GdkEventButton* button);
gboolean pdfpc_window_presenter_on_scroll (pdfpcWindowPresenter* self, GtkWidget* source, GdkEventScroll* scroll);
void pdfpc_window_presenter_update_slide_count (pdfpcWindowPresenter* self);
void pdfpc_window_presenter_custom_slide_count (pdfpcWindowPresenter* self, gint current);
void pdfpc_window_presenter_goto_page (pdfpcWindowPresenter* self, gint page_number);
gboolean pdfpc_window_presenter_on_key_press_slide_progress (pdfpcWindowPresenter* self, GtkWidget* source, GdkEventKey* key);
gboolean pdfpc_window_presenter_on_key_press_notes_view (pdfpcWindowPresenter* self, GtkWidget* source, GdkEventKey* key);
void pdfpc_window_presenter_update_note (pdfpcWindowPresenter* self);
void pdfpc_window_presenter_set_cache_observer (pdfpcWindowPresenter* self, pdfpcCacheStatus* observer);
void pdfpc_window_presenter_prerender_finished (pdfpcWindowPresenter* self);
GType pdfpc_slides_notes_get_type (void) G_GNUC_CONST;
void pdfpc_metadata_pdf_save_to_disk (pdfpcMetadataPdf* self);
gchar* pdfpc_metadata_pdf_format_skips (pdfpcMetadataPdf* self);
gchar* pdfpc_metadata_pdf_format_end_user_slide (pdfpcMetadataPdf* self);
gchar* pdfpc_metadata_pdf_format_notes (pdfpcMetadataPdf* self);
gchar* pdfpc_metadata_pdf_format_duration (pdfpcMetadataPdf* self);
pdfpcMetadataPdf* pdfpc_metadata_pdf_new (const gchar* fname);
pdfpcMetadataPdf* pdfpc_metadata_pdf_construct (GType object_type, const gchar* fname);
gint pdfpc_metadata_pdf_get_user_slide_count (pdfpcMetadataPdf* self);
gint pdfpc_metadata_pdf_get_end_user_slide (pdfpcMetadataPdf* self);
void pdfpc_metadata_pdf_set_end_user_slide (pdfpcMetadataPdf* self, gint slide);
gint pdfpc_metadata_pdf_toggle_skip (pdfpcMetadataPdf* self, gint slide_number, gint user_slide_number);
gint pdfpc_metadata_pdf_user_slide_to_real_slide (pdfpcMetadataPdf* self, gint number);
gint pdfpc_metadata_pdf_real_slide_to_user_slide (pdfpcMetadataPdf* self, gint number);
gdouble pdfpc_metadata_pdf_get_page_width (pdfpcMetadataPdf* self);
gdouble pdfpc_metadata_pdf_get_page_height (pdfpcMetadataPdf* self);
PopplerDocument* pdfpc_metadata_pdf_get_document (pdfpcMetadataPdf* self);
pdfpcslides_notes* pdfpc_metadata_pdf_get_notes (pdfpcMetadataPdf* self);
guint pdfpc_metadata_pdf_get_duration (pdfpcMetadataPdf* self);
void pdfpc_metadata_pdf_set_duration (pdfpcMetadataPdf* self, guint d);
PopplerDocument* pdfpc_metadata_pdf_open_pdf_document (pdfpcMetadataPdf* self, const gchar* url);
void pdfpc_slides_notes_set_note (pdfpcslides_notes* self, const gchar* note, gint slide_number);
gchar* pdfpc_slides_notes_get_note_for_slide (pdfpcslides_notes* self, gint number);
gboolean pdfpc_slides_notes_has_notes (pdfpcslides_notes* self);
gchar* pdfpc_slides_notes_format_to_save (pdfpcslides_notes* self);
void pdfpc_slides_notes_parse_lines (pdfpcslides_notes* self, gchar** lines, int lines_length1);
pdfpcslides_notes* pdfpc_slides_notes_new (void);
pdfpcslides_notes* pdfpc_slides_notes_construct (GType object_type);
pdfpcMetadataBase* pdfpc_metadata_base_construct (GType object_type, const gchar* fname);
gchar* pdfpc_metadata_base_get_url (pdfpcMetadataBase* self);
guint pdfpc_metadata_base_get_slide_count (pdfpcMetadataBase* self);


G_END_DECLS

#endif