~elementary-os/elementaryos/os-patch-at-spi2-core-xenial

« back to all changes in this revision

Viewing changes to atspi/atspi-enum-types.c

  • Committer: RabbitBot
  • Date: 2016-11-16 09:38:52 UTC
  • Revision ID: rabbitbot@elementary.io-20161116093852-xn6hcgpg5y25xooo
Initial import, version 2.18.3-4ubuntu1

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
 
 
2
/* Generated data (by glib-mkenums) */
 
3
 
 
4
#include "atspi-enum-types.h"
 
5
 
 
6
/* enumerations from "atspi-constants.h" */
 
7
#include "atspi-constants.h"
 
8
 
 
9
GType
 
10
atspi_locale_type_get_type (void)
 
11
{
 
12
        static GType the_type = 0;
 
13
        
 
14
        if (the_type == 0)
 
15
        {
 
16
                static const GEnumValue values[] = {
 
17
                        { ATSPI_LOCALE_TYPE_MESSAGES,
 
18
                          "ATSPI_LOCALE_TYPE_MESSAGES",
 
19
                          "messages" },
 
20
                        { ATSPI_LOCALE_TYPE_COLLATE,
 
21
                          "ATSPI_LOCALE_TYPE_COLLATE",
 
22
                          "collate" },
 
23
                        { ATSPI_LOCALE_TYPE_CTYPE,
 
24
                          "ATSPI_LOCALE_TYPE_CTYPE",
 
25
                          "ctype" },
 
26
                        { ATSPI_LOCALE_TYPE_MONETARY,
 
27
                          "ATSPI_LOCALE_TYPE_MONETARY",
 
28
                          "monetary" },
 
29
                        { ATSPI_LOCALE_TYPE_NUMERIC,
 
30
                          "ATSPI_LOCALE_TYPE_NUMERIC",
 
31
                          "numeric" },
 
32
                        { ATSPI_LOCALE_TYPE_TIME,
 
33
                          "ATSPI_LOCALE_TYPE_TIME",
 
34
                          "time" },
 
35
                        { 0, NULL, NULL }
 
36
                };
 
37
                the_type = g_enum_register_static (
 
38
                                g_intern_static_string ("AtspiLocaleType"),
 
39
                                values);
 
40
        }
 
41
        return the_type;
 
42
}
 
43
 
 
44
GType
 
45
atspi_coord_type_get_type (void)
 
46
{
 
47
        static GType the_type = 0;
 
48
        
 
49
        if (the_type == 0)
 
50
        {
 
51
                static const GEnumValue values[] = {
 
52
                        { ATSPI_COORD_TYPE_SCREEN,
 
53
                          "ATSPI_COORD_TYPE_SCREEN",
 
54
                          "screen" },
 
55
                        { ATSPI_COORD_TYPE_WINDOW,
 
56
                          "ATSPI_COORD_TYPE_WINDOW",
 
57
                          "window" },
 
58
                        { 0, NULL, NULL }
 
59
                };
 
60
                the_type = g_enum_register_static (
 
61
                                g_intern_static_string ("AtspiCoordType"),
 
62
                                values);
 
63
        }
 
64
        return the_type;
 
65
}
 
66
 
 
67
GType
 
68
atspi_collection_sort_order_get_type (void)
 
69
{
 
70
        static GType the_type = 0;
 
71
        
 
72
        if (the_type == 0)
 
73
        {
 
74
                static const GEnumValue values[] = {
 
75
                        { ATSPI_Collection_SORT_ORDER_INVALID,
 
76
                          "ATSPI_Collection_SORT_ORDER_INVALID",
 
77
                          "invalid" },
 
78
                        { ATSPI_Collection_SORT_ORDER_CANONICAL,
 
79
                          "ATSPI_Collection_SORT_ORDER_CANONICAL",
 
80
                          "canonical" },
 
81
                        { ATSPI_Collection_SORT_ORDER_FLOW,
 
82
                          "ATSPI_Collection_SORT_ORDER_FLOW",
 
83
                          "flow" },
 
84
                        { ATSPI_Collection_SORT_ORDER_TAB,
 
85
                          "ATSPI_Collection_SORT_ORDER_TAB",
 
86
                          "tab" },
 
87
                        { ATSPI_Collection_SORT_ORDER_REVERSE_CANONICAL,
 
88
                          "ATSPI_Collection_SORT_ORDER_REVERSE_CANONICAL",
 
89
                          "reverse-canonical" },
 
90
                        { ATSPI_Collection_SORT_ORDER_REVERSE_FLOW,
 
91
                          "ATSPI_Collection_SORT_ORDER_REVERSE_FLOW",
 
92
                          "reverse-flow" },
 
93
                        { ATSPI_Collection_SORT_ORDER_REVERSE_TAB,
 
94
                          "ATSPI_Collection_SORT_ORDER_REVERSE_TAB",
 
95
                          "reverse-tab" },
 
96
                        { ATSPI_Collection_SORT_ORDER_LAST_DEFINED,
 
97
                          "ATSPI_Collection_SORT_ORDER_LAST_DEFINED",
 
98
                          "last-defined" },
 
99
                        { 0, NULL, NULL }
 
100
                };
 
101
                the_type = g_enum_register_static (
 
102
                                g_intern_static_string ("AtspiCollectionSortOrder"),
 
103
                                values);
 
104
        }
 
105
        return the_type;
 
106
}
 
107
 
 
108
GType
 
109
atspi_collection_match_type_get_type (void)
 
110
{
 
111
        static GType the_type = 0;
 
112
        
 
113
        if (the_type == 0)
 
114
        {
 
115
                static const GEnumValue values[] = {
 
116
                        { ATSPI_Collection_MATCH_INVALID,
 
117
                          "ATSPI_Collection_MATCH_INVALID",
 
118
                          "invalid" },
 
119
                        { ATSPI_Collection_MATCH_ALL,
 
120
                          "ATSPI_Collection_MATCH_ALL",
 
121
                          "all" },
 
122
                        { ATSPI_Collection_MATCH_ANY,
 
123
                          "ATSPI_Collection_MATCH_ANY",
 
124
                          "any" },
 
125
                        { ATSPI_Collection_MATCH_NONE,
 
126
                          "ATSPI_Collection_MATCH_NONE",
 
127
                          "none" },
 
128
                        { ATSPI_Collection_MATCH_EMPTY,
 
129
                          "ATSPI_Collection_MATCH_EMPTY",
 
130
                          "empty" },
 
131
                        { ATSPI_Collection_MATCH_LAST_DEFINED,
 
132
                          "ATSPI_Collection_MATCH_LAST_DEFINED",
 
133
                          "last-defined" },
 
134
                        { 0, NULL, NULL }
 
135
                };
 
136
                the_type = g_enum_register_static (
 
137
                                g_intern_static_string ("AtspiCollectionMatchType"),
 
138
                                values);
 
139
        }
 
140
        return the_type;
 
141
}
 
142
 
 
143
GType
 
144
atspi_collection_tree_traversal_type_get_type (void)
 
