← Back to branch summary

~canonical-dx-team/ubuntu/maverick/gtk+2.0/menuproxy

« back to all changes in this revision

Viewing changes to gtk/gtktypebuiltins.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-05-04 12:24:25 UTC
  • mfrom: (1.1.21 upstream)
  • Revision ID: james.westby@ubuntu.com-20070504122425-0m8midgzrp40y8w2
Tags: 2.10.12-1ubuntu1
* Sync with Debian
* New upstream version:
  Fixed bugs:
  - 379414 file chooser warnings when changing path in the entry
  - 418585 GtkFileChooserDefault sizing code is not DPI independent
  - 419568 Crash in search if start with special letter
  - 435062 build dies with icon cache validation
  - 379399 Segfault to call gtk_print_operation_run twice.
  - 387889 cups backend has problems when there are too many printers
  - 418531 invalid read to gtkicontheme.c gtk_icon_theme_lookup_icon...
  - 423916 crash in color scheme code
  - 424042 Segmentation fault while quickly pressing Alt+arrows
  - 415260 Protect against negative indices when setting values in G...
  - 419171 XGetVisualInfo() may not set nxvisuals
  - 128852 Gdk cursors don't look good on win32
  - 344657 Ctrl-H doesn't toggle "Show Hidden Files" setting
  - 345345 PrintOperation::paginate is not emitted for class handler
  - 347567 GtkPrintOperation::end-print is not emitted if it's cance...
  - 369112 gtk_ui_manager_add_ui should accept unnamed separator
  - 392015 Selected menu item invisible on Windows Vista
  - 399253 MS-Windows Theme Bottom Tab placement rendering glitches
  - 399425 gtk_input_dialog_fill_axes() adds child to gtkscrolledwin...
  - 403251 [patch] little memory leak in GtkPrintJob
  - 403267 [patch] memory leak in GtkPageSetupUnixDialog
  - 403470 MS-Windows Theme tab placement other than on top leaks a ...
  - 404506 Windows system fonts that have multi-byte font names cann...
  - 405089 Incorrect window placement for GtkEventBox private window
  - 405515 Minor leak in gtkfilesystemmodel.c
  - 405539 gdk_pixbuf_save() for PNG saver can return FALSE without ...
  - 415681 gdk_window_clear_area includes an extra line and column o...
  - 418219 GtkRecentChooser should apply filter before sorting and c...
  - 418403 Scroll to printer after selecting it from settings
  - 421985 _gtk_print_operation_platform_backend_launch_preview
  - 421990 gtk_print_job_get_surface
  - 421993 gtk_print_operation_init
  - 423064 Conditional jump or move depends on uninitialised value(s...
  - 423722 Fix printing header in gtk-demo
  - 424168 gtk_print_operation_run on async preview
  - 425655 Don't install gtk+-unix-print-2.0.pc on non-UNIX platforms
  - 425786 GDK segfaults if XineramaQueryScreens fails
  - 428665 Lpr Backend gets stuck in infinite loop during gtk_enumer...
  - 429902 GtkPrintOperation leaks cairo contextes
  - 431997 First delay of GdkPixbufAnimationIter is wrong
  - 433242 Inconsistent scroll arrow position calculations
  - 433972 Placing gtk.Expander inside a gtk.TextView() changes gtk....
  - 434261 _gtk_toolbar_elide_underscores incorrectly handles some s...
  - 383354 ctrl-L should make 'Location' entry disappear
  - 418673 gtk_recent_manager_add_item
  - 429732 gtk_accel_group_finalize accesses invalid memory
  - 435028 WM_CLIENT_LEADER is wrong on the leader_window
  - 431067 Background of the header window is not updated
  - 338843 add recent files support inside the ui manager
  - 148535 add drop shadow to menus, tooltips, etc. under Windows XP
* debian/control.in:
  - Conflicts on ubuntulooks (<= 0.9.11-1)
* debian/patches/15_default-fallback-icon-theme.patch:
  - patch from Debian, fallback on gnome icon theme

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk/gtktypebuiltins.c
 
1
 
 
2
/* Generated data (by glib-mkenums) */
 
3
 
 
4
#undef GTK_DISABLE_DEPRECATED
 
5
#define GTK_ENABLE_BROKEN
 
6
#include "gtk.h"
 
7
#include "gtkprivate.h"
 
8
#include "gtkalias.h"
 
9
 
 
10
/* enumerations from "gtkaccelgroup.h" */
 
11
GType
 
12
gtk_accel_flags_get_type (void)
 
13
{
 
14
  static GType etype = 0;
 
15
  if (etype == 0) {
 
16
    static const GFlagsValue values[] = {
 
17
      { GTK_ACCEL_VISIBLE, "GTK_ACCEL_VISIBLE", "visible" },
 
18
      { GTK_ACCEL_LOCKED, "GTK_ACCEL_LOCKED", "locked" },
 
19
      { GTK_ACCEL_MASK, "GTK_ACCEL_MASK", "mask" },
 
20
      { 0, NULL, NULL }
 
21
    };
 
22
    etype = g_flags_register_static (g_intern_static_string ("GtkAccelFlags"), values);
 
23
  }
 
24
  return etype;
 
25
}
 
26
 
 
27
/* enumerations from "gtkassistant.h" */
 
28
GType
 
29
gtk_assistant_page_type_get_type (void)
 
30
{
 
31
  static GType etype = 0;
 
32
  if (etype == 0) {
 
33
    static const GEnumValue values[] = {
 
34
      { GTK_ASSISTANT_PAGE_CONTENT, "GTK_ASSISTANT_PAGE_CONTENT", "content" },
 
35
      { GTK_ASSISTANT_PAGE_INTRO, "GTK_ASSISTANT_PAGE_INTRO", "intro" },
 
36
      { GTK_ASSISTANT_PAGE_CONFIRM, "GTK_ASSISTANT_PAGE_CONFIRM", "confirm" },
 
37
      { GTK_ASSISTANT_PAGE_SUMMARY, "GTK_ASSISTANT_PAGE_SUMMARY", "summary" },
 
38
      { GTK_ASSISTANT_PAGE_PROGRESS, "GTK_ASSISTANT_PAGE_PROGRESS", "progress" },
 
39
      { 0, NULL, NULL }
 
40
    };
 
41
    etype = g_enum_register_static (g_intern_static_string ("GtkAssistantPageType"), values);
 
42
  }
 
43
  return etype;
 
44
}
 
45
 
 
46
/* enumerations from "gtkcalendar.h" */
 
47
GType
 
48
gtk_calendar_display_options_get_type (void)
 
49
{
 
50
  static GType etype = 0;
 
51
  if (etype == 0) {
 
52
    static const GFlagsValue values[] = {
 
53
      { GTK_CALENDAR_SHOW_HEADING, "GTK_CALENDAR_SHOW_HEADING", "show-heading" },
 
54
      { GTK_CALENDAR_SHOW_DAY_NAMES, "GTK_CALENDAR_SHOW_DAY_NAMES", "show-day-names" },
 
55
      { GTK_CALENDAR_NO_MONTH_CHANGE, "GTK_CALENDAR_NO_MONTH_CHANGE", "no-month-change" },
 
56
      { GTK_CALENDAR_SHOW_WEEK_NUMBERS, "GTK_CALENDAR_SHOW_WEEK_NUMBERS", "show-week-numbers" },
 
57
      { GTK_CALENDAR_WEEK_START_MONDAY, "GTK_CALENDAR_WEEK_START_MONDAY", "week-start-monday" },
 
58
      { 0, NULL, NULL }
 
59
    };
 
60
    etype = g_flags_register_static (g_intern_static_string ("GtkCalendarDisplayOptions"), values);
 
61
  }
 
62
  return etype;
 
63
}
 
64
 
 
65
/* enumerations from "gtkcellrenderer.h" */
 
66
GType
 
67
gtk_cell_renderer_state_get_type (void)
 
68
{
 
69
  static GType etype = 0;
 
70
  if (etype == 0) {
 
71
    static const GFlagsValue values[] = {
 
72
      { GTK_CELL_RENDERER_SELECTED, "GTK_CELL_RENDERER_SELECTED", "selected" },
 
73
      { GTK_CELL_RENDERER_PRELIT, "GTK_CELL_RENDERER_PRELIT", "prelit" },
 
74
      { GTK_CELL_RENDERER_INSENSITIVE, "GTK_CELL_RENDERER_INSENSITIVE", "insensitive" },
 
75
      { GTK_CELL_RENDERER_SORTED, "GTK_CELL_RENDERER_SORTED", "sorted" },
 
76
      { GTK_CELL_RENDERER_FOCUSED, "GTK_CELL_RENDERER_FOCUSED", "focused" },
 
77
      { 0, NULL, NULL }
 
78
    };
 
79
    etype = g_flags_register_static (g_intern_static_string ("GtkCellRendererState"), values);
 
80
  }
 
81
  return etype;
 
82
}
 
83
GType
 
84
gtk_cell_renderer_mode_get_type (void)
 
85
{
 
86
  static GType etype = 0;
 
87
  if (etype == 0) {
 
88
    static const GEnumValue values[] = {
 
89
      { GTK_CELL_RENDERER_MODE_INERT, "GTK_CELL_RENDERER_MODE_INERT", "inert" },
 
90
      { GTK_CELL_RENDERER_MODE_ACTIVATABLE, "GTK_CELL_RENDERER_MODE_ACTIVATABLE", "activatable" },
 
91
      { GTK_CELL_RENDERER_MODE_EDITABLE, "GTK_CELL_RENDERER_MODE_EDITABLE", "editable" },
 
92
      { 0, NULL, NULL }
 
93
    };
 
94
    etype = g_enum_register_static (g_intern_static_string ("GtkCellRendererMode"), values);
 
95
  }
 
96
  return etype;
 
97
}
 
98
 
 
99
/* enumerations from "gtkcellrendereraccel.h" */
 
100
GType
 
101
gtk_cell_renderer_accel_mode_get_type (void)
 
102
{
 
103
  static GType etype = 0;
 
104
  if (etype == 0) {
 
105
    static const GEnumValue values[] = {
 
106
      { GTK_CELL_RENDERER_ACCEL_MODE_GTK, "GTK_CELL_RENDERER_ACCEL_MODE_GTK", "gtk" },
 
107
      { GTK_CELL_RENDERER_ACCEL_MODE_OTHER, "GTK_CELL_RENDERER_ACCEL_MODE_OTHER", "other" },
 
108
      { 0, NULL, NULL }
 
109
    };
 
110
    etype = g_enum_register_static (g_intern_static_string ("GtkCellRendererAccelMode"), values);
 
111
  }
 
112
  return etype;
 
113
}
 
114
 
 
115
/* enumerations from "gtkclist.h" */
 
116
GType
 
117
gtk_cell_type_get_type (void)
 
118
{
 
119
  static GType etype = 0;
 
120
  if (etype == 0) {
 
121
    static const GEnumValue values[] = {
 
122
      { GTK_CELL_EMPTY, "GTK_CELL_EMPTY", "empty" },
 
123
      { GTK_CELL_TEXT, "GTK_CELL_TEXT", "text" },
 
124
      { GTK_CELL_PIXMAP, "GTK_CELL_PIXMAP", "pixmap" },
 
125
      { GTK_CELL_PIXTEXT, "GTK_CELL_PIXTEXT", "pixtext" },
 
126
      { GTK_CELL_WIDGET, "GTK_CELL_WIDGET", "widget" },
 
127
      { 0, NULL, NULL }
 
128
    };
 
129
    etype = g_enum_register_static (g_intern_static_string ("GtkCellType"), values);
 
130
  }
 
131
  return etype;
 
132
}
 
133
GType
 
134
gtk_clist_drag_pos_get_type (void)
 
135
{
 
136
  static GType etype = 0;
 
137
  if (etype == 0) {
 
138
    static const GEnumValue values[] = {
 
139
      { GTK_CLIST_DRAG_NONE, "GTK_CLIST_DRAG_NONE", "none" },
 
140
      { GTK_CLIST_DRAG_BEFORE, "GTK_CLIST_DRAG_BEFORE", "before" },
 
141
      { GTK_CLIST_DRAG_INTO, "GTK_CLIST_DRAG_INTO", "into" },
 
142
      { GTK_CLIST_DRAG_AFTER, "GTK_CLIST_DRAG_AFTER", "after" },
 
143
      { 0, NULL, NULL }
 
144
    };
 
145
    etype = g_enum_register_static (g_intern_static_string ("GtkCListDragPos"), values);
 
146
  }
 
147
  return etype;
 
148
}
 
149
GType
 
150
gtk_button_action_get_type (void)
 
151
{
 
152
  static GType etype = 0;
 
153
  if (etype == 0) {
 
154
    static const GFlagsValue values[] = {
 
155
      { GTK_BUTTON_IGNORED, "GTK_BUTTON_IGNORED", "ignored" },
 
156
      { GTK_BUTTON_SELECTS, "GTK_BUTTON_SELECTS", "selects" },
 
157
      { GTK_BUTTON_DRAGS, "GTK_BUTTON_DRAGS", "drags" },
 
158
      { GTK_BUTTON_EXPANDS, "GTK_BUTTON_EXPANDS", "expands" },
 
159
      { 0, NULL, NULL }
 
160
    };
 
161
    etype = g_flags_register_static (g_intern_static_string ("GtkButtonAction"), values);
 
162
  }
 
163
  return etype;
 
164
}
 
165
 
 
166
/* enumerations from "gtkctree.h" */
 
167
GType
 
168
gtk_ctree_pos_get_type (void)
 
169
{
 
170
  static GType etype = 0;
 
171
  if (etype == 0) {
 
172
    static const GEnumValue values[] = {
 
173
      { GTK_CTREE_POS_BEFORE, "GTK_CTREE_POS_BEFORE", "before" },
 
174
      { GTK_CTREE_POS_AS_CHILD, "GTK_CTREE_POS_AS_CHILD", "as-child" },
 
175
      { GTK_CTREE_POS_AFTER, "GTK_CTREE_POS_AFTER", "after" },
 
176
      { 0, NULL, NULL }
 
177
    };
 
178
    etype = g_enum_register_static (g_intern_static_string ("GtkCTreePos"), values);
 
179
  }
 
180
  return etype;
 
181
}
 
182
GType
 
183
gtk_ctree_line_style_get_type (void)
 
184
{
 
185
  static GType etype = 0;
 
186
  if (etype == 0) {
 
187
    static const GEnumValue values[] = {
 
188
      { GTK_CTREE_LINES_NONE, "GTK_CTREE_LINES_NONE", "none" },
 
189
      { GTK_CTREE_LINES_SOLID, "GTK_CTREE_LINES_SOLID", "solid" },
 
190
      { GTK_CTREE_LINES_DOTTED, "GTK_CTREE_LINES_DOTTED", "dotted" },
 
191
      { GTK_CTREE_LINES_TABBED, "GTK_CTREE_LINES_TABBED", "tabbed" },
 
192
      { 0, NULL, NULL }
 
193
    };
 
194
    etype = g_enum_register_static (g_intern_static_string ("GtkCTreeLineStyle"), values);
 
195
  }
 
196
  return etype;
 
197
}
 
198
GType
 
199
gtk_ctree_expander_style_get_type (void)
 
200
{
 
201
  static GType etype = 0;
 
202
  if (etype == 0) {
 
203
    static const GEnumValue values[] = {
 
204
      { GTK_CTREE_EXPANDER_NONE, "GTK_CTREE_EXPANDER_NONE", "none" },
 
205
      { GTK_CTREE_EXPANDER_SQUARE, "GTK_CTREE_EXPANDER_SQUARE", "square" },
 
206
      { GTK_CTREE_EXPANDER_TRIANGLE, "GTK_CTREE_EXPANDER_TRIANGLE", "triangle" },
 
207
      { GTK_CTREE_EXPANDER_CIRCULAR, "GTK_CTREE_EXPANDER_CIRCULAR", "circular" },
 
208
      { 0, NULL, NULL }
 
209
    };
 
210
    etype = g_enum_register_static (g_intern_static_string ("GtkCTreeExpanderStyle"), values);
 
211
  }
 
212
  return etype;
 
213
}
 
214
GType
 
215
gtk_ctree_expansion_type_get_type (void)
 
216
{
 
217
  static GType etype = 0;
 
218
  if (etype == 0) {
 
219
    static const GEnumValue values[] = {
 
220
      { GTK_CTREE_EXPANSION_EXPAND, "GTK_CTREE_EXPANSION_EXPAND", "expand" },
 
221
      { GTK_CTREE_EXPANSION_EXPAND_RECURSIVE, "GTK_CTREE_EXPANSION_EXPAND_RECURSIVE", "expand-recursive" },
 
222
      { GTK_CTREE_EXPANSION_COLLAPSE, "GTK_CTREE_EXPANSION_COLLAPSE", "collapse" },
 
223
      { GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE, "GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE", "collapse-recursive" },
 
224
      { GTK_CTREE_EXPANSION_TOGGLE, "GTK_CTREE_EXPANSION_TOGGLE", "toggle" },
 
225
      { GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE, "GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE", "toggle-recursive" },
 
226
      { 0, NULL, NULL }
 
227
    };
 
228
    etype = g_enum_register_static (g_intern_static_string ("GtkCTreeExpansionType"), values);
 
229
  }
 
230
  return etype;
 
231
}
 
232
 
 
233
/* enumerations from "gtkdebug.h" */
 
234
GType
 
235
gtk_debug_flag_get_type (void)
 
236
{
 
237
  static GType etype = 0;
 
238
  if (etype == 0) {
 
239
    static const GFlagsValue values[] = {
 
240
      { GTK_DEBUG_MISC, "GTK_DEBUG_MISC", "misc" },
 
241
      { GTK_DEBUG_PLUGSOCKET, "GTK_DEBUG_PLUGSOCKET", "plugsocket" },
 
242
      { GTK_DEBUG_TEXT, "GTK_DEBUG_TEXT", "text" },
 
243
      { GTK_DEBUG_TREE, "GTK_DEBUG_TREE", "tree" },
 
244
      { GTK_DEBUG_UPDATES, "GTK_DEBUG_UPDATES", "updates" },
 
245
      { GTK_DEBUG_KEYBINDINGS, "GTK_DEBUG_KEYBINDINGS", "keybindings" },
 
246
      { GTK_DEBUG_MULTIHEAD, "GTK_DEBUG_MULTIHEAD", "multihead" },
 
247
      { GTK_DEBUG_MODULES, "GTK_DEBUG_MODULES", "modules" },
 
248
      { GTK_DEBUG_GEOMETRY, "GTK_DEBUG_GEOMETRY", "geometry" },
 
249
      { GTK_DEBUG_ICONTHEME, "GTK_DEBUG_ICONTHEME", "icontheme" },
 
250
      { GTK_DEBUG_PRINTING, "GTK_DEBUG_PRINTING", "printing" },
 
251
      { 0, NULL, NULL }
 
252
    };
 
253
    etype = g_flags_register_static (g_intern_static_string ("GtkDebugFlag"), values);
 
254
  }
 
255
  return etype;
 
256
}
 
257
 
 
258
/* enumerations from "gtkdialog.h" */
 
259
GType
 
260
gtk_dialog_flags_get_type (void)
 
261
{
 
262
  static GType etype = 0;
 
263
  if (etype == 0) {
 
264
    static const GFlagsValue values[] = {
 
265
      { GTK_DIALOG_MODAL, "GTK_DIALOG_MODAL", "modal" },
 
266
      { GTK_DIALOG_DESTROY_WITH_PARENT, "GTK_DIALOG_DESTROY_WITH_PARENT", "destroy-with-parent" },
 
267
      { GTK_DIALOG_NO_SEPARATOR, "GTK_DIALOG_NO_SEPARATOR", "no-separator" },
 
268
      { 0, NULL, NULL }
 
269
    };
 
270
    etype = g_flags_register_static (g_intern_static_string ("GtkDialogFlags"), values);
 
271
  }
 
272
  return etype;
 
273
}
 
274
GType
 
275
gtk_response_type_get_type (void)
 
276
{
 
277
  static GType etype = 0;
 
278
  if (etype == 0) {
 
279
    static const GEnumValue values[] = {
 
280
      { GTK_RESPONSE_NONE, "GTK_RESPONSE_NONE", "none" },
 
281
      { GTK_RESPONSE_REJECT, "GTK_RESPONSE_REJECT", "reject" },
 
282
      { GTK_RESPONSE_ACCEPT, "GTK_RESPONSE_ACCEPT", "accept" },
 
283
      { GTK_RESPONSE_DELETE_EVENT, "GTK_RESPONSE_DELETE_EVENT", "delete-event" },
 
284
      { GTK_RESPONSE_OK, "GTK_RESPONSE_OK", "ok" },
 
285
      { GTK_RESPONSE_CANCEL, "GTK_RESPONSE_CANCEL", "cancel" },
 
286
      { GTK_RESPONSE_CLOSE, "GTK_RESPONSE_CLOSE", "close" },
 
287
      { GTK_RESPONSE_YES, "GTK_RESPONSE_YES", "yes" },
 
288
      { GTK_RESPONSE_NO, "GTK_RESPONSE_NO", "no" },
 
289
      { GTK_RESPONSE_APPLY, "GTK_RESPONSE_APPLY", "apply" },
 
290
      { GTK_RESPONSE_HELP, "GTK_RESPONSE_HELP", "help" },
 
291
      { 0, NULL, NULL }
 
292
    };
 
293
    etype = g_enum_register_static (g_intern_static_string ("GtkResponseType"), values);
 
294
  }
 
295
  return etype;
 
296
}
 
297
 
 
298
/* enumerations from "gtkdnd.h" */
 
299
GType
 
300
gtk_dest_defaults_get_type (void)
 
301
{
 
302
  static GType etype = 0;
 
303
  if (etype == 0) {
 
304
    static const GFlagsValue values[] = {
 
305
      { GTK_DEST_DEFAULT_MOTION, "GTK_DEST_DEFAULT_MOTION", "motion" },
 
306
      { GTK_DEST_DEFAULT_HIGHLIGHT, "GTK_DEST_DEFAULT_HIGHLIGHT", "highlight" },
 
307
      { GTK_DEST_DEFAULT_DROP, "GTK_DEST_DEFAULT_DROP", "drop" },
 
308
      { GTK_DEST_DEFAULT_ALL, "GTK_DEST_DEFAULT_ALL", "all" },
 
309
      { 0, NULL, NULL }
 
310
    };
 
311
    etype = g_flags_register_static (g_intern_static_string ("GtkDestDefaults"), values);
 
312
  }
 
313
  return etype;
 
314
}
 
315
GType
 
316
gtk_target_flags_get_type (void)
 
317
{
 
318
  static GType etype = 0;
 
319
  if (etype == 0) {
 
320
    static const GFlagsValue values[] = {
 
321
      { GTK_TARGET_SAME_APP, "GTK_TARGET_SAME_APP", "same-app" },
 
322
      { GTK_TARGET_SAME_WIDGET, "GTK_TARGET_SAME_WIDGET", "same-widget" },
 
323
      { 0, NULL, NULL }
 
324
    };
 
325
    etype = g_flags_register_static (g_intern_static_string ("GtkTargetFlags"), values);
 
326
  }
 
327
  return etype;
 
328
}
 
329
 
 
330
/* enumerations from "gtkenums.h" */
 
331
GType
 
332
gtk_anchor_type_get_type (void)
 
333
{
 
334
  static GType etype = 0;
 
335
  if (etype == 0) {
 
336
    static const GEnumValue values[] = {
 
337
      { GTK_ANCHOR_CENTER, "GTK_ANCHOR_CENTER", "center" },
 
338
      { GTK_ANCHOR_NORTH, "GTK_ANCHOR_NORTH", "north" },
 
339
      { GTK_ANCHOR_NORTH_WEST, "GTK_ANCHOR_NORTH_WEST", "north-west" },
 
340
      { GTK_ANCHOR_NORTH_EAST, "GTK_ANCHOR_NORTH_EAST", "north-east" },
 
341
      { GTK_ANCHOR_SOUTH, "GTK_ANCHOR_SOUTH", "south" },
 
342
      { GTK_ANCHOR_SOUTH_WEST, "GTK_ANCHOR_SOUTH_WEST", "south-west" },
 
343
      { GTK_ANCHOR_SOUTH_EAST, "GTK_ANCHOR_SOUTH_EAST", "south-east" },
 
344
      { GTK_ANCHOR_WEST, "GTK_ANCHOR_WEST", "west" },
 
345
      { GTK_ANCHOR_EAST, "GTK_ANCHOR_EAST", "east" },
 
346
      { GTK_ANCHOR_N, "GTK_ANCHOR_N", "n" },
 
347
      { GTK_ANCHOR_NW, "GTK_ANCHOR_NW", "nw" },
 
348
      { GTK_ANCHOR_NE, "GTK_ANCHOR_NE", "ne" },
 
349
      { GTK_ANCHOR_S, "GTK_ANCHOR_S", "s" },
 
350
      { GTK_ANCHOR_SW, "GTK_ANCHOR_SW", "sw" },
 
351
      { GTK_ANCHOR_SE, "GTK_ANCHOR_SE", "se" },
 
352
      { GTK_ANCHOR_W, "GTK_ANCHOR_W", "w" },
 
353
      { GTK_ANCHOR_E, "GTK_ANCHOR_E", "e" },
 
354
      { 0, NULL, NULL }
 
355
    };
 
356
    etype = g_enum_register_static (g_intern_static_string ("GtkAnchorType"), values);
 
357
  }
 
358
  return etype;
 
359
}
 
360
GType
 
361
gtk_arrow_type_get_type (void)
 
362
{
 
363
  static GType etype = 0;
 
364
  if (etype == 0) {
 
365
    static const GEnumValue values[] = {
 
366
      { GTK_ARROW_UP, "GTK_ARROW_UP", "up" },
 
367
      { GTK_ARROW_DOWN, "GTK_ARROW_DOWN", "down" },
 
368
      { GTK_ARROW_LEFT, "GTK_ARROW_LEFT", "left" },
 
369
      { GTK_ARROW_RIGHT, "GTK_ARROW_RIGHT", "right" },
 
370
      { GTK_ARROW_NONE, "GTK_ARROW_NONE", "none" },
 
371
      { 0, NULL, NULL }
 
372
    };
 
373
    etype = g_enum_register_static (g_intern_static_string ("GtkArrowType"), values);
 
374
  }
 
375
  return etype;
 
376
}
 
377
GType
 
378
gtk_attach_options_get_type (void)
 
379
{
 
380
  static GType etype = 0;
 
381
  if (etype == 0) {
 
382
    static const GFlagsValue values[] = {
 
383
      { GTK_EXPAND, "GTK_EXPAND", "expand" },
 
384
      { GTK_SHRINK, "GTK_SHRINK", "shrink" },
 
385
      { GTK_FILL, "GTK_FILL", "fill" },
 
386
      { 0, NULL, NULL }
 
387
    };
 
388
    etype = g_flags_register_static (g_intern_static_string ("GtkAttachOptions"), values);
 
389
  }
 
390
  return etype;
 
391
}
 
392
GType
 
393
gtk_button_box_style_get_type (void)
 
394
{
 
395
  static GType etype = 0;
 
396
  if (etype == 0) {
 
397
    static const GEnumValue values[] = {
 
398
      { GTK_BUTTONBOX_DEFAULT_STYLE, "GTK_BUTTONBOX_DEFAULT_STYLE", "default-style" },
 
399
      { GTK_BUTTONBOX_SPREAD, "GTK_BUTTONBOX_SPREAD", "spread" },
 
400
      { GTK_BUTTONBOX_EDGE, "GTK_BUTTONBOX_EDGE", "edge" },
 
401
      { GTK_BUTTONBOX_START, "GTK_BUTTONBOX_START", "start" },
 
402
      { GTK_BUTTONBOX_END, "GTK_BUTTONBOX_END", "end" },
 
403
      { 0, NULL, NULL }
 
404
    };
 
405
    etype = g_enum_register_static (g_intern_static_string ("GtkButtonBoxStyle"), values);
 
406
  }
 
407
  return etype;
 
408
}
 
409
GType
 
410
gtk_curve_type_get_type (void)
 
411
{
 
412
  static GType etype = 0;
 
413
  if (etype == 0) {
 
414
    static const GEnumValue values[] = {
 
415
      { GTK_CURVE_TYPE_LINEAR, "GTK_CURVE_TYPE_LINEAR", "linear" },
 
416
      { GTK_CURVE_TYPE_SPLINE, "GTK_CURVE_TYPE_SPLINE", "spline" },
 
417
      { GTK_CURVE_TYPE_FREE, "GTK_CURVE_TYPE_FREE", "free" },
 
418
      { 0, NULL, NULL }
 
419
    };
 
420
    etype = g_enum_register_static (g_intern_static_string ("GtkCurveType"), values);
 
421
  }
 
422
  return etype;
 
423
}
 
424
GType
 
425
gtk_delete_type_get_type (void)
 
426
{
 
427
  static GType etype = 0;
 
428
  if (etype == 0) {
 
429
    static const GEnumValue values[] = {
 
430
      { GTK_DELETE_CHARS, "GTK_DELETE_CHARS", "chars" },
 
431
      { GTK_DELETE_WORD_ENDS, "GTK_DELETE_WORD_ENDS", "word-ends" },
 
432
      { GTK_DELETE_WORDS, "GTK_DELETE_WORDS", "words" },
 
433
      { GTK_DELETE_DISPLAY_LINES, "GTK_DELETE_DISPLAY_LINES", "display-lines" },
 
434
      { GTK_DELETE_DISPLAY_LINE_ENDS, "GTK_DELETE_DISPLAY_LINE_ENDS", "display-line-ends" },
 
435
      { GTK_DELETE_PARAGRAPH_ENDS, "GTK_DELETE_PARAGRAPH_ENDS", "paragraph-ends" },
 
436
      { GTK_DELETE_PARAGRAPHS, "GTK_DELETE_PARAGRAPHS", "paragraphs" },
 
437
      { GTK_DELETE_WHITESPACE, "GTK_DELETE_WHITESPACE", "whitespace" },
 
438
      { 0, NULL, NULL }
 
439
    };
 
440
    etype = g_enum_register_static (g_intern_static_string ("GtkDeleteType"), values);
 
441
  }
 
442
  return etype;
 
443
}
 
444
GType
 
445
gtk_direction_type_get_type (void)
 
446
{
 
447
  static GType etype = 0;
 
448
  if (etype == 0) {
 
449
    static const GEnumValue values[] = {
 
450
      { GTK_DIR_TAB_FORWARD, "GTK_DIR_TAB_FORWARD", "tab-forward" },
 
451
      { GTK_DIR_TAB_BACKWARD, "GTK_DIR_TAB_BACKWARD", "tab-backward" },
 
452
      { GTK_DIR_UP, "GTK_DIR_UP", "up" },
 
453
      { GTK_DIR_DOWN, "GTK_DIR_DOWN", "down" },
 
454
      { GTK_DIR_LEFT, "GTK_DIR_LEFT", "left" },
 
455
      { GTK_DIR_RIGHT, "GTK_DIR_RIGHT", "right" },
 
456
      { 0, NULL, NULL }
 
457
    };
 
458
    etype = g_enum_register_static (g_intern_static_string ("GtkDirectionType"), values);
 
459
  }
 
460
  return etype;
 
461
}
 
462
GType
 
463
gtk_expander_style_get_type (void)
 
464
{
 
465
  static GType etype = 0;
 
466
  if (etype == 0) {
 
467
    static const GEnumValue values[] = {
 
468
      { GTK_EXPANDER_COLLAPSED, "GTK_EXPANDER_COLLAPSED", "collapsed" },
 
469
      { GTK_EXPANDER_SEMI_COLLAPSED, "GTK_EXPANDER_SEMI_COLLAPSED", "semi-collapsed" },
 
470
      { GTK_EXPANDER_SEMI_EXPANDED, "GTK_EXPANDER_SEMI_EXPANDED", "semi-expanded" },
 
471
      { GTK_EXPANDER_EXPANDED, "GTK_EXPANDER_EXPANDED", "expanded" },
 
472
      { 0, NULL, NULL }
 
473
    };
 
474
    etype = g_enum_register_static (g_intern_static_string ("GtkExpanderStyle"), values);
 
475
  }
 
476
  return etype;
 
477
}
 
478
GType
 
479
gtk_icon_size_get_type (void)
 
480
{
 
481
  static GType etype = 0;
 
482
  if (etype == 0) {
 
483
    static const GEnumValue values[] = {
 
484
      { GTK_ICON_SIZE_INVALID, "GTK_ICON_SIZE_INVALID", "invalid" },
 
485
      { GTK_ICON_SIZE_MENU, "GTK_ICON_SIZE_MENU", "menu" },
 
486
      { GTK_ICON_SIZE_SMALL_TOOLBAR, "GTK_ICON_SIZE_SMALL_TOOLBAR", "small-toolbar" },
 
487
      { GTK_ICON_SIZE_LARGE_TOOLBAR, "GTK_ICON_SIZE_LARGE_TOOLBAR", "large-toolbar" },
 
488
      { GTK_ICON_SIZE_BUTTON, "GTK_ICON_SIZE_BUTTON", "button" },
 
489
      { GTK_ICON_SIZE_DND, "GTK_ICON_SIZE_DND", "dnd" },
 
490
      { GTK_ICON_SIZE_DIALOG, "GTK_ICON_SIZE_DIALOG", "dialog" },
 
491
      { 0, NULL, NULL }
 
492
    };
 
493
    etype = g_enum_register_static (g_intern_static_string ("GtkIconSize"), values);
 
494
  }
 
495
  return etype;
 
496
}
 
497
GType
 
498
gtk_sensitivity_type_get_type (void)
 
499
{
 
500
  static GType etype = 0;
 
501
  if (etype == 0) {
 
502
    static const GEnumValue values[] = {
 
503
      { GTK_SENSITIVITY_AUTO, "GTK_SENSITIVITY_AUTO", "auto" },
 
504
      { GTK_SENSITIVITY_ON, "GTK_SENSITIVITY_ON", "on" },
 
505
      { GTK_SENSITIVITY_OFF, "GTK_SENSITIVITY_OFF", "off" },
 
506
      { 0, NULL, NULL }
 
507
    };
 
508
    etype = g_enum_register_static (g_intern_static_string ("GtkSensitivityType"), values);
 
509
  }
 
510
  return etype;
 
511
}
 
512
GType
 
513
gtk_side_type_get_type (void)
 
514
{
 
515
  static GType etype = 0;
 
516
  if (etype == 0) {
 
517
    static const GEnumValue values[] = {
 
518
      { GTK_SIDE_TOP, "GTK_SIDE_TOP", "top" },
 
519
      { GTK_SIDE_BOTTOM, "GTK_SIDE_BOTTOM", "bottom" },
 
520
      { GTK_SIDE_LEFT, "GTK_SIDE_LEFT", "left" },
 
521
      { GTK_SIDE_RIGHT, "GTK_SIDE_RIGHT", "right" },
 
522
      { 0, NULL, NULL }
 
523
    };
 
524
    etype = g_enum_register_static (g_intern_static_string ("GtkSideType"), values);
 
525
  }
 
526
  return etype;
 
527
}
 
528
GType
 
529
gtk_text_direction_get_type (void)
 
530
{
 
531
  static GType etype = 0;
 
532
  if (etype == 0) {
 
533
    static const GEnumValue values[] = {
 
534
      { GTK_TEXT_DIR_NONE, "GTK_TEXT_DIR_NONE", "none" },
 
535
      { GTK_TEXT_DIR_LTR, "GTK_TEXT_DIR_LTR", "ltr" },
 
536
      { GTK_TEXT_DIR_RTL, "GTK_TEXT_DIR_RTL", "rtl" },
 
537
      { 0, NULL, NULL }
 
538
    };
 
539
    etype = g_enum_register_static (g_intern_static_string ("GtkTextDirection"), values);
 
540
  }
 
541
  return etype;
 
542
}
 
543
GType
 
544
gtk_justification_get_type (void)
 
545
{
 
546
  static GType etype = 0;
 
547
  if (etype == 0) {
 
548
    static const GEnumValue values[] = {
 
549
      { GTK_JUSTIFY_LEFT, "GTK_JUSTIFY_LEFT", "left" },
 
550
      { GTK_JUSTIFY_RIGHT, "GTK_JUSTIFY_RIGHT", "right" },
 
551
      { GTK_JUSTIFY_CENTER, "GTK_JUSTIFY_CENTER", "center" },
 
552
      { GTK_JUSTIFY_FILL, "GTK_JUSTIFY_FILL", "fill" },
 
553
      { 0, NULL, NULL }
 
554
    };
 
555
    etype = g_enum_register_static (g_intern_static_string ("GtkJustification"), values);
 
556
  }
 
557
  return etype;
 
558
}
 
559
GType
 
560
gtk_match_type_get_type (void)
 
561
{
 
562
  static GType etype = 0;
 
563
  if (etype == 0) {
 
564
    static const GEnumValue values[] = {
 
565
      { GTK_MATCH_ALL, "GTK_MATCH_ALL", "all" },
 
566
      { GTK_MATCH_ALL_TAIL, "GTK_MATCH_ALL_TAIL", "all-tail" },
 
567
      { GTK_MATCH_HEAD, "GTK_MATCH_HEAD", "head" },
 
568
      { GTK_MATCH_TAIL, "GTK_MATCH_TAIL", "tail" },
 
569
      { GTK_MATCH_EXACT, "GTK_MATCH_EXACT", "exact" },
 
570
      { GTK_MATCH_LAST, "GTK_MATCH_LAST", "last" },
 
571
      { 0, NULL, NULL }
 
572
    };
 
573
    etype = g_enum_register_static (g_intern_static_string ("GtkMatchType"), values);
 
574
  }
 
575
  return etype;
 
576
}
 
577
GType
 
578
gtk_menu_direction_type_get_type (void)
 
579
{
 
580
  static GType etype = 0;
 
581
  if (etype == 0) {
 
582
    static const GEnumValue values[] = {
 
583
      { GTK_MENU_DIR_PARENT, "GTK_MENU_DIR_PARENT", "parent" },
 
584
      { GTK_MENU_DIR_CHILD, "GTK_MENU_DIR_CHILD", "child" },
 
585
      { GTK_MENU_DIR_NEXT, "GTK_MENU_DIR_NEXT", "next" },
 
586
      { GTK_MENU_DIR_PREV, "GTK_MENU_DIR_PREV", "prev" },
 
587
      { 0, NULL, NULL }
 
588
    };
 
589
    etype = g_enum_register_static (g_intern_static_string ("GtkMenuDirectionType"), values);
 
590
  }
 
591
  return etype;
 
592
}
 
593
GType
 
594
gtk_metric_type_get_type (void)
 
595
{
 
596
  static GType etype = 0;
 
597
  if (etype == 0) {
 
598
    static const GEnumValue values[] = {
 
599
      { GTK_PIXELS, "GTK_PIXELS", "pixels" },
 
600
      { GTK_INCHES, "GTK_INCHES", "inches" },
 
601
      { GTK_CENTIMETERS, "GTK_CENTIMETERS", "centimeters" },
 
602
      { 0, NULL, NULL }
 
603
    };
 
604
    etype = g_enum_register_static (g_intern_static_string ("GtkMetricType"), values);
 
605
  }
 
606
  return etype;
 
607
}
 
608
GType
 
609
gtk_movement_step_get_type (void)
 
610
{
 
611
  static GType etype = 0;
 
612
  if (etype == 0) {
 
613
    static const GEnumValue values[] = {
 
614
      { GTK_MOVEMENT_LOGICAL_POSITIONS, "GTK_MOVEMENT_LOGICAL_POSITIONS", "logical-positions" },
 
615
      { GTK_MOVEMENT_VISUAL_POSITIONS, "GTK_MOVEMENT_VISUAL_POSITIONS", "visual-positions" },
 
616
      { GTK_MOVEMENT_WORDS, "GTK_MOVEMENT_WORDS", "words" },
 
617
      { GTK_MOVEMENT_DISPLAY_LINES, "GTK_MOVEMENT_DISPLAY_LINES", "display-lines" },
 
618
      { GTK_MOVEMENT_DISPLAY_LINE_ENDS, "GTK_MOVEMENT_DISPLAY_LINE_ENDS", "display-line-ends" },
 
619
      { GTK_MOVEMENT_PARAGRAPHS, "GTK_MOVEMENT_PARAGRAPHS", "paragraphs" },
 
620
      { GTK_MOVEMENT_PARAGRAPH_ENDS, "GTK_MOVEMENT_PARAGRAPH_ENDS", "paragraph-ends" },
 
621
      { GTK_MOVEMENT_PAGES, "GTK_MOVEMENT_PAGES", "pages" },
 
622
      { GTK_MOVEMENT_BUFFER_ENDS, "GTK_MOVEMENT_BUFFER_ENDS", "buffer-ends" },
 
623
      { GTK_MOVEMENT_HORIZONTAL_PAGES, "GTK_MOVEMENT_HORIZONTAL_PAGES", "horizontal-pages" },
 
624
      { 0, NULL, NULL }
 
625
    };
 
626
    etype = g_enum_register_static (g_intern_static_string ("GtkMovementStep"), values);
 
627
  }
 
628
  return etype;
 
629
}
 
630
GType
 
631
gtk_scroll_step_get_type (void)
 
632
{
 
633
  static GType etype = 0;
 
634
  if (etype == 0) {
 
635
    static const GEnumValue values[] = {
 
636
      { GTK_SCROLL_STEPS, "GTK_SCROLL_STEPS", "steps" },
 
637
      { GTK_SCROLL_PAGES, "GTK_SCROLL_PAGES", "pages" },
 
638
      { GTK_SCROLL_ENDS, "GTK_SCROLL_ENDS", "ends" },
 
639
      { GTK_SCROLL_HORIZONTAL_STEPS, "GTK_SCROLL_HORIZONTAL_STEPS", "horizontal-steps" },
 
640
      { GTK_SCROLL_HORIZONTAL_PAGES, "GTK_SCROLL_HORIZONTAL_PAGES", "horizontal-pages" },
 
641
      { GTK_SCROLL_HORIZONTAL_ENDS, "GTK_SCROLL_HORIZONTAL_ENDS", "horizontal-ends" },
 
642
      { 0, NULL, NULL }
 
643
    };
 
644
    etype = g_enum_register_static (g_intern_static_string ("GtkScrollStep"), values);
 
645
  }
 
646
  return etype;
 
647
}
 
648
GType
 
649
gtk_orientation_get_type (void)
 
650
{
 
651
  static GType etype = 0;
 
652
  if (etype == 0) {
 
653
    static const GEnumValue values[] = {
 
654
      { GTK_ORIENTATION_HORIZONTAL, "GTK_ORIENTATION_HORIZONTAL", "horizontal" },
 
655
      { GTK_ORIENTATION_VERTICAL, "GTK_ORIENTATION_VERTICAL", "vertical" },
 
656
      { 0, NULL, NULL }
 
657
    };
 
658
    etype = g_enum_register_static (g_intern_static_string ("GtkOrientation"), values);
 
659
  }
 
660
  return etype;
 
661
}
 
662
GType
 
663
gtk_corner_type_get_type (void)
 
664
{
 
665
  static GType etype = 0;
 
666
  if (etype == 0) {
 
667
    static const GEnumValue values[] = {
 
668
      { GTK_CORNER_TOP_LEFT, "GTK_CORNER_TOP_LEFT", "top-left" },
 
669
      { GTK_CORNER_BOTTOM_LEFT, "GTK_CORNER_BOTTOM_LEFT", "bottom-left" },
 
670
      { GTK_CORNER_TOP_RIGHT, "GTK_CORNER_TOP_RIGHT", "top-right" },
 
671
      { GTK_CORNER_BOTTOM_RIGHT, "GTK_CORNER_BOTTOM_RIGHT", "bottom-right" },
 
672
      { 0, NULL, NULL }
 
673
    };
 
674
    etype = g_enum_register_static (g_intern_static_string ("GtkCornerType"), values);
 
675
  }
 
676
  return etype;
 
677
}
 
678
GType
 
679
gtk_pack_type_get_type (void)
 
680
{
 
681
  static GType etype = 0;
 
682
  if (etype == 0) {
 
683
    static const GEnumValue values[] = {
 
684
      { GTK_PACK_START, "GTK_PACK_START", "start" },
 
685
      { GTK_PACK_END, "GTK_PACK_END", "end" },
 
686
      { 0, NULL, NULL }
 
687
    };
 
688
    etype = g_enum_register_static (g_intern_static_string ("GtkPackType"), values);
 
689
  }
 
690
  return etype;
 
691
}
 
692
GType
 
693
gtk_path_priority_type_get_type (void)
 
694
{
 
695
  static GType etype = 0;
 
696
  if (etype == 0) {
 
697
    static const GEnumValue values[] = {
 
698
      { GTK_PATH_PRIO_LOWEST, "GTK_PATH_PRIO_LOWEST", "lowest" },
 
699
      { GTK_PATH_PRIO_GTK, "GTK_PATH_PRIO_GTK", "gtk" },
 
700
      { GTK_PATH_PRIO_APPLICATION, "GTK_PATH_PRIO_APPLICATION", "application" },
 
701
      { GTK_PATH_PRIO_THEME, "GTK_PATH_PRIO_THEME", "theme" },
 
702
      { GTK_PATH_PRIO_RC, "GTK_PATH_PRIO_RC", "rc" },
 
703
      { GTK_PATH_PRIO_HIGHEST, "GTK_PATH_PRIO_HIGHEST", "highest" },
 
704
      { 0, NULL, NULL }
 
705
    };
 
706
    etype = g_enum_register_static (g_intern_static_string ("GtkPathPriorityType"), values);
 
707
  }
 
708
  return etype;
 
709
}
 
710
GType
 
711
gtk_path_type_get_type (void)
 
712
{
 
713
  static GType etype = 0;
 
714
  if (etype == 0) {
 
715
    static const GEnumValue values[] = {
 
716
      { GTK_PATH_WIDGET, "GTK_PATH_WIDGET", "widget" },
 
717
      { GTK_PATH_WIDGET_CLASS, "GTK_PATH_WIDGET_CLASS", "widget-class" },
 
718
      { GTK_PATH_CLASS, "GTK_PATH_CLASS", "class" },
 
719
      { 0, NULL, NULL }
 
720
    };
 
721
    etype = g_enum_register_static (g_intern_static_string ("GtkPathType"), values);
 
722
  }
 
723
  return etype;
 
724
}
 
725
GType
 
726
gtk_policy_type_get_type (void)
 
727
{
 
728
  static GType etype = 0;
 
729
  if (etype == 0) {
 
730
    static const GEnumValue values[] = {
 
731
      { GTK_POLICY_ALWAYS, "GTK_POLICY_ALWAYS", "always" },
 
732
      { GTK_POLICY_AUTOMATIC, "GTK_POLICY_AUTOMATIC", "automatic" },
 
733
      { GTK_POLICY_NEVER, "GTK_POLICY_NEVER", "never" },
 
734
      { 0, NULL, NULL }
 
735
    };
 
736
    etype = g_enum_register_static (g_intern_static_string ("GtkPolicyType"), values);
 
737
  }
 
738
  return etype;
 
739
}
 
740
GType
 
741
gtk_position_type_get_type (void)
 
742
{
 
743
  static GType etype = 0;
 
744
  if (etype == 0) {
 
745
    static const GEnumValue values[] = {
 
746
      { GTK_POS_LEFT, "GTK_POS_LEFT", "left" },
 
747
      { GTK_POS_RIGHT, "GTK_POS_RIGHT", "right" },
 
748
      { GTK_POS_TOP, "GTK_POS_TOP", "top" },
 
749
      { GTK_POS_BOTTOM, "GTK_POS_BOTTOM", "bottom" },
 
750
      { 0, NULL, NULL }
 
751
    };
 
752
    etype = g_enum_register_static (g_intern_static_string ("GtkPositionType"), values);
 
753
  }
 
754
  return etype;
 
755
}
 
756
GType
 
757
gtk_preview_type_get_type (void)
 
758
{
 
759
  static GType etype = 0;
 
760
  if (etype == 0) {
 
761
    static const GEnumValue values[] = {
 
762
      { GTK_PREVIEW_COLOR, "GTK_PREVIEW_COLOR", "color" },
 
763
      { GTK_PREVIEW_GRAYSCALE, "GTK_PREVIEW_GRAYSCALE", "grayscale" },
 
764
      { 0, NULL, NULL }
 
765
    };
 
766
    etype = g_enum_register_static (g_intern_static_string ("GtkPreviewType"), values);
 
767
  }
 
768
  return etype;
 
769
}
 
770
GType
 
771
gtk_relief_style_get_type (void)
 
772
{
 
773
  static GType etype = 0;
 
774
  if (etype == 0) {
 
775
    static const GEnumValue values[] = {
 
776
      { GTK_RELIEF_NORMAL, "GTK_RELIEF_NORMAL", "normal" },
 
777
      { GTK_RELIEF_HALF, "GTK_RELIEF_HALF", "half" },
 
778
      { GTK_RELIEF_NONE, "GTK_RELIEF_NONE", "none" },
 
779
      { 0, NULL, NULL }
 
780
    };
 
781
    etype = g_enum_register_static (g_intern_static_string ("GtkReliefStyle"), values);
 
782
  }
 
783
  return etype;
 
784
}
 
785
GType
 
786
gtk_resize_mode_get_type (void)
 
787
{
 
788
  static GType etype = 0;
 
789
  if (etype == 0) {
 
790
    static const GEnumValue values[] = {
 
791
      { GTK_RESIZE_PARENT, "GTK_RESIZE_PARENT", "parent" },
 
792
      { GTK_RESIZE_QUEUE, "GTK_RESIZE_QUEUE", "queue" },
 
793
      { GTK_RESIZE_IMMEDIATE, "GTK_RESIZE_IMMEDIATE", "immediate" },
 
794
      { 0, NULL, NULL }
 
795
    };
 
796
    etype = g_enum_register_static (g_intern_static_string ("GtkResizeMode"), values);
 
797
  }
 
798
  return etype;
 
799
}
 
800
GType
 
801
gtk_signal_run_type_get_type (void)
 
802
{
 
803
  static GType etype = 0;
 
804
  if (etype == 0) {
 
805
    static const GFlagsValue values[] = {
 
806
      { GTK_RUN_FIRST, "GTK_RUN_FIRST", "first" },
 
807
      { GTK_RUN_LAST, "GTK_RUN_LAST", "last" },
 
808
      { GTK_RUN_BOTH, "GTK_RUN_BOTH", "both" },
 
809
      { GTK_RUN_NO_RECURSE, "GTK_RUN_NO_RECURSE", "no-recurse" },
 
810
      { GTK_RUN_ACTION, "GTK_RUN_ACTION", "action" },
 
811
      { GTK_RUN_NO_HOOKS, "GTK_RUN_NO_HOOKS", "no-hooks" },
 
812
      { 0, NULL, NULL }
 
813
    };
 
814
    etype = g_flags_register_static (g_intern_static_string ("GtkSignalRunType"), values);
 
815
  }
 
816
  return etype;
 
817
}
 
818
GType
 
819
gtk_scroll_type_get_type (void)
 
820
{
 
821
  static GType etype = 0;
 
822
  if (etype == 0) {
 
823
    static const GEnumValue values[] = {
 
824
      { GTK_SCROLL_NONE, "GTK_SCROLL_NONE", "none" },
 
825
      { GTK_SCROLL_JUMP, "GTK_SCROLL_JUMP", "jump" },
 
826
      { GTK_SCROLL_STEP_BACKWARD, "GTK_SCROLL_STEP_BACKWARD", "step-backward" },
 
827
      { GTK_SCROLL_STEP_FORWARD, "GTK_SCROLL_STEP_FORWARD", "step-forward" },
 
828
      { GTK_SCROLL_PAGE_BACKWARD, "GTK_SCROLL_PAGE_BACKWARD", "page-backward" },
 
829
      { GTK_SCROLL_PAGE_FORWARD, "GTK_SCROLL_PAGE_FORWARD", "page-forward" },
 
830
      { GTK_SCROLL_STEP_UP, "GTK_SCROLL_STEP_UP", "step-up" },
 
831
      { GTK_SCROLL_STEP_DOWN, "GTK_SCROLL_STEP_DOWN", "step-down" },
 
832
      { GTK_SCROLL_PAGE_UP, "GTK_SCROLL_PAGE_UP", "page-up" },
 
833
      { GTK_SCROLL_PAGE_DOWN, "GTK_SCROLL_PAGE_DOWN", "page-down" },
 
834
      { GTK_SCROLL_STEP_LEFT, "GTK_SCROLL_STEP_LEFT", "step-left" },
 
835
      { GTK_SCROLL_STEP_RIGHT, "GTK_SCROLL_STEP_RIGHT", "step-right" },
 
836
      { GTK_SCROLL_PAGE_LEFT, "GTK_SCROLL_PAGE_LEFT", "page-left" },
 
837
      { GTK_SCROLL_PAGE_RIGHT, "GTK_SCROLL_PAGE_RIGHT", "page-right" },
 
838
      { GTK_SCROLL_START, "GTK_SCROLL_START", "start" },
 
839
      { GTK_SCROLL_END, "GTK_SCROLL_END", "end" },
 
840
      { 0, NULL, NULL }
 
841
    };
 
842
    etype = g_enum_register_static (g_intern_static_string ("GtkScrollType"), values);
 
843
  }
 
844
  return etype;
 
845
}
 
846
GType
 
847
gtk_selection_mode_get_type (void)
 
848
{
 
849
  static GType etype = 0;
 
850
  if (etype == 0) {
 
851
    static const GEnumValue values[] = {
 
852
      { GTK_SELECTION_NONE, "GTK_SELECTION_NONE", "none" },
 
853
      { GTK_SELECTION_SINGLE, "GTK_SELECTION_SINGLE", "single" },
 
854
      { GTK_SELECTION_BROWSE, "GTK_SELECTION_BROWSE", "browse" },
 
855
      { GTK_SELECTION_MULTIPLE, "GTK_SELECTION_MULTIPLE", "multiple" },
 
856
      { GTK_SELECTION_EXTENDED, "GTK_SELECTION_EXTENDED", "extended" },
 
857
      { 0, NULL, NULL }
 
858
    };
 
859
    etype = g_enum_register_static (g_intern_static_string ("GtkSelectionMode"), values);
 
860
  }
 
861
  return etype;
 
862
}
 
863
GType
 
864
gtk_shadow_type_get_type (void)
 
865
{
 
866
  static GType etype = 0;
 
867
  if (etype == 0) {
 
868
    static const GEnumValue values[] = {
 
869
      { GTK_SHADOW_NONE, "GTK_SHADOW_NONE", "none" },
 
870
      { GTK_SHADOW_IN, "GTK_SHADOW_IN", "in" },
 
871
      { GTK_SHADOW_OUT, "GTK_SHADOW_OUT", "out" },
 
872
      { GTK_SHADOW_ETCHED_IN, "GTK_SHADOW_ETCHED_IN", "etched-in" },
 
873
      { GTK_SHADOW_ETCHED_OUT, "GTK_SHADOW_ETCHED_OUT", "etched-out" },
 
874
      { 0, NULL, NULL }
 
875
    };
 
876
    etype = g_enum_register_static (g_intern_static_string ("GtkShadowType"), values);
 
877
  }
 
878
  return etype;
 
879
}
 
880
GType
 
881
gtk_state_type_get_type (void)
 
882
{
 
883
  static GType etype = 0;
 
884
  if (etype == 0) {
 
885
    static const GEnumValue values[] = {
 
886
      { GTK_STATE_NORMAL, "GTK_STATE_NORMAL", "normal" },
 
887
      { GTK_STATE_ACTIVE, "GTK_STATE_ACTIVE", "active" },
 
888
      { GTK_STATE_PRELIGHT, "GTK_STATE_PRELIGHT", "prelight" },
 
889
      { GTK_STATE_SELECTED, "GTK_STATE_SELECTED", "selected" },
 
890
      { GTK_STATE_INSENSITIVE, "GTK_STATE_INSENSITIVE", "insensitive" },
 
891
      { 0, NULL, NULL }
 
892
    };
 
893
    etype = g_enum_register_static (g_intern_static_string ("GtkStateType"), values);
 
894
  }
 
895
  return etype;
 
896
}
 
897
GType
 
898
gtk_submenu_direction_get_type (void)
 
899
{
 
900
  static GType etype = 0;
 
901
  if (etype == 0) {
 
902
    static const GEnumValue values[] = {
 
903
      { GTK_DIRECTION_LEFT, "GTK_DIRECTION_LEFT", "left" },
 
904
      { GTK_DIRECTION_RIGHT, "GTK_DIRECTION_RIGHT", "right" },
 
905
      { 0, NULL, NULL }
 
906
    };
 
907
    etype = g_enum_register_static (g_intern_static_string ("GtkSubmenuDirection"), values);
 
908
  }
 
909
  return etype;
 
910
}
 
911
GType
 
912
gtk_submenu_placement_get_type (void)
 
913
{
 
914
  static GType etype = 0;
 
915
  if (etype == 0) {
 
916
    static const GEnumValue values[] = {
 
917
      { GTK_TOP_BOTTOM, "GTK_TOP_BOTTOM", "top-bottom" },
 
918
      { GTK_LEFT_RIGHT, "GTK_LEFT_RIGHT", "left-right" },
 
919
      { 0, NULL, NULL }
 
920
    };
 
921
    etype = g_enum_register_static (g_intern_static_string ("GtkSubmenuPlacement"), values);
 
922
  }
 
923
  return etype;
 
924
}
 
925
GType
 
926
gtk_toolbar_style_get_type (void)
 
927
{
 
928
  static GType etype = 0;
 
929
  if (etype == 0) {
 
930
    static const GEnumValue values[] = {
 
931
      { GTK_TOOLBAR_ICONS, "GTK_TOOLBAR_ICONS", "icons" },
 
932
      { GTK_TOOLBAR_TEXT, "GTK_TOOLBAR_TEXT", "text" },
 
933
      { GTK_TOOLBAR_BOTH, "GTK_TOOLBAR_BOTH", "both" },
 
934
      { GTK_TOOLBAR_BOTH_HORIZ, "GTK_TOOLBAR_BOTH_HORIZ", "both-horiz" },
 
935
      { 0, NULL, NULL }
 
936
    };
 
937
    etype = g_enum_register_static (g_intern_static_string ("GtkToolbarStyle"), values);
 
938
  }
 
939
  return etype;
 
940
}
 
941
GType
 
942
gtk_update_type_get_type (void)
 
943
{
 
944
  static GType etype = 0;
 
945
  if (etype == 0) {
 
946
    static const GEnumValue values[] = {
 
947
      { GTK_UPDATE_CONTINUOUS, "GTK_UPDATE_CONTINUOUS", "continuous" },
 
948
      { GTK_UPDATE_DISCONTINUOUS, "GTK_UPDATE_DISCONTINUOUS", "discontinuous" },
 
949
      { GTK_UPDATE_DELAYED, "GTK_UPDATE_DELAYED", "delayed" },
 
950
      { 0, NULL, NULL }
 
951
    };
 
952
    etype = g_enum_register_static (g_intern_static_string ("GtkUpdateType"), values);
 
953
  }
 
954
  return etype;
 
955
}
 
956
GType
 
957
gtk_visibility_get_type (void)
 
958
{
 
959
  static GType etype = 0;
 
960
  if (etype == 0) {
 
961
    static const GEnumValue values[] = {
 
962
      { GTK_VISIBILITY_NONE, "GTK_VISIBILITY_NONE", "none" },
 
963
      { GTK_VISIBILITY_PARTIAL, "GTK_VISIBILITY_PARTIAL", "partial" },
 
964
      { GTK_VISIBILITY_FULL, "GTK_VISIBILITY_FULL", "full" },
 
965
      { 0, NULL, NULL }
 
966
    };
 
967
    etype = g_enum_register_static (g_intern_static_string ("GtkVisibility"), values);
 
968
  }
 
969
  return etype;
 
970
}
 
971
GType
 
972
gtk_window_position_get_type (void)
 
973
{
 
974
  static GType etype = 0;
 
975
  if (etype == 0) {
 
976
    static const GEnumValue values[] = {
 
977
      { GTK_WIN_POS_NONE, "GTK_WIN_POS_NONE", "none" },
 
978
      { GTK_WIN_POS_CENTER, "GTK_WIN_POS_CENTER", "center" },
 
979
      { GTK_WIN_POS_MOUSE, "GTK_WIN_POS_MOUSE", "mouse" },
 
980
      { GTK_WIN_POS_CENTER_ALWAYS, "GTK_WIN_POS_CENTER_ALWAYS", "center-always" },
 
981
      { GTK_WIN_POS_CENTER_ON_PARENT, "GTK_WIN_POS_CENTER_ON_PARENT", "center-on-parent" },
 
982
      { 0, NULL, NULL }
 
983
    };
 
984
    etype = g_enum_register_static (g_intern_static_string ("GtkWindowPosition"), values);
 
985
  }
 
986
  return etype;
 
987
}
 
988
GType
 
989
gtk_window_type_get_type (void)
 
990
{
 
991
  static GType etype = 0;
 
992
  if (etype == 0) {
 
993
    static const GEnumValue values[] = {
 
994
      { GTK_WINDOW_TOPLEVEL, "GTK_WINDOW_TOPLEVEL", "toplevel" },
 
995
      { GTK_WINDOW_POPUP, "GTK_WINDOW_POPUP", "popup" },
 
996
      { 0, NULL, NULL }
 
997
    };
 
998
    etype = g_enum_register_static (g_intern_static_string ("GtkWindowType"), values);
 
999
  }
 
1000
  return etype;
 
1001
}
 
1002
GType
 
1003
gtk_wrap_mode_get_type (void)
 
1004
{
 
1005
  static GType etype = 0;
 
1006
  if (etype == 0) {
 
1007
    static const GEnumValue values[] = {
 
1008
      { GTK_WRAP_NONE, "GTK_WRAP_NONE", "none" },
 
1009
      { GTK_WRAP_CHAR, "GTK_WRAP_CHAR", "char" },
 
1010
      { GTK_WRAP_WORD, "GTK_WRAP_WORD", "word" },
 
1011
      { GTK_WRAP_WORD_CHAR, "GTK_WRAP_WORD_CHAR", "word-char" },
 
1012
      { 0, NULL, NULL }
 
1013
    };
 
1014
    etype = g_enum_register_static (g_intern_static_string ("GtkWrapMode"), values);
 
1015
  }
 
1016
  return etype;
 
1017
}
 
1018
GType
 
1019
gtk_sort_type_get_type (void)
 
1020
{
 
1021
  static GType etype = 0;
 
1022
  if (etype == 0) {
 
1023
    static const GEnumValue values[] = {
 
1024
      { GTK_SORT_ASCENDING, "GTK_SORT_ASCENDING", "ascending" },
 
1025
      { GTK_SORT_DESCENDING, "GTK_SORT_DESCENDING", "descending" },
 
1026
      { 0, NULL, NULL }
 
1027
    };
 
1028
    etype = g_enum_register_static (g_intern_static_string ("GtkSortType"), values);
 
1029
  }
 
1030
  return etype;
 
1031
}
 
1032
GType
 
1033
gtk_im_preedit_style_get_type (void)
 
1034
{
 
1035
  static GType etype = 0;
 
1036
  if (etype == 0) {
 
1037
    static const GEnumValue values[] = {
 
1038
      { GTK_IM_PREEDIT_NOTHING, "GTK_IM_PREEDIT_NOTHING", "nothing" },
 
1039
      { GTK_IM_PREEDIT_CALLBACK, "GTK_IM_PREEDIT_CALLBACK", "callback" },
 
1040
      { GTK_IM_PREEDIT_NONE, "GTK_IM_PREEDIT_NONE", "none" },
 
1041
      { 0, NULL, NULL }
 
1042
    };
 
1043
    etype = g_enum_register_static (g_intern_static_string ("GtkIMPreeditStyle"), values);
 
1044
  }
 
1045
  return etype;
 
1046
}
 
1047
GType
 
1048
gtk_im_status_style_get_type (void)
 
1049
{
 
1050
  static GType etype = 0;
 
1051
  if (etype == 0) {
 
1052
    static const GEnumValue values[] = {
 
1053
      { GTK_IM_STATUS_NOTHING, "GTK_IM_STATUS_NOTHING", "nothing" },
 
1054
      { GTK_IM_STATUS_CALLBACK, "GTK_IM_STATUS_CALLBACK", "callback" },
 
1055
      { GTK_IM_STATUS_NONE, "GTK_IM_STATUS_NONE", "none" },
 
1056
      { 0, NULL, NULL }
 
1057
    };
 
1058
    etype = g_enum_register_static (g_intern_static_string ("GtkIMStatusStyle"), values);
 
1059
  }
 
1060
  return etype;
 
1061
}
 
1062
GType
 
1063
gtk_pack_direction_get_type (void)
 
1064
{
 
1065
  static GType etype = 0;
 
1066
  if (etype == 0) {
 
1067
    static const GEnumValue values[] = {
 
1068
      { GTK_PACK_DIRECTION_LTR, "GTK_PACK_DIRECTION_LTR", "ltr" },
 
1069
      { GTK_PACK_DIRECTION_RTL, "GTK_PACK_DIRECTION_RTL", "rtl" },
 
1070
      { GTK_PACK_DIRECTION_TTB, "GTK_PACK_DIRECTION_TTB", "ttb" },
 
1071
      { GTK_PACK_DIRECTION_BTT, "GTK_PACK_DIRECTION_BTT", "btt" },
 
1072
      { 0, NULL, NULL }
 
1073
    };
 
1074
    etype = g_enum_register_static (g_intern_static_string ("GtkPackDirection"), values);
 
1075
  }
 
1076
  return etype;
 
1077
}
 
1078
GType
 
1079
gtk_print_pages_get_type (void)
 
1080
{
 
1081
  static GType etype = 0;
 
1082
  if (etype == 0) {
 
1083
    static const GEnumValue values[] = {
 
1084
      { GTK_PRINT_PAGES_ALL, "GTK_PRINT_PAGES_ALL", "all" },
 
1085
      { GTK_PRINT_PAGES_CURRENT, "GTK_PRINT_PAGES_CURRENT", "current" },
 
1086
      { GTK_PRINT_PAGES_RANGES, "GTK_PRINT_PAGES_RANGES", "ranges" },
 
1087
      { 0, NULL, NULL }
 
1088
    };
 
1089
    etype = g_enum_register_static (g_intern_static_string ("GtkPrintPages"), values);
 
1090
  }
 
1091
  return etype;
 
1092
}
 
1093
GType
 
1094
gtk_page_set_get_type (void)
 
1095
{
 
1096
  static GType etype = 0;
 
1097
  if (etype == 0) {
 
1098
    static const GEnumValue values[] = {
 
1099
      { GTK_PAGE_SET_ALL, "GTK_PAGE_SET_ALL", "all" },
 
1100
      { GTK_PAGE_SET_EVEN, "GTK_PAGE_SET_EVEN", "even" },
 
1101
      { GTK_PAGE_SET_ODD, "GTK_PAGE_SET_ODD", "odd" },
 
1102
      { 0, NULL, NULL }
 
1103
    };
 
1104
    etype = g_enum_register_static (g_intern_static_string ("GtkPageSet"), values);
 
1105
  }
 
1106
  return etype;
 
1107
}
 
1108
GType
 
1109
gtk_page_orientation_get_type (void)
 
1110
{
 
1111
  static GType etype = 0;
 
1112
  if (etype == 0) {
 
1113
    static const GEnumValue values[] = {
 
1114
      { GTK_PAGE_ORIENTATION_PORTRAIT, "GTK_PAGE_ORIENTATION_PORTRAIT", "portrait" },
 
1115
      { GTK_PAGE_ORIENTATION_LANDSCAPE, "GTK_PAGE_ORIENTATION_LANDSCAPE", "landscape" },
 
1116
      { GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT, "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT", "reverse-portrait" },
 
1117
      { GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE, "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE", "reverse-landscape" },
 
1118
      { 0, NULL, NULL }
 
1119
    };
 
1120
    etype = g_enum_register_static (g_intern_static_string ("GtkPageOrientation"), values);
 
1121
  }
 
1122
  return etype;
 
1123
}
 
1124
GType
 
1125
gtk_print_quality_get_type (void)
 
1126
{
 
1127
  static GType etype = 0;
 
1128
  if (etype == 0) {
 
1129
    static const GEnumValue values[] = {
 
1130
      { GTK_PRINT_QUALITY_LOW, "GTK_PRINT_QUALITY_LOW", "low" },
 
1131
      { GTK_PRINT_QUALITY_NORMAL, "GTK_PRINT_QUALITY_NORMAL", "normal" },
 
1132
      { GTK_PRINT_QUALITY_HIGH, "GTK_PRINT_QUALITY_HIGH", "high" },
 
1133
      { GTK_PRINT_QUALITY_DRAFT, "GTK_PRINT_QUALITY_DRAFT", "draft" },
 
1134
      { 0, NULL, NULL }
 
1135
    };
 
1136
    etype = g_enum_register_static (g_intern_static_string ("GtkPrintQuality"), values);
 
1137
  }
 
1138
  return etype;
 
1139
}
 
1140
GType
 
1141
gtk_print_duplex_get_type (void)
 
1142
{
 
1143
  static GType etype = 0;
 
1144
  if (etype == 0) {
 
1145
    static const GEnumValue values[] = {
 
1146
      { GTK_PRINT_DUPLEX_SIMPLEX, "GTK_PRINT_DUPLEX_SIMPLEX", "simplex" },
 
1147
      { GTK_PRINT_DUPLEX_HORIZONTAL, "GTK_PRINT_DUPLEX_HORIZONTAL", "horizontal" },
 
1148
      { GTK_PRINT_DUPLEX_VERTICAL, "GTK_PRINT_DUPLEX_VERTICAL", "vertical" },
 
1149
      { 0, NULL, NULL }
 
1150
    };
 
1151
    etype = g_enum_register_static (g_intern_static_string ("GtkPrintDuplex"), values);
 
1152
  }
 
1153
  return etype;
 
1154
}
 
1155
GType
 
1156
gtk_unit_get_type (void)
 
1157
{
 
1158
  static GType etype = 0;
 
1159
  if (etype == 0) {
 
1160
    static const GEnumValue values[] = {
 
1161
      { GTK_UNIT_PIXEL, "GTK_UNIT_PIXEL", "pixel" },
 
1162
      { GTK_UNIT_POINTS, "GTK_UNIT_POINTS", "points" },
 
1163
      { GTK_UNIT_INCH, "GTK_UNIT_INCH", "inch" },
 
1164
      { GTK_UNIT_MM, "GTK_UNIT_MM", "mm" },
 
1165
      { 0, NULL, NULL }
 
1166
    };
 
1167
    etype = g_enum_register_static (g_intern_static_string ("GtkUnit"), values);
 
1168
  }
 
1169
  return etype;
 
1170
}
 
1171
GType
 
1172
gtk_tree_view_grid_lines_get_type (void)
 
1173
{
 
1174
  static GType etype = 0;
 
1175
  if (etype == 0) {
 
1176
    static const GEnumValue values[] = {
 
1177
      { GTK_TREE_VIEW_GRID_LINES_NONE, "GTK_TREE_VIEW_GRID_LINES_NONE", "none" },
 
1178
      { GTK_TREE_VIEW_GRID_LINES_HORIZONTAL, "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL", "horizontal" },
 
1179
      { GTK_TREE_VIEW_GRID_LINES_VERTICAL, "GTK_TREE_VIEW_GRID_LINES_VERTICAL", "vertical" },
 
1180
      { GTK_TREE_VIEW_GRID_LINES_BOTH, "GTK_TREE_VIEW_GRID_LINES_BOTH", "both" },
 
1181
      { 0, NULL, NULL }
 
1182
    };
 
1183
    etype = g_enum_register_static (g_intern_static_string ("GtkTreeViewGridLines"), values);
 
1184
  }
 
1185
  return etype;
 
1186
}
 
1187
 
 
1188
/* enumerations from "gtkfilechooser.h" */
 
1189
GType
 
1190
gtk_file_chooser_action_get_type (void)
 
1191
{
 
1192
  static GType etype = 0;
 
1193
  if (etype == 0) {
 
1194
    static const GEnumValue values[] = {
 
1195
      { GTK_FILE_CHOOSER_ACTION_OPEN, "GTK_FILE_CHOOSER_ACTION_OPEN", "open" },
 
1196
      { GTK_FILE_CHOOSER_ACTION_SAVE, "GTK_FILE_CHOOSER_ACTION_SAVE", "save" },
 
1197
      { GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER", "select-folder" },
 
1198
      { GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, "GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER", "create-folder" },
 
1199
      { 0, NULL, NULL }
 
1200
    };
 
1201
    etype = g_enum_register_static (g_intern_static_string ("GtkFileChooserAction"), values);
 
1202
  }
 
1203
  return etype;
 
1204
}
 
1205
GType
 
1206
gtk_file_chooser_confirmation_get_type (void)
 
1207
{
 
1208
  static GType etype = 0;
 
1209
  if (etype == 0) {
 
1210
    static const GEnumValue values[] = {
 
1211
      { GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM, "GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM", "confirm" },
 
1212
      { GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME, "GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME", "accept-filename" },
 
1213
      { GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN, "GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN", "select-again" },
 
1214
      { 0, NULL, NULL }
 
1215
    };
 
1216
    etype = g_enum_register_static (g_intern_static_string ("GtkFileChooserConfirmation"), values);
 
1217
  }
 
1218
  return etype;
 
1219
}
 
1220
GType
 
1221
gtk_file_chooser_error_get_type (void)
 
1222
{
 
1223
  static GType etype = 0;
 
1224
  if (etype == 0) {
 
1225
    static const GEnumValue values[] = {
 
1226
      { GTK_FILE_CHOOSER_ERROR_NONEXISTENT, "GTK_FILE_CHOOSER_ERROR_NONEXISTENT", "nonexistent" },
 
1227
      { GTK_FILE_CHOOSER_ERROR_BAD_FILENAME, "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME", "bad-filename" },
 
1228
      { GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS, "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS", "already-exists" },
 
1229
      { 0, NULL, NULL }
 
1230
    };
 
1231
    etype = g_enum_register_static (g_intern_static_string ("GtkFileChooserError"), values);
 
1232
  }
 
1233
  return etype;
 
1234
}
 
1235
 
 
1236
/* enumerations from "gtkfilefilter.h" */
 
1237
GType
 
1238
gtk_file_filter_flags_get_type (void)
 
1239
{
 
1240
  static GType etype = 0;
 
1241
  if (etype == 0) {
 
1242
    static const GFlagsValue values[] = {
 
1243
      { GTK_FILE_FILTER_FILENAME, "GTK_FILE_FILTER_FILENAME", "filename" },
 
1244
      { GTK_FILE_FILTER_URI, "GTK_FILE_FILTER_URI", "uri" },
 
1245
      { GTK_FILE_FILTER_DISPLAY_NAME, "GTK_FILE_FILTER_DISPLAY_NAME", "display-name" },
 
1246
      { GTK_FILE_FILTER_MIME_TYPE, "GTK_FILE_FILTER_MIME_TYPE", "mime-type" },
 
1247
      { 0, NULL, NULL }
 
1248
    };
 
1249
    etype = g_flags_register_static (g_intern_static_string ("GtkFileFilterFlags"), values);
 
1250
  }
 
1251
  return etype;
 
1252
}
 
1253
 
 
1254
/* enumerations from "gtkicontheme.h" */
 
1255
GType
 
1256
gtk_icon_lookup_flags_get_type (void)
 
1257
{
 
1258
  static GType etype = 0;
 
1259
  if (etype == 0) {
 
1260
    static const GFlagsValue values[] = {
 
1261
      { GTK_ICON_LOOKUP_NO_SVG, "GTK_ICON_LOOKUP_NO_SVG", "no-svg" },
 
1262
      { GTK_ICON_LOOKUP_FORCE_SVG, "GTK_ICON_LOOKUP_FORCE_SVG", "force-svg" },
 
1263
      { GTK_ICON_LOOKUP_USE_BUILTIN, "GTK_ICON_LOOKUP_USE_BUILTIN", "use-builtin" },
 
1264
      { 0, NULL, NULL }
 
1265
    };
 
1266
    etype = g_flags_register_static (g_intern_static_string ("GtkIconLookupFlags"), values);
 
1267
  }
 
1268
  return etype;
 
1269
}
 
1270
GType
 
1271
gtk_icon_theme_error_get_type (void)
 
1272
{
 
1273
  static GType etype = 0;
 
1274
  if (etype == 0) {
 
1275
    static const GEnumValue values[] = {
 
1276
      { GTK_ICON_THEME_NOT_FOUND, "GTK_ICON_THEME_NOT_FOUND", "not-found" },
 
1277
      { GTK_ICON_THEME_FAILED, "GTK_ICON_THEME_FAILED", "failed" },
 
1278
      { 0, NULL, NULL }
 
1279
    };
 
1280
    etype = g_enum_register_static (g_intern_static_string ("GtkIconThemeError"), values);
 
1281
  }
 
1282
  return etype;
 
1283
}
 
1284
 
 
1285
/* enumerations from "gtkiconview.h" */
 
1286
GType
 
1287
gtk_icon_view_drop_position_get_type (void)
 
1288
{
 
1289
  static GType etype = 0;
 
1290
  if (etype == 0) {
 
1291
    static const GEnumValue values[] = {
 
1292
      { GTK_ICON_VIEW_NO_DROP, "GTK_ICON_VIEW_NO_DROP", "no-drop" },
 
1293
      { GTK_ICON_VIEW_DROP_INTO, "GTK_ICON_VIEW_DROP_INTO", "drop-into" },
 
1294
      { GTK_ICON_VIEW_DROP_LEFT, "GTK_ICON_VIEW_DROP_LEFT", "drop-left" },
 
1295
      { GTK_ICON_VIEW_DROP_RIGHT, "GTK_ICON_VIEW_DROP_RIGHT", "drop-right" },
 
1296
      { GTK_ICON_VIEW_DROP_ABOVE, "GTK_ICON_VIEW_DROP_ABOVE", "drop-above" },
 
1297
      { GTK_ICON_VIEW_DROP_BELOW, "GTK_ICON_VIEW_DROP_BELOW", "drop-below" },
 
1298
      { 0, NULL, NULL }
 
1299
    };
 
1300
    etype = g_enum_register_static (g_intern_static_string ("GtkIconViewDropPosition"), values);
 
1301
  }
 
1302
  return etype;
 
1303
}
 
1304
 
 
1305
/* enumerations from "gtkimage.h" */
 
1306
GType
 
1307
gtk_image_type_get_type (void)
 
1308
{
 
1309
  static GType etype = 0;
 
1310
  if (etype == 0) {
 
1311
    static const GEnumValue values[] = {
 
1312
      { GTK_IMAGE_EMPTY, "GTK_IMAGE_EMPTY", "empty" },
 
1313
      { GTK_IMAGE_PIXMAP, "GTK_IMAGE_PIXMAP", "pixmap" },
 
1314
      { GTK_IMAGE_IMAGE, "GTK_IMAGE_IMAGE", "image" },
 
1315
      { GTK_IMAGE_PIXBUF, "GTK_IMAGE_PIXBUF", "pixbuf" },
 
1316
      { GTK_IMAGE_STOCK, "GTK_IMAGE_STOCK", "stock" },
 
1317
      { GTK_IMAGE_ICON_SET, "GTK_IMAGE_ICON_SET", "icon-set" },
 
1318
      { GTK_IMAGE_ANIMATION, "GTK_IMAGE_ANIMATION", "animation" },
 
1319
      { GTK_IMAGE_ICON_NAME, "GTK_IMAGE_ICON_NAME", "icon-name" },
 
1320
      { 0, NULL, NULL }
 
1321
    };
 
1322
    etype = g_enum_register_static (g_intern_static_string ("GtkImageType"), values);
 
1323
  }
 
1324
  return etype;
 
1325
}
 
1326
 
 
1327
/* enumerations from "gtkmessagedialog.h" */
 
1328
GType
 
1329
gtk_message_type_get_type (void)
 
1330
{
 
1331
  static GType etype = 0;
 
1332
  if (etype == 0) {
 
1333
    static const GEnumValue values[] = {
 
1334
      { GTK_MESSAGE_INFO, "GTK_MESSAGE_INFO", "info" },
 
1335
      { GTK_MESSAGE_WARNING, "GTK_MESSAGE_WARNING", "warning" },
 
1336
      { GTK_MESSAGE_QUESTION, "GTK_MESSAGE_QUESTION", "question" },
 
1337
      { GTK_MESSAGE_ERROR, "GTK_MESSAGE_ERROR", "error" },
 
1338
      { GTK_MESSAGE_OTHER, "GTK_MESSAGE_OTHER", "other" },
 
1339
      { 0, NULL, NULL }
 
1340
    };
 
1341
    etype = g_enum_register_static (g_intern_static_string ("GtkMessageType"), values);
 
1342
  }
 
1343
  return etype;
 
1344
}
 
1345
GType
 
1346
gtk_buttons_type_get_type (void)
 
1347
{
 
1348
  static GType etype = 0;
 
1349
  if (etype == 0) {
 
1350
    static const GEnumValue values[] = {
 
1351
      { GTK_BUTTONS_NONE, "GTK_BUTTONS_NONE", "none" },
 
1352
      { GTK_BUTTONS_OK, "GTK_BUTTONS_OK", "ok" },
 
1353
      { GTK_BUTTONS_CLOSE, "GTK_BUTTONS_CLOSE", "close" },
 
1354
      { GTK_BUTTONS_CANCEL, "GTK_BUTTONS_CANCEL", "cancel" },
 
1355
      { GTK_BUTTONS_YES_NO, "GTK_BUTTONS_YES_NO", "yes-no" },
 
1356
      { GTK_BUTTONS_OK_CANCEL, "GTK_BUTTONS_OK_CANCEL", "ok-cancel" },
 
1357
      { 0, NULL, NULL }
 
1358
    };
 
1359
    etype = g_enum_register_static (g_intern_static_string ("GtkButtonsType"), values);
 
1360
  }
 
1361
  return etype;
 
1362
}
 
1363
 
 
1364
/* enumerations from "gtknotebook.h" */
 
1365
GType
 
1366
gtk_notebook_tab_get_type (void)
 
1367
{
 
1368
  static GType etype = 0;
 
1369
  if (etype == 0) {
 
1370
    static const GEnumValue values[] = {
 
1371
      { GTK_NOTEBOOK_TAB_FIRST, "GTK_NOTEBOOK_TAB_FIRST", "first" },
 
1372
      { GTK_NOTEBOOK_TAB_LAST, "GTK_NOTEBOOK_TAB_LAST", "last" },
 
1373
      { 0, NULL, NULL }
 
1374
    };
 
1375
    etype = g_enum_register_static (g_intern_static_string ("GtkNotebookTab"), values);
 
1376
  }
 
1377
  return etype;
 
1378
}
 
1379
 
 
1380
/* enumerations from "gtkobject.h" */
 
1381
GType
 
1382
gtk_object_flags_get_type (void)
 
1383
{
 
1384
  static GType etype = 0;
 
1385
  if (etype == 0) {
 
1386
    static const GFlagsValue values[] = {
 
1387
      { GTK_IN_DESTRUCTION, "GTK_IN_DESTRUCTION", "in-destruction" },
 
1388
      { GTK_FLOATING, "GTK_FLOATING", "floating" },
 
1389
      { GTK_RESERVED_1, "GTK_RESERVED_1", "reserved-1" },
 
1390
      { GTK_RESERVED_2, "GTK_RESERVED_2", "reserved-2" },
 
1391
      { 0, NULL, NULL }
 
1392
    };
 
1393
    etype = g_flags_register_static (g_intern_static_string ("GtkObjectFlags"), values);
 
1394
  }
 
1395
  return etype;
 
1396
}
 
1397
GType
 
1398
gtk_arg_flags_get_type (void)
 
1399
{
 
1400
  static GType etype = 0;
 
1401
  if (etype == 0) {
 
1402
    static const GFlagsValue values[] = {
 
1403
      { GTK_ARG_READABLE, "GTK_ARG_READABLE", "readable" },
 
1404
      { GTK_ARG_WRITABLE, "GTK_ARG_WRITABLE", "writable" },
 
1405
      { GTK_ARG_CONSTRUCT, "GTK_ARG_CONSTRUCT", "construct" },
 
1406
      { GTK_ARG_CONSTRUCT_ONLY, "GTK_ARG_CONSTRUCT_ONLY", "construct-only" },
 
1407
      { GTK_ARG_CHILD_ARG, "GTK_ARG_CHILD_ARG", "child-arg" },
 
1408
      { 0, NULL, NULL }
 
1409
    };
 
1410
    etype = g_flags_register_static (g_intern_static_string ("GtkArgFlags"), values);
 
1411
  }
 
1412
  return etype;
 
1413
}
 
1414
 
 
1415
/* enumerations from "gtkprintoperation.h" */
 
1416
GType
 
1417
gtk_print_status_get_type (void)
 
1418
{
 
1419
  static GType etype = 0;
 
1420
  if (etype == 0) {
 
1421
    static const GEnumValue values[] = {
 
1422
      { GTK_PRINT_STATUS_INITIAL, "GTK_PRINT_STATUS_INITIAL", "initial" },
 
1423
      { GTK_PRINT_STATUS_PREPARING, "GTK_PRINT_STATUS_PREPARING", "preparing" },
 
1424
      { GTK_PRINT_STATUS_GENERATING_DATA, "GTK_PRINT_STATUS_GENERATING_DATA", "generating-data" },
 
1425
      { GTK_PRINT_STATUS_SENDING_DATA, "GTK_PRINT_STATUS_SENDING_DATA", "sending-data" },
 
1426
      { GTK_PRINT_STATUS_PENDING, "GTK_PRINT_STATUS_PENDING", "pending" },
 
1427
      { GTK_PRINT_STATUS_PENDING_ISSUE, "GTK_PRINT_STATUS_PENDING_ISSUE", "pending-issue" },
 
1428
      { GTK_PRINT_STATUS_PRINTING, "GTK_PRINT_STATUS_PRINTING", "printing" },
 
1429
      { GTK_PRINT_STATUS_FINISHED, "GTK_PRINT_STATUS_FINISHED", "finished" },
 
1430
      { GTK_PRINT_STATUS_FINISHED_ABORTED, "GTK_PRINT_STATUS_FINISHED_ABORTED", "finished-aborted" },
 
1431
      { 0, NULL, NULL }
 
1432
    };
 
1433
    etype = g_enum_register_static (g_intern_static_string ("GtkPrintStatus"), values);
 
1434
  }
 
1435
  return etype;
 
1436
}
 
1437
GType
 
1438
gtk_print_operation_result_get_type (void)
 
1439
{
 
1440
  static GType etype = 0;
 
1441
  if (etype == 0) {
 
1442
    static const GEnumValue values[] = {
 
1443
      { GTK_PRINT_OPERATION_RESULT_ERROR, "GTK_PRINT_OPERATION_RESULT_ERROR", "error" },
 
1444
      { GTK_PRINT_OPERATION_RESULT_APPLY, "GTK_PRINT_OPERATION_RESULT_APPLY", "apply" },
 
1445
      { GTK_PRINT_OPERATION_RESULT_CANCEL, "GTK_PRINT_OPERATION_RESULT_CANCEL", "cancel" },
 
1446
      { GTK_PRINT_OPERATION_RESULT_IN_PROGRESS, "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS", "in-progress" },
 
1447
      { 0, NULL, NULL }
 
1448
    };
 
1449
    etype = g_enum_register_static (g_intern_static_string ("GtkPrintOperationResult"), values);
 
1450
  }
 
1451
  return etype;
 
1452
}
 
1453
GType
 
1454
gtk_print_operation_action_get_type (void)
 
1455
{
 
1456
  static GType etype = 0;
 
1457
  if (etype == 0) {
 
1458
    static const GEnumValue values[] = {
 
1459
      { GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG", "print-dialog" },
 
1460
      { GTK_PRINT_OPERATION_ACTION_PRINT, "GTK_PRINT_OPERATION_ACTION_PRINT", "print" },
 
1461
      { GTK_PRINT_OPERATION_ACTION_PREVIEW, "GTK_PRINT_OPERATION_ACTION_PREVIEW", "preview" },
 
1462
      { GTK_PRINT_OPERATION_ACTION_EXPORT, "GTK_PRINT_OPERATION_ACTION_EXPORT", "export" },
 
1463
      { 0, NULL, NULL }
 
1464
    };
 
1465
    etype = g_enum_register_static (g_intern_static_string ("GtkPrintOperationAction"), values);
 
1466
  }
 
1467
  return etype;
 
1468
}
 
1469
GType
 
1470
gtk_print_error_get_type (void)
 
1471
{
 
1472
  static GType etype = 0;
 
1473
  if (etype == 0) {
 
1474
    static const GEnumValue values[] = {
 
1475
      { GTK_PRINT_ERROR_GENERAL, "GTK_PRINT_ERROR_GENERAL", "general" },
 
1476
      { GTK_PRINT_ERROR_INTERNAL_ERROR, "GTK_PRINT_ERROR_INTERNAL_ERROR", "internal-error" },
 
1477
      { GTK_PRINT_ERROR_NOMEM, "GTK_PRINT_ERROR_NOMEM", "nomem" },
 
1478
      { 0, NULL, NULL }
 
1479
    };
 
1480
    etype = g_enum_register_static (g_intern_static_string ("GtkPrintError"), values);
 
1481
  }
 
1482
  return etype;
 
1483
}
 
1484
 
 
1485
/* enumerations from "gtkprivate.h" */
 
1486
GType
 
1487
gtk_private_flags_get_type (void)
 
1488
{
 
1489
  static GType etype = 0;
 
1490
  if (etype == 0) {
 
1491
    static const GFlagsValue values[] = {
 
1492
      { PRIVATE_GTK_USER_STYLE, "PRIVATE_GTK_USER_STYLE", "user-style" },
 
1493
      { PRIVATE_GTK_RESIZE_PENDING, "PRIVATE_GTK_RESIZE_PENDING", "resize-pending" },
 
1494
      { PRIVATE_GTK_LEAVE_PENDING, "PRIVATE_GTK_LEAVE_PENDING", "leave-pending" },
 
1495
      { PRIVATE_GTK_HAS_SHAPE_MASK, "PRIVATE_GTK_HAS_SHAPE_MASK", "has-shape-mask" },
 
1496
      { PRIVATE_GTK_IN_REPARENT, "PRIVATE_GTK_IN_REPARENT", "in-reparent" },
 
1497
      { PRIVATE_GTK_DIRECTION_SET, "PRIVATE_GTK_DIRECTION_SET", "direction-set" },
 
1498
      { PRIVATE_GTK_DIRECTION_LTR, "PRIVATE_GTK_DIRECTION_LTR", "direction-ltr" },
 
1499
      { PRIVATE_GTK_ANCHORED, "PRIVATE_GTK_ANCHORED", "anchored" },
 
1500
      { PRIVATE_GTK_CHILD_VISIBLE, "PRIVATE_GTK_CHILD_VISIBLE", "child-visible" },
 
1501
      { PRIVATE_GTK_REDRAW_ON_ALLOC, "PRIVATE_GTK_REDRAW_ON_ALLOC", "redraw-on-alloc" },
 
1502
      { PRIVATE_GTK_ALLOC_NEEDED, "PRIVATE_GTK_ALLOC_NEEDED", "alloc-needed" },
 
1503
      { PRIVATE_GTK_REQUEST_NEEDED, "PRIVATE_GTK_REQUEST_NEEDED", "request-needed" },
 
1504
      { 0, NULL, NULL }
 
1505
    };
 
1506
    etype = g_flags_register_static (g_intern_static_string ("GtkPrivateFlags"), values);
 
1507
  }
 
1508
  return etype;
 
1509
}
 
1510
 
 
1511
/* enumerations from "gtkprogressbar.h" */
 
1512
GType
 
1513
gtk_progress_bar_style_get_type (void)
 
1514
{
 
1515
  static GType etype = 0;
 
1516
  if (etype == 0) {
 
1517
    static const GEnumValue values[] = {
 
1518
      { GTK_PROGRESS_CONTINUOUS, "GTK_PROGRESS_CONTINUOUS", "continuous" },
 
1519
      { GTK_PROGRESS_DISCRETE, "GTK_PROGRESS_DISCRETE", "discrete" },
 
1520
      { 0, NULL, NULL }
 
1521
    };
 
1522
    etype = g_enum_register_static (g_intern_static_string ("GtkProgressBarStyle"), values);
 
1523
  }
 
1524
  return etype;
 
1525
}
 
1526
GType
 
1527
gtk_progress_bar_orientation_get_type (void)
 
1528
{
 
1529
  static GType etype = 0;
 
1530
  if (etype == 0) {
 
1531
    static const GEnumValue values[] = {
 
1532
      { GTK_PROGRESS_LEFT_TO_RIGHT, "GTK_PROGRESS_LEFT_TO_RIGHT", "left-to-right" },
 
1533
      { GTK_PROGRESS_RIGHT_TO_LEFT, "GTK_PROGRESS_RIGHT_TO_LEFT", "right-to-left" },
 
1534
      { GTK_PROGRESS_BOTTOM_TO_TOP, "GTK_PROGRESS_BOTTOM_TO_TOP", "bottom-to-top" },
 
1535
      { GTK_PROGRESS_TOP_TO_BOTTOM, "GTK_PROGRESS_TOP_TO_BOTTOM", "top-to-bottom" },
 
1536
      { 0, NULL, NULL }
 
1537
    };
 
1538
    etype = g_enum_register_static (g_intern_static_string ("GtkProgressBarOrientation"), values);
 
1539
  }
 
1540
  return etype;
 
1541
}
 
1542
 
 
1543
/* enumerations from "gtkrc.h" */
 
1544
GType
 
1545
gtk_rc_flags_get_type (void)
 
1546
{
 
1547
  static GType etype = 0;
 
1548
  if (etype == 0) {
 
1549
    static const GFlagsValue values[] = {
 
1550
      { GTK_RC_FG, "GTK_RC_FG", "fg" },
 
1551
      { GTK_RC_BG, "GTK_RC_BG", "bg" },
 
1552
      { GTK_RC_TEXT, "GTK_RC_TEXT", "text" },
 
1553
      { GTK_RC_BASE, "GTK_RC_BASE", "base" },
 
1554
      { 0, NULL, NULL }
 
1555
    };
 
1556
    etype = g_flags_register_static (g_intern_static_string ("GtkRcFlags"), values);
 
1557
  }
 
1558
  return etype;
 
1559
}
 
1560
GType
 
1561
gtk_rc_token_type_get_type (void)
 
1562
{
 
1563
  static GType etype = 0;
 
1564
  if (etype == 0) {
 
1565
    static const GEnumValue values[] = {
 
1566
      { GTK_RC_TOKEN_INVALID, "GTK_RC_TOKEN_INVALID", "invalid" },
 
1567
      { GTK_RC_TOKEN_INCLUDE, "GTK_RC_TOKEN_INCLUDE", "include" },
 
1568
      { GTK_RC_TOKEN_NORMAL, "GTK_RC_TOKEN_NORMAL", "normal" },
 
1569
      { GTK_RC_TOKEN_ACTIVE, "GTK_RC_TOKEN_ACTIVE", "active" },
 
1570
      { GTK_RC_TOKEN_PRELIGHT, "GTK_RC_TOKEN_PRELIGHT", "prelight" },
 
1571
      { GTK_RC_TOKEN_SELECTED, "GTK_RC_TOKEN_SELECTED", "selected" },
 
1572
      { GTK_RC_TOKEN_INSENSITIVE, "GTK_RC_TOKEN_INSENSITIVE", "insensitive" },
 
1573
      { GTK_RC_TOKEN_FG, "GTK_RC_TOKEN_FG", "fg" },
 
1574
      { GTK_RC_TOKEN_BG, "GTK_RC_TOKEN_BG", "bg" },
 
1575
      { GTK_RC_TOKEN_TEXT, "GTK_RC_TOKEN_TEXT", "text" },
 
1576
      { GTK_RC_TOKEN_BASE, "GTK_RC_TOKEN_BASE", "base" },
 
1577
      { GTK_RC_TOKEN_XTHICKNESS, "GTK_RC_TOKEN_XTHICKNESS", "xthickness" },
 
1578
      { GTK_RC_TOKEN_YTHICKNESS, "GTK_RC_TOKEN_YTHICKNESS", "ythickness" },
 
1579
      { GTK_RC_TOKEN_FONT, "GTK_RC_TOKEN_FONT", "font" },
 
1580
      { GTK_RC_TOKEN_FONTSET, "GTK_RC_TOKEN_FONTSET", "fontset" },
 
1581
      { GTK_RC_TOKEN_FONT_NAME, "GTK_RC_TOKEN_FONT_NAME", "font-name" },
 
1582
      { GTK_RC_TOKEN_BG_PIXMAP, "GTK_RC_TOKEN_BG_PIXMAP", "bg-pixmap" },
 
1583
      { GTK_RC_TOKEN_PIXMAP_PATH, "GTK_RC_TOKEN_PIXMAP_PATH", "pixmap-path" },
 
1584
      { GTK_RC_TOKEN_STYLE, "GTK_RC_TOKEN_STYLE", "style" },
 
1585
      { GTK_RC_TOKEN_BINDING, "GTK_RC_TOKEN_BINDING", "binding" },
 
1586
      { GTK_RC_TOKEN_BIND, "GTK_RC_TOKEN_BIND", "bind" },
 
1587
      { GTK_RC_TOKEN_WIDGET, "GTK_RC_TOKEN_WIDGET", "widget" },
 
1588
      { GTK_RC_TOKEN_WIDGET_CLASS, "GTK_RC_TOKEN_WIDGET_CLASS", "widget-class" },
 
1589
      { GTK_RC_TOKEN_CLASS, "GTK_RC_TOKEN_CLASS", "class" },
 
1590
      { GTK_RC_TOKEN_LOWEST, "GTK_RC_TOKEN_LOWEST", "lowest" },
 
1591
      { GTK_RC_TOKEN_GTK, "GTK_RC_TOKEN_GTK", "gtk" },
 
1592
      { GTK_RC_TOKEN_APPLICATION, "GTK_RC_TOKEN_APPLICATION", "application" },
 
1593
      { GTK_RC_TOKEN_THEME, "GTK_RC_TOKEN_THEME", "theme" },
 
1594
      { GTK_RC_TOKEN_RC, "GTK_RC_TOKEN_RC", "rc" },
 
1595
      { GTK_RC_TOKEN_HIGHEST, "GTK_RC_TOKEN_HIGHEST", "highest" },
 
1596
      { GTK_RC_TOKEN_ENGINE, "GTK_RC_TOKEN_ENGINE", "engine" },
 
1597
      { GTK_RC_TOKEN_MODULE_PATH, "GTK_RC_TOKEN_MODULE_PATH", "module-path" },
 
1598
      { GTK_RC_TOKEN_IM_MODULE_PATH, "GTK_RC_TOKEN_IM_MODULE_PATH", "im-module-path" },
 
1599
      { GTK_RC_TOKEN_IM_MODULE_FILE, "GTK_RC_TOKEN_IM_MODULE_FILE", "im-module-file" },
 
1600
      { GTK_RC_TOKEN_STOCK, "GTK_RC_TOKEN_STOCK", "stock" },
 
1601
      { GTK_RC_TOKEN_LTR, "GTK_RC_TOKEN_LTR", "ltr" },
 
1602
      { GTK_RC_TOKEN_RTL, "GTK_RC_TOKEN_RTL", "rtl" },
 
1603
      { GTK_RC_TOKEN_COLOR, "GTK_RC_TOKEN_COLOR", "color" },
 
1604
      { GTK_RC_TOKEN_LAST, "GTK_RC_TOKEN_LAST", "last" },
 
1605
      { 0, NULL, NULL }
 
1606
    };
 
1607
    etype = g_enum_register_static (g_intern_static_string ("GtkRcTokenType"), values);
 
1608
  }
 
1609
  return etype;
 
1610
}
 
1611
 
 
1612
/* enumerations from "gtkrecentchooser.h" */
 
1613
GType
 
1614
gtk_recent_sort_type_get_type (void)
 
1615
{
 
1616
  static GType etype = 0;
 
1617
  if (etype == 0) {
 
1618
    static const GEnumValue values[] = {
 
1619
      { GTK_RECENT_SORT_NONE, "GTK_RECENT_SORT_NONE", "none" },
 
1620
      { GTK_RECENT_SORT_MRU, "GTK_RECENT_SORT_MRU", "mru" },
 
1621
      { GTK_RECENT_SORT_LRU, "GTK_RECENT_SORT_LRU", "lru" },
 
1622
      { GTK_RECENT_SORT_CUSTOM, "GTK_RECENT_SORT_CUSTOM", "custom" },
 
1623
      { 0, NULL, NULL }
 
1624
    };
 
1625
    etype = g_enum_register_static (g_intern_static_string ("GtkRecentSortType"), values);
 
1626
  }
 
1627
  return etype;
 
1628
}
 
1629
GType
 
1630
gtk_recent_chooser_error_get_type (void)
 
1631
{
 
1632
  static GType etype = 0;
 
1633
  if (etype == 0) {
 
1634
    static const GEnumValue values[] = {
 
1635
      { GTK_RECENT_CHOOSER_ERROR_NOT_FOUND, "GTK_RECENT_CHOOSER_ERROR_NOT_FOUND", "not-found" },
 
1636
      { GTK_RECENT_CHOOSER_ERROR_INVALID_URI, "GTK_RECENT_CHOOSER_ERROR_INVALID_URI", "invalid-uri" },
 
1637
      { 0, NULL, NULL }
 
1638
    };
 
1639
    etype = g_enum_register_static (g_intern_static_string ("GtkRecentChooserError"), values);
 
1640
  }
 
1641
  return etype;
 
1642
}
 
1643
 
 
1644
/* enumerations from "gtkrecentfilter.h" */
 
1645
GType
 
1646
gtk_recent_filter_flags_get_type (void)
 
1647
{
 
1648
  static GType etype = 0;
 
1649
  if (etype == 0) {
 
1650
    static const GFlagsValue values[] = {
 
1651
      { GTK_RECENT_FILTER_URI, "GTK_RECENT_FILTER_URI", "uri" },
 
1652
      { GTK_RECENT_FILTER_DISPLAY_NAME, "GTK_RECENT_FILTER_DISPLAY_NAME", "display-name" },
 
1653
      { GTK_RECENT_FILTER_MIME_TYPE, "GTK_RECENT_FILTER_MIME_TYPE", "mime-type" },
 
1654
      { GTK_RECENT_FILTER_APPLICATION, "GTK_RECENT_FILTER_APPLICATION", "application" },
 
1655
      { GTK_RECENT_FILTER_GROUP, "GTK_RECENT_FILTER_GROUP", "group" },
 
1656
      { GTK_RECENT_FILTER_AGE, "GTK_RECENT_FILTER_AGE", "age" },
 
1657
      { 0, NULL, NULL }
 
1658
    };
 
1659
    etype = g_flags_register_static (g_intern_static_string ("GtkRecentFilterFlags"), values);
 
1660
  }
 
1661
  return etype;
 
1662
}
 
1663
 
 
1664
/* enumerations from "gtkrecentmanager.h" */
 
1665
GType
 
1666
gtk_recent_manager_error_get_type (void)
 
1667
{
 
1668
  static GType etype = 0;
 
1669
  if (etype == 0) {
 
1670
    static const GEnumValue values[] = {
 
1671
      { GTK_RECENT_MANAGER_ERROR_NOT_FOUND, "GTK_RECENT_MANAGER_ERROR_NOT_FOUND", "not-found" },
 
1672
      { GTK_RECENT_MANAGER_ERROR_INVALID_URI, "GTK_RECENT_MANAGER_ERROR_INVALID_URI", "invalid-uri" },
 
1673
      { GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING, "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING", "invalid-encoding" },
 
1674
      { GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED, "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED", "not-registered" },
 
1675
      { GTK_RECENT_MANAGER_ERROR_READ, "GTK_RECENT_MANAGER_ERROR_READ", "read" },
 
1676
      { GTK_RECENT_MANAGER_ERROR_WRITE, "GTK_RECENT_MANAGER_ERROR_WRITE", "write" },
 
1677
      { GTK_RECENT_MANAGER_ERROR_UNKNOWN, "GTK_RECENT_MANAGER_ERROR_UNKNOWN", "unknown" },
 
1678
      { 0, NULL, NULL }
 
1679
    };
 
1680
    etype = g_enum_register_static (g_intern_static_string ("GtkRecentManagerError"), values);
 
1681
  }
 
1682
  return etype;
 
1683
}
 
1684
 
 
1685
/* enumerations from "gtksizegroup.h" */
 
1686
GType
 
1687
gtk_size_group_mode_get_type (void)
 
1688
{
 
1689
  static GType etype = 0;
 
1690
  if (etype == 0) {
 
1691
    static const GEnumValue values[] = {
 
1692
      { GTK_SIZE_GROUP_NONE, "GTK_SIZE_GROUP_NONE", "none" },
 
1693
      { GTK_SIZE_GROUP_HORIZONTAL, "GTK_SIZE_GROUP_HORIZONTAL", "horizontal" },
 
1694
      { GTK_SIZE_GROUP_VERTICAL, "GTK_SIZE_GROUP_VERTICAL", "vertical" },
 
1695
      { GTK_SIZE_GROUP_BOTH, "GTK_SIZE_GROUP_BOTH", "both" },
 
1696
      { 0, NULL, NULL }
 
1697
    };
 
1698
    etype = g_enum_register_static (g_intern_static_string ("GtkSizeGroupMode"), values);
 
1699
  }
 
1700
  return etype;
 
1701
}
 
1702
 
 
1703
/* enumerations from "gtkspinbutton.h" */
 
1704
GType
 
1705
gtk_spin_button_update_policy_get_type (void)
 
1706
{
 
1707
  static GType etype = 0;
 
1708
  if (etype == 0) {
 
1709
    static const GEnumValue values[] = {
 
1710
      { GTK_UPDATE_ALWAYS, "GTK_UPDATE_ALWAYS", "always" },
 
1711
      { GTK_UPDATE_IF_VALID, "GTK_UPDATE_IF_VALID", "if-valid" },
 
1712
      { 0, NULL, NULL }
 
1713
    };
 
1714
    etype = g_enum_register_static (g_intern_static_string ("GtkSpinButtonUpdatePolicy"), values);
 
1715
  }
 
1716
  return etype;
 
1717
}
 
1718
GType
 
1719
gtk_spin_type_get_type (void)
 
1720
{
 
1721
  static GType etype = 0;
 
1722
  if (etype == 0) {
 
1723
    static const GEnumValue values[] = {
 
1724
      { GTK_SPIN_STEP_FORWARD, "GTK_SPIN_STEP_FORWARD", "step-forward" },
 
1725
      { GTK_SPIN_STEP_BACKWARD, "GTK_SPIN_STEP_BACKWARD", "step-backward" },
 
1726
      { GTK_SPIN_PAGE_FORWARD, "GTK_SPIN_PAGE_FORWARD", "page-forward" },
 
1727
      { GTK_SPIN_PAGE_BACKWARD, "GTK_SPIN_PAGE_BACKWARD", "page-backward" },
 
1728
      { GTK_SPIN_HOME, "GTK_SPIN_HOME", "home" },
 
1729
      { GTK_SPIN_END, "GTK_SPIN_END", "end" },
 
1730
      { GTK_SPIN_USER_DEFINED, "GTK_SPIN_USER_DEFINED", "user-defined" },
 
1731
      { 0, NULL, NULL }
 
1732
    };
 
1733
    etype = g_enum_register_static (g_intern_static_string ("GtkSpinType"), values);
 
1734
  }
 
1735
  return etype;
 
1736
}
 
1737
 
 
1738
/* enumerations from "gtktextbuffer.h" */
 
1739
GType
 
1740
gtk_text_buffer_target_info_get_type (void)
 
1741
{
 
1742
  static GType etype = 0;
 
1743
  if (etype == 0) {
 
1744
    static const GEnumValue values[] = {
 
1745
      { GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS, "GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS", "buffer-contents" },
 
1746
      { GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT, "GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT", "rich-text" },
 
1747
      { GTK_TEXT_BUFFER_TARGET_INFO_TEXT, "GTK_TEXT_BUFFER_TARGET_INFO_TEXT", "text" },
 
1748
      { 0, NULL, NULL }
 
1749
    };
 
1750
    etype = g_enum_register_static (g_intern_static_string ("GtkTextBufferTargetInfo"), values);
 
1751
  }
 
1752
  return etype;
 
1753
}
 
1754
 
 
1755
/* enumerations from "gtktextiter.h" */
 
1756
GType
 
1757
gtk_text_search_flags_get_type (void)
 
1758
{
 
1759
  static GType etype = 0;
 
1760
  if (etype == 0) {
 
1761
    static const GFlagsValue values[] = {
 
1762
      { GTK_TEXT_SEARCH_VISIBLE_ONLY, "GTK_TEXT_SEARCH_VISIBLE_ONLY", "visible-only" },
 
1763
      { GTK_TEXT_SEARCH_TEXT_ONLY, "GTK_TEXT_SEARCH_TEXT_ONLY", "text-only" },
 
1764
      { 0, NULL, NULL }
 
1765
    };
 
1766
    etype = g_flags_register_static (g_intern_static_string ("GtkTextSearchFlags"), values);
 
1767
  }
 
1768
  return etype;
 
1769
}
 
1770
 
 
1771
/* enumerations from "gtktextview.h" */
 
1772
GType
 
1773
gtk_text_window_type_get_type (void)
 
1774
{
 
1775
  static GType etype = 0;
 
1776
  if (etype == 0) {
 
1777
    static const GEnumValue values[] = {
 
1778
      { GTK_TEXT_WINDOW_PRIVATE, "GTK_TEXT_WINDOW_PRIVATE", "private" },
 
1779
      { GTK_TEXT_WINDOW_WIDGET, "GTK_TEXT_WINDOW_WIDGET", "widget" },
 
1780
      { GTK_TEXT_WINDOW_TEXT, "GTK_TEXT_WINDOW_TEXT", "text" },
 
1781
      { GTK_TEXT_WINDOW_LEFT, "GTK_TEXT_WINDOW_LEFT", "left" },
 
1782
      { GTK_TEXT_WINDOW_RIGHT, "GTK_TEXT_WINDOW_RIGHT", "right" },
 
1783
      { GTK_TEXT_WINDOW_TOP, "GTK_TEXT_WINDOW_TOP", "top" },
 
1784
      { GTK_TEXT_WINDOW_BOTTOM, "GTK_TEXT_WINDOW_BOTTOM", "bottom" },
 
1785
      { 0, NULL, NULL }
 
1786
    };
 
1787
    etype = g_enum_register_static (g_intern_static_string ("GtkTextWindowType"), values);
 
1788
  }
 
1789
  return etype;
 
1790
}
 
1791
 
 
1792
/* enumerations from "gtktoolbar.h" */
 
1793
GType
 
1794
gtk_toolbar_child_type_get_type (void)
 
1795
{
 
1796
  static GType etype = 0;
 
1797
  if (etype == 0) {
 
1798
    static const GEnumValue values[] = {
 
1799
      { GTK_TOOLBAR_CHILD_SPACE, "GTK_TOOLBAR_CHILD_SPACE", "space" },
 
1800
      { GTK_TOOLBAR_CHILD_BUTTON, "GTK_TOOLBAR_CHILD_BUTTON", "button" },
 
1801
      { GTK_TOOLBAR_CHILD_TOGGLEBUTTON, "GTK_TOOLBAR_CHILD_TOGGLEBUTTON", "togglebutton" },
 
1802
      { GTK_TOOLBAR_CHILD_RADIOBUTTON, "GTK_TOOLBAR_CHILD_RADIOBUTTON", "radiobutton" },
 
1803
      { GTK_TOOLBAR_CHILD_WIDGET, "GTK_TOOLBAR_CHILD_WIDGET", "widget" },
 
1804
      { 0, NULL, NULL }
 
1805
    };
 
1806
    etype = g_enum_register_static (g_intern_static_string ("GtkToolbarChildType"), values);
 
1807
  }
 
1808
  return etype;
 
1809
}
 
1810
GType
 
1811
gtk_toolbar_space_style_get_type (void)
 
1812
{
 
1813
  static GType etype = 0;
 
1814
  if (etype == 0) {
 
1815
    static const GEnumValue values[] = {
 
1816
      { GTK_TOOLBAR_SPACE_EMPTY, "GTK_TOOLBAR_SPACE_EMPTY", "empty" },
 
1817
      { GTK_TOOLBAR_SPACE_LINE, "GTK_TOOLBAR_SPACE_LINE", "line" },
 
1818
      { 0, NULL, NULL }
 
1819
    };
 
1820
    etype = g_enum_register_static (g_intern_static_string ("GtkToolbarSpaceStyle"), values);
 
1821
  }
 
1822
  return etype;
 
1823
}
 
1824
 
 
1825
/* enumerations from "gtktree.h" */
 
1826
GType
 
1827
gtk_tree_view_mode_get_type (void)
 
1828
{
 
1829
  static GType etype = 0;
 
1830
  if (etype == 0) {
 
1831
    static const GEnumValue values[] = {
 
1832
      { GTK_TREE_VIEW_LINE, "GTK_TREE_VIEW_LINE", "line" },
 
1833
      { GTK_TREE_VIEW_ITEM, "GTK_TREE_VIEW_ITEM", "item" },
 
1834
      { 0, NULL, NULL }
 
1835
    };
 
1836
    etype = g_enum_register_static (g_intern_static_string ("GtkTreeViewMode"), values);
 
1837
  }
 
1838
  return etype;
 
1839
}
 
1840
 
 
1841
/* enumerations from "gtktreemodel.h" */
 
1842
GType
 
1843
gtk_tree_model_flags_get_type (void)
 
1844
{
 
1845
  static GType etype = 0;
 
1846
  if (etype == 0) {
 
1847
    static const GFlagsValue values[] = {
 
1848
      { GTK_TREE_MODEL_ITERS_PERSIST, "GTK_TREE_MODEL_ITERS_PERSIST", "iters-persist" },
 
1849
      { GTK_TREE_MODEL_LIST_ONLY, "GTK_TREE_MODEL_LIST_ONLY", "list-only" },
 
1850
      { 0, NULL, NULL }
 
1851
    };
 
1852
    etype = g_flags_register_static (g_intern_static_string ("GtkTreeModelFlags"), values);
 
1853
  }
 
1854
  return etype;
 
1855
}
 
1856
 
 
1857
/* enumerations from "gtktreeview.h" */
 
1858
GType
 
1859
gtk_tree_view_drop_position_get_type (void)
 
1860
{
 
1861
  static GType etype = 0;
 
1862
  if (etype == 0) {
 
1863
    static const GEnumValue values[] = {
 
1864
      { GTK_TREE_VIEW_DROP_BEFORE, "GTK_TREE_VIEW_DROP_BEFORE", "before" },
 
1865
      { GTK_TREE_VIEW_DROP_AFTER, "GTK_TREE_VIEW_DROP_AFTER", "after" },
 
1866
      { GTK_TREE_VIEW_DROP_INTO_OR_BEFORE, "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE", "into-or-before" },
 
1867
      { GTK_TREE_VIEW_DROP_INTO_OR_AFTER, "GTK_TREE_VIEW_DROP_INTO_OR_AFTER", "into-or-after" },
 
1868
      { 0, NULL, NULL }
 
1869
    };
 
1870
    etype = g_enum_register_static (g_intern_static_string ("GtkTreeViewDropPosition"), values);
 
1871
  }
 
1872
  return etype;
 
1873
}
 
1874
 
 
1875
/* enumerations from "gtktreeviewcolumn.h" */
 
1876
GType
 
1877
gtk_tree_view_column_sizing_get_type (void)
 
1878
{
 
1879
  static GType etype = 0;
 
1880
  if (etype == 0) {
 
1881
    static const GEnumValue values[] = {
 
1882
      { GTK_TREE_VIEW_COLUMN_GROW_ONLY, "GTK_TREE_VIEW_COLUMN_GROW_ONLY", "grow-only" },
 
1883
      { GTK_TREE_VIEW_COLUMN_AUTOSIZE, "GTK_TREE_VIEW_COLUMN_AUTOSIZE", "autosize" },
 
1884
      { GTK_TREE_VIEW_COLUMN_FIXED, "GTK_TREE_VIEW_COLUMN_FIXED", "fixed" },
 
1885
      { 0, NULL, NULL }
 
1886
    };
 
1887
    etype = g_enum_register_static (g_intern_static_string ("GtkTreeViewColumnSizing"), values);
 
1888
  }
 
1889
  return etype;
 
1890
}
 
1891
 
 
1892
/* enumerations from "gtkuimanager.h" */
 
1893
GType
 
1894
gtk_ui_manager_item_type_get_type (void)
 
1895
{
 
1896
  static GType etype = 0;
 
1897
  if (etype == 0) {
 
1898
    static const GFlagsValue values[] = {
 
1899
      { GTK_UI_MANAGER_AUTO, "GTK_UI_MANAGER_AUTO", "auto" },
 
1900
      { GTK_UI_MANAGER_MENUBAR, "GTK_UI_MANAGER_MENUBAR", "menubar" },
 
1901
      { GTK_UI_MANAGER_MENU, "GTK_UI_MANAGER_MENU", "menu" },
 
1902
      { GTK_UI_MANAGER_TOOLBAR, "GTK_UI_MANAGER_TOOLBAR", "toolbar" },
 
1903
      { GTK_UI_MANAGER_PLACEHOLDER, "GTK_UI_MANAGER_PLACEHOLDER", "placeholder" },
 
1904
      { GTK_UI_MANAGER_POPUP, "GTK_UI_MANAGER_POPUP", "popup" },
 
1905
      { GTK_UI_MANAGER_MENUITEM, "GTK_UI_MANAGER_MENUITEM", "menuitem" },
 
1906
      { GTK_UI_MANAGER_TOOLITEM, "GTK_UI_MANAGER_TOOLITEM", "toolitem" },
 
1907
      { GTK_UI_MANAGER_SEPARATOR, "GTK_UI_MANAGER_SEPARATOR", "separator" },
 
1908
      { GTK_UI_MANAGER_ACCELERATOR, "GTK_UI_MANAGER_ACCELERATOR", "accelerator" },
 
1909
      { 0, NULL, NULL }
 
1910
    };
 
1911
    etype = g_flags_register_static (g_intern_static_string ("GtkUIManagerItemType"), values);
 
1912
  }
 
1913
  return etype;
 
1914
}
 
1915
 
 
1916
/* enumerations from "gtkwidget.h" */
 
1917
GType
 
1918
gtk_widget_flags_get_type (void)
 
1919
{
 
1920
  static GType etype = 0;
 
1921
  if (etype == 0) {
 
1922
    static const GFlagsValue values[] = {
 
1923
      { GTK_TOPLEVEL, "GTK_TOPLEVEL", "toplevel" },
 
1924
      { GTK_NO_WINDOW, "GTK_NO_WINDOW", "no-window" },
 
1925
      { GTK_REALIZED, "GTK_REALIZED", "realized" },
 
1926
      { GTK_MAPPED, "GTK_MAPPED", "mapped" },
 
1927
      { GTK_VISIBLE, "GTK_VISIBLE", "visible" },
 
1928
      { GTK_SENSITIVE, "GTK_SENSITIVE", "sensitive" },
 
1929
      { GTK_PARENT_SENSITIVE, "GTK_PARENT_SENSITIVE", "parent-sensitive" },
 
1930
      { GTK_CAN_FOCUS, "GTK_CAN_FOCUS", "can-focus" },
 
1931
      { GTK_HAS_FOCUS, "GTK_HAS_FOCUS", "has-focus" },
 
1932
      { GTK_CAN_DEFAULT, "GTK_CAN_DEFAULT", "can-default" },
 
1933
      { GTK_HAS_DEFAULT, "GTK_HAS_DEFAULT", "has-default" },
 
1934
      { GTK_HAS_GRAB, "GTK_HAS_GRAB", "has-grab" },
 
1935
      { GTK_RC_STYLE, "GTK_RC_STYLE", "rc-style" },
 
1936
      { GTK_COMPOSITE_CHILD, "GTK_COMPOSITE_CHILD", "composite-child" },
 
1937
      { GTK_NO_REPARENT, "GTK_NO_REPARENT", "no-reparent" },
 
1938
      { GTK_APP_PAINTABLE, "GTK_APP_PAINTABLE", "app-paintable" },
 
1939
      { GTK_RECEIVES_DEFAULT, "GTK_RECEIVES_DEFAULT", "receives-default" },
 
1940
      { GTK_DOUBLE_BUFFERED, "GTK_DOUBLE_BUFFERED", "double-buffered" },
 
1941
      { GTK_NO_SHOW_ALL, "GTK_NO_SHOW_ALL", "no-show-all" },
 
1942
      { 0, NULL, NULL }
 
1943
    };
 
1944
    etype = g_flags_register_static (g_intern_static_string ("GtkWidgetFlags"), values);
 
1945
  }
 
1946
  return etype;
 
1947
}
 
1948
GType
 
1949
gtk_widget_help_type_get_type (void)
 
1950
{
 
1951
  static GType etype = 0;
 
1952
  if (etype == 0) {
 
1953
    static const GEnumValue values[] = {
 
1954
      { GTK_WIDGET_HELP_TOOLTIP, "GTK_WIDGET_HELP_TOOLTIP", "tooltip" },
 
1955
      { GTK_WIDGET_HELP_WHATS_THIS, "GTK_WIDGET_HELP_WHATS_THIS", "whats-this" },
 
1956
      { 0, NULL, NULL }
 
1957
    };
 
1958
    etype = g_enum_register_static (g_intern_static_string ("GtkWidgetHelpType"), values);
 
1959
  }
 
1960
  return etype;
 
1961
}
 
1962
#define __GTK_TYPE_BUILTINS_C__
 
1963
#include "gtkaliasdef.c"
 
1964
 
 
1965
/* Generated data ends here */
 
1966