1
2 /* Generated data (by gimp-mkenums) */
3
4 #include "config.h"
5 #include <glib-object.h>
6 #undef GIMP_DISABLE_DEPRECATED
7 #include "gimpbasetypes.h"
8 #include "libgimp/libgimp-intl.h"
9
10 /* enumerations from "gimpbaseenums.h" */
11 GType
gimp_add_mask_type_get_type(void)12 gimp_add_mask_type_get_type (void)
13 {
14 static const GEnumValue values[] =
15 {
16 { GIMP_ADD_MASK_WHITE, "GIMP_ADD_MASK_WHITE", "white" },
17 { GIMP_ADD_MASK_BLACK, "GIMP_ADD_MASK_BLACK", "black" },
18 { GIMP_ADD_MASK_ALPHA, "GIMP_ADD_MASK_ALPHA", "alpha" },
19 { GIMP_ADD_MASK_ALPHA_TRANSFER, "GIMP_ADD_MASK_ALPHA_TRANSFER", "alpha-transfer" },
20 { GIMP_ADD_MASK_SELECTION, "GIMP_ADD_MASK_SELECTION", "selection" },
21 { GIMP_ADD_MASK_COPY, "GIMP_ADD_MASK_COPY", "copy" },
22 { GIMP_ADD_MASK_CHANNEL, "GIMP_ADD_MASK_CHANNEL", "channel" },
23 { 0, NULL, NULL }
24 };
25
26 static const GimpEnumDesc descs[] =
27 {
28 { GIMP_ADD_MASK_WHITE, NC_("add-mask-type", "_White (full opacity)"), NULL },
29 { GIMP_ADD_MASK_BLACK, NC_("add-mask-type", "_Black (full transparency)"), NULL },
30 { GIMP_ADD_MASK_ALPHA, NC_("add-mask-type", "Layer's _alpha channel"), NULL },
31 { GIMP_ADD_MASK_ALPHA_TRANSFER, NC_("add-mask-type", "_Transfer layer's alpha channel"), NULL },
32 { GIMP_ADD_MASK_SELECTION, NC_("add-mask-type", "_Selection"), NULL },
33 { GIMP_ADD_MASK_COPY, NC_("add-mask-type", "_Grayscale copy of layer"), NULL },
34 { GIMP_ADD_MASK_CHANNEL, NC_("add-mask-type", "C_hannel"), NULL },
35 { 0, NULL, NULL }
36 };
37
38 static GType type = 0;
39
40 if (G_UNLIKELY (! type))
41 {
42 type = g_enum_register_static ("GimpAddMaskType", values);
43 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
44 gimp_type_set_translation_context (type, "add-mask-type");
45 gimp_enum_set_value_descriptions (type, descs);
46 }
47
48 return type;
49 }
50
51 GType
gimp_blend_mode_get_type(void)52 gimp_blend_mode_get_type (void)
53 {
54 static const GEnumValue values[] =
55 {
56 { GIMP_BLEND_FG_BG_RGB, "GIMP_BLEND_FG_BG_RGB", "fg-bg-rgb" },
57 { GIMP_BLEND_FG_BG_HSV, "GIMP_BLEND_FG_BG_HSV", "fg-bg-hsv" },
58 { GIMP_BLEND_FG_TRANSPARENT, "GIMP_BLEND_FG_TRANSPARENT", "fg-transparent" },
59 { GIMP_BLEND_CUSTOM, "GIMP_BLEND_CUSTOM", "custom" },
60 { 0, NULL, NULL }
61 };
62
63 static const GimpEnumDesc descs[] =
64 {
65 { GIMP_BLEND_FG_BG_RGB, NC_("blend-mode", "FG to BG (RGB)"), NULL },
66 { GIMP_BLEND_FG_BG_HSV, NC_("blend-mode", "FG to BG (HSV)"), NULL },
67 { GIMP_BLEND_FG_TRANSPARENT, NC_("blend-mode", "FG to transparent"), NULL },
68 { GIMP_BLEND_CUSTOM, NC_("blend-mode", "Custom gradient"), NULL },
69 { 0, NULL, NULL }
70 };
71
72 static GType type = 0;
73
74 if (G_UNLIKELY (! type))
75 {
76 type = g_enum_register_static ("GimpBlendMode", values);
77 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
78 gimp_type_set_translation_context (type, "blend-mode");
79 gimp_enum_set_value_descriptions (type, descs);
80 }
81
82 return type;
83 }
84
85 GType
gimp_brush_generated_shape_get_type(void)86 gimp_brush_generated_shape_get_type (void)
87 {
88 static const GEnumValue values[] =
89 {
90 { GIMP_BRUSH_GENERATED_CIRCLE, "GIMP_BRUSH_GENERATED_CIRCLE", "circle" },
91 { GIMP_BRUSH_GENERATED_SQUARE, "GIMP_BRUSH_GENERATED_SQUARE", "square" },
92 { GIMP_BRUSH_GENERATED_DIAMOND, "GIMP_BRUSH_GENERATED_DIAMOND", "diamond" },
93 { 0, NULL, NULL }
94 };
95
96 static const GimpEnumDesc descs[] =
97 {
98 { GIMP_BRUSH_GENERATED_CIRCLE, NC_("brush-generated-shape", "Circle"), NULL },
99 { GIMP_BRUSH_GENERATED_SQUARE, NC_("brush-generated-shape", "Square"), NULL },
100 { GIMP_BRUSH_GENERATED_DIAMOND, NC_("brush-generated-shape", "Diamond"), NULL },
101 { 0, NULL, NULL }
102 };
103
104 static GType type = 0;
105
106 if (G_UNLIKELY (! type))
107 {
108 type = g_enum_register_static ("GimpBrushGeneratedShape", values);
109 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
110 gimp_type_set_translation_context (type, "brush-generated-shape");
111 gimp_enum_set_value_descriptions (type, descs);
112 }
113
114 return type;
115 }
116
117 GType
gimp_bucket_fill_mode_get_type(void)118 gimp_bucket_fill_mode_get_type (void)
119 {
120 static const GEnumValue values[] =
121 {
122 { GIMP_BUCKET_FILL_FG, "GIMP_BUCKET_FILL_FG", "fg" },
123 { GIMP_BUCKET_FILL_BG, "GIMP_BUCKET_FILL_BG", "bg" },
124 { GIMP_BUCKET_FILL_PATTERN, "GIMP_BUCKET_FILL_PATTERN", "pattern" },
125 { 0, NULL, NULL }
126 };
127
128 static const GimpEnumDesc descs[] =
129 {
130 { GIMP_BUCKET_FILL_FG, NC_("bucket-fill-mode", "FG color fill"), NULL },
131 { GIMP_BUCKET_FILL_BG, NC_("bucket-fill-mode", "BG color fill"), NULL },
132 { GIMP_BUCKET_FILL_PATTERN, NC_("bucket-fill-mode", "Pattern fill"), NULL },
133 { 0, NULL, NULL }
134 };
135
136 static GType type = 0;
137
138 if (G_UNLIKELY (! type))
139 {
140 type = g_enum_register_static ("GimpBucketFillMode", values);
141 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
142 gimp_type_set_translation_context (type, "bucket-fill-mode");
143 gimp_enum_set_value_descriptions (type, descs);
144 }
145
146 return type;
147 }
148
149 GType
gimp_cap_style_get_type(void)150 gimp_cap_style_get_type (void)
151 {
152 static const GEnumValue values[] =
153 {
154 { GIMP_CAP_BUTT, "GIMP_CAP_BUTT", "butt" },
155 { GIMP_CAP_ROUND, "GIMP_CAP_ROUND", "round" },
156 { GIMP_CAP_SQUARE, "GIMP_CAP_SQUARE", "square" },
157 { 0, NULL, NULL }
158 };
159
160 static const GimpEnumDesc descs[] =
161 {
162 { GIMP_CAP_BUTT, NC_("cap-style", "Butt"), NULL },
163 { GIMP_CAP_ROUND, NC_("cap-style", "Round"), NULL },
164 { GIMP_CAP_SQUARE, NC_("cap-style", "Square"), NULL },
165 { 0, NULL, NULL }
166 };
167
168 static GType type = 0;
169
170 if (G_UNLIKELY (! type))
171 {
172 type = g_enum_register_static ("GimpCapStyle", values);
173 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
174 gimp_type_set_translation_context (type, "cap-style");
175 gimp_enum_set_value_descriptions (type, descs);
176 }
177
178 return type;
179 }
180
181 GType
gimp_channel_ops_get_type(void)182 gimp_channel_ops_get_type (void)
183 {
184 static const GEnumValue values[] =
185 {
186 { GIMP_CHANNEL_OP_ADD, "GIMP_CHANNEL_OP_ADD", "add" },
187 { GIMP_CHANNEL_OP_SUBTRACT, "GIMP_CHANNEL_OP_SUBTRACT", "subtract" },
188 { GIMP_CHANNEL_OP_REPLACE, "GIMP_CHANNEL_OP_REPLACE", "replace" },
189 { GIMP_CHANNEL_OP_INTERSECT, "GIMP_CHANNEL_OP_INTERSECT", "intersect" },
190 { 0, NULL, NULL }
191 };
192
193 static const GimpEnumDesc descs[] =
194 {
195 { GIMP_CHANNEL_OP_ADD, NC_("channel-ops", "Add to the current selection"), NULL },
196 { GIMP_CHANNEL_OP_SUBTRACT, NC_("channel-ops", "Subtract from the current selection"), NULL },
197 { GIMP_CHANNEL_OP_REPLACE, NC_("channel-ops", "Replace the current selection"), NULL },
198 { GIMP_CHANNEL_OP_INTERSECT, NC_("channel-ops", "Intersect with the current selection"), NULL },
199 { 0, NULL, NULL }
200 };
201
202 static GType type = 0;
203
204 if (G_UNLIKELY (! type))
205 {
206 type = g_enum_register_static ("GimpChannelOps", values);
207 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
208 gimp_type_set_translation_context (type, "channel-ops");
209 gimp_enum_set_value_descriptions (type, descs);
210 }
211
212 return type;
213 }
214
215 GType
gimp_channel_type_get_type(void)216 gimp_channel_type_get_type (void)
217 {
218 static const GEnumValue values[] =
219 {
220 { GIMP_CHANNEL_RED, "GIMP_CHANNEL_RED", "red" },
221 { GIMP_CHANNEL_GREEN, "GIMP_CHANNEL_GREEN", "green" },
222 { GIMP_CHANNEL_BLUE, "GIMP_CHANNEL_BLUE", "blue" },
223 { GIMP_CHANNEL_GRAY, "GIMP_CHANNEL_GRAY", "gray" },
224 { GIMP_CHANNEL_INDEXED, "GIMP_CHANNEL_INDEXED", "indexed" },
225 { GIMP_CHANNEL_ALPHA, "GIMP_CHANNEL_ALPHA", "alpha" },
226 { 0, NULL, NULL }
227 };
228
229 static const GimpEnumDesc descs[] =
230 {
231 { GIMP_CHANNEL_RED, NC_("channel-type", "Red"), NULL },
232 { GIMP_CHANNEL_GREEN, NC_("channel-type", "Green"), NULL },
233 { GIMP_CHANNEL_BLUE, NC_("channel-type", "Blue"), NULL },
234 { GIMP_CHANNEL_GRAY, NC_("channel-type", "Gray"), NULL },
235 { GIMP_CHANNEL_INDEXED, NC_("channel-type", "Indexed"), NULL },
236 { GIMP_CHANNEL_ALPHA, NC_("channel-type", "Alpha"), NULL },
237 { 0, NULL, NULL }
238 };
239
240 static GType type = 0;
241
242 if (G_UNLIKELY (! type))
243 {
244 type = g_enum_register_static ("GimpChannelType", values);
245 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
246 gimp_type_set_translation_context (type, "channel-type");
247 gimp_enum_set_value_descriptions (type, descs);
248 }
249
250 return type;
251 }
252
253 GType
gimp_check_size_get_type(void)254 gimp_check_size_get_type (void)
255 {
256 static const GEnumValue values[] =
257 {
258 { GIMP_CHECK_SIZE_SMALL_CHECKS, "GIMP_CHECK_SIZE_SMALL_CHECKS", "small-checks" },
259 { GIMP_CHECK_SIZE_MEDIUM_CHECKS, "GIMP_CHECK_SIZE_MEDIUM_CHECKS", "medium-checks" },
260 { GIMP_CHECK_SIZE_LARGE_CHECKS, "GIMP_CHECK_SIZE_LARGE_CHECKS", "large-checks" },
261 { 0, NULL, NULL }
262 };
263
264 static const GimpEnumDesc descs[] =
265 {
266 { GIMP_CHECK_SIZE_SMALL_CHECKS, NC_("check-size", "Small"), NULL },
267 { GIMP_CHECK_SIZE_MEDIUM_CHECKS, NC_("check-size", "Medium"), NULL },
268 { GIMP_CHECK_SIZE_LARGE_CHECKS, NC_("check-size", "Large"), NULL },
269 { 0, NULL, NULL }
270 };
271
272 static GType type = 0;
273
274 if (G_UNLIKELY (! type))
275 {
276 type = g_enum_register_static ("GimpCheckSize", values);
277 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
278 gimp_type_set_translation_context (type, "check-size");
279 gimp_enum_set_value_descriptions (type, descs);
280 }
281
282 return type;
283 }
284
285 GType
gimp_check_type_get_type(void)286 gimp_check_type_get_type (void)
287 {
288 static const GEnumValue values[] =
289 {
290 { GIMP_CHECK_TYPE_LIGHT_CHECKS, "GIMP_CHECK_TYPE_LIGHT_CHECKS", "light-checks" },
291 { GIMP_CHECK_TYPE_GRAY_CHECKS, "GIMP_CHECK_TYPE_GRAY_CHECKS", "gray-checks" },
292 { GIMP_CHECK_TYPE_DARK_CHECKS, "GIMP_CHECK_TYPE_DARK_CHECKS", "dark-checks" },
293 { GIMP_CHECK_TYPE_WHITE_ONLY, "GIMP_CHECK_TYPE_WHITE_ONLY", "white-only" },
294 { GIMP_CHECK_TYPE_GRAY_ONLY, "GIMP_CHECK_TYPE_GRAY_ONLY", "gray-only" },
295 { GIMP_CHECK_TYPE_BLACK_ONLY, "GIMP_CHECK_TYPE_BLACK_ONLY", "black-only" },
296 { 0, NULL, NULL }
297 };
298
299 static const GimpEnumDesc descs[] =
300 {
301 { GIMP_CHECK_TYPE_LIGHT_CHECKS, NC_("check-type", "Light checks"), NULL },
302 { GIMP_CHECK_TYPE_GRAY_CHECKS, NC_("check-type", "Mid-tone checks"), NULL },
303 { GIMP_CHECK_TYPE_DARK_CHECKS, NC_("check-type", "Dark checks"), NULL },
304 { GIMP_CHECK_TYPE_WHITE_ONLY, NC_("check-type", "White only"), NULL },
305 { GIMP_CHECK_TYPE_GRAY_ONLY, NC_("check-type", "Gray only"), NULL },
306 { GIMP_CHECK_TYPE_BLACK_ONLY, NC_("check-type", "Black only"), NULL },
307 { 0, NULL, NULL }
308 };
309
310 static GType type = 0;
311
312 if (G_UNLIKELY (! type))
313 {
314 type = g_enum_register_static ("GimpCheckType", values);
315 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
316 gimp_type_set_translation_context (type, "check-type");
317 gimp_enum_set_value_descriptions (type, descs);
318 }
319
320 return type;
321 }
322
323 GType
gimp_clone_type_get_type(void)324 gimp_clone_type_get_type (void)
325 {
326 static const GEnumValue values[] =
327 {
328 { GIMP_CLONE_IMAGE, "GIMP_CLONE_IMAGE", "image" },
329 { GIMP_CLONE_PATTERN, "GIMP_CLONE_PATTERN", "pattern" },
330 { 0, NULL, NULL }
331 };
332
333 static const GimpEnumDesc descs[] =
334 {
335 { GIMP_CLONE_IMAGE, NC_("clone-type", "Image"), NULL },
336 { GIMP_CLONE_PATTERN, NC_("clone-type", "Pattern"), NULL },
337 { 0, NULL, NULL }
338 };
339
340 static GType type = 0;
341
342 if (G_UNLIKELY (! type))
343 {
344 type = g_enum_register_static ("GimpCloneType", values);
345 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
346 gimp_type_set_translation_context (type, "clone-type");
347 gimp_enum_set_value_descriptions (type, descs);
348 }
349
350 return type;
351 }
352
353 GType
gimp_color_tag_get_type(void)354 gimp_color_tag_get_type (void)
355 {
356 static const GEnumValue values[] =
357 {
358 { GIMP_COLOR_TAG_NONE, "GIMP_COLOR_TAG_NONE", "none" },
359 { GIMP_COLOR_TAG_BLUE, "GIMP_COLOR_TAG_BLUE", "blue" },
360 { GIMP_COLOR_TAG_GREEN, "GIMP_COLOR_TAG_GREEN", "green" },
361 { GIMP_COLOR_TAG_YELLOW, "GIMP_COLOR_TAG_YELLOW", "yellow" },
362 { GIMP_COLOR_TAG_ORANGE, "GIMP_COLOR_TAG_ORANGE", "orange" },
363 { GIMP_COLOR_TAG_BROWN, "GIMP_COLOR_TAG_BROWN", "brown" },
364 { GIMP_COLOR_TAG_RED, "GIMP_COLOR_TAG_RED", "red" },
365 { GIMP_COLOR_TAG_VIOLET, "GIMP_COLOR_TAG_VIOLET", "violet" },
366 { GIMP_COLOR_TAG_GRAY, "GIMP_COLOR_TAG_GRAY", "gray" },
367 { 0, NULL, NULL }
368 };
369
370 static const GimpEnumDesc descs[] =
371 {
372 { GIMP_COLOR_TAG_NONE, NC_("color-tag", "None"), NULL },
373 { GIMP_COLOR_TAG_BLUE, NC_("color-tag", "Blue"), NULL },
374 { GIMP_COLOR_TAG_GREEN, NC_("color-tag", "Green"), NULL },
375 { GIMP_COLOR_TAG_YELLOW, NC_("color-tag", "Yellow"), NULL },
376 { GIMP_COLOR_TAG_ORANGE, NC_("color-tag", "Orange"), NULL },
377 { GIMP_COLOR_TAG_BROWN, NC_("color-tag", "Brown"), NULL },
378 { GIMP_COLOR_TAG_RED, NC_("color-tag", "Red"), NULL },
379 { GIMP_COLOR_TAG_VIOLET, NC_("color-tag", "Violet"), NULL },
380 { GIMP_COLOR_TAG_GRAY, NC_("color-tag", "Gray"), NULL },
381 { 0, NULL, NULL }
382 };
383
384 static GType type = 0;
385
386 if (G_UNLIKELY (! type))
387 {
388 type = g_enum_register_static ("GimpColorTag", values);
389 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
390 gimp_type_set_translation_context (type, "color-tag");
391 gimp_enum_set_value_descriptions (type, descs);
392 }
393
394 return type;
395 }
396
397 GType
gimp_component_type_get_type(void)398 gimp_component_type_get_type (void)
399 {
400 static const GEnumValue values[] =
401 {
402 { GIMP_COMPONENT_TYPE_U8, "GIMP_COMPONENT_TYPE_U8", "u8" },
403 { GIMP_COMPONENT_TYPE_U16, "GIMP_COMPONENT_TYPE_U16", "u16" },
404 { GIMP_COMPONENT_TYPE_U32, "GIMP_COMPONENT_TYPE_U32", "u32" },
405 { GIMP_COMPONENT_TYPE_HALF, "GIMP_COMPONENT_TYPE_HALF", "half" },
406 { GIMP_COMPONENT_TYPE_FLOAT, "GIMP_COMPONENT_TYPE_FLOAT", "float" },
407 { GIMP_COMPONENT_TYPE_DOUBLE, "GIMP_COMPONENT_TYPE_DOUBLE", "double" },
408 { 0, NULL, NULL }
409 };
410
411 static const GimpEnumDesc descs[] =
412 {
413 { GIMP_COMPONENT_TYPE_U8, NC_("component-type", "8-bit integer"), NULL },
414 { GIMP_COMPONENT_TYPE_U16, NC_("component-type", "16-bit integer"), NULL },
415 { GIMP_COMPONENT_TYPE_U32, NC_("component-type", "32-bit integer"), NULL },
416 { GIMP_COMPONENT_TYPE_HALF, NC_("component-type", "16-bit floating point"), NULL },
417 { GIMP_COMPONENT_TYPE_FLOAT, NC_("component-type", "32-bit floating point"), NULL },
418 { GIMP_COMPONENT_TYPE_DOUBLE, NC_("component-type", "64-bit floating point"), NULL },
419 { 0, NULL, NULL }
420 };
421
422 static GType type = 0;
423
424 if (G_UNLIKELY (! type))
425 {
426 type = g_enum_register_static ("GimpComponentType", values);
427 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
428 gimp_type_set_translation_context (type, "component-type");
429 gimp_enum_set_value_descriptions (type, descs);
430 }
431
432 return type;
433 }
434
435 GType
gimp_convert_palette_type_get_type(void)436 gimp_convert_palette_type_get_type (void)
437 {
438 static const GEnumValue values[] =
439 {
440 { GIMP_CONVERT_PALETTE_GENERATE, "GIMP_CONVERT_PALETTE_GENERATE", "generate" },
441 { GIMP_CONVERT_PALETTE_WEB, "GIMP_CONVERT_PALETTE_WEB", "web" },
442 { GIMP_CONVERT_PALETTE_MONO, "GIMP_CONVERT_PALETTE_MONO", "mono" },
443 { GIMP_CONVERT_PALETTE_CUSTOM, "GIMP_CONVERT_PALETTE_CUSTOM", "custom" },
444 { 0, NULL, NULL }
445 };
446
447 static const GimpEnumDesc descs[] =
448 {
449 { GIMP_CONVERT_PALETTE_GENERATE, NC_("convert-palette-type", "Generate optimum palette"), NULL },
450 { GIMP_CONVERT_PALETTE_WEB, NC_("convert-palette-type", "Use web-optimized palette"), NULL },
451 { GIMP_CONVERT_PALETTE_MONO, NC_("convert-palette-type", "Use black and white (1-bit) palette"), NULL },
452 { GIMP_CONVERT_PALETTE_CUSTOM, NC_("convert-palette-type", "Use custom palette"), NULL },
453 { 0, NULL, NULL }
454 };
455
456 static GType type = 0;
457
458 if (G_UNLIKELY (! type))
459 {
460 type = g_enum_register_static ("GimpConvertPaletteType", values);
461 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
462 gimp_type_set_translation_context (type, "convert-palette-type");
463 gimp_enum_set_value_descriptions (type, descs);
464 }
465
466 return type;
467 }
468
469 GType
gimp_convolve_type_get_type(void)470 gimp_convolve_type_get_type (void)
471 {
472 static const GEnumValue values[] =
473 {
474 { GIMP_CONVOLVE_BLUR, "GIMP_CONVOLVE_BLUR", "blur" },
475 { GIMP_CONVOLVE_SHARPEN, "GIMP_CONVOLVE_SHARPEN", "sharpen" },
476 { 0, NULL, NULL }
477 };
478
479 static const GimpEnumDesc descs[] =
480 {
481 { GIMP_CONVOLVE_BLUR, NC_("convolve-type", "Blur"), NULL },
482 { GIMP_CONVOLVE_SHARPEN, NC_("convolve-type", "Sharpen"), NULL },
483 { 0, NULL, NULL }
484 };
485
486 static GType type = 0;
487
488 if (G_UNLIKELY (! type))
489 {
490 type = g_enum_register_static ("GimpConvolveType", values);
491 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
492 gimp_type_set_translation_context (type, "convolve-type");
493 gimp_enum_set_value_descriptions (type, descs);
494 }
495
496 return type;
497 }
498
499 GType
gimp_desaturate_mode_get_type(void)500 gimp_desaturate_mode_get_type (void)
501 {
502 static const GEnumValue values[] =
503 {
504 { GIMP_DESATURATE_LIGHTNESS, "GIMP_DESATURATE_LIGHTNESS", "lightness" },
505 { GIMP_DESATURATE_LUMA, "GIMP_DESATURATE_LUMA", "luma" },
506 { GIMP_DESATURATE_AVERAGE, "GIMP_DESATURATE_AVERAGE", "average" },
507 { GIMP_DESATURATE_LUMINANCE, "GIMP_DESATURATE_LUMINANCE", "luminance" },
508 { GIMP_DESATURATE_VALUE, "GIMP_DESATURATE_VALUE", "value" },
509 { 0, NULL, NULL }
510 };
511
512 static const GimpEnumDesc descs[] =
513 {
514 { GIMP_DESATURATE_LIGHTNESS, NC_("desaturate-mode", "Lightness (HSL)"), NULL },
515 { GIMP_DESATURATE_LUMA, NC_("desaturate-mode", "Luma"), NULL },
516 { GIMP_DESATURATE_AVERAGE, NC_("desaturate-mode", "Average (HSI Intensity)"), NULL },
517 { GIMP_DESATURATE_LUMINANCE, NC_("desaturate-mode", "Luminance"), NULL },
518 { GIMP_DESATURATE_VALUE, NC_("desaturate-mode", "Value (HSV)"), NULL },
519 { 0, NULL, NULL }
520 };
521
522 static GType type = 0;
523
524 if (G_UNLIKELY (! type))
525 {
526 type = g_enum_register_static ("GimpDesaturateMode", values);
527 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
528 gimp_type_set_translation_context (type, "desaturate-mode");
529 gimp_enum_set_value_descriptions (type, descs);
530 }
531
532 return type;
533 }
534
535 GType
gimp_dodge_burn_type_get_type(void)536 gimp_dodge_burn_type_get_type (void)
537 {
538 static const GEnumValue values[] =
539 {
540 { GIMP_DODGE_BURN_TYPE_DODGE, "GIMP_DODGE_BURN_TYPE_DODGE", "dodge" },
541 { GIMP_DODGE_BURN_TYPE_BURN, "GIMP_DODGE_BURN_TYPE_BURN", "burn" },
542 { 0, NULL, NULL }
543 };
544
545 static const GimpEnumDesc descs[] =
546 {
547 { GIMP_DODGE_BURN_TYPE_DODGE, NC_("dodge-burn-type", "Dodge"), NULL },
548 { GIMP_DODGE_BURN_TYPE_BURN, NC_("dodge-burn-type", "Burn"), NULL },
549 { 0, NULL, NULL }
550 };
551
552 static GType type = 0;
553
554 if (G_UNLIKELY (! type))
555 {
556 type = g_enum_register_static ("GimpDodgeBurnType", values);
557 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
558 gimp_type_set_translation_context (type, "dodge-burn-type");
559 gimp_enum_set_value_descriptions (type, descs);
560 }
561
562 return type;
563 }
564
565 GType
gimp_fill_type_get_type(void)566 gimp_fill_type_get_type (void)
567 {
568 static const GEnumValue values[] =
569 {
570 { GIMP_FILL_FOREGROUND, "GIMP_FILL_FOREGROUND", "foreground" },
571 { GIMP_FILL_BACKGROUND, "GIMP_FILL_BACKGROUND", "background" },
572 { GIMP_FILL_WHITE, "GIMP_FILL_WHITE", "white" },
573 { GIMP_FILL_TRANSPARENT, "GIMP_FILL_TRANSPARENT", "transparent" },
574 { GIMP_FILL_PATTERN, "GIMP_FILL_PATTERN", "pattern" },
575 { 0, NULL, NULL }
576 };
577
578 static const GimpEnumDesc descs[] =
579 {
580 { GIMP_FILL_FOREGROUND, NC_("fill-type", "Foreground color"), NULL },
581 { GIMP_FILL_BACKGROUND, NC_("fill-type", "Background color"), NULL },
582 { GIMP_FILL_WHITE, NC_("fill-type", "White"), NULL },
583 { GIMP_FILL_TRANSPARENT, NC_("fill-type", "Transparency"), NULL },
584 { GIMP_FILL_PATTERN, NC_("fill-type", "Pattern"), NULL },
585 { 0, NULL, NULL }
586 };
587
588 static GType type = 0;
589
590 if (G_UNLIKELY (! type))
591 {
592 type = g_enum_register_static ("GimpFillType", values);
593 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
594 gimp_type_set_translation_context (type, "fill-type");
595 gimp_enum_set_value_descriptions (type, descs);
596 }
597
598 return type;
599 }
600
601 GType
gimp_foreground_extract_mode_get_type(void)602 gimp_foreground_extract_mode_get_type (void)
603 {
604 static const GEnumValue values[] =
605 {
606 { GIMP_FOREGROUND_EXTRACT_SIOX, "GIMP_FOREGROUND_EXTRACT_SIOX", "siox" },
607 { GIMP_FOREGROUND_EXTRACT_MATTING, "GIMP_FOREGROUND_EXTRACT_MATTING", "matting" },
608 { 0, NULL, NULL }
609 };
610
611 static const GimpEnumDesc descs[] =
612 {
613 { GIMP_FOREGROUND_EXTRACT_SIOX, "GIMP_FOREGROUND_EXTRACT_SIOX", NULL },
614 { GIMP_FOREGROUND_EXTRACT_MATTING, "GIMP_FOREGROUND_EXTRACT_MATTING", NULL },
615 { 0, NULL, NULL }
616 };
617
618 static GType type = 0;
619
620 if (G_UNLIKELY (! type))
621 {
622 type = g_enum_register_static ("GimpForegroundExtractMode", values);
623 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
624 gimp_type_set_translation_context (type, "foreground-extract-mode");
625 gimp_enum_set_value_descriptions (type, descs);
626 }
627
628 return type;
629 }
630
631 GType
gimp_gradient_blend_color_space_get_type(void)632 gimp_gradient_blend_color_space_get_type (void)
633 {
634 static const GEnumValue values[] =
635 {
636 { GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL, "GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL", "rgb-perceptual" },
637 { GIMP_GRADIENT_BLEND_RGB_LINEAR, "GIMP_GRADIENT_BLEND_RGB_LINEAR", "rgb-linear" },
638 { GIMP_GRADIENT_BLEND_CIE_LAB, "GIMP_GRADIENT_BLEND_CIE_LAB", "cie-lab" },
639 { 0, NULL, NULL }
640 };
641
642 static const GimpEnumDesc descs[] =
643 {
644 { GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL, NC_("gradient-blend-color-space", "Perceptual RGB"), NULL },
645 { GIMP_GRADIENT_BLEND_RGB_LINEAR, NC_("gradient-blend-color-space", "Linear RGB"), NULL },
646 { GIMP_GRADIENT_BLEND_CIE_LAB, NC_("gradient-blend-color-space", "CIE Lab"), NULL },
647 { 0, NULL, NULL }
648 };
649
650 static GType type = 0;
651
652 if (G_UNLIKELY (! type))
653 {
654 type = g_enum_register_static ("GimpGradientBlendColorSpace", values);
655 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
656 gimp_type_set_translation_context (type, "gradient-blend-color-space");
657 gimp_enum_set_value_descriptions (type, descs);
658 }
659
660 return type;
661 }
662
663 GType
gimp_gradient_segment_color_get_type(void)664 gimp_gradient_segment_color_get_type (void)
665 {
666 static const GEnumValue values[] =
667 {
668 { GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", "rgb" },
669 { GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", "hsv-ccw" },
670 { GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", "hsv-cw" },
671 { 0, NULL, NULL }
672 };
673
674 static const GimpEnumDesc descs[] =
675 {
676 { GIMP_GRADIENT_SEGMENT_RGB, NC_("gradient-segment-color", "RGB"), NULL },
677 { GIMP_GRADIENT_SEGMENT_HSV_CCW, NC_("gradient-segment-color", "HSV (counter-clockwise hue)"), NULL },
678 /* Translators: this is an abbreviated version of "HSV (counter-clockwise hue)".
679 Keep it short. */
680 { GIMP_GRADIENT_SEGMENT_HSV_CCW, NC_("gradient-segment-color", "HSV (ccw)"), NULL },
681 { GIMP_GRADIENT_SEGMENT_HSV_CW, NC_("gradient-segment-color", "HSV (clockwise hue)"), NULL },
682 /* Translators: this is an abbreviated version of "HSV (clockwise hue)".
683 Keep it short. */
684 { GIMP_GRADIENT_SEGMENT_HSV_CW, NC_("gradient-segment-color", "HSV (cw)"), NULL },
685 { 0, NULL, NULL }
686 };
687
688 static GType type = 0;
689
690 if (G_UNLIKELY (! type))
691 {
692 type = g_enum_register_static ("GimpGradientSegmentColor", values);
693 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
694 gimp_type_set_translation_context (type, "gradient-segment-color");
695 gimp_enum_set_value_descriptions (type, descs);
696 }
697
698 return type;
699 }
700
701 GType
gimp_gradient_segment_type_get_type(void)702 gimp_gradient_segment_type_get_type (void)
703 {
704 static const GEnumValue values[] =
705 {
706 { GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", "linear" },
707 { GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", "curved" },
708 { GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", "sine" },
709 { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", "sphere-increasing" },
710 { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", "sphere-decreasing" },
711 { GIMP_GRADIENT_SEGMENT_STEP, "GIMP_GRADIENT_SEGMENT_STEP", "step" },
712 { 0, NULL, NULL }
713 };
714
715 static const GimpEnumDesc descs[] =
716 {
717 { GIMP_GRADIENT_SEGMENT_LINEAR, NC_("gradient-segment-type", "Linear"), NULL },
718 { GIMP_GRADIENT_SEGMENT_CURVED, NC_("gradient-segment-type", "Curved"), NULL },
719 { GIMP_GRADIENT_SEGMENT_SINE, NC_("gradient-segment-type", "Sinusoidal"), NULL },
720 { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, NC_("gradient-segment-type", "Spherical (increasing)"), NULL },
721 /* Translators: this is an abbreviated version of "Spherical (increasing)".
722 Keep it short. */
723 { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, NC_("gradient-segment-type", "Spherical (inc)"), NULL },
724 { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, NC_("gradient-segment-type", "Spherical (decreasing)"), NULL },
725 /* Translators: this is an abbreviated version of "Spherical (decreasing)".
726 Keep it short. */
727 { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, NC_("gradient-segment-type", "Spherical (dec)"), NULL },
728 { GIMP_GRADIENT_SEGMENT_STEP, NC_("gradient-segment-type", "Step"), NULL },
729 { 0, NULL, NULL }
730 };
731
732 static GType type = 0;
733
734 if (G_UNLIKELY (! type))
735 {
736 type = g_enum_register_static ("GimpGradientSegmentType", values);
737 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
738 gimp_type_set_translation_context (type, "gradient-segment-type");
739 gimp_enum_set_value_descriptions (type, descs);
740 }
741
742 return type;
743 }
744
745 GType
gimp_gradient_type_get_type(void)746 gimp_gradient_type_get_type (void)
747 {
748 static const GEnumValue values[] =
749 {
750 { GIMP_GRADIENT_LINEAR, "GIMP_GRADIENT_LINEAR", "linear" },
751 { GIMP_GRADIENT_BILINEAR, "GIMP_GRADIENT_BILINEAR", "bilinear" },
752 { GIMP_GRADIENT_RADIAL, "GIMP_GRADIENT_RADIAL", "radial" },
753 { GIMP_GRADIENT_SQUARE, "GIMP_GRADIENT_SQUARE", "square" },
754 { GIMP_GRADIENT_CONICAL_SYMMETRIC, "GIMP_GRADIENT_CONICAL_SYMMETRIC", "conical-symmetric" },
755 { GIMP_GRADIENT_CONICAL_ASYMMETRIC, "GIMP_GRADIENT_CONICAL_ASYMMETRIC", "conical-asymmetric" },
756 { GIMP_GRADIENT_SHAPEBURST_ANGULAR, "GIMP_GRADIENT_SHAPEBURST_ANGULAR", "shapeburst-angular" },
757 { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, "GIMP_GRADIENT_SHAPEBURST_SPHERICAL", "shapeburst-spherical" },
758 { GIMP_GRADIENT_SHAPEBURST_DIMPLED, "GIMP_GRADIENT_SHAPEBURST_DIMPLED", "shapeburst-dimpled" },
759 { GIMP_GRADIENT_SPIRAL_CLOCKWISE, "GIMP_GRADIENT_SPIRAL_CLOCKWISE", "spiral-clockwise" },
760 { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, "GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE", "spiral-anticlockwise" },
761 { 0, NULL, NULL }
762 };
763
764 static const GimpEnumDesc descs[] =
765 {
766 { GIMP_GRADIENT_LINEAR, NC_("gradient-type", "Linear"), NULL },
767 { GIMP_GRADIENT_BILINEAR, NC_("gradient-type", "Bi-linear"), NULL },
768 { GIMP_GRADIENT_RADIAL, NC_("gradient-type", "Radial"), NULL },
769 { GIMP_GRADIENT_SQUARE, NC_("gradient-type", "Square"), NULL },
770 { GIMP_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (symmetric)"), NULL },
771 /* Translators: this is an abbreviated version of "Conical (symmetric)".
772 Keep it short. */
773 { GIMP_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (sym)"), NULL },
774 { GIMP_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asymmetric)"), NULL },
775 /* Translators: this is an abbreviated version of "Conical (asymmetric)".
776 Keep it short. */
777 { GIMP_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asym)"), NULL },
778 { GIMP_GRADIENT_SHAPEBURST_ANGULAR, NC_("gradient-type", "Shaped (angular)"), NULL },
779 { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, NC_("gradient-type", "Shaped (spherical)"), NULL },
780 { GIMP_GRADIENT_SHAPEBURST_DIMPLED, NC_("gradient-type", "Shaped (dimpled)"), NULL },
781 { GIMP_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (clockwise)"), NULL },
782 /* Translators: this is an abbreviated version of "Spiral (clockwise)".
783 Keep it short. */
784 { GIMP_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (cw)"), NULL },
785 { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (counter-clockwise)"), NULL },
786 /* Translators: this is an abbreviated version of "Spiral (counter-clockwise)".
787 Keep it short. */
788 { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (ccw)"), NULL },
789 { 0, NULL, NULL }
790 };
791
792 static GType type = 0;
793
794 if (G_UNLIKELY (! type))
795 {
796 type = g_enum_register_static ("GimpGradientType", values);
797 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
798 gimp_type_set_translation_context (type, "gradient-type");
799 gimp_enum_set_value_descriptions (type, descs);
800 }
801
802 return type;
803 }
804
805 GType
gimp_grid_style_get_type(void)806 gimp_grid_style_get_type (void)
807 {
808 static const GEnumValue values[] =
809 {
810 { GIMP_GRID_DOTS, "GIMP_GRID_DOTS", "dots" },
811 { GIMP_GRID_INTERSECTIONS, "GIMP_GRID_INTERSECTIONS", "intersections" },
812 { GIMP_GRID_ON_OFF_DASH, "GIMP_GRID_ON_OFF_DASH", "on-off-dash" },
813 { GIMP_GRID_DOUBLE_DASH, "GIMP_GRID_DOUBLE_DASH", "double-dash" },
814 { GIMP_GRID_SOLID, "GIMP_GRID_SOLID", "solid" },
815 { 0, NULL, NULL }
816 };
817
818 static const GimpEnumDesc descs[] =
819 {
820 { GIMP_GRID_DOTS, NC_("grid-style", "Intersections (dots)"), NULL },
821 { GIMP_GRID_INTERSECTIONS, NC_("grid-style", "Intersections (crosshairs)"), NULL },
822 { GIMP_GRID_ON_OFF_DASH, NC_("grid-style", "Dashed"), NULL },
823 { GIMP_GRID_DOUBLE_DASH, NC_("grid-style", "Double dashed"), NULL },
824 { GIMP_GRID_SOLID, NC_("grid-style", "Solid"), NULL },
825 { 0, NULL, NULL }
826 };
827
828 static GType type = 0;
829
830 if (G_UNLIKELY (! type))
831 {
832 type = g_enum_register_static ("GimpGridStyle", values);
833 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
834 gimp_type_set_translation_context (type, "grid-style");
835 gimp_enum_set_value_descriptions (type, descs);
836 }
837
838 return type;
839 }
840
841 GType
gimp_hue_range_get_type(void)842 gimp_hue_range_get_type (void)
843 {
844 static const GEnumValue values[] =
845 {
846 { GIMP_HUE_RANGE_ALL, "GIMP_HUE_RANGE_ALL", "all" },
847 { GIMP_HUE_RANGE_RED, "GIMP_HUE_RANGE_RED", "red" },
848 { GIMP_HUE_RANGE_YELLOW, "GIMP_HUE_RANGE_YELLOW", "yellow" },
849 { GIMP_HUE_RANGE_GREEN, "GIMP_HUE_RANGE_GREEN", "green" },
850 { GIMP_HUE_RANGE_CYAN, "GIMP_HUE_RANGE_CYAN", "cyan" },
851 { GIMP_HUE_RANGE_BLUE, "GIMP_HUE_RANGE_BLUE", "blue" },
852 { GIMP_HUE_RANGE_MAGENTA, "GIMP_HUE_RANGE_MAGENTA", "magenta" },
853 { 0, NULL, NULL }
854 };
855
856 static const GimpEnumDesc descs[] =
857 {
858 { GIMP_HUE_RANGE_ALL, "GIMP_HUE_RANGE_ALL", NULL },
859 { GIMP_HUE_RANGE_RED, "GIMP_HUE_RANGE_RED", NULL },
860 { GIMP_HUE_RANGE_YELLOW, "GIMP_HUE_RANGE_YELLOW", NULL },
861 { GIMP_HUE_RANGE_GREEN, "GIMP_HUE_RANGE_GREEN", NULL },
862 { GIMP_HUE_RANGE_CYAN, "GIMP_HUE_RANGE_CYAN", NULL },
863 { GIMP_HUE_RANGE_BLUE, "GIMP_HUE_RANGE_BLUE", NULL },
864 { GIMP_HUE_RANGE_MAGENTA, "GIMP_HUE_RANGE_MAGENTA", NULL },
865 { 0, NULL, NULL }
866 };
867
868 static GType type = 0;
869
870 if (G_UNLIKELY (! type))
871 {
872 type = g_enum_register_static ("GimpHueRange", values);
873 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
874 gimp_type_set_translation_context (type, "hue-range");
875 gimp_enum_set_value_descriptions (type, descs);
876 }
877
878 return type;
879 }
880
881 GType
gimp_icon_type_get_type(void)882 gimp_icon_type_get_type (void)
883 {
884 static const GEnumValue values[] =
885 {
886 { GIMP_ICON_TYPE_ICON_NAME, "GIMP_ICON_TYPE_ICON_NAME", "icon-name" },
887 { GIMP_ICON_TYPE_INLINE_PIXBUF, "GIMP_ICON_TYPE_INLINE_PIXBUF", "inline-pixbuf" },
888 { GIMP_ICON_TYPE_IMAGE_FILE, "GIMP_ICON_TYPE_IMAGE_FILE", "image-file" },
889 { 0, NULL, NULL }
890 };
891
892 static const GimpEnumDesc descs[] =
893 {
894 { GIMP_ICON_TYPE_ICON_NAME, NC_("icon-type", "Icon name"), NULL },
895 { GIMP_ICON_TYPE_INLINE_PIXBUF, NC_("icon-type", "Inline pixbuf"), NULL },
896 { GIMP_ICON_TYPE_IMAGE_FILE, NC_("icon-type", "Image file"), NULL },
897 { 0, NULL, NULL }
898 };
899
900 static GType type = 0;
901
902 if (G_UNLIKELY (! type))
903 {
904 type = g_enum_register_static ("GimpIconType", values);
905 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
906 gimp_type_set_translation_context (type, "icon-type");
907 gimp_enum_set_value_descriptions (type, descs);
908 }
909
910 return type;
911 }
912
913 GType
gimp_image_base_type_get_type(void)914 gimp_image_base_type_get_type (void)
915 {
916 static const GEnumValue values[] =
917 {
918 { GIMP_RGB, "GIMP_RGB", "rgb" },
919 { GIMP_GRAY, "GIMP_GRAY", "gray" },
920 { GIMP_INDEXED, "GIMP_INDEXED", "indexed" },
921 { 0, NULL, NULL }
922 };
923
924 static const GimpEnumDesc descs[] =
925 {
926 { GIMP_RGB, NC_("image-base-type", "RGB color"), NULL },
927 { GIMP_GRAY, NC_("image-base-type", "Grayscale"), NULL },
928 { GIMP_INDEXED, NC_("image-base-type", "Indexed color"), NULL },
929 { 0, NULL, NULL }
930 };
931
932 static GType type = 0;
933
934 if (G_UNLIKELY (! type))
935 {
936 type = g_enum_register_static ("GimpImageBaseType", values);
937 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
938 gimp_type_set_translation_context (type, "image-base-type");
939 gimp_enum_set_value_descriptions (type, descs);
940 }
941
942 return type;
943 }
944
945 GType
gimp_image_type_get_type(void)946 gimp_image_type_get_type (void)
947 {
948 static const GEnumValue values[] =
949 {
950 { GIMP_RGB_IMAGE, "GIMP_RGB_IMAGE", "rgb-image" },
951 { GIMP_RGBA_IMAGE, "GIMP_RGBA_IMAGE", "rgba-image" },
952 { GIMP_GRAY_IMAGE, "GIMP_GRAY_IMAGE", "gray-image" },
953 { GIMP_GRAYA_IMAGE, "GIMP_GRAYA_IMAGE", "graya-image" },
954 { GIMP_INDEXED_IMAGE, "GIMP_INDEXED_IMAGE", "indexed-image" },
955 { GIMP_INDEXEDA_IMAGE, "GIMP_INDEXEDA_IMAGE", "indexeda-image" },
956 { 0, NULL, NULL }
957 };
958
959 static const GimpEnumDesc descs[] =
960 {
961 { GIMP_RGB_IMAGE, NC_("image-type", "RGB"), NULL },
962 { GIMP_RGBA_IMAGE, NC_("image-type", "RGB-alpha"), NULL },
963 { GIMP_GRAY_IMAGE, NC_("image-type", "Grayscale"), NULL },
964 { GIMP_GRAYA_IMAGE, NC_("image-type", "Grayscale-alpha"), NULL },
965 { GIMP_INDEXED_IMAGE, NC_("image-type", "Indexed"), NULL },
966 { GIMP_INDEXEDA_IMAGE, NC_("image-type", "Indexed-alpha"), NULL },
967 { 0, NULL, NULL }
968 };
969
970 static GType type = 0;
971
972 if (G_UNLIKELY (! type))
973 {
974 type = g_enum_register_static ("GimpImageType", values);
975 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
976 gimp_type_set_translation_context (type, "image-type");
977 gimp_enum_set_value_descriptions (type, descs);
978 }
979
980 return type;
981 }
982
983 GType
gimp_ink_blob_type_get_type(void)984 gimp_ink_blob_type_get_type (void)
985 {
986 static const GEnumValue values[] =
987 {
988 { GIMP_INK_BLOB_TYPE_CIRCLE, "GIMP_INK_BLOB_TYPE_CIRCLE", "circle" },
989 { GIMP_INK_BLOB_TYPE_SQUARE, "GIMP_INK_BLOB_TYPE_SQUARE", "square" },
990 { GIMP_INK_BLOB_TYPE_DIAMOND, "GIMP_INK_BLOB_TYPE_DIAMOND", "diamond" },
991 { 0, NULL, NULL }
992 };
993
994 static const GimpEnumDesc descs[] =
995 {
996 { GIMP_INK_BLOB_TYPE_CIRCLE, NC_("ink-blob-type", "Circle"), NULL },
997 { GIMP_INK_BLOB_TYPE_SQUARE, NC_("ink-blob-type", "Square"), NULL },
998 { GIMP_INK_BLOB_TYPE_DIAMOND, NC_("ink-blob-type", "Diamond"), NULL },
999 { 0, NULL, NULL }
1000 };
1001
1002 static GType type = 0;
1003
1004 if (G_UNLIKELY (! type))
1005 {
1006 type = g_enum_register_static ("GimpInkBlobType", values);
1007 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1008 gimp_type_set_translation_context (type, "ink-blob-type");
1009 gimp_enum_set_value_descriptions (type, descs);
1010 }
1011
1012 return type;
1013 }
1014
1015 GType
gimp_interpolation_type_get_type(void)1016 gimp_interpolation_type_get_type (void)
1017 {
1018 static const GEnumValue values[] =
1019 {
1020 { GIMP_INTERPOLATION_NONE, "GIMP_INTERPOLATION_NONE", "none" },
1021 { GIMP_INTERPOLATION_LINEAR, "GIMP_INTERPOLATION_LINEAR", "linear" },
1022 { GIMP_INTERPOLATION_CUBIC, "GIMP_INTERPOLATION_CUBIC", "cubic" },
1023 { GIMP_INTERPOLATION_NOHALO, "GIMP_INTERPOLATION_NOHALO", "nohalo" },
1024 { GIMP_INTERPOLATION_LOHALO, "GIMP_INTERPOLATION_LOHALO", "lohalo" },
1025 { 0, NULL, NULL }
1026 };
1027
1028 static const GimpEnumDesc descs[] =
1029 {
1030 { GIMP_INTERPOLATION_NONE, NC_("interpolation-type", "None"), NULL },
1031 { GIMP_INTERPOLATION_LINEAR, NC_("interpolation-type", "Linear"), NULL },
1032 { GIMP_INTERPOLATION_CUBIC, NC_("interpolation-type", "Cubic"), NULL },
1033 { GIMP_INTERPOLATION_NOHALO, NC_("interpolation-type", "NoHalo"), NULL },
1034 { GIMP_INTERPOLATION_LOHALO, NC_("interpolation-type", "LoHalo"), NULL },
1035 { 0, NULL, NULL }
1036 };
1037
1038 static GType type = 0;
1039
1040 if (G_UNLIKELY (! type))
1041 {
1042 type = g_enum_register_static ("GimpInterpolationType", values);
1043 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1044 gimp_type_set_translation_context (type, "interpolation-type");
1045 gimp_enum_set_value_descriptions (type, descs);
1046 }
1047
1048 return type;
1049 }
1050
1051 GType
gimp_join_style_get_type(void)1052 gimp_join_style_get_type (void)
1053 {
1054 static const GEnumValue values[] =
1055 {
1056 { GIMP_JOIN_MITER, "GIMP_JOIN_MITER", "miter" },
1057 { GIMP_JOIN_ROUND, "GIMP_JOIN_ROUND", "round" },
1058 { GIMP_JOIN_BEVEL, "GIMP_JOIN_BEVEL", "bevel" },
1059 { 0, NULL, NULL }
1060 };
1061
1062 static const GimpEnumDesc descs[] =
1063 {
1064 { GIMP_JOIN_MITER, NC_("join-style", "Miter"), NULL },
1065 { GIMP_JOIN_ROUND, NC_("join-style", "Round"), NULL },
1066 { GIMP_JOIN_BEVEL, NC_("join-style", "Bevel"), NULL },
1067 { 0, NULL, NULL }
1068 };
1069
1070 static GType type = 0;
1071
1072 if (G_UNLIKELY (! type))
1073 {
1074 type = g_enum_register_static ("GimpJoinStyle", values);
1075 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1076 gimp_type_set_translation_context (type, "join-style");
1077 gimp_enum_set_value_descriptions (type, descs);
1078 }
1079
1080 return type;
1081 }
1082
1083 GType
gimp_mask_apply_mode_get_type(void)1084 gimp_mask_apply_mode_get_type (void)
1085 {
1086 static const GEnumValue values[] =
1087 {
1088 { GIMP_MASK_APPLY, "GIMP_MASK_APPLY", "apply" },
1089 { GIMP_MASK_DISCARD, "GIMP_MASK_DISCARD", "discard" },
1090 { 0, NULL, NULL }
1091 };
1092
1093 static const GimpEnumDesc descs[] =
1094 {
1095 { GIMP_MASK_APPLY, "GIMP_MASK_APPLY", NULL },
1096 { GIMP_MASK_DISCARD, "GIMP_MASK_DISCARD", NULL },
1097 { 0, NULL, NULL }
1098 };
1099
1100 static GType type = 0;
1101
1102 if (G_UNLIKELY (! type))
1103 {
1104 type = g_enum_register_static ("GimpMaskApplyMode", values);
1105 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1106 gimp_type_set_translation_context (type, "mask-apply-mode");
1107 gimp_enum_set_value_descriptions (type, descs);
1108 }
1109
1110 return type;
1111 }
1112
1113 GType
gimp_merge_type_get_type(void)1114 gimp_merge_type_get_type (void)
1115 {
1116 static const GEnumValue values[] =
1117 {
1118 { GIMP_EXPAND_AS_NECESSARY, "GIMP_EXPAND_AS_NECESSARY", "expand-as-necessary" },
1119 { GIMP_CLIP_TO_IMAGE, "GIMP_CLIP_TO_IMAGE", "clip-to-image" },
1120 { GIMP_CLIP_TO_BOTTOM_LAYER, "GIMP_CLIP_TO_BOTTOM_LAYER", "clip-to-bottom-layer" },
1121 { GIMP_FLATTEN_IMAGE, "GIMP_FLATTEN_IMAGE", "flatten-image" },
1122 { 0, NULL, NULL }
1123 };
1124
1125 static const GimpEnumDesc descs[] =
1126 {
1127 { GIMP_EXPAND_AS_NECESSARY, NC_("merge-type", "Expanded as necessary"), NULL },
1128 { GIMP_CLIP_TO_IMAGE, NC_("merge-type", "Clipped to image"), NULL },
1129 { GIMP_CLIP_TO_BOTTOM_LAYER, NC_("merge-type", "Clipped to bottom layer"), NULL },
1130 { GIMP_FLATTEN_IMAGE, NC_("merge-type", "Flatten"), NULL },
1131 { 0, NULL, NULL }
1132 };
1133
1134 static GType type = 0;
1135
1136 if (G_UNLIKELY (! type))
1137 {
1138 type = g_enum_register_static ("GimpMergeType", values);
1139 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1140 gimp_type_set_translation_context (type, "merge-type");
1141 gimp_enum_set_value_descriptions (type, descs);
1142 }
1143
1144 return type;
1145 }
1146
1147 GType
gimp_message_handler_type_get_type(void)1148 gimp_message_handler_type_get_type (void)
1149 {
1150 static const GEnumValue values[] =
1151 {
1152 { GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", "message-box" },
1153 { GIMP_CONSOLE, "GIMP_CONSOLE", "console" },
1154 { GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", "error-console" },
1155 { 0, NULL, NULL }
1156 };
1157
1158 static const GimpEnumDesc descs[] =
1159 {
1160 { GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", NULL },
1161 { GIMP_CONSOLE, "GIMP_CONSOLE", NULL },
1162 { GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", NULL },
1163 { 0, NULL, NULL }
1164 };
1165
1166 static GType type = 0;
1167
1168 if (G_UNLIKELY (! type))
1169 {
1170 type = g_enum_register_static ("GimpMessageHandlerType", values);
1171 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1172 gimp_type_set_translation_context (type, "message-handler-type");
1173 gimp_enum_set_value_descriptions (type, descs);
1174 }
1175
1176 return type;
1177 }
1178
1179 GType
gimp_offset_type_get_type(void)1180 gimp_offset_type_get_type (void)
1181 {
1182 static const GEnumValue values[] =
1183 {
1184 { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", "background" },
1185 { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", "transparent" },
1186 { GIMP_OFFSET_WRAP_AROUND, "GIMP_OFFSET_WRAP_AROUND", "wrap-around" },
1187 { 0, NULL, NULL }
1188 };
1189
1190 static const GimpEnumDesc descs[] =
1191 {
1192 { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", NULL },
1193 { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", NULL },
1194 { GIMP_OFFSET_WRAP_AROUND, "GIMP_OFFSET_WRAP_AROUND", NULL },
1195 { 0, NULL, NULL }
1196 };
1197
1198 static GType type = 0;
1199
1200 if (G_UNLIKELY (! type))
1201 {
1202 type = g_enum_register_static ("GimpOffsetType", values);
1203 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1204 gimp_type_set_translation_context (type, "offset-type");
1205 gimp_enum_set_value_descriptions (type, descs);
1206 }
1207
1208 return type;
1209 }
1210
1211 GType
gimp_orientation_type_get_type(void)1212 gimp_orientation_type_get_type (void)
1213 {
1214 static const GEnumValue values[] =
1215 {
1216 { GIMP_ORIENTATION_HORIZONTAL, "GIMP_ORIENTATION_HORIZONTAL", "horizontal" },
1217 { GIMP_ORIENTATION_VERTICAL, "GIMP_ORIENTATION_VERTICAL", "vertical" },
1218 { GIMP_ORIENTATION_UNKNOWN, "GIMP_ORIENTATION_UNKNOWN", "unknown" },
1219 { 0, NULL, NULL }
1220 };
1221
1222 static const GimpEnumDesc descs[] =
1223 {
1224 { GIMP_ORIENTATION_HORIZONTAL, NC_("orientation-type", "Horizontal"), NULL },
1225 { GIMP_ORIENTATION_VERTICAL, NC_("orientation-type", "Vertical"), NULL },
1226 { GIMP_ORIENTATION_UNKNOWN, NC_("orientation-type", "Unknown"), NULL },
1227 { 0, NULL, NULL }
1228 };
1229
1230 static GType type = 0;
1231
1232 if (G_UNLIKELY (! type))
1233 {
1234 type = g_enum_register_static ("GimpOrientationType", values);
1235 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1236 gimp_type_set_translation_context (type, "orientation-type");
1237 gimp_enum_set_value_descriptions (type, descs);
1238 }
1239
1240 return type;
1241 }
1242
1243 GType
gimp_paint_application_mode_get_type(void)1244 gimp_paint_application_mode_get_type (void)
1245 {
1246 static const GEnumValue values[] =
1247 {
1248 { GIMP_PAINT_CONSTANT, "GIMP_PAINT_CONSTANT", "constant" },
1249 { GIMP_PAINT_INCREMENTAL, "GIMP_PAINT_INCREMENTAL", "incremental" },
1250 { 0, NULL, NULL }
1251 };
1252
1253 static const GimpEnumDesc descs[] =
1254 {
1255 { GIMP_PAINT_CONSTANT, NC_("paint-application-mode", "Constant"), NULL },
1256 { GIMP_PAINT_INCREMENTAL, NC_("paint-application-mode", "Incremental"), NULL },
1257 { 0, NULL, NULL }
1258 };
1259
1260 static GType type = 0;
1261
1262 if (G_UNLIKELY (! type))
1263 {
1264 type = g_enum_register_static ("GimpPaintApplicationMode", values);
1265 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1266 gimp_type_set_translation_context (type, "paint-application-mode");
1267 gimp_enum_set_value_descriptions (type, descs);
1268 }
1269
1270 return type;
1271 }
1272
1273 GType
gimp_pdb_arg_type_get_type(void)1274 gimp_pdb_arg_type_get_type (void)
1275 {
1276 static const GEnumValue values[] =
1277 {
1278 { GIMP_PDB_INT32, "GIMP_PDB_INT32", "int32" },
1279 { GIMP_PDB_INT16, "GIMP_PDB_INT16", "int16" },
1280 { GIMP_PDB_INT8, "GIMP_PDB_INT8", "int8" },
1281 { GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", "float" },
1282 { GIMP_PDB_STRING, "GIMP_PDB_STRING", "string" },
1283 { GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", "int32array" },
1284 { GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", "int16array" },
1285 { GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", "int8array" },
1286 { GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", "floatarray" },
1287 { GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", "stringarray" },
1288 { GIMP_PDB_COLOR, "GIMP_PDB_COLOR", "color" },
1289 { GIMP_PDB_ITEM, "GIMP_PDB_ITEM", "item" },
1290 { GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", "display" },
1291 { GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", "image" },
1292 { GIMP_PDB_LAYER, "GIMP_PDB_LAYER", "layer" },
1293 { GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", "channel" },
1294 { GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", "drawable" },
1295 { GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", "selection" },
1296 { GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", "colorarray" },
1297 { GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", "vectors" },
1298 { GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", "parasite" },
1299 { GIMP_PDB_STATUS, "GIMP_PDB_STATUS", "status" },
1300 { GIMP_PDB_END, "GIMP_PDB_END", "end" },
1301 { 0, NULL, NULL }
1302 };
1303
1304 static const GimpEnumDesc descs[] =
1305 {
1306 { GIMP_PDB_INT32, "GIMP_PDB_INT32", NULL },
1307 { GIMP_PDB_INT16, "GIMP_PDB_INT16", NULL },
1308 { GIMP_PDB_INT8, "GIMP_PDB_INT8", NULL },
1309 { GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", NULL },
1310 { GIMP_PDB_STRING, "GIMP_PDB_STRING", NULL },
1311 { GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", NULL },
1312 { GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", NULL },
1313 { GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", NULL },
1314 { GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", NULL },
1315 { GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", NULL },
1316 { GIMP_PDB_COLOR, "GIMP_PDB_COLOR", NULL },
1317 { GIMP_PDB_ITEM, "GIMP_PDB_ITEM", NULL },
1318 { GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", NULL },
1319 { GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", NULL },
1320 { GIMP_PDB_LAYER, "GIMP_PDB_LAYER", NULL },
1321 { GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", NULL },
1322 { GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", NULL },
1323 { GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", NULL },
1324 { GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", NULL },
1325 { GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", NULL },
1326 { GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", NULL },
1327 { GIMP_PDB_STATUS, "GIMP_PDB_STATUS", NULL },
1328 { GIMP_PDB_END, "GIMP_PDB_END", NULL },
1329 { 0, NULL, NULL }
1330 };
1331
1332 static GType type = 0;
1333
1334 if (G_UNLIKELY (! type))
1335 {
1336 type = g_enum_register_static ("GimpPDBArgType", values);
1337 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1338 gimp_type_set_translation_context (type, "pdb-arg-type");
1339 gimp_enum_set_value_descriptions (type, descs);
1340 }
1341
1342 return type;
1343 }
1344
1345 GType
gimp_pdb_error_handler_get_type(void)1346 gimp_pdb_error_handler_get_type (void)
1347 {
1348 static const GEnumValue values[] =
1349 {
1350 { GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", "internal" },
1351 { GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", "plugin" },
1352 { 0, NULL, NULL }
1353 };
1354
1355 static const GimpEnumDesc descs[] =
1356 {
1357 { GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", NULL },
1358 { GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", NULL },
1359 { 0, NULL, NULL }
1360 };
1361
1362 static GType type = 0;
1363
1364 if (G_UNLIKELY (! type))
1365 {
1366 type = g_enum_register_static ("GimpPDBErrorHandler", values);
1367 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1368 gimp_type_set_translation_context (type, "pdb-error-handler");
1369 gimp_enum_set_value_descriptions (type, descs);
1370 }
1371
1372 return type;
1373 }
1374
1375 GType
gimp_pdb_proc_type_get_type(void)1376 gimp_pdb_proc_type_get_type (void)
1377 {
1378 static const GEnumValue values[] =
1379 {
1380 { GIMP_INTERNAL, "GIMP_INTERNAL", "internal" },
1381 { GIMP_PLUGIN, "GIMP_PLUGIN", "plugin" },
1382 { GIMP_EXTENSION, "GIMP_EXTENSION", "extension" },
1383 { GIMP_TEMPORARY, "GIMP_TEMPORARY", "temporary" },
1384 { 0, NULL, NULL }
1385 };
1386
1387 static const GimpEnumDesc descs[] =
1388 {
1389 { GIMP_INTERNAL, NC_("pdb-proc-type", "Internal GIMP procedure"), NULL },
1390 { GIMP_PLUGIN, NC_("pdb-proc-type", "GIMP Plug-In"), NULL },
1391 { GIMP_EXTENSION, NC_("pdb-proc-type", "GIMP Extension"), NULL },
1392 { GIMP_TEMPORARY, NC_("pdb-proc-type", "Temporary Procedure"), NULL },
1393 { 0, NULL, NULL }
1394 };
1395
1396 static GType type = 0;
1397
1398 if (G_UNLIKELY (! type))
1399 {
1400 type = g_enum_register_static ("GimpPDBProcType", values);
1401 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1402 gimp_type_set_translation_context (type, "pdb-proc-type");
1403 gimp_enum_set_value_descriptions (type, descs);
1404 }
1405
1406 return type;
1407 }
1408
1409 GType
gimp_pdb_status_type_get_type(void)1410 gimp_pdb_status_type_get_type (void)
1411 {
1412 static const GEnumValue values[] =
1413 {
1414 { GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", "execution-error" },
1415 { GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", "calling-error" },
1416 { GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", "pass-through" },
1417 { GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", "success" },
1418 { GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", "cancel" },
1419 { 0, NULL, NULL }
1420 };
1421
1422 static const GimpEnumDesc descs[] =
1423 {
1424 { GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", NULL },
1425 { GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", NULL },
1426 { GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", NULL },
1427 { GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", NULL },
1428 { GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", NULL },
1429 { 0, NULL, NULL }
1430 };
1431
1432 static GType type = 0;
1433
1434 if (G_UNLIKELY (! type))
1435 {
1436 type = g_enum_register_static ("GimpPDBStatusType", values);
1437 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1438 gimp_type_set_translation_context (type, "pdb-status-type");
1439 gimp_enum_set_value_descriptions (type, descs);
1440 }
1441
1442 return type;
1443 }
1444
1445 GType
gimp_precision_get_type(void)1446 gimp_precision_get_type (void)
1447 {
1448 static const GEnumValue values[] =
1449 {
1450 { GIMP_PRECISION_U8_LINEAR, "GIMP_PRECISION_U8_LINEAR", "u8-linear" },
1451 { GIMP_PRECISION_U8_GAMMA, "GIMP_PRECISION_U8_GAMMA", "u8-gamma" },
1452 { GIMP_PRECISION_U16_LINEAR, "GIMP_PRECISION_U16_LINEAR", "u16-linear" },
1453 { GIMP_PRECISION_U16_GAMMA, "GIMP_PRECISION_U16_GAMMA", "u16-gamma" },
1454 { GIMP_PRECISION_U32_LINEAR, "GIMP_PRECISION_U32_LINEAR", "u32-linear" },
1455 { GIMP_PRECISION_U32_GAMMA, "GIMP_PRECISION_U32_GAMMA", "u32-gamma" },
1456 { GIMP_PRECISION_HALF_LINEAR, "GIMP_PRECISION_HALF_LINEAR", "half-linear" },
1457 { GIMP_PRECISION_HALF_GAMMA, "GIMP_PRECISION_HALF_GAMMA", "half-gamma" },
1458 { GIMP_PRECISION_FLOAT_LINEAR, "GIMP_PRECISION_FLOAT_LINEAR", "float-linear" },
1459 { GIMP_PRECISION_FLOAT_GAMMA, "GIMP_PRECISION_FLOAT_GAMMA", "float-gamma" },
1460 { GIMP_PRECISION_DOUBLE_LINEAR, "GIMP_PRECISION_DOUBLE_LINEAR", "double-linear" },
1461 { GIMP_PRECISION_DOUBLE_GAMMA, "GIMP_PRECISION_DOUBLE_GAMMA", "double-gamma" },
1462 { 0, NULL, NULL }
1463 };
1464
1465 static const GimpEnumDesc descs[] =
1466 {
1467 { GIMP_PRECISION_U8_LINEAR, NC_("precision", "8-bit linear integer"), NULL },
1468 { GIMP_PRECISION_U8_GAMMA, NC_("precision", "8-bit gamma integer"), NULL },
1469 { GIMP_PRECISION_U16_LINEAR, NC_("precision", "16-bit linear integer"), NULL },
1470 { GIMP_PRECISION_U16_GAMMA, NC_("precision", "16-bit gamma integer"), NULL },
1471 { GIMP_PRECISION_U32_LINEAR, NC_("precision", "32-bit linear integer"), NULL },
1472 { GIMP_PRECISION_U32_GAMMA, NC_("precision", "32-bit gamma integer"), NULL },
1473 { GIMP_PRECISION_HALF_LINEAR, NC_("precision", "16-bit linear floating point"), NULL },
1474 { GIMP_PRECISION_HALF_GAMMA, NC_("precision", "16-bit gamma floating point"), NULL },
1475 { GIMP_PRECISION_FLOAT_LINEAR, NC_("precision", "32-bit linear floating point"), NULL },
1476 { GIMP_PRECISION_FLOAT_GAMMA, NC_("precision", "32-bit gamma floating point"), NULL },
1477 { GIMP_PRECISION_DOUBLE_LINEAR, NC_("precision", "64-bit linear floating point"), NULL },
1478 { GIMP_PRECISION_DOUBLE_GAMMA, NC_("precision", "64-bit gamma floating point"), NULL },
1479 { 0, NULL, NULL }
1480 };
1481
1482 static GType type = 0;
1483
1484 if (G_UNLIKELY (! type))
1485 {
1486 type = g_enum_register_static ("GimpPrecision", values);
1487 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1488 gimp_type_set_translation_context (type, "precision");
1489 gimp_enum_set_value_descriptions (type, descs);
1490 }
1491
1492 return type;
1493 }
1494
1495 GType
gimp_progress_command_get_type(void)1496 gimp_progress_command_get_type (void)
1497 {
1498 static const GEnumValue values[] =
1499 {
1500 { GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", "start" },
1501 { GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", "end" },
1502 { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", "set-text" },
1503 { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", "set-value" },
1504 { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", "pulse" },
1505 { GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", "get-window" },
1506 { 0, NULL, NULL }
1507 };
1508
1509 static const GimpEnumDesc descs[] =
1510 {
1511 { GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", NULL },
1512 { GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", NULL },
1513 { GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", NULL },
1514 { GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", NULL },
1515 { GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", NULL },
1516 { GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", NULL },
1517 { 0, NULL, NULL }
1518 };
1519
1520 static GType type = 0;
1521
1522 if (G_UNLIKELY (! type))
1523 {
1524 type = g_enum_register_static ("GimpProgressCommand", values);
1525 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1526 gimp_type_set_translation_context (type, "progress-command");
1527 gimp_enum_set_value_descriptions (type, descs);
1528 }
1529
1530 return type;
1531 }
1532
1533 GType
gimp_repeat_mode_get_type(void)1534 gimp_repeat_mode_get_type (void)
1535 {
1536 static const GEnumValue values[] =
1537 {
1538 { GIMP_REPEAT_NONE, "GIMP_REPEAT_NONE", "none" },
1539 { GIMP_REPEAT_SAWTOOTH, "GIMP_REPEAT_SAWTOOTH", "sawtooth" },
1540 { GIMP_REPEAT_TRIANGULAR, "GIMP_REPEAT_TRIANGULAR", "triangular" },
1541 { GIMP_REPEAT_TRUNCATE, "GIMP_REPEAT_TRUNCATE", "truncate" },
1542 { 0, NULL, NULL }
1543 };
1544
1545 static const GimpEnumDesc descs[] =
1546 {
1547 { GIMP_REPEAT_NONE, NC_("repeat-mode", "None (extend)"), NULL },
1548 { GIMP_REPEAT_SAWTOOTH, NC_("repeat-mode", "Sawtooth wave"), NULL },
1549 { GIMP_REPEAT_TRIANGULAR, NC_("repeat-mode", "Triangular wave"), NULL },
1550 { GIMP_REPEAT_TRUNCATE, NC_("repeat-mode", "Truncate"), NULL },
1551 { 0, NULL, NULL }
1552 };
1553
1554 static GType type = 0;
1555
1556 if (G_UNLIKELY (! type))
1557 {
1558 type = g_enum_register_static ("GimpRepeatMode", values);
1559 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1560 gimp_type_set_translation_context (type, "repeat-mode");
1561 gimp_enum_set_value_descriptions (type, descs);
1562 }
1563
1564 return type;
1565 }
1566
1567 GType
gimp_rotation_type_get_type(void)1568 gimp_rotation_type_get_type (void)
1569 {
1570 static const GEnumValue values[] =
1571 {
1572 { GIMP_ROTATE_90, "GIMP_ROTATE_90", "90" },
1573 { GIMP_ROTATE_180, "GIMP_ROTATE_180", "180" },
1574 { GIMP_ROTATE_270, "GIMP_ROTATE_270", "270" },
1575 { 0, NULL, NULL }
1576 };
1577
1578 static const GimpEnumDesc descs[] =
1579 {
1580 { GIMP_ROTATE_90, "GIMP_ROTATE_90", NULL },
1581 { GIMP_ROTATE_180, "GIMP_ROTATE_180", NULL },
1582 { GIMP_ROTATE_270, "GIMP_ROTATE_270", NULL },
1583 { 0, NULL, NULL }
1584 };
1585
1586 static GType type = 0;
1587
1588 if (G_UNLIKELY (! type))
1589 {
1590 type = g_enum_register_static ("GimpRotationType", values);
1591 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1592 gimp_type_set_translation_context (type, "rotation-type");
1593 gimp_enum_set_value_descriptions (type, descs);
1594 }
1595
1596 return type;
1597 }
1598
1599 GType
gimp_run_mode_get_type(void)1600 gimp_run_mode_get_type (void)
1601 {
1602 static const GEnumValue values[] =
1603 {
1604 { GIMP_RUN_INTERACTIVE, "GIMP_RUN_INTERACTIVE", "interactive" },
1605 { GIMP_RUN_NONINTERACTIVE, "GIMP_RUN_NONINTERACTIVE", "noninteractive" },
1606 { GIMP_RUN_WITH_LAST_VALS, "GIMP_RUN_WITH_LAST_VALS", "with-last-vals" },
1607 { 0, NULL, NULL }
1608 };
1609
1610 static const GimpEnumDesc descs[] =
1611 {
1612 { GIMP_RUN_INTERACTIVE, NC_("run-mode", "Run interactively"), NULL },
1613 { GIMP_RUN_NONINTERACTIVE, NC_("run-mode", "Run non-interactively"), NULL },
1614 { GIMP_RUN_WITH_LAST_VALS, NC_("run-mode", "Run with last used values"), NULL },
1615 { 0, NULL, NULL }
1616 };
1617
1618 static GType type = 0;
1619
1620 if (G_UNLIKELY (! type))
1621 {
1622 type = g_enum_register_static ("GimpRunMode", values);
1623 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1624 gimp_type_set_translation_context (type, "run-mode");
1625 gimp_enum_set_value_descriptions (type, descs);
1626 }
1627
1628 return type;
1629 }
1630
1631 GType
gimp_select_criterion_get_type(void)1632 gimp_select_criterion_get_type (void)
1633 {
1634 static const GEnumValue values[] =
1635 {
1636 { GIMP_SELECT_CRITERION_COMPOSITE, "GIMP_SELECT_CRITERION_COMPOSITE", "composite" },
1637 { GIMP_SELECT_CRITERION_R, "GIMP_SELECT_CRITERION_R", "r" },
1638 { GIMP_SELECT_CRITERION_G, "GIMP_SELECT_CRITERION_G", "g" },
1639 { GIMP_SELECT_CRITERION_B, "GIMP_SELECT_CRITERION_B", "b" },
1640 { GIMP_SELECT_CRITERION_H, "GIMP_SELECT_CRITERION_H", "h" },
1641 { GIMP_SELECT_CRITERION_S, "GIMP_SELECT_CRITERION_S", "s" },
1642 { GIMP_SELECT_CRITERION_V, "GIMP_SELECT_CRITERION_V", "v" },
1643 { GIMP_SELECT_CRITERION_A, "GIMP_SELECT_CRITERION_A", "a" },
1644 { GIMP_SELECT_CRITERION_LCH_L, "GIMP_SELECT_CRITERION_LCH_L", "lch-l" },
1645 { GIMP_SELECT_CRITERION_LCH_C, "GIMP_SELECT_CRITERION_LCH_C", "lch-c" },
1646 { GIMP_SELECT_CRITERION_LCH_H, "GIMP_SELECT_CRITERION_LCH_H", "lch-h" },
1647 { 0, NULL, NULL }
1648 };
1649
1650 static const GimpEnumDesc descs[] =
1651 {
1652 { GIMP_SELECT_CRITERION_COMPOSITE, NC_("select-criterion", "Composite"), NULL },
1653 { GIMP_SELECT_CRITERION_R, NC_("select-criterion", "Red"), NULL },
1654 { GIMP_SELECT_CRITERION_G, NC_("select-criterion", "Green"), NULL },
1655 { GIMP_SELECT_CRITERION_B, NC_("select-criterion", "Blue"), NULL },
1656 { GIMP_SELECT_CRITERION_H, NC_("select-criterion", "HSV Hue"), NULL },
1657 { GIMP_SELECT_CRITERION_S, NC_("select-criterion", "HSV Saturation"), NULL },
1658 { GIMP_SELECT_CRITERION_V, NC_("select-criterion", "HSV Value"), NULL },
1659 { GIMP_SELECT_CRITERION_A, NC_("select-criterion", "Alpha"), NULL },
1660 { GIMP_SELECT_CRITERION_LCH_L, NC_("select-criterion", "LCh Lightness"), NULL },
1661 { GIMP_SELECT_CRITERION_LCH_C, NC_("select-criterion", "LCh Chroma"), NULL },
1662 { GIMP_SELECT_CRITERION_LCH_H, NC_("select-criterion", "LCh Hue"), NULL },
1663 { 0, NULL, NULL }
1664 };
1665
1666 static GType type = 0;
1667
1668 if (G_UNLIKELY (! type))
1669 {
1670 type = g_enum_register_static ("GimpSelectCriterion", values);
1671 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1672 gimp_type_set_translation_context (type, "select-criterion");
1673 gimp_enum_set_value_descriptions (type, descs);
1674 }
1675
1676 return type;
1677 }
1678
1679 GType
gimp_size_type_get_type(void)1680 gimp_size_type_get_type (void)
1681 {
1682 static const GEnumValue values[] =
1683 {
1684 { GIMP_PIXELS, "GIMP_PIXELS", "pixels" },
1685 { GIMP_POINTS, "GIMP_POINTS", "points" },
1686 { 0, NULL, NULL }
1687 };
1688
1689 static const GimpEnumDesc descs[] =
1690 {
1691 { GIMP_PIXELS, NC_("size-type", "Pixels"), NULL },
1692 { GIMP_POINTS, NC_("size-type", "Points"), NULL },
1693 { 0, NULL, NULL }
1694 };
1695
1696 static GType type = 0;
1697
1698 if (G_UNLIKELY (! type))
1699 {
1700 type = g_enum_register_static ("GimpSizeType", values);
1701 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1702 gimp_type_set_translation_context (type, "size-type");
1703 gimp_enum_set_value_descriptions (type, descs);
1704 }
1705
1706 return type;
1707 }
1708
1709 GType
gimp_stack_trace_mode_get_type(void)1710 gimp_stack_trace_mode_get_type (void)
1711 {
1712 static const GEnumValue values[] =
1713 {
1714 { GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", "never" },
1715 { GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", "query" },
1716 { GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", "always" },
1717 { 0, NULL, NULL }
1718 };
1719
1720 static const GimpEnumDesc descs[] =
1721 {
1722 { GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", NULL },
1723 { GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", NULL },
1724 { GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", NULL },
1725 { 0, NULL, NULL }
1726 };
1727
1728 static GType type = 0;
1729
1730 if (G_UNLIKELY (! type))
1731 {
1732 type = g_enum_register_static ("GimpStackTraceMode", values);
1733 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1734 gimp_type_set_translation_context (type, "stack-trace-mode");
1735 gimp_enum_set_value_descriptions (type, descs);
1736 }
1737
1738 return type;
1739 }
1740
1741 GType
gimp_stroke_method_get_type(void)1742 gimp_stroke_method_get_type (void)
1743 {
1744 static const GEnumValue values[] =
1745 {
1746 { GIMP_STROKE_LINE, "GIMP_STROKE_LINE", "line" },
1747 { GIMP_STROKE_PAINT_METHOD, "GIMP_STROKE_PAINT_METHOD", "paint-method" },
1748 { 0, NULL, NULL }
1749 };
1750
1751 static const GimpEnumDesc descs[] =
1752 {
1753 { GIMP_STROKE_LINE, NC_("stroke-method", "Stroke line"), NULL },
1754 { GIMP_STROKE_PAINT_METHOD, NC_("stroke-method", "Stroke with a paint tool"), NULL },
1755 { 0, NULL, NULL }
1756 };
1757
1758 static GType type = 0;
1759
1760 if (G_UNLIKELY (! type))
1761 {
1762 type = g_enum_register_static ("GimpStrokeMethod", values);
1763 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1764 gimp_type_set_translation_context (type, "stroke-method");
1765 gimp_enum_set_value_descriptions (type, descs);
1766 }
1767
1768 return type;
1769 }
1770
1771 GType
gimp_text_direction_get_type(void)1772 gimp_text_direction_get_type (void)
1773 {
1774 static const GEnumValue values[] =
1775 {
1776 { GIMP_TEXT_DIRECTION_LTR, "GIMP_TEXT_DIRECTION_LTR", "ltr" },
1777 { GIMP_TEXT_DIRECTION_RTL, "GIMP_TEXT_DIRECTION_RTL", "rtl" },
1778 { GIMP_TEXT_DIRECTION_TTB_RTL, "GIMP_TEXT_DIRECTION_TTB_RTL", "ttb-rtl" },
1779 { GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT, "GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT", "ttb-rtl-upright" },
1780 { GIMP_TEXT_DIRECTION_TTB_LTR, "GIMP_TEXT_DIRECTION_TTB_LTR", "ttb-ltr" },
1781 { GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT, "GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT", "ttb-ltr-upright" },
1782 { 0, NULL, NULL }
1783 };
1784
1785 static const GimpEnumDesc descs[] =
1786 {
1787 { GIMP_TEXT_DIRECTION_LTR, NC_("text-direction", "From left to right"), NULL },
1788 { GIMP_TEXT_DIRECTION_RTL, NC_("text-direction", "From right to left"), NULL },
1789 { GIMP_TEXT_DIRECTION_TTB_RTL, NC_("text-direction", "Vertical, right to left (mixed orientation)"), NULL },
1790 { GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT, NC_("text-direction", "Vertical, right to left (upright orientation)"), NULL },
1791 { GIMP_TEXT_DIRECTION_TTB_LTR, NC_("text-direction", "Vertical, left to right (mixed orientation)"), NULL },
1792 { GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT, NC_("text-direction", "Vertical, left to right (upright orientation)"), NULL },
1793 { 0, NULL, NULL }
1794 };
1795
1796 static GType type = 0;
1797
1798 if (G_UNLIKELY (! type))
1799 {
1800 type = g_enum_register_static ("GimpTextDirection", values);
1801 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1802 gimp_type_set_translation_context (type, "text-direction");
1803 gimp_enum_set_value_descriptions (type, descs);
1804 }
1805
1806 return type;
1807 }
1808
1809 GType
gimp_text_hint_style_get_type(void)1810 gimp_text_hint_style_get_type (void)
1811 {
1812 static const GEnumValue values[] =
1813 {
1814 { GIMP_TEXT_HINT_STYLE_NONE, "GIMP_TEXT_HINT_STYLE_NONE", "none" },
1815 { GIMP_TEXT_HINT_STYLE_SLIGHT, "GIMP_TEXT_HINT_STYLE_SLIGHT", "slight" },
1816 { GIMP_TEXT_HINT_STYLE_MEDIUM, "GIMP_TEXT_HINT_STYLE_MEDIUM", "medium" },
1817 { GIMP_TEXT_HINT_STYLE_FULL, "GIMP_TEXT_HINT_STYLE_FULL", "full" },
1818 { 0, NULL, NULL }
1819 };
1820
1821 static const GimpEnumDesc descs[] =
1822 {
1823 { GIMP_TEXT_HINT_STYLE_NONE, NC_("text-hint-style", "None"), NULL },
1824 { GIMP_TEXT_HINT_STYLE_SLIGHT, NC_("text-hint-style", "Slight"), NULL },
1825 { GIMP_TEXT_HINT_STYLE_MEDIUM, NC_("text-hint-style", "Medium"), NULL },
1826 { GIMP_TEXT_HINT_STYLE_FULL, NC_("text-hint-style", "Full"), NULL },
1827 { 0, NULL, NULL }
1828 };
1829
1830 static GType type = 0;
1831
1832 if (G_UNLIKELY (! type))
1833 {
1834 type = g_enum_register_static ("GimpTextHintStyle", values);
1835 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1836 gimp_type_set_translation_context (type, "text-hint-style");
1837 gimp_enum_set_value_descriptions (type, descs);
1838 }
1839
1840 return type;
1841 }
1842
1843 GType
gimp_text_justification_get_type(void)1844 gimp_text_justification_get_type (void)
1845 {
1846 static const GEnumValue values[] =
1847 {
1848 { GIMP_TEXT_JUSTIFY_LEFT, "GIMP_TEXT_JUSTIFY_LEFT", "left" },
1849 { GIMP_TEXT_JUSTIFY_RIGHT, "GIMP_TEXT_JUSTIFY_RIGHT", "right" },
1850 { GIMP_TEXT_JUSTIFY_CENTER, "GIMP_TEXT_JUSTIFY_CENTER", "center" },
1851 { GIMP_TEXT_JUSTIFY_FILL, "GIMP_TEXT_JUSTIFY_FILL", "fill" },
1852 { 0, NULL, NULL }
1853 };
1854
1855 static const GimpEnumDesc descs[] =
1856 {
1857 { GIMP_TEXT_JUSTIFY_LEFT, NC_("text-justification", "Left justified"), NULL },
1858 { GIMP_TEXT_JUSTIFY_RIGHT, NC_("text-justification", "Right justified"), NULL },
1859 { GIMP_TEXT_JUSTIFY_CENTER, NC_("text-justification", "Centered"), NULL },
1860 { GIMP_TEXT_JUSTIFY_FILL, NC_("text-justification", "Filled"), NULL },
1861 { 0, NULL, NULL }
1862 };
1863
1864 static GType type = 0;
1865
1866 if (G_UNLIKELY (! type))
1867 {
1868 type = g_enum_register_static ("GimpTextJustification", values);
1869 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1870 gimp_type_set_translation_context (type, "text-justification");
1871 gimp_enum_set_value_descriptions (type, descs);
1872 }
1873
1874 return type;
1875 }
1876
1877 GType
gimp_transfer_mode_get_type(void)1878 gimp_transfer_mode_get_type (void)
1879 {
1880 static const GEnumValue values[] =
1881 {
1882 { GIMP_TRANSFER_SHADOWS, "GIMP_TRANSFER_SHADOWS", "shadows" },
1883 { GIMP_TRANSFER_MIDTONES, "GIMP_TRANSFER_MIDTONES", "midtones" },
1884 { GIMP_TRANSFER_HIGHLIGHTS, "GIMP_TRANSFER_HIGHLIGHTS", "highlights" },
1885 { 0, NULL, NULL }
1886 };
1887
1888 static const GimpEnumDesc descs[] =
1889 {
1890 { GIMP_TRANSFER_SHADOWS, NC_("transfer-mode", "Shadows"), NULL },
1891 { GIMP_TRANSFER_MIDTONES, NC_("transfer-mode", "Midtones"), NULL },
1892 { GIMP_TRANSFER_HIGHLIGHTS, NC_("transfer-mode", "Highlights"), NULL },
1893 { 0, NULL, NULL }
1894 };
1895
1896 static GType type = 0;
1897
1898 if (G_UNLIKELY (! type))
1899 {
1900 type = g_enum_register_static ("GimpTransferMode", values);
1901 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1902 gimp_type_set_translation_context (type, "transfer-mode");
1903 gimp_enum_set_value_descriptions (type, descs);
1904 }
1905
1906 return type;
1907 }
1908
1909 GType
gimp_transform_direction_get_type(void)1910 gimp_transform_direction_get_type (void)
1911 {
1912 static const GEnumValue values[] =
1913 {
1914 { GIMP_TRANSFORM_FORWARD, "GIMP_TRANSFORM_FORWARD", "forward" },
1915 { GIMP_TRANSFORM_BACKWARD, "GIMP_TRANSFORM_BACKWARD", "backward" },
1916 { 0, NULL, NULL }
1917 };
1918
1919 static const GimpEnumDesc descs[] =
1920 {
1921 { GIMP_TRANSFORM_FORWARD, NC_("transform-direction", "Normal (Forward)"), NULL },
1922 { GIMP_TRANSFORM_BACKWARD, NC_("transform-direction", "Corrective (Backward)"), NULL },
1923 { 0, NULL, NULL }
1924 };
1925
1926 static GType type = 0;
1927
1928 if (G_UNLIKELY (! type))
1929 {
1930 type = g_enum_register_static ("GimpTransformDirection", values);
1931 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1932 gimp_type_set_translation_context (type, "transform-direction");
1933 gimp_enum_set_value_descriptions (type, descs);
1934 }
1935
1936 return type;
1937 }
1938
1939 GType
gimp_transform_resize_get_type(void)1940 gimp_transform_resize_get_type (void)
1941 {
1942 static const GEnumValue values[] =
1943 {
1944 { GIMP_TRANSFORM_RESIZE_ADJUST, "GIMP_TRANSFORM_RESIZE_ADJUST", "adjust" },
1945 { GIMP_TRANSFORM_RESIZE_CLIP, "GIMP_TRANSFORM_RESIZE_CLIP", "clip" },
1946 { GIMP_TRANSFORM_RESIZE_CROP, "GIMP_TRANSFORM_RESIZE_CROP", "crop" },
1947 { GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, "GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT", "crop-with-aspect" },
1948 { 0, NULL, NULL }
1949 };
1950
1951 static const GimpEnumDesc descs[] =
1952 {
1953 { GIMP_TRANSFORM_RESIZE_ADJUST, NC_("transform-resize", "Adjust"), NULL },
1954 { GIMP_TRANSFORM_RESIZE_CLIP, NC_("transform-resize", "Clip"), NULL },
1955 { GIMP_TRANSFORM_RESIZE_CROP, NC_("transform-resize", "Crop to result"), NULL },
1956 { GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, NC_("transform-resize", "Crop with aspect"), NULL },
1957 { 0, NULL, NULL }
1958 };
1959
1960 static GType type = 0;
1961
1962 if (G_UNLIKELY (! type))
1963 {
1964 type = g_enum_register_static ("GimpTransformResize", values);
1965 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
1966 gimp_type_set_translation_context (type, "transform-resize");
1967 gimp_enum_set_value_descriptions (type, descs);
1968 }
1969
1970 return type;
1971 }
1972
1973 GType
gimp_user_directory_get_type(void)1974 gimp_user_directory_get_type (void)
1975 {
1976 static const GEnumValue values[] =
1977 {
1978 { GIMP_USER_DIRECTORY_DESKTOP, "GIMP_USER_DIRECTORY_DESKTOP", "desktop" },
1979 { GIMP_USER_DIRECTORY_DOCUMENTS, "GIMP_USER_DIRECTORY_DOCUMENTS", "documents" },
1980 { GIMP_USER_DIRECTORY_DOWNLOAD, "GIMP_USER_DIRECTORY_DOWNLOAD", "download" },
1981 { GIMP_USER_DIRECTORY_MUSIC, "GIMP_USER_DIRECTORY_MUSIC", "music" },
1982 { GIMP_USER_DIRECTORY_PICTURES, "GIMP_USER_DIRECTORY_PICTURES", "pictures" },
1983 { GIMP_USER_DIRECTORY_PUBLIC_SHARE, "GIMP_USER_DIRECTORY_PUBLIC_SHARE", "public-share" },
1984 { GIMP_USER_DIRECTORY_TEMPLATES, "GIMP_USER_DIRECTORY_TEMPLATES", "templates" },
1985 { GIMP_USER_DIRECTORY_VIDEOS, "GIMP_USER_DIRECTORY_VIDEOS", "videos" },
1986 { 0, NULL, NULL }
1987 };
1988
1989 static const GimpEnumDesc descs[] =
1990 {
1991 { GIMP_USER_DIRECTORY_DESKTOP, "GIMP_USER_DIRECTORY_DESKTOP", NULL },
1992 { GIMP_USER_DIRECTORY_DOCUMENTS, "GIMP_USER_DIRECTORY_DOCUMENTS", NULL },
1993 { GIMP_USER_DIRECTORY_DOWNLOAD, "GIMP_USER_DIRECTORY_DOWNLOAD", NULL },
1994 { GIMP_USER_DIRECTORY_MUSIC, "GIMP_USER_DIRECTORY_MUSIC", NULL },
1995 { GIMP_USER_DIRECTORY_PICTURES, "GIMP_USER_DIRECTORY_PICTURES", NULL },
1996 { GIMP_USER_DIRECTORY_PUBLIC_SHARE, "GIMP_USER_DIRECTORY_PUBLIC_SHARE", NULL },
1997 { GIMP_USER_DIRECTORY_TEMPLATES, "GIMP_USER_DIRECTORY_TEMPLATES", NULL },
1998 { GIMP_USER_DIRECTORY_VIDEOS, "GIMP_USER_DIRECTORY_VIDEOS", NULL },
1999 { 0, NULL, NULL }
2000 };
2001
2002 static GType type = 0;
2003
2004 if (G_UNLIKELY (! type))
2005 {
2006 type = g_enum_register_static ("GimpUserDirectory", values);
2007 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
2008 gimp_type_set_translation_context (type, "user-directory");
2009 gimp_enum_set_value_descriptions (type, descs);
2010 }
2011
2012 return type;
2013 }
2014
2015 GType
gimp_vectors_stroke_type_get_type(void)2016 gimp_vectors_stroke_type_get_type (void)
2017 {
2018 static const GEnumValue values[] =
2019 {
2020 { GIMP_VECTORS_STROKE_TYPE_BEZIER, "GIMP_VECTORS_STROKE_TYPE_BEZIER", "bezier" },
2021 { 0, NULL, NULL }
2022 };
2023
2024 static const GimpEnumDesc descs[] =
2025 {
2026 { GIMP_VECTORS_STROKE_TYPE_BEZIER, "GIMP_VECTORS_STROKE_TYPE_BEZIER", NULL },
2027 { 0, NULL, NULL }
2028 };
2029
2030 static GType type = 0;
2031
2032 if (G_UNLIKELY (! type))
2033 {
2034 type = g_enum_register_static ("GimpVectorsStrokeType", values);
2035 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
2036 gimp_type_set_translation_context (type, "vectors-stroke-type");
2037 gimp_enum_set_value_descriptions (type, descs);
2038 }
2039
2040 return type;
2041 }
2042
2043
2044 /* Generated data ends here */
2045
2046