← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/gtkglext/gutsy

« back to all changes in this revision

Viewing changes to gdk/gdkglenumtypes.c

  • Committer: Bazaar Package Importer
  • Author(s): Marcelo E. Magallon
  • Date: 2004-04-03 17:43:17 UTC
  • Revision ID: james.westby@ubuntu.com-20040403174317-d5gb2d2gftaligp8
Tags: upstream-1.0.6
Import upstream version 1.0.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdk/gdkglenumtypes.c
 
1
 
 
2
/* Generated data (by glib-mkenums) */
 
3
 
 
4
#include "gdkgl.h"
 
5
 
 
6
/* enumerations from "gdkgltokens.h" */
 
7
GType
 
8
gdk_gl_config_attrib_get_type (void)
 
9
{
 
10
  static GType etype = 0;
 
11
  if (etype == 0) {
 
12
    static const GEnumValue values[] = {
 
13
      { GDK_GL_USE_GL, "GDK_GL_USE_GL", "use-gl" },
 
14
      { GDK_GL_BUFFER_SIZE, "GDK_GL_BUFFER_SIZE", "buffer-size" },
 
15
      { GDK_GL_LEVEL, "GDK_GL_LEVEL", "level" },
 
16
      { GDK_GL_RGBA, "GDK_GL_RGBA", "rgba" },
 
17
      { GDK_GL_DOUBLEBUFFER, "GDK_GL_DOUBLEBUFFER", "doublebuffer" },
 
18
      { GDK_GL_STEREO, "GDK_GL_STEREO", "stereo" },
 
19
      { GDK_GL_AUX_BUFFERS, "GDK_GL_AUX_BUFFERS", "aux-buffers" },
 
20
      { GDK_GL_RED_SIZE, "GDK_GL_RED_SIZE", "red-size" },
 
21
      { GDK_GL_GREEN_SIZE, "GDK_GL_GREEN_SIZE", "green-size" },
 
22
      { GDK_GL_BLUE_SIZE, "GDK_GL_BLUE_SIZE", "blue-size" },
 
23
      { GDK_GL_ALPHA_SIZE, "GDK_GL_ALPHA_SIZE", "alpha-size" },
 
24
      { GDK_GL_DEPTH_SIZE, "GDK_GL_DEPTH_SIZE", "depth-size" },
 
25
      { GDK_GL_STENCIL_SIZE, "GDK_GL_STENCIL_SIZE", "stencil-size" },
 
26
      { GDK_GL_ACCUM_RED_SIZE, "GDK_GL_ACCUM_RED_SIZE", "accum-red-size" },
 
27
      { GDK_GL_ACCUM_GREEN_SIZE, "GDK_GL_ACCUM_GREEN_SIZE", "accum-green-size" },
 
28
      { GDK_GL_ACCUM_BLUE_SIZE, "GDK_GL_ACCUM_BLUE_SIZE", "accum-blue-size" },
 
29
      { GDK_GL_ACCUM_ALPHA_SIZE, "GDK_GL_ACCUM_ALPHA_SIZE", "accum-alpha-size" },
 
30
      { GDK_GL_CONFIG_CAVEAT, "GDK_GL_CONFIG_CAVEAT", "config-caveat" },
 
31
      { GDK_GL_X_VISUAL_TYPE, "GDK_GL_X_VISUAL_TYPE", "x-visual-type" },
 
32
      { GDK_GL_TRANSPARENT_TYPE, "GDK_GL_TRANSPARENT_TYPE", "transparent-type" },
 
33
      { GDK_GL_TRANSPARENT_INDEX_VALUE, "GDK_GL_TRANSPARENT_INDEX_VALUE", "transparent-index-value" },
 
34
      { GDK_GL_TRANSPARENT_RED_VALUE, "GDK_GL_TRANSPARENT_RED_VALUE", "transparent-red-value" },
 
35
      { GDK_GL_TRANSPARENT_GREEN_VALUE, "GDK_GL_TRANSPARENT_GREEN_VALUE", "transparent-green-value" },
 
36
      { GDK_GL_TRANSPARENT_BLUE_VALUE, "GDK_GL_TRANSPARENT_BLUE_VALUE", "transparent-blue-value" },
 
37
      { GDK_GL_TRANSPARENT_ALPHA_VALUE, "GDK_GL_TRANSPARENT_ALPHA_VALUE", "transparent-alpha-value" },
 
38
      { GDK_GL_DRAWABLE_TYPE, "GDK_GL_DRAWABLE_TYPE", "drawable-type" },
 
39
      { GDK_GL_RENDER_TYPE, "GDK_GL_RENDER_TYPE", "render-type" },
 
40
      { GDK_GL_X_RENDERABLE, "GDK_GL_X_RENDERABLE", "x-renderable" },
 
41
      { GDK_GL_FBCONFIG_ID, "GDK_GL_FBCONFIG_ID", "fbconfig-id" },
 
42
      { GDK_GL_MAX_PBUFFER_WIDTH, "GDK_GL_MAX_PBUFFER_WIDTH", "max-pbuffer-width" },
 
43
      { GDK_GL_MAX_PBUFFER_HEIGHT, "GDK_GL_MAX_PBUFFER_HEIGHT", "max-pbuffer-height" },
 
44
      { GDK_GL_MAX_PBUFFER_PIXELS, "GDK_GL_MAX_PBUFFER_PIXELS", "max-pbuffer-pixels" },
 
45
      { GDK_GL_VISUAL_ID, "GDK_GL_VISUAL_ID", "visual-id" },
 
46
      { GDK_GL_SCREEN, "GDK_GL_SCREEN", "screen" },
 
47
      { GDK_GL_SAMPLE_BUFFERS, "GDK_GL_SAMPLE_BUFFERS", "sample-buffers" },
 
48
      { GDK_GL_SAMPLES, "GDK_GL_SAMPLES", "samples" },
 
49
      { 0, NULL, NULL }
 
50
    };
 
51
    etype = g_enum_register_static ("GdkGLConfigAttrib", values);
 
52
  }
 
53
  return etype;
 
54
}
 
