diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/XF86VMode.c | 1233 |
1 files changed, 1233 insertions, 0 deletions
diff --git a/src/XF86VMode.c b/src/XF86VMode.c new file mode 100644 index 0000000..3259db4 --- /dev/null +++ b/src/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.34 2002/12/22 00:46:51 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; +} + |