145
{
 
146
        static GType the_type = 0;
 
147
        
 
148
        if (the_type == 0)
 
149
        {
 
150
                static const GEnumValue values[] = {
 
151
                        { ATSPI_Collection_TREE_RESTRICT_CHILDREN,
 
152
                          "ATSPI_Collection_TREE_RESTRICT_CHILDREN",
 
153
                          "restrict-children" },
 
154
                        { ATSPI_Collection_TREE_RESTRICT_SIBLING,
 
155
                          "ATSPI_Collection_TREE_RESTRICT_SIBLING",
 
156
                          "restrict-sibling" },
 
157
                        { ATSPI_Collection_TREE_INORDER,
 
158
                          "ATSPI_Collection_TREE_INORDER",
 
159
                          "inorder" },
 
160
                        { ATSPI_Collection_TREE_LAST_DEFINED,
 
161
                          "ATSPI_Collection_TREE_LAST_DEFINED",
 
162
                          "last-defined" },
 
163
                        { 0, NULL, NULL }
 
164
                };
 
165
                the_type = g_enum_register_static (
 
166
                                g_intern_static_string ("AtspiCollectionTreeTraversalType"),
 
167
                                values);
 
168
        }
 
169
        return the_type;
 
170
}
 
171
 
 
172
GType
 
173
atspi_component_layer_get_type (void)
 
174
{
 
175
        static GType the_type = 0;
 
176
        
 
177
        if (the_type == 0)
 
178
        {
 
179
                static const GEnumValue values[] = {
 
180
                        { ATSPI_LAYER_INVALID,
 
181
                          "ATSPI_LAYER_INVALID",
 
182
                          "invalid" },
 
183
                        { ATSPI_LAYER_BACKGROUND,
 
184
                          "ATSPI_LAYER_BACKGROUND",
 
185
                          "background" },
 
186
                        { ATSPI_LAYER_CANVAS,
 
187
                          "ATSPI_LAYER_CANVAS",
 
188
                          "canvas" },
 
189
                        { ATSPI_LAYER_WIDGET,
 
190
                          "ATSPI_LAYER_WIDGET",
 
191
                          "widget" },
 
192
                        { ATSPI_LAYER_MDI,
 
193
                          "ATSPI_LAYER_MDI",
 
194
                          "mdi" },
 
195
                        { ATSPI_LAYER_POPUP,
 
196
                          "ATSPI_LAYER_POPUP",
 
197
                          "popup" },
 
198
                        { ATSPI_LAYER_OVERLAY,
 
199
                          "ATSPI_LAYER_OVERLAY",
 
200
                          "overlay" },
 
201
                        { ATSPI_LAYER_WINDOW,
 
202
                          "ATSPI_LAYER_WINDOW",
 
203
                          "window" },
 
204
                        { ATSPI_LAYER_LAST_DEFINED,
 
205
                          "ATSPI_LAYER_LAST_DEFINED",
 
206
                          "last-defined" },
 
207
                        { 0, NULL, NULL }
 
208
                };
 
209
                the_type = g_enum_register_static (
 
210
                                g_intern_static_string ("AtspiComponentLayer"),
 
211
                                values);
 
212
        }
 
213
        return the_type;
 
214
}
 
215
 
 
216
GType
 
217
atspi_text_boundary_type_get_type (void)
 
218
{
 
219
        static GType the_type = 0;
 
220
        
 
221
        if (the_type == 0)
 
222
        {
 
223
                static const GEnumValue values[] = {
 
224
                        { ATSPI_TEXT_BOUNDARY_CHAR,
 
225
                          "ATSPI_TEXT_BOUNDARY_CHAR",
 
226
                          "char" },
 
227
                        { ATSPI_TEXT_BOUNDARY_WORD_START,
 
228
                          "ATSPI_TEXT_BOUNDARY_WORD_START",
 
229
                          "word-start" },
 
230
                        { ATSPI_TEXT_BOUNDARY_WORD_END,
 
231
                          "ATSPI_TEXT_BOUNDARY_WORD_END",
 
232
                          "word-end" },
 
233
                        { ATSPI_TEXT_BOUNDARY_SENTENCE_START,
 
234
                          "ATSPI_TEXT_BOUNDARY_SENTENCE_START",
 
235
                          "sentence-start" },
 
236
                        { ATSPI_TEXT_BOUNDARY_SENTENCE_END,
 
237
                          "ATSPI_TEXT_BOUNDARY_SENTENCE_END",
 
238
                          "sentence-end" },
 
239
                        { ATSPI_TEXT_BOUNDARY_LINE_START,
 
240
                          "ATSPI_TEXT_BOUNDARY_LINE_START",
 
241
                          "line-start" },
 
242
                        { ATSPI_TEXT_BOUNDARY_LINE_END,
 
243
                          "ATSPI_TEXT_BOUNDARY_LINE_END",
 
244
                          "line-end" },
 
245
                        { 0, NULL, NULL }
 
246
                };
 
247
                the_type = g_enum_register_static (
 
248
                                g_intern_static_string ("AtspiTextBoundaryType"),
 
249
                                values);
 
250
        }
 
251
        return the_type;
 
252
}
 
253
 
 
254
GType
 
255
atspi_text_granularity_get_type (void)
 
256
{
 
257
        static GType the_type = 0;
 
258
        
 
259
        if (the_type == 0)
 
260
        {
 
261
                static const GEnumValue values[] = {
 
262
                        { ATSPI_TEXT_GRANULARITY_CHAR,
 
263
                          "ATSPI_TEXT_GRANULARITY_CHAR",
 
264
                          "char" },
 
265
                        { ATSPI_TEXT_GRANULARITY_WORD,
 
266
                          "ATSPI_TEXT_GRANULARITY_WORD",
 
267
                          "word" },
 
268
                        { ATSPI_TEXT_GRANULARITY_SENTENCE,
 
269
                          "ATSPI_TEXT_GRANULARITY_SENTENCE",
 
270
                          "sentence" },
 
271
                        { ATSPI_TEXT_GRANULARITY_LINE,
 
272
                          "ATSPI_TEXT_GRANULARITY_LINE",
 
273
                          "line" },
 
274
                        { ATSPI_TEXT_GRANULARITY_PARAGRAPH,
 
275
                          "ATSPI_TEXT_GRANULARITY_PARAGRAPH",
 
276
                          "paragraph" },
 
277
                        { 0, NULL, NULL }
 
278
                };
 
279
                the_type = g_enum_register_static (
 
280
                                g_intern_static_string ("AtspiTextGranularity"),
 
281
                                values);
 
282
        }
 
283
        return the_type;
 
284
}
 
285
 
 
286
GType
 
287
atspi_text_clip_type_get_type (void)
 
288
{
 
289
        static GType the_type = 0;
 
290
        
 
291
        if (the_type == 0)
 
292
        {
 
293
                static const GEnumValue values[] = {
 
294
                        { ATSPI_TEXT_CLIP_NONE,
 
295
                          "ATSPI_TEXT_CLIP_NONE",
 
296
                          "none" },
 
297
                        { ATSPI_TEXT_CLIP_MIN,
 
298
                          "ATSPI_TEXT_CLIP_MIN",
 
299
                          "min" },
 
300
                        { ATSPI_TEXT_CLIP_MAX,
 
301
                          "ATSPI_TEXT_CLIP_MAX",
 
302
                          "max" },
 
303
                        { ATSPI_TEXT_CLIP_BOTH,
 
304
                          "ATSPI_TEXT_CLIP_BOTH",
 
305
                          "both" },
 
306
                        { 0, NULL, NULL }
 
307
                };
 
308
                the_type = g_enum_register_static (
 
309
                                g_intern_static_string ("AtspiTextClipType"),
 
310
                                values);
 
311
        }
 
312
        return the_type;
 
313
}
 
