← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/core/core-enums.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mto: This revision was merged to the branch mainline in revision 12.
  • Revision ID: james.westby@ubuntu.com-20070502163303-6wchheivjxgjtlna
Tags: upstream-2.3.16
Import upstream version 2.3.16

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/core/core-enums.c
9
9
 
10
10
/* enumerations from "./core-enums.h" */
11
11
GType
12
 
gimp_add_mask_type_get_type (void)
13
 
{
14
 
  static const GEnumValue values[] =
15
 
  {
16
 
    { GIMP_ADD_WHITE_MASK, "GIMP_ADD_WHITE_MASK", "white-mask" },
17
 
    { GIMP_ADD_BLACK_MASK, "GIMP_ADD_BLACK_MASK", "black-mask" },
18
 
    { GIMP_ADD_ALPHA_MASK, "GIMP_ADD_ALPHA_MASK", "alpha-mask" },
19
 
    { GIMP_ADD_ALPHA_TRANSFER_MASK, "GIMP_ADD_ALPHA_TRANSFER_MASK", "alpha-transfer-mask" },
20
 
    { GIMP_ADD_SELECTION_MASK, "GIMP_ADD_SELECTION_MASK", "selection-mask" },
21
 
    { GIMP_ADD_COPY_MASK, "GIMP_ADD_COPY_MASK", "copy-mask" },
22
 
    { 0, NULL, NULL }
23
 
  };
24
 
 
25
 
  static const GimpEnumDesc descs[] =
26
 
  {
27
 
    { GIMP_ADD_WHITE_MASK, N_("_White (full opacity)"), NULL },
28
 
    { GIMP_ADD_BLACK_MASK, N_("_Black (full transparency)"), NULL },
29
 
    { GIMP_ADD_ALPHA_MASK, N_("Layer's _alpha channel"), NULL },
30
 
    { GIMP_ADD_ALPHA_TRANSFER_MASK, N_("_Transfer layer's alpha channel"), NULL },
31
 
    { GIMP_ADD_SELECTION_MASK, N_("_Selection"), NULL },
32
 
    { GIMP_ADD_COPY_MASK, N_("_Grayscale copy of layer"), NULL },
33
 
    { 0, NULL, NULL }
34
 
  };
35
 
 
36
 
  static GType type = 0;
37
 
 
38
 
  if (! type)
39
 
    {
40
 
      type = g_enum_register_static ("GimpAddMaskType", values);
41
 
      gimp_enum_set_value_descriptions (type, descs);
42
 
    }
43
 
 
44
 
  return type;
45
 
}
46
 
 
47
 
GType
48
 
gimp_blend_mode_get_type (void)
49
 
{
50
 
  static const GEnumValue values[] =
51
 
  {
52
 
    { GIMP_FG_BG_RGB_MODE, "GIMP_FG_BG_RGB_MODE", "fg-bg-rgb-mode" },
53
 
    { GIMP_FG_BG_HSV_MODE, "GIMP_FG_BG_HSV_MODE", "fg-bg-hsv-mode" },
54
 
    { GIMP_FG_TRANSPARENT_MODE, "GIMP_FG_TRANSPARENT_MODE", "fg-transparent-mode" },
55
 
    { GIMP_CUSTOM_MODE, "GIMP_CUSTOM_MODE", "custom-mode" },
56
 
    { 0, NULL, NULL }
57
 
  };
58
 
 
59
 
  static const GimpEnumDesc descs[] =
60
 
  {
61
 
    { GIMP_FG_BG_RGB_MODE, N_("FG to BG (RGB)"), NULL },
62
 
    { GIMP_FG_BG_HSV_MODE, N_("FG to BG (HSV)"), NULL },
63
 
    { GIMP_FG_TRANSPARENT_MODE, N_("FG to transparent"), NULL },
64
 
    { GIMP_CUSTOM_MODE, N_("Custom gradient"), NULL },
65
 
    { 0, NULL, NULL }
66
 
  };
67
 
 
68
 
  static GType type = 0;
69
 
 
70
 
  if (! type)
71
 
    {
72
 
      type = g_enum_register_static ("GimpBlendMode", values);
73
 
      gimp_enum_set_value_descriptions (type, descs);
74
 
    }
75
 
 
76
 
  return type;
77
 
}
78
 
 
79
 
GType
80
 
gimp_bucket_fill_mode_get_type (void)
81
 
{
82
 
  static const GEnumValue values[] =
83
 
  {
84
 
    { GIMP_FG_BUCKET_FILL, "GIMP_FG_BUCKET_FILL", "fg-bucket-fill" },
85
 
    { GIMP_BG_BUCKET_FILL, "GIMP_BG_BUCKET_FILL", "bg-bucket-fill" },
86
 
    { GIMP_PATTERN_BUCKET_FILL, "GIMP_PATTERN_BUCKET_FILL", "pattern-bucket-fill" },
87
 
    { 0, NULL, NULL }
88
 
  };
89
 
 
90
 
  static const GimpEnumDesc descs[] =
91
 
  {
92
 
    { GIMP_FG_BUCKET_FILL, N_("FG color fill"), NULL },
93
 
    { GIMP_BG_BUCKET_FILL, N_("BG color fill"), NULL },
94
 
    { GIMP_PATTERN_BUCKET_FILL, N_("Pattern fill"), NULL },
95
 
    { 0, NULL, NULL }
96
 
  };
97
 
 
98
 
  static GType type = 0;
99
 
 
100
 
  if (! type)
101
 
    {
102
 
      type = g_enum_register_static ("GimpBucketFillMode", values);
103
 
      gimp_enum_set_value_descriptions (type, descs);
104
 
    }
105
 
 
106
 
  return type;
107
 
}
108
 
 
109
 
GType
110
 
gimp_channel_ops_get_type (void)
111
 
{
112
 
  static const GEnumValue values[] =
113
 
  {
114
 
    { GIMP_CHANNEL_OP_ADD, "GIMP_CHANNEL_OP_ADD", "add" },
115
 
    { GIMP_CHANNEL_OP_SUBTRACT, "GIMP_CHANNEL_OP_SUBTRACT", "subtract" },
116
 
    { GIMP_CHANNEL_OP_REPLACE, "GIMP_CHANNEL_OP_REPLACE", "replace" },
117
 
    { GIMP_CHANNEL_OP_INTERSECT, "GIMP_CHANNEL_OP_INTERSECT", "intersect" },
118
 
    { 0, NULL, NULL }
119
 
  };
120
 
 
121
 
  static const GimpEnumDesc descs[] =
122
 
  {
123
 
    { GIMP_CHANNEL_OP_ADD, N_("Add to the current selection"), NULL },
124
 
    { GIMP_CHANNEL_OP_SUBTRACT, N_("Subtract from the current selection"), NULL },
125
 
    { GIMP_CHANNEL_OP_REPLACE, N_("Replace the current selection"), NULL },
126
 
    { GIMP_CHANNEL_OP_INTERSECT, N_("Intersect with the current selection"), NULL },
127
 
    { 0, NULL, NULL }
128
 
  };
129
 
 
130
 
  static GType type = 0;
131
 
 
132
 
  if (! type)
133
 
    {
134
 
      type = g_enum_register_static ("GimpChannelOps", values);
135
 
      gimp_enum_set_value_descriptions (type, descs);
136
 
    }
137
 
 
138
 
  return type;
139
 
}
140
 
 
141
 
GType
142
 
gimp_channel_type_get_type (void)
143
 
