1
2 /* Generated data (by gimp-mkenums) */
3
4 #include "config.h"
5 #include <gio/gio.h>
6 #include "libgimpbase/gimpbase.h"
7 #include "core-enums.h"
8 #include "gimp-intl.h"
9
10 /* enumerations from "core-enums.h" */
11 GType
gimp_align_reference_type_get_type(void)12 gimp_align_reference_type_get_type (void)
13 {
14 static const GEnumValue values[] =
15 {
16 { GIMP_ALIGN_REFERENCE_FIRST, "GIMP_ALIGN_REFERENCE_FIRST", "first" },
17 { GIMP_ALIGN_REFERENCE_IMAGE, "GIMP_ALIGN_REFERENCE_IMAGE", "image" },
18 { GIMP_ALIGN_REFERENCE_SELECTION, "GIMP_ALIGN_REFERENCE_SELECTION", "selection" },
19 { GIMP_ALIGN_REFERENCE_ACTIVE_LAYER, "GIMP_ALIGN_REFERENCE_ACTIVE_LAYER", "active-layer" },
20 { GIMP_ALIGN_REFERENCE_ACTIVE_CHANNEL, "GIMP_ALIGN_REFERENCE_ACTIVE_CHANNEL", "active-channel" },
21 { GIMP_ALIGN_REFERENCE_ACTIVE_PATH, "GIMP_ALIGN_REFERENCE_ACTIVE_PATH", "active-path" },
22 { 0, NULL, NULL }
23 };
24
25 static const GimpEnumDesc descs[] =
26 {
27 { GIMP_ALIGN_REFERENCE_FIRST, NC_("align-reference-type", "First item"), NULL },
28 { GIMP_ALIGN_REFERENCE_IMAGE, NC_("align-reference-type", "Image"), NULL },
29 { GIMP_ALIGN_REFERENCE_SELECTION, NC_("align-reference-type", "Selection"), NULL },
30 { GIMP_ALIGN_REFERENCE_ACTIVE_LAYER, NC_("align-reference-type", "Active layer"), NULL },
31 { GIMP_ALIGN_REFERENCE_ACTIVE_CHANNEL, NC_("align-reference-type", "Active channel"), NULL },
32 { GIMP_ALIGN_REFERENCE_ACTIVE_PATH, NC_("align-reference-type", "Active path"), NULL },
33 { 0, NULL, NULL }
34 };
35
36 static GType type = 0;
37
38 if (G_UNLIKELY (! type))
39 {
40 type = g_enum_register_static ("GimpAlignReferenceType", values);
41 gimp_type_set_translation_context (type, "align-reference-type");
42 gimp_enum_set_value_descriptions (type, descs);
43 }
44
45 return type;
46 }
47
48 GType
gimp_alignment_type_get_type(void)49 gimp_alignment_type_get_type (void)
50 {
51 static const GEnumValue values[] =
52 {
53 { GIMP_ALIGN_LEFT, "GIMP_ALIGN_LEFT", "align-left" },
54 { GIMP_ALIGN_HCENTER, "GIMP_ALIGN_HCENTER", "align-hcenter" },
55 { GIMP_ALIGN_RIGHT, "GIMP_ALIGN_RIGHT", "align-right" },
56 { GIMP_ALIGN_TOP, "GIMP_ALIGN_TOP", "align-top" },
57 { GIMP_ALIGN_VCENTER, "GIMP_ALIGN_VCENTER", "align-vcenter" },
58 { GIMP_ALIGN_BOTTOM, "GIMP_ALIGN_BOTTOM", "align-bottom" },
59 { GIMP_ARRANGE_LEFT, "GIMP_ARRANGE_LEFT", "arrange-left" },
60 { GIMP_ARRANGE_HCENTER, "GIMP_ARRANGE_HCENTER", "arrange-hcenter" },
61 { GIMP_ARRANGE_RIGHT, "GIMP_ARRANGE_RIGHT", "arrange-right" },
62 { GIMP_ARRANGE_TOP, "GIMP_ARRANGE_TOP", "arrange-top" },
63 { GIMP_ARRANGE_VCENTER, "GIMP_ARRANGE_VCENTER", "arrange-vcenter" },
64 { GIMP_ARRANGE_BOTTOM, "GIMP_ARRANGE_BOTTOM", "arrange-bottom" },
65 { GIMP_ARRANGE_HFILL, "GIMP_ARRANGE_HFILL", "arrange-hfill" },
66 { GIMP_ARRANGE_VFILL, "GIMP_ARRANGE_VFILL", "arrange-vfill" },
67 { 0, NULL, NULL }
68 };
69
70 static const GimpEnumDesc descs[] =
71 {
72 { GIMP_ALIGN_LEFT, "GIMP_ALIGN_LEFT", NULL },
73 { GIMP_ALIGN_HCENTER, "GIMP_ALIGN_HCENTER", NULL },
74 { GIMP_ALIGN_RIGHT, "GIMP_ALIGN_RIGHT", NULL },
75 { GIMP_ALIGN_TOP, "GIMP_ALIGN_TOP", NULL },
76 { GIMP_ALIGN_VCENTER, "GIMP_ALIGN_VCENTER", NULL },
77 { GIMP_ALIGN_BOTTOM, "GIMP_ALIGN_BOTTOM", NULL },
78 { GIMP_ARRANGE_LEFT, "GIMP_ARRANGE_LEFT", NULL },
79 { GIMP_ARRANGE_HCENTER, "GIMP_ARRANGE_HCENTER", NULL },
80 { GIMP_ARRANGE_RIGHT, "GIMP_ARRANGE_RIGHT", NULL },
81 { GIMP_ARRANGE_TOP, "GIMP_ARRANGE_TOP", NULL },
82 { GIMP_ARRANGE_VCENTER, "GIMP_ARRANGE_VCENTER", NULL },
83 { GIMP_ARRANGE_BOTTOM, "GIMP_ARRANGE_BOTTOM", NULL },
84 { GIMP_ARRANGE_HFILL, "GIMP_ARRANGE_HFILL", NULL },
85 { GIMP_ARRANGE_VFILL, "GIMP_ARRANGE_VFILL", NULL },
86 { 0, NULL, NULL }
87 };
88
89 static GType type = 0;
90
91 if (G_UNLIKELY (! type))
92 {
93 type = g_enum_register_static ("GimpAlignmentType", values);
94 gimp_type_set_translation_context (type, "alignment-type");
95 gimp_enum_set_value_descriptions (type, descs);
96 }
97
98 return type;
99 }
100
101 GType
gimp_channel_border_style_get_type(void)102 gimp_channel_border_style_get_type (void)
103 {
104 static const GEnumValue values[] =
105 {
106 { GIMP_CHANNEL_BORDER_STYLE_HARD, "GIMP_CHANNEL_BORDER_STYLE_HARD", "hard" },
107 { GIMP_CHANNEL_BORDER_STYLE_SMOOTH, "GIMP_CHANNEL_BORDER_STYLE_SMOOTH", "smooth" },
108 { GIMP_CHANNEL_BORDER_STYLE_FEATHERED, "GIMP_CHANNEL_BORDER_STYLE_FEATHERED", "feathered" },
109 { 0, NULL, NULL }
110 };
111
112 static const GimpEnumDesc descs[] =
113 {
114 { GIMP_CHANNEL_BORDER_STYLE_HARD, NC_("channel-border-style", "Hard"), NULL },
115 { GIMP_CHANNEL_BORDER_STYLE_SMOOTH, NC_("channel-border-style", "Smooth"), NULL },
116 { GIMP_CHANNEL_BORDER_STYLE_FEATHERED, NC_("channel-border-style", "Feathered"), NULL },
117 { 0, NULL, NULL }
118 };
119
120 static GType type = 0;
121
122 if (G_UNLIKELY (! type))
123 {
124 type = g_enum_register_static ("GimpChannelBorderStyle", values);
125 gimp_type_set_translation_context (type, "channel-border-style");
126 gimp_enum_set_value_descriptions (type, descs);
127 }
128
129 return type;
130 }
131
132 GType
gimp_color_pick_mode_get_type(void)133 gimp_color_pick_mode_get_type (void)
134 {
135 static const GEnumValue values[] =
136 {
137 { GIMP_COLOR_PICK_MODE_PIXEL, "GIMP_COLOR_PICK_MODE_PIXEL", "pixel" },
138 { GIMP_COLOR_PICK_MODE_RGB_PERCENT, "GIMP_COLOR_PICK_MODE_RGB_PERCENT", "rgb-percent" },
139 { GIMP_COLOR_PICK_MODE_RGB_U8, "GIMP_COLOR_PICK_MODE_RGB_U8", "rgb-u8" },
140 { GIMP_COLOR_PICK_MODE_HSV, "GIMP_COLOR_PICK_MODE_HSV", "hsv" },
141 { GIMP_COLOR_PICK_MODE_LCH, "GIMP_COLOR_PICK_MODE_LCH", "lch" },
142 { GIMP_COLOR_PICK_MODE_LAB, "GIMP_COLOR_PICK_MODE_LAB", "lab" },
143 { GIMP_COLOR_PICK_MODE_CMYK, "GIMP_COLOR_PICK_MODE_CMYK", "cmyk" },
144 { GIMP_COLOR_PICK_MODE_XYY, "GIMP_COLOR_PICK_MODE_XYY", "xyy" },
145 { GIMP_COLOR_PICK_MODE_YUV, "GIMP_COLOR_PICK_MODE_YUV", "yuv" },
146 { 0, NULL, NULL }
147 };
148
149 static const GimpEnumDesc descs[] =
150 {
151 { GIMP_COLOR_PICK_MODE_PIXEL, NC_("color-pick-mode", "Pixel"), NULL },
152 { GIMP_COLOR_PICK_MODE_RGB_PERCENT, NC_("color-pick-mode", "RGB (%)"), NULL },
153 { GIMP_COLOR_PICK_MODE_RGB_U8, NC_("color-pick-mode", "RGB (0..255)"), NULL },
154 { GIMP_COLOR_PICK_MODE_HSV, NC_("color-pick-mode", "HSV"), NULL },
155 { GIMP_COLOR_PICK_MODE_LCH, NC_("color-pick-mode", "CIE LCh"), NULL },
156 { GIMP_COLOR_PICK_MODE_LAB, NC_("color-pick-mode", "CIE LAB"), NULL },
157 { GIMP_COLOR_PICK_MODE_CMYK, NC_("color-pick-mode", "CMYK"), NULL },
158 { GIMP_COLOR_PICK_MODE_XYY, NC_("color-pick-mode", "CIE xyY"), NULL },
159 { GIMP_COLOR_PICK_MODE_YUV, NC_("color-pick-mode", "CIE Yu'v'"), NULL },
160 { 0, NULL, NULL }
161 };
162
163 static GType type = 0;
164
165 if (G_UNLIKELY (! type))
166 {
167 type = g_enum_register_static ("GimpColorPickMode", values);
168 gimp_type_set_translation_context (type, "color-pick-mode");
169 gimp_enum_set_value_descriptions (type, descs);
170 }
171
172 return type;
173 }
174
175 GType
gimp_color_profile_policy_get_type(void)176 gimp_color_profile_policy_get_type (void)
177 {
178 static const GEnumValue values[] =
179 {
180 { GIMP_COLOR_PROFILE_POLICY_ASK, "GIMP_COLOR_PROFILE_POLICY_ASK", "ask" },
181 { GIMP_COLOR_PROFILE_POLICY_KEEP, "GIMP_COLOR_PROFILE_POLICY_KEEP", "keep" },
182 { GIMP_COLOR_PROFILE_POLICY_CONVERT, "GIMP_COLOR_PROFILE_POLICY_CONVERT", "convert" },
183 { 0, NULL, NULL }
184 };
185
186 static const GimpEnumDesc descs[] =
187 {
188 { GIMP_COLOR_PROFILE_POLICY_ASK, NC_("color-profile-policy", "Ask what to do"), NULL },
189 { GIMP_COLOR_PROFILE_POLICY_KEEP, NC_("color-profile-policy", "Keep embedded profile"), NULL },
190 { GIMP_COLOR_PROFILE_POLICY_CONVERT, NC_("color-profile-policy", "Convert to built-in sRGB or grayscale profile"), NULL },
191 { 0, NULL, NULL }
192 };
193
194 static GType type = 0;
195
196 if (G_UNLIKELY (! type))
197 {
198 type = g_enum_register_static ("GimpColorProfilePolicy", values);
199 gimp_type_set_translation_context (type, "color-profile-policy");
200 gimp_enum_set_value_descriptions (type, descs);
201 }
202
203 return type;
204 }
205
206 GType
gimp_component_mask_get_type(void)207 gimp_component_mask_get_type (void)
208 {
209 static const GFlagsValue values[] =
210 {
211 { GIMP_COMPONENT_MASK_RED, "GIMP_COMPONENT_MASK_RED", "red" },
212 { GIMP_COMPONENT_MASK_GREEN, "GIMP_COMPONENT_MASK_GREEN", "green" },
213 { GIMP_COMPONENT_MASK_BLUE, "GIMP_COMPONENT_MASK_BLUE", "blue" },
214 { GIMP_COMPONENT_MASK_ALPHA, "GIMP_COMPONENT_MASK_ALPHA", "alpha" },
215 { GIMP_COMPONENT_MASK_ALL, "GIMP_COMPONENT_MASK_ALL", "all" },
216 { 0, NULL, NULL }
217 };
218
219 static const GimpFlagsDesc descs[] =
220 {
221 { GIMP_COMPONENT_MASK_RED, "GIMP_COMPONENT_MASK_RED", NULL },
222 { GIMP_COMPONENT_MASK_GREEN, "GIMP_COMPONENT_MASK_GREEN", NULL },
223 { GIMP_COMPONENT_MASK_BLUE, "GIMP_COMPONENT_MASK_BLUE", NULL },
224 { GIMP_COMPONENT_MASK_ALPHA, "GIMP_COMPONENT_MASK_ALPHA", NULL },
225 { GIMP_COMPONENT_MASK_ALL, "GIMP_COMPONENT_MASK_ALL", NULL },
226 { 0, NULL, NULL }
227 };
228
229 static GType type = 0;
230
231 if (G_UNLIKELY (! type))
232 {
233 type = g_flags_register_static ("GimpComponentMask", values);
234 gimp_type_set_translation_context (type, "component-mask");
235 gimp_flags_set_value_descriptions (type, descs);
236 }
237
238 return type;
239 }
240
241 GType
gimp_container_policy_get_type(void)242 gimp_container_policy_get_type (void)
243 {
244 static const GEnumValue values[] =
245 {
246 { GIMP_CONTAINER_POLICY_STRONG, "GIMP_CONTAINER_POLICY_STRONG", "strong" },
247 { GIMP_CONTAINER_POLICY_WEAK, "GIMP_CONTAINER_POLICY_WEAK", "weak" },
248 { 0, NULL, NULL }
249 };
250
251 static const GimpEnumDesc descs[] =
252 {
253 { GIMP_CONTAINER_POLICY_STRONG, "GIMP_CONTAINER_POLICY_STRONG", NULL },
254 { GIMP_CONTAINER_POLICY_WEAK, "GIMP_CONTAINER_POLICY_WEAK", NULL },
255 { 0, NULL, NULL }
256 };
257
258 static GType type = 0;
259
260 if (G_UNLIKELY (! type))
261 {
262 type = g_enum_register_static ("GimpContainerPolicy", values);
263 gimp_type_set_translation_context (type, "container-policy");
264 gimp_enum_set_value_descriptions (type, descs);
265 }
266
267 return type;
268 }
269
270 GType
gimp_convert_dither_type_get_type(void)271 gimp_convert_dither_type_get_type (void)
272 {
273 static const GEnumValue values[] =
274 {
275 { GIMP_CONVERT_DITHER_NONE, "GIMP_CONVERT_DITHER_NONE", "none" },
276 { GIMP_CONVERT_DITHER_FS, "GIMP_CONVERT_DITHER_FS", "fs" },
277 { GIMP_CONVERT_DITHER_FS_LOWBLEED, "GIMP_CONVERT_DITHER_FS_LOWBLEED", "fs-lowbleed" },
278 { GIMP_CONVERT_DITHER_FIXED, "GIMP_CONVERT_DITHER_FIXED", "fixed" },
279 { 0, NULL, NULL }
280 };
281
282 static const GimpEnumDesc descs[] =
283 {
284 { GIMP_CONVERT_DITHER_NONE, NC_("convert-dither-type", "None"), NULL },
285 { GIMP_CONVERT_DITHER_FS, NC_("convert-dither-type", "Floyd-Steinberg (normal)"), NULL },
286 { GIMP_CONVERT_DITHER_FS_LOWBLEED, NC_("convert-dither-type", "Floyd-Steinberg (reduced color bleeding)"), NULL },
287 { GIMP_CONVERT_DITHER_FIXED, NC_("convert-dither-type", "Positioned"), NULL },
288 { 0, NULL, NULL }
289 };
290
291 static GType type = 0;
292
293 if (G_UNLIKELY (! type))
294 {
295 type = g_enum_register_static ("GimpConvertDitherType", values);
296 gimp_type_set_translation_context (type, "convert-dither-type");
297 gimp_enum_set_value_descriptions (type, descs);
298 }
299
300 return type;
301 }
302
303 GType
gimp_convolution_type_get_type(void)304 gimp_convolution_type_get_type (void)
305 {
306 static const GEnumValue values[] =
307 {
308 { GIMP_NORMAL_CONVOL, "GIMP_NORMAL_CONVOL", "normal-convol" },
309 { GIMP_ABSOLUTE_CONVOL, "GIMP_ABSOLUTE_CONVOL", "absolute-convol" },
310 { GIMP_NEGATIVE_CONVOL, "GIMP_NEGATIVE_CONVOL", "negative-convol" },
311 { 0, NULL, NULL }
312 };
313
314 static const GimpEnumDesc descs[] =
315 {
316 { GIMP_NORMAL_CONVOL, "GIMP_NORMAL_CONVOL", NULL },
317 { GIMP_ABSOLUTE_CONVOL, "GIMP_ABSOLUTE_CONVOL", NULL },
318 { GIMP_NEGATIVE_CONVOL, "GIMP_NEGATIVE_CONVOL", NULL },
319 { 0, NULL, NULL }
320 };
321
322 static GType type = 0;
323
324 if (G_UNLIKELY (! type))
325 {
326 type = g_enum_register_static ("GimpConvolutionType", values);
327 gimp_type_set_translation_context (type, "convolution-type");
328 gimp_enum_set_value_descriptions (type, descs);
329 }
330
331 return type;
332 }
333
334 GType
gimp_curve_point_type_get_type(void)335 gimp_curve_point_type_get_type (void)
336 {
337 static const GEnumValue values[] =
338 {
339 { GIMP_CURVE_POINT_SMOOTH, "GIMP_CURVE_POINT_SMOOTH", "smooth" },
340 { GIMP_CURVE_POINT_CORNER, "GIMP_CURVE_POINT_CORNER", "corner" },
341 { 0, NULL, NULL }
342 };
343
344 static const GimpEnumDesc descs[] =
345 {
346 { GIMP_CURVE_POINT_SMOOTH, NC_("curve-point-type", "Smooth"), NULL },
347 { GIMP_CURVE_POINT_CORNER, NC_("curve-point-type", "Corner"), NULL },
348 { 0, NULL, NULL }
349 };
350
351 static GType type = 0;
352
353 if (G_UNLIKELY (! type))
354 {
355 type = g_enum_register_static ("GimpCurvePointType", values);
356 gimp_type_set_translation_context (type, "curve-point-type");
357 gimp_enum_set_value_descriptions (type, descs);
358 }
359
360 return type;
361 }
362
363 GType
gimp_curve_type_get_type(void)364 gimp_curve_type_get_type (void)
365 {
366 static const GEnumValue values[] =
367 {
368 { GIMP_CURVE_SMOOTH, "GIMP_CURVE_SMOOTH", "smooth" },
369 { GIMP_CURVE_FREE, "GIMP_CURVE_FREE", "free" },
370 { 0, NULL, NULL }
371 };
372
373 static const GimpEnumDesc descs[] =
374 {
375 { GIMP_CURVE_SMOOTH, NC_("curve-type", "Smooth"), NULL },
376 { GIMP_CURVE_FREE, NC_("curve-type", "Freehand"), NULL },
377 { 0, NULL, NULL }
378 };
379
380 static GType type = 0;
381
382 if (G_UNLIKELY (! type))
383 {
384 type = g_enum_register_static ("GimpCurveType", values);
385 gimp_type_set_translation_context (type, "curve-type");
386 gimp_enum_set_value_descriptions (type, descs);
387 }
388
389 return type;
390 }
391
392 GType
gimp_dash_preset_get_type(void)393 gimp_dash_preset_get_type (void)
394 {
395 static const GEnumValue values[] =
396 {
397 { GIMP_DASH_CUSTOM, "GIMP_DASH_CUSTOM", "custom" },
398 { GIMP_DASH_LINE, "GIMP_DASH_LINE", "line" },
399 { GIMP_DASH_LONG_DASH, "GIMP_DASH_LONG_DASH", "long-dash" },
400 { GIMP_DASH_MEDIUM_DASH, "GIMP_DASH_MEDIUM_DASH", "medium-dash" },
401 { GIMP_DASH_SHORT_DASH, "GIMP_DASH_SHORT_DASH", "short-dash" },
402 { GIMP_DASH_SPARSE_DOTS, "GIMP_DASH_SPARSE_DOTS", "sparse-dots" },
403 { GIMP_DASH_NORMAL_DOTS, "GIMP_DASH_NORMAL_DOTS", "normal-dots" },
404 { GIMP_DASH_DENSE_DOTS, "GIMP_DASH_DENSE_DOTS", "dense-dots" },
405 { GIMP_DASH_STIPPLES, "GIMP_DASH_STIPPLES", "stipples" },
406 { GIMP_DASH_DASH_DOT, "GIMP_DASH_DASH_DOT", "dash-dot" },
407 { GIMP_DASH_DASH_DOT_DOT, "GIMP_DASH_DASH_DOT_DOT", "dash-dot-dot" },
408 { 0, NULL, NULL }
409 };
410
411 static const GimpEnumDesc descs[] =
412 {
413 { GIMP_DASH_CUSTOM, NC_("dash-preset", "Custom"), NULL },
414 { GIMP_DASH_LINE, NC_("dash-preset", "Line"), NULL },
415 { GIMP_DASH_LONG_DASH, NC_("dash-preset", "Long dashes"), NULL },
416 { GIMP_DASH_MEDIUM_DASH, NC_("dash-preset", "Medium dashes"), NULL },
417 { GIMP_DASH_SHORT_DASH, NC_("dash-preset", "Short dashes"), NULL },
418 { GIMP_DASH_SPARSE_DOTS, NC_("dash-preset", "Sparse dots"), NULL },
419 { GIMP_DASH_NORMAL_DOTS, NC_("dash-preset", "Normal dots"), NULL },
420 { GIMP_DASH_DENSE_DOTS, NC_("dash-preset", "Dense dots"), NULL },
421 { GIMP_DASH_STIPPLES, NC_("dash-preset", "Stipples"), NULL },
422 { GIMP_DASH_DASH_DOT, NC_("dash-preset", "Dash, dot"), NULL },
423 { GIMP_DASH_DASH_DOT_DOT, NC_("dash-preset", "Dash, dot, dot"), NULL },
424 { 0, NULL, NULL }
425 };
426
427 static GType type = 0;
428
429 if (G_UNLIKELY (! type))
430 {
431 type = g_enum_register_static ("GimpDashPreset", values);
432 gimp_type_set_translation_context (type, "dash-preset");
433 gimp_enum_set_value_descriptions (type, descs);
434 }
435
436 return type;
437 }
438
439 GType
gimp_debug_policy_get_type(void)440 gimp_debug_policy_get_type (void)
441 {
442 static const GEnumValue values[] =
443 {
444 { GIMP_DEBUG_POLICY_WARNING, "GIMP_DEBUG_POLICY_WARNING", "warning" },
445 { GIMP_DEBUG_POLICY_CRITICAL, "GIMP_DEBUG_POLICY_CRITICAL", "critical" },
446 { GIMP_DEBUG_POLICY_FATAL, "GIMP_DEBUG_POLICY_FATAL", "fatal" },
447 { GIMP_DEBUG_POLICY_NEVER, "GIMP_DEBUG_POLICY_NEVER", "never" },
448 { 0, NULL, NULL }
449 };
450
451 static const GimpEnumDesc descs[] =
452 {
453 { GIMP_DEBUG_POLICY_WARNING, NC_("debug-policy", "Debug warnings, critical errors and crashes"), NULL },
454 { GIMP_DEBUG_POLICY_CRITICAL, NC_("debug-policy", "Debug critical errors and crashes"), NULL },
455 { GIMP_DEBUG_POLICY_FATAL, NC_("debug-policy", "Debug crashes only"), NULL },
456 { GIMP_DEBUG_POLICY_NEVER, NC_("debug-policy", "Never debug GIMP"), NULL },
457 { 0, NULL, NULL }
458 };
459
460 static GType type = 0;
461
462 if (G_UNLIKELY (! type))
463 {
464 type = g_enum_register_static ("GimpDebugPolicy", values);
465 gimp_type_set_translation_context (type, "debug-policy");
466 gimp_enum_set_value_descriptions (type, descs);
467 }
468
469 return type;
470 }
471
472 GType
gimp_dirty_mask_get_type(void)473 gimp_dirty_mask_get_type (void)
474 {
475 static const GFlagsValue values[] =
476 {
477 { GIMP_DIRTY_NONE, "GIMP_DIRTY_NONE", "none" },
478 { GIMP_DIRTY_IMAGE, "GIMP_DIRTY_IMAGE", "image" },
479 { GIMP_DIRTY_IMAGE_SIZE, "GIMP_DIRTY_IMAGE_SIZE", "image-size" },
480 { GIMP_DIRTY_IMAGE_META, "GIMP_DIRTY_IMAGE_META", "image-meta" },
481 { GIMP_DIRTY_IMAGE_STRUCTURE, "GIMP_DIRTY_IMAGE_STRUCTURE", "image-structure" },
482 { GIMP_DIRTY_ITEM, "GIMP_DIRTY_ITEM", "item" },
483 { GIMP_DIRTY_ITEM_META, "GIMP_DIRTY_ITEM_META", "item-meta" },
484 { GIMP_DIRTY_DRAWABLE, "GIMP_DIRTY_DRAWABLE", "drawable" },
485 { GIMP_DIRTY_VECTORS, "GIMP_DIRTY_VECTORS", "vectors" },
486 { GIMP_DIRTY_SELECTION, "GIMP_DIRTY_SELECTION", "selection" },
487 { GIMP_DIRTY_ACTIVE_DRAWABLE, "GIMP_DIRTY_ACTIVE_DRAWABLE", "active-drawable" },
488 { GIMP_DIRTY_ALL, "GIMP_DIRTY_ALL", "all" },
489 { 0, NULL, NULL }
490 };
491
492 static const GimpFlagsDesc descs[] =
493 {
494 { GIMP_DIRTY_NONE, "GIMP_DIRTY_NONE", NULL },
495 { GIMP_DIRTY_IMAGE, "GIMP_DIRTY_IMAGE", NULL },
496 { GIMP_DIRTY_IMAGE_SIZE, "GIMP_DIRTY_IMAGE_SIZE", NULL },
497 { GIMP_DIRTY_IMAGE_META, "GIMP_DIRTY_IMAGE_META", NULL },
498 { GIMP_DIRTY_IMAGE_STRUCTURE, "GIMP_DIRTY_IMAGE_STRUCTURE", NULL },
499 { GIMP_DIRTY_ITEM, "GIMP_DIRTY_ITEM", NULL },
500 { GIMP_DIRTY_ITEM_META, "GIMP_DIRTY_ITEM_META", NULL },
501 { GIMP_DIRTY_DRAWABLE, "GIMP_DIRTY_DRAWABLE", NULL },
502 { GIMP_DIRTY_VECTORS, "GIMP_DIRTY_VECTORS", NULL },
503 { GIMP_DIRTY_SELECTION, "GIMP_DIRTY_SELECTION", NULL },
504 { GIMP_DIRTY_ACTIVE_DRAWABLE, "GIMP_DIRTY_ACTIVE_DRAWABLE", NULL },
505 { GIMP_DIRTY_ALL, "GIMP_DIRTY_ALL", NULL },
506 { 0, NULL, NULL }
507 };
508
509 static GType type = 0;
510
511 if (G_UNLIKELY (! type))
512 {
513 type = g_flags_register_static ("GimpDirtyMask", values);
514 gimp_type_set_translation_context (type, "dirty-mask");
515 gimp_flags_set_value_descriptions (type, descs);
516 }
517
518 return type;
519 }
520
521 GType
gimp_dynamics_output_type_get_type(void)522 gimp_dynamics_output_type_get_type (void)
523 {
524 static const GEnumValue values[] =
525 {
526 { GIMP_DYNAMICS_OUTPUT_OPACITY, "GIMP_DYNAMICS_OUTPUT_OPACITY", "opacity" },
527 { GIMP_DYNAMICS_OUTPUT_SIZE, "GIMP_DYNAMICS_OUTPUT_SIZE", "size" },
528 { GIMP_DYNAMICS_OUTPUT_ANGLE, "GIMP_DYNAMICS_OUTPUT_ANGLE", "angle" },
529 { GIMP_DYNAMICS_OUTPUT_COLOR, "GIMP_DYNAMICS_OUTPUT_COLOR", "color" },
530 { GIMP_DYNAMICS_OUTPUT_HARDNESS, "GIMP_DYNAMICS_OUTPUT_HARDNESS", "hardness" },
531 { GIMP_DYNAMICS_OUTPUT_FORCE, "GIMP_DYNAMICS_OUTPUT_FORCE", "force" },
532 { GIMP_DYNAMICS_OUTPUT_ASPECT_RATIO, "GIMP_DYNAMICS_OUTPUT_ASPECT_RATIO", "aspect-ratio" },
533 { GIMP_DYNAMICS_OUTPUT_SPACING, "GIMP_DYNAMICS_OUTPUT_SPACING", "spacing" },
534 { GIMP_DYNAMICS_OUTPUT_RATE, "GIMP_DYNAMICS_OUTPUT_RATE", "rate" },
535 { GIMP_DYNAMICS_OUTPUT_FLOW, "GIMP_DYNAMICS_OUTPUT_FLOW", "flow" },
536 { GIMP_DYNAMICS_OUTPUT_JITTER, "GIMP_DYNAMICS_OUTPUT_JITTER", "jitter" },
537 { 0, NULL, NULL }
538 };
539
540 static const GimpEnumDesc descs[] =
541 {
542 { GIMP_DYNAMICS_OUTPUT_OPACITY, NC_("dynamics-output-type", "Opacity"), NULL },
543 { GIMP_DYNAMICS_OUTPUT_SIZE, NC_("dynamics-output-type", "Size"), NULL },
544 { GIMP_DYNAMICS_OUTPUT_ANGLE, NC_("dynamics-output-type", "Angle"), NULL },
545 { GIMP_DYNAMICS_OUTPUT_COLOR, NC_("dynamics-output-type", "Color"), NULL },
546 { GIMP_DYNAMICS_OUTPUT_HARDNESS, NC_("dynamics-output-type", "Hardness"), NULL },
547 { GIMP_DYNAMICS_OUTPUT_FORCE, NC_("dynamics-output-type", "Force"), NULL },
548 { GIMP_DYNAMICS_OUTPUT_ASPECT_RATIO, NC_("dynamics-output-type", "Aspect ratio"), NULL },
549 { GIMP_DYNAMICS_OUTPUT_SPACING, NC_("dynamics-output-type", "Spacing"), NULL },
550 { GIMP_DYNAMICS_OUTPUT_RATE, NC_("dynamics-output-type", "Rate"), NULL },
551 { GIMP_DYNAMICS_OUTPUT_FLOW, NC_("dynamics-output-type", "Flow"), NULL },
552 { GIMP_DYNAMICS_OUTPUT_JITTER, NC_("dynamics-output-type", "Jitter"), NULL },
553 { 0, NULL, NULL }
554 };
555
556 static GType type = 0;
557
558 if (G_UNLIKELY (! type))
559 {
560 type = g_enum_register_static ("GimpDynamicsOutputType", values);
561 gimp_type_set_translation_context (type, "dynamics-output-type");
562 gimp_enum_set_value_descriptions (type, descs);
563 }
564
565 return type;
566 }
567
568 GType
gimp_fill_style_get_type(void)569 gimp_fill_style_get_type (void)
570 {
571 static const GEnumValue values[] =
572 {
573 { GIMP_FILL_STYLE_SOLID, "GIMP_FILL_STYLE_SOLID", "solid" },
574 { GIMP_FILL_STYLE_PATTERN, "GIMP_FILL_STYLE_PATTERN", "pattern" },
575 { 0, NULL, NULL }
576 };
577
578 static const GimpEnumDesc descs[] =
579 {
580 { GIMP_FILL_STYLE_SOLID, NC_("fill-style", "Solid color"), NULL },
581 { GIMP_FILL_STYLE_PATTERN, NC_("fill-style", "Pattern"), NULL },
582 { 0, NULL, NULL }
583 };
584
585 static GType type = 0;
586
587 if (G_UNLIKELY (! type))
588 {
589 type = g_enum_register_static ("GimpFillStyle", values);
590 gimp_type_set_translation_context (type, "fill-style");
591 gimp_enum_set_value_descriptions (type, descs);
592 }
593
594 return type;
595 }
596
597 GType
gimp_filter_region_get_type(void)598 gimp_filter_region_get_type (void)
599 {
600 static const GEnumValue values[] =
601 {
602 { GIMP_FILTER_REGION_SELECTION, "GIMP_FILTER_REGION_SELECTION", "selection" },
603 { GIMP_FILTER_REGION_DRAWABLE, "GIMP_FILTER_REGION_DRAWABLE", "drawable" },
604 { 0, NULL, NULL }
605 };
606
607 static const GimpEnumDesc descs[] =
608 {
609 { GIMP_FILTER_REGION_SELECTION, NC_("filter-region", "Use the selection as input"), NULL },
610 { GIMP_FILTER_REGION_DRAWABLE, NC_("filter-region", "Use the entire layer as input"), NULL },
611 { 0, NULL, NULL }
612 };
613
614 static GType type = 0;
615
616 if (G_UNLIKELY (! type))
617 {
618 type = g_enum_register_static ("GimpFilterRegion", values);
619 gimp_type_set_translation_context (type, "filter-region");
620 gimp_enum_set_value_descriptions (type, descs);
621 }
622
623 return type;
624 }
625
626 GType
gimp_gradient_color_get_type(void)627 gimp_gradient_color_get_type (void)
628 {
629 static const GEnumValue values[] =
630 {
631 { GIMP_GRADIENT_COLOR_FIXED, "GIMP_GRADIENT_COLOR_FIXED", "fixed" },
632 { GIMP_GRADIENT_COLOR_FOREGROUND, "GIMP_GRADIENT_COLOR_FOREGROUND", "foreground" },
633 { GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT", "foreground-transparent" },
634 { GIMP_GRADIENT_COLOR_BACKGROUND, "GIMP_GRADIENT_COLOR_BACKGROUND", "background" },
635 { GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT", "background-transparent" },
636 { 0, NULL, NULL }
637 };
638
639 static const GimpEnumDesc descs[] =
640 {
641 { GIMP_GRADIENT_COLOR_FIXED, NC_("gradient-color", "Fixed"), NULL },
642 { GIMP_GRADIENT_COLOR_FOREGROUND, NC_("gradient-color", "Foreground color"), NULL },
643 /* Translators: this is an abbreviated version of "Foreground color".
644 Keep it short. */
645 { GIMP_GRADIENT_COLOR_FOREGROUND, NC_("gradient-color", "FG"), NULL },
646 { GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, NC_("gradient-color", "Foreground color (transparent)"), NULL },
647 /* Translators: this is an abbreviated version of "Foreground color (transparent)".
648 Keep it short. */
649 { GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, NC_("gradient-color", "FG (t)"), NULL },
650 { GIMP_GRADIENT_COLOR_BACKGROUND, NC_("gradient-color", "Background color"), NULL },
651 /* Translators: this is an abbreviated version of "Background color".
652 Keep it short. */
653 { GIMP_GRADIENT_COLOR_BACKGROUND, NC_("gradient-color", "BG"), NULL },
654 { GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, NC_("gradient-color", "Background color (transparent)"), NULL },
655 /* Translators: this is an abbreviated version of "Background color (transparent)".
656 Keep it short. */
657 { GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, NC_("gradient-color", "BG (t)"), NULL },
658 { 0, NULL, NULL }
659 };
660
661 static GType type = 0;
662
663 if (G_UNLIKELY (! type))
664 {
665 type = g_enum_register_static ("GimpGradientColor", values);
666 gimp_type_set_translation_context (type, "gradient-color");
667 gimp_enum_set_value_descriptions (type, descs);
668 }
669
670 return type;
671 }
672
673 GType
gimp_gravity_type_get_type(void)674 gimp_gravity_type_get_type (void)
675 {
676 static const GEnumValue values[] =
677 {
678 { GIMP_GRAVITY_NONE, "GIMP_GRAVITY_NONE", "none" },
679 { GIMP_GRAVITY_NORTH_WEST, "GIMP_GRAVITY_NORTH_WEST", "north-west" },
680 { GIMP_GRAVITY_NORTH, "GIMP_GRAVITY_NORTH", "north" },
681 { GIMP_GRAVITY_NORTH_EAST, "GIMP_GRAVITY_NORTH_EAST", "north-east" },
682 { GIMP_GRAVITY_WEST, "GIMP_GRAVITY_WEST", "west" },
683 { GIMP_GRAVITY_CENTER, "GIMP_GRAVITY_CENTER", "center" },
684 { GIMP_GRAVITY_EAST, "GIMP_GRAVITY_EAST", "east" },
685 { GIMP_GRAVITY_SOUTH_WEST, "GIMP_GRAVITY_SOUTH_WEST", "south-west" },
686 { GIMP_GRAVITY_SOUTH, "GIMP_GRAVITY_SOUTH", "south" },
687 { GIMP_GRAVITY_SOUTH_EAST, "GIMP_GRAVITY_SOUTH_EAST", "south-east" },
688 { 0, NULL, NULL }
689 };
690
691 static const GimpEnumDesc descs[] =
692 {
693 { GIMP_GRAVITY_NONE, "GIMP_GRAVITY_NONE", NULL },
694 { GIMP_GRAVITY_NORTH_WEST, "GIMP_GRAVITY_NORTH_WEST", NULL },
695 { GIMP_GRAVITY_NORTH, "GIMP_GRAVITY_NORTH", NULL },
696 { GIMP_GRAVITY_NORTH_EAST, "GIMP_GRAVITY_NORTH_EAST", NULL },
697 { GIMP_GRAVITY_WEST, "GIMP_GRAVITY_WEST", NULL },
698 { GIMP_GRAVITY_CENTER, "GIMP_GRAVITY_CENTER", NULL },
699 { GIMP_GRAVITY_EAST, "GIMP_GRAVITY_EAST", NULL },
700 { GIMP_GRAVITY_SOUTH_WEST, "GIMP_GRAVITY_SOUTH_WEST", NULL },
701 { GIMP_GRAVITY_SOUTH, "GIMP_GRAVITY_SOUTH", NULL },
702 { GIMP_GRAVITY_SOUTH_EAST, "GIMP_GRAVITY_SOUTH_EAST", NULL },
703 { 0, NULL, NULL }
704 };
705
706 static GType type = 0;
707
708 if (G_UNLIKELY (! type))
709 {
710 type = g_enum_register_static ("GimpGravityType", values);
711 gimp_type_set_translation_context (type, "gravity-type");
712 gimp_enum_set_value_descriptions (type, descs);
713 }
714
715 return type;
716 }
717
718 GType
gimp_guide_style_get_type(void)719 gimp_guide_style_get_type (void)
720 {
721 static const GEnumValue values[] =
722 {
723 { GIMP_GUIDE_STYLE_NONE, "GIMP_GUIDE_STYLE_NONE", "none" },
724 { GIMP_GUIDE_STYLE_NORMAL, "GIMP_GUIDE_STYLE_NORMAL", "normal" },
725 { GIMP_GUIDE_STYLE_MIRROR, "GIMP_GUIDE_STYLE_MIRROR", "mirror" },
726 { GIMP_GUIDE_STYLE_MANDALA, "GIMP_GUIDE_STYLE_MANDALA", "mandala" },
727 { GIMP_GUIDE_STYLE_SPLIT_VIEW, "GIMP_GUIDE_STYLE_SPLIT_VIEW", "split-view" },
728 { 0, NULL, NULL }
729 };
730
731 static const GimpEnumDesc descs[] =
732 {
733 { GIMP_GUIDE_STYLE_NONE, "GIMP_GUIDE_STYLE_NONE", NULL },
734 { GIMP_GUIDE_STYLE_NORMAL, "GIMP_GUIDE_STYLE_NORMAL", NULL },
735 { GIMP_GUIDE_STYLE_MIRROR, "GIMP_GUIDE_STYLE_MIRROR", NULL },
736 { GIMP_GUIDE_STYLE_MANDALA, "GIMP_GUIDE_STYLE_MANDALA", NULL },
737 { GIMP_GUIDE_STYLE_SPLIT_VIEW, "GIMP_GUIDE_STYLE_SPLIT_VIEW", NULL },
738 { 0, NULL, NULL }
739 };
740
741 static GType type = 0;
742
743 if (G_UNLIKELY (! type))
744 {
745 type = g_enum_register_static ("GimpGuideStyle", values);
746 gimp_type_set_translation_context (type, "guide-style");
747 gimp_enum_set_value_descriptions (type, descs);
748 }
749
750 return type;
751 }
752
753 GType
gimp_histogram_channel_get_type(void)754 gimp_histogram_channel_get_type (void)
755 {
756 static const GEnumValue values[] =
757 {
758 { GIMP_HISTOGRAM_VALUE, "GIMP_HISTOGRAM_VALUE", "value" },
759 { GIMP_HISTOGRAM_RED, "GIMP_HISTOGRAM_RED", "red" },
760 { GIMP_HISTOGRAM_GREEN, "GIMP_HISTOGRAM_GREEN", "green" },
761 { GIMP_HISTOGRAM_BLUE, "GIMP_HISTOGRAM_BLUE", "blue" },
762 { GIMP_HISTOGRAM_ALPHA, "GIMP_HISTOGRAM_ALPHA", "alpha" },
763 { GIMP_HISTOGRAM_LUMINANCE, "GIMP_HISTOGRAM_LUMINANCE", "luminance" },
764 { GIMP_HISTOGRAM_RGB, "GIMP_HISTOGRAM_RGB", "rgb" },
765 { 0, NULL, NULL }
766 };
767
768 static const GimpEnumDesc descs[] =
769 {
770 { GIMP_HISTOGRAM_VALUE, NC_("histogram-channel", "Value"), NULL },
771 { GIMP_HISTOGRAM_RED, NC_("histogram-channel", "Red"), NULL },
772 { GIMP_HISTOGRAM_GREEN, NC_("histogram-channel", "Green"), NULL },
773 { GIMP_HISTOGRAM_BLUE, NC_("histogram-channel", "Blue"), NULL },
774 { GIMP_HISTOGRAM_ALPHA, NC_("histogram-channel", "Alpha"), NULL },
775 { GIMP_HISTOGRAM_LUMINANCE, NC_("histogram-channel", "Luminance"), NULL },
776 { GIMP_HISTOGRAM_RGB, NC_("histogram-channel", "RGB"), NULL },
777 { 0, NULL, NULL }
778 };
779
780 static GType type = 0;
781
782 if (G_UNLIKELY (! type))
783 {
784 type = g_enum_register_static ("GimpHistogramChannel", values);
785 gimp_type_set_translation_context (type, "histogram-channel");
786 gimp_enum_set_value_descriptions (type, descs);
787 }
788
789 return type;
790 }
791
792 GType
gimp_item_set_get_type(void)793 gimp_item_set_get_type (void)
794 {
795 static const GEnumValue values[] =
796 {
797 { GIMP_ITEM_SET_NONE, "GIMP_ITEM_SET_NONE", "none" },
798 { GIMP_ITEM_SET_ALL, "GIMP_ITEM_SET_ALL", "all" },
799 { GIMP_ITEM_SET_IMAGE_SIZED, "GIMP_ITEM_SET_IMAGE_SIZED", "image-sized" },
800 { GIMP_ITEM_SET_VISIBLE, "GIMP_ITEM_SET_VISIBLE", "visible" },
801 { GIMP_ITEM_SET_LINKED, "GIMP_ITEM_SET_LINKED", "linked" },
802 { 0, NULL, NULL }
803 };
804
805 static const GimpEnumDesc descs[] =
806 {
807 { GIMP_ITEM_SET_NONE, NC_("item-set", "None"), NULL },
808 { GIMP_ITEM_SET_ALL, NC_("item-set", "All layers"), NULL },
809 { GIMP_ITEM_SET_IMAGE_SIZED, NC_("item-set", "Image-sized layers"), NULL },
810 { GIMP_ITEM_SET_VISIBLE, NC_("item-set", "All visible layers"), NULL },
811 { GIMP_ITEM_SET_LINKED, NC_("item-set", "All linked layers"), NULL },
812 { 0, NULL, NULL }
813 };
814
815 static GType type = 0;
816
817 if (G_UNLIKELY (! type))
818 {
819 type = g_enum_register_static ("GimpItemSet", values);
820 gimp_type_set_translation_context (type, "item-set");
821 gimp_enum_set_value_descriptions (type, descs);
822 }
823
824 return type;
825 }
826
827 GType
gimp_matting_engine_get_type(void)828 gimp_matting_engine_get_type (void)
829 {
830 static const GEnumValue values[] =
831 {
832 { GIMP_MATTING_ENGINE_GLOBAL, "GIMP_MATTING_ENGINE_GLOBAL", "global" },
833 { GIMP_MATTING_ENGINE_LEVIN, "GIMP_MATTING_ENGINE_LEVIN", "levin" },
834 { 0, NULL, NULL }
835 };
836
837 static const GimpEnumDesc descs[] =
838 {
839 { GIMP_MATTING_ENGINE_GLOBAL, NC_("matting-engine", "Matting Global"), NULL },
840 { GIMP_MATTING_ENGINE_LEVIN, NC_("matting-engine", "Matting Levin"), NULL },
841 { 0, NULL, NULL }
842 };
843
844 static GType type = 0;
845
846 if (G_UNLIKELY (! type))
847 {
848 type = g_enum_register_static ("GimpMattingEngine", values);
849 gimp_type_set_translation_context (type, "matting-engine");
850 gimp_enum_set_value_descriptions (type, descs);
851 }
852
853 return type;
854 }
855
856 GType
gimp_message_severity_get_type(void)857 gimp_message_severity_get_type (void)
858 {
859 static const GEnumValue values[] =
860 {
861 { GIMP_MESSAGE_INFO, "GIMP_MESSAGE_INFO", "info" },
862 { GIMP_MESSAGE_WARNING, "GIMP_MESSAGE_WARNING", "warning" },
863 { GIMP_MESSAGE_ERROR, "GIMP_MESSAGE_ERROR", "error" },
864 { GIMP_MESSAGE_BUG_WARNING, "GIMP_MESSAGE_BUG_WARNING", "bug-warning" },
865 { GIMP_MESSAGE_BUG_CRITICAL, "GIMP_MESSAGE_BUG_CRITICAL", "bug-critical" },
866 { 0, NULL, NULL }
867 };
868
869 static const GimpEnumDesc descs[] =
870 {
871 { GIMP_MESSAGE_INFO, NC_("message-severity", "Message"), NULL },
872 { GIMP_MESSAGE_WARNING, NC_("message-severity", "Warning"), NULL },
873 { GIMP_MESSAGE_ERROR, NC_("message-severity", "Error"), NULL },
874 { GIMP_MESSAGE_BUG_WARNING, NC_("message-severity", "WARNING"), NULL },
875 { GIMP_MESSAGE_BUG_CRITICAL, NC_("message-severity", "CRITICAL"), NULL },
876 { 0, NULL, NULL }
877 };
878
879 static GType type = 0;
880
881 if (G_UNLIKELY (! type))
882 {
883 type = g_enum_register_static ("GimpMessageSeverity", values);
884 gimp_type_set_translation_context (type, "message-severity");
885 gimp_enum_set_value_descriptions (type, descs);
886 }
887
888 return type;
889 }
890
891 GType
gimp_paste_type_get_type(void)892 gimp_paste_type_get_type (void)
893 {
894 static const GEnumValue values[] =
895 {
896 { GIMP_PASTE_TYPE_FLOATING, "GIMP_PASTE_TYPE_FLOATING", "floating" },
897 { GIMP_PASTE_TYPE_FLOATING_IN_PLACE, "GIMP_PASTE_TYPE_FLOATING_IN_PLACE", "floating-in-place" },
898 { GIMP_PASTE_TYPE_FLOATING_INTO, "GIMP_PASTE_TYPE_FLOATING_INTO", "floating-into" },
899 { GIMP_PASTE_TYPE_FLOATING_INTO_IN_PLACE, "GIMP_PASTE_TYPE_FLOATING_INTO_IN_PLACE", "floating-into-in-place" },
900 { GIMP_PASTE_TYPE_NEW_LAYER, "GIMP_PASTE_TYPE_NEW_LAYER", "new-layer" },
901 { GIMP_PASTE_TYPE_NEW_LAYER_IN_PLACE, "GIMP_PASTE_TYPE_NEW_LAYER_IN_PLACE", "new-layer-in-place" },
902 { 0, NULL, NULL }
903 };
904
905 static const GimpEnumDesc descs[] =
906 {
907 { GIMP_PASTE_TYPE_FLOATING, "GIMP_PASTE_TYPE_FLOATING", NULL },
908 { GIMP_PASTE_TYPE_FLOATING_IN_PLACE, "GIMP_PASTE_TYPE_FLOATING_IN_PLACE", NULL },
909 { GIMP_PASTE_TYPE_FLOATING_INTO, "GIMP_PASTE_TYPE_FLOATING_INTO", NULL },
910 { GIMP_PASTE_TYPE_FLOATING_INTO_IN_PLACE, "GIMP_PASTE_TYPE_FLOATING_INTO_IN_PLACE", NULL },
911 { GIMP_PASTE_TYPE_NEW_LAYER, "GIMP_PASTE_TYPE_NEW_LAYER", NULL },
912 { GIMP_PASTE_TYPE_NEW_LAYER_IN_PLACE, "GIMP_PASTE_TYPE_NEW_LAYER_IN_PLACE", NULL },
913 { 0, NULL, NULL }
914 };
915
916 static GType type = 0;
917
918 if (G_UNLIKELY (! type))
919 {
920 type = g_enum_register_static ("GimpPasteType", values);
921 gimp_type_set_translation_context (type, "paste-type");
922 gimp_enum_set_value_descriptions (type, descs);
923 }
924
925 return type;
926 }
927
928 GType
gimp_thumbnail_size_get_type(void)929 gimp_thumbnail_size_get_type (void)
930 {
931 static const GEnumValue values[] =
932 {
933 { GIMP_THUMBNAIL_SIZE_NONE, "GIMP_THUMBNAIL_SIZE_NONE", "none" },
934 { GIMP_THUMBNAIL_SIZE_NORMAL, "GIMP_THUMBNAIL_SIZE_NORMAL", "normal" },
935 { GIMP_THUMBNAIL_SIZE_LARGE, "GIMP_THUMBNAIL_SIZE_LARGE", "large" },
936 { 0, NULL, NULL }
937 };
938
939 static const GimpEnumDesc descs[] =
940 {
941 { GIMP_THUMBNAIL_SIZE_NONE, NC_("thumbnail-size", "No thumbnails"), NULL },
942 { GIMP_THUMBNAIL_SIZE_NORMAL, NC_("thumbnail-size", "Normal (128x128)"), NULL },
943 { GIMP_THUMBNAIL_SIZE_LARGE, NC_("thumbnail-size", "Large (256x256)"), NULL },
944 { 0, NULL, NULL }
945 };
946
947 static GType type = 0;
948
949 if (G_UNLIKELY (! type))
950 {
951 type = g_enum_register_static ("GimpThumbnailSize", values);
952 gimp_type_set_translation_context (type, "thumbnail-size");
953 gimp_enum_set_value_descriptions (type, descs);
954 }
955
956 return type;
957 }
958
959 GType
gimp_undo_event_get_type(void)960 gimp_undo_event_get_type (void)
961 {
962 static const GEnumValue values[] =
963 {
964 { GIMP_UNDO_EVENT_UNDO_PUSHED, "GIMP_UNDO_EVENT_UNDO_PUSHED", "undo-pushed" },
965 { GIMP_UNDO_EVENT_UNDO_EXPIRED, "GIMP_UNDO_EVENT_UNDO_EXPIRED", "undo-expired" },
966 { GIMP_UNDO_EVENT_REDO_EXPIRED, "GIMP_UNDO_EVENT_REDO_EXPIRED", "redo-expired" },
967 { GIMP_UNDO_EVENT_UNDO, "GIMP_UNDO_EVENT_UNDO", "undo" },
968 { GIMP_UNDO_EVENT_REDO, "GIMP_UNDO_EVENT_REDO", "redo" },
969 { GIMP_UNDO_EVENT_UNDO_FREE, "GIMP_UNDO_EVENT_UNDO_FREE", "undo-free" },
970 { GIMP_UNDO_EVENT_UNDO_FREEZE, "GIMP_UNDO_EVENT_UNDO_FREEZE", "undo-freeze" },
971 { GIMP_UNDO_EVENT_UNDO_THAW, "GIMP_UNDO_EVENT_UNDO_THAW", "undo-thaw" },
972 { 0, NULL, NULL }
973 };
974
975 static const GimpEnumDesc descs[] =
976 {
977 { GIMP_UNDO_EVENT_UNDO_PUSHED, "GIMP_UNDO_EVENT_UNDO_PUSHED", NULL },
978 { GIMP_UNDO_EVENT_UNDO_EXPIRED, "GIMP_UNDO_EVENT_UNDO_EXPIRED", NULL },
979 { GIMP_UNDO_EVENT_REDO_EXPIRED, "GIMP_UNDO_EVENT_REDO_EXPIRED", NULL },
980 { GIMP_UNDO_EVENT_UNDO, "GIMP_UNDO_EVENT_UNDO", NULL },
981 { GIMP_UNDO_EVENT_REDO, "GIMP_UNDO_EVENT_REDO", NULL },
982 { GIMP_UNDO_EVENT_UNDO_FREE, "GIMP_UNDO_EVENT_UNDO_FREE", NULL },
983 { GIMP_UNDO_EVENT_UNDO_FREEZE, "GIMP_UNDO_EVENT_UNDO_FREEZE", NULL },
984 { GIMP_UNDO_EVENT_UNDO_THAW, "GIMP_UNDO_EVENT_UNDO_THAW", NULL },
985 { 0, NULL, NULL }
986 };
987
988 static GType type = 0;
989
990 if (G_UNLIKELY (! type))
991 {
992 type = g_enum_register_static ("GimpUndoEvent", values);
993 gimp_type_set_translation_context (type, "undo-event");
994 gimp_enum_set_value_descriptions (type, descs);
995 }
996
997 return type;
998 }
999
1000 GType
gimp_undo_mode_get_type(void)1001 gimp_undo_mode_get_type (void)
1002 {
1003 static const GEnumValue values[] =
1004 {
1005 { GIMP_UNDO_MODE_UNDO, "GIMP_UNDO_MODE_UNDO", "undo" },
1006 { GIMP_UNDO_MODE_REDO, "GIMP_UNDO_MODE_REDO", "redo" },
1007 { 0, NULL, NULL }
1008 };
1009
1010 static const GimpEnumDesc descs[] =
1011 {
1012 { GIMP_UNDO_MODE_UNDO, "GIMP_UNDO_MODE_UNDO", NULL },
1013 { GIMP_UNDO_MODE_REDO, "GIMP_UNDO_MODE_REDO", NULL },
1014 { 0, NULL, NULL }
1015 };
1016
1017 static GType type = 0;
1018
1019 if (G_UNLIKELY (! type))
1020 {
1021 type = g_enum_register_static ("GimpUndoMode", values);
1022 gimp_type_set_translation_context (type, "undo-mode");
1023 gimp_enum_set_value_descriptions (type, descs);
1024 }
1025
1026 return type;
1027 }
1028
1029 GType
gimp_undo_type_get_type(void)1030 gimp_undo_type_get_type (void)
1031 {
1032 static const GEnumValue values[] =
1033 {
1034 { GIMP_UNDO_GROUP_NONE, "GIMP_UNDO_GROUP_NONE", "group-none" },
1035 { GIMP_UNDO_GROUP_IMAGE_SCALE, "GIMP_UNDO_GROUP_IMAGE_SCALE", "group-image-scale" },
1036 { GIMP_UNDO_GROUP_IMAGE_RESIZE, "GIMP_UNDO_GROUP_IMAGE_RESIZE", "group-image-resize" },
1037 { GIMP_UNDO_GROUP_IMAGE_FLIP, "GIMP_UNDO_GROUP_IMAGE_FLIP", "group-image-flip" },
1038 { GIMP_UNDO_GROUP_IMAGE_ROTATE, "GIMP_UNDO_GROUP_IMAGE_ROTATE", "group-image-rotate" },
1039 { GIMP_UNDO_GROUP_IMAGE_TRANSFORM, "GIMP_UNDO_GROUP_IMAGE_TRANSFORM", "group-image-transform" },
1040 { GIMP_UNDO_GROUP_IMAGE_CROP, "GIMP_UNDO_GROUP_IMAGE_CROP", "group-image-crop" },
1041 { GIMP_UNDO_GROUP_IMAGE_CONVERT, "GIMP_UNDO_GROUP_IMAGE_CONVERT", "group-image-convert" },
1042 { GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, "GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE", "group-image-item-remove" },
1043 { GIMP_UNDO_GROUP_IMAGE_ITEM_REORDER, "GIMP_UNDO_GROUP_IMAGE_ITEM_REORDER", "group-image-item-reorder" },
1044 { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, "GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE", "group-image-layers-merge" },
1045 { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, "GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE", "group-image-vectors-merge" },
1046 { GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, "GIMP_UNDO_GROUP_IMAGE_QUICK_MASK", "group-image-quick-mask" },
1047 { GIMP_UNDO_GROUP_IMAGE_GRID, "GIMP_UNDO_GROUP_IMAGE_GRID", "group-image-grid" },
1048 { GIMP_UNDO_GROUP_GUIDE, "GIMP_UNDO_GROUP_GUIDE", "group-guide" },
1049 { GIMP_UNDO_GROUP_SAMPLE_POINT, "GIMP_UNDO_GROUP_SAMPLE_POINT", "group-sample-point" },
1050 { GIMP_UNDO_GROUP_DRAWABLE, "GIMP_UNDO_GROUP_DRAWABLE", "group-drawable" },
1051 { GIMP_UNDO_GROUP_DRAWABLE_MOD, "GIMP_UNDO_GROUP_DRAWABLE_MOD", "group-drawable-mod" },
1052 { GIMP_UNDO_GROUP_MASK, "GIMP_UNDO_GROUP_MASK", "group-mask" },
1053 { GIMP_UNDO_GROUP_ITEM_VISIBILITY, "GIMP_UNDO_GROUP_ITEM_VISIBILITY", "group-item-visibility" },
1054 { GIMP_UNDO_GROUP_ITEM_LINKED, "GIMP_UNDO_GROUP_ITEM_LINKED", "group-item-linked" },
1055 { GIMP_UNDO_GROUP_ITEM_PROPERTIES, "GIMP_UNDO_GROUP_ITEM_PROPERTIES", "group-item-properties" },
1056 { GIMP_UNDO_GROUP_ITEM_DISPLACE, "GIMP_UNDO_GROUP_ITEM_DISPLACE", "group-item-displace" },
1057 { GIMP_UNDO_GROUP_ITEM_SCALE, "GIMP_UNDO_GROUP_ITEM_SCALE", "group-item-scale" },
1058 { GIMP_UNDO_GROUP_ITEM_RESIZE, "GIMP_UNDO_GROUP_ITEM_RESIZE", "group-item-resize" },
1059 { GIMP_UNDO_GROUP_LAYER_ADD, "GIMP_UNDO_GROUP_LAYER_ADD", "group-layer-add" },
1060 { GIMP_UNDO_GROUP_LAYER_ADD_MASK, "GIMP_UNDO_GROUP_LAYER_ADD_MASK", "group-layer-add-mask" },
1061 { GIMP_UNDO_GROUP_LAYER_APPLY_MASK, "GIMP_UNDO_GROUP_LAYER_APPLY_MASK", "group-layer-apply-mask" },
1062 { GIMP_UNDO_GROUP_FS_TO_LAYER, "GIMP_UNDO_GROUP_FS_TO_LAYER", "group-fs-to-layer" },
1063 { GIMP_UNDO_GROUP_FS_FLOAT, "GIMP_UNDO_GROUP_FS_FLOAT", "group-fs-float" },
1064 { GIMP_UNDO_GROUP_FS_ANCHOR, "GIMP_UNDO_GROUP_FS_ANCHOR", "group-fs-anchor" },
1065 { GIMP_UNDO_GROUP_EDIT_PASTE, "GIMP_UNDO_GROUP_EDIT_PASTE", "group-edit-paste" },
1066 { GIMP_UNDO_GROUP_EDIT_CUT, "GIMP_UNDO_GROUP_EDIT_CUT", "group-edit-cut" },
1067 { GIMP_UNDO_GROUP_TEXT, "GIMP_UNDO_GROUP_TEXT", "group-text" },
1068 { GIMP_UNDO_GROUP_TRANSFORM, "GIMP_UNDO_GROUP_TRANSFORM", "group-transform" },
1069 { GIMP_UNDO_GROUP_PAINT, "GIMP_UNDO_GROUP_PAINT", "group-paint" },
1070 { GIMP_UNDO_GROUP_PARASITE_ATTACH, "GIMP_UNDO_GROUP_PARASITE_ATTACH", "group-parasite-attach" },
1071 { GIMP_UNDO_GROUP_PARASITE_REMOVE, "GIMP_UNDO_GROUP_PARASITE_REMOVE", "group-parasite-remove" },
1072 { GIMP_UNDO_GROUP_VECTORS_IMPORT, "GIMP_UNDO_GROUP_VECTORS_IMPORT", "group-vectors-import" },
1073 { GIMP_UNDO_GROUP_MISC, "GIMP_UNDO_GROUP_MISC", "group-misc" },
1074 { GIMP_UNDO_IMAGE_TYPE, "GIMP_UNDO_IMAGE_TYPE", "image-type" },
1075 { GIMP_UNDO_IMAGE_PRECISION, "GIMP_UNDO_IMAGE_PRECISION", "image-precision" },
1076 { GIMP_UNDO_IMAGE_SIZE, "GIMP_UNDO_IMAGE_SIZE", "image-size" },
1077 { GIMP_UNDO_IMAGE_RESOLUTION, "GIMP_UNDO_IMAGE_RESOLUTION", "image-resolution" },
1078 { GIMP_UNDO_IMAGE_GRID, "GIMP_UNDO_IMAGE_GRID", "image-grid" },
1079 { GIMP_UNDO_IMAGE_METADATA, "GIMP_UNDO_IMAGE_METADATA", "image-metadata" },
1080 { GIMP_UNDO_IMAGE_COLORMAP, "GIMP_UNDO_IMAGE_COLORMAP", "image-colormap" },
1081 { GIMP_UNDO_IMAGE_COLOR_MANAGED, "GIMP_UNDO_IMAGE_COLOR_MANAGED", "image-color-managed" },
1082 { GIMP_UNDO_GUIDE, "GIMP_UNDO_GUIDE", "guide" },
1083 { GIMP_UNDO_SAMPLE_POINT, "GIMP_UNDO_SAMPLE_POINT", "sample-point" },
1084 { GIMP_UNDO_DRAWABLE, "GIMP_UNDO_DRAWABLE", "drawable" },
1085 { GIMP_UNDO_DRAWABLE_MOD, "GIMP_UNDO_DRAWABLE_MOD", "drawable-mod" },
1086 { GIMP_UNDO_MASK, "GIMP_UNDO_MASK", "mask" },
1087 { GIMP_UNDO_ITEM_REORDER, "GIMP_UNDO_ITEM_REORDER", "item-reorder" },
1088 { GIMP_UNDO_ITEM_RENAME, "GIMP_UNDO_ITEM_RENAME", "item-rename" },
1089 { GIMP_UNDO_ITEM_DISPLACE, "GIMP_UNDO_ITEM_DISPLACE", "item-displace" },
1090 { GIMP_UNDO_ITEM_VISIBILITY, "GIMP_UNDO_ITEM_VISIBILITY", "item-visibility" },
1091 { GIMP_UNDO_ITEM_LINKED, "GIMP_UNDO_ITEM_LINKED", "item-linked" },
1092 { GIMP_UNDO_ITEM_COLOR_TAG, "GIMP_UNDO_ITEM_COLOR_TAG", "item-color-tag" },
1093 { GIMP_UNDO_ITEM_LOCK_CONTENT, "GIMP_UNDO_ITEM_LOCK_CONTENT", "item-lock-content" },
1094 { GIMP_UNDO_ITEM_LOCK_POSITION, "GIMP_UNDO_ITEM_LOCK_POSITION", "item-lock-position" },
1095 { GIMP_UNDO_LAYER_ADD, "GIMP_UNDO_LAYER_ADD", "layer-add" },
1096 { GIMP_UNDO_LAYER_REMOVE, "GIMP_UNDO_LAYER_REMOVE", "layer-remove" },
1097 { GIMP_UNDO_LAYER_MODE, "GIMP_UNDO_LAYER_MODE", "layer-mode" },
1098 { GIMP_UNDO_LAYER_OPACITY, "GIMP_UNDO_LAYER_OPACITY", "layer-opacity" },
1099 { GIMP_UNDO_LAYER_LOCK_ALPHA, "GIMP_UNDO_LAYER_LOCK_ALPHA", "layer-lock-alpha" },
1100 { GIMP_UNDO_GROUP_LAYER_SUSPEND_RESIZE, "GIMP_UNDO_GROUP_LAYER_SUSPEND_RESIZE", "group-layer-suspend-resize" },
1101 { GIMP_UNDO_GROUP_LAYER_RESUME_RESIZE, "GIMP_UNDO_GROUP_LAYER_RESUME_RESIZE", "group-layer-resume-resize" },
1102 { GIMP_UNDO_GROUP_LAYER_SUSPEND_MASK, "GIMP_UNDO_GROUP_LAYER_SUSPEND_MASK", "group-layer-suspend-mask" },
1103 { GIMP_UNDO_GROUP_LAYER_RESUME_MASK, "GIMP_UNDO_GROUP_LAYER_RESUME_MASK", "group-layer-resume-mask" },
1104 { GIMP_UNDO_GROUP_LAYER_START_TRANSFORM, "GIMP_UNDO_GROUP_LAYER_START_TRANSFORM", "group-layer-start-transform" },
1105 { GIMP_UNDO_GROUP_LAYER_END_TRANSFORM, "GIMP_UNDO_GROUP_LAYER_END_TRANSFORM", "group-layer-end-transform" },
1106 { GIMP_UNDO_GROUP_LAYER_CONVERT, "GIMP_UNDO_GROUP_LAYER_CONVERT", "group-layer-convert" },
1107 { GIMP_UNDO_TEXT_LAYER, "GIMP_UNDO_TEXT_LAYER", "text-layer" },
1108 { GIMP_UNDO_TEXT_LAYER_MODIFIED, "GIMP_UNDO_TEXT_LAYER_MODIFIED", "text-layer-modified" },
1109 { GIMP_UNDO_TEXT_LAYER_CONVERT, "GIMP_UNDO_TEXT_LAYER_CONVERT", "text-layer-convert" },
1110 { GIMP_UNDO_LAYER_MASK_ADD, "GIMP_UNDO_LAYER_MASK_ADD", "layer-mask-add" },
1111 { GIMP_UNDO_LAYER_MASK_REMOVE, "GIMP_UNDO_LAYER_MASK_REMOVE", "layer-mask-remove" },
1112 { GIMP_UNDO_LAYER_MASK_APPLY, "GIMP_UNDO_LAYER_MASK_APPLY", "layer-mask-apply" },
1113 { GIMP_UNDO_LAYER_MASK_SHOW, "GIMP_UNDO_LAYER_MASK_SHOW", "layer-mask-show" },
1114 { GIMP_UNDO_CHANNEL_ADD, "GIMP_UNDO_CHANNEL_ADD", "channel-add" },
1115 { GIMP_UNDO_CHANNEL_REMOVE, "GIMP_UNDO_CHANNEL_REMOVE", "channel-remove" },
1116 { GIMP_UNDO_CHANNEL_COLOR, "GIMP_UNDO_CHANNEL_COLOR", "channel-color" },
1117 { GIMP_UNDO_VECTORS_ADD, "GIMP_UNDO_VECTORS_ADD", "vectors-add" },
1118 { GIMP_UNDO_VECTORS_REMOVE, "GIMP_UNDO_VECTORS_REMOVE", "vectors-remove" },
1119 { GIMP_UNDO_VECTORS_MOD, "GIMP_UNDO_VECTORS_MOD", "vectors-mod" },
1120 { GIMP_UNDO_FS_TO_LAYER, "GIMP_UNDO_FS_TO_LAYER", "fs-to-layer" },
1121 { GIMP_UNDO_TRANSFORM_GRID, "GIMP_UNDO_TRANSFORM_GRID", "transform-grid" },
1122 { GIMP_UNDO_PAINT, "GIMP_UNDO_PAINT", "paint" },
1123 { GIMP_UNDO_INK, "GIMP_UNDO_INK", "ink" },
1124 { GIMP_UNDO_FOREGROUND_SELECT, "GIMP_UNDO_FOREGROUND_SELECT", "foreground-select" },
1125 { GIMP_UNDO_PARASITE_ATTACH, "GIMP_UNDO_PARASITE_ATTACH", "parasite-attach" },
1126 { GIMP_UNDO_PARASITE_REMOVE, "GIMP_UNDO_PARASITE_REMOVE", "parasite-remove" },
1127 { GIMP_UNDO_CANT, "GIMP_UNDO_CANT", "cant" },
1128 { 0, NULL, NULL }
1129 };
1130
1131 static const GimpEnumDesc descs[] =
1132 {
1133 { GIMP_UNDO_GROUP_NONE, NC_("undo-type", "<<invalid>>"), NULL },
1134 { GIMP_UNDO_GROUP_IMAGE_SCALE, NC_("undo-type", "Scale image"), NULL },
1135 { GIMP_UNDO_GROUP_IMAGE_RESIZE, NC_("undo-type", "Resize image"), NULL },
1136 { GIMP_UNDO_GROUP_IMAGE_FLIP, NC_("undo-type", "Flip image"), NULL },
1137 { GIMP_UNDO_GROUP_IMAGE_ROTATE, NC_("undo-type", "Rotate image"), NULL },
1138 { GIMP_UNDO_GROUP_IMAGE_TRANSFORM, NC_("undo-type", "Transform image"), NULL },
1139 { GIMP_UNDO_GROUP_IMAGE_CROP, NC_("undo-type", "Crop image"), NULL },
1140 { GIMP_UNDO_GROUP_IMAGE_CONVERT, NC_("undo-type", "Convert image"), NULL },
1141 { GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, NC_("undo-type", "Remove item"), NULL },
1142 { GIMP_UNDO_GROUP_IMAGE_ITEM_REORDER, NC_("undo-type", "Reorder item"), NULL },
1143 { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, NC_("undo-type", "Merge layers"), NULL },
1144 { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, NC_("undo-type", "Merge paths"), NULL },
1145 { GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, NC_("undo-type", "Quick Mask"), NULL },
1146 { GIMP_UNDO_GROUP_IMAGE_GRID, NC_("undo-type", "Grid"), NULL },
1147 { GIMP_UNDO_GROUP_GUIDE, NC_("undo-type", "Guide"), NULL },
1148 { GIMP_UNDO_GROUP_SAMPLE_POINT, NC_("undo-type", "Sample Point"), NULL },
1149 { GIMP_UNDO_GROUP_DRAWABLE, NC_("undo-type", "Layer/Channel"), NULL },
1150 { GIMP_UNDO_GROUP_DRAWABLE_MOD, NC_("undo-type", "Layer/Channel modification"), NULL },
1151 { GIMP_UNDO_GROUP_MASK, NC_("undo-type", "Selection mask"), NULL },
1152 { GIMP_UNDO_GROUP_ITEM_VISIBILITY, NC_("undo-type", "Item visibility"), NULL },
1153 { GIMP_UNDO_GROUP_ITEM_LINKED, NC_("undo-type", "Link/Unlink item"), NULL },
1154 { GIMP_UNDO_GROUP_ITEM_PROPERTIES, NC_("undo-type", "Item properties"), NULL },
1155 { GIMP_UNDO_GROUP_ITEM_DISPLACE, NC_("undo-type", "Move item"), NULL },
1156 { GIMP_UNDO_GROUP_ITEM_SCALE, NC_("undo-type", "Scale item"), NULL },
1157 { GIMP_UNDO_GROUP_ITEM_RESIZE, NC_("undo-type", "Resize item"), NULL },
1158 { GIMP_UNDO_GROUP_LAYER_ADD, NC_("undo-type", "Add layer"), NULL },
1159 { GIMP_UNDO_GROUP_LAYER_ADD_MASK, NC_("undo-type", "Add layer mask"), NULL },
1160 { GIMP_UNDO_GROUP_LAYER_APPLY_MASK, NC_("undo-type", "Apply layer mask"), NULL },
1161 { GIMP_UNDO_GROUP_FS_TO_LAYER, NC_("undo-type", "Floating selection to layer"), NULL },
1162 { GIMP_UNDO_GROUP_FS_FLOAT, NC_("undo-type", "Float selection"), NULL },
1163 { GIMP_UNDO_GROUP_FS_ANCHOR, NC_("undo-type", "Anchor floating selection"), NULL },
1164 { GIMP_UNDO_GROUP_EDIT_PASTE, NC_("undo-type", "Paste"), NULL },
1165 { GIMP_UNDO_GROUP_EDIT_CUT, NC_("undo-type", "Cut"), NULL },
1166 { GIMP_UNDO_GROUP_TEXT, NC_("undo-type", "Text"), NULL },
1167 { GIMP_UNDO_GROUP_TRANSFORM, NC_("undo-type", "Transform"), NULL },
1168 { GIMP_UNDO_GROUP_PAINT, NC_("undo-type", "Paint"), NULL },
1169 { GIMP_UNDO_GROUP_PARASITE_ATTACH, NC_("undo-type", "Attach parasite"), NULL },
1170 { GIMP_UNDO_GROUP_PARASITE_REMOVE, NC_("undo-type", "Remove parasite"), NULL },
1171 { GIMP_UNDO_GROUP_VECTORS_IMPORT, NC_("undo-type", "Import paths"), NULL },
1172 { GIMP_UNDO_GROUP_MISC, NC_("undo-type", "Plug-In"), NULL },
1173 { GIMP_UNDO_IMAGE_TYPE, NC_("undo-type", "Image type"), NULL },
1174 { GIMP_UNDO_IMAGE_PRECISION, NC_("undo-type", "Image precision"), NULL },
1175 { GIMP_UNDO_IMAGE_SIZE, NC_("undo-type", "Image size"), NULL },
1176 { GIMP_UNDO_IMAGE_RESOLUTION, NC_("undo-type", "Image resolution change"), NULL },
1177 { GIMP_UNDO_IMAGE_GRID, NC_("undo-type", "Grid"), NULL },
1178 { GIMP_UNDO_IMAGE_METADATA, NC_("undo-type", "Change metadata"), NULL },
1179 { GIMP_UNDO_IMAGE_COLORMAP, NC_("undo-type", "Change indexed palette"), NULL },
1180 { GIMP_UNDO_IMAGE_COLOR_MANAGED, NC_("undo-type", "Change color managed state"), NULL },
1181 { GIMP_UNDO_GUIDE, NC_("undo-type", "Guide"), NULL },
1182 { GIMP_UNDO_SAMPLE_POINT, NC_("undo-type", "Sample Point"), NULL },
1183 { GIMP_UNDO_DRAWABLE, NC_("undo-type", "Layer/Channel"), NULL },
1184 { GIMP_UNDO_DRAWABLE_MOD, NC_("undo-type", "Layer/Channel modification"), NULL },
1185 { GIMP_UNDO_MASK, NC_("undo-type", "Selection mask"), NULL },
1186 { GIMP_UNDO_ITEM_REORDER, NC_("undo-type", "Reorder item"), NULL },
1187 { GIMP_UNDO_ITEM_RENAME, NC_("undo-type", "Rename item"), NULL },
1188 { GIMP_UNDO_ITEM_DISPLACE, NC_("undo-type", "Move item"), NULL },
1189 { GIMP_UNDO_ITEM_VISIBILITY, NC_("undo-type", "Item visibility"), NULL },
1190 { GIMP_UNDO_ITEM_LINKED, NC_("undo-type", "Link/Unlink item"), NULL },
1191 { GIMP_UNDO_ITEM_COLOR_TAG, NC_("undo-type", "Item color tag"), NULL },
1192 { GIMP_UNDO_ITEM_LOCK_CONTENT, NC_("undo-type", "Lock/Unlock content"), NULL },
1193 { GIMP_UNDO_ITEM_LOCK_POSITION, NC_("undo-type", "Lock/Unlock position"), NULL },
1194 { GIMP_UNDO_LAYER_ADD, NC_("undo-type", "New layer"), NULL },
1195 { GIMP_UNDO_LAYER_REMOVE, NC_("undo-type", "Delete layer"), NULL },
1196 { GIMP_UNDO_LAYER_MODE, NC_("undo-type", "Set layer mode"), NULL },
1197 { GIMP_UNDO_LAYER_OPACITY, NC_("undo-type", "Set layer opacity"), NULL },
1198 { GIMP_UNDO_LAYER_LOCK_ALPHA, NC_("undo-type", "Lock/Unlock alpha channel"), NULL },
1199 { GIMP_UNDO_GROUP_LAYER_SUSPEND_RESIZE, NC_("undo-type", "Suspend group layer resize"), NULL },
1200 { GIMP_UNDO_GROUP_LAYER_RESUME_RESIZE, NC_("undo-type", "Resume group layer resize"), NULL },
1201 { GIMP_UNDO_GROUP_LAYER_SUSPEND_MASK, NC_("undo-type", "Suspend group layer mask"), NULL },
1202 { GIMP_UNDO_GROUP_LAYER_RESUME_MASK, NC_("undo-type", "Resume group layer mask"), NULL },
1203 { GIMP_UNDO_GROUP_LAYER_START_TRANSFORM, NC_("undo-type", "Start transforming group layer"), NULL },
1204 { GIMP_UNDO_GROUP_LAYER_END_TRANSFORM, NC_("undo-type", "End transforming group layer"), NULL },
1205 { GIMP_UNDO_GROUP_LAYER_CONVERT, NC_("undo-type", "Convert group layer"), NULL },
1206 { GIMP_UNDO_TEXT_LAYER, NC_("undo-type", "Text layer"), NULL },
1207 { GIMP_UNDO_TEXT_LAYER_MODIFIED, NC_("undo-type", "Text layer modification"), NULL },
1208 { GIMP_UNDO_TEXT_LAYER_CONVERT, NC_("undo-type", "Convert text layer"), NULL },
1209 { GIMP_UNDO_LAYER_MASK_ADD, NC_("undo-type", "Add layer mask"), NULL },
1210 { GIMP_UNDO_LAYER_MASK_REMOVE, NC_("undo-type", "Delete layer mask"), NULL },
1211 { GIMP_UNDO_LAYER_MASK_APPLY, NC_("undo-type", "Apply layer mask"), NULL },
1212 { GIMP_UNDO_LAYER_MASK_SHOW, NC_("undo-type", "Show layer mask"), NULL },
1213 { GIMP_UNDO_CHANNEL_ADD, NC_("undo-type", "New channel"), NULL },
1214 { GIMP_UNDO_CHANNEL_REMOVE, NC_("undo-type", "Delete channel"), NULL },
1215 { GIMP_UNDO_CHANNEL_COLOR, NC_("undo-type", "Channel color"), NULL },
1216 { GIMP_UNDO_VECTORS_ADD, NC_("undo-type", "New path"), NULL },
1217 { GIMP_UNDO_VECTORS_REMOVE, NC_("undo-type", "Delete path"), NULL },
1218 { GIMP_UNDO_VECTORS_MOD, NC_("undo-type", "Path modification"), NULL },
1219 { GIMP_UNDO_FS_TO_LAYER, NC_("undo-type", "Floating selection to layer"), NULL },
1220 { GIMP_UNDO_TRANSFORM_GRID, NC_("undo-type", "Transform grid"), NULL },
1221 { GIMP_UNDO_PAINT, NC_("undo-type", "Paint"), NULL },
1222 { GIMP_UNDO_INK, NC_("undo-type", "Ink"), NULL },
1223 { GIMP_UNDO_FOREGROUND_SELECT, NC_("undo-type", "Select foreground"), NULL },
1224 { GIMP_UNDO_PARASITE_ATTACH, NC_("undo-type", "Attach parasite"), NULL },
1225 { GIMP_UNDO_PARASITE_REMOVE, NC_("undo-type", "Remove parasite"), NULL },
1226 { GIMP_UNDO_CANT, NC_("undo-type", "Not undoable"), 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 ("GimpUndoType", values);
1235 gimp_type_set_translation_context (type, "undo-type");
1236 gimp_enum_set_value_descriptions (type, descs);
1237 }
1238
1239 return type;
1240 }
1241
1242 GType
gimp_view_size_get_type(void)1243 gimp_view_size_get_type (void)
1244 {
1245 static const GEnumValue values[] =
1246 {
1247 { GIMP_VIEW_SIZE_TINY, "GIMP_VIEW_SIZE_TINY", "tiny" },
1248 { GIMP_VIEW_SIZE_EXTRA_SMALL, "GIMP_VIEW_SIZE_EXTRA_SMALL", "extra-small" },
1249 { GIMP_VIEW_SIZE_SMALL, "GIMP_VIEW_SIZE_SMALL", "small" },
1250 { GIMP_VIEW_SIZE_MEDIUM, "GIMP_VIEW_SIZE_MEDIUM", "medium" },
1251 { GIMP_VIEW_SIZE_LARGE, "GIMP_VIEW_SIZE_LARGE", "large" },
1252 { GIMP_VIEW_SIZE_EXTRA_LARGE, "GIMP_VIEW_SIZE_EXTRA_LARGE", "extra-large" },
1253 { GIMP_VIEW_SIZE_HUGE, "GIMP_VIEW_SIZE_HUGE", "huge" },
1254 { GIMP_VIEW_SIZE_ENORMOUS, "GIMP_VIEW_SIZE_ENORMOUS", "enormous" },
1255 { GIMP_VIEW_SIZE_GIGANTIC, "GIMP_VIEW_SIZE_GIGANTIC", "gigantic" },
1256 { 0, NULL, NULL }
1257 };
1258
1259 static const GimpEnumDesc descs[] =
1260 {
1261 { GIMP_VIEW_SIZE_TINY, NC_("view-size", "Tiny"), NULL },
1262 { GIMP_VIEW_SIZE_EXTRA_SMALL, NC_("view-size", "Very small"), NULL },
1263 { GIMP_VIEW_SIZE_SMALL, NC_("view-size", "Small"), NULL },
1264 { GIMP_VIEW_SIZE_MEDIUM, NC_("view-size", "Medium"), NULL },
1265 { GIMP_VIEW_SIZE_LARGE, NC_("view-size", "Large"), NULL },
1266 { GIMP_VIEW_SIZE_EXTRA_LARGE, NC_("view-size", "Very large"), NULL },
1267 { GIMP_VIEW_SIZE_HUGE, NC_("view-size", "Huge"), NULL },
1268 { GIMP_VIEW_SIZE_ENORMOUS, NC_("view-size", "Enormous"), NULL },
1269 { GIMP_VIEW_SIZE_GIGANTIC, NC_("view-size", "Gigantic"), NULL },
1270 { 0, NULL, NULL }
1271 };
1272
1273 static GType type = 0;
1274
1275 if (G_UNLIKELY (! type))
1276 {
1277 type = g_enum_register_static ("GimpViewSize", values);
1278 gimp_type_set_translation_context (type, "view-size");
1279 gimp_enum_set_value_descriptions (type, descs);
1280 }
1281
1282 return type;
1283 }
1284
1285 GType
gimp_view_type_get_type(void)1286 gimp_view_type_get_type (void)
1287 {
1288 static const GEnumValue values[] =
1289 {
1290 { GIMP_VIEW_TYPE_LIST, "GIMP_VIEW_TYPE_LIST", "list" },
1291 { GIMP_VIEW_TYPE_GRID, "GIMP_VIEW_TYPE_GRID", "grid" },
1292 { 0, NULL, NULL }
1293 };
1294
1295 static const GimpEnumDesc descs[] =
1296 {
1297 { GIMP_VIEW_TYPE_LIST, NC_("view-type", "View as list"), NULL },
1298 { GIMP_VIEW_TYPE_GRID, NC_("view-type", "View as grid"), NULL },
1299 { 0, NULL, NULL }
1300 };
1301
1302 static GType type = 0;
1303
1304 if (G_UNLIKELY (! type))
1305 {
1306 type = g_enum_register_static ("GimpViewType", values);
1307 gimp_type_set_translation_context (type, "view-type");
1308 gimp_enum_set_value_descriptions (type, descs);
1309 }
1310
1311 return type;
1312 }
1313
1314
1315 /* Generated data ends here */
1316
1317