314
 
 
315
GType
 
316
atspi_state_type_get_type (void)
 
317
{
 
318
        static GType the_type = 0;
 
319
        
 
320
        if (the_type == 0)
 
321
        {
 
322
                static const GEnumValue values[] = {
 
323
                        { ATSPI_STATE_INVALID,
 
324
                          "ATSPI_STATE_INVALID",
 
325
                          "invalid" },
 
326
                        { ATSPI_STATE_ACTIVE,
 
327
                          "ATSPI_STATE_ACTIVE",
 
328
                          "active" },
 
329
                        { ATSPI_STATE_ARMED,
 
330
                          "ATSPI_STATE_ARMED",
 
331
                          "armed" },
 
332
                        { ATSPI_STATE_BUSY,
 
333
                          "ATSPI_STATE_BUSY",
 
334
                          "busy" },
 
335
                        { ATSPI_STATE_CHECKED,
 
336
                          "ATSPI_STATE_CHECKED",
 
337
                          "checked" },
 
338
                        { ATSPI_STATE_COLLAPSED,
 
339
                          "ATSPI_STATE_COLLAPSED",
 
340
                          "collapsed" },
 
341
                        { ATSPI_STATE_DEFUNCT,
 
342
                          "ATSPI_STATE_DEFUNCT",
 
343
                          "defunct" },
 
344
                        { ATSPI_STATE_EDITABLE,
 
345
                          "ATSPI_STATE_EDITABLE",
 
346
                          "editable" },
 
347
                        { ATSPI_STATE_ENABLED,
 
348
                          "ATSPI_STATE_ENABLED",
 
349
                          "enabled" },
 
350
                        { ATSPI_STATE_EXPANDABLE,
 
351
                          "ATSPI_STATE_EXPANDABLE",
 
352
                          "expandable" },
 
353
                        { ATSPI_STATE_EXPANDED,
 
354
                          "ATSPI_STATE_EXPANDED",
 
355
                          "expanded" },
 
356
                        { ATSPI_STATE_FOCUSABLE,
 
357
                          "ATSPI_STATE_FOCUSABLE",
 
358
                          "focusable" },
 
359
                        { ATSPI_STATE_FOCUSED,
 
360
                          "ATSPI_STATE_FOCUSED",
 
361
                          "focused" },
 
362
                        { ATSPI_STATE_HAS_TOOLTIP,
 
363
                          "ATSPI_STATE_HAS_TOOLTIP",
 
364
                          "has-tooltip" },
 
365
                        { ATSPI_STATE_HORIZONTAL,
 
366
                          "ATSPI_STATE_HORIZONTAL",
 
367
                          "horizontal" },
 
368
                        { ATSPI_STATE_ICONIFIED,
 
369
                          "ATSPI_STATE_ICONIFIED",
 
370
                          "iconified" },
 
371
                        { ATSPI_STATE_MODAL,
 
372
                          "ATSPI_STATE_MODAL",
 
373
                          "modal" },
 
374
                        { ATSPI_STATE_MULTI_LINE,
 
375
                          "ATSPI_STATE_MULTI_LINE",
 
376
                          "multi-line" },
 
377
                        { ATSPI_STATE_MULTISELECTABLE,
 
378
                          "ATSPI_STATE_MULTISELECTABLE",
 
379
                          "multiselectable" },
 
380
                        { ATSPI_STATE_OPAQUE,
 
381
                          "ATSPI_STATE_OPAQUE",
 
382
                          "opaque" },
 
383
                        { ATSPI_STATE_PRESSED,
 
384
                          "ATSPI_STATE_PRESSED",
 
385
                          "pressed" },
 
386
                        { ATSPI_STATE_RESIZABLE,
 
387
                          "ATSPI_STATE_RESIZABLE",
 
388
                          "resizable" },
 
389
                        { ATSPI_STATE_SELECTABLE,
 
390
                          "ATSPI_STATE_SELECTABLE",
 
391
                          "selectable" },
 
392
                        { ATSPI_STATE_SELECTED,
 
393
                          "ATSPI_STATE_SELECTED",
 
394
                          "selected" },
 
395
                        { ATSPI_STATE_SENSITIVE,
 
396
                          "ATSPI_STATE_SENSITIVE",
 
397
                          "sensitive" },
 
398
                        { ATSPI_STATE_SHOWING,
 
399
                          "ATSPI_STATE_SHOWING",
 
400
                          "showing" },
 
401
                        { ATSPI_STATE_SINGLE_LINE,
 
402
                          "ATSPI_STATE_SINGLE_LINE",
 
403
                          "single-line" },
 
404
                        { ATSPI_STATE_STALE,
 
405
                          "ATSPI_STATE_STALE",
 
406
                          "stale" },
 
407
                        { ATSPI_STATE_TRANSIENT,
 
408
                          "ATSPI_STATE_TRANSIENT",
 
409
                          "transient" },
 
410
                        { ATSPI_STATE_VERTICAL,
 
411
                          "ATSPI_STATE_VERTICAL",
 
412
                          "vertical" },
 
413
                        { ATSPI_STATE_VISIBLE,
 
414
                          "ATSPI_STATE_VISIBLE",
 
415
                          "visible" },
 
416
                        { ATSPI_STATE_MANAGES_DESCENDANTS,
 
417
                          "ATSPI_STATE_MANAGES_DESCENDANTS",
 
418
                          "manages-descendants" },
 
419
                        { ATSPI_STATE_INDETERMINATE,
 
420
                          "ATSPI_STATE_INDETERMINATE",
 
421
                          "indeterminate" },
 
422
                        { ATSPI_STATE_REQUIRED,
 
423
                          "ATSPI_STATE_REQUIRED",
 
424
                          "required" },
 
425
                        { ATSPI_STATE_TRUNCATED,
 
426
                          "ATSPI_STATE_TRUNCATED",
 
427
                          "truncated" },
 
428
                        { ATSPI_STATE_ANIMATED,
 
429
                          "ATSPI_STATE_ANIMATED",
 
430
                          "animated" },
 
431
                        { ATSPI_STATE_INVALID_ENTRY,
 
432
                          "ATSPI_STATE_INVALID_ENTRY",
 
433
                          "invalid-entry" },
 
434
                        { ATSPI_STATE_SUPPORTS_AUTOCOMPLETION,
 
435
                          "ATSPI_STATE_SUPPORTS_AUTOCOMPLETION",
 
436
                          "supports-autocompletion" },
 
437
                        { ATSPI_STATE_SELECTABLE_TEXT,
 
438
                          "ATSPI_STATE_SELECTABLE_TEXT",
 
439
                          "selectable-text" },
 
440
                        { ATSPI_STATE_IS_DEFAULT,
 
441
                          "ATSPI_STATE_IS_DEFAULT",
 
442
                          "is-default" },
 
443
                        { ATSPI_STATE_VISITED,
 
444
                          "ATSPI_STATE_VISITED",
 
445
                          "visited" },
 
446
                        { ATSPI_STATE_CHECKABLE,
 
447
                          "ATSPI_STATE_CHECKABLE",
 
448
                          "checkable" },
 
449
                        { ATSPI_STATE_HAS_POPUP,
 
450
                          "ATSPI_STATE_HAS_POPUP",
 
451
                          "has-popup" },
 
452
                        { ATSPI_STATE_READ_ONLY,
 
453
                          "ATSPI_STATE_READ_ONLY",
 
454
                          "read-only" },
 
455
                        { ATSPI_STATE_LAST_DEFINED,
 
456
                          "ATSPI_STATE_LAST_DEFINED",
 
457
                          "last-defined" },
 
458
                        { 0, NULL, NULL }
 
459
                };
 
460
                the_type = g_enum_register_static (
 
461
                                g_intern_static_string ("AtspiStateType"),
 
462
                                values);
 
463
        }
 
464
        return the_type;
 
465
}
 