{
144
 
  static const GEnumValue values[] =
145
 
  {
146
 
    { GIMP_RED_CHANNEL, "GIMP_RED_CHANNEL", "red-channel" },
147
 
    { GIMP_GREEN_CHANNEL, "GIMP_GREEN_CHANNEL", "green-channel" },
148
 
    { GIMP_BLUE_CHANNEL, "GIMP_BLUE_CHANNEL", "blue-channel" },
149
 
    { GIMP_GRAY_CHANNEL, "GIMP_GRAY_CHANNEL", "gray-channel" },
150
 
    { GIMP_INDEXED_CHANNEL, "GIMP_INDEXED_CHANNEL", "indexed-channel" },
151
 
    { GIMP_ALPHA_CHANNEL, "GIMP_ALPHA_CHANNEL", "alpha-channel" },
152
 
    { 0, NULL, NULL }
153
 
  };
154
 
 
155
 
  static const GimpEnumDesc descs[] =
156
 
  {
157
 
    { GIMP_RED_CHANNEL, N_("Red"), NULL },
158
 
    { GIMP_GREEN_CHANNEL, N_("Green"), NULL },
159
 
    { GIMP_BLUE_CHANNEL, N_("Blue"), NULL },
160
 
    { GIMP_GRAY_CHANNEL, N_("Gray"), NULL },
161
 
    { GIMP_INDEXED_CHANNEL, N_("Indexed"), NULL },
162
 
    { GIMP_ALPHA_CHANNEL, N_("Alpha"), NULL },
163
 
    { 0, NULL, NULL }
164
 
  };
165
 
 
166
 
  static GType type = 0;
167
 
 
168
 
  if (! type)
169
 
    {
170
 
      type = g_enum_register_static ("GimpChannelType", values);
171
 
      gimp_enum_set_value_descriptions (type, descs);
172
 
    }
173
 
 
174
 
  return type;
175
 
}
176
 
 
177
 
GType
178
12
gimp_container_policy_get_type (void)
179
13
{
180
14
  static const GEnumValue values[] =
311
145
}
312
146
 
313
147
GType
 
148
gimp_alignment_type_get_type (void)
 
149
{
 
150
  static const GEnumValue values[] =
 
151
  {
 
152
    { GIMP_ALIGN_LEFT, "GIMP_ALIGN_LEFT", "align-left" },
 
153
    { GIMP_ALIGN_HCENTER, "GIMP_ALIGN_HCENTER", "align-hcenter" },
 
154
    { GIMP_ALIGN_RIGHT, "GIMP_ALIGN_RIGHT", "align-right" },
 
155
    { GIMP_ALIGN_TOP, "GIMP_ALIGN_TOP", "align-top" },
 
156
    { GIMP_ALIGN_VCENTER, "GIMP_ALIGN_VCENTER", "align-vcenter" },
 
157
    { GIMP_ALIGN_BOTTOM, "GIMP_ALIGN_BOTTOM", "align-bottom" },
 
158
    { GIMP_ARRANGE_LEFT, "GIMP_ARRANGE_LEFT", "arrange-left" },
 
159
    { GIMP_ARRANGE_HCENTER, "GIMP_ARRANGE_HCENTER", "arrange-hcenter" },
 
160
    { GIMP_ARRANGE_RIGHT, "GIMP_ARRANGE_RIGHT", "arrange-right" },
 
161
    { GIMP_ARRANGE_TOP, "GIMP_ARRANGE_TOP", "arrange-top" },
 
162
    { GIMP_ARRANGE_VCENTER, "GIMP_ARRANGE_VCENTER", "arrange-vcenter" },
 
163
    { GIMP_ARRANGE_BOTTOM, "GIMP_ARRANGE_BOTTOM", "arrange-bottom" },
 
164
    { 0, NULL, NULL }
 
165
  };
 
166
 
 
167
  static const GimpEnumDesc descs[] =
 
168
  {
 
169
    { GIMP_ALIGN_LEFT, "GIMP_ALIGN_LEFT", NULL },
 
170
    { GIMP_ALIGN_HCENTER, "GIMP_ALIGN_HCENTER", NULL },
 
171
    { GIMP_ALIGN_RIGHT, "GIMP_ALIGN_RIGHT", NULL },
 
172
    { GIMP_ALIGN_TOP, "GIMP_ALIGN_TOP", NULL },
 
173
    { GIMP_ALIGN_VCENTER, "GIMP_ALIGN_VCENTER", NULL },
 
174
    { GIMP_ALIGN_BOTTOM, "GIMP_ALIGN_BOTTOM", NULL },
 
175
    { GIMP_ARRANGE_LEFT, "GIMP_ARRANGE_LEFT", NULL },
 
176
    { GIMP_ARRANGE_HCENTER, "GIMP_ARRANGE_HCENTER", NULL },
 
177
    { GIMP_ARRANGE_RIGHT, "GIMP_ARRANGE_RIGHT", NULL },
 
178
    { GIMP_ARRANGE_TOP, "GIMP_ARRANGE_TOP", NULL },
 
179
    { GIMP_ARRANGE_VCENTER, "GIMP_ARRANGE_VCENTER", NULL },
 
180
    { GIMP_ARRANGE_BOTTOM, "GIMP_ARRANGE_BOTTOM", NULL },
 
181
    { 0, NULL, NULL }
 
182
  };
 
183
 
 
184
  static GType type = 0;
 
185
 
 
186
  if (! type)
 
187
    {
 
188
      type = g_enum_register_static ("GimpAlignmentType", values);
 
189
      gimp_enum_set_value_descriptions (type, descs);
 
190
    }
 
191
 
 
192
  return type;
 
193
}
 
194
 
 
195
GType
 
196
gimp_align_reference_type_get_type (void)
 
197
{
 
198
  static const GEnumValue values[] =
 
199
  {
 
200
    { GIMP_ALIGN_REFERENCE_FIRST, "GIMP_ALIGN_REFERENCE_FIRST", "first" },
 
201
    { GIMP_ALIGN_REFERENCE_IMAGE, "GIMP_ALIGN_REFERENCE_IMAGE", "image" },
 
202
    { GIMP_ALIGN_REFERENCE_SELECTION, "GIMP_ALIGN_REFERENCE_SELECTION", "selection" },
 
203
    { GIMP_ALIGN_REFERENCE_ACTIVE_LAYER, "GIMP_ALIGN_REFERENCE_ACTIVE_LAYER", "active-layer" },
 
204
    { GIMP_ALIGN_REFERENCE_ACTIVE_CHANNEL, "GIMP_ALIGN_REFERENCE_ACTIVE_CHANNEL", "active-channel" },
 
205
    { GIMP_ALIGN_REFERENCE_ACTIVE_PATH, "GIMP_ALIGN_REFERENCE_ACTIVE_PATH", "active-path" },
 
206
    { 0, NULL, NULL }
 
207
  };
 
208
 
 
209
  static const GimpEnumDesc descs[] =
 
210
  {
 
211
    { GIMP_ALIGN_REFERENCE_FIRST, N_("First item"), NULL },
 
212
    { GIMP_ALIGN_REFERENCE_IMAGE, N_("Image"), NULL },
 
213
    { GIMP_ALIGN_REFERENCE_SELECTION, N_("Selection"), NULL },
 
214
    { GIMP_ALIGN_REFERENCE_ACTIVE_LAYER, N_("Active layer"), NULL },
 
215
    { GIMP_ALIGN_REFERENCE_ACTIVE_CHANNEL, N_("Active channel"), NULL },
 
216
    { GIMP_ALIGN_REFERENCE_ACTIVE_PATH, N_("Active path"), NULL },
 
217
    { 0, NULL, NULL }
 
218
  };
 
219
 
 
220
  static GType type = 0;
 
221
 
 
222
  if (! type)
 
223
    {
 
224
      type = g_enum_register_static ("GimpAlignReferenceType", values);
 
225
      gimp_enum_set_value_descriptions (type, descs);
 
226
    }
 
227
 
 
228
  return type;
 
229
}
 
