IABSD.fr/xenocara/lib/libXxf86vm/src/XF86VMode.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : matthieu
  Date : 2008-06-13 17:30:58
  Hash : 657fa785
  Message : XF86VidModeGetMonitor: don't return static strings to the caller when the man page says it's dynamically allocated memory. Just leave the NULL there (after discusion with Adam Jackson from X.Org). also remove the RCS keyworks while there to ease future merge.

• lib/libXxf86vm/src/XF86VMode.c

• /*
  
  Copyright (c) 1995  Kaleb S. KEITHLEY
  
  Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so, subject to
  the following conditions:
  
  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.
  
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES 
  OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.
  
  Except as contained in this notice, the name of Kaleb S. KEITHLEY 
  shall not be used in advertising or otherwise to promote the sale, use 
  or other dealings in this Software without prior written authorization
  from Kaleb S. KEITHLEY.
  
  */
  
  /* THIS IS NOT AN X CONSORTIUM STANDARD */
  
  #define NEED_EVENTS
  #define NEED_REPLIES
  #include <X11/Xlibint.h>
  #include <X11/extensions/xf86vmstr.h>
  #include <X11/extensions/Xext.h>
  #include <X11/extensions/extutil.h>
  
  #ifdef DEBUG
  #include <stdio.h>
  #endif
  
  #ifndef MODE_BAD
  #define MODE_BAD 255
  #endif
  
  static XExtensionInfo _xf86vidmode_info_data;
  static XExtensionInfo *xf86vidmode_info = &_xf86vidmode_info_data;
  static char *xf86vidmode_extension_name = XF86VIDMODENAME;
  
  #define XF86VidModeCheckExtension(dpy,i,val) \
    XextCheckExtension (dpy, i, xf86vidmode_extension_name, val)
  
  /*****************************************************************************
   *                                                                           *
   *			   private utility routines                          *
   *                                                                           *
   *****************************************************************************/
  
  static XEXT_CLOSE_DISPLAY_PROTO(close_display);
  static /* const */ XExtensionHooks xf86vidmode_extension_hooks = {
      NULL,				/* create_gc */
      NULL,				/* copy_gc */
      NULL,				/* flush_gc */
      NULL,				/* free_gc */
      NULL,				/* create_font */
      NULL,				/* free_font */
      close_display,			/* close_display */
      NULL,				/* wire_to_event */
      NULL,				/* event_to_wire */
      NULL,				/* error */
      NULL,				/* error_string */
  };
  
  static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info, 
  				   xf86vidmode_extension_name, 
  				   &xf86vidmode_extension_hooks, 
  				   0, NULL)
  
  static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info)
  
  
  /*****************************************************************************
   *                                                                           *
   *		    public XFree86-VidMode Extension routines                *
   *                                                                           *
   *****************************************************************************/
  
  Bool
  XF86VidModeQueryExtension (dpy, event_basep, error_basep)
      Display *dpy;
      int *event_basep, *error_basep;
  {
      XExtDisplayInfo *info = find_display (dpy);
  
      if (XextHasExtension(info)) {
  	*event_basep = info->codes->first_event;
  	*error_basep = info->codes->first_error;
  	return True;
      } else {
  	return False;
      }
  }
  
  Bool
  XF86VidModeQueryVersion(dpy, majorVersion, minorVersion)
      Display* dpy;
      int* majorVersion; 
      int* minorVersion;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeQueryVersionReply rep;
      xXF86VidModeQueryVersionReq *req;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeQueryVersion, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeQueryVersion;
      if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  	UnlockDisplay(dpy);
  	SyncHandle();
  	return False;
      }
      *majorVersion = rep.majorVersion;
      *minorVersion = rep.minorVersion;
      UnlockDisplay(dpy);
      SyncHandle();
      if (*majorVersion >= 2)
  	XF86VidModeSetClientVersion(dpy);
      return True;
  }
  
  Bool
  XF86VidModeSetClientVersion(Display *dpy)
  {
      XExtDisplayInfo *info = find_display(dpy);
      xXF86VidModeSetClientVersionReq *req;
  
      XF86VidModeCheckExtension(dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeSetClientVersion, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion;
      req->major = XF86VIDMODE_MAJOR_VERSION;
      req->minor = XF86VIDMODE_MINOR_VERSION;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeSetGamma(Display *dpy, int screen, XF86VidModeGamma *Gamma)
  {
      XExtDisplayInfo *info = find_display(dpy);
      xXF86VidModeSetGammaReq *req;
  
      XF86VidModeCheckExtension(dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeSetGamma, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeSetGamma;
      req->screen = screen;
      req->red = (CARD32)(Gamma->red * 10000.);
      req->green = (CARD32)(Gamma->green * 10000.);
      req->blue = (CARD32)(Gamma->blue * 10000.);
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeGetGamma(Display *dpy, int screen, XF86VidModeGamma *Gamma)
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetGammaReply rep;
      xXF86VidModeGetGammaReq *req;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeGetGamma, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetGamma;
      req->screen = screen;
      if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  	UnlockDisplay(dpy);
  	SyncHandle();
  	return False;
      }
      Gamma->red = ((float)rep.red) / 10000.;
      Gamma->green = ((float)rep.green) / 10000.;
      Gamma->blue = ((float)rep.blue) / 10000.;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeGetModeLine(dpy, screen, dotclock, modeline)
      Display* dpy;
      int screen;
      int* dotclock; 
      XF86VidModeModeLine* modeline;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetModeLineReply rep;
      xXF86OldVidModeGetModeLineReply oldrep;
      xXF86VidModeGetModeLineReq *req;
      int majorVersion, minorVersion;
  
      XF86VidModeCheckExtension (dpy, info, False);
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeGetModeLine, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetModeLine;
      req->screen = screen;
      
      if (majorVersion < 2) {
  	if (!_XReply(dpy, (xReply *)&oldrep, 
              (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
  	    UnlockDisplay(dpy);
  	    SyncHandle();
  	    return False;
  	}
  	*dotclock = oldrep.dotclock;
  	modeline->hdisplay   = oldrep.hdisplay;
  	modeline->hsyncstart = oldrep.hsyncstart;
  	modeline->hsyncend   = oldrep.hsyncend;
  	modeline->htotal     = oldrep.htotal;
  	modeline->hskew      = 0;
  	modeline->vdisplay   = oldrep.vdisplay;
  	modeline->vsyncstart = oldrep.vsyncstart;
  	modeline->vsyncend   = oldrep.vsyncend;
  	modeline->vtotal     = oldrep.vtotal;
  	modeline->flags      = oldrep.flags;
  	modeline->privsize   = oldrep.privsize;
      } else {
  	if (!_XReply(dpy, (xReply *)&rep, 
              (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
  	    UnlockDisplay(dpy);
  	    SyncHandle();
  	    return False;
  	}
  	*dotclock = rep.dotclock;
  	modeline->hdisplay   = rep.hdisplay;
  	modeline->hsyncstart = rep.hsyncstart;
  	modeline->hsyncend   = rep.hsyncend;
  	modeline->htotal     = rep.htotal;
  	modeline->hskew      = rep.hskew;
  	modeline->vdisplay   = rep.vdisplay;
  	modeline->vsyncstart = rep.vsyncstart;
  	modeline->vsyncend   = rep.vsyncend;
  	modeline->vtotal     = rep.vtotal;
  	modeline->flags      = rep.flags;
  	modeline->privsize   = rep.privsize;
      }
      
      if (modeline->privsize > 0) {
  	if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) {
  	    _XEatData(dpy, (modeline->privsize) * sizeof(INT32));
  	    Xfree(modeline->private);
  	    return False;
  	}
  	_XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32));
      } else {
  	modeline->private = NULL;
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeGetAllModeLines(dpy, screen, modecount, modelinesPtr)
      Display* dpy;
      int screen;
      int* modecount; 
      XF86VidModeModeInfo ***modelinesPtr;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetAllModeLinesReply rep;
      xXF86VidModeGetAllModeLinesReq *req;
      XF86VidModeModeInfo *mdinfptr, **modelines;
      xXF86VidModeModeInfo xmdline;
      xXF86OldVidModeModeInfo oldxmdline;
      int i;
      int majorVersion, minorVersion;
      Bool protocolBug = False;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      /*
       * Note: There was a bug in the protocol implementation in versions
       * 0.x with x < 8 (the .private field wasn't being passed over the wire).
       * Check the server's version, and accept the old format if appropriate.
       */
  
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
      if (majorVersion == 0 && minorVersion < 8) {
  	protocolBug = True;
  #ifdef DEBUG
  	fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is"
  		"running an old version (%d.%d)\n", majorVersion,
  		minorVersion);
  #endif
      }
      
      LockDisplay(dpy);
      GetReq(XF86VidModeGetAllModeLines, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines;
      req->screen = screen;
      if (!_XReply(dpy, (xReply *)&rep, 
          (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) {
          UnlockDisplay(dpy);
  	SyncHandle();
  	return False;
      }
  
      *modecount = rep.modecount;
  
      if (!(modelines = (XF86VidModeModeInfo **) Xcalloc(rep.modecount,
                                            sizeof(XF86VidModeModeInfo *)
                                            +sizeof(XF86VidModeModeInfo)))) {
  	if (majorVersion < 2)
              _XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo));
  	else
              _XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo));
          Xfree(modelines);
          return False;
      }
      mdinfptr = (XF86VidModeModeInfo *) (
  			    (char *) modelines
  			    + rep.modecount*sizeof(XF86VidModeModeInfo *)
  		    );
  
      for (i = 0; i < rep.modecount; i++) {
          modelines[i] = mdinfptr++;
  	if (majorVersion < 2) {
              _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo));
  	    modelines[i]->dotclock   = oldxmdline.dotclock;
  	    modelines[i]->hdisplay   = oldxmdline.hdisplay;
  	    modelines[i]->hsyncstart = oldxmdline.hsyncstart;
  	    modelines[i]->hsyncend   = oldxmdline.hsyncend;
  	    modelines[i]->htotal     = oldxmdline.htotal;
  	    modelines[i]->hskew      = 0;
  	    modelines[i]->vdisplay   = oldxmdline.vdisplay;
  	    modelines[i]->vsyncstart = oldxmdline.vsyncstart;
  	    modelines[i]->vsyncend   = oldxmdline.vsyncend;
  	    modelines[i]->vtotal     = oldxmdline.vtotal;
  	    modelines[i]->flags      = oldxmdline.flags;
  	    if (protocolBug) {
  		modelines[i]->privsize = 0;
  		modelines[i]->private = NULL;
  	    } else {
  		modelines[i]->privsize   = oldxmdline.privsize;
  		if (oldxmdline.privsize > 0) {
  	            if (!(modelines[i]->private =
  			    Xcalloc(oldxmdline.privsize, sizeof(INT32)))) {
  			_XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32));
  			Xfree(modelines[i]->private);
  		    } else {
  			_XRead(dpy, (char*)modelines[i]->private,
  			     oldxmdline.privsize * sizeof(INT32));
  		    }
  		} else {
  		  modelines[i]->private = NULL;
  		}
  	    }
  	} else {
              _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo));
  	    modelines[i]->dotclock   = xmdline.dotclock;
  	    modelines[i]->hdisplay   = xmdline.hdisplay;
  	    modelines[i]->hsyncstart = xmdline.hsyncstart;
  	    modelines[i]->hsyncend   = xmdline.hsyncend;
  	    modelines[i]->htotal     = xmdline.htotal;
  	    modelines[i]->hskew      = xmdline.hskew;
  	    modelines[i]->vdisplay   = xmdline.vdisplay;
  	    modelines[i]->vsyncstart = xmdline.vsyncstart;
  	    modelines[i]->vsyncend   = xmdline.vsyncend;
  	    modelines[i]->vtotal     = xmdline.vtotal;
  	    modelines[i]->flags      = xmdline.flags;
  	    if (protocolBug) {
  		modelines[i]->privsize = 0;
  		modelines[i]->private = NULL;
  	    } else {
  		modelines[i]->privsize   = xmdline.privsize;
  		if (xmdline.privsize > 0) {
  		    if (!(modelines[i]->private =
  			    Xcalloc(xmdline.privsize, sizeof(INT32)))) {
  			_XEatData(dpy, (xmdline.privsize) * sizeof(INT32));
  			Xfree(modelines[i]->private);
  		    } else {
  			_XRead(dpy, (char*)modelines[i]->private,
  			     xmdline.privsize * sizeof(INT32));
  		    }
  		} else {
  		    modelines[i]->private = NULL;
  		}
  	    }
  	}
      }
      *modelinesPtr = modelines;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  /*
   * GetReq replacement for use with VidMode protocols earlier than 2.0
   */
  #if !defined(UNIXCPP) || defined(ANSICPP)
  #define GetOldReq(name, oldname, req) \
          WORD64ALIGN\
  	if ((dpy->bufptr + SIZEOF(x##oldname##Req)) > dpy->bufmax)\
  		_XFlush(dpy);\
  	req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);\
  	req->reqType = X_##name;\
  	req->length = (SIZEOF(x##oldname##Req))>>2;\
  	dpy->bufptr += SIZEOF(x##oldname##Req);\
  	dpy->request++
  
  #else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
  #define GetOldReq(name, oldname, req) \
          WORD64ALIGN\
  	if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\
  		_XFlush(dpy);\
  	req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\
  	req->reqType = X_/**/name;\
  	req->length = (SIZEOF(x/**/oldname/**/Req))>>2;\
  	dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\
  	dpy->request++
  #endif
  
  Bool
  XF86VidModeAddModeLine (dpy, screen, newmodeline, aftermodeline)
      Display *dpy;
      int screen;
      XF86VidModeModeInfo* newmodeline;
      XF86VidModeModeInfo* aftermodeline;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeAddModeLineReq *req;
      xXF86OldVidModeAddModeLineReq *oldreq;
      int majorVersion, minorVersion;
  
      XF86VidModeCheckExtension (dpy, info, False);
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
  
      LockDisplay(dpy);
      if (majorVersion < 2) {
  	GetOldReq(XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq);
  	oldreq->reqType = info->codes->major_opcode;
  	oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
  	oldreq->screen = screen;
  	oldreq->dotclock =	newmodeline->dotclock;
  	oldreq->hdisplay =	newmodeline->hdisplay;
  	oldreq->hsyncstart =	newmodeline->hsyncstart;
  	oldreq->hsyncend =	newmodeline->hsyncend;
  	oldreq->htotal =	newmodeline->htotal;
  	oldreq->vdisplay =	newmodeline->vdisplay;
  	oldreq->vsyncstart =	newmodeline->vsyncstart;
  	oldreq->vsyncend =	newmodeline->vsyncend;
  	oldreq->vtotal =	newmodeline->vtotal;
  	oldreq->flags =		newmodeline->flags;
  	oldreq->privsize =	newmodeline->privsize;
  	if (aftermodeline != NULL) {
  	    oldreq->after_dotclock =	aftermodeline->dotclock;
  	    oldreq->after_hdisplay =	aftermodeline->hdisplay;
  	    oldreq->after_hsyncstart =	aftermodeline->hsyncstart;
  	    oldreq->after_hsyncend =	aftermodeline->hsyncend;
  	    oldreq->after_htotal =	aftermodeline->htotal;
  	    oldreq->after_vdisplay =	aftermodeline->vdisplay;
  	    oldreq->after_vsyncstart =	aftermodeline->vsyncstart;
  	    oldreq->after_vsyncend =	aftermodeline->vsyncend;
  	    oldreq->after_vtotal =	aftermodeline->vtotal;
  	    oldreq->after_flags =	aftermodeline->flags;
  	} else {
  	    oldreq->after_dotclock =	0;
  	    oldreq->after_hdisplay =	0;
  	    oldreq->after_hsyncstart =	0;
  	    oldreq->after_hsyncend =	0;
  	    oldreq->after_htotal =	0;
  	    oldreq->after_vdisplay =	0;
  	    oldreq->after_vsyncstart =	0;
  	    oldreq->after_vsyncend =	0;
  	    oldreq->after_vtotal =	0;
  	    oldreq->after_flags =	0;
  	}
  	if (newmodeline->privsize) {
  	    oldreq->length += newmodeline->privsize;
  	    Data32(dpy, (long *) newmodeline->private,
  	       newmodeline->privsize * sizeof(INT32));
  	}
      } else {
  	GetReq(XF86VidModeAddModeLine, req);
  	req->reqType = info->codes->major_opcode;
  	req->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
  	req->screen = screen;
  	req->dotclock =		newmodeline->dotclock;
  	req->hdisplay =		newmodeline->hdisplay;
  	req->hsyncstart =	newmodeline->hsyncstart;
  	req->hsyncend =		newmodeline->hsyncend;
  	req->htotal =		newmodeline->htotal;
  	req->hskew =		newmodeline->hskew;
  	req->vdisplay =		newmodeline->vdisplay;
  	req->vsyncstart =	newmodeline->vsyncstart;
  	req->vsyncend =		newmodeline->vsyncend;
  	req->vtotal =		newmodeline->vtotal;
  	req->flags =		newmodeline->flags;
  	req->privsize =		newmodeline->privsize;
  	if (aftermodeline != NULL) {
  	    req->after_dotclock =	aftermodeline->dotclock;
  	    req->after_hdisplay =	aftermodeline->hdisplay;
  	    req->after_hsyncstart =	aftermodeline->hsyncstart;
  	    req->after_hsyncend =	aftermodeline->hsyncend;
  	    req->after_htotal =		aftermodeline->htotal;
  	    req->after_hskew =		aftermodeline->hskew;
  	    req->after_vdisplay =	aftermodeline->vdisplay;
  	    req->after_vsyncstart =	aftermodeline->vsyncstart;
  	    req->after_vsyncend =	aftermodeline->vsyncend;
  	    req->after_vtotal =		aftermodeline->vtotal;
  	    req->after_flags =		aftermodeline->flags;
  	} else {
  	    req->after_dotclock =	0;
  	    req->after_hdisplay =	0;
  	    req->after_hsyncstart =	0;
  	    req->after_hsyncend =	0;
  	    req->after_htotal =		0;
  	    req->after_hskew =		0;
  	    req->after_vdisplay =	0;
  	    req->after_vsyncstart =	0;
  	    req->after_vsyncend =	0;
  	    req->after_vtotal =		0;
  	    req->after_flags =		0;
  	}
  	if (newmodeline->privsize) {
  	    req->length += newmodeline->privsize;
  	    Data32(dpy, (long *) newmodeline->private,
  	       newmodeline->privsize * sizeof(INT32));
  	}
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeDeleteModeLine (dpy, screen, modeline)
      Display *dpy;
      int screen;
      XF86VidModeModeInfo* modeline;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeDeleteModeLineReq *req;
      xXF86OldVidModeDeleteModeLineReq *oldreq;
      int majorVersion, minorVersion;
  
      XF86VidModeCheckExtension (dpy, info, 0);
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
  
      LockDisplay(dpy);
      if (majorVersion < 2) {
  	GetOldReq(XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine, oldreq);
  	oldreq->reqType = info->codes->major_opcode;
  	oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
  	oldreq->screen = screen;
  	oldreq->dotclock =	modeline->dotclock;
  	oldreq->hdisplay =	modeline->hdisplay;
  	oldreq->hsyncstart =	modeline->hsyncstart;
  	oldreq->hsyncend =	modeline->hsyncend;
  	oldreq->htotal =	modeline->htotal;
  	oldreq->vdisplay =	modeline->vdisplay;
  	oldreq->vsyncstart =	modeline->vsyncstart;
  	oldreq->vsyncend =	modeline->vsyncend;
  	oldreq->vtotal =	modeline->vtotal;
  	oldreq->flags =		modeline->flags;
  	oldreq->privsize =	modeline->privsize;
  	if (modeline->privsize) {
  	    oldreq->length += modeline->privsize;
  	    Data32(dpy, (long *) modeline->private,
  	       modeline->privsize * sizeof(INT32));
  	}
      } else {
  	GetReq(XF86VidModeDeleteModeLine, req);
  	req->reqType = info->codes->major_opcode;
  	req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
  	req->screen = screen;
  	req->dotclock =		modeline->dotclock;
  	req->hdisplay =		modeline->hdisplay;
  	req->hsyncstart =	modeline->hsyncstart;
  	req->hsyncend =		modeline->hsyncend;
  	req->htotal =		modeline->htotal;
  	req->hskew =		modeline->hskew;
  	req->vdisplay =		modeline->vdisplay;
  	req->vsyncstart =	modeline->vsyncstart;
  	req->vsyncend =		modeline->vsyncend;
  	req->vtotal =		modeline->vtotal;
  	req->flags =		modeline->flags;
  	req->privsize =		modeline->privsize;
  	if (modeline->privsize) {
  	    req->length += modeline->privsize;
  	    Data32(dpy, (long *) modeline->private,
  	       modeline->privsize * sizeof(INT32));
  	}
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeModModeLine (dpy, screen, modeline)
      Display *dpy;
      int screen;
      XF86VidModeModeLine* modeline;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeModModeLineReq *req;
      xXF86OldVidModeModModeLineReq *oldreq;
      int majorVersion, minorVersion;
  
      XF86VidModeCheckExtension (dpy, info, 0);
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
  
      LockDisplay(dpy);
      if (majorVersion < 2) {
  	GetOldReq(XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq);
  	oldreq->reqType = info->codes->major_opcode;
  	oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine;
  	oldreq->screen = screen;
  	oldreq->hdisplay =	modeline->hdisplay;
  	oldreq->hsyncstart =	modeline->hsyncstart;
  	oldreq->hsyncend =	modeline->hsyncend;
  	oldreq->htotal =	modeline->htotal;
  	oldreq->vdisplay =	modeline->vdisplay;
  	oldreq->vsyncstart =	modeline->vsyncstart;
  	oldreq->vsyncend =	modeline->vsyncend;
  	oldreq->vtotal =	modeline->vtotal;
  	oldreq->flags =		modeline->flags;
  	oldreq->privsize =	modeline->privsize;
  	if (modeline->privsize) {
  	    oldreq->length += modeline->privsize;
  	    Data32(dpy, (long *) modeline->private,
  	       modeline->privsize * sizeof(INT32));
  	}
      } else {
  	GetReq(XF86VidModeModModeLine, req);
  	req->reqType = info->codes->major_opcode;
  	req->xf86vidmodeReqType = X_XF86VidModeModModeLine;
  	req->screen = screen;
  	req->hdisplay =		modeline->hdisplay;
  	req->hsyncstart =	modeline->hsyncstart;
  	req->hsyncend =		modeline->hsyncend;
  	req->htotal =		modeline->htotal;
  	req->hskew =		modeline->hskew;
  	req->vdisplay =		modeline->vdisplay;
  	req->vsyncstart =	modeline->vsyncstart;
  	req->vsyncend =		modeline->vsyncend;
  	req->vtotal =		modeline->vtotal;
  	req->flags =		modeline->flags;
  	req->privsize =		modeline->privsize;
  	if (modeline->privsize) {
  	    req->length += modeline->privsize;
  	    Data32(dpy, (long *) modeline->private,
  	       modeline->privsize * sizeof(INT32));
  	}
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Status
  XF86VidModeValidateModeLine (dpy, screen, modeline)
      Display *dpy;
      int screen;
      XF86VidModeModeInfo* modeline;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeValidateModeLineReq *req;
      xXF86OldVidModeValidateModeLineReq *oldreq;
      xXF86VidModeValidateModeLineReply rep;
      int majorVersion, minorVersion;
  
      XF86VidModeCheckExtension (dpy, info, 0);
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
  
      LockDisplay(dpy);
  
      if (majorVersion < 2) {
  	GetOldReq(XF86VidModeValidateModeLine, XF86OldVidModeValidateModeLine, oldreq);
  	oldreq->reqType = info->codes->major_opcode;
  	oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
  	oldreq->screen = screen;
  	oldreq->dotclock =	modeline->dotclock;
  	oldreq->hdisplay =	modeline->hdisplay;
  	oldreq->hsyncstart =	modeline->hsyncstart;
  	oldreq->hsyncend =	modeline->hsyncend;
  	oldreq->htotal =	modeline->htotal;
  	oldreq->vdisplay =	modeline->vdisplay;
  	oldreq->vsyncstart =	modeline->vsyncstart;
  	oldreq->vsyncend =	modeline->vsyncend;
  	oldreq->vtotal =	modeline->vtotal;
  	oldreq->flags =		modeline->flags;
  	oldreq->privsize =	modeline->privsize;
  	if (modeline->privsize) {
  	    oldreq->length += modeline->privsize;
  	    Data32(dpy, (long *) modeline->private,
  	       modeline->privsize * sizeof(INT32));
  	}
      } else {
  	GetReq(XF86VidModeValidateModeLine, req);
  	req->reqType = info->codes->major_opcode;
  	req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
  	req->screen = screen;
  	req->dotclock =		modeline->dotclock;
  	req->hdisplay =		modeline->hdisplay;
  	req->hsyncstart =	modeline->hsyncstart;
  	req->hsyncend =		modeline->hsyncend;
  	req->htotal =		modeline->htotal;
  	req->hskew =		modeline->hskew;
  	req->vdisplay =		modeline->vdisplay;
  	req->vsyncstart =	modeline->vsyncstart;
  	req->vsyncend =		modeline->vsyncend;
  	req->vtotal =		modeline->vtotal;
  	req->flags =		modeline->flags;
  	req->privsize =		modeline->privsize;
  	if (modeline->privsize) {
  	    req->length += modeline->privsize;
  	    Data32(dpy, (long *) modeline->private,
  	       modeline->privsize * sizeof(INT32));
  	}
      }
      if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  	UnlockDisplay(dpy);
  	SyncHandle();
  	return MODE_BAD;
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return rep.status;
  }
  
  Bool
  XF86VidModeSwitchMode(dpy, screen, zoom)
      Display* dpy;
      int screen;
      int zoom;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeSwitchModeReq *req;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeSwitchMode, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeSwitchMode;
      req->screen = screen;
      req->zoom = zoom;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
      
  Bool
  XF86VidModeSwitchToMode(dpy, screen, modeline)
      Display* dpy;
      int screen;
      XF86VidModeModeInfo* modeline;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeSwitchToModeReq *req;
      xXF86OldVidModeSwitchToModeReq *oldreq;
      int majorVersion, minorVersion;
      Bool protocolBug = False;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      /*
       * Note: There was a bug in the protocol implementation in versions
       * 0.x with x < 8 (the .private field wasn't expected to be sent over
       * the wire).  Check the server's version, and accept the old format
       * if appropriate.
       */
  
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
      if (majorVersion == 0 && minorVersion < 8) {
  	protocolBug = True;
  #ifdef DEBUG
  	fprintf(stderr, "XF86VidModeSwitchToMode: Warning: Xserver is"
  		"running an old version (%d.%d)\n", majorVersion,
  		minorVersion);
  #endif
      }
      
      LockDisplay(dpy);
      if (majorVersion < 2) {
  	GetOldReq(XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode, oldreq);
  	oldreq->reqType = info->codes->major_opcode;
  	oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
  	oldreq->screen = screen;
  	oldreq->dotclock =	modeline->dotclock;
  	oldreq->hdisplay =	modeline->hdisplay;
  	oldreq->hsyncstart =	modeline->hsyncstart;
  	oldreq->hsyncend =	modeline->hsyncend;
  	oldreq->htotal =	modeline->htotal;
  	oldreq->vdisplay =	modeline->vdisplay;
  	oldreq->vsyncstart =	modeline->vsyncstart;
  	oldreq->vsyncend =	modeline->vsyncend;
  	oldreq->vtotal =	modeline->vtotal;
  	oldreq->flags =	modeline->flags;
  	if (protocolBug) {
  	    oldreq->privsize = 0;
  	} else {
  	    oldreq->privsize =	modeline->privsize;
  	    if (modeline->privsize) {
  		oldreq->length += modeline->privsize;
  		Data32(dpy, (long *) modeline->private,
  	           modeline->privsize * sizeof(INT32));
  	    }
  	}
      } else {
  	GetReq(XF86VidModeSwitchToMode, req);
  	req->reqType = info->codes->major_opcode;
  	req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
  	req->screen = screen;
  	req->dotclock =	modeline->dotclock;
  	req->hdisplay =	modeline->hdisplay;
  	req->hsyncstart =	modeline->hsyncstart;
  	req->hsyncend =	modeline->hsyncend;
  	req->htotal =	modeline->htotal;
  	req->hskew =	modeline->hskew;
  	req->vdisplay =	modeline->vdisplay;
  	req->vsyncstart =	modeline->vsyncstart;
  	req->vsyncend =	modeline->vsyncend;
  	req->vtotal =	modeline->vtotal;
  	req->flags =	modeline->flags;
  	if (protocolBug) {
  	    req->privsize = 0;
  	} else {
  	    req->privsize =	modeline->privsize;
  	    if (modeline->privsize) {
  		req->length += modeline->privsize;
  		Data32(dpy, (long *) modeline->private,
  	           modeline->privsize * sizeof(INT32));
  	    }
  	}
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
      
  Bool
  XF86VidModeLockModeSwitch(dpy, screen, lock)
      Display* dpy;
      int screen;
      int lock;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeLockModeSwitchReq *req;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeLockModeSwitch, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch;
      req->screen = screen;
      req->lock = lock;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
      
  Bool
  XF86VidModeGetMonitor(dpy, screen, monitor)
      Display* dpy;
      int screen;
      XF86VidModeMonitor* monitor;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetMonitorReply rep;
      xXF86VidModeGetMonitorReq *req;
      CARD32 syncrange;
      int i;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeGetMonitor, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetMonitor;
      req->screen = screen;
      if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  	UnlockDisplay(dpy);
  	SyncHandle();
  	return False;
      }
      monitor->nhsync = rep.nhsync;
      monitor->nvsync = rep.nvsync;
  #if 0
      monitor->bandwidth = (float)rep.bandwidth / 1e6;
  #endif
      if (rep.vendorLength) {
  	if (!(monitor->vendor = (char *)Xcalloc(rep.vendorLength + 1, 1))) {
  	    _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  		      ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  	    return False;
  	}
      } else {
  	monitor->vendor = NULL;
      }
      if (rep.modelLength) {
  	if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) {
  	    _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  		      ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  	    if (monitor->vendor)
  		Xfree(monitor->vendor);
  	    return False;
  	}
      } else {
  	monitor->model = NULL;
      }
      if (!(monitor->hsync = Xcalloc(rep.nhsync, sizeof(XF86VidModeSyncRange)))) {
  	_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  		  ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  	
  	if (monitor->vendor)
  	    Xfree(monitor->vendor);
  	if (monitor->model)
  	    Xfree(monitor->model);
  	return False;
      }
      if (!(monitor->vsync = Xcalloc(rep.nvsync, sizeof(XF86VidModeSyncRange)))) {
  	_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  		  ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  	if (monitor->vendor)
  	    Xfree(monitor->vendor);
  	if (monitor->model)
  	    Xfree(monitor->model);
  	Xfree(monitor->hsync);
  	return False;
      }
      for (i = 0; i < rep.nhsync; i++) {
  	_XRead(dpy, (char *)&syncrange, 4);
  	monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
  	monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0;
      }
      for (i = 0; i < rep.nvsync; i++) {
  	_XRead(dpy, (char *)&syncrange, 4);
  	monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
  	monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0;
      }
      if (rep.vendorLength)
  	_XReadPad(dpy, monitor->vendor, rep.vendorLength);
      if (rep.modelLength)
  	_XReadPad(dpy, monitor->model, rep.modelLength);
  	
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeGetViewPort(dpy, screen, x, y)
      Display* dpy;
      int screen;
      int *x, *y;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetViewPortReply rep;
      xXF86VidModeGetViewPortReq *req;
      int majorVersion, minorVersion;
      Bool protocolBug = False;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      /*
       * Note: There was a bug in the protocol implementation in versions
       * 0.x with x < 8 (no reply was sent, so the client would hang)
       * Check the server's version, and don't wait for a reply with older
       * versions.
       */
  
      XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
      if (majorVersion == 0 && minorVersion < 8) {
  	protocolBug = True;
  #ifdef DEBUG
  	fprintf(stderr, "XF86VidModeGetViewPort: Warning: Xserver is"
  		"running an old version (%d.%d)\n", majorVersion,
  		minorVersion);
  #endif
      }
      LockDisplay(dpy);
      GetReq(XF86VidModeGetViewPort, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetViewPort;
      req->screen = screen;
      if (protocolBug) {
  	*x = 0;
  	*y = 0;
      } else {
  	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  	    UnlockDisplay(dpy);
  	    SyncHandle();
  	    return False;
  	}
  	*x = rep.x;
  	*y = rep.y;
      }
  
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeSetViewPort(dpy, screen, x, y)
      Display* dpy;
      int screen;
      int x, y;
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeSetViewPortReq *req;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeSetViewPort, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeSetViewPort;
      req->screen = screen;
      req->x = x;
      req->y = y;
  
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeGetDotClocks(dpy, screen,
  	    flagsPtr, numclocksPtr, maxclocksPtr, clocksPtr)
      Display* dpy;
      int screen;
      int *flagsPtr, *numclocksPtr, *maxclocksPtr, *clocksPtr[]; 
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetDotClocksReply rep;
      xXF86VidModeGetDotClocksReq *req;
      int i, *dotclocks;
      CARD32 dotclk;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeGetDotClocks, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks;
      req->screen = screen;
      if (!_XReply(dpy, (xReply *)&rep, 
          (SIZEOF(xXF86VidModeGetDotClocksReply) - SIZEOF(xReply)) >> 2, xFalse))
      {
          UnlockDisplay(dpy);
          SyncHandle();
          return False;
      }
      *numclocksPtr = rep.clocks;
      *maxclocksPtr = rep.maxclocks;
      *flagsPtr     = rep.flags;
  
      if (!(dotclocks = (int*) Xcalloc(rep.clocks, sizeof(int)))) {
          _XEatData(dpy, (rep.clocks) * 4);
          Xfree(dotclocks);
          return False;
      }
  
      for (i = 0; i < rep.clocks; i++) {
          _XRead(dpy, (char*)&dotclk, 4);
  	dotclocks[i] = dotclk;
      }
      *clocksPtr = dotclocks;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool
  XF86VidModeSetGammaRamp (
      Display *dpy,
      int screen,
      int size,
      unsigned short *red,
      unsigned short *green,
      unsigned short *blue
  )
  {
      int length = (size + 1) & ~1;
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeSetGammaRampReq *req;
  
      XF86VidModeCheckExtension (dpy, info, False);
      LockDisplay(dpy);
      GetReq(XF86VidModeSetGammaRamp, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp;
      req->screen = screen;
      req->length += (length >> 1) * 3;
      req->size = size;
      _XSend(dpy, (char*)red, size * 2);
      _XSend(dpy, (char*)green, size * 2);
      _XSend(dpy, (char*)blue, size * 2);
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  
  Bool
  XF86VidModeGetGammaRamp (
      Display *dpy,
      int screen,
      int size,
      unsigned short *red,
      unsigned short *green,
      unsigned short *blue
  )
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetGammaRampReq *req;
      xXF86VidModeGetGammaRampReply rep;
    
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeGetGammaRamp, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp;
      req->screen = screen;
      req->size = size;
      if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      if(rep.size) {
  	_XRead(dpy, (char*)red, rep.size << 1);
  	_XRead(dpy, (char*)green, rep.size << 1);
  	_XRead(dpy, (char*)blue, rep.size << 1);
      }
  
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool XF86VidModeGetGammaRampSize(
      Display *dpy,
      int screen,
      int *size
  )
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetGammaRampSizeReq *req;
      xXF86VidModeGetGammaRampSizeReply rep;
    
      *size = 0;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeGetGammaRampSize, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize;
      req->screen = screen;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False; 
      }
      *size = rep.size;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }
  
  Bool XF86VidModeGetPermissions(
      Display *dpy,
      int screen,
      int *permissions
  )
  {
      XExtDisplayInfo *info = find_display (dpy);
      xXF86VidModeGetPermissionsReq *req;
      xXF86VidModeGetPermissionsReply rep;
    
      *permissions = 0;
  
      XF86VidModeCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(XF86VidModeGetPermissions, req);
      req->reqType = info->codes->major_opcode;
      req->xf86vidmodeReqType = X_XF86VidModeGetPermissions;
      req->screen = screen;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False; 
      }
      *permissions = rep.permissions;
      UnlockDisplay(dpy);
      SyncHandle();
      return True;
  }