466
 
 
467
GType
 
468
atspi_key_event_type_get_type (void)
 
469
{
 
470
        static GType the_type = 0;
 
471
        
 
472
        if (the_type == 0)
 
473
        {
 
474
                static const GEnumValue values[] = {
 
475
                        { ATSPI_KEY_PRESSED,
 
476
                          "ATSPI_KEY_PRESSED",
 
477
                          "pressed" },
 
478
                        { ATSPI_KEY_RELEASED,
 
479
                          "ATSPI_KEY_RELEASED",
 
480
                          "released" },
 
481
                        { 0, NULL, NULL }
 
482
                };
 
483
                the_type = g_enum_register_static (
 
484
                                g_intern_static_string ("AtspiKeyEventType"),
 
485
                                values);
 
486
        }
 
487
        return the_type;
 
488
}
 
489
 
 
490
GType
 
491
atspi_event_type_get_type (void)
 
492
{
 
493
        static GType the_type = 0;
 
494
        
 
495
        if (the_type == 0)
 
496
        {
 
497
                static const GEnumValue values[] = {
 
498
                        { ATSPI_KEY_PRESSED_EVENT,
 
499
                          "ATSPI_KEY_PRESSED_EVENT",
 
500
                          "key-pressed-event" },
 
501
                        { ATSPI_KEY_RELEASED_EVENT,
 
502
                          "ATSPI_KEY_RELEASED_EVENT",
 
503
                          "key-released-event" },
 
504
                        { ATSPI_BUTTON_PRESSED_EVENT,
 
505
                          "ATSPI_BUTTON_PRESSED_EVENT",
 
506
                          "button-pressed-event" },
 
507
                        { ATSPI_BUTTON_RELEASED_EVENT,
 
508
                          "ATSPI_BUTTON_RELEASED_EVENT",
 
509
                          "button-released-event" },
 
510
                        { 0, NULL, NULL }
 
511
                };
 
512
                the_type = g_enum_register_static (
 
513
                                g_intern_static_string ("AtspiEventType"),
 
514
                                values);
 
515
        }
 
516
        return the_type;
 
517
}
 
518
 
 
519
GType
 
520
atspi_key_synth_type_get_type (void)
 
521
{
 
522
        static GType the_type = 0;
 
523
        
 
524
        if (the_type == 0)
 
525
        {
 
526
                static const GEnumValue values[] = {
 
527
                        { ATSPI_KEY_PRESS,
 
528
                          "ATSPI_KEY_PRESS",
 
529
                          "press" },
 
530
                        { ATSPI_KEY_RELEASE,
 
531
                          "ATSPI_KEY_RELEASE",
 
532
                          "release" },
 
533
                        { ATSPI_KEY_PRESSRELEASE,
 
534
                          "ATSPI_KEY_PRESSRELEASE",
 
535
                          "pressrelease" },
 
536
                        { ATSPI_KEY_SYM,
 
537
                          "ATSPI_KEY_SYM",
 
538
                          "sym" },
 
539
                        { ATSPI_KEY_STRING,
 
540
                          "ATSPI_KEY_STRING",
 
541
                          "string" },
 
542
                        { 0, NULL, NULL }
 
543
                };
 
544
                the_type = g_enum_register_static (
 
545
                                g_intern_static_string ("AtspiKeySynthType"),
 
546
                                values);
 
547
        }
 
548
        return the_type;
 
549
}
 
550
 
 
551
GType
 
552
atspi_modifier_type_get_type (void)
 
553
{
 
554
        static GType the_type = 0;
 
555
        
 
556
        if (the_type == 0)
 
557
        {
 
558
                static const GEnumValue values[] = {
 
559
                        { ATSPI_MODIFIER_SHIFT,
 
560
                          "ATSPI_MODIFIER_SHIFT",
 
561
                          "shift" },
 
562
                        { ATSPI_MODIFIER_SHIFTLOCK,
 
563
                          "ATSPI_MODIFIER_SHIFTLOCK",
 
564
                          "shiftlock" },
 
565
                        { ATSPI_MODIFIER_CONTROL,
 
566
                          "ATSPI_MODIFIER_CONTROL",
 
567
                          "control" },
 
568
                        { ATSPI_MODIFIER_ALT,
 
569
                          "ATSPI_MODIFIER_ALT",
 
570
                          "alt" },
 
571
                        { ATSPI_MODIFIER_META,
 
572
                          "ATSPI_MODIFIER_META",
 
573
                          "meta" },
 
574
                        { ATSPI_MODIFIER_META2,
 
575
                          "ATSPI_MODIFIER_META2",
 
576
                          "meta2" },
 
577
                        { ATSPI_MODIFIER_META3,
 
578
                          "ATSPI_MODIFIER_META3",
 
579
                          "meta3" },
 
580
                        { ATSPI_MODIFIER_NUMLOCK,
 
581
                          "ATSPI_MODIFIER_NUMLOCK",
 
582
                          "numlock" },
 
583
                        { 0, NULL, NULL }
 
584
                };
 
585
                the_type = g_enum_register_static (
 
586
                                g_intern_static_string ("AtspiModifierType"),
 
587
                                values);
 
588
        }
 
589
        return the_type;
 
590
}
 
591
 
 
592
GType
 
593
atspi_relation_type_get_type (void)
 