230
 
 
231
GType
314
232
gimp_fill_type_get_type (void)
315
233
{
316
234
  static const GEnumValue values[] =
347
265
}
348
266
 
349
267
GType
350
 
gimp_gradient_type_get_type (void)
351
 
{
352
 
  static const GEnumValue values[] =
353
 
  {
354
 
    { GIMP_GRADIENT_LINEAR, "GIMP_GRADIENT_LINEAR", "linear" },
355
 
    { GIMP_GRADIENT_BILINEAR, "GIMP_GRADIENT_BILINEAR", "bilinear" },
356
 
    { GIMP_GRADIENT_RADIAL, "GIMP_GRADIENT_RADIAL", "radial" },
357
 
    { GIMP_GRADIENT_SQUARE, "GIMP_GRADIENT_SQUARE", "square" },
358
 
    { GIMP_GRADIENT_CONICAL_SYMMETRIC, "GIMP_GRADIENT_CONICAL_SYMMETRIC", "conical-symmetric" },
359
 
    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, "GIMP_GRADIENT_CONICAL_ASYMMETRIC", "conical-asymmetric" },
360
 
    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, "GIMP_GRADIENT_SHAPEBURST_ANGULAR", "shapeburst-angular" },
361
 
    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, "GIMP_GRADIENT_SHAPEBURST_SPHERICAL", "shapeburst-spherical" },
362
 
    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, "GIMP_GRADIENT_SHAPEBURST_DIMPLED", "shapeburst-dimpled" },
363
 
    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, "GIMP_GRADIENT_SPIRAL_CLOCKWISE", "spiral-clockwise" },
364
 
    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, "GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE", "spiral-anticlockwise" },
365
 
    { 0, NULL, NULL }
366
 
  };
367
 
 
368
 
  static const GimpEnumDesc descs[] =
369
 
  {
370
 
    { GIMP_GRADIENT_LINEAR, N_("Linear"), NULL },
371
 
    { GIMP_GRADIENT_BILINEAR, N_("Bi-linear"), NULL },
372
 
    { GIMP_GRADIENT_RADIAL, N_("Radial"), NULL },
373
 
    { GIMP_GRADIENT_SQUARE, N_("Square"), NULL },
374
 
    { GIMP_GRADIENT_CONICAL_SYMMETRIC, N_("Conical (sym)"), NULL },
375
 
    { GIMP_GRADIENT_CONICAL_ASYMMETRIC, N_("Conical (asym)"), NULL },
376
 
    { GIMP_GRADIENT_SHAPEBURST_ANGULAR, N_("Shaped (angular)"), NULL },
377
 
    { GIMP_GRADIENT_SHAPEBURST_SPHERICAL, N_("Shaped (spherical)"), NULL },
378
 
    { GIMP_GRADIENT_SHAPEBURST_DIMPLED, N_("Shaped (dimpled)"), NULL },
379
 
    { GIMP_GRADIENT_SPIRAL_CLOCKWISE, N_("Spiral (cw)"), NULL },
380
 
    { GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, N_("Spiral (ccw)"), NULL },
381
 
    { 0, NULL, NULL }
382
 
  };
383
 
 
384
 
  static GType type = 0;
385
 
 
386
 
  if (! type)
387
 
    {
388
 
      type = g_enum_register_static ("GimpGradientType", values);
389
 
      gimp_enum_set_value_descriptions (type, descs);
390
 
    }
391
 
 
392
 
  return type;
393
 
}
394
 
 
395
 
GType
396
 
gimp_grid_style_get_type (void)
397
 
{
398
 
  static const GEnumValue values[] =
399
 
  {
400
 
    { GIMP_GRID_DOTS, "GIMP_GRID_DOTS", "dots" },
401
 
    { GIMP_GRID_INTERSECTIONS, "GIMP_GRID_INTERSECTIONS", "intersections" },
402
 
    { GIMP_GRID_ON_OFF_DASH, "GIMP_GRID_ON_OFF_DASH", "on-off-dash" },
403
 
    { GIMP_GRID_DOUBLE_DASH, "GIMP_GRID_DOUBLE_DASH", "double-dash" },
404
 
    { GIMP_GRID_SOLID, "GIMP_GRID_SOLID", "solid" },
405
 
    { 0, NULL, NULL }
406
 
  };
407
 
 
408
 
  static const GimpEnumDesc descs[] =
409
 
  {
410
 
    { GIMP_GRID_DOTS, N_("Intersections (dots)"), NULL },
411
 
    { GIMP_GRID_INTERSECTIONS, N_("Intersections (crosshairs)"), NULL },
412
 
    { GIMP_GRID_ON_OFF_DASH, N_("Dashed"), NULL },
413
 
    { GIMP_GRID_DOUBLE_DASH, N_("Double dashed"), NULL },
414
 
    { GIMP_GRID_SOLID, N_("Solid"), NULL },
415
 
    { 0, NULL, NULL }
416
 
  };
417
 
 
418
 
  static GType type = 0;
419
 
 
420
 
  if (! type)
421
 
    {
422
 
      type = g_enum_register_static ("GimpGridStyle", values);
423
 
      gimp_enum_set_value_descriptions (type, descs);
424
 
    }
425
 
 
426
 
  return type;
427
 
}
428
 
 
429
 
GType
430
268
gimp_stroke_method_get_type (void)
431
269
{
432
270
  static const GEnumValue values[] =
466
304
 
467
305
  static const GimpEnumDesc descs[] =
468
306
  {
469
 
    { GIMP_STROKE_STYLE_SOLID, N_("Solid"), NULL },
 
307
    { GIMP_STROKE_STYLE_SOLID, N_("Solid color"), NULL },
470
308
    { GIMP_STROKE_STYLE_PATTERN, N_("Pattern"), NULL },
471
309
    { 0, NULL, NULL }
472
310
  };
572
410
    { GIMP_DASH_NORMAL_DOTS, N_("Normal dots"), NULL },
573
411
    { GIMP_DASH_DENSE_DOTS, N_("Dense dots"), NULL },
574
412
    { GIMP_DASH_STIPPLES, N_("Stipples"), NULL },
575
 
    { GIMP_DASH_DASH_DOT, N_("Dash dot..."), NULL },
576
 
    { GIMP_DASH_DASH_DOT_DOT, N_("Dash dot dot..."), NULL },
 
413
    { GIMP_DASH_DASH_DOT, N_("Dash, dot"), NULL },
 
414
    { GIMP_DASH_DASH_DOT_DOT, N_("Dash, dot, dot"), NULL },
577
415
    { 0, NULL, NULL }
578
416
  };
579
417
 
589
427
}
590
428
 
591
429
GType
592
 
gimp_icon_type_get_type (void)
593
 