55
 
 
56
GType
 
57
gdk_gl_config_caveat_get_type (void)
 
58
{
 
59
  static GType etype = 0;
 
60
  if (etype == 0) {
 
61
    static const GEnumValue values[] = {
 
62
      { GDK_GL_CONFIG_CAVEAT_DONT_CARE, "GDK_GL_CONFIG_CAVEAT_DONT_CARE", "config-caveat-dont-care" },
 
63
      { GDK_GL_CONFIG_CAVEAT_NONE, "GDK_GL_CONFIG_CAVEAT_NONE", "config-caveat-none" },
 
64
      { GDK_GL_SLOW_CONFIG, "GDK_GL_SLOW_CONFIG", "slow-config" },
 
65
      { GDK_GL_NON_CONFORMANT_CONFIG, "GDK_GL_NON_CONFORMANT_CONFIG", "non-conformant-config" },
 
66
      { 0, NULL, NULL }
 
67
    };
 
68
    etype = g_enum_register_static ("GdkGLConfigCaveat", values);
 
69
  }
 
70
  return etype;
 
71
}
 
72
 
 
73
GType
 
74
gdk_gl_visual_type_get_type (void)
 
75
{
 
76
  static GType etype = 0;
 
77
  if (etype == 0) {
 
78
    static const GEnumValue values[] = {
 
79
      { GDK_GL_VISUAL_TYPE_DONT_CARE, "GDK_GL_VISUAL_TYPE_DONT_CARE", "visual-type-dont-care" },
 
80
      { GDK_GL_TRUE_COLOR, "GDK_GL_TRUE_COLOR", "true-color" },
 
81
      { GDK_GL_DIRECT_COLOR, "GDK_GL_DIRECT_COLOR", "direct-color" },
 
82
      { GDK_GL_PSEUDO_COLOR, "GDK_GL_PSEUDO_COLOR", "pseudo-color" },
 
83
      { GDK_GL_STATIC_COLOR, "GDK_GL_STATIC_COLOR", "static-color" },
 
84
      { GDK_GL_GRAY_SCALE, "GDK_GL_GRAY_SCALE", "gray-scale" },
 
85
      { GDK_GL_STATIC_GRAY, "GDK_GL_STATIC_GRAY", "static-gray" },
 
86
      { 0, NULL, NULL }
 
87
    };
 
88
    etype = g_enum_register_static ("GdkGLVisualType", values);
 
89
  }
 
90
  return etype;
 
91
}
 
