← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libgimpwidgets/gimpwidgetsenums.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgimpwidgets/gimpwidgetsenums.c
 
1
 
 
2
/* Generated data (by gimp-mkenums) */
 
3
 
 
4
#include "config.h"
 
5
#include <glib-object.h>
 
6
#include "libgimpbase/gimpbase.h"
 
7
#include "gimpwidgetsenums.h"
 
8
#include "libgimp/libgimp-intl.h"
 
9
 
 
10
/* enumerations from "./gimpwidgetsenums.h" */
 
11
GType
 
12
gimp_aspect_type_get_type (void)
 
13
{
 
14
  static const GEnumValue values[] =
 
15
  {
 
16
    { GIMP_ASPECT_SQUARE, "GIMP_ASPECT_SQUARE", "square" },
 
17
    { GIMP_ASPECT_PORTRAIT, "GIMP_ASPECT_PORTRAIT", "portrait" },
 
18
    { GIMP_ASPECT_LANDSCAPE, "GIMP_ASPECT_LANDSCAPE", "landscape" },
 
19
    { 0, NULL, NULL }
 
20
  };
 
21
 
 
22
  static const GimpEnumDesc descs[] =
 
23
  {
 
24
    { GIMP_ASPECT_SQUARE, N_("Square"), NULL },
 
25
    { GIMP_ASPECT_PORTRAIT, N_("Portrait"), NULL },
 
26
    { GIMP_ASPECT_LANDSCAPE, N_("Landscape"), NULL },
 
27
    { 0, NULL, NULL }
 
28
  };
 
29
 
 
30
  static GType type = 0;
 
31
 
 
32
  if (! type)
 
33
    {
 
34
      type = g_enum_register_static ("GimpAspectType", values);
 
35
      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
 
36
      gimp_enum_set_value_descriptions (type, descs);
 
37
    }
 
38
 
 
39
  return type;
 
40
}
 
41
 
 
42
GType
 
43
gimp_chain_position_get_type (void)
 
44
{
 
45
  static const GEnumValue values[] =
 
46
  {
 
47
    { GIMP_CHAIN_TOP, "GIMP_CHAIN_TOP", "top" },
 
48
    { GIMP_CHAIN_LEFT, "GIMP_CHAIN_LEFT", "left" },
 
49
    { GIMP_CHAIN_BOTTOM, "GIMP_CHAIN_BOTTOM", "bottom" },
 
50
    { GIMP_CHAIN_RIGHT, "GIMP_CHAIN_RIGHT", "right" },
 
51
    { 0, NULL, NULL }
 
52
  };
 
53
 
 
54
  static const GimpEnumDesc descs[] =
 
55
  {
 
56
    { GIMP_CHAIN_TOP, "GIMP_CHAIN_TOP", NULL },
 
57
    { GIMP_CHAIN_LEFT, "GIMP_CHAIN_LEFT", NULL },
 
58
    { GIMP_CHAIN_BOTTOM, "GIMP_CHAIN_BOTTOM", NULL },
 
59
    { GIMP_CHAIN_RIGHT, "GIMP_CHAIN_RIGHT", NULL },
 
60
    { 0, NULL, NULL }
 
61
  };
 
62
 
 
63
  static GType type = 0;
 
64
 
 
65
  if (! type)
 
66
    {
 
67
      type = g_enum_register_static ("GimpChainPosition", values);
 
68
      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
 
69
      gimp_enum_set_value_descriptions (type, descs);
 
70
    }
 
71
 
 
72
  return type;
 
73
}
 
74
 
 
75
GType
 
76
gimp_color_area_type_get_type (void)
 