{
594
 
  static const GEnumValue values[] =
595
 
  {
596
 
    { GIMP_ICON_TYPE_STOCK_ID, "GIMP_ICON_TYPE_STOCK_ID", "stock-id" },
597
 
    { GIMP_ICON_TYPE_INLINE_PIXBUF, "GIMP_ICON_TYPE_INLINE_PIXBUF", "inline-pixbuf" },
598
 
    { GIMP_ICON_TYPE_IMAGE_FILE, "GIMP_ICON_TYPE_IMAGE_FILE", "image-file" },
599
 
    { 0, NULL, NULL }
600
 
  };
601
 
 
602
 
  static const GimpEnumDesc descs[] =
603
 
  {
604
 
    { GIMP_ICON_TYPE_STOCK_ID, N_("Stock ID"), NULL },
605
 
    { GIMP_ICON_TYPE_INLINE_PIXBUF, N_("Inline pixbuf"), NULL },
606
 
    { GIMP_ICON_TYPE_IMAGE_FILE, N_("Image file"), NULL },
607
 
    { 0, NULL, NULL }
608
 
  };
609
 
 
610
 
  static GType type = 0;
611
 
 
612
 
  if (! type)
613
 
    {
614
 
      type = g_enum_register_static ("GimpIconType", values);
615
 
      gimp_enum_set_value_descriptions (type, descs);
616
 
    }
617
 
 
618
 
  return type;
619
 
}
620
 
 
621
 
GType
622
430
gimp_brush_generated_shape_get_type (void)
623
431
{
624
432
  static const GEnumValue values[] =
679
487
}
680
488
 
681
489
GType
 
490
gimp_item_set_get_type (void)
 
491
{
 
492
  static const GEnumValue values[] =
 
493
  {
 
494
    { GIMP_ITEM_SET_NONE, "GIMP_ITEM_SET_NONE", "none" },
 
495
    { GIMP_ITEM_SET_ALL, "GIMP_ITEM_SET_ALL", "all" },
 
496
    { GIMP_ITEM_SET_IMAGE_SIZED, "GIMP_ITEM_SET_IMAGE_SIZED", "image-sized" },
 
497
    { GIMP_ITEM_SET_VISIBLE, "GIMP_ITEM_SET_VISIBLE", "visible" },
 
498
    { GIMP_ITEM_SET_LINKED, "GIMP_ITEM_SET_LINKED", "linked" },
 
499
    { 0, NULL, NULL }
 
500
  };
 
501
 
 
502
  static const GimpEnumDesc descs[] =
 
503
  {
 
504
    { GIMP_ITEM_SET_NONE, N_("None"), NULL },
 
505
    { GIMP_ITEM_SET_ALL, N_("All layers"), NULL },
 
506
    { GIMP_ITEM_SET_IMAGE_SIZED, N_("Image-sized layers"), NULL },
 
507
    { GIMP_ITEM_SET_VISIBLE, N_("All visible layers"), NULL },
 
508
    { GIMP_ITEM_SET_LINKED, N_("All linked layers"), NULL },
 
509
    { 0, NULL, NULL }
 
510
  };
 
511
 
 
512
  static GType type = 0;
 
513
 
 
514
  if (! type)
 
515
    {
 
516
      type = g_enum_register_static ("GimpItemSet", values);
 
517
      gimp_enum_set_value_descriptions (type, descs);
 
518
    }
 
519
 
 
520
  return type;
 
521
}
 
522
 
 
523
GType
682
524
gimp_rotation_type_get_type (void)
683
525
{
684
526
  static const GEnumValue values[] =
751
593
}
752
594
 
753
595
GType
754
 
gimp_repeat_mode_get_type (void)
 
596
gimp_view_type_get_type (void)
755
597
{
756
598
  static const GEnumValue values[] =
757
599
  {
758
 
    { GIMP_REPEAT_NONE, "GIMP_REPEAT_NONE", "none" },
759
 
    { GIMP_REPEAT_SAWTOOTH, "GIMP_REPEAT_SAWTOOTH", "sawtooth" },
760
 
    { GIMP_REPEAT_TRIANGULAR, "GIMP_REPEAT_TRIANGULAR", "triangular" },
 
600
    { GIMP_VIEW_TYPE_LIST, "GIMP_VIEW_TYPE_LIST", "list" },
 
601
    { GIMP_VIEW_TYPE_GRID, "GIMP_VIEW_TYPE_GRID", "grid" },
761
602
    { 0, NULL, NULL }
762
603
  };
763
604
 
764
605
  static const GimpEnumDesc descs[] =
765
606
  {
766
 
    { GIMP_REPEAT_NONE, N_("None"), NULL },
767
 
    { GIMP_REPEAT_SAWTOOTH, N_("Sawtooth wave"), NULL },
768
 
    { GIMP_REPEAT_TRIANGULAR, N_("Triangular wave"), NULL },
 
607
    { GIMP_VIEW_TYPE_LIST, N_("View as list"), NULL },
 
608
    { GIMP_VIEW_TYPE_GRID, N_("View as grid"), NULL },
769
609
    { 0, NULL, NULL }
770
610
  };
771
611
 
773
613
 
774
614
  if (! type)
775
615
    {
776
 
      type = g_enum_register_static ("GimpRepeatMode", values);
 
616
      type = g_enum_register_static ("GimpViewType", values);
777
617
      gimp_enum_set_value_descriptions (type, descs);
778
618
    }
779
619
 
845
685
}
846
686
 
847
687
GType
848
 
gimp_transform_direction_get_type (void)
849
 
{
850
 
  static const GEnumValue values[] =
851
 
  {
852
 
    { GIMP_TRANSFORM_FORWARD, "GIMP_TRANSFORM_FORWARD", "forward" },
853
 
    { GIMP_TRANSFORM_BACKWARD, "GIMP_TRANSFORM_BACKWARD", "backward" },
854
 
    { 0, NULL, NULL }
855
 
  };
856
 
 
857
 
  static const GimpEnumDesc descs[] =
858
 
  {
859
 
    { GIMP_TRANSFORM_FORWARD, N_("Forward (traditional)"), NULL },
860
 
    { GIMP_TRANSFORM_BACKWARD, N_("Backward (corrective)"), NULL },
861
 
    { 0, NULL, NULL }
862
 
  };
863
 
 
864
 
  static GType type = 0;
865
 
 
866
 
  if (! type)
867
 
    {
868
 
      type = g_enum_register_static ("GimpTransformDirection", values);
869
 
      gimp_enum_set_value_descriptions (type, descs);
870
 
    }
871
 
 
872
 
  return type;
873
 
}
874
 
 
875
 
