1
2 /* Generated data (by gimp-mkenums) */
3
4 #include "config.h"
5 #include <gio/gio.h>
6 #include <gegl.h>
7 #undef GIMP_DISABLE_DEPRECATED
8 #include "libgimpbase/gimpbase.h"
9 #include "libgimpbase/gimpbase-private.h"
10 #include "libgimpconfig/gimpconfigenums.h"
11 #include "gimpenums.h"
12
13 /* enumerations from "../../libgimp/gimpenums.h" */
14 GType
gimp_brush_application_mode_get_type(void)15 gimp_brush_application_mode_get_type (void)
16 {
17 static const GEnumValue values[] =
18 {
19 { GIMP_BRUSH_HARD, "GIMP_BRUSH_HARD", "hard" },
20 { GIMP_BRUSH_SOFT, "GIMP_BRUSH_SOFT", "soft" },
21 { 0, NULL, NULL }
22 };
23
24 static const GimpEnumDesc descs[] =
25 {
26 { GIMP_BRUSH_HARD, "GIMP_BRUSH_HARD", NULL },
27 { GIMP_BRUSH_SOFT, "GIMP_BRUSH_SOFT", NULL },
28 { 0, NULL, NULL }
29 };
30
31 static GType type = 0;
32
33 if (G_UNLIKELY (! type))
34 {
35 type = g_enum_register_static ("GimpBrushApplicationMode", values);
36 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
37 gimp_type_set_translation_context (type, "brush-application-mode");
38 gimp_enum_set_value_descriptions (type, descs);
39 }
40
41 return type;
42 }
43
44 GType
gimp_convert_dither_type_get_type(void)45 gimp_convert_dither_type_get_type (void)
46 {
47 static const GEnumValue values[] =
48 {
49 { GIMP_CONVERT_DITHER_NONE, "GIMP_CONVERT_DITHER_NONE", "none" },
50 { GIMP_CONVERT_DITHER_FS, "GIMP_CONVERT_DITHER_FS", "fs" },
51 { GIMP_CONVERT_DITHER_FS_LOWBLEED, "GIMP_CONVERT_DITHER_FS_LOWBLEED", "fs-lowbleed" },
52 { GIMP_CONVERT_DITHER_FIXED, "GIMP_CONVERT_DITHER_FIXED", "fixed" },
53 { 0, NULL, NULL }
54 };
55
56 static const GimpEnumDesc descs[] =
57 {
58 { GIMP_CONVERT_DITHER_NONE, "GIMP_CONVERT_DITHER_NONE", NULL },
59 { GIMP_CONVERT_DITHER_FS, "GIMP_CONVERT_DITHER_FS", NULL },
60 { GIMP_CONVERT_DITHER_FS_LOWBLEED, "GIMP_CONVERT_DITHER_FS_LOWBLEED", NULL },
61 { GIMP_CONVERT_DITHER_FIXED, "GIMP_CONVERT_DITHER_FIXED", NULL },
62 { 0, NULL, NULL }
63 };
64
65 static GType type = 0;
66
67 if (G_UNLIKELY (! type))
68 {
69 type = g_enum_register_static ("GimpConvertDitherType", values);
70 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
71 gimp_type_set_translation_context (type, "convert-dither-type");
72 gimp_enum_set_value_descriptions (type, descs);
73 }
74
75 return type;
76 }
77
78 GType
gimp_histogram_channel_get_type(void)79 gimp_histogram_channel_get_type (void)
80 {
81 static const GEnumValue values[] =
82 {
83 { GIMP_HISTOGRAM_VALUE, "GIMP_HISTOGRAM_VALUE", "value" },
84 { GIMP_HISTOGRAM_RED, "GIMP_HISTOGRAM_RED", "red" },
85 { GIMP_HISTOGRAM_GREEN, "GIMP_HISTOGRAM_GREEN", "green" },
86 { GIMP_HISTOGRAM_BLUE, "GIMP_HISTOGRAM_BLUE", "blue" },
87 { GIMP_HISTOGRAM_ALPHA, "GIMP_HISTOGRAM_ALPHA", "alpha" },
88 { GIMP_HISTOGRAM_LUMINANCE, "GIMP_HISTOGRAM_LUMINANCE", "luminance" },
89 { 0, NULL, NULL }
90 };
91
92 static const GimpEnumDesc descs[] =
93 {
94 { GIMP_HISTOGRAM_VALUE, "GIMP_HISTOGRAM_VALUE", NULL },
95 { GIMP_HISTOGRAM_RED, "GIMP_HISTOGRAM_RED", NULL },
96 { GIMP_HISTOGRAM_GREEN, "GIMP_HISTOGRAM_GREEN", NULL },
97 { GIMP_HISTOGRAM_BLUE, "GIMP_HISTOGRAM_BLUE", NULL },
98 { GIMP_HISTOGRAM_ALPHA, "GIMP_HISTOGRAM_ALPHA", NULL },
99 { GIMP_HISTOGRAM_LUMINANCE, "GIMP_HISTOGRAM_LUMINANCE", NULL },
100 { 0, NULL, NULL }
101 };
102
103 static GType type = 0;
104
105 if (G_UNLIKELY (! type))
106 {
107 type = g_enum_register_static ("GimpHistogramChannel", values);
108 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
109 gimp_type_set_translation_context (type, "histogram-channel");
110 gimp_enum_set_value_descriptions (type, descs);
111 }
112
113 return type;
114 }
115
116 GType
gimp_layer_color_space_get_type(void)117 gimp_layer_color_space_get_type (void)
118 {
119 static const GEnumValue values[] =
120 {
121 { GIMP_LAYER_COLOR_SPACE_AUTO, "GIMP_LAYER_COLOR_SPACE_AUTO", "auto" },
122 { GIMP_LAYER_COLOR_SPACE_RGB_LINEAR, "GIMP_LAYER_COLOR_SPACE_RGB_LINEAR", "rgb-linear" },
123 { GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL, "GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL", "rgb-perceptual" },
124 { 0, NULL, NULL }
125 };
126
127 static const GimpEnumDesc descs[] =
128 {
129 { GIMP_LAYER_COLOR_SPACE_AUTO, "GIMP_LAYER_COLOR_SPACE_AUTO", NULL },
130 { GIMP_LAYER_COLOR_SPACE_RGB_LINEAR, "GIMP_LAYER_COLOR_SPACE_RGB_LINEAR", NULL },
131 { GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL, "GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL", NULL },
132 { 0, NULL, NULL }
133 };
134
135 static GType type = 0;
136
137 if (G_UNLIKELY (! type))
138 {
139 type = g_enum_register_static ("GimpLayerColorSpace", values);
140 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
141 gimp_type_set_translation_context (type, "layer-color-space");
142 gimp_enum_set_value_descriptions (type, descs);
143 }
144
145 return type;
146 }
147
148 GType
gimp_layer_composite_mode_get_type(void)149 gimp_layer_composite_mode_get_type (void)
150 {
151 static const GEnumValue values[] =
152 {
153 { GIMP_LAYER_COMPOSITE_AUTO, "GIMP_LAYER_COMPOSITE_AUTO", "auto" },
154 { GIMP_LAYER_COMPOSITE_UNION, "GIMP_LAYER_COMPOSITE_UNION", "union" },
155 { GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP, "GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP", "clip-to-backdrop" },
156 { GIMP_LAYER_COMPOSITE_CLIP_TO_LAYER, "GIMP_LAYER_COMPOSITE_CLIP_TO_LAYER", "clip-to-layer" },
157 { GIMP_LAYER_COMPOSITE_INTERSECTION, "GIMP_LAYER_COMPOSITE_INTERSECTION", "intersection" },
158 { 0, NULL, NULL }
159 };
160
161 static const GimpEnumDesc descs[] =
162 {
163 { GIMP_LAYER_COMPOSITE_AUTO, "GIMP_LAYER_COMPOSITE_AUTO", NULL },
164 { GIMP_LAYER_COMPOSITE_UNION, "GIMP_LAYER_COMPOSITE_UNION", NULL },
165 { GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP, "GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP", NULL },
166 { GIMP_LAYER_COMPOSITE_CLIP_TO_LAYER, "GIMP_LAYER_COMPOSITE_CLIP_TO_LAYER", NULL },
167 { GIMP_LAYER_COMPOSITE_INTERSECTION, "GIMP_LAYER_COMPOSITE_INTERSECTION", NULL },
168 { 0, NULL, NULL }
169 };
170
171 static GType type = 0;
172
173 if (G_UNLIKELY (! type))
174 {
175 type = g_enum_register_static ("GimpLayerCompositeMode", values);
176 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
177 gimp_type_set_translation_context (type, "layer-composite-mode");
178 gimp_enum_set_value_descriptions (type, descs);
179 }
180
181 return type;
182 }
183
184 GType
gimp_layer_mode_get_type(void)185 gimp_layer_mode_get_type (void)
186 {
187 static const GEnumValue values[] =
188 {
189 { GIMP_LAYER_MODE_NORMAL_LEGACY, "GIMP_LAYER_MODE_NORMAL_LEGACY", "normal-legacy" },
190 { GIMP_LAYER_MODE_DISSOLVE, "GIMP_LAYER_MODE_DISSOLVE", "dissolve" },
191 { GIMP_LAYER_MODE_BEHIND_LEGACY, "GIMP_LAYER_MODE_BEHIND_LEGACY", "behind-legacy" },
192 { GIMP_LAYER_MODE_MULTIPLY_LEGACY, "GIMP_LAYER_MODE_MULTIPLY_LEGACY", "multiply-legacy" },
193 { GIMP_LAYER_MODE_SCREEN_LEGACY, "GIMP_LAYER_MODE_SCREEN_LEGACY", "screen-legacy" },
194 { GIMP_LAYER_MODE_OVERLAY_LEGACY, "GIMP_LAYER_MODE_OVERLAY_LEGACY", "overlay-legacy" },
195 { GIMP_LAYER_MODE_DIFFERENCE_LEGACY, "GIMP_LAYER_MODE_DIFFERENCE_LEGACY", "difference-legacy" },
196 { GIMP_LAYER_MODE_ADDITION_LEGACY, "GIMP_LAYER_MODE_ADDITION_LEGACY", "addition-legacy" },
197 { GIMP_LAYER_MODE_SUBTRACT_LEGACY, "GIMP_LAYER_MODE_SUBTRACT_LEGACY", "subtract-legacy" },
198 { GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY, "GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY", "darken-only-legacy" },
199 { GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY, "GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY", "lighten-only-legacy" },
200 { GIMP_LAYER_MODE_HSV_HUE_LEGACY, "GIMP_LAYER_MODE_HSV_HUE_LEGACY", "hsv-hue-legacy" },
201 { GIMP_LAYER_MODE_HSV_SATURATION_LEGACY, "GIMP_LAYER_MODE_HSV_SATURATION_LEGACY", "hsv-saturation-legacy" },
202 { GIMP_LAYER_MODE_HSL_COLOR_LEGACY, "GIMP_LAYER_MODE_HSL_COLOR_LEGACY", "hsl-color-legacy" },
203 { GIMP_LAYER_MODE_HSV_VALUE_LEGACY, "GIMP_LAYER_MODE_HSV_VALUE_LEGACY", "hsv-value-legacy" },
204 { GIMP_LAYER_MODE_DIVIDE_LEGACY, "GIMP_LAYER_MODE_DIVIDE_LEGACY", "divide-legacy" },
205 { GIMP_LAYER_MODE_DODGE_LEGACY, "GIMP_LAYER_MODE_DODGE_LEGACY", "dodge-legacy" },
206 { GIMP_LAYER_MODE_BURN_LEGACY, "GIMP_LAYER_MODE_BURN_LEGACY", "burn-legacy" },
207 { GIMP_LAYER_MODE_HARDLIGHT_LEGACY, "GIMP_LAYER_MODE_HARDLIGHT_LEGACY", "hardlight-legacy" },
208 { GIMP_LAYER_MODE_SOFTLIGHT_LEGACY, "GIMP_LAYER_MODE_SOFTLIGHT_LEGACY", "softlight-legacy" },
209 { GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY, "GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY", "grain-extract-legacy" },
210 { GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY, "GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY", "grain-merge-legacy" },
211 { GIMP_LAYER_MODE_COLOR_ERASE_LEGACY, "GIMP_LAYER_MODE_COLOR_ERASE_LEGACY", "color-erase-legacy" },
212 { GIMP_LAYER_MODE_OVERLAY, "GIMP_LAYER_MODE_OVERLAY", "overlay" },
213 { GIMP_LAYER_MODE_LCH_HUE, "GIMP_LAYER_MODE_LCH_HUE", "lch-hue" },
214 { GIMP_LAYER_MODE_LCH_CHROMA, "GIMP_LAYER_MODE_LCH_CHROMA", "lch-chroma" },
215 { GIMP_LAYER_MODE_LCH_COLOR, "GIMP_LAYER_MODE_LCH_COLOR", "lch-color" },
216 { GIMP_LAYER_MODE_LCH_LIGHTNESS, "GIMP_LAYER_MODE_LCH_LIGHTNESS", "lch-lightness" },
217 { GIMP_LAYER_MODE_NORMAL, "GIMP_LAYER_MODE_NORMAL", "normal" },
218 { GIMP_LAYER_MODE_BEHIND, "GIMP_LAYER_MODE_BEHIND", "behind" },
219 { GIMP_LAYER_MODE_MULTIPLY, "GIMP_LAYER_MODE_MULTIPLY", "multiply" },
220 { GIMP_LAYER_MODE_SCREEN, "GIMP_LAYER_MODE_SCREEN", "screen" },
221 { GIMP_LAYER_MODE_DIFFERENCE, "GIMP_LAYER_MODE_DIFFERENCE", "difference" },
222 { GIMP_LAYER_MODE_ADDITION, "GIMP_LAYER_MODE_ADDITION", "addition" },
223 { GIMP_LAYER_MODE_SUBTRACT, "GIMP_LAYER_MODE_SUBTRACT", "subtract" },
224 { GIMP_LAYER_MODE_DARKEN_ONLY, "GIMP_LAYER_MODE_DARKEN_ONLY", "darken-only" },
225 { GIMP_LAYER_MODE_LIGHTEN_ONLY, "GIMP_LAYER_MODE_LIGHTEN_ONLY", "lighten-only" },
226 { GIMP_LAYER_MODE_HSV_HUE, "GIMP_LAYER_MODE_HSV_HUE", "hsv-hue" },
227 { GIMP_LAYER_MODE_HSV_SATURATION, "GIMP_LAYER_MODE_HSV_SATURATION", "hsv-saturation" },
228 { GIMP_LAYER_MODE_HSL_COLOR, "GIMP_LAYER_MODE_HSL_COLOR", "hsl-color" },
229 { GIMP_LAYER_MODE_HSV_VALUE, "GIMP_LAYER_MODE_HSV_VALUE", "hsv-value" },
230 { GIMP_LAYER_MODE_DIVIDE, "GIMP_LAYER_MODE_DIVIDE", "divide" },
231 { GIMP_LAYER_MODE_DODGE, "GIMP_LAYER_MODE_DODGE", "dodge" },
232 { GIMP_LAYER_MODE_BURN, "GIMP_LAYER_MODE_BURN", "burn" },
233 { GIMP_LAYER_MODE_HARDLIGHT, "GIMP_LAYER_MODE_HARDLIGHT", "hardlight" },
234 { GIMP_LAYER_MODE_SOFTLIGHT, "GIMP_LAYER_MODE_SOFTLIGHT", "softlight" },
235 { GIMP_LAYER_MODE_GRAIN_EXTRACT, "GIMP_LAYER_MODE_GRAIN_EXTRACT", "grain-extract" },
236 { GIMP_LAYER_MODE_GRAIN_MERGE, "GIMP_LAYER_MODE_GRAIN_MERGE", "grain-merge" },
237 { GIMP_LAYER_MODE_VIVID_LIGHT, "GIMP_LAYER_MODE_VIVID_LIGHT", "vivid-light" },
238 { GIMP_LAYER_MODE_PIN_LIGHT, "GIMP_LAYER_MODE_PIN_LIGHT", "pin-light" },
239 { GIMP_LAYER_MODE_LINEAR_LIGHT, "GIMP_LAYER_MODE_LINEAR_LIGHT", "linear-light" },
240 { GIMP_LAYER_MODE_HARD_MIX, "GIMP_LAYER_MODE_HARD_MIX", "hard-mix" },
241 { GIMP_LAYER_MODE_EXCLUSION, "GIMP_LAYER_MODE_EXCLUSION", "exclusion" },
242 { GIMP_LAYER_MODE_LINEAR_BURN, "GIMP_LAYER_MODE_LINEAR_BURN", "linear-burn" },
243 { GIMP_LAYER_MODE_LUMA_DARKEN_ONLY, "GIMP_LAYER_MODE_LUMA_DARKEN_ONLY", "luma-darken-only" },
244 { GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY, "GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY", "luma-lighten-only" },
245 { GIMP_LAYER_MODE_LUMINANCE, "GIMP_LAYER_MODE_LUMINANCE", "luminance" },
246 { GIMP_LAYER_MODE_COLOR_ERASE, "GIMP_LAYER_MODE_COLOR_ERASE", "color-erase" },
247 { GIMP_LAYER_MODE_ERASE, "GIMP_LAYER_MODE_ERASE", "erase" },
248 { GIMP_LAYER_MODE_MERGE, "GIMP_LAYER_MODE_MERGE", "merge" },
249 { GIMP_LAYER_MODE_SPLIT, "GIMP_LAYER_MODE_SPLIT", "split" },
250 { GIMP_LAYER_MODE_PASS_THROUGH, "GIMP_LAYER_MODE_PASS_THROUGH", "pass-through" },
251 { 0, NULL, NULL }
252 };
253
254 static const GimpEnumDesc descs[] =
255 {
256 { GIMP_LAYER_MODE_NORMAL_LEGACY, "GIMP_LAYER_MODE_NORMAL_LEGACY", NULL },
257 { GIMP_LAYER_MODE_DISSOLVE, "GIMP_LAYER_MODE_DISSOLVE", NULL },
258 { GIMP_LAYER_MODE_BEHIND_LEGACY, "GIMP_LAYER_MODE_BEHIND_LEGACY", NULL },
259 { GIMP_LAYER_MODE_MULTIPLY_LEGACY, "GIMP_LAYER_MODE_MULTIPLY_LEGACY", NULL },
260 { GIMP_LAYER_MODE_SCREEN_LEGACY, "GIMP_LAYER_MODE_SCREEN_LEGACY", NULL },
261 { GIMP_LAYER_MODE_OVERLAY_LEGACY, "GIMP_LAYER_MODE_OVERLAY_LEGACY", NULL },
262 { GIMP_LAYER_MODE_DIFFERENCE_LEGACY, "GIMP_LAYER_MODE_DIFFERENCE_LEGACY", NULL },
263 { GIMP_LAYER_MODE_ADDITION_LEGACY, "GIMP_LAYER_MODE_ADDITION_LEGACY", NULL },
264 { GIMP_LAYER_MODE_SUBTRACT_LEGACY, "GIMP_LAYER_MODE_SUBTRACT_LEGACY", NULL },
265 { GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY, "GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY", NULL },
266 { GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY, "GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY", NULL },
267 { GIMP_LAYER_MODE_HSV_HUE_LEGACY, "GIMP_LAYER_MODE_HSV_HUE_LEGACY", NULL },
268 { GIMP_LAYER_MODE_HSV_SATURATION_LEGACY, "GIMP_LAYER_MODE_HSV_SATURATION_LEGACY", NULL },
269 { GIMP_LAYER_MODE_HSL_COLOR_LEGACY, "GIMP_LAYER_MODE_HSL_COLOR_LEGACY", NULL },
270 { GIMP_LAYER_MODE_HSV_VALUE_LEGACY, "GIMP_LAYER_MODE_HSV_VALUE_LEGACY", NULL },
271 { GIMP_LAYER_MODE_DIVIDE_LEGACY, "GIMP_LAYER_MODE_DIVIDE_LEGACY", NULL },
272 { GIMP_LAYER_MODE_DODGE_LEGACY, "GIMP_LAYER_MODE_DODGE_LEGACY", NULL },
273 { GIMP_LAYER_MODE_BURN_LEGACY, "GIMP_LAYER_MODE_BURN_LEGACY", NULL },
274 { GIMP_LAYER_MODE_HARDLIGHT_LEGACY, "GIMP_LAYER_MODE_HARDLIGHT_LEGACY", NULL },
275 { GIMP_LAYER_MODE_SOFTLIGHT_LEGACY, "GIMP_LAYER_MODE_SOFTLIGHT_LEGACY", NULL },
276 { GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY, "GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY", NULL },
277 { GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY, "GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY", NULL },
278 { GIMP_LAYER_MODE_COLOR_ERASE_LEGACY, "GIMP_LAYER_MODE_COLOR_ERASE_LEGACY", NULL },
279 { GIMP_LAYER_MODE_OVERLAY, "GIMP_LAYER_MODE_OVERLAY", NULL },
280 { GIMP_LAYER_MODE_LCH_HUE, "GIMP_LAYER_MODE_LCH_HUE", NULL },
281 { GIMP_LAYER_MODE_LCH_CHROMA, "GIMP_LAYER_MODE_LCH_CHROMA", NULL },
282 { GIMP_LAYER_MODE_LCH_COLOR, "GIMP_LAYER_MODE_LCH_COLOR", NULL },
283 { GIMP_LAYER_MODE_LCH_LIGHTNESS, "GIMP_LAYER_MODE_LCH_LIGHTNESS", NULL },
284 { GIMP_LAYER_MODE_NORMAL, "GIMP_LAYER_MODE_NORMAL", NULL },
285 { GIMP_LAYER_MODE_BEHIND, "GIMP_LAYER_MODE_BEHIND", NULL },
286 { GIMP_LAYER_MODE_MULTIPLY, "GIMP_LAYER_MODE_MULTIPLY", NULL },
287 { GIMP_LAYER_MODE_SCREEN, "GIMP_LAYER_MODE_SCREEN", NULL },
288 { GIMP_LAYER_MODE_DIFFERENCE, "GIMP_LAYER_MODE_DIFFERENCE", NULL },
289 { GIMP_LAYER_MODE_ADDITION, "GIMP_LAYER_MODE_ADDITION", NULL },
290 { GIMP_LAYER_MODE_SUBTRACT, "GIMP_LAYER_MODE_SUBTRACT", NULL },
291 { GIMP_LAYER_MODE_DARKEN_ONLY, "GIMP_LAYER_MODE_DARKEN_ONLY", NULL },
292 { GIMP_LAYER_MODE_LIGHTEN_ONLY, "GIMP_LAYER_MODE_LIGHTEN_ONLY", NULL },
293 { GIMP_LAYER_MODE_HSV_HUE, "GIMP_LAYER_MODE_HSV_HUE", NULL },
294 { GIMP_LAYER_MODE_HSV_SATURATION, "GIMP_LAYER_MODE_HSV_SATURATION", NULL },
295 { GIMP_LAYER_MODE_HSL_COLOR, "GIMP_LAYER_MODE_HSL_COLOR", NULL },
296 { GIMP_LAYER_MODE_HSV_VALUE, "GIMP_LAYER_MODE_HSV_VALUE", NULL },
297 { GIMP_LAYER_MODE_DIVIDE, "GIMP_LAYER_MODE_DIVIDE", NULL },
298 { GIMP_LAYER_MODE_DODGE, "GIMP_LAYER_MODE_DODGE", NULL },
299 { GIMP_LAYER_MODE_BURN, "GIMP_LAYER_MODE_BURN", NULL },
300 { GIMP_LAYER_MODE_HARDLIGHT, "GIMP_LAYER_MODE_HARDLIGHT", NULL },
301 { GIMP_LAYER_MODE_SOFTLIGHT, "GIMP_LAYER_MODE_SOFTLIGHT", NULL },
302 { GIMP_LAYER_MODE_GRAIN_EXTRACT, "GIMP_LAYER_MODE_GRAIN_EXTRACT", NULL },
303 { GIMP_LAYER_MODE_GRAIN_MERGE, "GIMP_LAYER_MODE_GRAIN_MERGE", NULL },
304 { GIMP_LAYER_MODE_VIVID_LIGHT, "GIMP_LAYER_MODE_VIVID_LIGHT", NULL },
305 { GIMP_LAYER_MODE_PIN_LIGHT, "GIMP_LAYER_MODE_PIN_LIGHT", NULL },
306 { GIMP_LAYER_MODE_LINEAR_LIGHT, "GIMP_LAYER_MODE_LINEAR_LIGHT", NULL },
307 { GIMP_LAYER_MODE_HARD_MIX, "GIMP_LAYER_MODE_HARD_MIX", NULL },
308 { GIMP_LAYER_MODE_EXCLUSION, "GIMP_LAYER_MODE_EXCLUSION", NULL },
309 { GIMP_LAYER_MODE_LINEAR_BURN, "GIMP_LAYER_MODE_LINEAR_BURN", NULL },
310 { GIMP_LAYER_MODE_LUMA_DARKEN_ONLY, "GIMP_LAYER_MODE_LUMA_DARKEN_ONLY", NULL },
311 { GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY, "GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY", NULL },
312 { GIMP_LAYER_MODE_LUMINANCE, "GIMP_LAYER_MODE_LUMINANCE", NULL },
313 { GIMP_LAYER_MODE_COLOR_ERASE, "GIMP_LAYER_MODE_COLOR_ERASE", NULL },
314 { GIMP_LAYER_MODE_ERASE, "GIMP_LAYER_MODE_ERASE", NULL },
315 { GIMP_LAYER_MODE_MERGE, "GIMP_LAYER_MODE_MERGE", NULL },
316 { GIMP_LAYER_MODE_SPLIT, "GIMP_LAYER_MODE_SPLIT", NULL },
317 { GIMP_LAYER_MODE_PASS_THROUGH, "GIMP_LAYER_MODE_PASS_THROUGH", NULL },
318 { 0, NULL, NULL }
319 };
320
321 static GType type = 0;
322
323 if (G_UNLIKELY (! type))
324 {
325 type = g_enum_register_static ("GimpLayerMode", values);
326 gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
327 gimp_type_set_translation_context (type, "layer-mode");
328 gimp_enum_set_value_descriptions (type, descs);
329 }
330
331 return type;
332 }
333
334
335 /* Generated data ends here */
336
337
338 typedef GType (* GimpGetTypeFunc) (void);
339
340 static const GimpGetTypeFunc get_type_funcs[] =
341 {
342 gegl_distance_metric_get_type,
343 gimp_add_mask_type_get_type,
344 gimp_blend_mode_get_type,
345 gimp_brush_application_mode_get_type,
346 gimp_brush_generated_shape_get_type,
347 gimp_bucket_fill_mode_get_type,
348 gimp_cap_style_get_type,
349 gimp_channel_ops_get_type,
350 gimp_channel_type_get_type,
351 gimp_clone_type_get_type,
352 gimp_color_management_mode_get_type,
353 gimp_color_rendering_intent_get_type,
354 gimp_color_tag_get_type,
355 gimp_component_type_get_type,
356 gimp_convert_dither_type_get_type,
357 gimp_convert_palette_type_get_type,
358 gimp_convolve_type_get_type,
359 gimp_desaturate_mode_get_type,
360 gimp_dodge_burn_type_get_type,
361 gimp_fill_type_get_type,
362 gimp_foreground_extract_mode_get_type,
363 gimp_gradient_blend_color_space_get_type,
364 gimp_gradient_segment_color_get_type,
365 gimp_gradient_segment_type_get_type,
366 gimp_gradient_type_get_type,
367 gimp_grid_style_get_type,
368 gimp_histogram_channel_get_type,
369 gimp_hue_range_get_type,
370 gimp_icon_type_get_type,
371 gimp_image_base_type_get_type,
372 gimp_image_type_get_type,
373 gimp_ink_blob_type_get_type,
374 gimp_interpolation_type_get_type,
375 gimp_join_style_get_type,
376 gimp_layer_color_space_get_type,
377 gimp_layer_composite_mode_get_type,
378 gimp_layer_mode_get_type,
379 gimp_mask_apply_mode_get_type,
380 gimp_merge_type_get_type,
381 gimp_message_handler_type_get_type,
382 gimp_offset_type_get_type,
383 gimp_orientation_type_get_type,
384 gimp_pdb_arg_type_get_type,
385 gimp_pdb_error_handler_get_type,
386 gimp_pdb_proc_type_get_type,
387 gimp_pdb_status_type_get_type,
388 gimp_paint_application_mode_get_type,
389 gimp_precision_get_type,
390 gimp_progress_command_get_type,
391 gimp_repeat_mode_get_type,
392 gimp_rotation_type_get_type,
393 gimp_run_mode_get_type,
394 gimp_select_criterion_get_type,
395 gimp_size_type_get_type,
396 gimp_stack_trace_mode_get_type,
397 gimp_stroke_method_get_type,
398 gimp_text_direction_get_type,
399 gimp_text_hint_style_get_type,
400 gimp_text_justification_get_type,
401 gimp_transfer_mode_get_type,
402 gimp_transform_direction_get_type,
403 gimp_transform_resize_get_type,
404 gimp_user_directory_get_type,
405 gimp_vectors_stroke_type_get_type
406 };
407
408 static const gchar * const type_names[] =
409 {
410 "GeglDistanceMetric",
411 "GimpAddMaskType",
412 "GimpBlendMode",
413 "GimpBrushApplicationMode",
414 "GimpBrushGeneratedShape",
415 "GimpBucketFillMode",
416 "GimpCapStyle",
417 "GimpChannelOps",
418 "GimpChannelType",
419 "GimpCloneType",
420 "GimpColorManagementMode",
421 "GimpColorRenderingIntent",
422 "GimpColorTag",
423 "GimpComponentType",
424 "GimpConvertDitherType",
425 "GimpConvertPaletteType",
426 "GimpConvolveType",
427 "GimpDesaturateMode",
428 "GimpDodgeBurnType",
429 "GimpFillType",
430 "GimpForegroundExtractMode",
431 "GimpGradientBlendColorSpace",
432 "GimpGradientSegmentColor",
433 "GimpGradientSegmentType",
434 "GimpGradientType",
435 "GimpGridStyle",
436 "GimpHistogramChannel",
437 "GimpHueRange",
438 "GimpIconType",
439 "GimpImageBaseType",
440 "GimpImageType",
441 "GimpInkBlobType",
442 "GimpInterpolationType",
443 "GimpJoinStyle",
444 "GimpLayerColorSpace",
445 "GimpLayerCompositeMode",
446 "GimpLayerMode",
447 "GimpMaskApplyMode",
448 "GimpMergeType",
449 "GimpMessageHandlerType",
450 "GimpOffsetType",
451 "GimpOrientationType",
452 "GimpPDBArgType",
453 "GimpPDBErrorHandler",
454 "GimpPDBProcType",
455 "GimpPDBStatusType",
456 "GimpPaintApplicationMode",
457 "GimpPrecision",
458 "GimpProgressCommand",
459 "GimpRepeatMode",
460 "GimpRotationType",
461 "GimpRunMode",
462 "GimpSelectCriterion",
463 "GimpSizeType",
464 "GimpStackTraceMode",
465 "GimpStrokeMethod",
466 "GimpTextDirection",
467 "GimpTextHintStyle",
468 "GimpTextJustification",
469 "GimpTransferMode",
470 "GimpTransformDirection",
471 "GimpTransformResize",
472 "GimpUserDirectory",
473 "GimpVectorsStrokeType"
474 };
475
476 static gboolean enums_initialized = FALSE;
477
478 GType gimp_convert_dither_type_compat_get_type (void);
479 GType gimp_layer_mode_effects_get_type (void);
480
481 /**
482 * gimp_enums_init:
483 *
484 * This function makes sure all the enum types are registered
485 * with the #GType system. This is intended for use by language
486 * bindings that need the symbols early, before gimp_main is run.
487 * It's not necessary for plug-ins to call this directly, because
488 * the normal plug-in initialization code will handle it implicitly.
489 *
490 * Since: 2.4
491 **/
492 void
gimp_enums_init(void)493 gimp_enums_init (void)
494 {
495 const GimpGetTypeFunc *funcs = get_type_funcs;
496 GQuark quark;
497 gint i;
498
499 if (enums_initialized)
500 return;
501
502 for (i = 0; i < G_N_ELEMENTS (get_type_funcs); i++, funcs++)
503 {
504 GType type = (*funcs) ();
505
506 g_type_class_ref (type);
507 }
508
509 /* keep compat enum code in sync with app/app.c (app_libs_init) */
510 quark = g_quark_from_static_string ("gimp-compat-enum");
511
512 g_type_set_qdata (GIMP_TYPE_CONVERT_DITHER_TYPE, quark,
513 (gpointer) gimp_convert_dither_type_compat_get_type ());
514 g_type_set_qdata (GIMP_TYPE_LAYER_MODE, quark,
515 (gpointer) gimp_layer_mode_effects_get_type ());
516
517 gimp_base_compat_enums_init ();
518
519 enums_initialized = TRUE;
520 }
521
522 /**
523 * gimp_enums_get_type_names:
524 * @n_type_names: return location for the number of names
525 *
526 * This function gives access to the list of enums registered by libgimp.
527 * The returned array is static and must not be modified.
528 *
529 * Return value: an array with type names
530 *
531 * Since: 2.2
532 **/
533 const gchar **
gimp_enums_get_type_names(gint * n_type_names)534 gimp_enums_get_type_names (gint *n_type_names)
535 {
536 g_return_val_if_fail (n_type_names != NULL, NULL);
537
538 *n_type_names = G_N_ELEMENTS (type_names);
539
540 return (const gchar **) type_names;
541 }
542