← Back to branch summary

~ubuntu-branches/ubuntu/natty/virtualbox-ose/natty-updates

« back to all changes in this revision

Viewing changes to src/VBox/Additions/common/crOpenGL/glx_c_exports.c

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2010-03-11 17:16:37 UTC
  • mfrom: (0.3.4 upstream) (0.4.8 sid)
  • Revision ID: james.westby@ubuntu.com-20100311171637-43z64ia3ccpj8vqn
Tags: 3.1.4-dfsg-2ubuntu1
https://launchpad.net/bugs/528561
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/535297
* Merge from Debian unstable (LP: #528561), remaining changes:
  - VirtualBox should go in Accessories, not in System tools (LP: #288590)
    - debian/virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add Apport hook
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Add Launchpad integration
    - debian/control
    - debian/lpi-bug.xpm
    - debian/patches/u02-lp-integration.dpatch
  - Replace *-source packages with transitional packages for *-dkms
* Fix crash in vboxvideo_drm with kernel 2.6.33 / backported drm code
  (LP: #535297)
* Add a list of linux-headers packages to the apport hook
* Update debian/patches/u02-lp-integration.dpatch with a
  DEP-3 compliant header
* Add ${misc:Depends} to virtualbox-ose-source and virtualbox-ose-guest-source
  Depends

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Additions/common/crOpenGL/glx_c_exports.c
26
26
 
27
27
 
28
28
#ifdef VBOXOGL_FAKEDRI
29
 
/*void VBOXGLXENTRYTAG(glXGetDriverConfig)(const char *driverName)
 
29
/*DECLEXPORT(void) VBOXGLXENTRYTAG(glXGetDriverConfig)(const char *driverName)
30
30
{
31
31
    return glxim.GetDriverConfig(driverName);
32
32
}*/
33
33
 
34
 
void VBOXGLXENTRYTAG(glXFreeMemoryMESA)(Display *dpy, int scrn, void *pointer)
 
34
DECLEXPORT(void) VBOXGLXENTRYTAG(glXFreeMemoryMESA)(Display *dpy, int scrn, void *pointer)
35
35
{
36
36
    return glxim.FreeMemoryMESA(dpy, scrn, pointer);
37
37
}
38
38
 
39
 
GLXContext VBOXGLXENTRYTAG(glXImportContextEXT)(Display *dpy, GLXContextID contextID)
 
39
DECLEXPORT(GLXContext) VBOXGLXENTRYTAG(glXImportContextEXT)(Display *dpy, GLXContextID contextID)
40
40
{
41
41
    return glxim.ImportContextEXT(dpy, contextID);
42
42
}
43
43
 
44
 
GLXContextID VBOXGLXENTRYTAG(glXGetContextIDEXT)(const GLXContext ctx)
 
44
DECLEXPORT(GLXContextID) VBOXGLXENTRYTAG(glXGetContextIDEXT)(const GLXContext ctx)
45
45
{
46
46
    return glxim.GetContextIDEXT(ctx);
47
47
}
48
48
 
49
 
Bool VBOXGLXENTRYTAG(glXMakeCurrentReadSGI)(Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
 
49
DECLEXPORT(Bool) VBOXGLXENTRYTAG(glXMakeCurrentReadSGI)(Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
50
50
{
51
51
    return glxim.MakeCurrentReadSGI(display, draw, read, ctx);
52
52
}
58
58
}*/
59
59
 
60
60
 
61
 
Display * VBOXGLXENTRYTAG(glXGetCurrentDisplayEXT)(void)
 
61
DECLEXPORT(Display*) VBOXGLXENTRYTAG(glXGetCurrentDisplayEXT)(void)
62
62
{
63
63
    return glxim.GetCurrentDisplayEXT();
64
64
}
65
65
 
66
 
void VBOXGLXENTRYTAG(glXFreeContextEXT)(Display *dpy, GLXContext ctx)
 
66
DECLEXPORT(void) VBOXGLXENTRYTAG(glXFreeContextEXT)(Display *dpy, GLXContext ctx)
67
67
{
68
68
    return glxim.FreeContextEXT(dpy, ctx);
69
69
}
70
70
 
71
71
/*Mesa insternal*/
72
 
int VBOXGLXENTRYTAG(glXQueryContextInfoEXT)(Display *dpy, GLXContext ctx)
 
72
DECLEXPORT(int) VBOXGLXENTRYTAG(glXQueryContextInfoEXT)(Display *dpy, GLXContext ctx)
73
73
{
74
74
    return glxim.QueryContextInfoEXT(dpy, ctx);
75
75
}
76
76
 
77
 
void * VBOXGLXENTRYTAG(glXAllocateMemoryMESA)(Display *dpy, int scrn,
 
77
DECLEXPORT(void *) VBOXGLXENTRYTAG(glXAllocateMemoryMESA)(Display *dpy, int scrn,
78
78
                                                       size_t size, float readFreq,
79
79
                                                       float writeFreq, float priority)
80
80
{
81
81
    return glxim.AllocateMemoryMESA(dpy, scrn, size, readFreq, writeFreq, priority);
82
82
}
83
83
 
84
 
GLuint VBOXGLXENTRYTAG(glXGetMemoryOffsetMESA)(Display *dpy, int scrn, const void *pointer )
 
84
DECLEXPORT(GLuint) VBOXGLXENTRYTAG(glXGetMemoryOffsetMESA)(Display *dpy, int scrn, const void *pointer )
85
85
{
86
86
    return glxim.GetMemoryOffsetMESA(dpy, scrn, pointer);
87
87
}
88
88
 
89
89
 
90
 
GLXPixmap VBOXGLXENTRYTAG(glXCreateGLXPixmapMESA)(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap)
 
90
DECLEXPORT(GLXPixmap) VBOXGLXENTRYTAG(glXCreateGLXPixmapMESA)(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap)
91
91
{
92
92
    return glxim.CreateGLXPixmapMESA(dpy, visual, pixmap, cmap);
93
93
}
94
94
#endif
95
95
 
96
96
/*Common glX functions*/
97
 
void VBOXGLXENTRYTAG(glXCopyContext)( Display *dpy, GLXContext src, GLXContext dst, unsigned long mask)
 
97
DECLEXPORT(void) VBOXGLXENTRYTAG(glXCopyContext)( Display *dpy, GLXContext src, GLXContext dst, unsigned long mask)
98
98
{
99
99
    return glxim.CopyContext(dpy, src, dst, mask);
100
100
}
101
101
 
102
102
 
103
 
void VBOXGLXENTRYTAG(glXUseXFont)(Font font, int first, int count, int listBase)
 
103
DECLEXPORT(void) VBOXGLXENTRYTAG(glXUseXFont)(Font font, int first, int count, int listBase)
104
104
{
105
105
    return glxim.UseXFont(font, first, count, listBase);
106
106
}
107
107
 
108
 
CR_GLXFuncPtr VBOXGLXENTRYTAG(glXGetProcAddress)(const GLubyte *name)
 
108
DECLEXPORT(CR_GLXFuncPtr) VBOXGLXENTRYTAG(glXGetProcAddress)(const GLubyte *name)
109
109
{
110
110
    return glxim.GetProcAddress(name);
111
111
}
112
112
 
113
 
Bool VBOXGLXENTRYTAG(glXQueryExtension)(Display *dpy, int *errorBase, int *eventBase)
 
113
DECLEXPORT(Bool) VBOXGLXENTRYTAG(glXQueryExtension)(Display *dpy, int *errorBase, int *eventBase)
114
114
{
115
115
    return glxim.QueryExtension(dpy, errorBase, eventBase);
116
116
}
117
117
 
118
 
Bool VBOXGLXENTRYTAG(glXIsDirect)(Display *dpy, GLXContext ctx)
 
118
DECLEXPORT(Bool) VBOXGLXENTRYTAG(glXIsDirect)(Display *dpy, GLXContext ctx)
119
119
{
120
120
    return glxim.IsDirect(dpy, ctx);
121
121
}
122
122
 
123
 
GLXPixmap VBOXGLXENTRYTAG(glXCreateGLXPixmap)(Display *dpy, XVisualInfo *vis, Pixmap pixmap)
 
123
DECLEXPORT(GLXPixmap) VBOXGLXENTRYTAG(glXCreateGLXPixmap)(Display *dpy, XVisualInfo *vis, Pixmap pixmap)
124
124
{
125
125
    return glxim.CreateGLXPixmap(dpy, vis, pixmap);
126
126
}
127
127
 
128
 
void VBOXGLXENTRYTAG(glXSwapBuffers)(Display *dpy, GLXDrawable drawable)
 
128
DECLEXPORT(void) VBOXGLXENTRYTAG(glXSwapBuffers)(Display *dpy, GLXDrawable drawable)
129
129
{
130
130
    return glxim.SwapBuffers(dpy, drawable);
131
131
}
132
132
 
133
133
 
134
 
GLXDrawable VBOXGLXENTRYTAG(glXGetCurrentDrawable)(void)
 
134
DECLEXPORT(GLXDrawable) VBOXGLXENTRYTAG(glXGetCurrentDrawable)(void)
135
135
{
136
136
    return glxim.GetCurrentDrawable();
137
137
}
138
138
 
139
 
void VBOXGLXENTRYTAG(glXWaitGL)(void)
 
139
DECLEXPORT(void) VBOXGLXENTRYTAG(glXWaitGL)(void)
140
140
{
141
141
    return glxim.WaitGL();
142
142
}
143
143
 
144
 
Display * VBOXGLXENTRYTAG(glXGetCurrentDisplay)(void)
 
144
DECLEXPORT(Display *) VBOXGLXENTRYTAG(glXGetCurrentDisplay)(void)
145
145
{
146
146
    return glxim.GetCurrentDisplay();
147
147
}
148
148
 
149
 
const char * VBOXGLXENTRYTAG(glXQueryServerString)(Display *dpy, int screen, int name)
 
149
DECLEXPORT(const char *) VBOXGLXENTRYTAG(glXQueryServerString)(Display *dpy, int screen, int name)
150
150
{
151
151
    return glxim.QueryServerString(dpy, screen, name);
152
152
}
153
153
 
154
 
GLXContext VBOXGLXENTRYTAG(glXCreateContext)(Display *dpy, XVisualInfo *vis, GLXContext share, Bool direct)
 
154
DECLEXPORT(GLXContext) VBOXGLXENTRYTAG(glXCreateContext)(Display *dpy, XVisualInfo *vis, GLXContext share, Bool direct)
155
155
{
156
156
    return glxim.CreateContext(dpy, vis, share, direct);
157
157
}
158
158
 
159
 
int VBOXGLXENTRYTAG(glXGetConfig)(Display *dpy, XVisualInfo *vis, int attrib, int *value)
 
159
DECLEXPORT(int) VBOXGLXENTRYTAG(glXGetConfig)(Display *dpy, XVisualInfo *vis, int attrib, int *value)
160
160
{
161
161
    return glxim.GetConfig(dpy, vis, attrib, value);
162
162
}
163
163
 
164
 
void VBOXGLXENTRYTAG(glXWaitX)(void)
 
164
DECLEXPORT(void) VBOXGLXENTRYTAG(glXWaitX)(void)
165
165
{
166
166
    return glxim.WaitX();
167
167
}
168
168
 
169
 
GLXContext VBOXGLXENTRYTAG(glXGetCurrentContext)(void)
 
169
DECLEXPORT(GLXContext) VBOXGLXENTRYTAG(glXGetCurrentContext)(void)
170
170
{
171
171
    return glxim.GetCurrentContext();
172
172
}
173
173
 
174
 
const char * VBOXGLXENTRYTAG(glXGetClientString)(Display *dpy, int name)
 
174
DECLEXPORT(const char *) VBOXGLXENTRYTAG(glXGetClientString)(Display *dpy, int name)
175
175
{
176
176
    return glxim.GetClientString(dpy, name);
177
177
}
178
178
 
179
 
Bool VBOXGLXENTRYTAG(glXMakeCurrent)(Display *dpy, GLXDrawable drawable, GLXContext ctx)
 
179
DECLEXPORT(Bool) VBOXGLXENTRYTAG(glXMakeCurrent)(Display *dpy, GLXDrawable drawable, GLXContext ctx)
180
180
{
181
181
    return glxim.MakeCurrent(dpy, drawable, ctx);
182
182
}
183
183
 
184
 
void VBOXGLXENTRYTAG(glXDestroyContext)(Display *dpy, GLXContext ctx)
 
184
DECLEXPORT(void) VBOXGLXENTRYTAG(glXDestroyContext)(Display *dpy, GLXContext ctx)
185
185
{
186
186
    return glxim.DestroyContext(dpy, ctx);
187
187
}
188
188
 
189
 
CR_GLXFuncPtr VBOXGLXENTRYTAG(glXGetProcAddressARB)(const GLubyte *name)
 
189
DECLEXPORT(CR_GLXFuncPtr) VBOXGLXENTRYTAG(glXGetProcAddressARB)(const GLubyte *name)
190
190
{
191
191
    return glxim.GetProcAddressARB(name);
192
192
}
193
193
 
194
 
void VBOXGLXENTRYTAG(glXDestroyGLXPixmap)(Display *dpy, GLXPixmap pix)
 
194
DECLEXPORT(void) VBOXGLXENTRYTAG(glXDestroyGLXPixmap)(Display *dpy, GLXPixmap pix)
195
195
{
196
196
    return glxim.DestroyGLXPixmap(dpy, pix);
197
197
}
198
198
 
199
 
Bool VBOXGLXENTRYTAG(glXQueryVersion)(Display *dpy, int *major, int *minor)
 
199
DECLEXPORT(Bool) VBOXGLXENTRYTAG(glXQueryVersion)(Display *dpy, int *major, int *minor)
200
200
{
201
201
    return glxim.QueryVersion(dpy, major, minor);
202
202
}
203
203
 
204
 
XVisualInfo * VBOXGLXENTRYTAG(glXChooseVisual)(Display *dpy, int screen, int *attribList)
 
204
DECLEXPORT(XVisualInfo *) VBOXGLXENTRYTAG(glXChooseVisual)(Display *dpy, int screen, int *attribList)
205
205
{
206
206
    return glxim.ChooseVisual(dpy, screen, attribList);
207
207
}
208
208
 
209
 
const char * VBOXGLXENTRYTAG(glXQueryExtensionsString)(Display *dpy, int screen)
 
209
DECLEXPORT(const char *) VBOXGLXENTRYTAG(glXQueryExtensionsString)(Display *dpy, int screen)
210
210
{
211
211
    return glxim.QueryExtensionsString(dpy, screen);
212
212
}
213
213
 
214
214
#if GLX_EXTRAS
215
 
GLXPbufferSGIX VBOXGLXENTRYTAG(glXCreateGLXPbufferSGIX)
 
215
DECLEXPORT(GLXPbufferSGIX) VBOXGLXENTRYTAG(glXCreateGLXPbufferSGIX)
216
216
(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list)
217
217
{
218
218
    return glxim.CreateGLXPbufferSGIX(dpy, config, width, height, attrib_list);
219
219
}
220
220
 
221
 
int VBOXGLXENTRYTAG(glXQueryGLXPbufferSGIX)
 
221
DECLEXPORT(int) VBOXGLXENTRYTAG(glXQueryGLXPbufferSGIX)
222
222
(Display *dpy, GLXPbuffer pbuf, int attribute, unsigned int *value)
223
223
{
224
224
    return glxim.QueryGLXPbufferSGIX(dpy, pbuf, attribute, value);
225
225
}
226
226
 
227
 
GLXFBConfigSGIX * VBOXGLXENTRYTAG(glXChooseFBConfigSGIX)
 
227
DECLEXPORT(GLXFBConfigSGIX *) VBOXGLXENTRYTAG(glXChooseFBConfigSGIX)
228
228
(Display *dpy, int screen, int *attrib_list, int *nelements)
229
229
{
230
230
    return glxim.ChooseFBConfigSGIX(dpy, screen, attrib_list, nelements);
231
231
}
232
232
 
233
 
void VBOXGLXENTRYTAG(glXDestroyGLXPbufferSGIX)(Display *dpy, GLXPbuffer pbuf)
 
233
DECLEXPORT(void) VBOXGLXENTRYTAG(glXDestroyGLXPbufferSGIX)(Display *dpy, GLXPbuffer pbuf)
234
234
{
235
235
    return glxim.DestroyGLXPbufferSGIX(dpy, pbuf);
236
236
}
237
237
 
238
 
void VBOXGLXENTRYTAG(glXSelectEventSGIX)(Display *dpy, GLXDrawable drawable, unsigned long mask)
 
238
DECLEXPORT(void) VBOXGLXENTRYTAG(glXSelectEventSGIX)(Display *dpy, GLXDrawable drawable, unsigned long mask)
239
239
{
240
240
    return glxim.SelectEventSGIX(dpy, drawable, mask);
241
241
}
242
242
 
243
 
void VBOXGLXENTRYTAG(glXGetSelectedEventSGIX)(Display *dpy, GLXDrawable drawable, unsigned long *mask)
 
243
DECLEXPORT(void) VBOXGLXENTRYTAG(glXGetSelectedEventSGIX)(Display *dpy, GLXDrawable drawable, unsigned long *mask)
244
244
{
245
245
    return glxim.GetSelectedEventSGIX(dpy, drawable, mask);
246
246
}
247
247
 
248
 
GLXFBConfigSGIX VBOXGLXENTRYTAG(glXGetFBConfigFromVisualSGIX)(Display *dpy, XVisualInfo *vis)
 
248
DECLEXPORT(GLXFBConfigSGIX) VBOXGLXENTRYTAG(glXGetFBConfigFromVisualSGIX)(Display *dpy, XVisualInfo *vis)
249
249
{
250
250
    return glxim.GetFBConfigFromVisualSGIX(dpy, vis);
251
251
}
252
252
 
253
 
XVisualInfo * VBOXGLXENTRYTAG(glXGetVisualFromFBConfigSGIX)(Display *dpy, GLXFBConfig config)
 
253
DECLEXPORT(XVisualInfo *) VBOXGLXENTRYTAG(glXGetVisualFromFBConfigSGIX)(Display *dpy, GLXFBConfig config)
254
254
{
255
255
    return glxim.GetVisualFromFBConfigSGIX(dpy, config);
256
256
}
257
257
 
258
 
GLXContext VBOXGLXENTRYTAG(glXCreateContextWithConfigSGIX)
 
258
DECLEXPORT(GLXContext) VBOXGLXENTRYTAG(glXCreateContextWithConfigSGIX)
259
259
(Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct)
260
260
{
261
261
    return glxim.CreateContextWithConfigSGIX(dpy, config, render_type, share_list, direct);
262
262
}
263
263
 
264
 
GLXPixmap VBOXGLXENTRYTAG(glXCreateGLXPixmapWithConfigSGIX)(Display *dpy, GLXFBConfig config, Pixmap pixmap)
 
264
DECLEXPORT(GLXPixmap) VBOXGLXENTRYTAG(glXCreateGLXPixmapWithConfigSGIX)(Display *dpy, GLXFBConfig config, Pixmap pixmap)
265
265
{
266
266
    return glxim.CreateGLXPixmapWithConfigSGIX(dpy, config, pixmap);
267
267
}
268
268
 
269
 
int VBOXGLXENTRYTAG(glXGetFBConfigAttribSGIX)(Display *dpy, GLXFBConfig config, int attribute, int *value)
 
269
DECLEXPORT(int) VBOXGLXENTRYTAG(glXGetFBConfigAttribSGIX)(Display *dpy, GLXFBConfig config, int attribute, int *value)
270
270
{
271
271
    return glxim.GetFBConfigAttribSGIX(dpy, config, attribute, value);
272
272
}
275
275
/*
276
276
 * GLX 1.3 functions
277
277
 */
278
 
GLXFBConfig * VBOXGLXENTRYTAG(glXChooseFBConfig)(Display *dpy, int screen, ATTRIB_TYPE *attrib_list, int *nelements)
 
278
DECLEXPORT(GLXFBConfig *) VBOXGLXENTRYTAG(glXChooseFBConfig)(Display *dpy, int screen, ATTRIB_TYPE *attrib_list, int *nelements)
279
279
{
280
280
    return glxim.ChooseFBConfig(dpy, screen, attrib_list, nelements);
281
281
}
282
282
 
283
 
GLXPbuffer VBOXGLXENTRYTAG(glXCreatePbuffer)(Display *dpy, GLXFBConfig config, ATTRIB_TYPE *attrib_list)
 
283
DECLEXPORT(GLXPbuffer) VBOXGLXENTRYTAG(glXCreatePbuffer)(Display *dpy, GLXFBConfig config, ATTRIB_TYPE *attrib_list)
284
284
{
285
285
    return glxim.CreatePbuffer(dpy, config, attrib_list);
286
286
}
287
287
 
288
 
GLXPixmap VBOXGLXENTRYTAG(glXCreatePixmap)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const ATTRIB_TYPE *attrib_list)
 
288
DECLEXPORT(GLXPixmap) VBOXGLXENTRYTAG(glXCreatePixmap)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const ATTRIB_TYPE *attrib_list)
289
289
{
290
290
    return glxim.CreatePixmap(dpy, config, pixmap, attrib_list);
291
291
}
292
292
 
293
 
GLXWindow VBOXGLXENTRYTAG(glXCreateWindow)(Display *dpy, GLXFBConfig config, Window win, ATTRIB_TYPE *attrib_list)
 
293
DECLEXPORT(GLXWindow) VBOXGLXENTRYTAG(glXCreateWindow)(Display *dpy, GLXFBConfig config, Window win, ATTRIB_TYPE *attrib_list)
294
294
{
295
295
    return glxim.CreateWindow(dpy, config, win, attrib_list);
296
296
}
297
297
 
298
298
 
299
 
GLXContext VBOXGLXENTRYTAG(glXCreateNewContext)
 
299
DECLEXPORT(GLXContext) VBOXGLXENTRYTAG(glXCreateNewContext)
300
300
(Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct)
301
301
{
302
302
    return glxim.CreateNewContext(dpy, config, render_type, share_list, direct);
303
303
}
304
304
 
305
 
void VBOXGLXENTRYTAG(glXDestroyPbuffer)(Display *dpy, GLXPbuffer pbuf)
 
305
DECLEXPORT(void) VBOXGLXENTRYTAG(glXDestroyPbuffer)(Display *dpy, GLXPbuffer pbuf)
306
306
{
307
307
    return glxim.DestroyPbuffer(dpy, pbuf);
308
308
}
309
309
 
310
 
void VBOXGLXENTRYTAG(glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap)
 
310
DECLEXPORT(void) VBOXGLXENTRYTAG(glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap)
311
311
{
312
312
    return glxim.DestroyPixmap(dpy, pixmap);
313
313
}
314
314
 
315
 
void VBOXGLXENTRYTAG(glXDestroyWindow)(Display *dpy, GLXWindow win)
 
315
DECLEXPORT(void) VBOXGLXENTRYTAG(glXDestroyWindow)(Display *dpy, GLXWindow win)
316
316
{
317
317
    return glxim.DestroyWindow(dpy, win);
318
318
}
319
319
 
320
 
GLXDrawable VBOXGLXENTRYTAG(glXGetCurrentReadDrawable)(void)
 
320
DECLEXPORT(GLXDrawable) VBOXGLXENTRYTAG(glXGetCurrentReadDrawable)(void)
321
321
{
322
322
    return glxim.GetCurrentReadDrawable();
323
323
}
324
324
 
325
 
int VBOXGLXENTRYTAG(glXGetFBConfigAttrib)(Display *dpy, GLXFBConfig config, int attribute, int *value)
 
325
DECLEXPORT(int) VBOXGLXENTRYTAG(glXGetFBConfigAttrib)(Display *dpy, GLXFBConfig config, int attribute, int *value)
326
326
{
327
327
    return glxim.GetFBConfigAttrib(dpy, config, attribute, value);
328
328
}
329
329
 
330
 
GLXFBConfig * VBOXGLXENTRYTAG(glXGetFBConfigs)(Display *dpy, int screen, int *nelements)
 
330
DECLEXPORT(GLXFBConfig *) VBOXGLXENTRYTAG(glXGetFBConfigs)(Display *dpy, int screen, int *nelements)
331
331
{
332
332
    return glxim.GetFBConfigs(dpy, screen, nelements);
333
333
}
334
334
 
335
 
void VBOXGLXENTRYTAG(glXGetSelectedEvent)(Display *dpy, GLXDrawable draw, unsigned long *event_mask)
 
335
DECLEXPORT(void) VBOXGLXENTRYTAG(glXGetSelectedEvent)(Display *dpy, GLXDrawable draw, unsigned long *event_mask)
336
336
{
337
337
    return glxim.GetSelectedEvent(dpy, draw, event_mask);
338
338
}
339
339
 
340
 
XVisualInfo * VBOXGLXENTRYTAG(glXGetVisualFromFBConfig)(Display *dpy, GLXFBConfig config)
 
340
DECLEXPORT(XVisualInfo *) VBOXGLXENTRYTAG(glXGetVisualFromFBConfig)(Display *dpy, GLXFBConfig config)
341
341
{
342
342
    return glxim.GetVisualFromFBConfig(dpy, config);
343
343
}
344
344
 
345
 
Bool VBOXGLXENTRYTAG(glXMakeContextCurrent)(Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
 
345
DECLEXPORT(Bool) VBOXGLXENTRYTAG(glXMakeContextCurrent)(Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
346
346
{
347
347
    return glxim.MakeContextCurrent(display, draw, read, ctx);
348
348
}
349
349
 
350
 
int VBOXGLXENTRYTAG(glXQueryContext)(Display *dpy, GLXContext ctx, int attribute, int *value)
 
350
DECLEXPORT(int) VBOXGLXENTRYTAG(glXQueryContext)(Display *dpy, GLXContext ctx, int attribute, int *value)
351
351
{
352
352
    return glxim.QueryContext(dpy, ctx, attribute, value);
353
353
}
354
354
 
355
 
void VBOXGLXENTRYTAG(glXQueryDrawable)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
 
355
DECLEXPORT(void) VBOXGLXENTRYTAG(glXQueryDrawable)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
356
356
{
357
357
    return glxim.QueryDrawable(dpy, draw, attribute, value);
358
358
}
359
359
 
360
 
void VBOXGLXENTRYTAG(glXSelectEvent)(Display *dpy, GLXDrawable draw, unsigned long event_mask)
 
360
DECLEXPORT(void) VBOXGLXENTRYTAG(glXSelectEvent)(Display *dpy, GLXDrawable draw, unsigned long event_mask)
361
361
{
362
362
    return glxim.SelectEvent(dpy, draw, event_mask);
363
363
}
364
364
 
365
365
/*
366
366
#ifdef CR_EXT_texture_from_pixmap
367
 
void VBOXGLXENTRYTAG(glXBindTexImageEXT)(Display *dpy, GLXDrawable draw, int buffer, const int *attrib_list)
 
367
DECLEXPORT(void) VBOXGLXENTRYTAG(glXBindTexImageEXT)(Display *dpy, GLXDrawable draw, int buffer, const int *attrib_list)
368
368
{
369
369
    return glxim.BindTexImageEXT(dpy, draw, buffer, attrib_list);
370
370
}
371
371
 
372
 
void VBOXGLXENTRYTAG(glXReleaseTexImageEXT)(Display *dpy, GLXDrawable draw, int buffer)
 
372
DECLEXPORT(void) VBOXGLXENTRYTAG(glXReleaseTexImageEXT)(Display *dpy, GLXDrawable draw, int buffer)
373
373
{
374
374
    return glxim.ReleaseTexImageEXT(dpy, draw, buffer);
375
375
}