GType
876
688
gimp_undo_mode_get_type (void)
877
689
{
878
690
  static const GEnumValue values[] =
955
767
    { GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, "GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE", "group-image-item-remove" },
956
768
    { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, "GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE", "group-image-layers-merge" },
957
769
    { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, "GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE", "group-image-vectors-merge" },
958
 
    { GIMP_UNDO_GROUP_IMAGE_QMASK, "GIMP_UNDO_GROUP_IMAGE_QMASK", "group-image-qmask" },
 
770
    { GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, "GIMP_UNDO_GROUP_IMAGE_QUICK_MASK", "group-image-quick-mask" },
959
771
    { GIMP_UNDO_GROUP_IMAGE_GRID, "GIMP_UNDO_GROUP_IMAGE_GRID", "group-image-grid" },
960
 
    { GIMP_UNDO_GROUP_IMAGE_GUIDE, "GIMP_UNDO_GROUP_IMAGE_GUIDE", "group-image-guide" },
 
772
    { GIMP_UNDO_GROUP_GUIDE, "GIMP_UNDO_GROUP_GUIDE", "group-guide" },
 
773
    { GIMP_UNDO_GROUP_SAMPLE_POINT, "GIMP_UNDO_GROUP_SAMPLE_POINT", "group-sample-point" },
961
774
    { GIMP_UNDO_GROUP_DRAWABLE, "GIMP_UNDO_GROUP_DRAWABLE", "group-drawable" },
962
775
    { GIMP_UNDO_GROUP_DRAWABLE_MOD, "GIMP_UNDO_GROUP_DRAWABLE_MOD", "group-drawable-mod" },
963
776
    { GIMP_UNDO_GROUP_MASK, "GIMP_UNDO_GROUP_MASK", "group-mask" },
967
780
    { GIMP_UNDO_GROUP_ITEM_DISPLACE, "GIMP_UNDO_GROUP_ITEM_DISPLACE", "group-item-displace" },
968
781
    { GIMP_UNDO_GROUP_ITEM_SCALE, "GIMP_UNDO_GROUP_ITEM_SCALE", "group-item-scale" },
969
782
    { GIMP_UNDO_GROUP_ITEM_RESIZE, "GIMP_UNDO_GROUP_ITEM_RESIZE", "group-item-resize" },
 
783
    { GIMP_UNDO_GROUP_LAYER_ADD, "GIMP_UNDO_GROUP_LAYER_ADD", "group-layer-add" },
970
784
    { GIMP_UNDO_GROUP_LAYER_ADD_MASK, "GIMP_UNDO_GROUP_LAYER_ADD_MASK", "group-layer-add-mask" },
971
785
    { GIMP_UNDO_GROUP_LAYER_APPLY_MASK, "GIMP_UNDO_GROUP_LAYER_APPLY_MASK", "group-layer-apply-mask" },
972
786
    { GIMP_UNDO_GROUP_FS_TO_LAYER, "GIMP_UNDO_GROUP_FS_TO_LAYER", "group-fs-to-layer" },
986
800
    { GIMP_UNDO_IMAGE_SIZE, "GIMP_UNDO_IMAGE_SIZE", "image-size" },
987
801
    { GIMP_UNDO_IMAGE_RESOLUTION, "GIMP_UNDO_IMAGE_RESOLUTION", "image-resolution" },
988
802
    { GIMP_UNDO_IMAGE_GRID, "GIMP_UNDO_IMAGE_GRID", "image-grid" },
989
 
    { GIMP_UNDO_IMAGE_GUIDE, "GIMP_UNDO_IMAGE_GUIDE", "image-guide" },
990
803
    { GIMP_UNDO_IMAGE_COLORMAP, "GIMP_UNDO_IMAGE_COLORMAP", "image-colormap" },
 
804
    { GIMP_UNDO_GUIDE, "GIMP_UNDO_GUIDE", "guide" },
 
805
    { GIMP_UNDO_SAMPLE_POINT, "GIMP_UNDO_SAMPLE_POINT", "sample-point" },
991
806
    { GIMP_UNDO_DRAWABLE, "GIMP_UNDO_DRAWABLE", "drawable" },
992
807
    { GIMP_UNDO_DRAWABLE_MOD, "GIMP_UNDO_DRAWABLE_MOD", "drawable-mod" },
993
808
    { GIMP_UNDO_MASK, "GIMP_UNDO_MASK", "mask" },
997
812
    { GIMP_UNDO_ITEM_LINKED, "GIMP_UNDO_ITEM_LINKED", "item-linked" },
998
813
    { GIMP_UNDO_LAYER_ADD, "GIMP_UNDO_LAYER_ADD", "layer-add" },
999
814
    { GIMP_UNDO_LAYER_REMOVE, "GIMP_UNDO_LAYER_REMOVE", "layer-remove" },
1000
 
    { GIMP_UNDO_LAYER_MASK_ADD, "GIMP_UNDO_LAYER_MASK_ADD", "layer-mask-add" },
1001
 
    { GIMP_UNDO_LAYER_MASK_REMOVE, "GIMP_UNDO_LAYER_MASK_REMOVE", "layer-mask-remove" },
1002
815
    { GIMP_UNDO_LAYER_REPOSITION, "GIMP_UNDO_LAYER_REPOSITION", "layer-reposition" },
1003
816
    { GIMP_UNDO_LAYER_MODE, "GIMP_UNDO_LAYER_MODE", "layer-mode" },
1004
817
    { GIMP_UNDO_LAYER_OPACITY, "GIMP_UNDO_LAYER_OPACITY", "layer-opacity" },
1005
 
    { GIMP_UNDO_LAYER_PRESERVE_TRANS, "GIMP_UNDO_LAYER_PRESERVE_TRANS", "layer-preserve-trans" },
 
818
    { GIMP_UNDO_LAYER_LOCK_ALPHA, "GIMP_UNDO_LAYER_LOCK_ALPHA", "layer-lock-alpha" },
1006
819
    { GIMP_UNDO_TEXT_LAYER, "GIMP_UNDO_TEXT_LAYER", "text-layer" },
1007
820
    { GIMP_UNDO_TEXT_LAYER_MODIFIED, "GIMP_UNDO_TEXT_LAYER_MODIFIED", "text-layer-modified" },
 
821
    { GIMP_UNDO_LAYER_MASK_ADD, "GIMP_UNDO_LAYER_MASK_ADD", "layer-mask-add" },
 
822
    { GIMP_UNDO_LAYER_MASK_REMOVE, "GIMP_UNDO_LAYER_MASK_REMOVE", "layer-mask-remove" },
 
823
    { GIMP_UNDO_LAYER_MASK_APPLY, "GIMP_UNDO_LAYER_MASK_APPLY", "layer-mask-apply" },
 
824
    { GIMP_UNDO_LAYER_MASK_SHOW, "GIMP_UNDO_LAYER_MASK_SHOW", "layer-mask-show" },
1008
825
    { GIMP_UNDO_CHANNEL_ADD, "GIMP_UNDO_CHANNEL_ADD", "channel-add" },
1009
826
    { GIMP_UNDO_CHANNEL_REMOVE, "GIMP_UNDO_CHANNEL_REMOVE", "channel-remove" },
1010
827
    { GIMP_UNDO_CHANNEL_REPOSITION, "GIMP_UNDO_CHANNEL_REPOSITION", "channel-reposition" },
1019
836
    { GIMP_UNDO_TRANSFORM, "GIMP_UNDO_TRANSFORM", "transform" },
1020
837
    { GIMP_UNDO_PAINT, "GIMP_UNDO_PAINT", "paint" },
1021
838
    { GIMP_UNDO_INK, "GIMP_UNDO_INK", "ink" },
 
839
    { GIMP_UNDO_FOREGROUND_SELECT, "GIMP_UNDO_FOREGROUND_SELECT", "foreground-select" },
1022
840
    { GIMP_UNDO_PARASITE_ATTACH, "GIMP_UNDO_PARASITE_ATTACH", "parasite-attach" },
1023
841
    { GIMP_UNDO_PARASITE_REMOVE, "GIMP_UNDO_PARASITE_REMOVE", "parasite-remove" },
1024
842
    { GIMP_UNDO_CANT, "GIMP_UNDO_CANT", "cant" },
1036
854
    { GIMP_UNDO_GROUP_IMAGE_CONVERT, N_("Convert image"), NULL },
1037
855
    { GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, N_("Remove item"), NULL },
1038
856
    { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, N_("Merge layers"), NULL },
1039
 
    { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, N_("Merge vectors"), NULL },
1040
 
    { GIMP_UNDO_GROUP_IMAGE_QMASK, N_("Quick Mask"), NULL },
 
857
    { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, N_("Merge paths"), NULL },
 
858
    { GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, N_("Quick Mask"), NULL },
1041
859
    { GIMP_UNDO_GROUP_IMAGE_GRID, N_("Grid"), NULL },
1042
 
    { GIMP_UNDO_GROUP_IMAGE_GUIDE, N_("Guide"), NULL },
1043
 
    { GIMP_UNDO_GROUP_DRAWABLE, N_("Drawable"), NULL },
1044
 
    { GIMP_UNDO_GROUP_DRAWABLE_MOD, N_("Drawable mod"), NULL },
 
860
    { GIMP_UNDO_GROUP_GUIDE, N_("Guide"), NULL },
 
861
    { GIMP_UNDO_GROUP_SAMPLE_POINT, N_("Sample Point"), NULL },
 
862
    { GIMP_UNDO_GROUP_DRAWABLE, N_("Layer/Channel"), NULL },
 
863
    { GIMP_UNDO_GROUP_DRAWABLE_MOD, N_("Layer/Channel modification"), NULL },
1045
864
    { GIMP_UNDO_GROUP_MASK, N_("Selection mask"), NULL },
1046
865
    { GIMP_UNDO_GROUP_ITEM_VISIBILITY, N_("Item visibility"), NULL },
1047
 
    { GIMP_UNDO_GROUP_ITEM_LINKED, N_("Linked item"), NULL },
 
866
    { GIMP_UNDO_GROUP_ITEM_LINKED, N_("Link/Unlink item"), NULL },
1048
867
    { GIMP_UNDO_GROUP_ITEM_PROPERTIES, N_("Item properties"), NULL },
1049
868
    { GIMP_UNDO_GROUP_ITEM_DISPLACE, N_("Move item"), NULL },
1050
869
    { GIMP_UNDO_GROUP_ITEM_SCALE, N_("Scale item"), NULL },
1051
870
    { GIMP_UNDO_GROUP_ITEM_RESIZE, N_("Resize item"), NULL },
 
871
    { GIMP_UNDO_GROUP_LAYER_ADD, N_("Add layer"), NULL },
1052
872
    { GIMP_UNDO_GROUP_LAYER_ADD_MASK, N_("Add layer mask"), NULL },
1053
873
    { GIMP_UNDO_GROUP_LAYER_APPLY_MASK, N_("Apply layer mask"), NULL },
1054
874
    { GIMP_UNDO_GROUP_FS_TO_LAYER, N_("Floating selection to layer"), NULL },
1066
886
    { GIMP_UNDO_GROUP_MISC, N_("Plug-In"), NULL },
1067
887
    { GIMP_UNDO_IMAGE_TYPE, N_("Image type"), NULL },
1068
888
    { GIMP_UNDO_IMAGE_SIZE, N_("Image size"), NULL },
1069
 
    { GIMP_UNDO_IMAGE_RESOLUTION, N_("Resolution change"), NULL },
 
889
    { GIMP_UNDO_IMAGE_RESOLUTION, N_("Image resolution change"), NULL },
1070
890
    { GIMP_UNDO_IMAGE_GRID, N_("Grid"), NULL },
1071
 
    { GIMP_UNDO_IMAGE_GUIDE, N_("Guide"), NULL },
1072
891
    { GIMP_UNDO_IMAGE_COLORMAP, N_("Change indexed palette"), NULL },
1073
 
    { GIMP_UNDO_DRAWABLE, N_("Drawable"), NULL },
1074
 
    { GIMP_UNDO_DRAWABLE_MOD, N_("Drawable mod"), NULL },
 
892
    { GIMP_UNDO_GUIDE, N_("Guide"), NULL },
 
893
    { GIMP_UNDO_SAMPLE_POINT, N_("Sample Point"), NULL },
 
894
    { GIMP_UNDO_DRAWABLE, N_("Layer/Channel"), NULL },
 
895
    { GIMP_UNDO_DRAWABLE_MOD, N_("Layer/Channel modification"), NULL },
1075
896
    { GIMP_UNDO_MASK, N_("Selection mask"), NULL },
1076
897
    { GIMP_UNDO_ITEM_RENAME, N_("Rename item"), NULL },
1077
898
    { GIMP_UNDO_ITEM_DISPLACE, N_("Move item"), NULL },
1078
899
    { GIMP_UNDO_ITEM_VISIBILITY, N_("Item visibility"), NULL },
1079
 
    { GIMP_UNDO_ITEM_LINKED, N_("Set item linked"), NULL },
 
900
    { GIMP_UNDO_ITEM_LINKED, N_("Link/Unlink item"), NULL },
1080
901
    { GIMP_UNDO_LAYER_ADD, N_("New layer"), NULL },
1081
902
    { GIMP_UNDO_LAYER_REMOVE, N_("Delete layer"), NULL },
1082
 
    { GIMP_UNDO_LAYER_MASK_ADD, N_("Add layer mask"), NULL },
1083
 
    { GIMP_UNDO_LAYER_MASK_REMOVE, N_("Delete layer mask"), NULL },
1084
903
    { GIMP_UNDO_LAYER_REPOSITION, N_("Reposition layer"), NULL },
1085
904
    { GIMP_UNDO_LAYER_MODE, N_("Set layer mode"), NULL },
1086
905
    { GIMP_UNDO_LAYER_OPACITY, N_("Set layer opacity"), NULL },
1087
 
    { GIMP_UNDO_LAYER_PRESERVE_TRANS, N_("Set preserve trans"), NULL },
1088
 
    { GIMP_UNDO_TEXT_LAYER, N_("Text"), NULL },
1089
 
    { GIMP_UNDO_TEXT_LAYER_MODIFIED, N_("Text modified"), NULL },
 
906
    { GIMP_UNDO_LAYER_LOCK_ALPHA, N_("Lock/Unlock alpha channel"), NULL },
 
907
    { GIMP_UNDO_TEXT_LAYER, N_("Text layer"), NULL },
 
908
    { GIMP_UNDO_TEXT_LAYER_MODIFIED, N_("Text layer modification"), NULL },
 
909
    { GIMP_UNDO_LAYER_MASK_ADD, N_("Add layer mask"), NULL },
 
910
    { GIMP_UNDO_LAYER_MASK_REMOVE, N_("Delete layer mask"), NULL },
 
911
    { GIMP_UNDO_LAYER_MASK_APPLY, N_("Apply layer mask"), NULL },
 
912
    { GIMP_UNDO_LAYER_MASK_SHOW, N_("Show layer mask"), NULL },
1090
913
    { GIMP_UNDO_CHANNEL_ADD, N_("New channel"), NULL },
1091
914
    { GIMP_UNDO_CHANNEL_REMOVE, N_("Delete channel"), NULL },
1092
915
    { GIMP_UNDO_CHANNEL_REPOSITION, N_("Reposition channel"), NULL },
1093
916
    { GIMP_UNDO_CHANNEL_COLOR, N_("Channel color"), NULL },
1094
 
    { GIMP_UNDO_VECTORS_ADD, N_("New vectors"), NULL },
1095
 
    { GIMP_UNDO_VECTORS_REMOVE, N_("Delete vectors"), NULL },
1096
 
    { GIMP_UNDO_VECTORS_MOD, N_("Vectors mod"), NULL },
1097
 
    { GIMP_UNDO_VECTORS_REPOSITION, N_("Reposition vectors"), NULL },
1098
 
    { GIMP_UNDO_FS_TO_LAYER, N_("FS to layer"), NULL },
 
917
    { GIMP_UNDO_VECTORS_ADD, N_("New path"), NULL },
 
918
    { GIMP_UNDO_VECTORS_REMOVE, N_("Delete path"), NULL },
 
919
    { GIMP_UNDO_VECTORS_MOD, N_("Path modification"), NULL },
 
920
    { GIMP_UNDO_VECTORS_REPOSITION, N_("Reposition path"), NULL },
 
921
    { GIMP_UNDO_FS_TO_LAYER, N_("Floating selection to layer"), NULL },
1099
922
    { GIMP_UNDO_FS_RIGOR, N_("FS rigor"), NULL },
1100
923
    { GIMP_UNDO_FS_RELAX, N_("FS relax"), NULL },
1101
924
    { GIMP_UNDO_TRANSFORM, N_("Transform"), NULL },
1102
925
    { GIMP_UNDO_PAINT, N_("Paint"), NULL },
1103
926
    { GIMP_UNDO_INK, N_("Ink"), NULL },
 
927
    { GIMP_UNDO_FOREGROUND_SELECT, N_("Select foreground"), NULL },
1104
928
    { GIMP_UNDO_PARASITE_ATTACH, N_("Attach parasite"), NULL },
1105
929
    { GIMP_UNDO_PARASITE_REMOVE, N_("Remove parasite"), NULL },
1106
930
    { GIMP_UNDO_CANT, N_("EEK: can't undo"), NULL },
1164
988
  return type;
1165
989
}
1166
990
 
 
991
GType
 
