#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)
static XEXT_CLOSE_DISPLAY_PROTO(close_display);
static XExtensionHooks xf86vidmode_extension_hooks = {
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
close_display,
NULL,
NULL,
NULL,
NULL,
};
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)
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);
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;
}
#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
#define GetOldReq(name, oldname, req) \
WORD64ALIGN\
if ((dpy->bufptr + SIZEOF(xoldnameReq)) > dpy->bufmax)\
_XFlush(dpy);\
req = (xoldnameReq *)(dpy->last_req = dpy->bufptr);\
req->reqType = X_name;\
req->length = (SIZEOF(xoldnameReq))>>2;\
dpy->bufptr += SIZEOF(xoldnameReq);\
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);
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);
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;
}