← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/poppler/glib/poppler-enums.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/poppler/glib/poppler-enums.c
 
1
 
 
2
/* Generated data (by glib-mkenums) */
 
3
 
 
4
#include <config.h>
 
5
 
 
6
#include "poppler-enums.h"
 
7
 
 
8
/* enumerations from "poppler-action.h" */
 
9
#include "poppler-action.h"
 
10
GType
 
11
poppler_action_type_get_type (void)
 
12
{
 
13
  static volatile gsize g_define_type_id__volatile = 0;
 
14
 
 
15
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
16
    static const GEnumValue values[] = {
 
17
      { POPPLER_ACTION_UNKNOWN, "POPPLER_ACTION_UNKNOWN", "unknown" },
 
18
      { POPPLER_ACTION_NONE, "POPPLER_ACTION_NONE", "none" },
 
19
      { POPPLER_ACTION_GOTO_DEST, "POPPLER_ACTION_GOTO_DEST", "goto-dest" },
 
20
      { POPPLER_ACTION_GOTO_REMOTE, "POPPLER_ACTION_GOTO_REMOTE", "goto-remote" },
 
21
      { POPPLER_ACTION_LAUNCH, "POPPLER_ACTION_LAUNCH", "launch" },
 
22
      { POPPLER_ACTION_URI, "POPPLER_ACTION_URI", "uri" },
 
23
      { POPPLER_ACTION_NAMED, "POPPLER_ACTION_NAMED", "named" },
 
24
      { POPPLER_ACTION_MOVIE, "POPPLER_ACTION_MOVIE", "movie" },
 
25
      { POPPLER_ACTION_RENDITION, "POPPLER_ACTION_RENDITION", "rendition" },
 
26
      { POPPLER_ACTION_OCG_STATE, "POPPLER_ACTION_OCG_STATE", "ocg-state" },
 
27
      { 0, NULL, NULL }
 
28
    };
 
29
    GType g_define_type_id = 
 
30
       g_enum_register_static (g_intern_static_string ("PopplerActionType"), values);
 
31
      
 
32
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
33
  }
 
34
    
 
35
  return g_define_type_id__volatile;
 
36
}
 
37
 
 
38
GType
 
39
poppler_dest_type_get_type (void)
 
40
{
 
41
  static volatile gsize g_define_type_id__volatile = 0;
 
42
 
 
43
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
44
    static const GEnumValue values[] = {
 
45
      { POPPLER_DEST_UNKNOWN, "POPPLER_DEST_UNKNOWN", "unknown" },
 
46
      { POPPLER_DEST_XYZ, "POPPLER_DEST_XYZ", "xyz" },
 
47
      { POPPLER_DEST_FIT, "POPPLER_DEST_FIT", "fit" },
 
48
      { POPPLER_DEST_FITH, "POPPLER_DEST_FITH", "fith" },
 
49
      { POPPLER_DEST_FITV, "POPPLER_DEST_FITV", "fitv" },
 
50
      { POPPLER_DEST_FITR, "POPPLER_DEST_FITR", "fitr" },
 
51
      { POPPLER_DEST_FITB, "POPPLER_DEST_FITB", "fitb" },
 
52
      { POPPLER_DEST_FITBH, "POPPLER_DEST_FITBH", "fitbh" },
 
53
      { POPPLER_DEST_FITBV, "POPPLER_DEST_FITBV", "fitbv" },
 
54
      { POPPLER_DEST_NAMED, "POPPLER_DEST_NAMED", "named" },
 
55
      { 0, NULL, NULL }
 
56
    };
 
57
    GType g_define_type_id = 
 
58
       g_enum_register_static (g_intern_static_string ("PopplerDestType"), values);
 
59
      
 
60
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
61
  }
 
62
    
 
63
  return g_define_type_id__volatile;
 
64
}
 
65
 
 
66
GType
 
67
poppler_action_movie_operation_get_type (void)
 
68
{
 
69
  static volatile gsize g_define_type_id__volatile = 0;
 
70
 
 
71
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
72
    static const GEnumValue values[] = {
 
73
      { POPPLER_ACTION_MOVIE_PLAY, "POPPLER_ACTION_MOVIE_PLAY", "play" },
 
74
      { POPPLER_ACTION_MOVIE_PAUSE, "POPPLER_ACTION_MOVIE_PAUSE", "pause" },
 
75
      { POPPLER_ACTION_MOVIE_RESUME, "POPPLER_ACTION_MOVIE_RESUME", "resume" },
 
76
      { POPPLER_ACTION_MOVIE_STOP, "POPPLER_ACTION_MOVIE_STOP", "stop" },
 
77
      { 0, NULL, NULL }
 
78
    };
 
79
    GType g_define_type_id = 
 
80
       g_enum_register_static (g_intern_static_string ("PopplerActionMovieOperation"), values);
 
81
      
 
82
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
83
  }
 
84
    
 
85
  return g_define_type_id__volatile;
 
86
}
 
87
 
 
88
GType
 
89
poppler_action_layer_action_get_type (void)
 