77
{
 
78
  static const GEnumValue values[] =
 
79
  {
 
80
    { GIMP_COLOR_AREA_FLAT, "GIMP_COLOR_AREA_FLAT", "flat" },
 
81
    { GIMP_COLOR_AREA_SMALL_CHECKS, "GIMP_COLOR_AREA_SMALL_CHECKS", "small-checks" },
 
82
    { GIMP_COLOR_AREA_LARGE_CHECKS, "GIMP_COLOR_AREA_LARGE_CHECKS", "large-checks" },
 
83
    { 0, NULL, NULL }
 
84
  };
 
85
 
 
86
  static const GimpEnumDesc descs[] =
 
87
  {
 
88
    { GIMP_COLOR_AREA_FLAT, "GIMP_COLOR_AREA_FLAT", NULL },
 
89
    { GIMP_COLOR_AREA_SMALL_CHECKS, "GIMP_COLOR_AREA_SMALL_CHECKS", NULL },
 
90
    { GIMP_COLOR_AREA_LARGE_CHECKS, "GIMP_COLOR_AREA_LARGE_CHECKS", NULL },
 
91
    { 0, NULL, NULL }
 
92
  };
 
93
 
 
94
  static GType type = 0;
 
95
 
 
96
  if (! type)
 
97
    {
 
98
      type = g_enum_register_static ("GimpColorAreaType", values);
 
99
      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
 
100
      gimp_enum_set_value_descriptions (type, descs);
 
101
    }
 
102
 
 
103
  return type;
 
104
}
 
105
 
 
106
GType
 
107
gimp_color_selector_channel_get_type (void)
 
108
{
 
109
  static const GEnumValue values[] =
 
110
  {
 
111
    { GIMP_COLOR_SELECTOR_HUE, "GIMP_COLOR_SELECTOR_HUE", "hue" },
 
112
    { GIMP_COLOR_SELECTOR_SATURATION, "GIMP_COLOR_SELECTOR_SATURATION", "saturation" },
 
113
    { GIMP_COLOR_SELECTOR_VALUE, "GIMP_COLOR_SELECTOR_VALUE", "value" },
 
114
    { GIMP_COLOR_SELECTOR_RED, "GIMP_COLOR_SELECTOR_RED", "red" },
 
115
    { GIMP_COLOR_SELECTOR_GREEN, "GIMP_COLOR_SELECTOR_GREEN", "green" },
 
116
    { GIMP_COLOR_SELECTOR_BLUE, "GIMP_COLOR_SELECTOR_BLUE", "blue" },
 
117
    { GIMP_COLOR_SELECTOR_ALPHA, "GIMP_COLOR_SELECTOR_ALPHA", "alpha" },
 
118
    { 0, NULL, NULL }
 
119
  };
 
120
 
 
121
  static const GimpEnumDesc descs[] =
 
122
  {
 
123
    { GIMP_COLOR_SELECTOR_HUE, N_("_H"), N_("Hue") },
 
124
    { GIMP_COLOR_SELECTOR_SATURATION, N_("_S"), N_("Saturation") },
 
125
    { GIMP_COLOR_SELECTOR_VALUE, N_("_V"), N_("Value") },
 
126
    { GIMP_COLOR_SELECTOR_RED, N_("_R"), N_("Red") },
 
127
    { GIMP_COLOR_SELECTOR_GREEN, N_("_G"), N_("Green") },
 
128
    { GIMP_COLOR_SELECTOR_BLUE, N_("_B"), N_("Blue") },
 
129
    { GIMP_COLOR_SELECTOR_ALPHA, N_("_A"), N_("Alpha") },
 
130
    { 0, NULL, NULL }
 
131
  };
 
132
 
 
133
  static GType type = 0;
 
134
 
 
135
  if (! type)
 
136
    {
 
137
      type = g_enum_register_static ("GimpColorSelectorChannel", values);
 
138
      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
 
139
      gimp_enum_set_value_descriptions (type, descs);
 
140
    }
 
141
 
 
142
  return type;
 
143
}
 
144
 
 
145
GType
 
146
gimp_page_selector_target_get_type (void)
 
