Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 1233 insertions, 0 deletions

diff --git a/nx-X11/lib/Xxf86vm/XF86VMode.c b/nx-X11/lib/Xxf86vm/XF86VMode.c
new file mode 100644
index 000000000..75a49d2ba
--- /dev/null
+++ b/nx-X11/lib/Xxf86vm/XF86VMode.c
@@ -0,0 +1,1233 @@
+/* $XConsortium: XF86VMode.c /main/2 1995/11/14 18:17:58 kaleb $ */
+/* $XFree86: xc/lib/Xxf86vm/XF86VMode.c,v 3.33 2002/10/16 00:37:34 dawes Exp $ */
+/*
+
+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.
+
+*/
+/* $XConsortium: XF86VMode.c /main/4 1996/01/16 07:52:25 kaleb CHECKEDOUT $ */
+
+/* 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);
+    else
+	monitor->vendor = "";
+    if (rep.modelLength)
+	_XReadPad(dpy, monitor->model, rep.modelLength);
+    else
+	monitor->model = "";
+	
+    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;
+}
+