92
 
 
93
GType
 
94
gdk_gl_transparent_type_get_type (void)
 
95
{
 
96
  static GType etype = 0;
 
97
  if (etype == 0) {
 
98
    static const GEnumValue values[] = {
 
99
      { GDK_GL_TRANSPARENT_NONE, "GDK_GL_TRANSPARENT_NONE", "none" },
 
100
      { GDK_GL_TRANSPARENT_RGB, "GDK_GL_TRANSPARENT_RGB", "rgb" },
 
101
      { GDK_GL_TRANSPARENT_INDEX, "GDK_GL_TRANSPARENT_INDEX", "index" },
 
102
      { 0, NULL, NULL }
 
103
    };
 
104
    etype = g_enum_register_static ("GdkGLTransparentType", values);
 
105
  }
 
106
  return etype;
 
107
}
 
108
 
 
109
GType
 
110
gdk_gl_drawable_type_mask_get_type (void)
 
111
{
 
112
  static GType etype = 0;
 
113
  if (etype == 0) {
 
114
    static const GFlagsValue values[] = {
 
115
      { GDK_GL_WINDOW_BIT, "GDK_GL_WINDOW_BIT", "window-bit" },
 
116
      { GDK_GL_PIXMAP_BIT, "GDK_GL_PIXMAP_BIT", "pixmap-bit" },
 
117
      { GDK_GL_PBUFFER_BIT, "GDK_GL_PBUFFER_BIT", "pbuffer-bit" },
 
118
      { 0, NULL, NULL }
 
119
    };
 
120
    etype = g_flags_register_static ("GdkGLDrawableTypeMask", values);
 
121
  }
 
122
  return etype;
 
123
}
 
124
 
 
125
GType
 
126
gdk_gl_render_type_mask_get_type (void)
 
127
{
 
128
  static GType etype = 0;
 
129
  if (etype == 0) {
 
130
    static const GFlagsValue values[] = {
 
131
      { GDK_GL_RGBA_BIT, "GDK_GL_RGBA_BIT", "rgba-bit" },
 
132
      { GDK_GL_COLOR_INDEX_BIT, "GDK_GL_COLOR_INDEX_BIT", "color-index-bit" },
 
133
      { 0, NULL, NULL }
 
134
    };
 
135
    etype = g_flags_register_static ("GdkGLRenderTypeMask", values);
 
136
  }
 
137
  return etype;
 
138
}
 
139
 
 
140
GType
 
141
gdk_gl_buffer_mask_get_type (void)
 
142
{
 
143
  static GType etype = 0;
 
144
  if (etype == 0) {
 
145
    static const GFlagsValue values[] = {
 
146
      { GDK_GL_FRONT_LEFT_BUFFER_BIT, "GDK_GL_FRONT_LEFT_BUFFER_BIT", "front-left-buffer-bit" },
 
147
      { GDK_GL_FRONT_RIGHT_BUFFER_BIT, "GDK_GL_FRONT_RIGHT_BUFFER_BIT", "front-right-buffer-bit" },
 
148
      { GDK_GL_BACK_LEFT_BUFFER_BIT, "GDK_GL_BACK_LEFT_BUFFER_BIT", "back-left-buffer-bit" },
 
149
      { GDK_GL_BACK_RIGHT_BUFFER_BIT, "GDK_GL_BACK_RIGHT_BUFFER_BIT", "back-right-buffer-bit" },
 
150
      { GDK_GL_AUX_BUFFERS_BIT, "GDK_GL_AUX_BUFFERS_BIT", "aux-buffers-bit" },
 
151
      { GDK_GL_DEPTH_BUFFER_BIT, "GDK_GL_DEPTH_BUFFER_BIT", "depth-buffer-bit" },
 
152
      { GDK_GL_STENCIL_BUFFER_BIT, "GDK_GL_STENCIL_BUFFER_BIT", "stencil-buffer-bit" },
 
153
      { GDK_GL_ACCUM_BUFFER_BIT, "GDK_GL_ACCUM_BUFFER_BIT", "accum-buffer-bit" },
 
154
      { 0, NULL, NULL }
 
155
    };
 
156
    etype = g_flags_register_static ("GdkGLBufferMask", values);
 
157
  }
 
158
  return etype;
 
159
}
 