90
{
 
91
  static volatile gsize g_define_type_id__volatile = 0;
 
92
 
 
93
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
94
    static const GEnumValue values[] = {
 
95
      { POPPLER_ACTION_LAYER_ON, "POPPLER_ACTION_LAYER_ON", "on" },
 
96
      { POPPLER_ACTION_LAYER_OFF, "POPPLER_ACTION_LAYER_OFF", "off" },
 
97
      { POPPLER_ACTION_LAYER_TOGGLE, "POPPLER_ACTION_LAYER_TOGGLE", "toggle" },
 
98
      { 0, NULL, NULL }
 
99
    };
 
100
    GType g_define_type_id = 
 
101
       g_enum_register_static (g_intern_static_string ("PopplerActionLayerAction"), values);
 
102
      
 
103
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
104
  }
 
105
    
 
106
  return g_define_type_id__volatile;
 
107
}
 
108
 
 
109
/* enumerations from "poppler-document.h" */
 
110
#include "poppler-document.h"
 
111
GType
 
112
poppler_page_layout_get_type (void)
 
113
{
 
114
  static volatile gsize g_define_type_id__volatile = 0;
 
115
 
 
116
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
117
    static const GEnumValue values[] = {
 
118
      { POPPLER_PAGE_LAYOUT_UNSET, "POPPLER_PAGE_LAYOUT_UNSET", "unset" },
 
119
      { POPPLER_PAGE_LAYOUT_SINGLE_PAGE, "POPPLER_PAGE_LAYOUT_SINGLE_PAGE", "single-page" },
 
120
      { POPPLER_PAGE_LAYOUT_ONE_COLUMN, "POPPLER_PAGE_LAYOUT_ONE_COLUMN", "one-column" },
 
121
      { POPPLER_PAGE_LAYOUT_TWO_COLUMN_LEFT, "POPPLER_PAGE_LAYOUT_TWO_COLUMN_LEFT", "two-column-left" },
 
122
      { POPPLER_PAGE_LAYOUT_TWO_COLUMN_RIGHT, "POPPLER_PAGE_LAYOUT_TWO_COLUMN_RIGHT", "two-column-right" },
 
123
      { POPPLER_PAGE_LAYOUT_TWO_PAGE_LEFT, "POPPLER_PAGE_LAYOUT_TWO_PAGE_LEFT", "two-page-left" },
 
124
      { POPPLER_PAGE_LAYOUT_TWO_PAGE_RIGHT, "POPPLER_PAGE_LAYOUT_TWO_PAGE_RIGHT", "two-page-right" },
 
125
      { 0, NULL, NULL }
 
126
    };
 
127
    GType g_define_type_id = 
 
128
       g_enum_register_static (g_intern_static_string ("PopplerPageLayout"), values);
 
129
      
 
130
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
131
  }
 
132
    
 
133
  return g_define_type_id__volatile;
 
134
}
 
135
 
 
136
GType
 
137
poppler_page_mode_get_type (void)
 
138
{
 
139
  static volatile gsize g_define_type_id__volatile = 0;
 
140
 
 
141
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
142
    static const GEnumValue values[] = {
 
143
      { POPPLER_PAGE_MODE_UNSET, "POPPLER_PAGE_MODE_UNSET", "unset" },
 
144
      { POPPLER_PAGE_MODE_NONE, "POPPLER_PAGE_MODE_NONE", "none" },
 
145
      { POPPLER_PAGE_MODE_USE_OUTLINES, "POPPLER_PAGE_MODE_USE_OUTLINES", "use-outlines" },
 
146
      { POPPLER_PAGE_MODE_USE_THUMBS, "POPPLER_PAGE_MODE_USE_THUMBS", "use-thumbs" },
 
147
      { POPPLER_PAGE_MODE_FULL_SCREEN, "POPPLER_PAGE_MODE_FULL_SCREEN", "full-screen" },
 
148
      { POPPLER_PAGE_MODE_USE_OC, "POPPLER_PAGE_MODE_USE_OC", "use-oc" },
 
149
      { POPPLER_PAGE_MODE_USE_ATTACHMENTS, "POPPLER_PAGE_MODE_USE_ATTACHMENTS", "use-attachments" },
 
150
      { 0, NULL, NULL }
 
151
    };
 
152
    GType g_define_type_id = 
 
153
       g_enum_register_static (g_intern_static_string ("PopplerPageMode"), values);
 
154
      
 
155
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
156
  }
 
157
    
 
158
  return g_define_type_id__volatile;
 
159
}
 
160
 
 
161
GType
 
162
poppler_font_type_get_type (void)
 