594
{
 
595
        static GType the_type = 0;
 
596
        
 
597
        if (the_type == 0)
 
598
        {
 
599
                static const GEnumValue values[] = {
 
600
                        { ATSPI_RELATION_NULL,
 
601
                          "ATSPI_RELATION_NULL",
 
602
                          "null" },
 
603
                        { ATSPI_RELATION_LABEL_FOR,
 
604
                          "ATSPI_RELATION_LABEL_FOR",
 
605
                          "label-for" },
 
606
                        { ATSPI_RELATION_LABELLED_BY,
 
607
                          "ATSPI_RELATION_LABELLED_BY",
 
608
                          "labelled-by" },
 
609
                        { ATSPI_RELATION_CONTROLLER_FOR,
 
610
                          "ATSPI_RELATION_CONTROLLER_FOR",
 
611
                          "controller-for" },
 
612
                        { ATSPI_RELATION_CONTROLLED_BY,
 
613
                          "ATSPI_RELATION_CONTROLLED_BY",
 
614
                          "controlled-by" },
 
615
                        { ATSPI_RELATION_MEMBER_OF,
 
616
                          "ATSPI_RELATION_MEMBER_OF",
 
617
                          "member-of" },
 
618
                        { ATSPI_RELATION_TOOLTIP_FOR,
 
619
                          "ATSPI_RELATION_TOOLTIP_FOR",
 
620
                          "tooltip-for" },
 
621
                        { ATSPI_RELATION_NODE_CHILD_OF,
 
622
                          "ATSPI_RELATION_NODE_CHILD_OF",
 
623
                          "node-child-of" },
 
624
                        { ATSPI_RELATION_NODE_PARENT_OF,
 
625
                          "ATSPI_RELATION_NODE_PARENT_OF",
 
626
                          "node-parent-of" },
 
627
                        { ATSPI_RELATION_EXTENDED,
 
628
                          "ATSPI_RELATION_EXTENDED",
 
629
                          "extended" },
 
630
                        { ATSPI_RELATION_FLOWS_TO,
 
631
                          "ATSPI_RELATION_FLOWS_TO",
 
632
                          "flows-to" },
 
633
                        { ATSPI_RELATION_FLOWS_FROM,
 
634
                          "ATSPI_RELATION_FLOWS_FROM",
 
635
                          "flows-from" },
 
636
                        { ATSPI_RELATION_SUBWINDOW_OF,
 
637
                          "ATSPI_RELATION_SUBWINDOW_OF",
 
638
                          "subwindow-of" },
 
639
                        { ATSPI_RELATION_EMBEDS,
 
640
                          "ATSPI_RELATION_EMBEDS",
 
641
                          "embeds" },
 
642
                        { ATSPI_RELATION_EMBEDDED_BY,
 
643
                          "ATSPI_RELATION_EMBEDDED_BY",
 
644
                          "embedded-by" },
 
645
                        { ATSPI_RELATION_POPUP_FOR,
 
646
                          "ATSPI_RELATION_POPUP_FOR",
 
647
                          "popup-for" },
 
648
                        { ATSPI_RELATION_PARENT_WINDOW_OF,
 
649
                          "ATSPI_RELATION_PARENT_WINDOW_OF",
 
650
                          "parent-window-of" },
 
651
                        { ATSPI_RELATION_DESCRIPTION_FOR,
 
652
                          "ATSPI_RELATION_DESCRIPTION_FOR",
 
653
                          "description-for" },
 
654
                        { ATSPI_RELATION_DESCRIBED_BY,
 
655
                          "ATSPI_RELATION_DESCRIBED_BY",
 
656
                          "described-by" },
 
657
                        { ATSPI_RELATION_LAST_DEFINED,
 
658
                          "ATSPI_RELATION_LAST_DEFINED",
 
659
                          "last-defined" },
 
660
                        { 0, NULL, NULL }
 
661
                };
 
662
                the_type = g_enum_register_static (
 
663
                                g_intern_static_string ("AtspiRelationType"),
 
664
                                values);
 
665
        }
 
666
        return the_type;
 
667
}
 
668
 
 
669
GType
 
670
atspi_role_get_type (void)
 
