From f4092abdf94af6a99aff944d6264bc1284e8bdd4 Mon Sep 17 00:00:00 2001 From: Reinhard Tartler Date: Mon, 10 Oct 2011 17:43:39 +0200 Subject: Imported nx-X11-3.1.0-1.tar.gz Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository --- nx-X11/lib/Xxf86vm/Imakefile | 40 ++ nx-X11/lib/Xxf86vm/XF86VM.man | 425 +++++++++++++ nx-X11/lib/Xxf86vm/XF86VMode.c | 1233 ++++++++++++++++++++++++++++++++++++ nx-X11/lib/Xxf86vm/Xxf86vm-def.cpp | 16 + 4 files changed, 1714 insertions(+) create mode 100644 nx-X11/lib/Xxf86vm/Imakefile create mode 100644 nx-X11/lib/Xxf86vm/XF86VM.man create mode 100644 nx-X11/lib/Xxf86vm/XF86VMode.c create mode 100644 nx-X11/lib/Xxf86vm/Xxf86vm-def.cpp (limited to 'nx-X11/lib/Xxf86vm') diff --git a/nx-X11/lib/Xxf86vm/Imakefile b/nx-X11/lib/Xxf86vm/Imakefile new file mode 100644 index 000000000..84a29eb1d --- /dev/null +++ b/nx-X11/lib/Xxf86vm/Imakefile @@ -0,0 +1,40 @@ +XCOMM $XFree86: xc/lib/Xxf86vm/Imakefile,v 3.3 2002/10/16 00:37:34 dawes Exp $ +XCOMM $XdotOrg: xc/lib/Xxf86vm/Imakefile,v 1.3 2005/05/14 18:35:56 alanc Exp $ + +#define DoNormalLib NormalLibXxf86vm +#define DoSharedLib SharedLibXxf86vm +#define DoExtraLib SharedLibXxf86vm +#define DoDebugLib DebugLibXxf86vm +#define DoProfileLib ProfileLibXxf86vm +#define LibName Xxf86vm +#define SoRev SOXXF86VMREV +#define LibHeaders NO + +#include + +#ifdef SharedXxf86vmReqs +REQUIREDLIBS = SharedXxf86vmReqs +#endif + +VIDMODESRCS = XF86VMode.c +VIDMODEOBJS = XF86VMode.o + +#if Malloc0ReturnsNull +ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL +#endif + + DEFINES = $(ALLOC_DEFINES) + SRCS = $(VIDMODESRCS) + OBJS = $(VIDMODEOBJS) + LINTLIBS = $(LINTXLIB) + +#define IncludeSharedObjectInNormalLib + +#include + +InstallGenManPageLong(XF86VM,$(LIBMANDIR),XF86VidMode,$(LIBMANSUFFIX)) +#if ExpandManNames +InstallGenManPageAliases(XF86VidMode,$(LIBMANDIR),$(LIBMANSUFFIX),XF86VidModeQueryExtension XF86VidModeQueryVersion XF86VidModeGetModeLine XF86VidModeGetAllModeLines XF86VidModeDeleteModeLine XF86VidModeModModeLine XF86VidModeSwitchMode XF86VidModeSwitchToMode XF86VidModeLockModeSwitch XF86VidModeGetMonitor XF86VidModeGetViewPort XF86VidModeSetViewPort XF86VidModeValidateModeLine XF86VidModeSetClientVersion XF86VidModeGetDotClocks XF86VidModeGetGamma XF86VidModeSetGamma XF86VidModeSetGammaRamp XF86VidModeGetGammaRamp XF86VidModeGetGammaRampSize XF86VidModeGetPermissions) +#endif + +DependTarget() diff --git a/nx-X11/lib/Xxf86vm/XF86VM.man b/nx-X11/lib/Xxf86vm/XF86VM.man new file mode 100644 index 000000000..6e53ad158 --- /dev/null +++ b/nx-X11/lib/Xxf86vm/XF86VM.man @@ -0,0 +1,425 @@ +.\" $XdotOrg: xc/lib/Xxf86vm/XF86VM.man,v 1.2 2004/04/23 19:23:08 eich Exp $ +.\" $TOG: XF86VM.man /main/6 1997/07/19 10:30:39 kaleb $ +.\" +.\" +.\" +.\" +.\" Copyright (c) 1996 Joe Moss, The XFree86 Project +.\" $XFree86: xc/programs/Xserver/hw/xfree86/doc/man/XF86VM.man,v 3.14 2003/10/02 13:29:56 eich Exp $ +.\" +.de ZN +.ie t \fB\^\\$1\^\fR\\$2 +.el \fI\^\\$1\^\fP\\$2 +.. +.TH XF86VIDMODE __libmansuffix__ __vendorversion__ +.SH NAME +XF86VidModeQueryExtension, XF86VidModeQueryVersion, XF86VidModeSetClientVersion, XF86VidModeGetModeLine, XF86VidModeGetAllModeLines, XF86VidModeDeleteModeLine, XF86VidModeModModeLine, XF86VidModeValidateModeLine, XF86VidModeSwitchMode, XF86VidModeSwitchToMode, XF86VidModeLockModeSwitch, XF86VidModeGetMonitor, XF86VidModeGetViewPort, XF86VidModeSetViewPort, XF86VidModeGetDotClocks, XF86VidModeGetGamma, XF86VidModeSetGamma, XF86VidModeGetGammaRamp, XF86VidModeSetGammaRamp, XF86VidModeGetGammaRampSize, XF86VidModeGetPermissions \- Extension libary for the XFree86-VidMode X extension +.SH SYNTAX +.nf +.LP +\&#include +.LP +Bool XF86VidModeQueryExtension( + Display *\fIdisplay\fP\^, + int *\fIevent_base_return\fP\^, + int *\fIerror_base_return\fP\^); +.LP +Bool XF86VidModeQueryVersion( + Display *\fIdisplay\fP\^, + int *\fImajor_version_return\fP\^, + int *\fIminor_version_return\fP\^); +.LP +Bool XF86VidModeSetClientVersion( + Display *\fIdisplay\fP\^); +.LP +Bool XF86VidModeGetModeLine( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int *\fIdotclock_return\fP\^, + XF86VidModeModeLine *\fImodeline\fP\^); +.LP +Bool XF86VidModeGetAllModeLines( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int *\fImodecount_return\fP\^, + XF86VidModeModeInfo ***\fImodesinfo\fP\^); +.ig +.LP +Bool XF86VidModeAddModeLine( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeModeInfo *\fImodeline\fP\, + XF86VidModeModeInfo *\fIaftermode\fP\^); +.. +.LP +Bool XF86VidModeDeleteModeLine( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeModeInfo *\fImodeline\fP\^); +.LP +Bool XF86VidModeModModeLine( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeModeLine *\fImodeline\fP\^); +.LP +Status XF86VidModeValidateModeLine( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeModeLine *\fImodeline\fP\^); +.LP +Bool XF86VidModeSwitchMode( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int \fIzoom\fP\^); +.LP +Bool XF86VidModeSwitchToMode( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeModeInfo *\fImodeline\fP\^); +.LP +Bool XF86VidModeLockModeSwitch( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int \fIlock\fP\^); +.LP +Bool XF86VidModeGetMonitor( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeMonitor *\fImonitor\fP\^); +.LP +Bool XF86VidModeGetViewPort( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int *\fIx_return\fP\^, + int *\fIy_return\fP\^); +.LP +Bool XF86VidModeSetViewPort( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int \fIx\fP\^, + int \fIy\fP\^); +.LP +XF86VidModeGetDotClocks( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int *\fIflags return\fP\^, + int *\fInumber of clocks return\fP\^, + int *\fImax dot clock return\fP\^, + int **\fIclocks return\fP\^); +.LP +XF86VidModeGetGamma( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeGamma *\fIGamma\fP\^); +.LP +XF86VidModeSetGamma( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + XF86VidModeGamma *\fIGamma\fP\^); +.LP +XF86VidModeGetGammaRamp( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int \fIsize\fP\^, + unsigned short *\fIred array\fP\^, + unsigned short *\fIgreen array\fP\^, + unsigned short *\fIblue array\fP\^); +.LP +XF86VidModeSetGammaRamp( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int \fIsize\fP\^, + unsigned short *\fIred array\fP\^, + unsigned short *\fIgreen array\fP\^, + unsigned short *\fIblue array\fP\^); +.LP +XF86VidModeGetGammaRampSize( + Display *\fIdisplay\fP\^, + int \fIscreen\fP\^, + int *\fIsize\fP\^); +.fi +.SH ARGUMENTS +.IP \fIdisplay\fP 2i +Specifies the connection to the X server. +.IP \fIscreen\fP 2i +Specifies which screen number the setting apply to. +.IP \fIevent_base_return\fP 2i +Returns the base event number for the extension. +.IP \fIerror_base_return\fP 2i +Returns the base error number for the extension. +.IP \fImajor_version_return\fP 2i +Returns the major version number of the extension. +.IP \fIminor_version_return\fP 2i +Returns the minor version number of the extension. +.IP \fIdotclock_return\fP 2i +Returns the clock for the mode line. +.IP \fImodecount_return\fP 2i +Returns the number of video modes available in the server. +.IP \fIzoom\fP 2i +If greater than zero, indicates that the server should switch to +the next mode, otherwise switch to the previous mode. +.IP \fIlock\fP 2i +Indicates that mode switching should be locked, if non-zero. +.IP \fImodeline\fP 2i +Specifies or returns the timing values for a video mode. +.ig +.IP \fIaftermode\fP 2i +Specifies the timing values for the video mode after which the +new mode will added. +.. +.IP \fImodesinfo\fP 2i +Returns the timing values and dotclocks for all of the available +video modes. +.IP \fImonitor\fP 2i +Returns information about the monitor. +.IP \fIx\fP 2i +Specifies the desired X location for the viewport. +.IP \fIx_return\fP 2i +Returns the current X location of the viewport. +.IP \fIy\fP 2i +Specifies the desired Y location for the viewport. +.IP \fIy_return\fP 2i +Returns the current Y location of the viewport. +.SH STRUCTURES +.nf +.ta 2.25i 3.5i +\fIVideo Mode Settings:\fP +typedef struct { + unsigned short hdisplay; /\(** Number of display pixels horizontally */ + unsigned short hsyncstart; /\(** Horizontal sync start */ + unsigned short hsyncend; /\(** Horizontal sync end */ + unsigned short htotal; /\(** Total horizontal pixels */ + unsigned short vdisplay; /\(** Number of display pixels vertically */ + unsigned short vsyncstart; /\(** Vertical sync start */ + unsigned short vsyncend; /\(** Vertical sync start */ + unsigned short vtotal; /\(** Total vertical pixels */ + unsigned int flags; /\(** Mode flags */ + int privsize; /\(** Size of private */ + INT32 *private; /\(** Server privates */ +} XF86VidModeModeLine; +.sp +typedef struct { + unsigned int dotclock; /\(** Pixel clock */ + unsigned short hdisplay; /\(** Number of display pixels horizontally */ + unsigned short hsyncstart; /\(** Horizontal sync start */ + unsigned short hsyncend; /\(** Horizontal sync end */ + unsigned short htotal; /\(** Total horizontal pixels */ + unsigned short vdisplay; /\(** Number of display pixels vertically */ + unsigned short vsyncstart; /\(** Vertical sync start */ + unsigned short vsyncend; /\(** Vertical sync start */ + unsigned short vtotal; /\(** Total vertical pixels */ + unsigned int flags; /\(** Mode flags */ + int privsize; /\(** Size of private */ + INT32 *private; /\(** Server privates */ +} XF86VidModeModeInfo; +.LP +\fIMonitor information:\fP +typedef struct { + char* vendor; /\(** Name of manufacturer */ + char* model; /\(** Model name */ + float EMPTY; /\(** unused, for backward compatibility */ + unsigned char nhsync; /\(** Number of horiz sync ranges */ + XF86VidModeSyncRange* hsync; /\(** Horizontal sync ranges */ + unsigned char nvsync; /\(** Number of vert sync ranges */ + XF86VidModeSyncRange* vsync; /\(** Vertical sync ranges */ +} XF86VidModeMonitor; +.sp +typedef struct { + float hi; /\(** Top of range */ + float lo; /\(** Bottom of range */ +} XF86VidModeSyncRange; +.LP +typedef struct { + int type; /\(** of event */ + unsigned long serial; /\(** # of last request processed by server */ + Bool send_event; /\(** true if this came from a SendEvent req */ + Display *display; /\(** Display the event was read from */ + Window root; /\(** root window of event screen */ + int state; /\(** What happened */ + int kind; /\(** What happened */ + Bool forced; /\(** extents of new region */ + Time time; /\(** event timestamp */ +} XF86VidModeNotifyEvent; +.LP +typedef struct { + float red; /\(** Red Gamma value */ + float green; /\(** Green Gamma value */ + float blue; /\(** Blue Gamma value */ +} XF86VidModeGamma; +.fi +.SH DESCRIPTION +These functions provide an interface to the server extension +\fIXFree86-VidModeExtension\fP +which allows the video modes to be +queried and adjusted dynamically and mode switching to be controlled. +Applications that use these functions must be linked with +.ZN -lXxf86vm +.SS "MODELINE FUNCTIONS" +The +.ZN XF86VidModeGetModeLine +function is used to query the settings for the currently selected +video mode. The calling program should pass a pointer to a +.ZN XF86VidModeModeLine +structure that it has already allocated. The function fills in +the fields of the structure. +.PP +If there are any server private values (currently only applicable to +the S3 server) the function will allocate storage for them. +Therefore, if the +.ZN privsize +field is non-zero, the calling program should call +.ZN Xfree(private) +to free the storage. +.PP +.ZN XF86VidModeGetAllModeLines +returns the settings for all video modes. +The calling program supplies the address of a pointer which will be +set by the function to point to an array of +.ZN XF86VidModeModeInfo +structures. The memory occupied by the array is dynamically allocated +by the +.ZN XF86VidModeGetAllModeLines +function and should be freed by the caller. +The first element of the array corresponds to the current video mode. +.PP +The +.ZN XF86VidModeModModeLine +function can be used to change the settings of the current video mode +provided the requested settings are valid (e.g. they don't exceed the +capabilities of the monitor). +.PP +.ig +To add a mode to the list of available modes, the +.ZN XF86VidModeAddModeLine +function can be used. +Assuming the settings are valid, the video mode will be added after +the existing mode which matches the timings specified by the +.ZN aftermode +parameter. +To be considered a match, all of the fields of the given +.ZN XF86VidModeModeInfo +structure must match, except the +.ZN privsize +and +.ZN private +fields. +If the +.ZN aftermode +parameter is zero, the mode will be added +after the current mode. +.PP +.. +Modes can be deleted with the +.ZN XF86VidModeDeleteModeLine +function. The specified mode must match an existing mode. +To be considered a match, all of the fields of the given +.ZN XF86VidModeModeInfo +structure must match, except the +.ZN privsize +and +.ZN private +fields. +If the mode to be deleted is the current mode, a mode switch +to the next mode will occur first. The last remaining mode can not +be deleted. +.PP +The validity of a mode can be checked with the +.ZN XF86VidModeValidateModeLine +function. +If the specified mode can be used by the server (i.e. meets all the +constraints placed upon a mode by the combination of the server, card, +and monitor) the function returns +.ZN MODE_OK , +otherwise it returns a value indicating the reason why the mode is +invalid (as defined in \fIxf86.h\fP) +.SS "MODE SWITCH FUNCTIONS" +When the function +.ZN XF86VidModeSwitchMode +is called, the server will change the video mode to next (or previous) +video mode. The +.ZN XF86VidModeSwitchToMode +function can be used to switch directly to the specified mode. +Matching is as specified in the description of the +.ZN XF86VidModeAddModeLine +function above. +The +.ZN XF86VidModeLockModeSwitch +function can be used to allow or disallow mode switching whether +the request to switch modes comes from a call to the +.ZN XF86VidModeSwitchMode +or +.ZN XF86VidModeSwitchToMode +functions or from one of the mode switch key sequences. +.PP +.RB Note: +Because of the asynchronous nature of the X protocol, a call to +.ZN XFlush +is needed if the application wants to see the mode change immediately. +To be informed of the execution status of the request, a +custom error handler should be installed using +.ZN XSetErrorHandler +before calling the mode switching function. +.SS "MONITOR FUNCTIONS" +Information known to the server about the monitor is returned by the +.ZN XF86VidModeGetMonitor +function. The +.ZN hsync +and +.ZN vsync +fields each point to an array of +.ZN XF86VidModeSyncRange +structures. The arrays contain +.ZN nhsync +and +.ZN nvsync +elements, respectively. +The +.ZN hi +and +.ZN low +values will be equal if a discreate value was given in the +.ZN XF86Config +file. +.PP +The +.ZN vendor , +.ZN model , +.ZN hsync , +and +.ZN vsync +fields point to dynamically allocated storage that should be freed +by the caller. +.SS "VIEWPORT FUNCTIONS" +The +.ZN XF86VidModeGetViewPort +and +.ZN XF86VidModeSetViewPort +functions can be used to, respectively, query and change the location +of the upper left corner of the viewport into the virtual screen. +.SS "OTHER FUNCTIONS" +The +.ZN XF86VidModeQueryVersion +function can be used to determine the version of the extension +built into the server. +.PP +The function +.ZN XF86VidModeQueryExtension +returns the lowest numbered error and event values +assigned to the extension. +.SH BUGS +The +XF86VidModeSetClientVersion, +XF86VidModeGetDotClocks, +XF86VidModeGetGamma, +XF86VidModeSetGamma, +XF86VidModeSetGammaRamp, +XF86VidModeGetGammaRamp, +XF86VidModeGetGammaRampSize, +and +XF86VidModeGetPermissions +functions need to be documented. In the meantime, check the source +code for information about how to use them. +.SH SEE ALSO +__xservername__(__appmansuffix__), __xconfigfile__(__filemansuffix__), XFlush(__libmansuffix__), XSetErrorHandler(__libmansuffix__), xvidtune(__appmansuffix__) +.SH AUTHORS +Kaleb Keithley, Jon Tombs, David Dawes, and Joe Moss 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 +#include +#include +#include + +#ifdef DEBUG +#include +#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; +} + diff --git a/nx-X11/lib/Xxf86vm/Xxf86vm-def.cpp b/nx-X11/lib/Xxf86vm/Xxf86vm-def.cpp new file mode 100644 index 000000000..0f7b4f335 --- /dev/null +++ b/nx-X11/lib/Xxf86vm/Xxf86vm-def.cpp @@ -0,0 +1,16 @@ +LIBRARY XXF86VM +EXPORTS + XF86VidModeQueryExtension + XF86VidModeQueryVersion + XF86VidModeGetModeLine + XF86VidModeGetAllModeLines + XF86VidModeModModeLine + XF86VidModeSwitchMode + XF86VidModeLockModeSwitch + XF86VidModeGetMonitor + XF86VidModeGetGamma + XF86VidModeSetGamma + XF86VidModeSwitchToMode + XF86VidModeAddModeLine + +/* $XFree86$ */ -- cgit v1.2.3