163
{
 
164
  static volatile gsize g_define_type_id__volatile = 0;
 
165
 
 
166
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
167
    static const GEnumValue values[] = {
 
168
      { POPPLER_FONT_TYPE_UNKNOWN, "POPPLER_FONT_TYPE_UNKNOWN", "unknown" },
 
169
      { POPPLER_FONT_TYPE_TYPE1, "POPPLER_FONT_TYPE_TYPE1", "type1" },
 
170
      { POPPLER_FONT_TYPE_TYPE1C, "POPPLER_FONT_TYPE_TYPE1C", "type1c" },
 
171
      { POPPLER_FONT_TYPE_TYPE1COT, "POPPLER_FONT_TYPE_TYPE1COT", "type1cot" },
 
172
      { POPPLER_FONT_TYPE_TYPE3, "POPPLER_FONT_TYPE_TYPE3", "type3" },
 
173
      { POPPLER_FONT_TYPE_TRUETYPE, "POPPLER_FONT_TYPE_TRUETYPE", "truetype" },
 
174
      { POPPLER_FONT_TYPE_TRUETYPEOT, "POPPLER_FONT_TYPE_TRUETYPEOT", "truetypeot" },
 
175
      { POPPLER_FONT_TYPE_CID_TYPE0, "POPPLER_FONT_TYPE_CID_TYPE0", "cid-type0" },
 
176
      { POPPLER_FONT_TYPE_CID_TYPE0C, "POPPLER_FONT_TYPE_CID_TYPE0C", "cid-type0c" },
 
177
      { POPPLER_FONT_TYPE_CID_TYPE0COT, "POPPLER_FONT_TYPE_CID_TYPE0COT", "cid-type0cot" },
 
178
      { POPPLER_FONT_TYPE_CID_TYPE2, "POPPLER_FONT_TYPE_CID_TYPE2", "cid-type2" },
 
179
      { POPPLER_FONT_TYPE_CID_TYPE2OT, "POPPLER_FONT_TYPE_CID_TYPE2OT", "cid-type2ot" },
 
180
      { 0, NULL, NULL }
 
181
    };
 
182
    GType g_define_type_id = 
 
183
       g_enum_register_static (g_intern_static_string ("PopplerFontType"), values);
 
184
      
 
185
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
186
  }
 
187
    
 
188
  return g_define_type_id__volatile;
 
189
}
 
190
 
 
191
GType
 
192
poppler_viewer_preferences_get_type (void)
 
193
{
 
194
  static volatile gsize g_define_type_id__volatile = 0;
 
195
 
 
196
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
197
    static const GFlagsValue values[] = {
 
198
      { POPPLER_VIEWER_PREFERENCES_UNSET, "POPPLER_VIEWER_PREFERENCES_UNSET", "unset" },
 
199
      { POPPLER_VIEWER_PREFERENCES_HIDE_TOOLBAR, "POPPLER_VIEWER_PREFERENCES_HIDE_TOOLBAR", "hide-toolbar" },
 
200
      { POPPLER_VIEWER_PREFERENCES_HIDE_MENUBAR, "POPPLER_VIEWER_PREFERENCES_HIDE_MENUBAR", "hide-menubar" },
 
201
      { POPPLER_VIEWER_PREFERENCES_HIDE_WINDOWUI, "POPPLER_VIEWER_PREFERENCES_HIDE_WINDOWUI", "hide-windowui" },
 
202
      { POPPLER_VIEWER_PREFERENCES_FIT_WINDOW, "POPPLER_VIEWER_PREFERENCES_FIT_WINDOW", "fit-window" },
 
203
      { POPPLER_VIEWER_PREFERENCES_CENTER_WINDOW, "POPPLER_VIEWER_PREFERENCES_CENTER_WINDOW", "center-window" },
 
204
      { POPPLER_VIEWER_PREFERENCES_DISPLAY_DOC_TITLE, "POPPLER_VIEWER_PREFERENCES_DISPLAY_DOC_TITLE", "display-doc-title" },
 
205
      { POPPLER_VIEWER_PREFERENCES_DIRECTION_RTL, "POPPLER_VIEWER_PREFERENCES_DIRECTION_RTL", "direction-rtl" },
 
206
      { 0, NULL, NULL }
 
207
    };
 
208
    GType g_define_type_id = 
 
209
       g_flags_register_static (g_intern_static_string ("PopplerViewerPreferences"), values);
 
210
      
 
211
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
212
  }
 
213
    
 
214
  return g_define_type_id__volatile;
 
215
}
 
216
 
 
217
GType
 
218
poppler_permissions_get_type (void)
 
219
{
 
220
  static volatile gsize g_define_type_id__volatile = 0;
 
221
 
 
222
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
223
    static const GFlagsValue values[] = {
 
224
      { POPPLER_PERMISSIONS_OK_TO_PRINT, "POPPLER_PERMISSIONS_OK_TO_PRINT", "ok-to-print" },
 
225
      { POPPLER_PERMISSIONS_OK_TO_MODIFY, "POPPLER_PERMISSIONS_OK_TO_MODIFY", "ok-to-modify" },
 
226
      { POPPLER_PERMISSIONS_OK_TO_COPY, "POPPLER_PERMISSIONS_OK_TO_COPY", "ok-to-copy" },
 
227
      { POPPLER_PERMISSIONS_OK_TO_ADD_NOTES, "POPPLER_PERMISSIONS_OK_TO_ADD_NOTES", "ok-to-add-notes" },
 
228
      { POPPLER_PERMISSIONS_OK_TO_FILL_FORM, "POPPLER_PERMISSIONS_OK_TO_FILL_FORM", "ok-to-fill-form" },
 
229
      { POPPLER_PERMISSIONS_FULL, "POPPLER_PERMISSIONS_FULL", "full" },
 
230
      { 0, NULL, NULL }
 
231
    };
 
232
    GType g_define_type_id = 
 
233
       g_flags_register_static (g_intern_static_string ("PopplerPermissions"), values);
 
234
      
 
235
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
236
  }
 