671
{
 
672
        static GType the_type = 0;
 
673
        
 
674
        if (the_type == 0)
 
675
        {
 
676
                static const GEnumValue values[] = {
 
677
                        { ATSPI_ROLE_INVALID,
 
678
                          "ATSPI_ROLE_INVALID",
 
679
                          "invalid" },
 
680
                        { ATSPI_ROLE_ACCELERATOR_LABEL,
 
681
                          "ATSPI_ROLE_ACCELERATOR_LABEL",
 
682
                          "accelerator-label" },
 
683
                        { ATSPI_ROLE_ALERT,
 
684
                          "ATSPI_ROLE_ALERT",
 
685
                          "alert" },
 
686
                        { ATSPI_ROLE_ANIMATION,
 
687
                          "ATSPI_ROLE_ANIMATION",
 
688
                          "animation" },
 
689
                        { ATSPI_ROLE_ARROW,
 
690
                          "ATSPI_ROLE_ARROW",
 
691
                          "arrow" },
 
692
                        { ATSPI_ROLE_CALENDAR,
 
693
                          "ATSPI_ROLE_CALENDAR",
 
694
                          "calendar" },
 
695
                        { ATSPI_ROLE_CANVAS,
 
696
                          "ATSPI_ROLE_CANVAS",
 
697
                          "canvas" },
 
698
                        { ATSPI_ROLE_CHECK_BOX,
 
699
                          "ATSPI_ROLE_CHECK_BOX",
 
700
                          "check-box" },
 
701
                        { ATSPI_ROLE_CHECK_MENU_ITEM,
 
702
                          "ATSPI_ROLE_CHECK_MENU_ITEM",
 
703
                          "check-menu-item" },
 
704
                        { ATSPI_ROLE_COLOR_CHOOSER,
 
705
                          "ATSPI_ROLE_COLOR_CHOOSER",
 
706
                          "color-chooser" },
 
707
                        { ATSPI_ROLE_COLUMN_HEADER,
 
708
                          "ATSPI_ROLE_COLUMN_HEADER",
 
709
                          "column-header" },
 
710
                        { ATSPI_ROLE_COMBO_BOX,
 
711
                          "ATSPI_ROLE_COMBO_BOX",
 
712
                          "combo-box" },
 
713
                        { ATSPI_ROLE_DATE_EDITOR,
 
714
                          "ATSPI_ROLE_DATE_EDITOR",
 
715
                          "date-editor" },
 
716
                        { ATSPI_ROLE_DESKTOP_ICON,
 
717
                          "ATSPI_ROLE_DESKTOP_ICON",
 
718
                          "desktop-icon" },
 
719
                        { ATSPI_ROLE_DESKTOP_FRAME,
 
720
                          "ATSPI_ROLE_DESKTOP_FRAME",
 
721
                          "desktop-frame" },
 
722
                        { ATSPI_ROLE_DIAL,
 
723
                          "ATSPI_ROLE_DIAL",
 
724
                          "dial" },
 
725
                        { ATSPI_ROLE_DIALOG,
 
726
                          "ATSPI_ROLE_DIALOG",
 
727
                          "dialog" },
 
728
                        { ATSPI_ROLE_DIRECTORY_PANE,
 
729
                          "ATSPI_ROLE_DIRECTORY_PANE",
 
730
                          "directory-pane" },
 
731
                        { ATSPI_ROLE_DRAWING_AREA,
 
732
                          "ATSPI_ROLE_DRAWING_AREA",
 
733
                          "drawing-area" },
 
734
                        { ATSPI_ROLE_FILE_CHOOSER,
 
735
                          "ATSPI_ROLE_FILE_CHOOSER",
 
736
                          "file-chooser" },
 
737
                        { ATSPI_ROLE_FILLER,
 
738
                          "ATSPI_ROLE_FILLER",
 
739
                          "filler" },
 
740
                        { ATSPI_ROLE_FOCUS_TRAVERSABLE,
 
741
                          "ATSPI_ROLE_FOCUS_TRAVERSABLE",
 
742
                          "focus-traversable" },
 
743
                        { ATSPI_ROLE_FONT_CHOOSER,
 
744
                          "ATSPI_ROLE_FONT_CHOOSER",
 
745
                          "font-chooser" },
 
746
                        { ATSPI_ROLE_FRAME,
 
747
                          "ATSPI_ROLE_FRAME",
 
748
                          "frame" },
 
749
                        { ATSPI_ROLE_GLASS_PANE,
 
750
                          "ATSPI_ROLE_GLASS_PANE",
 
751
                          "glass-pane" },
 
752
                        { ATSPI_ROLE_HTML_CONTAINER,
 
753
                          "ATSPI_ROLE_HTML_CONTAINER",
 
754
                          "html-container" },
 
755
                        { ATSPI_ROLE_ICON,
 
756
                          "ATSPI_ROLE_ICON",
 
757
                          "icon" },
 
758
                        { ATSPI_ROLE_IMAGE,
 
759
                          "ATSPI_ROLE_IMAGE",
 
760
                          "image" },
 
761
                        { ATSPI_ROLE_INTERNAL_FRAME,
 
762
                          "ATSPI_ROLE_INTERNAL_FRAME",
 
763
                          "internal-frame" },
 
764
                        { ATSPI_ROLE_LABEL,
 
765
                          "ATSPI_ROLE_LABEL",
 
766
                          "label" },
 
767
                        { ATSPI_ROLE_LAYERED_PANE,
 
768
                          "ATSPI_ROLE_LAYERED_PANE",
 
769
                          "layered-pane" },
 
770
                        { ATSPI_ROLE_LIST,
 
771
                          "ATSPI_ROLE_LIST",
 
772
                          "list" },
 
773
                        { ATSPI_ROLE_LIST_ITEM,
 
774
                          "ATSPI_ROLE_LIST_ITEM",
 
775
                          "list-item" },
 
776
                        { ATSPI_ROLE_MENU,
 
777
                          "ATSPI_ROLE_MENU",
 
778
                          "menu" },
 
779
                        { ATSPI_ROLE_MENU_BAR,
 
780
                          "ATSPI_ROLE_MENU_BAR",
 
781
                          "menu-bar" },
 
782
                        { ATSPI_ROLE_MENU_ITEM,
 
783
                          "ATSPI_ROLE_MENU_ITEM",
 
784
                          "menu-item" },
 
785
                        { ATSPI_ROLE_OPTION_PANE,
 
786
                          "ATSPI_ROLE_OPTION_PANE",
 
787
                          "option-pane" },
 
788
                        { ATSPI_ROLE_PAGE_TAB,
 
789
                          "ATSPI_ROLE_PAGE_TAB",
 
790
                          "page-tab" },
 
791
                        { ATSPI_ROLE_PAGE_TAB_LIST,
 
792
                          "ATSPI_ROLE_PAGE_TAB_LIST",
 
793
                          "page-tab-list" },
 
794
                        { ATSPI_ROLE_PANEL,
 
795
                          "ATSPI_ROLE_PANEL",
 
796
                          "panel" },
 
797
                        { ATSPI_ROLE_PASSWORD_TEXT,
 
798
                          "ATSPI_ROLE_PASSWORD_TEXT",
 
799
                          "password-text" },
 
800
                        { ATSPI_ROLE_POPUP_MENU,
 
801
                          "ATSPI_ROLE_POPUP_MENU",
 
802
                          "popup-menu" },
 
803
                        { ATSPI_ROLE_PROGRESS_BAR,
 
804
                          "ATSPI_ROLE_PROGRESS_BAR",
 
805
                          "progress-bar" },
 
806
                        { ATSPI_ROLE_PUSH_BUTTON,
 
807
                          "ATSPI_ROLE_PUSH_BUTTON",
 
808
                          "push-button" },
 
809
                        { ATSPI_ROLE_RADIO_BUTTON,
 
810
                          "ATSPI_ROLE_RADIO_BUTTON",
 
811
                          "radio-button" },
 
812
                        { ATSPI_ROLE_RADIO_MENU_ITEM,
 
813
                          "ATSPI_ROLE_RADIO_MENU_ITEM",
 
814
                          "radio-menu-item" },
 
815
                        { ATSPI_ROLE_ROOT_PANE,
 
816
                          "ATSPI_ROLE_ROOT_PANE",
 
817
                          "root-pane" },
 
818
                        { ATSPI_ROLE_ROW_HEADER,
 
819
                          "ATSPI_ROLE_ROW_HEADER",
 
820
                          "row-header" },
 
821
                        { ATSPI_ROLE_SCROLL_BAR,
 
822
                          "ATSPI_ROLE_SCROLL_BAR",
 
823
                          "scroll-bar" },
 
824
                        { ATSPI_ROLE_SCROLL_PANE,
 
825
                          "ATSPI_ROLE_SCROLL_PANE",
 
826
                          "scroll-pane" },
 
827
                        { ATSPI_ROLE_SEPARATOR,
 
828
                          "ATSPI_ROLE_SEPARATOR",
 
829
                          "separator" },
 
830
                        { ATSPI_ROLE_SLIDER,
 
831
                          "ATSPI_ROLE_SLIDER",
 
832
                          "slider" },
 
833
                        { ATSPI_ROLE_SPIN_BUTTON,
 
834
                          "ATSPI_ROLE_SPIN_BUTTON",
 
835
                          "spin-button" },
 
836
                        { ATSPI_ROLE_SPLIT_PANE,
 
837
                          "ATSPI_ROLE_SPLIT_PANE",
 
838
                          "split-pane" },
 
839
                        { ATSPI_ROLE_STATUS_BAR,
 
840
                          "ATSPI_ROLE_STATUS_BAR",
 
841
                          "status-bar" },
 
842
                        { ATSPI_ROLE_TABLE,
 
843
                          "ATSPI_ROLE_TABLE",
 
844
                          "table" },
 
845
                        { ATSPI_ROLE_TABLE_CELL,
 
846
                          "ATSPI_ROLE_TABLE_CELL",
 
847
                          "table-cell" },
 
848
                        { ATSPI_ROLE_TABLE_COLUMN_HEADER,
 
849
                          "ATSPI_ROLE_TABLE_COLUMN_HEADER",
 
850
                          "table-column-header" },
 
851
                        { ATSPI_ROLE_TABLE_ROW_HEADER,
 
852
                          "ATSPI_ROLE_TABLE_ROW_HEADER",
 
853
                          "table-row-header" },
 
854
                        { ATSPI_ROLE_TEAROFF_MENU_ITEM,
 
855
                          "ATSPI_ROLE_TEAROFF_MENU_ITEM",
 
856
                          "tearoff-menu-item" },
 
857
                        { ATSPI_ROLE_TERMINAL,
 
858
                          "ATSPI_ROLE_TERMINAL",
 
859
                          "terminal" },
 
860
                        { ATSPI_ROLE_TEXT,
 
861
                          "ATSPI_ROLE_TEXT",
 
862
                          "text" },
 
863
                        { ATSPI_ROLE_TOGGLE_BUTTON,
 
864
                          "ATSPI_ROLE_TOGGLE_BUTTON",
 
865
                          "toggle-button" },
 
866
                        { ATSPI_ROLE_TOOL_BAR,
 
867
                          "ATSPI_ROLE_TOOL_BAR",
 
868
                          "tool-bar" },
 
869
                        { ATSPI_ROLE_TOOL_TIP,
 
870
                          "ATSPI_ROLE_TOOL_TIP",
 
871
                          "tool-tip" },
 
872
                        { ATSPI_ROLE_TREE,
 
873
                          "ATSPI_ROLE_TREE",
 
874
                          "tree" },
 
875
                        { ATSPI_ROLE_TREE_TABLE,
 
876
                          "ATSPI_ROLE_TREE_TABLE",
 
877
                          "tree-table" },
 
878
                        { ATSPI_ROLE_UNKNOWN,
 
879
                          "ATSPI_ROLE_UNKNOWN",
 
880
                          "unknown" },
 
881
                        { ATSPI_ROLE_VIEWPORT,
 
882
                          "ATSPI_ROLE_VIEWPORT",
 
883
                          "viewport" },
 
884
                        { ATSPI_ROLE_WINDOW,
 
885
                          "ATSPI_ROLE_WINDOW",
 
886
                          "window" },
 
887
                        { ATSPI_ROLE_EXTENDED,
 
888
                          "ATSPI_ROLE_EXTENDED",
 
889
                          "extended" },
 
890
                        { ATSPI_ROLE_HEADER,
 
891
                          "ATSPI_ROLE_HEADER",
 
892
                          "header" },
 
893
                        { ATSPI_ROLE_FOOTER,
 
894
                          "ATSPI_ROLE_FOOTER",
 
895
                          "footer" },
 
896
                        { ATSPI_ROLE_PARAGRAPH,
 
897
                          "ATSPI_ROLE_PARAGRAPH",
 
898
                          "paragraph" },
 
899
                        { ATSPI_ROLE_RULER,
 
900
                          "ATSPI_ROLE_RULER",
 
901
                          "ruler" },
 
902
                        { ATSPI_ROLE_APPLICATION,
 
903
                          "ATSPI_ROLE_APPLICATION",
 
904
                          "application" },
 
905
                        { ATSPI_ROLE_AUTOCOMPLETE,
 
906
                          "ATSPI_ROLE_AUTOCOMPLETE",
 
907
                          "autocomplete" },
 
908
                        { ATSPI_ROLE_EDITBAR,
 
909
                          "ATSPI_ROLE_EDITBAR",
 
910
                          "editbar" },
 
911
                        { ATSPI_ROLE_EMBEDDED,
 
912
                          "ATSPI_ROLE_EMBEDDED",
 
913
                          "embedded" },
 
914
                        { ATSPI_ROLE_ENTRY,
 
915
                          "ATSPI_ROLE_ENTRY",
 
916
                          "entry" },
 
917
                        { ATSPI_ROLE_CHART,
 
918
                          "ATSPI_ROLE_CHART",
 
919
                          "chart" },
 
920
                        { ATSPI_ROLE_CAPTION,
 
921
                          "ATSPI_ROLE_CAPTION",
 
922
                          "caption" },
 
923
                        { ATSPI_ROLE_DOCUMENT_FRAME,
 
924
                          "ATSPI_ROLE_DOCUMENT_FRAME",
 
925
                          "document-frame" },
 
926
                        { ATSPI_ROLE_HEADING,
 
927
                          "ATSPI_ROLE_HEADING",
 
928
                          "heading" },
 
929
                        { ATSPI_ROLE_PAGE,
 
930
                          "ATSPI_ROLE_PAGE",
 
931
                          "page" },
 
932
                        { ATSPI_ROLE_SECTION,
 
933
                          "ATSPI_ROLE_SECTION",
 
934
                          "section" },
 
935
                        { ATSPI_ROLE_REDUNDANT_OBJECT,
 
936
                          "ATSPI_ROLE_REDUNDANT_OBJECT",
 
937
                          "redundant-object" },
 
938
                        { ATSPI_ROLE_FORM,
 
939
                          "ATSPI_ROLE_FORM",
 
940
                          "form" },
 
941
                        { ATSPI_ROLE_LINK,
 
942
                          "ATSPI_ROLE_LINK",
 
943
                          "link" },
 
944
                        { ATSPI_ROLE_INPUT_METHOD_WINDOW,
 
945
                          "ATSPI_ROLE_INPUT_METHOD_WINDOW",
 
946
                          "input-method-window" },
 
947
                        { ATSPI_ROLE_TABLE_ROW,
 
948
                          "ATSPI_ROLE_TABLE_ROW",
 
949
                          "table-row" },
 
950
                        { ATSPI_ROLE_TREE_ITEM,
 
951
                          "ATSPI_ROLE_TREE_ITEM",
 
952
                          "tree-item" },
 
953
                        { ATSPI_ROLE_DOCUMENT_SPREADSHEET,
 
954
                          "ATSPI_ROLE_DOCUMENT_SPREADSHEET",
 
955
                          "document-spreadsheet" },
 
956
                        { ATSPI_ROLE_DOCUMENT_PRESENTATION,
 
957
                          "ATSPI_ROLE_DOCUMENT_PRESENTATION",
 
958
                          "document-presentation" },
 
959
                        { ATSPI_ROLE_DOCUMENT_TEXT,
 
960
                          "ATSPI_ROLE_DOCUMENT_TEXT",
 
961
                          "document-text" },
 
962
                        { ATSPI_ROLE_DOCUMENT_WEB,
 
963
                          "ATSPI_ROLE_DOCUMENT_WEB",
 
964
                          "document-web" },
 
965
                        { ATSPI_ROLE_DOCUMENT_EMAIL,
 
966
                          "ATSPI_ROLE_DOCUMENT_EMAIL",
 
967
                          "document-email" },
 
968
                        { ATSPI_ROLE_COMMENT,
 
969
                          "ATSPI_ROLE_COMMENT",
 
970
                          "comment" },
 
971
                        { ATSPI_ROLE_LIST_BOX,
 
972
                          "ATSPI_ROLE_LIST_BOX",
 
973
                          "list-box" },
 
974
                        { ATSPI_ROLE_GROUPING,
 
975
                          "ATSPI_ROLE_GROUPING",
 
976
                          "grouping" },
 
977
                        { ATSPI_ROLE_IMAGE_MAP,
 
978
                          "ATSPI_ROLE_IMAGE_MAP",
 
979
                          "image-map" },
 
980
                        { ATSPI_ROLE_NOTIFICATION,
 
981
                          "ATSPI_ROLE_NOTIFICATION",
 
982
                          "notification" },
 
983
                        { ATSPI_ROLE_INFO_BAR,
 
984
                          "ATSPI_ROLE_INFO_BAR",
 
985
                          "info-bar" },
 
986
                        { ATSPI_ROLE_LEVEL_BAR,
 
987
                          "ATSPI_ROLE_LEVEL_BAR",
 
988
                          "level-bar" },
 
989
                        { ATSPI_ROLE_TITLE_BAR,
 
990
                          "ATSPI_ROLE_TITLE_BAR",
 
991
                          "title-bar" },
 
992
                        { ATSPI_ROLE_BLOCK_QUOTE,
 
993
                          "ATSPI_ROLE_BLOCK_QUOTE",
 
994
                          "block-quote" },
 
995
                        { ATSPI_ROLE_AUDIO,
 
996
                          "ATSPI_ROLE_AUDIO",
 
997
                          "audio" },
 
998
                        { ATSPI_ROLE_VIDEO,
 
999
                          "ATSPI_ROLE_VIDEO",
 
1000
                          "video" },
 
1001
                        { ATSPI_ROLE_DEFINITION,
 
1002
                          "ATSPI_ROLE_DEFINITION",
 
1003
                          "definition" },
 
1004
                        { ATSPI_ROLE_ARTICLE,
 
1005
                          "ATSPI_ROLE_ARTICLE",
 
1006
                          "article" },
 
1007
                        { ATSPI_ROLE_LANDMARK,
 
1008
                          "ATSPI_ROLE_LANDMARK",
 
1009
                          "landmark" },
 
1010
                        { ATSPI_ROLE_LOG,
 
1011
                          "ATSPI_ROLE_LOG",
 
1012
                          "log" },
 
1013
                        { ATSPI_ROLE_MARQUEE,
 
1014
                          "ATSPI_ROLE_MARQUEE",
 
1015
                          "marquee" },
 
1016
                        { ATSPI_ROLE_MATH,
 
1017
                          "ATSPI_ROLE_MATH",
 
1018
                          "math" },
 
1019
                        { ATSPI_ROLE_RATING,
 
1020
                          "ATSPI_ROLE_RATING",
 
1021
                          "rating" },
 
1022
                        { ATSPI_ROLE_TIMER,
 
1023
                          "ATSPI_ROLE_TIMER",
 
1024
                          "timer" },
 
1025
                        { ATSPI_ROLE_STATIC,
 
1026
                          "ATSPI_ROLE_STATIC",
 
1027
                          "static" },
 
1028
                        { ATSPI_ROLE_MATH_FRACTION,
 
1029
                          "ATSPI_ROLE_MATH_FRACTION",
 
1030
                          "math-fraction" },
 
1031
                        { ATSPI_ROLE_MATH_ROOT,
 
1032
                          "ATSPI_ROLE_MATH_ROOT",
 
1033
                          "math-root" },
 
1034
                        { ATSPI_ROLE_SUBSCRIPT,
 
1035
                          "ATSPI_ROLE_SUBSCRIPT",
 
1036
                          "subscript" },
 
1037
                        { ATSPI_ROLE_SUPERSCRIPT,
 
1038
                          "ATSPI_ROLE_SUPERSCRIPT",
 
1039
                          "superscript" },
 
1040
                        { ATSPI_ROLE_LAST_DEFINED,
 
1041
                          "ATSPI_ROLE_LAST_DEFINED",
 
1042
                          "last-defined" },
 
1043
                        { 0, NULL, NULL }
 
1044
                };
 
1045
                the_type = g_enum_register_static (
 
1046
                                g_intern_static_string ("AtspiRole"),
 
1047
                                values);
 
1048
        }
 
1049
        return the_type;
 
1050
}
 
