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