237
    
 
238
  return g_define_type_id__volatile;
 
239
}
 
240
 
 
241
/* enumerations from "poppler-form-field.h" */
 
242
#include "poppler-form-field.h"
 
243
GType
 
244
poppler_form_field_type_get_type (void)
 
245
{
 
246
  static volatile gsize g_define_type_id__volatile = 0;
 
247
 
 
248
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
249
    static const GEnumValue values[] = {
 
250
      { POPPLER_FORM_FIELD_UNKNOWN, "POPPLER_FORM_FIELD_UNKNOWN", "unknown" },
 
251
      { POPPLER_FORM_FIELD_BUTTON, "POPPLER_FORM_FIELD_BUTTON", "button" },
 
252
      { POPPLER_FORM_FIELD_TEXT, "POPPLER_FORM_FIELD_TEXT", "text" },
 
253
      { POPPLER_FORM_FIELD_CHOICE, "POPPLER_FORM_FIELD_CHOICE", "choice" },
 
254
      { POPPLER_FORM_FIELD_SIGNATURE, "POPPLER_FORM_FIELD_SIGNATURE", "signature" },
 
255
      { 0, NULL, NULL }
 
256
    };
 
257
    GType g_define_type_id = 
 
258
       g_enum_register_static (g_intern_static_string ("PopplerFormFieldType"), values);
 
259
      
 
260
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
261
  }
 
262
    
 
263
  return g_define_type_id__volatile;
 
264
}
 
265
 
 
266
GType
 
267
poppler_form_button_type_get_type (void)
 
268
{
 
269
  static volatile gsize g_define_type_id__volatile = 0;
 
270
 
 
271
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
272
    static const GEnumValue values[] = {
 
273
      { POPPLER_FORM_BUTTON_PUSH, "POPPLER_FORM_BUTTON_PUSH", "push" },
 
274
      { POPPLER_FORM_BUTTON_CHECK, "POPPLER_FORM_BUTTON_CHECK", "check" },
 
275
      { POPPLER_FORM_BUTTON_RADIO, "POPPLER_FORM_BUTTON_RADIO", "radio" },
 
276
      { 0, NULL, NULL }
 
277
    };
 
278
    GType g_define_type_id = 
 
279
       g_enum_register_static (g_intern_static_string ("PopplerFormButtonType"), values);
 
280
      
 
281
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
282
  }
 
283
    
 
284
  return g_define_type_id__volatile;
 
285
}
 
286
 
 
287
GType
 
288
poppler_form_text_type_get_type (void)
 
289
{
 
290
  static volatile gsize g_define_type_id__volatile = 0;
 
291
 
 
292
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
293
    static const GEnumValue values[] = {
 
294
      { POPPLER_FORM_TEXT_NORMAL, "POPPLER_FORM_TEXT_NORMAL", "normal" },
 
295
      { POPPLER_FORM_TEXT_MULTILINE, "POPPLER_FORM_TEXT_MULTILINE", "multiline" },
 
296
      { POPPLER_FORM_TEXT_FILE_SELECT, "POPPLER_FORM_TEXT_FILE_SELECT", "file-select" },
 
297
      { 0, NULL, NULL }
 
298
    };
 
299
    GType g_define_type_id = 
 
300
       g_enum_register_static (g_intern_static_string ("PopplerFormTextType"), values);
 
301
      
 
302
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
303
  }
 
304
    
 
305
  return g_define_type_id__volatile;
 
306
}
 
307
 
 
308
GType
 
309
poppler_form_choice_type_get_type (void)
 
310
{
 
311
  static volatile gsize g_define_type_id__volatile = 0;
 
312
 
 
313
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
314
    static const GEnumValue values[] = {
 
315
      { POPPLER_FORM_CHOICE_COMBO, "POPPLER_FORM_CHOICE_COMBO", "combo" },
 
316
      { POPPLER_FORM_CHOICE_LIST, "POPPLER_FORM_CHOICE_LIST", "list" },
 
317
      { 0, NULL, NULL }
 
318
    };
 
319
    GType g_define_type_id = 
 
320
       g_enum_register_static (g_intern_static_string ("PopplerFormChoiceType"), values);
 
321
      
 
322
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
323
  }
 
324
    
 
325
  return g_define_type_id__volatile;
 
326
}
 
327
 
 
328
/* enumerations from "poppler-annot.h" */
 
329
#include "poppler-annot.h"
 
330
GType
 
331
poppler_annot_type_get_type (void)
 