147
{
 
148
  static const GEnumValue values[] =
 
149
  {
 
150
    { GIMP_PAGE_SELECTOR_TARGET_LAYERS, "GIMP_PAGE_SELECTOR_TARGET_LAYERS", "layers" },
 
151
    { GIMP_PAGE_SELECTOR_TARGET_IMAGES, "GIMP_PAGE_SELECTOR_TARGET_IMAGES", "images" },
 
152
    { 0, NULL, NULL }
 
153
  };
 
154
 
 
155
  static const GimpEnumDesc descs[] =
 
156
  {
 
157
    { GIMP_PAGE_SELECTOR_TARGET_LAYERS, N_("Layers"), NULL },
 
158
    { GIMP_PAGE_SELECTOR_TARGET_IMAGES, N_("Images"), NULL },
 
159
    { 0, NULL, NULL }
 
160
  };
 
161
 
 
162
  static GType type = 0;
 
163
 
 
164
  if (! type)
 
165
    {
 
166
      type = g_enum_register_static ("GimpPageSelectorTarget", values);
 
167
      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
 
168
      gimp_enum_set_value_descriptions (type, descs);
 
169
    }
 
170
 
 
171
  return type;
 
172
}
 
173
 
 
174
GType
 
175
gimp_size_entry_update_policy_get_type (void)
 
176
{
 
177
  static const GEnumValue values[] =
 
178
  {
 
179
    { GIMP_SIZE_ENTRY_UPDATE_NONE, "GIMP_SIZE_ENTRY_UPDATE_NONE", "none" },
 
180
    { GIMP_SIZE_ENTRY_UPDATE_SIZE, "GIMP_SIZE_ENTRY_UPDATE_SIZE", "size" },
 
181
    { GIMP_SIZE_ENTRY_UPDATE_RESOLUTION, "GIMP_SIZE_ENTRY_UPDATE_RESOLUTION", "resolution" },
 
182
    { 0, NULL, NULL }
 
183
  };
 
184
 
 
185
  static const GimpEnumDesc descs[] =
 
186
  {
 
187
    { GIMP_SIZE_ENTRY_UPDATE_NONE, "GIMP_SIZE_ENTRY_UPDATE_NONE", NULL },
 
188
    { GIMP_SIZE_ENTRY_UPDATE_SIZE, "GIMP_SIZE_ENTRY_UPDATE_SIZE", NULL },
 
189
    { GIMP_SIZE_ENTRY_UPDATE_RESOLUTION, "GIMP_SIZE_ENTRY_UPDATE_RESOLUTION", NULL },
 
190
    { 0, NULL, NULL }
 
191
  };
 
192
 
 
193
  static GType type = 0;
 
194
 
 
195
  if (! type)
 
196
    {
 
197
      type = g_enum_register_static ("GimpSizeEntryUpdatePolicy", values);
 
198
      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
 
199
      gimp_enum_set_value_descriptions (type, descs);
 
200
    }
 
201
 
 
202
  return type;
 
203
}
 
204
 
 
205
GType
 
206
gimp_zoom_type_get_type (void)
 
207
{
 
208
  static const GEnumValue values[] =
 
209
  {
 
210
    { GIMP_ZOOM_IN, "GIMP_ZOOM_IN", "in" },
 
211
    { GIMP_ZOOM_OUT, "GIMP_ZOOM_OUT", "out" },
 
212
    { 0, NULL, NULL }
 
213
  };
 
214
 
 
215
  static const GimpEnumDesc descs[] =
 
216
  {
 
217
    { GIMP_ZOOM_IN, N_("Zoom in"), NULL },
 
218
    { GIMP_ZOOM_OUT, N_("Zoom out"), NULL },
 
219
    { 0, NULL, NULL }
 
220
  };
 
221
 
 
222
  static GType type = 0;
 
223
 
 
224
  if (! type)
 
225
    {
 
226
      type = g_enum_register_static ("GimpZoomType", values);
 
227
      gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
 
228
      gimp_enum_set_value_descriptions (type, descs);
 
229
    }
 
230
 
 
231
  return type;
 
232
}
 
233
 
 
234
 
 
235
/* Generated data ends here */
 
236