160
 
 
161
GType
 
162
gdk_gl_config_error_get_type (void)
 
163
{
 
164
  static GType etype = 0;
 
165
  if (etype == 0) {
 
166
    static const GEnumValue values[] = {
 
167
      { GDK_GL_BAD_SCREEN, "GDK_GL_BAD_SCREEN", "bad-screen" },
 
168
      { GDK_GL_BAD_ATTRIBUTE, "GDK_GL_BAD_ATTRIBUTE", "bad-attribute" },
 
169
      { GDK_GL_NO_EXTENSION, "GDK_GL_NO_EXTENSION", "no-extension" },
 
170
      { GDK_GL_BAD_VISUAL, "GDK_GL_BAD_VISUAL", "bad-visual" },
 
171
      { GDK_GL_BAD_CONTEXT, "GDK_GL_BAD_CONTEXT", "bad-context" },
 
172
      { GDK_GL_BAD_VALUE, "GDK_GL_BAD_VALUE", "bad-value" },
 
173
      { GDK_GL_BAD_ENUM, "GDK_GL_BAD_ENUM", "bad-enum" },
 
174
      { 0, NULL, NULL }
 
175
    };
 
176
    etype = g_enum_register_static ("GdkGLConfigError", values);
 
177
  }
 
178
  return etype;
 
179
}
 
180
 
 
181
GType
 
182
gdk_gl_render_type_get_type (void)
 
183
{
 
184
  static GType etype = 0;
 
185
  if (etype == 0) {
 
186
    static const GEnumValue values[] = {
 
187
      { GDK_GL_RGBA_TYPE, "GDK_GL_RGBA_TYPE", "rgba-type" },
 
188
      { GDK_GL_COLOR_INDEX_TYPE, "GDK_GL_COLOR_INDEX_TYPE", "color-index-type" },
 
189
      { 0, NULL, NULL }
 
190
    };
 
191
    etype = g_enum_register_static ("GdkGLRenderType", values);
 
192
  }
 
193
  return etype;
 
194
}
 
195
 
 
196
GType
 
197
gdk_gl_drawable_attrib_get_type (void)
 
198
{
 
199
  static GType etype = 0;
 
200
  if (etype == 0) {
 
201
    static const GEnumValue values[] = {
 
202
      { GDK_GL_PRESERVED_CONTENTS, "GDK_GL_PRESERVED_CONTENTS", "preserved-contents" },
 
203
      { GDK_GL_LARGEST_PBUFFER, "GDK_GL_LARGEST_PBUFFER", "largest-pbuffer" },
 
204
      { GDK_GL_WIDTH, "GDK_GL_WIDTH", "width" },
 
205
      { GDK_GL_HEIGHT, "GDK_GL_HEIGHT", "height" },
 
206
      { GDK_GL_EVENT_MASK, "GDK_GL_EVENT_MASK", "event-mask" },
 
207
      { 0, NULL, NULL }
 
208
    };
 
209
    etype = g_enum_register_static ("GdkGLDrawableAttrib", values);
 
210
  }
 
211
  return etype;
 
212
}
 
213
 
 
214
GType
 
215
gdk_gl_pbuffer_attrib_get_type (void)
 
216
{
 
217
  static GType etype = 0;
 
218
  if (etype == 0) {
 
219
    static const GEnumValue values[] = {
 
220
      { GDK_GL_PBUFFER_PRESERVED_CONTENTS, "GDK_GL_PBUFFER_PRESERVED_CONTENTS", "preserved-contents" },
 
221
      { GDK_GL_PBUFFER_LARGEST_PBUFFER, "GDK_GL_PBUFFER_LARGEST_PBUFFER", "largest-pbuffer" },
 
222
      { GDK_GL_PBUFFER_HEIGHT, "GDK_GL_PBUFFER_HEIGHT", "height" },
 
223
      { GDK_GL_PBUFFER_WIDTH, "GDK_GL_PBUFFER_WIDTH", "width" },
 
224
      { 0, NULL, NULL }
 
225
    };
 
226
    etype = g_enum_register_static ("GdkGLPbufferAttrib", values);
 
227
  }
 
228
  return etype;
 
229
}
 