332
{
 
333
  static volatile gsize g_define_type_id__volatile = 0;
 
334
 
 
335
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
336
    static const GEnumValue values[] = {
 
337
      { POPPLER_ANNOT_UNKNOWN, "POPPLER_ANNOT_UNKNOWN", "unknown" },
 
338
      { POPPLER_ANNOT_TEXT, "POPPLER_ANNOT_TEXT", "text" },
 
339
      { POPPLER_ANNOT_LINK, "POPPLER_ANNOT_LINK", "link" },
 
340
      { POPPLER_ANNOT_FREE_TEXT, "POPPLER_ANNOT_FREE_TEXT", "free-text" },
 
341
      { POPPLER_ANNOT_LINE, "POPPLER_ANNOT_LINE", "line" },
 
342
      { POPPLER_ANNOT_SQUARE, "POPPLER_ANNOT_SQUARE", "square" },
 
343
      { POPPLER_ANNOT_CIRCLE, "POPPLER_ANNOT_CIRCLE", "circle" },
 
344
      { POPPLER_ANNOT_POLYGON, "POPPLER_ANNOT_POLYGON", "polygon" },
 
345
      { POPPLER_ANNOT_POLY_LINE, "POPPLER_ANNOT_POLY_LINE", "poly-line" },
 
346
      { POPPLER_ANNOT_HIGHLIGHT, "POPPLER_ANNOT_HIGHLIGHT", "highlight" },
 
347
      { POPPLER_ANNOT_UNDERLINE, "POPPLER_ANNOT_UNDERLINE", "underline" },
 
348
      { POPPLER_ANNOT_SQUIGGLY, "POPPLER_ANNOT_SQUIGGLY", "squiggly" },
 
349
      { POPPLER_ANNOT_STRIKE_OUT, "POPPLER_ANNOT_STRIKE_OUT", "strike-out" },
 
350
      { POPPLER_ANNOT_STAMP, "POPPLER_ANNOT_STAMP", "stamp" },
 
351
      { POPPLER_ANNOT_CARET, "POPPLER_ANNOT_CARET", "caret" },
 
352
      { POPPLER_ANNOT_INK, "POPPLER_ANNOT_INK", "ink" },
 
353
      { POPPLER_ANNOT_POPUP, "POPPLER_ANNOT_POPUP", "popup" },
 
354
      { POPPLER_ANNOT_FILE_ATTACHMENT, "POPPLER_ANNOT_FILE_ATTACHMENT", "file-attachment" },
 
355
      { POPPLER_ANNOT_SOUND, "POPPLER_ANNOT_SOUND", "sound" },
 
356
      { POPPLER_ANNOT_MOVIE, "POPPLER_ANNOT_MOVIE", "movie" },
 
357
      { POPPLER_ANNOT_WIDGET, "POPPLER_ANNOT_WIDGET", "widget" },
 
358
      { POPPLER_ANNOT_SCREEN, "POPPLER_ANNOT_SCREEN", "screen" },
 
359
      { POPPLER_ANNOT_PRINTER_MARK, "POPPLER_ANNOT_PRINTER_MARK", "printer-mark" },
 
360
      { POPPLER_ANNOT_TRAP_NET, "POPPLER_ANNOT_TRAP_NET", "trap-net" },
 
361
      { POPPLER_ANNOT_WATERMARK, "POPPLER_ANNOT_WATERMARK", "watermark" },
 
362
      { POPPLER_ANNOT_3D, "POPPLER_ANNOT_3D", "3d" },
 
363
      { 0, NULL, NULL }
 
364
    };
 
365
    GType g_define_type_id = 
 
366
       g_enum_register_static (g_intern_static_string ("PopplerAnnotType"), values);
 
367
      
 
368
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
369
  }
 
370
    
 
371
  return g_define_type_id__volatile;
 
372
}
 
373
 
 
374
GType
 
375
poppler_annot_flag_get_type (void)
 
376
{
 
377
  static volatile gsize g_define_type_id__volatile = 0;
 
378
 
 
379
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
380
    static const GFlagsValue values[] = {
 
381
      { POPPLER_ANNOT_FLAG_UNKNOWN, "POPPLER_ANNOT_FLAG_UNKNOWN", "unknown" },
 
382
      { POPPLER_ANNOT_FLAG_INVISIBLE, "POPPLER_ANNOT_FLAG_INVISIBLE", "invisible" },
 
383
      { POPPLER_ANNOT_FLAG_HIDDEN, "POPPLER_ANNOT_FLAG_HIDDEN", "hidden" },
 
384
      { POPPLER_ANNOT_FLAG_PRINT, "POPPLER_ANNOT_FLAG_PRINT", "print" },
 
385
      { POPPLER_ANNOT_FLAG_NO_ZOOM, "POPPLER_ANNOT_FLAG_NO_ZOOM", "no-zoom" },
 
386
      { POPPLER_ANNOT_FLAG_NO_ROTATE, "POPPLER_ANNOT_FLAG_NO_ROTATE", "no-rotate" },
 
387
      { POPPLER_ANNOT_FLAG_NO_VIEW, "POPPLER_ANNOT_FLAG_NO_VIEW", "no-view" },
 
388
      { POPPLER_ANNOT_FLAG_READ_ONLY, "POPPLER_ANNOT_FLAG_READ_ONLY", "read-only" },
 
389
      { POPPLER_ANNOT_FLAG_LOCKED, "POPPLER_ANNOT_FLAG_LOCKED", "locked" },
 
390
      { POPPLER_ANNOT_FLAG_TOGGLE_NO_VIEW, "POPPLER_ANNOT_FLAG_TOGGLE_NO_VIEW", "toggle-no-view" },
 
391
      { POPPLER_ANNOT_FLAG_LOCKED_CONTENTS, "POPPLER_ANNOT_FLAG_LOCKED_CONTENTS", "locked-contents" },
 
392
      { 0, NULL, NULL }
 
393
    };
 
394
    GType g_define_type_id = 
 
395
       g_flags_register_static (g_intern_static_string ("PopplerAnnotFlag"), values);
 
396
      
 
397
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
398
  }
 
