src/XF86VMode.c

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