1051
 
 
1052
GType
 
1053
atspi_cache_get_type (void)
 
1054
{
 
1055
        static GType the_type = 0;
 
1056
        
 
1057
        if (the_type == 0)
 
1058
        {
 
1059
                static const GFlagsValue values[] = {
 
1060
                        { ATSPI_CACHE_NONE,
 
1061
                          "ATSPI_CACHE_NONE",
 
1062
                          "none" },
 
1063
                        { ATSPI_CACHE_PARENT,
 
1064
                          "ATSPI_CACHE_PARENT",
 
1065
                          "parent" },
 
1066
                        { ATSPI_CACHE_CHILDREN,
 
1067
                          "ATSPI_CACHE_CHILDREN",
 
1068
                          "children" },
 
1069
                        { ATSPI_CACHE_NAME,
 
1070
                          "ATSPI_CACHE_NAME",
 
1071
                          "name" },
 
1072
                        { ATSPI_CACHE_DESCRIPTION,
 
1073
                          "ATSPI_CACHE_DESCRIPTION",
 
1074
                          "description" },
 
1075
                        { ATSPI_CACHE_STATES,
 
1076
                          "ATSPI_CACHE_STATES",
 
1077
                          "states" },
 
1078
                        { ATSPI_CACHE_ROLE,
 
1079
                          "ATSPI_CACHE_ROLE",
 
1080
                          "role" },
 
1081
                        { ATSPI_CACHE_INTERFACES,
 
1082
                          "ATSPI_CACHE_INTERFACES",
 
1083
                          "interfaces" },
 
1084
                        { ATSPI_CACHE_ATTRIBUTES,
 
1085
                          "ATSPI_CACHE_ATTRIBUTES",
 
1086
                          "attributes" },
 
1087
                        { ATSPI_CACHE_ALL,
 
1088
                          "ATSPI_CACHE_ALL",
 
1089
                          "all" },
 
1090
                        { ATSPI_CACHE_DEFAULT,
 
1091
                          "ATSPI_CACHE_DEFAULT",
 
1092
                          "default" },
 
1093
                        { ATSPI_CACHE_UNDEFINED,
 
1094
                          "ATSPI_CACHE_UNDEFINED",
 
1095
                          "undefined" },
 
1096
                        { 0, NULL, NULL }
 
1097
                };
 
1098
                the_type = g_flags_register_static (
 
1099
                                g_intern_static_string ("AtspiCache"),
 
1100
                                values);
 
1101
        }
 
1102
        return the_type;
 
1103
}
 