399
    
 
400
  return g_define_type_id__volatile;
 
401
}
 
402
 
 
403
GType
 
404
poppler_annot_markup_reply_type_get_type (void)
 
405
{
 
406
  static volatile gsize g_define_type_id__volatile = 0;
 
407
 
 
408
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
409
    static const GEnumValue values[] = {
 
410
      { POPPLER_ANNOT_MARKUP_REPLY_TYPE_R, "POPPLER_ANNOT_MARKUP_REPLY_TYPE_R", "r" },
 
411
      { POPPLER_ANNOT_MARKUP_REPLY_TYPE_GROUP, "POPPLER_ANNOT_MARKUP_REPLY_TYPE_GROUP", "group" },
 
412
      { 0, NULL, NULL }
 
413
    };
 
414
    GType g_define_type_id = 
 
415
       g_enum_register_static (g_intern_static_string ("PopplerAnnotMarkupReplyType"), values);
 
416
      
 
417
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
418
  }
 
419
    
 
420
  return g_define_type_id__volatile;
 
421
}
 
422
 
 
423
GType
 
424
poppler_annot_external_data_type_get_type (void)
 
425
{
 
426
  static volatile gsize g_define_type_id__volatile = 0;
 
427
 
 
428
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
429
    static const GEnumValue values[] = {
 
430
      { POPPLER_ANNOT_EXTERNAL_DATA_MARKUP_3D, "POPPLER_ANNOT_EXTERNAL_DATA_MARKUP_3D", "3d" },
 
431
      { POPPLER_ANNOT_EXTERNAL_DATA_MARKUP_UNKNOWN, "POPPLER_ANNOT_EXTERNAL_DATA_MARKUP_UNKNOWN", "unknown" },
 
432
      { 0, NULL, NULL }
 
433
    };
 
434
    GType g_define_type_id = 
 
435
       g_enum_register_static (g_intern_static_string ("PopplerAnnotExternalDataType"), values);
 
436
      
 
437
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
438
  }
 
439
    
 
440
  return g_define_type_id__volatile;
 
441
}
 
442
 
 
443
GType
 
444
poppler_annot_text_state_get_type (void)
 
445
{
 
446
  static volatile gsize g_define_type_id__volatile = 0;
 
447
 
 
448
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
449
    static const GEnumValue values[] = {
 
450
      { POPPLER_ANNOT_TEXT_STATE_MARKED, "POPPLER_ANNOT_TEXT_STATE_MARKED", "marked" },
 
451
      { POPPLER_ANNOT_TEXT_STATE_UNMARKED, "POPPLER_ANNOT_TEXT_STATE_UNMARKED", "unmarked" },
 
452
      { POPPLER_ANNOT_TEXT_STATE_ACCEPTED, "POPPLER_ANNOT_TEXT_STATE_ACCEPTED", "accepted" },
 
453
      { POPPLER_ANNOT_TEXT_STATE_REJECTED, "POPPLER_ANNOT_TEXT_STATE_REJECTED", "rejected" },
 
454
      { POPPLER_ANNOT_TEXT_STATE_CANCELLED, "POPPLER_ANNOT_TEXT_STATE_CANCELLED", "cancelled" },
 
455
      { POPPLER_ANNOT_TEXT_STATE_COMPLETED, "POPPLER_ANNOT_TEXT_STATE_COMPLETED", "completed" },
 
456
      { POPPLER_ANNOT_TEXT_STATE_NONE, "POPPLER_ANNOT_TEXT_STATE_NONE", "none" },
 
457
      { POPPLER_ANNOT_TEXT_STATE_UNKNOWN, "POPPLER_ANNOT_TEXT_STATE_UNKNOWN", "unknown" },
 
458
      { 0, NULL, NULL }
 
459
    };
 
460
    GType g_define_type_id = 
 
461
       g_enum_register_static (g_intern_static_string ("PopplerAnnotTextState"), values);
 
462
      
 
463
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
464
  }
 
465
    
 
466
  return g_define_type_id__volatile;
 
467
}
 
468
 
 
469
GType
 
470
poppler_annot_free_text_quadding_get_type (void)
 
471
{
 
472
  static volatile gsize g_define_type_id__volatile = 0;
 
473
 
 
474
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
475
    static const GEnumValue values[] = {
 
476
      { POPPLER_ANNOT_FREE_TEXT_QUADDING_LEFT_JUSTIFIED, "POPPLER_ANNOT_FREE_TEXT_QUADDING_LEFT_JUSTIFIED", "left-justified" },
 
477
      { POPPLER_ANNOT_FREE_TEXT_QUADDING_CENTERED, "POPPLER_ANNOT_FREE_TEXT_QUADDING_CENTERED", "centered" },
 
478
      { POPPLER_ANNOT_FREE_TEXT_QUADDING_RIGHT_JUSTIFIED, "POPPLER_ANNOT_FREE_TEXT_QUADDING_RIGHT_JUSTIFIED", "right-justified" },
 
479
      { 0, NULL, NULL }
 
480
    };
 
481
    GType g_define_type_id = 
 
482
       g_enum_register_static (g_intern_static_string ("PopplerAnnotFreeTextQuadding"), values);
 
483
      
 
484
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
485
  }
 
