Merge branch 'sunweaver-pr/libXx86FOO-cleanup' into arctica-3.6.x

Attributes GH PR #43: https://github.com/ArcticaProject/nx-libs/pull/43

4 files changed, 0 insertions, 1712 deletions

diff --git a/nx-X11/lib/Xxf86vm/Imakefile b/nx-X11/lib/Xxf86vm/Imakefile
deleted file mode 100644
index 84a29eb1d..000000000
--- a/nx-X11/lib/Xxf86vm/Imakefile
+++ /dev/null
@@ -1,40 +0,0 @@
-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 <Threads.tmpl>
-
-#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 <Library.tmpl>
-
-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
deleted file mode 100644
index 6e53ad158..000000000
--- a/nx-X11/lib/Xxf86vm/XF86VM.man
+++ /dev/null
@@ -1,425 +0,0 @@
-.\" $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 <X11/extensions/xf86vmode.h>
-.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
deleted file mode 100644
index edff93fe5..000000000
--- a/nx-X11/lib/Xxf86vm/XF86VMode.c
+++ /dev/null
@@ -1,1231 +0,0 @@
-/* $XConsortium: XF86VMode.c /main/2 1995/11/14 18:17:58 kaleb $ */
-/* $XFree86: xc/lib/Xxf86vm/XF86VMode.c,v 3.33 2002/10/16 00:37:34 dawes Exp $ */
-/*
-
-Copyright (c) 1995  Kaleb S. KEITHLEY
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES 
-OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name of Kaleb S. KEITHLEY 
-shall not be used in advertising or otherwise to promote the sale, use 
-or other dealings in this Software without prior written authorization
-from Kaleb S. KEITHLEY.
-
-*/
-/* $XConsortium: XF86VMode.c /main/4 1996/01/16 07:52:25 kaleb CHECKEDOUT $ */
-
-/* THIS IS NOT AN X CONSORTIUM STANDARD */
-
-#define NEED_EVENTS
-#define NEED_REPLIES
-#include <X11/Xlibint.h>
-#include <X11/extensions/xf86vmstr.h>
-#include <X11/extensions/Xext.h>
-#include <X11/extensions/extutil.h>
-
-#ifdef DEBUG
-#include <stdio.h>
-#endif
-
-#ifndef MODE_BAD
-#define MODE_BAD 255
-#endif
-
-static XExtensionInfo _xf86vidmode_info_data;
-static XExtensionInfo *xf86vidmode_info = &_xf86vidmode_info_data;
-static char *xf86vidmode_extension_name = XF86VIDMODENAME;
-
-#define XF86VidModeCheckExtension(dpy,i,val) \
-  XextCheckExtension (dpy, i, xf86vidmode_extension_name, val)
-
-/*****************************************************************************
- *                                                                           *
- *			   private utility routines                          *
- *                                                                           *
- *****************************************************************************/
-
-static XEXT_CLOSE_DISPLAY_PROTO(close_display);
-static /* const */ XExtensionHooks xf86vidmode_extension_hooks = {
-    NULL,				/* create_gc */
-    NULL,				/* copy_gc */
-    NULL,				/* flush_gc */
-    NULL,				/* free_gc */
-    NULL,				/* create_font */
-    NULL,				/* free_font */
-    close_display,			/* close_display */
-    NULL,				/* wire_to_event */
-    NULL,				/* event_to_wire */
-    NULL,				/* error */
-    NULL,				/* error_string */
-};
-
-static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info, 
-				   xf86vidmode_extension_name, 
-				   &xf86vidmode_extension_hooks, 
-				   0, NULL)
-
-static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info)
-
-
-/*****************************************************************************
- *                                                                           *
- *		    public XFree86-VidMode Extension routines                *
- *                                                                           *
- *****************************************************************************/
-
-Bool
-XF86VidModeQueryExtension (dpy, event_basep, error_basep)
-    Display *dpy;
-    int *event_basep, *error_basep;
-{
-    XExtDisplayInfo *info = find_display (dpy);
-
-    if (XextHasExtension(info)) {
-	*event_basep = info->codes->first_event;
-	*error_basep = info->codes->first_error;
-	return True;
-    } else {
-	return False;
-    }
-}
-
-Bool
-XF86VidModeQueryVersion(dpy, majorVersion, minorVersion)
-    Display* dpy;
-    int* majorVersion; 
-    int* minorVersion;
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86VidModeQueryVersionReply rep;
-    xXF86VidModeQueryVersionReq *req;
-
-    XF86VidModeCheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86VidModeQueryVersion, req);
-    req->reqType = info->codes->major_opcode;
-    req->xf86vidmodeReqType = X_XF86VidModeQueryVersion;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-	return False;
-    }
-    *majorVersion = rep.majorVersion;
-    *minorVersion = rep.minorVersion;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    if (*majorVersion >= 2)
-	XF86VidModeSetClientVersion(dpy);
-    return True;
-}
-
-Bool
-XF86VidModeSetClientVersion(Display *dpy)
-{
-    XExtDisplayInfo *info = find_display(dpy);
-    xXF86VidModeSetClientVersionReq *req;
-
-    XF86VidModeCheckExtension(dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86VidModeSetClientVersion, req);
-    req->reqType = info->codes->major_opcode;
-    req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion;
-    req->major = XF86VIDMODE_MAJOR_VERSION;
-    req->minor = XF86VIDMODE_MINOR_VERSION;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    return True;
-}
-
-Bool
-XF86VidModeSetGamma(Display *dpy, int screen, XF86VidModeGamma *Gamma)
-{
-    XExtDisplayInfo *info = find_display(dpy);
-    xXF86VidModeSetGammaReq *req;
-
-    XF86VidModeCheckExtension(dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86VidModeSetGamma, req);
-    req->reqType = info->codes->major_opcode;
-    req->xf86vidmodeReqType = X_XF86VidModeSetGamma;
-    req->screen = screen;
-    req->red = (CARD32)(Gamma->red * 10000.);
-    req->green = (CARD32)(Gamma->green * 10000.);
-    req->blue = (CARD32)(Gamma->blue * 10000.);
-    UnlockDisplay(dpy);
-    SyncHandle();
-    return True;
-}
-
-Bool
-XF86VidModeGetGamma(Display *dpy, int screen, XF86VidModeGamma *Gamma)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86VidModeGetGammaReply rep;
-    xXF86VidModeGetGammaReq *req;
-
-    XF86VidModeCheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86VidModeGetGamma, req);
-    req->reqType = info->codes->major_opcode;
-    req->xf86vidmodeReqType = X_XF86VidModeGetGamma;
-    req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-	return False;
-    }
-    Gamma->red = ((float)rep.red) / 10000.;
-    Gamma->green = ((float)rep.green) / 10000.;
-    Gamma->blue = ((float)rep.blue) / 10000.;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    return True;
-}
-
-Bool
-XF86VidModeGetModeLine(dpy, screen, dotclock, modeline)
-    Display* dpy;
-    int screen;
-    int* dotclock; 
-    XF86VidModeModeLine* modeline;
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86VidModeGetModeLineReply rep;
-    xXF86OldVidModeGetModeLineReply oldrep;
-    xXF86VidModeGetModeLineReq *req;
-    int majorVersion, minorVersion;
-
-    XF86VidModeCheckExtension (dpy, info, False);
-    XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
-
-    LockDisplay(dpy);
-    GetReq(XF86VidModeGetModeLine, req);
-    req->reqType = info->codes->major_opcode;
-    req->xf86vidmodeReqType = X_XF86VidModeGetModeLine;
-    req->screen = screen;
-    
-    if (majorVersion < 2) {
-	if (!_XReply(dpy, (xReply *)&oldrep, 
-            (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
-	    UnlockDisplay(dpy);
-	    SyncHandle();
-	    return False;
-	}
-	*dotclock = oldrep.dotclock;
-	modeline->hdisplay   = oldrep.hdisplay;
-	modeline->hsyncstart = oldrep.hsyncstart;
-	modeline->hsyncend   = oldrep.hsyncend;
-	modeline->htotal     = oldrep.htotal;
-	modeline->hskew      = 0;
-	modeline->vdisplay   = oldrep.vdisplay;
-	modeline->vsyncstart = oldrep.vsyncstart;
-	modeline->vsyncend   = oldrep.vsyncend;
-	modeline->vtotal     = oldrep.vtotal;
-	modeline->flags      = oldrep.flags;
-	modeline->privsize   = oldrep.privsize;
-    } else {
-	if (!_XReply(dpy, (xReply *)&rep, 
-            (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
-	    UnlockDisplay(dpy);
-	    SyncHandle();
-	    return False;
-	}
-	*dotclock = rep.dotclock;
-	modeline->hdisplay   = rep.hdisplay;
-	modeline->hsyncstart = rep.hsyncstart;
-	modeline->hsyncend   = rep.hsyncend;
-	modeline->htotal     = rep.htotal;
-	modeline->hskew      = rep.hskew;
-	modeline->vdisplay   = rep.vdisplay;
-	modeline->vsyncstart = rep.vsyncstart;
-	modeline->vsyncend   = rep.vsyncend;
-	modeline->vtotal     = rep.vtotal;
-	modeline->flags      = rep.flags;
-	modeline->privsize   = rep.privsize;
-    }
-    
-    if (modeline->privsize > 0) {
-	if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) {
-	    _XEatData(dpy, (modeline->privsize) * sizeof(INT32));
-	    Xfree(modeline->private);
-	    return False;
-	}
-	_XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32));
-    } else {
-	modeline->private = NULL;
-    }
-    UnlockDisplay(dpy);
-    SyncHandle();
-    return True;
-}
-
-Bool
-XF86VidModeGetAllModeLines(dpy, screen, modecount, modelinesPtr)
-    Display* dpy;
-    int screen;
-    int* modecount; 
-    XF86VidModeModeInfo ***modelinesPtr;
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86VidModeGetAllModeLinesReply rep;
-    xXF86VidModeGetAllModeLinesReq *req;
-    XF86VidModeModeInfo *mdinfptr, **modelines;
-    xXF86VidModeModeInfo xmdline;
-    xXF86OldVidModeModeInfo oldxmdline;
-    int i;
-    int majorVersion, minorVersion;
-    Bool protocolBug = False;
-
-    XF86VidModeCheckExtension (dpy, info, False);
-
-    /*
-     * Note: There was a bug in the protocol implementation in versions
-     * 0.x with x < 8 (the .private field wasn't being passed over the wire).
-     * Check the server's version, and accept the old format if appropriate.
-     */
-
-    XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
-    if (majorVersion == 0 && minorVersion < 8) {
-	protocolBug = True;
-#ifdef DEBUG
-	fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is"
-		"running an old version (%d.%d)\n", majorVersion,
-		minorVersion);
-#endif
-    }
-    
-    LockDisplay(dpy);
-    GetReq(XF86VidModeGetAllModeLines, req);
-    req->reqType = info->codes->major_opcode;
-    req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines;
-    req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 
-        (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) {
-        UnlockDisplay(dpy);
-	SyncHandle();
-	return False;
-    }
-
-    *modecount = rep.modecount;
-
-    if (!(modelines = (XF86VidModeModeInfo **) Xcalloc(rep.modecount,
-                                          sizeof(XF86VidModeModeInfo *)
-                                          +sizeof(XF86VidModeModeInfo)))) {
-	if (majorVersion < 2)
-            _XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo));
-	else
-            _XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo));
-        Xfree(modelines);
-        return False;
-    }
-    mdinfptr = (XF86VidModeModeInfo *) (
-			    (char *) modelines
-			    + rep.modecount*sizeof(XF86VidModeModeInfo *)
-		    );
-
-    for (i = 0; i < rep.modecount; i++) {
-        modelines[i] = mdinfptr++;
-	if (majorVersion < 2) {
-            _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo));
-	    modelines[i]->dotclock   = oldxmdline.dotclock;
-	    modelines[i]->hdisplay   = oldxmdline.hdisplay;
-	    modelines[i]->hsyncstart = oldxmdline.hsyncstart;
-	    modelines[i]->hsyncend   = oldxmdline.hsyncend;
-	    modelines[i]->htotal     = oldxmdline.htotal;
-	    modelines[i]->hskew      = 0;
-	    modelines[i]->vdisplay   = oldxmdline.vdisplay;
-	    modelines[i]->vsyncstart = oldxmdline.vsyncstart;
-	    modelines[i]->vsyncend   = oldxmdline.vsyncend;
-	    modelines[i]->vtotal     = oldxmdline.vtotal;
-	    modelines[i]->flags      = oldxmdline.flags;
-	    if (protocolBug) {
-		modelines[i]->privsize = 0;
-		modelines[i]->private = NULL;
-	    } else {
-		modelines[i]->privsize   = oldxmdline.privsize;
-		if (oldxmdline.privsize > 0) {
-	            if (!(modelines[i]->private =
-			    Xcalloc(oldxmdline.privsize, sizeof(INT32)))) {
-			_XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32));
-			Xfree(modelines[i]->private);
-		    } else {
-			_XRead(dpy, (char*)modelines[i]->private,
-			     oldxmdline.privsize * sizeof(INT32));
-		    }
-		} else {
-		  modelines[i]->private = NULL;
-		}
-	    }
-	} else {
-            _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo));
-	    modelines[i]->dotclock   = xmdline.dotclock;
-	    modelines[i]->hdisplay   = xmdline.hdisplay;
-	    modelines[i]->hsyncstart = xmdline.hsyncstart;
-	    modelines[i]->hsyncend   = xmdline.hsyncend;
-	    modelines[i]->htotal     = xmdline.htotal;
-	    modelines[i]->hskew      = xmdline.hskew;
-	    modelines[i]->vdisplay   = xmdline.vdisplay;
-	    modelines[i]->vsyncstart = xmdline.vsyncstart;
-	    modelines[i]->vsyncend   = xmdline.vsyncend;
-	    modelines[i]->vtotal     = xmdline.vtotal;
-	    modelines[i]->flags      = xmdline.flags;
-	    if (protocolBug) {
-		modelines[i]->privsize = 0;
-		modelines[i]->private = NULL;
-	    } else {
-		modelines[i]->privsize   = xmdline.privsize;
-		if (xmdline.privsize > 0) {
-		    if (!(modelines[i]->private =
-			    Xcalloc(xmdline.privsize, sizeof(INT32)))) {
-			_XEatData(dpy, (xmdline.privsize) * sizeof(INT32));
-			Xfree(modelines[i]->private);
-		    } else {
-			_XRead(dpy, (char*)modelines[i]->private,
-			     xmdline.privsize * sizeof(INT32));
-		    }
-		} else {
-		    modelines[i]->private = NULL;
-		}
-	    }
-	}
-    }
-    *modelinesPtr = modelines;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    return True;
-}
-
-/*
- * GetReq replacement for use with VidMode protocols earlier than 2.0
- */
-#if !defined(UNIXCPP) || defined(ANSICPP)
-#define GetOldReq(name, oldname, req) \
-	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) \
-	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
deleted file mode 100644
index 0f7b4f335..000000000
--- a/nx-X11/lib/Xxf86vm/Xxf86vm-def.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-LIBRARY XXF86VM
-EXPORTS
-	XF86VidModeQueryExtension 
-	XF86VidModeQueryVersion 
-	XF86VidModeGetModeLine 
-	XF86VidModeGetAllModeLines
-	XF86VidModeModModeLine 
-	XF86VidModeSwitchMode 
-	XF86VidModeLockModeSwitch 
-	XF86VidModeGetMonitor
-	XF86VidModeGetGamma
-	XF86VidModeSetGamma
-	XF86VidModeSwitchToMode
-	XF86VidModeAddModeLine
-	
-/* $XFree86$ */