992
gimp_offset_type_get_type (void)
 
993
{
 
994
  static const GEnumValue values[] =
 
995
  {
 
996
    { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", "background" },
 
997
    { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", "transparent" },
 
998
    { 0, NULL, NULL }
 
999
  };
 
1000
 
 
1001
  static const GimpEnumDesc descs[] =
 
1002
  {
 
1003
    { GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", NULL },
 
1004
    { GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", NULL },
 
1005
    { 0, NULL, NULL }
 
1006
  };
 
1007
 
 
1008
  static GType type = 0;
 
1009
 
 
1010
  if (! type)
 
1011
    {
 
1012
      type = g_enum_register_static ("GimpOffsetType", values);
 
1013
      gimp_enum_set_value_descriptions (type, descs);
 
1014
    }
 
1015
 
 
1016
  return type;
 
1017
}
 
1018
 
 
1019
GType
 
1020
gimp_gradient_color_get_type (void)
 
1021
{
 
1022
  static const GEnumValue values[] =
 
1023
  {
 
1024
    { GIMP_GRADIENT_COLOR_FIXED, "GIMP_GRADIENT_COLOR_FIXED", "fixed" },
 
1025
    { GIMP_GRADIENT_COLOR_FOREGROUND, "GIMP_GRADIENT_COLOR_FOREGROUND", "foreground" },
 
1026
    { GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT", "foreground-transparent" },
 
1027
    { GIMP_GRADIENT_COLOR_BACKGROUND, "GIMP_GRADIENT_COLOR_BACKGROUND", "background" },
 
1028
    { GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT", "background-transparent" },
 
1029
    { 0, NULL, NULL }
 
1030
  };
 
1031
 
 
1032
  static const GimpEnumDesc descs[] =
 
1033
  {
 
1034
    { GIMP_GRADIENT_COLOR_FIXED, "GIMP_GRADIENT_COLOR_FIXED", NULL },
 
1035
    { GIMP_GRADIENT_COLOR_FOREGROUND, "GIMP_GRADIENT_COLOR_FOREGROUND", NULL },
 
1036
    { GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT", NULL },
 
1037
    { GIMP_GRADIENT_COLOR_BACKGROUND, "GIMP_GRADIENT_COLOR_BACKGROUND", NULL },
 
1038
    { GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT", NULL },
 
1039
    { 0, NULL, NULL }
 
1040
  };
 
1041
 
 
1042
  static GType type = 0;
 
1043
 
 
1044
  if (! type)
 
1045
    {
 
1046
      type = g_enum_register_static ("GimpGradientColor", values);
 
1047
      gimp_enum_set_value_descriptions (type, descs);
 
1048
    }
 
1049
 
 
1050
  return type;
 
1051
}
 
1052
 
 
1053
GType
 
1054
gimp_gradient_segment_type_get_type (void)
 
1055
{
 
1056
  static const GEnumValue values[] =
 
1057
  {
 
1058
    { GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", "linear" },
 
1059
    { GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", "curved" },
 
1060
    { GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", "sine" },
 
1061
    { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", "sphere-increasing" },
 
1062
    { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", "sphere-decreasing" },
 
1063
    { 0, NULL, NULL }
 
1064
  };
 
1065
 
 
1066
  static const GimpEnumDesc descs[] =
 
1067
  {
 
1068
    { GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", NULL },
 
1069
    { GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", NULL },
 
1070
    { GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", NULL },
 
1071
    { GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", NULL },
 
1072
    { GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", NULL },
 
1073
    { 0, NULL, NULL }
 
1074
  };
 
1075
 
 
1076
  static GType type = 0;
 
1077
 
 
1078
  if (! type)
 
1079
    {
 
1080
      type = g_enum_register_static ("GimpGradientSegmentType", values);
 
1081
      gimp_enum_set_value_descriptions (type, descs);
 
1082
    }
 
1083
 
 
1084
  return type;
 
1085
}
 
1086
 
 
1087
GType
 
1088
gimp_gradient_segment_color_get_type (void)
 
1089
{
 
1090
  static const GEnumValue values[] =
 
1091
  {
 
1092
    { GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", "rgb" },
 
1093
    { GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", "hsv-ccw" },
 
1094
    { GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", "hsv-cw" },
 
1095
    { 0, NULL, NULL }
 
1096
  };
 
1097
 
 
1098
  static const GimpEnumDesc descs[] =
 
1099
  {
 
1100
    { GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", NULL },
 
1101
    { GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", NULL },
 
1102
    { GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", NULL },
 
1103
    { 0, NULL, NULL }
 
1104
  };
 
1105
 
 
1106
  static GType type = 0;
 
1107
 
 
1108
  if (! type)
 
1109
    {
 
1110
      type = g_enum_register_static ("GimpGradientSegmentColor", values);
 
1111
      gimp_enum_set_value_descriptions (type, descs);
 
1112
    }
 
1113
 
 
1114
  return type;
 
1115
}
 
1116
 
 
1117
GType
 
1118
gimp_mask_apply_mode_get_type (void)
 
1119
{
 
1120
  static const GEnumValue values[] =
 
1121
  {
 
1122
    { GIMP_MASK_APPLY, "GIMP_MASK_APPLY", "apply" },
 
1123
    { GIMP_MASK_DISCARD, "GIMP_MASK_DISCARD", "discard" },
 
1124
    { 0, NULL, NULL }
 
1125
  };
 
1126
 
 
1127
  static const GimpEnumDesc descs[] =
 
1128
  {
 
1129
    { GIMP_MASK_APPLY, "GIMP_MASK_APPLY", NULL },
 
1130
    { GIMP_MASK_DISCARD, "GIMP_MASK_DISCARD", NULL },
 
1131
    { 0, NULL, NULL }
 
1132
  };
 
1133
 
 
1134
  static GType type = 0;
 
1135
 
 
1136
  if (! type)
 
1137
    {
 
1138
      type = g_enum_register_static ("GimpMaskApplyMode", values);
 
1139
      gimp_enum_set_value_descriptions (type, descs);
 
1140
    }
 
1141
 
 
1142
  return type;
 
1143
}
 
1144
 
 
1145
GType
 
1146
gimp_merge_type_get_type (void)
 
1147
{
 
1148
  static const GEnumValue values[] =
 
1149
  {
 
1150
    { GIMP_EXPAND_AS_NECESSARY, "GIMP_EXPAND_AS_NECESSARY", "expand-as-necessary" },
 
1151
    { GIMP_CLIP_TO_IMAGE, "GIMP_CLIP_TO_IMAGE", "clip-to-image" },
 
1152
    { GIMP_CLIP_TO_BOTTOM_LAYER, "GIMP_CLIP_TO_BOTTOM_LAYER", "clip-to-bottom-layer" },
 
1153
    { GIMP_FLATTEN_IMAGE, "GIMP_FLATTEN_IMAGE", "flatten-image" },
 
1154
    { 0, NULL, NULL }
 
1155
  };
 
1156
 
 
1157
  static const GimpEnumDesc descs[] =
 
1158
  {
 
1159
    { GIMP_EXPAND_AS_NECESSARY, "GIMP_EXPAND_AS_NECESSARY", NULL },
 
1160
    { GIMP_CLIP_TO_IMAGE, "GIMP_CLIP_TO_IMAGE", NULL },
 
1161
    { GIMP_CLIP_TO_BOTTOM_LAYER, "GIMP_CLIP_TO_BOTTOM_LAYER", NULL },
 
1162
    { GIMP_FLATTEN_IMAGE, "GIMP_FLATTEN_IMAGE", NULL },
 
1163
    { 0, NULL, NULL }
 
1164
  };
 
1165
 
 
1166
  static GType type = 0;
 
1167
 
 
1168
  if (! type)
 
1169
    {
 
1170
      type = g_enum_register_static ("GimpMergeType", values);
 
1171
      gimp_enum_set_value_descriptions (type, descs);
 
1172
    }
 
1173
 
 
1174
  return type;
 
1175
}
 
1176
 
 
1177
GType
 
1178
gimp_select_criterion_get_type (void)
 
1179
{
 
1180
  static const GEnumValue values[] =
 
1181
  {
 
1182
    { GIMP_SELECT_CRITERION_COMPOSITE, "GIMP_SELECT_CRITERION_COMPOSITE", "composite" },
 
1183
    { GIMP_SELECT_CRITERION_R, "GIMP_SELECT_CRITERION_R", "r" },
 
1184
    { GIMP_SELECT_CRITERION_G, "GIMP_SELECT_CRITERION_G", "g" },
 
1185
    { GIMP_SELECT_CRITERION_B, "GIMP_SELECT_CRITERION_B", "b" },
 
1186
    { GIMP_SELECT_CRITERION_H, "GIMP_SELECT_CRITERION_H", "h" },
 
1187
    { GIMP_SELECT_CRITERION_S, "GIMP_SELECT_CRITERION_S", "s" },
 
1188
    { GIMP_SELECT_CRITERION_V, "GIMP_SELECT_CRITERION_V", "v" },
 
1189
    { 0, NULL, NULL }
 
1190
  };
 
1191
 
 
1192
  static const GimpEnumDesc descs[] =
 
1193
  {
 
1194
    { GIMP_SELECT_CRITERION_COMPOSITE, N_("Composite"), NULL },
 
1195
    { GIMP_SELECT_CRITERION_R, N_("Red"), NULL },
 
1196
    { GIMP_SELECT_CRITERION_G, N_("Green"), NULL },
 
1197
    { GIMP_SELECT_CRITERION_B, N_("Blue"), NULL },
 
1198
    { GIMP_SELECT_CRITERION_H, N_("Hue"), NULL },
 
1199
    { GIMP_SELECT_CRITERION_S, N_("Saturation"), NULL },
 
1200
    { GIMP_SELECT_CRITERION_V, N_("Value"), NULL },
 
1201
    { 0, NULL, NULL }
 
1202
  };
 
1203
 
 
1204
  static GType type = 0;
 
1205
 
 
1206
  if (! type)
 
1207
    {
 
1208
      type = g_enum_register_static ("GimpSelectCriterion", values);
 
1209
      gimp_enum_set_value_descriptions (type, descs);
 
1210
    }
 
1211
 
 
1212
  return type;
 
1213
}
 
1214
 
 
1215
GType
 
1216
gimp_message_severity_get_type (void)
 
1217
{
 
1218
  static const GEnumValue values[] =
 
1219
  {
 
1220
    { GIMP_MESSAGE_INFO, "GIMP_MESSAGE_INFO", "info" },
 
1221
    { GIMP_MESSAGE_WARNING, "GIMP_MESSAGE_WARNING", "warning" },
 
1222
    { GIMP_MESSAGE_ERROR, "GIMP_MESSAGE_ERROR", "error" },
 
1223
    { 0, NULL, NULL }
 
1224
  };
 
1225
 
 
1226
  static const GimpEnumDesc descs[] =
 
1227
  {
 
1228
    { GIMP_MESSAGE_INFO, N_("Message"), NULL },
 
1229
    { GIMP_MESSAGE_WARNING, N_("Warning"), NULL },
 
1230
    { GIMP_MESSAGE_ERROR, N_("Error"), NULL },
 
1231
    { 0, NULL, NULL }
 
1232
  };
 
1233
 
 
1234
  static GType type = 0;
 
1235
 
 
1236
  if (! type)
 
1237
    {
 
1238
      type = g_enum_register_static ("GimpMessageSeverity", values);
 
1239
      gimp_enum_set_value_descriptions (type, descs);
 
1240
    }
 
1241
 
 
1242
  return type;
 
1243
}
 
1244
 
 
1245
GType
 
1246
gimp_color_profile_policy_get_type (void)
 
1247
{
 
1248
  static const GEnumValue values[] =
 
1249
  {
 
1250
    { GIMP_COLOR_PROFILE_POLICY_ASK, "GIMP_COLOR_PROFILE_POLICY_ASK", "ask" },
 
1251
    { GIMP_COLOR_PROFILE_POLICY_KEEP, "GIMP_COLOR_PROFILE_POLICY_KEEP", "keep" },
 
1252
    { GIMP_COLOR_PROFILE_POLICY_CONVERT, "GIMP_COLOR_PROFILE_POLICY_CONVERT", "convert" },
 
1253
    { 0, NULL, NULL }
 
1254
  };
 
1255
 
 
1256
  static const GimpEnumDesc descs[] =
 
1257
  {
 
1258
    { GIMP_COLOR_PROFILE_POLICY_ASK, N_("Ask what to do"), NULL },
 
1259
    { GIMP_COLOR_PROFILE_POLICY_KEEP, N_("Keep embedded profile"), NULL },
 
1260
    { GIMP_COLOR_PROFILE_POLICY_CONVERT, N_("Convert to RGB workspace"), NULL },
 
1261
    { 0, NULL, NULL }
 
1262
  };
 
1263
 
 
1264
  static GType type = 0;
 
1265
 
 
1266
  if (! type)
 
1267
    {
 
1268
      type = g_enum_register_static ("GimpColorProfilePolicy", values);
 
1269
      gimp_enum_set_value_descriptions (type, descs);
 
1270
    }
 
1271
 
 
1272
  return type;
 
1273
}
 
1274
 
1167
1275
 
1168
1276
/* Generated data ends here */
1169
1277