486
    
 
487
  return g_define_type_id__volatile;
 
488
}
 
489
 
 
490
/* enumerations from "poppler.h" */
 
491
#include "poppler.h"
 
492
GType
 
493
poppler_error_get_type (void)
 
494
{
 
495
  static volatile gsize g_define_type_id__volatile = 0;
 
496
 
 
497
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
498
    static const GEnumValue values[] = {
 
499
      { POPPLER_ERROR_INVALID, "POPPLER_ERROR_INVALID", "invalid" },
 
500
      { POPPLER_ERROR_ENCRYPTED, "POPPLER_ERROR_ENCRYPTED", "encrypted" },
 
501
      { POPPLER_ERROR_OPEN_FILE, "POPPLER_ERROR_OPEN_FILE", "open-file" },
 
502
      { POPPLER_ERROR_BAD_CATALOG, "POPPLER_ERROR_BAD_CATALOG", "bad-catalog" },
 
503
      { POPPLER_ERROR_DAMAGED, "POPPLER_ERROR_DAMAGED", "damaged" },
 
504
      { 0, NULL, NULL }
 
505
    };
 
506
    GType g_define_type_id = 
 
507
       g_enum_register_static (g_intern_static_string ("PopplerError"), values);
 
508
      
 
509
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
510
  }
 
511
    
 
512
  return g_define_type_id__volatile;
 
513
}
 
514
 
 
515
GType
 
516
poppler_orientation_get_type (void)
 
517
{
 
518
  static volatile gsize g_define_type_id__volatile = 0;
 
519
 
 
520
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
521
    static const GEnumValue values[] = {
 
522
      { POPPLER_ORIENTATION_PORTRAIT, "POPPLER_ORIENTATION_PORTRAIT", "portrait" },
 
523
      { POPPLER_ORIENTATION_LANDSCAPE, "POPPLER_ORIENTATION_LANDSCAPE", "landscape" },
 
524
      { POPPLER_ORIENTATION_UPSIDEDOWN, "POPPLER_ORIENTATION_UPSIDEDOWN", "upsidedown" },
 
525
      { POPPLER_ORIENTATION_SEASCAPE, "POPPLER_ORIENTATION_SEASCAPE", "seascape" },
 
526
      { 0, NULL, NULL }
 
527
    };
 
528
    GType g_define_type_id = 
 
529
       g_enum_register_static (g_intern_static_string ("PopplerOrientation"), values);
 
530
      
 
531
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
532
  }
 
533
    
 
534
  return g_define_type_id__volatile;
 
535
}
 
536
 
 
537
GType
 
538
poppler_page_transition_type_get_type (void)
 
539
{
 
540
  static volatile gsize g_define_type_id__volatile = 0;
 
541
 
 
542
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
543
    static const GEnumValue values[] = {
 
544
      { POPPLER_PAGE_TRANSITION_REPLACE, "POPPLER_PAGE_TRANSITION_REPLACE", "replace" },
 
545
      { POPPLER_PAGE_TRANSITION_SPLIT, "POPPLER_PAGE_TRANSITION_SPLIT", "split" },
 
546
      { POPPLER_PAGE_TRANSITION_BLINDS, "POPPLER_PAGE_TRANSITION_BLINDS", "blinds" },
 
547
      { POPPLER_PAGE_TRANSITION_BOX, "POPPLER_PAGE_TRANSITION_BOX", "box" },
 
548
      { POPPLER_PAGE_TRANSITION_WIPE, "POPPLER_PAGE_TRANSITION_WIPE", "wipe" },
 
549
      { POPPLER_PAGE_TRANSITION_DISSOLVE, "POPPLER_PAGE_TRANSITION_DISSOLVE", "dissolve" },
 
550
      { POPPLER_PAGE_TRANSITION_GLITTER, "POPPLER_PAGE_TRANSITION_GLITTER", "glitter" },
 
551
      { POPPLER_PAGE_TRANSITION_FLY, "POPPLER_PAGE_TRANSITION_FLY", "fly" },
 
552
      { POPPLER_PAGE_TRANSITION_PUSH, "POPPLER_PAGE_TRANSITION_PUSH", "push" },
 
553
      { POPPLER_PAGE_TRANSITION_COVER, "POPPLER_PAGE_TRANSITION_COVER", "cover" },
 
554
      { POPPLER_PAGE_TRANSITION_UNCOVER, "POPPLER_PAGE_TRANSITION_UNCOVER", "uncover" },
 
555
      { POPPLER_PAGE_TRANSITION_FADE, "POPPLER_PAGE_TRANSITION_FADE", "fade" },
 
556
      { 0, NULL, NULL }
 
557
    };
 
558
    GType g_define_type_id = 
 
559
       g_enum_register_static (g_intern_static_string ("PopplerPageTransitionType"), values);
 
560
      
 
561
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
562
  }
 
