1
2 /* Generated data (by gimp-mkenums) */
3
4 #include "config.h"
5 #include <gio/gio.h>
6 #include "libgimpbase/gimpbase.h"
7 #include "config-enums.h"
8 #include"gimp-intl.h"
9
10 /* enumerations from "config-enums.h" */
11 GType
gimp_canvas_padding_mode_get_type(void)12 gimp_canvas_padding_mode_get_type (void)
13 {
14 static const GEnumValue values[] =
15 {
16 { GIMP_CANVAS_PADDING_MODE_DEFAULT, "GIMP_CANVAS_PADDING_MODE_DEFAULT", "default" },
17 { GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, "GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK", "light-check" },
18 { GIMP_CANVAS_PADDING_MODE_DARK_CHECK, "GIMP_CANVAS_PADDING_MODE_DARK_CHECK", "dark-check" },
19 { GIMP_CANVAS_PADDING_MODE_CUSTOM, "GIMP_CANVAS_PADDING_MODE_CUSTOM", "custom" },
20 { 0, NULL, NULL }
21 };
22
23 static const GimpEnumDesc descs[] =
24 {
25 { GIMP_CANVAS_PADDING_MODE_DEFAULT, NC_("canvas-padding-mode", "From theme"), NULL },
26 { GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK, NC_("canvas-padding-mode", "Light check color"), NULL },
27 { GIMP_CANVAS_PADDING_MODE_DARK_CHECK, NC_("canvas-padding-mode", "Dark check color"), NULL },
28 { GIMP_CANVAS_PADDING_MODE_CUSTOM, NC_("canvas-padding-mode", "Custom color"), NULL },
29 { 0, NULL, NULL }
30 };
31
32 static GType type = 0;
33
34 if (G_UNLIKELY (! type))
35 {
36 type = g_enum_register_static ("GimpCanvasPaddingMode", values);
37 gimp_type_set_translation_context (type, "canvas-padding-mode");
38 gimp_enum_set_value_descriptions (type, descs);
39 }
40
41 return type;
42 }
43
44 GType
gimp_cursor_format_get_type(void)45 gimp_cursor_format_get_type (void)
46 {
47 static const GEnumValue values[] =
48 {
49 { GIMP_CURSOR_FORMAT_BITMAP, "GIMP_CURSOR_FORMAT_BITMAP", "bitmap" },
50 { GIMP_CURSOR_FORMAT_PIXBUF, "GIMP_CURSOR_FORMAT_PIXBUF", "pixbuf" },
51 { 0, NULL, NULL }
52 };
53
54 static const GimpEnumDesc descs[] =
55 {
56 { GIMP_CURSOR_FORMAT_BITMAP, NC_("cursor-format", "Black & white"), NULL },
57 { GIMP_CURSOR_FORMAT_PIXBUF, NC_("cursor-format", "Fancy"), NULL },
58 { 0, NULL, NULL }
59 };
60
61 static GType type = 0;
62
63 if (G_UNLIKELY (! type))
64 {
65 type = g_enum_register_static ("GimpCursorFormat", values);
66 gimp_type_set_translation_context (type, "cursor-format");
67 gimp_enum_set_value_descriptions (type, descs);
68 }
69
70 return type;
71 }
72
73 GType
gimp_cursor_mode_get_type(void)74 gimp_cursor_mode_get_type (void)
75 {
76 static const GEnumValue values[] =
77 {
78 { GIMP_CURSOR_MODE_TOOL_ICON, "GIMP_CURSOR_MODE_TOOL_ICON", "tool-icon" },
79 { GIMP_CURSOR_MODE_TOOL_CROSSHAIR, "GIMP_CURSOR_MODE_TOOL_CROSSHAIR", "tool-crosshair" },
80 { GIMP_CURSOR_MODE_CROSSHAIR, "GIMP_CURSOR_MODE_CROSSHAIR", "crosshair" },
81 { 0, NULL, NULL }
82 };
83
84 static const GimpEnumDesc descs[] =
85 {
86 { GIMP_CURSOR_MODE_TOOL_ICON, NC_("cursor-mode", "Tool icon"), NULL },
87 { GIMP_CURSOR_MODE_TOOL_CROSSHAIR, NC_("cursor-mode", "Tool icon with crosshair"), NULL },
88 { GIMP_CURSOR_MODE_CROSSHAIR, NC_("cursor-mode", "Crosshair only"), NULL },
89 { 0, NULL, NULL }
90 };
91
92 static GType type = 0;
93
94 if (G_UNLIKELY (! type))
95 {
96 type = g_enum_register_static ("GimpCursorMode", values);
97 gimp_type_set_translation_context (type, "cursor-mode");
98 gimp_enum_set_value_descriptions (type, descs);
99 }
100
101 return type;
102 }
103
104 GType
gimp_export_file_type_get_type(void)105 gimp_export_file_type_get_type (void)
106 {
107 static const GEnumValue values[] =
108 {
109 { GIMP_EXPORT_FILE_PNG, "GIMP_EXPORT_FILE_PNG", "png" },
110 { GIMP_EXPORT_FILE_JPG, "GIMP_EXPORT_FILE_JPG", "jpg" },
111 { GIMP_EXPORT_FILE_ORA, "GIMP_EXPORT_FILE_ORA", "ora" },
112 { GIMP_EXPORT_FILE_PSD, "GIMP_EXPORT_FILE_PSD", "psd" },
113 { GIMP_EXPORT_FILE_PDF, "GIMP_EXPORT_FILE_PDF", "pdf" },
114 { GIMP_EXPORT_FILE_TIF, "GIMP_EXPORT_FILE_TIF", "tif" },
115 { GIMP_EXPORT_FILE_BMP, "GIMP_EXPORT_FILE_BMP", "bmp" },
116 { GIMP_EXPORT_FILE_WEBP, "GIMP_EXPORT_FILE_WEBP", "webp" },
117 { 0, NULL, NULL }
118 };
119
120 static const GimpEnumDesc descs[] =
121 {
122 { GIMP_EXPORT_FILE_PNG, NC_("export-file-type", "PNG Image"), NULL },
123 { GIMP_EXPORT_FILE_JPG, NC_("export-file-type", "JPEG Image"), NULL },
124 { GIMP_EXPORT_FILE_ORA, NC_("export-file-type", "OpenRaster Image"), NULL },
125 { GIMP_EXPORT_FILE_PSD, NC_("export-file-type", "Photoshop Image"), NULL },
126 { GIMP_EXPORT_FILE_PDF, NC_("export-file-type", "Portable Document Format"), NULL },
127 { GIMP_EXPORT_FILE_TIF, NC_("export-file-type", "TIFF Image"), NULL },
128 { GIMP_EXPORT_FILE_BMP, NC_("export-file-type", "Windows BMP Image"), NULL },
129 { GIMP_EXPORT_FILE_WEBP, NC_("export-file-type", "WebP Image"), NULL },
130 { 0, NULL, NULL }
131 };
132
133 static GType type = 0;
134
135 if (G_UNLIKELY (! type))
136 {
137 type = g_enum_register_static ("GimpExportFileType", values);
138 gimp_type_set_translation_context (type, "export-file-type");
139 gimp_enum_set_value_descriptions (type, descs);
140 }
141
142 return type;
143 }
144
145 GType
gimp_handedness_get_type(void)146 gimp_handedness_get_type (void)
147 {
148 static const GEnumValue values[] =
149 {
150 { GIMP_HANDEDNESS_LEFT, "GIMP_HANDEDNESS_LEFT", "left" },
151 { GIMP_HANDEDNESS_RIGHT, "GIMP_HANDEDNESS_RIGHT", "right" },
152 { 0, NULL, NULL }
153 };
154
155 static const GimpEnumDesc descs[] =
156 {
157 { GIMP_HANDEDNESS_LEFT, NC_("handedness", "Left-handed"), NULL },
158 { GIMP_HANDEDNESS_RIGHT, NC_("handedness", "Right-handed"), NULL },
159 { 0, NULL, NULL }
160 };
161
162 static GType type = 0;
163
164 if (G_UNLIKELY (! type))
165 {
166 type = g_enum_register_static ("GimpHandedness", values);
167 gimp_type_set_translation_context (type, "handedness");
168 gimp_enum_set_value_descriptions (type, descs);
169 }
170
171 return type;
172 }
173
174 GType
gimp_help_browser_type_get_type(void)175 gimp_help_browser_type_get_type (void)
176 {
177 static const GEnumValue values[] =
178 {
179 { GIMP_HELP_BROWSER_GIMP, "GIMP_HELP_BROWSER_GIMP", "gimp" },
180 { GIMP_HELP_BROWSER_WEB_BROWSER, "GIMP_HELP_BROWSER_WEB_BROWSER", "web-browser" },
181 { 0, NULL, NULL }
182 };
183
184 static const GimpEnumDesc descs[] =
185 {
186 { GIMP_HELP_BROWSER_GIMP, NC_("help-browser-type", "GIMP help browser"), NULL },
187 { GIMP_HELP_BROWSER_WEB_BROWSER, NC_("help-browser-type", "Web browser"), NULL },
188 { 0, NULL, NULL }
189 };
190
191 static GType type = 0;
192
193 if (G_UNLIKELY (! type))
194 {
195 type = g_enum_register_static ("GimpHelpBrowserType", values);
196 gimp_type_set_translation_context (type, "help-browser-type");
197 gimp_enum_set_value_descriptions (type, descs);
198 }
199
200 return type;
201 }
202
203 GType
gimp_icon_size_get_type(void)204 gimp_icon_size_get_type (void)
205 {
206 static const GEnumValue values[] =
207 {
208 { GIMP_ICON_SIZE_AUTO, "GIMP_ICON_SIZE_AUTO", "auto" },
209 { GIMP_ICON_SIZE_THEME, "GIMP_ICON_SIZE_THEME", "theme" },
210 { GIMP_ICON_SIZE_SMALL, "GIMP_ICON_SIZE_SMALL", "small" },
211 { GIMP_ICON_SIZE_MEDIUM, "GIMP_ICON_SIZE_MEDIUM", "medium" },
212 { GIMP_ICON_SIZE_LARGE, "GIMP_ICON_SIZE_LARGE", "large" },
213 { GIMP_ICON_SIZE_HUGE, "GIMP_ICON_SIZE_HUGE", "huge" },
214 { 0, NULL, NULL }
215 };
216
217 static const GimpEnumDesc descs[] =
218 {
219 { GIMP_ICON_SIZE_AUTO, NC_("icon-size", "Guess ideal size"), NULL },
220 { GIMP_ICON_SIZE_THEME, NC_("icon-size", "Theme-set size"), NULL },
221 { GIMP_ICON_SIZE_SMALL, NC_("icon-size", "Small size"), NULL },
222 { GIMP_ICON_SIZE_MEDIUM, NC_("icon-size", "Medium size"), NULL },
223 { GIMP_ICON_SIZE_LARGE, NC_("icon-size", "Large size"), NULL },
224 { GIMP_ICON_SIZE_HUGE, NC_("icon-size", "Huge size"), NULL },
225 { 0, NULL, NULL }
226 };
227
228 static GType type = 0;
229
230 if (G_UNLIKELY (! type))
231 {
232 type = g_enum_register_static ("GimpIconSize", values);
233 gimp_type_set_translation_context (type, "icon-size");
234 gimp_enum_set_value_descriptions (type, descs);
235 }
236
237 return type;
238 }
239
240 GType
gimp_position_get_type(void)241 gimp_position_get_type (void)
242 {
243 static const GEnumValue values[] =
244 {
245 { GIMP_POSITION_TOP, "GIMP_POSITION_TOP", "top" },
246 { GIMP_POSITION_BOTTOM, "GIMP_POSITION_BOTTOM", "bottom" },
247 { GIMP_POSITION_LEFT, "GIMP_POSITION_LEFT", "left" },
248 { GIMP_POSITION_RIGHT, "GIMP_POSITION_RIGHT", "right" },
249 { 0, NULL, NULL }
250 };
251
252 static const GimpEnumDesc descs[] =
253 {
254 { GIMP_POSITION_TOP, NC_("position", "Top"), NULL },
255 { GIMP_POSITION_BOTTOM, NC_("position", "Bottom"), NULL },
256 { GIMP_POSITION_LEFT, NC_("position", "Left"), NULL },
257 { GIMP_POSITION_RIGHT, NC_("position", "Right"), NULL },
258 { 0, NULL, NULL }
259 };
260
261 static GType type = 0;
262
263 if (G_UNLIKELY (! type))
264 {
265 type = g_enum_register_static ("GimpPosition", values);
266 gimp_type_set_translation_context (type, "position");
267 gimp_enum_set_value_descriptions (type, descs);
268 }
269
270 return type;
271 }
272
273 GType
gimp_space_bar_action_get_type(void)274 gimp_space_bar_action_get_type (void)
275 {
276 static const GEnumValue values[] =
277 {
278 { GIMP_SPACE_BAR_ACTION_NONE, "GIMP_SPACE_BAR_ACTION_NONE", "none" },
279 { GIMP_SPACE_BAR_ACTION_PAN, "GIMP_SPACE_BAR_ACTION_PAN", "pan" },
280 { GIMP_SPACE_BAR_ACTION_MOVE, "GIMP_SPACE_BAR_ACTION_MOVE", "move" },
281 { 0, NULL, NULL }
282 };
283
284 static const GimpEnumDesc descs[] =
285 {
286 { GIMP_SPACE_BAR_ACTION_NONE, NC_("space-bar-action", "No action"), NULL },
287 { GIMP_SPACE_BAR_ACTION_PAN, NC_("space-bar-action", "Pan view"), NULL },
288 { GIMP_SPACE_BAR_ACTION_MOVE, NC_("space-bar-action", "Switch to Move tool"), NULL },
289 { 0, NULL, NULL }
290 };
291
292 static GType type = 0;
293
294 if (G_UNLIKELY (! type))
295 {
296 type = g_enum_register_static ("GimpSpaceBarAction", values);
297 gimp_type_set_translation_context (type, "space-bar-action");
298 gimp_enum_set_value_descriptions (type, descs);
299 }
300
301 return type;
302 }
303
304 GType
gimp_tool_group_menu_mode_get_type(void)305 gimp_tool_group_menu_mode_get_type (void)
306 {
307 static const GEnumValue values[] =
308 {
309 { GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_CLICK, "GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_CLICK", "click" },
310 { GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_HOVER, "GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_HOVER", "hover" },
311 { GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_HOVER_SINGLE_COLUMN, "GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_HOVER_SINGLE_COLUMN", "hover-single-column" },
312 { 0, NULL, NULL }
313 };
314
315 static const GimpEnumDesc descs[] =
316 {
317 { GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_CLICK, NC_("tool-group-menu-mode", "Show on click"), NULL },
318 { GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_HOVER, NC_("tool-group-menu-mode", "Show on hover"), NULL },
319 { GIMP_TOOL_GROUP_MENU_MODE_SHOW_ON_HOVER_SINGLE_COLUMN, NC_("tool-group-menu-mode", "Show on hover in single column"), NULL },
320 { 0, NULL, NULL }
321 };
322
323 static GType type = 0;
324
325 if (G_UNLIKELY (! type))
326 {
327 type = g_enum_register_static ("GimpToolGroupMenuMode", values);
328 gimp_type_set_translation_context (type, "tool-group-menu-mode");
329 gimp_enum_set_value_descriptions (type, descs);
330 }
331
332 return type;
333 }
334
335 GType
gimp_window_hint_get_type(void)336 gimp_window_hint_get_type (void)
337 {
338 static const GEnumValue values[] =
339 {
340 { GIMP_WINDOW_HINT_NORMAL, "GIMP_WINDOW_HINT_NORMAL", "normal" },
341 { GIMP_WINDOW_HINT_UTILITY, "GIMP_WINDOW_HINT_UTILITY", "utility" },
342 { GIMP_WINDOW_HINT_KEEP_ABOVE, "GIMP_WINDOW_HINT_KEEP_ABOVE", "keep-above" },
343 { 0, NULL, NULL }
344 };
345
346 static const GimpEnumDesc descs[] =
347 {
348 { GIMP_WINDOW_HINT_NORMAL, NC_("window-hint", "Normal window"), NULL },
349 { GIMP_WINDOW_HINT_UTILITY, NC_("window-hint", "Utility window"), NULL },
350 { GIMP_WINDOW_HINT_KEEP_ABOVE, NC_("window-hint", "Keep above"), NULL },
351 { 0, NULL, NULL }
352 };
353
354 static GType type = 0;
355
356 if (G_UNLIKELY (! type))
357 {
358 type = g_enum_register_static ("GimpWindowHint", values);
359 gimp_type_set_translation_context (type, "window-hint");
360 gimp_enum_set_value_descriptions (type, descs);
361 }
362
363 return type;
364 }
365
366 GType
gimp_zoom_quality_get_type(void)367 gimp_zoom_quality_get_type (void)
368 {
369 static const GEnumValue values[] =
370 {
371 { GIMP_ZOOM_QUALITY_LOW, "GIMP_ZOOM_QUALITY_LOW", "low" },
372 { GIMP_ZOOM_QUALITY_HIGH, "GIMP_ZOOM_QUALITY_HIGH", "high" },
373 { 0, NULL, NULL }
374 };
375
376 static const GimpEnumDesc descs[] =
377 {
378 { GIMP_ZOOM_QUALITY_LOW, NC_("zoom-quality", "Low"), NULL },
379 { GIMP_ZOOM_QUALITY_HIGH, NC_("zoom-quality", "High"), NULL },
380 { 0, NULL, NULL }
381 };
382
383 static GType type = 0;
384
385 if (G_UNLIKELY (! type))
386 {
387 type = g_enum_register_static ("GimpZoomQuality", values);
388 gimp_type_set_translation_context (type, "zoom-quality");
389 gimp_enum_set_value_descriptions (type, descs);
390 }
391
392 return type;
393 }
394
395
396 /* Generated data ends here */
397
398