1104
 
 
1105
/* enumerations from "atspi-types.h" */
 
1106
#include "atspi-types.h"
 
1107
 
 
1108
GType
 
1109
atspi_key_listener_sync_type_get_type (void)
 
1110
{
 
1111
        static GType the_type = 0;
 
1112
        
 
1113
        if (the_type == 0)
 
1114
        {
 
1115
                static const GFlagsValue values[] = {
 
1116
                        { ATSPI_KEYLISTENER_NOSYNC,
 
1117
                          "ATSPI_KEYLISTENER_NOSYNC",
 
1118
                          "nosync" },
 
1119
                        { ATSPI_KEYLISTENER_SYNCHRONOUS,
 
1120
                          "ATSPI_KEYLISTENER_SYNCHRONOUS",
 
1121
                          "synchronous" },
 
1122
                        { ATSPI_KEYLISTENER_CANCONSUME,
 
1123
                          "ATSPI_KEYLISTENER_CANCONSUME",
 
1124
                          "canconsume" },
 
1125
                        { ATSPI_KEYLISTENER_ALL_WINDOWS,
 
1126
                          "ATSPI_KEYLISTENER_ALL_WINDOWS",
 
1127
                          "all-windows" },
 
1128
                        { 0, NULL, NULL }
 
1129
                };
 
1130
                the_type = g_flags_register_static (
 
1131
                                g_intern_static_string ("AtspiKeyListenerSyncType"),
 
1132
                                values);
 
1133
        }
 
1134
        return the_type;
 
1135
}
 
1136
 
 
1137
 
 
1138
/* Generated data ends here */
 
1139