563
    
 
564
  return g_define_type_id__volatile;
 
565
}
 
566
 
 
567
GType
 
568
poppler_page_transition_alignment_get_type (void)
 
569
{
 
570
  static volatile gsize g_define_type_id__volatile = 0;
 
571
 
 
572
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
573
    static const GEnumValue values[] = {
 
574
      { POPPLER_PAGE_TRANSITION_HORIZONTAL, "POPPLER_PAGE_TRANSITION_HORIZONTAL", "horizontal" },
 
575
      { POPPLER_PAGE_TRANSITION_VERTICAL, "POPPLER_PAGE_TRANSITION_VERTICAL", "vertical" },
 
576
      { 0, NULL, NULL }
 
577
    };
 
578
    GType g_define_type_id = 
 
579
       g_enum_register_static (g_intern_static_string ("PopplerPageTransitionAlignment"), values);
 
580
      
 
581
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
582
  }
 
583
    
 
584
  return g_define_type_id__volatile;
 
585
}
 
586
 
 
587
GType
 
588
poppler_page_transition_direction_get_type (void)
 
589
{
 
590
  static volatile gsize g_define_type_id__volatile = 0;
 
591
 
 
592
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
593
    static const GEnumValue values[] = {
 
594
      { POPPLER_PAGE_TRANSITION_INWARD, "POPPLER_PAGE_TRANSITION_INWARD", "inward" },
 
595
      { POPPLER_PAGE_TRANSITION_OUTWARD, "POPPLER_PAGE_TRANSITION_OUTWARD", "outward" },
 
596
      { 0, NULL, NULL }
 
597
    };
 
598
    GType g_define_type_id = 
 
599
       g_enum_register_static (g_intern_static_string ("PopplerPageTransitionDirection"), values);
 
600
      
 
601
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
602
  }
 
603
    
 
604
  return g_define_type_id__volatile;
 
605
}
 
606
 
 
607
GType
 
608
poppler_selection_style_get_type (void)
 
609
{
 
610
  static volatile gsize g_define_type_id__volatile = 0;
 
611
 
 
612
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
613
    static const GEnumValue values[] = {
 
614
      { POPPLER_SELECTION_GLYPH, "POPPLER_SELECTION_GLYPH", "glyph" },
 
615
      { POPPLER_SELECTION_WORD, "POPPLER_SELECTION_WORD", "word" },
 
616
      { POPPLER_SELECTION_LINE, "POPPLER_SELECTION_LINE", "line" },
 
617
      { 0, NULL, NULL }
 
618
    };
 
619
    GType g_define_type_id = 
 
620
       g_enum_register_static (g_intern_static_string ("PopplerSelectionStyle"), values);
 
621
      
 
622
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
623
  }
 
624
    
 
625
  return g_define_type_id__volatile;
 
626
}
 
627
 
 
628
GType
 
629
poppler_print_flags_get_type (void)
 
630
{
 
631
  static volatile gsize g_define_type_id__volatile = 0;
 
632
 
 
633
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
634
    static const GFlagsValue values[] = {
 
635
      { POPPLER_PRINT_DOCUMENT, "POPPLER_PRINT_DOCUMENT", "document" },
 
636
      { POPPLER_PRINT_MARKUP_ANNOTS, "POPPLER_PRINT_MARKUP_ANNOTS", "markup-annots" },
 
637
      { POPPLER_PRINT_STAMP_ANNOTS_ONLY, "POPPLER_PRINT_STAMP_ANNOTS_ONLY", "stamp-annots-only" },
 
638
      { POPPLER_PRINT_ALL, "POPPLER_PRINT_ALL", "all" },
 
639
      { 0, NULL, NULL }
 
640
    };
 
641
    GType g_define_type_id = 
 
642
       g_flags_register_static (g_intern_static_string ("PopplerPrintFlags"), values);
 
643
      
 
644
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
645
  }
 
646
    
 
647
  return g_define_type_id__volatile;
 
648
}
 
649
 
 
650
GType
 
651
poppler_backend_get_type (void)
 
652
{
 
653
  static volatile gsize g_define_type_id__volatile = 0;
 
654
 
 
655
  if (g_once_init_enter (&g_define_type_id__volatile)) {
 
656
    static const GEnumValue values[] = {
 
657
      { POPPLER_BACKEND_UNKNOWN, "POPPLER_BACKEND_UNKNOWN", "unknown" },
 
658
      { POPPLER_BACKEND_SPLASH, "POPPLER_BACKEND_SPLASH", "splash" },
 
659
      { POPPLER_BACKEND_CAIRO, "POPPLER_BACKEND_CAIRO", "cairo" },
 
660
      { 0, NULL, NULL }
 
661
    };
 
662
    GType g_define_type_id = 
 
663
       g_enum_register_static (g_intern_static_string ("PopplerBackend"), values);
 
664
      
 
665
    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 
666
  }
 
667
    
 
668
  return g_define_type_id__volatile;
 
669
}
 
670
 
 
671
 
 
672
 
 
673
/* Generated data ends here */
 
674