diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/Xext/Xxf86vm/XF86VMode.c')
-rw-r--r-- | apps/plugins/sdl/src/video/Xext/Xxf86vm/XF86VMode.c | 1226 |
1 files changed, 0 insertions, 1226 deletions
diff --git a/apps/plugins/sdl/src/video/Xext/Xxf86vm/XF86VMode.c b/apps/plugins/sdl/src/video/Xext/Xxf86vm/XF86VMode.c deleted file mode 100644 index 5cb21905af..0000000000 --- a/apps/plugins/sdl/src/video/Xext/Xxf86vm/XF86VMode.c +++ /dev/null | |||
@@ -1,1226 +0,0 @@ | |||
1 | /* $XConsortium: XF86VMode.c /main/2 1995/11/14 18:17:58 kaleb $ */ | ||
2 | /* $XFree86: xc/lib/Xxf86vm/XF86VMode.c,v 3.32 2001/07/25 15:04:54 dawes Exp $ */ | ||
3 | /* | ||
4 | |||
5 | Copyright (c) 1995 Kaleb S. KEITHLEY | ||
6 | |||
7 | Permission is hereby granted, free of charge, to any person obtaining | ||
8 | a copy of this software and associated documentation files (the | ||
9 | "Software"), to deal in the Software without restriction, including | ||
10 | without limitation the rights to use, copy, modify, merge, publish, | ||
11 | distribute, sublicense, and/or sell copies of the Software, and to | ||
12 | permit persons to whom the Software is furnished to do so, subject to | ||
13 | the following conditions: | ||
14 | |||
15 | The above copyright notice and this permission notice shall be | ||
16 | included in all copies or substantial portions of the Software. | ||
17 | |||
18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
19 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
20 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | ||
21 | IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES | ||
22 | OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
23 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
24 | OTHER DEALINGS IN THE SOFTWARE. | ||
25 | |||
26 | Except as contained in this notice, the name of Kaleb S. KEITHLEY | ||
27 | shall not be used in advertising or otherwise to promote the sale, use | ||
28 | or other dealings in this Software without prior written authorization | ||
29 | from Kaleb S. KEITHLEY. | ||
30 | |||
31 | */ | ||
32 | /* $XConsortium: XF86VMode.c /main/4 1996/01/16 07:52:25 kaleb CHECKEDOUT $ */ | ||
33 | |||
34 | /* THIS IS NOT AN X CONSORTIUM STANDARD */ | ||
35 | |||
36 | #define NEED_EVENTS | ||
37 | #define NEED_REPLIES | ||
38 | |||
39 | #ifndef XBUILD_IN_CLIENT | ||
40 | /* Apparently some X11 systems can't include this multiple times... */ | ||
41 | #ifndef SDL_INCLUDED_XLIBINT_H | ||
42 | #define SDL_INCLUDED_XLIBINT_H 1 | ||
43 | #include <X11/Xlibint.h> | ||
44 | #endif | ||
45 | #include "../extensions/xf86vmstr.h" | ||
46 | #include "../extensions/Xext.h" | ||
47 | #include "../extensions/extutil.h" | ||
48 | #else | ||
49 | #include "include/extensions/xf86vmstr.h" | ||
50 | #include "include/extensions/Xext.h" | ||
51 | #include "include/extensions/extutil.h" | ||
52 | #endif | ||
53 | |||
54 | #ifdef DEBUG | ||
55 | #include <stdio.h> | ||
56 | #endif | ||
57 | |||
58 | #ifndef MODE_BAD | ||
59 | #define MODE_BAD 255 | ||
60 | #endif | ||
61 | |||
62 | static XExtensionInfo _xf86vidmode_info_data; | ||
63 | static XExtensionInfo *xf86vidmode_info = &_xf86vidmode_info_data; | ||
64 | static char *xf86vidmode_extension_name = XF86VIDMODENAME; | ||
65 | |||
66 | #define XF86VidModeCheckExtension(dpy,i,val) \ | ||
67 | XextCheckExtension (dpy, i, xf86vidmode_extension_name, val) | ||
68 | |||
69 | /***************************************************************************** | ||
70 | * * | ||
71 | * private utility routines * | ||
72 | * * | ||
73 | *****************************************************************************/ | ||
74 | |||
75 | static XEXT_CLOSE_DISPLAY_PROTO(close_display); | ||
76 | static /* const */ XExtensionHooks xf86vidmode_extension_hooks = { | ||
77 | NULL, /* create_gc */ | ||
78 | NULL, /* copy_gc */ | ||
79 | NULL, /* flush_gc */ | ||
80 | NULL, /* free_gc */ | ||
81 | NULL, /* create_font */ | ||
82 | NULL, /* free_font */ | ||
83 | close_display, /* close_display */ | ||
84 | NULL, /* wire_to_event */ | ||
85 | NULL, /* event_to_wire */ | ||
86 | NULL, /* error */ | ||
87 | NULL, /* error_string */ | ||
88 | }; | ||
89 | |||
90 | static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info, | ||
91 | xf86vidmode_extension_name, | ||
92 | &xf86vidmode_extension_hooks, | ||
93 | 0, NULL) | ||
94 | |||
95 | static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info) | ||
96 | |||
97 | |||
98 | /***************************************************************************** | ||
99 | * * | ||
100 | * public XFree86-VidMode Extension routines * | ||
101 | * * | ||
102 | *****************************************************************************/ | ||
103 | |||
104 | Bool | ||
105 | SDL_NAME(XF86VidModeQueryExtension) (dpy, event_basep, error_basep) | ||
106 | Display *dpy; | ||
107 | int *event_basep, *error_basep; | ||
108 | { | ||
109 | XExtDisplayInfo *info = find_display (dpy); | ||
110 | |||
111 | if (XextHasExtension(info)) { | ||
112 | *event_basep = info->codes->first_event; | ||
113 | *error_basep = info->codes->first_error; | ||
114 | return True; | ||
115 | } else { | ||
116 | return False; | ||
117 | } | ||
118 | } | ||
119 | |||
120 | Bool | ||
121 | SDL_NAME(XF86VidModeQueryVersion)(dpy, majorVersion, minorVersion) | ||
122 | Display* dpy; | ||
123 | int* majorVersion; | ||
124 | int* minorVersion; | ||
125 | { | ||
126 | XExtDisplayInfo *info = find_display (dpy); | ||
127 | xXF86VidModeQueryVersionReply rep; | ||
128 | xXF86VidModeQueryVersionReq *req; | ||
129 | |||
130 | XF86VidModeCheckExtension (dpy, info, False); | ||
131 | |||
132 | LockDisplay(dpy); | ||
133 | GetReq(XF86VidModeQueryVersion, req); | ||
134 | req->reqType = info->codes->major_opcode; | ||
135 | req->xf86vidmodeReqType = X_XF86VidModeQueryVersion; | ||
136 | if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { | ||
137 | UnlockDisplay(dpy); | ||
138 | SyncHandle(); | ||
139 | return False; | ||
140 | } | ||
141 | *majorVersion = rep.majorVersion; | ||
142 | *minorVersion = rep.minorVersion; | ||
143 | UnlockDisplay(dpy); | ||
144 | SyncHandle(); | ||
145 | if (*majorVersion >= 2) | ||
146 | SDL_NAME(XF86VidModeSetClientVersion)(dpy); | ||
147 | return True; | ||
148 | } | ||
149 | |||
150 | Bool | ||
151 | SDL_NAME(XF86VidModeSetClientVersion)(Display *dpy) | ||
152 | { | ||
153 | XExtDisplayInfo *info = find_display(dpy); | ||
154 | xXF86VidModeSetClientVersionReq *req; | ||
155 | |||
156 | XF86VidModeCheckExtension(dpy, info, False); | ||
157 | |||
158 | LockDisplay(dpy); | ||
159 | GetReq(XF86VidModeSetClientVersion, req); | ||
160 | req->reqType = info->codes->major_opcode; | ||
161 | req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion; | ||
162 | req->major = XF86VIDMODE_MAJOR_VERSION; | ||
163 | req->minor = XF86VIDMODE_MINOR_VERSION; | ||
164 | UnlockDisplay(dpy); | ||
165 | SyncHandle(); | ||
166 | return True; | ||
167 | } | ||
168 | |||
169 | Bool | ||
170 | SDL_NAME(XF86VidModeSetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma) | ||
171 | { | ||
172 | XExtDisplayInfo *info = find_display(dpy); | ||
173 | xXF86VidModeSetGammaReq *req; | ||
174 | |||
175 | XF86VidModeCheckExtension(dpy, info, False); | ||
176 | |||
177 | LockDisplay(dpy); | ||
178 | GetReq(XF86VidModeSetGamma, req); | ||
179 | req->reqType = info->codes->major_opcode; | ||
180 | req->xf86vidmodeReqType = X_XF86VidModeSetGamma; | ||
181 | req->screen = screen; | ||
182 | req->red = (CARD32)(Gamma->red * 10000.); | ||
183 | req->green = (CARD32)(Gamma->green * 10000.); | ||
184 | req->blue = (CARD32)(Gamma->blue * 10000.); | ||
185 | UnlockDisplay(dpy); | ||
186 | SyncHandle(); | ||
187 | return True; | ||
188 | } | ||
189 | |||
190 | Bool | ||
191 | SDL_NAME(XF86VidModeGetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma) | ||
192 | { | ||
193 | XExtDisplayInfo *info = find_display (dpy); | ||
194 | xXF86VidModeGetGammaReply rep; | ||
195 | xXF86VidModeGetGammaReq *req; | ||
196 | |||
197 | XF86VidModeCheckExtension (dpy, info, False); | ||
198 | |||
199 | LockDisplay(dpy); | ||
200 | GetReq(XF86VidModeGetGamma, req); | ||
201 | req->reqType = info->codes->major_opcode; | ||
202 | req->xf86vidmodeReqType = X_XF86VidModeGetGamma; | ||
203 | req->screen = screen; | ||
204 | if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { | ||
205 | UnlockDisplay(dpy); | ||
206 | SyncHandle(); | ||
207 | return False; | ||
208 | } | ||
209 | Gamma->red = ((float)rep.red) / 10000.; | ||
210 | Gamma->green = ((float)rep.green) / 10000.; | ||
211 | Gamma->blue = ((float)rep.blue) / 10000.; | ||
212 | UnlockDisplay(dpy); | ||
213 | SyncHandle(); | ||
214 | return True; | ||
215 | } | ||
216 | |||
217 | Bool | ||
218 | SDL_NAME(XF86VidModeGetModeLine)(dpy, screen, dotclock, modeline) | ||
219 | Display* dpy; | ||
220 | int screen; | ||
221 | int* dotclock; | ||
222 | SDL_NAME(XF86VidModeModeLine)* modeline; | ||
223 | { | ||
224 | XExtDisplayInfo *info = find_display (dpy); | ||
225 | xXF86VidModeGetModeLineReply rep; | ||
226 | xXF86OldVidModeGetModeLineReply oldrep; | ||
227 | xXF86VidModeGetModeLineReq *req; | ||
228 | int majorVersion, minorVersion; | ||
229 | |||
230 | XF86VidModeCheckExtension (dpy, info, False); | ||
231 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
232 | |||
233 | LockDisplay(dpy); | ||
234 | GetReq(XF86VidModeGetModeLine, req); | ||
235 | req->reqType = info->codes->major_opcode; | ||
236 | req->xf86vidmodeReqType = X_XF86VidModeGetModeLine; | ||
237 | req->screen = screen; | ||
238 | |||
239 | if (majorVersion < 2) { | ||
240 | if (!_XReply(dpy, (xReply *)&oldrep, | ||
241 | (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) { | ||
242 | UnlockDisplay(dpy); | ||
243 | SyncHandle(); | ||
244 | return False; | ||
245 | } | ||
246 | *dotclock = oldrep.dotclock; | ||
247 | modeline->hdisplay = oldrep.hdisplay; | ||
248 | modeline->hsyncstart = oldrep.hsyncstart; | ||
249 | modeline->hsyncend = oldrep.hsyncend; | ||
250 | modeline->htotal = oldrep.htotal; | ||
251 | modeline->hskew = 0; | ||
252 | modeline->vdisplay = oldrep.vdisplay; | ||
253 | modeline->vsyncstart = oldrep.vsyncstart; | ||
254 | modeline->vsyncend = oldrep.vsyncend; | ||
255 | modeline->vtotal = oldrep.vtotal; | ||
256 | modeline->flags = oldrep.flags; | ||
257 | modeline->privsize = oldrep.privsize; | ||
258 | } else { | ||
259 | if (!_XReply(dpy, (xReply *)&rep, | ||
260 | (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) { | ||
261 | UnlockDisplay(dpy); | ||
262 | SyncHandle(); | ||
263 | return False; | ||
264 | } | ||
265 | *dotclock = rep.dotclock; | ||
266 | modeline->hdisplay = rep.hdisplay; | ||
267 | modeline->hsyncstart = rep.hsyncstart; | ||
268 | modeline->hsyncend = rep.hsyncend; | ||
269 | modeline->htotal = rep.htotal; | ||
270 | modeline->hskew = rep.hskew; | ||
271 | modeline->vdisplay = rep.vdisplay; | ||
272 | modeline->vsyncstart = rep.vsyncstart; | ||
273 | modeline->vsyncend = rep.vsyncend; | ||
274 | modeline->vtotal = rep.vtotal; | ||
275 | modeline->flags = rep.flags; | ||
276 | modeline->privsize = rep.privsize; | ||
277 | } | ||
278 | |||
279 | if (modeline->privsize > 0) { | ||
280 | if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) { | ||
281 | _XEatData(dpy, (modeline->privsize) * sizeof(INT32)); | ||
282 | Xfree(modeline->private); | ||
283 | return False; | ||
284 | } | ||
285 | _XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32)); | ||
286 | } else { | ||
287 | modeline->private = NULL; | ||
288 | } | ||
289 | UnlockDisplay(dpy); | ||
290 | SyncHandle(); | ||
291 | return True; | ||
292 | } | ||
293 | |||
294 | Bool | ||
295 | SDL_NAME(XF86VidModeGetAllModeLines)(dpy, screen, modecount, modelinesPtr) | ||
296 | Display* dpy; | ||
297 | int screen; | ||
298 | int* modecount; | ||
299 | SDL_NAME(XF86VidModeModeInfo) ***modelinesPtr; | ||
300 | { | ||
301 | XExtDisplayInfo *info = find_display (dpy); | ||
302 | xXF86VidModeGetAllModeLinesReply rep; | ||
303 | xXF86VidModeGetAllModeLinesReq *req; | ||
304 | SDL_NAME(XF86VidModeModeInfo) *mdinfptr, **modelines; | ||
305 | xXF86VidModeModeInfo xmdline; | ||
306 | xXF86OldVidModeModeInfo oldxmdline; | ||
307 | int i; | ||
308 | int majorVersion, minorVersion; | ||
309 | Bool protocolBug = False; | ||
310 | |||
311 | XF86VidModeCheckExtension (dpy, info, False); | ||
312 | |||
313 | /* | ||
314 | * Note: There was a bug in the protocol implementation in versions | ||
315 | * 0.x with x < 8 (the .private field wasn't being passed over the wire). | ||
316 | * Check the server's version, and accept the old format if appropriate. | ||
317 | */ | ||
318 | |||
319 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
320 | if (majorVersion == 0 && minorVersion < 8) { | ||
321 | protocolBug = True; | ||
322 | #ifdef DEBUG | ||
323 | fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is" | ||
324 | "running an old version (%d.%d)\n", majorVersion, | ||
325 | minorVersion); | ||
326 | #endif | ||
327 | } | ||
328 | |||
329 | LockDisplay(dpy); | ||
330 | GetReq(XF86VidModeGetAllModeLines, req); | ||
331 | req->reqType = info->codes->major_opcode; | ||
332 | req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines; | ||
333 | req->screen = screen; | ||
334 | if (!_XReply(dpy, (xReply *)&rep, | ||
335 | (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) { | ||
336 | UnlockDisplay(dpy); | ||
337 | SyncHandle(); | ||
338 | return False; | ||
339 | } | ||
340 | |||
341 | *modecount = rep.modecount; | ||
342 | |||
343 | if (!(modelines = (SDL_NAME(XF86VidModeModeInfo) **) Xcalloc(rep.modecount, | ||
344 | sizeof(SDL_NAME(XF86VidModeModeInfo) *) | ||
345 | +sizeof(SDL_NAME(XF86VidModeModeInfo))))) { | ||
346 | if (majorVersion < 2) | ||
347 | _XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo)); | ||
348 | else | ||
349 | _XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo)); | ||
350 | Xfree(modelines); | ||
351 | UnlockDisplay(dpy); | ||
352 | SyncHandle(); | ||
353 | return False; | ||
354 | } | ||
355 | mdinfptr = (SDL_NAME(XF86VidModeModeInfo) *) ( | ||
356 | (char *) modelines | ||
357 | + rep.modecount*sizeof(SDL_NAME(XF86VidModeModeInfo) *) | ||
358 | ); | ||
359 | |||
360 | for (i = 0; i < rep.modecount; i++) { | ||
361 | modelines[i] = mdinfptr++; | ||
362 | if (majorVersion < 2) { | ||
363 | _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo)); | ||
364 | modelines[i]->dotclock = oldxmdline.dotclock; | ||
365 | modelines[i]->hdisplay = oldxmdline.hdisplay; | ||
366 | modelines[i]->hsyncstart = oldxmdline.hsyncstart; | ||
367 | modelines[i]->hsyncend = oldxmdline.hsyncend; | ||
368 | modelines[i]->htotal = oldxmdline.htotal; | ||
369 | modelines[i]->hskew = 0; | ||
370 | modelines[i]->vdisplay = oldxmdline.vdisplay; | ||
371 | modelines[i]->vsyncstart = oldxmdline.vsyncstart; | ||
372 | modelines[i]->vsyncend = oldxmdline.vsyncend; | ||
373 | modelines[i]->vtotal = oldxmdline.vtotal; | ||
374 | modelines[i]->flags = oldxmdline.flags; | ||
375 | if (protocolBug) { | ||
376 | modelines[i]->privsize = 0; | ||
377 | modelines[i]->private = NULL; | ||
378 | } else { | ||
379 | modelines[i]->privsize = oldxmdline.privsize; | ||
380 | if (oldxmdline.privsize > 0) { | ||
381 | if (!(modelines[i]->private = | ||
382 | Xcalloc(oldxmdline.privsize, sizeof(INT32)))) { | ||
383 | _XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32)); | ||
384 | Xfree(modelines[i]->private); | ||
385 | } else { | ||
386 | _XRead(dpy, (char*)modelines[i]->private, | ||
387 | oldxmdline.privsize * sizeof(INT32)); | ||
388 | } | ||
389 | } else { | ||
390 | modelines[i]->private = NULL; | ||
391 | } | ||
392 | } | ||
393 | } else { | ||
394 | _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo)); | ||
395 | modelines[i]->dotclock = xmdline.dotclock; | ||
396 | modelines[i]->hdisplay = xmdline.hdisplay; | ||
397 | modelines[i]->hsyncstart = xmdline.hsyncstart; | ||
398 | modelines[i]->hsyncend = xmdline.hsyncend; | ||
399 | modelines[i]->htotal = xmdline.htotal; | ||
400 | modelines[i]->hskew = xmdline.hskew; | ||
401 | modelines[i]->vdisplay = xmdline.vdisplay; | ||
402 | modelines[i]->vsyncstart = xmdline.vsyncstart; | ||
403 | modelines[i]->vsyncend = xmdline.vsyncend; | ||
404 | modelines[i]->vtotal = xmdline.vtotal; | ||
405 | modelines[i]->flags = xmdline.flags; | ||
406 | if (protocolBug) { | ||
407 | modelines[i]->privsize = 0; | ||
408 | modelines[i]->private = NULL; | ||
409 | } else { | ||
410 | modelines[i]->privsize = xmdline.privsize; | ||
411 | if (xmdline.privsize > 0) { | ||
412 | if (!(modelines[i]->private = | ||
413 | Xcalloc(xmdline.privsize, sizeof(INT32)))) { | ||
414 | _XEatData(dpy, (xmdline.privsize) * sizeof(INT32)); | ||
415 | Xfree(modelines[i]->private); | ||
416 | } else { | ||
417 | _XRead(dpy, (char*)modelines[i]->private, | ||
418 | xmdline.privsize * sizeof(INT32)); | ||
419 | } | ||
420 | } else { | ||
421 | modelines[i]->private = NULL; | ||
422 | } | ||
423 | } | ||
424 | } | ||
425 | } | ||
426 | *modelinesPtr = modelines; | ||
427 | UnlockDisplay(dpy); | ||
428 | SyncHandle(); | ||
429 | return True; | ||
430 | } | ||
431 | |||
432 | /* | ||
433 | * GetReq replacement for use with VidMode protocols earlier than 2.0 | ||
434 | */ | ||
435 | #if !defined(UNIXCPP) || defined(ANSICPP) | ||
436 | #define GetOldReq(name, oldname, req) \ | ||
437 | WORD64ALIGN\ | ||
438 | if ((dpy->bufptr + SIZEOF(x##oldname##Req)) > dpy->bufmax)\ | ||
439 | _XFlush(dpy);\ | ||
440 | req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);\ | ||
441 | req->reqType = X_##name;\ | ||
442 | req->length = (SIZEOF(x##oldname##Req))>>2;\ | ||
443 | dpy->bufptr += SIZEOF(x##oldname##Req);\ | ||
444 | dpy->request++ | ||
445 | |||
446 | #else /* non-ANSI C uses empty comment instead of "##" for token concatenation */ | ||
447 | #define GetOldReq(name, oldname, req) \ | ||
448 | WORD64ALIGN\ | ||
449 | if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\ | ||
450 | _XFlush(dpy);\ | ||
451 | req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\ | ||
452 | req->reqType = X_/**/name;\ | ||
453 | req->length = (SIZEOF(x/**/oldname/**/Req))>>2;\ | ||
454 | dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\ | ||
455 | dpy->request++ | ||
456 | #endif | ||
457 | |||
458 | Bool | ||
459 | SDL_NAME(XF86VidModeAddModeLine) (dpy, screen, newmodeline, aftermodeline) | ||
460 | Display *dpy; | ||
461 | int screen; | ||
462 | SDL_NAME(XF86VidModeModeInfo)* newmodeline; | ||
463 | SDL_NAME(XF86VidModeModeInfo)* aftermodeline; | ||
464 | { | ||
465 | XExtDisplayInfo *info = find_display (dpy); | ||
466 | xXF86VidModeAddModeLineReq *req; | ||
467 | xXF86OldVidModeAddModeLineReq *oldreq; | ||
468 | int majorVersion, minorVersion; | ||
469 | |||
470 | XF86VidModeCheckExtension (dpy, info, False); | ||
471 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
472 | |||
473 | LockDisplay(dpy); | ||
474 | if (majorVersion < 2) { | ||
475 | GetOldReq(XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq); | ||
476 | oldreq->reqType = info->codes->major_opcode; | ||
477 | oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine; | ||
478 | oldreq->screen = screen; | ||
479 | oldreq->dotclock = newmodeline->dotclock; | ||
480 | oldreq->hdisplay = newmodeline->hdisplay; | ||
481 | oldreq->hsyncstart = newmodeline->hsyncstart; | ||
482 | oldreq->hsyncend = newmodeline->hsyncend; | ||
483 | oldreq->htotal = newmodeline->htotal; | ||
484 | oldreq->vdisplay = newmodeline->vdisplay; | ||
485 | oldreq->vsyncstart = newmodeline->vsyncstart; | ||
486 | oldreq->vsyncend = newmodeline->vsyncend; | ||
487 | oldreq->vtotal = newmodeline->vtotal; | ||
488 | oldreq->flags = newmodeline->flags; | ||
489 | oldreq->privsize = newmodeline->privsize; | ||
490 | if (aftermodeline != NULL) { | ||
491 | oldreq->after_dotclock = aftermodeline->dotclock; | ||
492 | oldreq->after_hdisplay = aftermodeline->hdisplay; | ||
493 | oldreq->after_hsyncstart = aftermodeline->hsyncstart; | ||
494 | oldreq->after_hsyncend = aftermodeline->hsyncend; | ||
495 | oldreq->after_htotal = aftermodeline->htotal; | ||
496 | oldreq->after_vdisplay = aftermodeline->vdisplay; | ||
497 | oldreq->after_vsyncstart = aftermodeline->vsyncstart; | ||
498 | oldreq->after_vsyncend = aftermodeline->vsyncend; | ||
499 | oldreq->after_vtotal = aftermodeline->vtotal; | ||
500 | oldreq->after_flags = aftermodeline->flags; | ||
501 | } else { | ||
502 | oldreq->after_dotclock = 0; | ||
503 | oldreq->after_hdisplay = 0; | ||
504 | oldreq->after_hsyncstart = 0; | ||
505 | oldreq->after_hsyncend = 0; | ||
506 | oldreq->after_htotal = 0; | ||
507 | oldreq->after_vdisplay = 0; | ||
508 | oldreq->after_vsyncstart = 0; | ||
509 | oldreq->after_vsyncend = 0; | ||
510 | oldreq->after_vtotal = 0; | ||
511 | oldreq->after_flags = 0; | ||
512 | } | ||
513 | if (newmodeline->privsize) { | ||
514 | oldreq->length += newmodeline->privsize; | ||
515 | Data32(dpy, (long *) newmodeline->private, | ||
516 | newmodeline->privsize * sizeof(INT32)); | ||
517 | } | ||
518 | } else { | ||
519 | GetReq(XF86VidModeAddModeLine, req); | ||
520 | req->reqType = info->codes->major_opcode; | ||
521 | req->xf86vidmodeReqType = X_XF86VidModeAddModeLine; | ||
522 | req->screen = screen; | ||
523 | req->dotclock = newmodeline->dotclock; | ||
524 | req->hdisplay = newmodeline->hdisplay; | ||
525 | req->hsyncstart = newmodeline->hsyncstart; | ||
526 | req->hsyncend = newmodeline->hsyncend; | ||
527 | req->htotal = newmodeline->htotal; | ||
528 | req->hskew = newmodeline->hskew; | ||
529 | req->vdisplay = newmodeline->vdisplay; | ||
530 | req->vsyncstart = newmodeline->vsyncstart; | ||
531 | req->vsyncend = newmodeline->vsyncend; | ||
532 | req->vtotal = newmodeline->vtotal; | ||
533 | req->flags = newmodeline->flags; | ||
534 | req->privsize = newmodeline->privsize; | ||
535 | if (aftermodeline != NULL) { | ||
536 | req->after_dotclock = aftermodeline->dotclock; | ||
537 | req->after_hdisplay = aftermodeline->hdisplay; | ||
538 | req->after_hsyncstart = aftermodeline->hsyncstart; | ||
539 | req->after_hsyncend = aftermodeline->hsyncend; | ||
540 | req->after_htotal = aftermodeline->htotal; | ||
541 | req->after_hskew = aftermodeline->hskew; | ||
542 | req->after_vdisplay = aftermodeline->vdisplay; | ||
543 | req->after_vsyncstart = aftermodeline->vsyncstart; | ||
544 | req->after_vsyncend = aftermodeline->vsyncend; | ||
545 | req->after_vtotal = aftermodeline->vtotal; | ||
546 | req->after_flags = aftermodeline->flags; | ||
547 | } else { | ||
548 | req->after_dotclock = 0; | ||
549 | req->after_hdisplay = 0; | ||
550 | req->after_hsyncstart = 0; | ||
551 | req->after_hsyncend = 0; | ||
552 | req->after_htotal = 0; | ||
553 | req->after_hskew = 0; | ||
554 | req->after_vdisplay = 0; | ||
555 | req->after_vsyncstart = 0; | ||
556 | req->after_vsyncend = 0; | ||
557 | req->after_vtotal = 0; | ||
558 | req->after_flags = 0; | ||
559 | } | ||
560 | if (newmodeline->privsize) { | ||
561 | req->length += newmodeline->privsize; | ||
562 | Data32(dpy, (long *) newmodeline->private, | ||
563 | newmodeline->privsize * sizeof(INT32)); | ||
564 | } | ||
565 | } | ||
566 | UnlockDisplay(dpy); | ||
567 | SyncHandle(); | ||
568 | return True; | ||
569 | } | ||
570 | |||
571 | Bool | ||
572 | SDL_NAME(XF86VidModeDeleteModeLine) (dpy, screen, modeline) | ||
573 | Display *dpy; | ||
574 | int screen; | ||
575 | SDL_NAME(XF86VidModeModeInfo)* modeline; | ||
576 | { | ||
577 | XExtDisplayInfo *info = find_display (dpy); | ||
578 | xXF86VidModeDeleteModeLineReq *req; | ||
579 | xXF86OldVidModeDeleteModeLineReq *oldreq; | ||
580 | int majorVersion, minorVersion; | ||
581 | |||
582 | XF86VidModeCheckExtension (dpy, info, 0); | ||
583 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
584 | |||
585 | LockDisplay(dpy); | ||
586 | if (majorVersion < 2) { | ||
587 | GetOldReq(XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine, oldreq); | ||
588 | oldreq->reqType = info->codes->major_opcode; | ||
589 | oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine; | ||
590 | oldreq->screen = screen; | ||
591 | oldreq->dotclock = modeline->dotclock; | ||
592 | oldreq->hdisplay = modeline->hdisplay; | ||
593 | oldreq->hsyncstart = modeline->hsyncstart; | ||
594 | oldreq->hsyncend = modeline->hsyncend; | ||
595 | oldreq->htotal = modeline->htotal; | ||
596 | oldreq->vdisplay = modeline->vdisplay; | ||
597 | oldreq->vsyncstart = modeline->vsyncstart; | ||
598 | oldreq->vsyncend = modeline->vsyncend; | ||
599 | oldreq->vtotal = modeline->vtotal; | ||
600 | oldreq->flags = modeline->flags; | ||
601 | oldreq->privsize = modeline->privsize; | ||
602 | if (modeline->privsize) { | ||
603 | oldreq->length += modeline->privsize; | ||
604 | Data32(dpy, (long *) modeline->private, | ||
605 | modeline->privsize * sizeof(INT32)); | ||
606 | } | ||
607 | } else { | ||
608 | GetReq(XF86VidModeDeleteModeLine, req); | ||
609 | req->reqType = info->codes->major_opcode; | ||
610 | req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine; | ||
611 | req->screen = screen; | ||
612 | req->dotclock = modeline->dotclock; | ||
613 | req->hdisplay = modeline->hdisplay; | ||
614 | req->hsyncstart = modeline->hsyncstart; | ||
615 | req->hsyncend = modeline->hsyncend; | ||
616 | req->htotal = modeline->htotal; | ||
617 | req->hskew = modeline->hskew; | ||
618 | req->vdisplay = modeline->vdisplay; | ||
619 | req->vsyncstart = modeline->vsyncstart; | ||
620 | req->vsyncend = modeline->vsyncend; | ||
621 | req->vtotal = modeline->vtotal; | ||
622 | req->flags = modeline->flags; | ||
623 | req->privsize = modeline->privsize; | ||
624 | if (modeline->privsize) { | ||
625 | req->length += modeline->privsize; | ||
626 | Data32(dpy, (long *) modeline->private, | ||
627 | modeline->privsize * sizeof(INT32)); | ||
628 | } | ||
629 | } | ||
630 | UnlockDisplay(dpy); | ||
631 | SyncHandle(); | ||
632 | return True; | ||
633 | } | ||
634 | |||
635 | Bool | ||
636 | SDL_NAME(XF86VidModeModModeLine) (dpy, screen, modeline) | ||
637 | Display *dpy; | ||
638 | int screen; | ||
639 | SDL_NAME(XF86VidModeModeLine)* modeline; | ||
640 | { | ||
641 | XExtDisplayInfo *info = find_display (dpy); | ||
642 | xXF86VidModeModModeLineReq *req; | ||
643 | xXF86OldVidModeModModeLineReq *oldreq; | ||
644 | int majorVersion, minorVersion; | ||
645 | |||
646 | XF86VidModeCheckExtension (dpy, info, 0); | ||
647 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
648 | |||
649 | LockDisplay(dpy); | ||
650 | if (majorVersion < 2) { | ||
651 | GetOldReq(XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq); | ||
652 | oldreq->reqType = info->codes->major_opcode; | ||
653 | oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine; | ||
654 | oldreq->screen = screen; | ||
655 | oldreq->hdisplay = modeline->hdisplay; | ||
656 | oldreq->hsyncstart = modeline->hsyncstart; | ||
657 | oldreq->hsyncend = modeline->hsyncend; | ||
658 | oldreq->htotal = modeline->htotal; | ||
659 | oldreq->vdisplay = modeline->vdisplay; | ||
660 | oldreq->vsyncstart = modeline->vsyncstart; | ||
661 | oldreq->vsyncend = modeline->vsyncend; | ||
662 | oldreq->vtotal = modeline->vtotal; | ||
663 | oldreq->flags = modeline->flags; | ||
664 | oldreq->privsize = modeline->privsize; | ||
665 | if (modeline->privsize) { | ||
666 | oldreq->length += modeline->privsize; | ||
667 | Data32(dpy, (long *) modeline->private, | ||
668 | modeline->privsize * sizeof(INT32)); | ||
669 | } | ||
670 | } else { | ||
671 | GetReq(XF86VidModeModModeLine, req); | ||
672 | req->reqType = info->codes->major_opcode; | ||
673 | req->xf86vidmodeReqType = X_XF86VidModeModModeLine; | ||
674 | req->screen = screen; | ||
675 | req->hdisplay = modeline->hdisplay; | ||
676 | req->hsyncstart = modeline->hsyncstart; | ||
677 | req->hsyncend = modeline->hsyncend; | ||
678 | req->htotal = modeline->htotal; | ||
679 | req->hskew = modeline->hskew; | ||
680 | req->vdisplay = modeline->vdisplay; | ||
681 | req->vsyncstart = modeline->vsyncstart; | ||
682 | req->vsyncend = modeline->vsyncend; | ||
683 | req->vtotal = modeline->vtotal; | ||
684 | req->flags = modeline->flags; | ||
685 | req->privsize = modeline->privsize; | ||
686 | if (modeline->privsize) { | ||
687 | req->length += modeline->privsize; | ||
688 | Data32(dpy, (long *) modeline->private, | ||
689 | modeline->privsize * sizeof(INT32)); | ||
690 | } | ||
691 | } | ||
692 | UnlockDisplay(dpy); | ||
693 | SyncHandle(); | ||
694 | return True; | ||
695 | } | ||
696 | |||
697 | Status | ||
698 | SDL_NAME(XF86VidModeValidateModeLine) (dpy, screen, modeline) | ||
699 | Display *dpy; | ||
700 | int screen; | ||
701 | SDL_NAME(XF86VidModeModeInfo)* modeline; | ||
702 | { | ||
703 | XExtDisplayInfo *info = find_display (dpy); | ||
704 | xXF86VidModeValidateModeLineReq *req; | ||
705 | xXF86OldVidModeValidateModeLineReq *oldreq; | ||
706 | xXF86VidModeValidateModeLineReply rep; | ||
707 | int majorVersion, minorVersion; | ||
708 | |||
709 | XF86VidModeCheckExtension (dpy, info, 0); | ||
710 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
711 | |||
712 | LockDisplay(dpy); | ||
713 | |||
714 | if (majorVersion < 2) { | ||
715 | GetOldReq(XF86VidModeValidateModeLine, XF86OldVidModeValidateModeLine, oldreq); | ||
716 | oldreq->reqType = info->codes->major_opcode; | ||
717 | oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine; | ||
718 | oldreq->screen = screen; | ||
719 | oldreq->dotclock = modeline->dotclock; | ||
720 | oldreq->hdisplay = modeline->hdisplay; | ||
721 | oldreq->hsyncstart = modeline->hsyncstart; | ||
722 | oldreq->hsyncend = modeline->hsyncend; | ||
723 | oldreq->htotal = modeline->htotal; | ||
724 | oldreq->vdisplay = modeline->vdisplay; | ||
725 | oldreq->vsyncstart = modeline->vsyncstart; | ||
726 | oldreq->vsyncend = modeline->vsyncend; | ||
727 | oldreq->vtotal = modeline->vtotal; | ||
728 | oldreq->flags = modeline->flags; | ||
729 | oldreq->privsize = modeline->privsize; | ||
730 | if (modeline->privsize) { | ||
731 | oldreq->length += modeline->privsize; | ||
732 | Data32(dpy, (long *) modeline->private, | ||
733 | modeline->privsize * sizeof(INT32)); | ||
734 | } | ||
735 | } else { | ||
736 | GetReq(XF86VidModeValidateModeLine, req); | ||
737 | req->reqType = info->codes->major_opcode; | ||
738 | req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine; | ||
739 | req->screen = screen; | ||
740 | req->dotclock = modeline->dotclock; | ||
741 | req->hdisplay = modeline->hdisplay; | ||
742 | req->hsyncstart = modeline->hsyncstart; | ||
743 | req->hsyncend = modeline->hsyncend; | ||
744 | req->htotal = modeline->htotal; | ||
745 | req->hskew = modeline->hskew; | ||
746 | req->vdisplay = modeline->vdisplay; | ||
747 | req->vsyncstart = modeline->vsyncstart; | ||
748 | req->vsyncend = modeline->vsyncend; | ||
749 | req->vtotal = modeline->vtotal; | ||
750 | req->flags = modeline->flags; | ||
751 | req->privsize = modeline->privsize; | ||
752 | if (modeline->privsize) { | ||
753 | req->length += modeline->privsize; | ||
754 | Data32(dpy, (long *) modeline->private, | ||
755 | modeline->privsize * sizeof(INT32)); | ||
756 | } | ||
757 | } | ||
758 | if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { | ||
759 | UnlockDisplay(dpy); | ||
760 | SyncHandle(); | ||
761 | return MODE_BAD; | ||
762 | } | ||
763 | UnlockDisplay(dpy); | ||
764 | SyncHandle(); | ||
765 | return rep.status; | ||
766 | } | ||
767 | |||
768 | Bool | ||
769 | SDL_NAME(XF86VidModeSwitchMode)(dpy, screen, zoom) | ||
770 | Display* dpy; | ||
771 | int screen; | ||
772 | int zoom; | ||
773 | { | ||
774 | XExtDisplayInfo *info = find_display (dpy); | ||
775 | xXF86VidModeSwitchModeReq *req; | ||
776 | |||
777 | XF86VidModeCheckExtension (dpy, info, False); | ||
778 | |||
779 | LockDisplay(dpy); | ||
780 | GetReq(XF86VidModeSwitchMode, req); | ||
781 | req->reqType = info->codes->major_opcode; | ||
782 | req->xf86vidmodeReqType = X_XF86VidModeSwitchMode; | ||
783 | req->screen = screen; | ||
784 | req->zoom = zoom; | ||
785 | UnlockDisplay(dpy); | ||
786 | SyncHandle(); | ||
787 | return True; | ||
788 | } | ||
789 | |||
790 | Bool | ||
791 | SDL_NAME(XF86VidModeSwitchToMode)(dpy, screen, modeline) | ||
792 | Display* dpy; | ||
793 | int screen; | ||
794 | SDL_NAME(XF86VidModeModeInfo)* modeline; | ||
795 | { | ||
796 | XExtDisplayInfo *info = find_display (dpy); | ||
797 | xXF86VidModeSwitchToModeReq *req; | ||
798 | xXF86OldVidModeSwitchToModeReq *oldreq; | ||
799 | int majorVersion, minorVersion; | ||
800 | Bool protocolBug = False; | ||
801 | |||
802 | XF86VidModeCheckExtension (dpy, info, False); | ||
803 | |||
804 | /* | ||
805 | * Note: There was a bug in the protocol implementation in versions | ||
806 | * 0.x with x < 8 (the .private field wasn't expected to be sent over | ||
807 | * the wire). Check the server's version, and accept the old format | ||
808 | * if appropriate. | ||
809 | */ | ||
810 | |||
811 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
812 | if (majorVersion == 0 && minorVersion < 8) { | ||
813 | protocolBug = True; | ||
814 | #ifdef DEBUG | ||
815 | fprintf(stderr, "XF86VidModeSwitchToMode: Warning: Xserver is" | ||
816 | "running an old version (%d.%d)\n", majorVersion, | ||
817 | minorVersion); | ||
818 | #endif | ||
819 | } | ||
820 | |||
821 | LockDisplay(dpy); | ||
822 | if (majorVersion < 2) { | ||
823 | GetOldReq(XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode, oldreq); | ||
824 | oldreq->reqType = info->codes->major_opcode; | ||
825 | oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode; | ||
826 | oldreq->screen = screen; | ||
827 | oldreq->dotclock = modeline->dotclock; | ||
828 | oldreq->hdisplay = modeline->hdisplay; | ||
829 | oldreq->hsyncstart = modeline->hsyncstart; | ||
830 | oldreq->hsyncend = modeline->hsyncend; | ||
831 | oldreq->htotal = modeline->htotal; | ||
832 | oldreq->vdisplay = modeline->vdisplay; | ||
833 | oldreq->vsyncstart = modeline->vsyncstart; | ||
834 | oldreq->vsyncend = modeline->vsyncend; | ||
835 | oldreq->vtotal = modeline->vtotal; | ||
836 | oldreq->flags = modeline->flags; | ||
837 | if (protocolBug) { | ||
838 | oldreq->privsize = 0; | ||
839 | } else { | ||
840 | oldreq->privsize = modeline->privsize; | ||
841 | if (modeline->privsize) { | ||
842 | oldreq->length += modeline->privsize; | ||
843 | Data32(dpy, (long *) modeline->private, | ||
844 | modeline->privsize * sizeof(INT32)); | ||
845 | } | ||
846 | } | ||
847 | } else { | ||
848 | GetReq(XF86VidModeSwitchToMode, req); | ||
849 | req->reqType = info->codes->major_opcode; | ||
850 | req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode; | ||
851 | req->screen = screen; | ||
852 | req->dotclock = modeline->dotclock; | ||
853 | req->hdisplay = modeline->hdisplay; | ||
854 | req->hsyncstart = modeline->hsyncstart; | ||
855 | req->hsyncend = modeline->hsyncend; | ||
856 | req->htotal = modeline->htotal; | ||
857 | req->hskew = modeline->hskew; | ||
858 | req->vdisplay = modeline->vdisplay; | ||
859 | req->vsyncstart = modeline->vsyncstart; | ||
860 | req->vsyncend = modeline->vsyncend; | ||
861 | req->vtotal = modeline->vtotal; | ||
862 | req->flags = modeline->flags; | ||
863 | if (protocolBug) { | ||
864 | req->privsize = 0; | ||
865 | } else { | ||
866 | req->privsize = modeline->privsize; | ||
867 | if (modeline->privsize) { | ||
868 | req->length += modeline->privsize; | ||
869 | Data32(dpy, (long *) modeline->private, | ||
870 | modeline->privsize * sizeof(INT32)); | ||
871 | } | ||
872 | } | ||
873 | } | ||
874 | UnlockDisplay(dpy); | ||
875 | SyncHandle(); | ||
876 | return True; | ||
877 | } | ||
878 | |||
879 | Bool | ||
880 | SDL_NAME(XF86VidModeLockModeSwitch)(dpy, screen, lock) | ||
881 | Display* dpy; | ||
882 | int screen; | ||
883 | int lock; | ||
884 | { | ||
885 | XExtDisplayInfo *info = find_display (dpy); | ||
886 | xXF86VidModeLockModeSwitchReq *req; | ||
887 | |||
888 | XF86VidModeCheckExtension (dpy, info, False); | ||
889 | |||
890 | LockDisplay(dpy); | ||
891 | GetReq(XF86VidModeLockModeSwitch, req); | ||
892 | req->reqType = info->codes->major_opcode; | ||
893 | req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch; | ||
894 | req->screen = screen; | ||
895 | req->lock = lock; | ||
896 | UnlockDisplay(dpy); | ||
897 | SyncHandle(); | ||
898 | return True; | ||
899 | } | ||
900 | |||
901 | Bool | ||
902 | SDL_NAME(XF86VidModeGetMonitor)(dpy, screen, monitor) | ||
903 | Display* dpy; | ||
904 | int screen; | ||
905 | SDL_NAME(XF86VidModeMonitor)* monitor; | ||
906 | { | ||
907 | XExtDisplayInfo *info = find_display (dpy); | ||
908 | xXF86VidModeGetMonitorReply rep; | ||
909 | xXF86VidModeGetMonitorReq *req; | ||
910 | CARD32 syncrange; | ||
911 | int i; | ||
912 | |||
913 | XF86VidModeCheckExtension (dpy, info, False); | ||
914 | |||
915 | LockDisplay(dpy); | ||
916 | GetReq(XF86VidModeGetMonitor, req); | ||
917 | req->reqType = info->codes->major_opcode; | ||
918 | req->xf86vidmodeReqType = X_XF86VidModeGetMonitor; | ||
919 | req->screen = screen; | ||
920 | if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { | ||
921 | UnlockDisplay(dpy); | ||
922 | SyncHandle(); | ||
923 | return False; | ||
924 | } | ||
925 | monitor->nhsync = rep.nhsync; | ||
926 | monitor->nvsync = rep.nvsync; | ||
927 | #if 0 | ||
928 | monitor->bandwidth = (float)rep.bandwidth / 1e6; | ||
929 | #endif | ||
930 | if (rep.vendorLength) { | ||
931 | if (!(monitor->vendor = (char *)Xcalloc(rep.vendorLength + 1, 1))) { | ||
932 | _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + | ||
933 | ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); | ||
934 | UnlockDisplay(dpy); | ||
935 | SyncHandle(); | ||
936 | return False; | ||
937 | } | ||
938 | } else { | ||
939 | monitor->vendor = NULL; | ||
940 | } | ||
941 | if (rep.modelLength) { | ||
942 | if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) { | ||
943 | _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + | ||
944 | ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); | ||
945 | if (monitor->vendor) | ||
946 | Xfree(monitor->vendor); | ||
947 | UnlockDisplay(dpy); | ||
948 | SyncHandle(); | ||
949 | return False; | ||
950 | } | ||
951 | } else { | ||
952 | monitor->model = NULL; | ||
953 | } | ||
954 | if (!(monitor->hsync = Xcalloc(rep.nhsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) { | ||
955 | _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + | ||
956 | ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); | ||
957 | |||
958 | if (monitor->vendor) | ||
959 | Xfree(monitor->vendor); | ||
960 | if (monitor->model) | ||
961 | Xfree(monitor->model); | ||
962 | UnlockDisplay(dpy); | ||
963 | SyncHandle(); | ||
964 | return False; | ||
965 | } | ||
966 | if (!(monitor->vsync = Xcalloc(rep.nvsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) { | ||
967 | _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + | ||
968 | ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); | ||
969 | if (monitor->vendor) | ||
970 | Xfree(monitor->vendor); | ||
971 | if (monitor->model) | ||
972 | Xfree(monitor->model); | ||
973 | Xfree(monitor->hsync); | ||
974 | UnlockDisplay(dpy); | ||
975 | SyncHandle(); | ||
976 | return False; | ||
977 | } | ||
978 | for (i = 0; i < rep.nhsync; i++) { | ||
979 | _XRead(dpy, (char *)&syncrange, 4); | ||
980 | monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0; | ||
981 | monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0; | ||
982 | } | ||
983 | for (i = 0; i < rep.nvsync; i++) { | ||
984 | _XRead(dpy, (char *)&syncrange, 4); | ||
985 | monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0; | ||
986 | monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0; | ||
987 | } | ||
988 | if (rep.vendorLength) | ||
989 | _XReadPad(dpy, monitor->vendor, rep.vendorLength); | ||
990 | else | ||
991 | monitor->vendor = ""; | ||
992 | if (rep.modelLength) | ||
993 | _XReadPad(dpy, monitor->model, rep.modelLength); | ||
994 | else | ||
995 | monitor->model = ""; | ||
996 | |||
997 | UnlockDisplay(dpy); | ||
998 | SyncHandle(); | ||
999 | return True; | ||
1000 | } | ||
1001 | |||
1002 | Bool | ||
1003 | SDL_NAME(XF86VidModeGetViewPort)(dpy, screen, x, y) | ||
1004 | Display* dpy; | ||
1005 | int screen; | ||
1006 | int *x, *y; | ||
1007 | { | ||
1008 | XExtDisplayInfo *info = find_display (dpy); | ||
1009 | xXF86VidModeGetViewPortReply rep; | ||
1010 | xXF86VidModeGetViewPortReq *req; | ||
1011 | int majorVersion, minorVersion; | ||
1012 | Bool protocolBug = False; | ||
1013 | |||
1014 | XF86VidModeCheckExtension (dpy, info, False); | ||
1015 | |||
1016 | /* | ||
1017 | * Note: There was a bug in the protocol implementation in versions | ||
1018 | * 0.x with x < 8 (no reply was sent, so the client would hang) | ||
1019 | * Check the server's version, and don't wait for a reply with older | ||
1020 | * versions. | ||
1021 | */ | ||
1022 | |||
1023 | SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); | ||
1024 | if (majorVersion == 0 && minorVersion < 8) { | ||
1025 | protocolBug = True; | ||
1026 | #ifdef DEBUG | ||
1027 | fprintf(stderr, "XF86VidModeGetViewPort: Warning: Xserver is" | ||
1028 | "running an old version (%d.%d)\n", majorVersion, | ||
1029 | minorVersion); | ||
1030 | #endif | ||
1031 | } | ||
1032 | LockDisplay(dpy); | ||
1033 | GetReq(XF86VidModeGetViewPort, req); | ||
1034 | req->reqType = info->codes->major_opcode; | ||
1035 | req->xf86vidmodeReqType = X_XF86VidModeGetViewPort; | ||
1036 | req->screen = screen; | ||
1037 | if (protocolBug) { | ||
1038 | *x = 0; | ||
1039 | *y = 0; | ||
1040 | } else { | ||
1041 | if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { | ||
1042 | UnlockDisplay(dpy); | ||
1043 | SyncHandle(); | ||
1044 | return False; | ||
1045 | } | ||
1046 | *x = rep.x; | ||
1047 | *y = rep.y; | ||
1048 | } | ||
1049 | |||
1050 | UnlockDisplay(dpy); | ||
1051 | SyncHandle(); | ||
1052 | return True; | ||
1053 | } | ||
1054 | |||
1055 | Bool | ||
1056 | SDL_NAME(XF86VidModeSetViewPort)(dpy, screen, x, y) | ||
1057 | Display* dpy; | ||
1058 | int screen; | ||
1059 | int x, y; | ||
1060 | { | ||
1061 | XExtDisplayInfo *info = find_display (dpy); | ||
1062 | xXF86VidModeSetViewPortReq *req; | ||
1063 | |||
1064 | XF86VidModeCheckExtension (dpy, info, False); | ||
1065 | |||
1066 | LockDisplay(dpy); | ||
1067 | GetReq(XF86VidModeSetViewPort, req); | ||
1068 | req->reqType = info->codes->major_opcode; | ||
1069 | req->xf86vidmodeReqType = X_XF86VidModeSetViewPort; | ||
1070 | req->screen = screen; | ||
1071 | req->x = x; | ||
1072 | req->y = y; | ||
1073 | |||
1074 | UnlockDisplay(dpy); | ||
1075 | SyncHandle(); | ||
1076 | return True; | ||
1077 | } | ||
1078 | |||
1079 | Bool | ||
1080 | SDL_NAME(XF86VidModeGetDotClocks)(dpy, screen, | ||
1081 | flagsPtr, numclocksPtr, maxclocksPtr, clocksPtr) | ||
1082 | Display* dpy; | ||
1083 | int screen; | ||
1084 | int *flagsPtr, *numclocksPtr, *maxclocksPtr, *clocksPtr[]; | ||
1085 | { | ||
1086 | XExtDisplayInfo *info = find_display (dpy); | ||
1087 | xXF86VidModeGetDotClocksReply rep; | ||
1088 | xXF86VidModeGetDotClocksReq *req; | ||
1089 | int i, *dotclocks; | ||
1090 | CARD32 dotclk; | ||
1091 | |||
1092 | XF86VidModeCheckExtension (dpy, info, False); | ||
1093 | |||
1094 | LockDisplay(dpy); | ||
1095 | GetReq(XF86VidModeGetDotClocks, req); | ||
1096 | req->reqType = info->codes->major_opcode; | ||
1097 | req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks; | ||
1098 | req->screen = screen; | ||
1099 | if (!_XReply(dpy, (xReply *)&rep, | ||
1100 | (SIZEOF(xXF86VidModeGetDotClocksReply) - SIZEOF(xReply)) >> 2, xFalse)) | ||
1101 | { | ||
1102 | UnlockDisplay(dpy); | ||
1103 | SyncHandle(); | ||
1104 | return False; | ||
1105 | } | ||
1106 | *numclocksPtr = rep.clocks; | ||
1107 | *maxclocksPtr = rep.maxclocks; | ||
1108 | *flagsPtr = rep.flags; | ||
1109 | |||
1110 | if (!(dotclocks = (int*) Xcalloc(rep.clocks, sizeof(int)))) { | ||
1111 | _XEatData(dpy, (rep.clocks) * 4); | ||
1112 | Xfree(dotclocks); | ||
1113 | UnlockDisplay(dpy); | ||
1114 | SyncHandle(); | ||
1115 | return False; | ||
1116 | } | ||
1117 | |||
1118 | for (i = 0; i < rep.clocks; i++) { | ||
1119 | _XRead(dpy, (char*)&dotclk, 4); | ||
1120 | dotclocks[i] = dotclk; | ||
1121 | } | ||
1122 | *clocksPtr = dotclocks; | ||
1123 | UnlockDisplay(dpy); | ||
1124 | SyncHandle(); | ||
1125 | return True; | ||
1126 | } | ||
1127 | |||
1128 | Bool | ||
1129 | SDL_NAME(XF86VidModeSetGammaRamp) ( | ||
1130 | Display *dpy, | ||
1131 | int screen, | ||
1132 | int size, | ||
1133 | unsigned short *red, | ||
1134 | unsigned short *green, | ||
1135 | unsigned short *blue | ||
1136 | ) | ||
1137 | { | ||
1138 | int length = (size + 1) & ~1; | ||
1139 | XExtDisplayInfo *info = find_display (dpy); | ||
1140 | xXF86VidModeSetGammaRampReq *req; | ||
1141 | |||
1142 | XF86VidModeCheckExtension (dpy, info, False); | ||
1143 | LockDisplay(dpy); | ||
1144 | GetReq(XF86VidModeSetGammaRamp, req); | ||
1145 | req->reqType = info->codes->major_opcode; | ||
1146 | req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp; | ||
1147 | req->screen = screen; | ||
1148 | req->length += (length >> 1) * 3; | ||
1149 | req->size = size; | ||
1150 | _XSend(dpy, (char*)red, size * 2); | ||
1151 | _XSend(dpy, (char*)green, size * 2); | ||
1152 | _XSend(dpy, (char*)blue, size * 2); | ||
1153 | UnlockDisplay(dpy); | ||
1154 | SyncHandle(); | ||
1155 | return True; | ||
1156 | } | ||
1157 | |||
1158 | |||
1159 | Bool | ||
1160 | SDL_NAME(XF86VidModeGetGammaRamp) ( | ||
1161 | Display *dpy, | ||
1162 | int screen, | ||
1163 | int size, | ||
1164 | unsigned short *red, | ||
1165 | unsigned short *green, | ||
1166 | unsigned short *blue | ||
1167 | ) | ||
1168 | { | ||
1169 | XExtDisplayInfo *info = find_display (dpy); | ||
1170 | xXF86VidModeGetGammaRampReq *req; | ||
1171 | xXF86VidModeGetGammaRampReply rep; | ||
1172 | |||
1173 | XF86VidModeCheckExtension (dpy, info, False); | ||
1174 | |||
1175 | LockDisplay(dpy); | ||
1176 | GetReq(XF86VidModeGetGammaRamp, req); | ||
1177 | req->reqType = info->codes->major_opcode; | ||
1178 | req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp; | ||
1179 | req->screen = screen; | ||
1180 | req->size = size; | ||
1181 | if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { | ||
1182 | UnlockDisplay (dpy); | ||
1183 | SyncHandle (); | ||
1184 | return False; | ||
1185 | } | ||
1186 | if(rep.size) { | ||
1187 | _XRead(dpy, (char*)red, rep.size << 1); | ||
1188 | _XRead(dpy, (char*)green, rep.size << 1); | ||
1189 | _XRead(dpy, (char*)blue, rep.size << 1); | ||
1190 | } | ||
1191 | |||
1192 | UnlockDisplay(dpy); | ||
1193 | SyncHandle(); | ||
1194 | return True; | ||
1195 | } | ||
1196 | |||
1197 | Bool SDL_NAME(XF86VidModeGetGammaRampSize)( | ||
1198 | Display *dpy, | ||
1199 | int screen, | ||
1200 | int *size | ||
1201 | ) | ||
1202 | { | ||
1203 | XExtDisplayInfo *info = find_display (dpy); | ||
1204 | xXF86VidModeGetGammaRampSizeReq *req; | ||
1205 | xXF86VidModeGetGammaRampSizeReply rep; | ||
1206 | |||
1207 | *size = 0; | ||
1208 | |||
1209 | XF86VidModeCheckExtension (dpy, info, False); | ||
1210 | |||
1211 | LockDisplay(dpy); | ||
1212 | GetReq(XF86VidModeGetGammaRampSize, req); | ||
1213 | req->reqType = info->codes->major_opcode; | ||
1214 | req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize; | ||
1215 | req->screen = screen; | ||
1216 | if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { | ||
1217 | UnlockDisplay (dpy); | ||
1218 | SyncHandle (); | ||
1219 | return False; | ||
1220 | } | ||
1221 | *size = rep.size; | ||
1222 | UnlockDisplay(dpy); | ||
1223 | SyncHandle(); | ||
1224 | return True; | ||
1225 | } | ||
1226 | |||