230
 
 
231
GType
 
232
gdk_gl_event_mask_get_type (void)
 
233
{
 
234
  static GType etype = 0;
 
235
  if (etype == 0) {
 
236
    static const GFlagsValue values[] = {
 
237
      { GDK_GL_PBUFFER_CLOBBER_MASK, "GDK_GL_PBUFFER_CLOBBER_MASK", "mask" },
 
238
      { 0, NULL, NULL }
 
239
    };
 
240
    etype = g_flags_register_static ("GdkGLEventMask", values);
 
241
  }
 
242
  return etype;
 
243
}
 
244
 
 
245
GType
 
246
gdk_gl_event_type_get_type (void)
 
247
{
 
248
  static GType etype = 0;
 
249
  if (etype == 0) {
 
250
    static const GEnumValue values[] = {
 
251
      { GDK_GL_DAMAGED, "GDK_GL_DAMAGED", "damaged" },
 
252
      { GDK_GL_SAVED, "GDK_GL_SAVED", "saved" },
 
253
      { 0, NULL, NULL }
 
254
    };
 
255
    etype = g_enum_register_static ("GdkGLEventType", values);
 
256
  }
 
257
  return etype;
 
258
}
 
259
 
 
260
GType
 
261
gdk_gl_drawable_type_get_type (void)
 
262
{
 
263
  static GType etype = 0;
 
264
  if (etype == 0) {
 
265
    static const GEnumValue values[] = {
 
266
      { GDK_GL_WINDOW, "GDK_GL_WINDOW", "window" },
 
267
      { GDK_GL_PBUFFER, "GDK_GL_PBUFFER", "pbuffer" },
 
268
      { 0, NULL, NULL }
 
269
    };
 
270
    etype = g_enum_register_static ("GdkGLDrawableType", values);
 
271
  }
 
272
  return etype;
 
273
}
 
274
 
 
275
 
 
276
/* enumerations from "gdkglconfig.h" */
 
277
GType
 
278
gdk_gl_config_mode_get_type (void)
 
279
{
 
280
  static GType etype = 0;
 
281
  if (etype == 0) {
 
282
    static const GFlagsValue values[] = {
 
283
      { GDK_GL_MODE_RGB, "GDK_GL_MODE_RGB", "rgb" },
 
284
      { GDK_GL_MODE_RGBA, "GDK_GL_MODE_RGBA", "rgba" },
 
285
      { GDK_GL_MODE_INDEX, "GDK_GL_MODE_INDEX", "index" },
 
286
      { GDK_GL_MODE_SINGLE, "GDK_GL_MODE_SINGLE", "single" },
 
287
      { GDK_GL_MODE_DOUBLE, "GDK_GL_MODE_DOUBLE", "double" },
 
288
      { GDK_GL_MODE_STEREO, "GDK_GL_MODE_STEREO", "stereo" },
 
289
      { GDK_GL_MODE_ALPHA, "GDK_GL_MODE_ALPHA", "alpha" },
 
290
      { GDK_GL_MODE_DEPTH, "GDK_GL_MODE_DEPTH", "depth" },
 
291
      { GDK_GL_MODE_STENCIL, "GDK_GL_MODE_STENCIL", "stencil" },
 
292
      { GDK_GL_MODE_ACCUM, "GDK_GL_MODE_ACCUM", "accum" },
 
293
      { GDK_GL_MODE_MULTISAMPLE, "GDK_GL_MODE_MULTISAMPLE", "multisample" },
 
294
      { 0, NULL, NULL }
 
295
    };
 
296
    etype = g_flags_register_static ("GdkGLConfigMode", values);
 
297
  }
 
298
  return etype;
 
299
}
 
300
 
 
301
 
 
302
/* Generated data ends here */
 
303