		      Release 5 Public Patch #18
			   MIT X Consortium

WARNING:
This patch was previously released as an optional patch, in support of the
X Test Suite, and was labeled "Release 5 XTEST Public Patch" (the file on
expo was "/pub/XTEST/R5fix-xtest-1").  If you have already applied that patch,
do not try to apply this one!  Proceed instead to apply public patch #19.

To apply this patch:

cd to the top of the source tree (to the directory containing the "mit"
and "contrib" subdirectories) and do:
	patch -p -s < ThisFile
Patch will work silently unless an error occurs.  You will likely get
the following warning messages, which can be ignored:
	mkdir: mit: File exists
	mkdir: mit/extensions: File exists
	mkdir: mit/extensions/include: File exists
	mkdir: mit: File exists
	mkdir: mit/extensions: File exists
	mkdir: mit/extensions/include: File exists
	mkdir: mit: File exists
	mkdir: mit/extensions: File exists
	mkdir: mit/extensions/lib: File exists
	mkdir: mit: File exists
	mkdir: mit/extensions: File exists
	mkdir: mit/extensions/lib: File exists
	mkdir: mit/extensions/lib/xtest: File exists
	mkdir: mit: File exists
	mkdir: mit/extensions: File exists
	mkdir: mit/extensions/server: File exists
	mkdir: mit: File exists
	mkdir: mit/extensions: File exists
	mkdir: mit/extensions/server: File exists
If you want to watch patch do its thing, leave out the "-s" argument to patch.

This patch creates the following new files:
	mit/extensions/include/XTest.h
	mit/extensions/include/xteststr.h
	mit/extensions/lib/xtest/Imakefile
	mit/extensions/lib/xtest/XTest.c
	mit/extensions/server/sleepuntil.c
	mit/extensions/server/xtest.c
If you are using a symbolic link tree, you will need to create new links.

To build a server with the XTEST extension enabled, you will need to edit
your vendor.cf or site.def file in mit/config/.  For most servers, you can
insert the following line into the "AfterVendorCF" part of your site.def:

#define ExtensionOSDefines -DXTEST

If your vendor.cf already contains a #define for ExtensionOSDefines (e.g.,
x386.cf does), then you can edit the .cf file and add -DXTEST to
ExtensionOSDefines there.

Finally, to rebuild after applying this patch, cd to the "mit" subdirectory
and do:
	make Everything >& every.log
Note: this will *not* "clean" your tree.

Brief notes on what this patch provides:

xtest: add implementation of XTEST extension

Prereq: 91/07/16

*** /tmp/,RCSt1016565	Wed Sep  9 15:41:50 1992
--- mit/extensions/include/Imakefile	Wed Sep  9 15:41:51 1992
***************
*** 1,4 ****
! XCOMM $XConsortium: Imakefile,v 1.24 91/07/16 23:08:47 gildea Exp $
  #if BuildPexClients || BuildPexExt
  #define IHaveSubdirs
  #define PassCDebugFlags 'CDEBUGFLAGS=$(CDEBUGFLAGS)'
--- 1,4 ----
! XCOMM $XConsortium: Imakefile,v 1.24.1.1 92/09/09 15:25:53 rws Exp $
  #if BuildPexClients || BuildPexExt
  #define IHaveSubdirs
  #define PassCDebugFlags 'CDEBUGFLAGS=$(CDEBUGFLAGS)'
***************
*** 6,12 ****
  #endif
  
  HEADERS = Xext.h multibuf.h shape.h XShm.h MITMisc.h XI.h XInput.h XIproto.h \
! 	xtestext1.h
  INSTALLFLAGS = $(INSTINCFLAGS)
  
  all::
--- 6,12 ----
  #endif
  
  HEADERS = Xext.h multibuf.h shape.h XShm.h MITMisc.h XI.h XInput.h XIproto.h \
! 	XTest.h xtestext1.h
  INSTALLFLAGS = $(INSTINCFLAGS)
  
  all::
*** /dev/null	Wed Sep  9 15:40:33 1992
--- mit/extensions/include/XTest.h	Mon Apr 20 13:15:18 1992
***************
*** 0 ****
--- 1,126 ----
+ /* $XConsortium: XTest.h,v 1.4 92/04/20 13:13:54 rws Exp $ */
+ /*
+ 
+ Copyright 1992 by the Massachusetts Institute of Technology
+ 
+ Permission to use, copy, modify, distribute, and sell this software and its
+ documentation for any purpose is hereby granted without fee, provided that
+ the above copyright notice appear in all copies and that both that
+ copyright notice and this permission notice appear in supporting
+ documentation, and that the name of M.I.T. not be used in advertising or
+ publicity pertaining to distribution of the software without specific,
+ written prior permission.  M.I.T. makes no representations about the
+ suitability of this software for any purpose.  It is provided "as is"
+ without express or implied warranty.
+ 
+ */
+ 
+ #ifndef _XTEST_H_
+ #define _XTEST_H_
+ 
+ #include <X11/Xfuncproto.h>
+ 
+ #define X_XTestGetVersion	0
+ #define X_XTestCompareCursor	1
+ #define X_XTestFakeInput	2
+ 
+ #define XTestNumberEvents	0
+ 
+ #define XTestNumberErrors	0
+ 
+ #define XTestMajorVersion	2
+ #define XTestMinorVersion	1
+ 
+ #define XTestExtensionName	"XTEST"
+ 
+ #ifndef _XTEST_SERVER_
+ 
+ _XFUNCPROTOBEGIN
+ 
+ Bool XTestQueryExtension(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */,
+     int*		/* event_basep */,
+     int*		/* error_basep */,
+     int*		/* majorp */,
+     int*		/* minorp */
+ #endif
+ );
+ 
+ Bool XTestCompareCursorWithWindow(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */,
+     Window		/* window */,
+     Cursor		/* cursor */
+ #endif
+ );
+ 
+ Bool XTestCompareCurrentCursorWithWindow(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */,
+     Window		/* window */
+ #endif
+ );
+ 
+ extern XTestFakeKeyEvent(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */,
+     unsigned int	/* keycode */,
+     Bool		/* is_press */,
+     unsigned long	/* delay */
+ #endif
+ );
+ 
+ extern XTestFakeButtonEvent(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */,
+     unsigned int	/* button */,
+     Bool		/* is_press */,
+     unsigned long	/* delay */
+ #endif
+ );
+ 
+ extern XTestFakeMotionEvent(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */,
+     int			/* screen */,
+     int			/* x */,
+     int			/* y */,
+     unsigned long	/* delay */
+ #endif
+ );
+ 
+ extern XTestFakeRelativeMotionEvent(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */,
+     int			/* x */,
+     int			/* y */,
+     unsigned long	/* delay */
+ #endif
+ );
+ 
+ void XTestSetGContextOfGC(
+ #if NeedFunctionPrototypes
+     GC			/* gc */,
+     GContext		/* gid */
+ #endif
+ );
+ 
+ void XTestSetVisualIDOfVisual(
+ #if NeedFunctionPrototypes
+     Visual*		/* visual */,
+     VisualID		/* visualid */
+ #endif
+ );
+ 
+ Status XTestDiscard(
+ #if NeedFunctionPrototypes
+     Display*		/* dpy */
+ #endif
+ );
+ 
+ _XFUNCPROTOEND
+ 
+ #endif /* _XTEST_SERVER_ */
+ 
+ #endif
*** /dev/null	Wed Sep  9 15:40:33 1992
--- mit/extensions/include/xteststr.h	Mon Apr 20 13:15:45 1992
***************
*** 0 ****
--- 1,84 ----
+ /* $XConsortium: xteststr.h,v 1.5 92/04/20 13:14:15 rws Exp $ */
+ /*
+ 
+ Copyright 1992 by the Massachusetts Institute of Technology
+ 
+ Permission to use, copy, modify, distribute, and sell this software and its
+ documentation for any purpose is hereby granted without fee, provided that
+ the above copyright notice appear in all copies and that both that
+ copyright notice and this permission notice appear in supporting
+ documentation, and that the name of M.I.T. not be used in advertising or
+ publicity pertaining to distribution of the software without specific,
+ written prior permission.  M.I.T. makes no representations about the
+ suitability of this software for any purpose.  It is provided "as is"
+ without express or implied warranty.
+ 
+ */
+ 
+ #define XTestCurrentCursor ((Cursor)1)
+ 
+ typedef struct {
+     CARD8	reqType;	/* always XTestReqCode */
+     CARD8	xtReqType;	/* always X_XTestGetVersion */
+     CARD16	length B16;
+     CARD8	majorVersion;
+     CARD8	pad;
+     CARD16	minorVersion B16;
+ } xXTestGetVersionReq;
+ #define sz_xXTestGetVersionReq 8
+ 
+ typedef struct {
+     BYTE	type;			/* X_Reply */
+     CARD8	majorVersion;
+     CARD16	sequenceNumber B16;
+     CARD32	length B32;
+     CARD16	minorVersion B16;
+     CARD16	pad0 B16;
+     CARD32	pad1 B32;
+     CARD32	pad2 B32;
+     CARD32	pad3 B32;
+     CARD32	pad4 B32;
+     CARD32	pad5 B32;
+ } xXTestGetVersionReply;
+ #define sz_xXTestGetVersionReply 32
+ 
+ typedef struct {
+     CARD8	reqType;	/* always XTestReqCode */
+     CARD8	xtReqType;	/* always X_XTestCompareCursor */
+     CARD16	length B16;
+     Window	window B32;
+     Cursor	cursor B32;
+ } xXTestCompareCursorReq;
+ #define sz_xXTestCompareCursorReq 12
+ 
+ typedef struct {
+     BYTE	type;			/* X_Reply */
+     BOOL	same;
+     CARD16	sequenceNumber B16;
+     CARD32	length B32;
+     CARD32	pad0 B32;
+     CARD32	pad1 B32;
+     CARD32	pad2 B32;
+     CARD32	pad3 B32;
+     CARD32	pad4 B32;
+     CARD32	pad5 B32;
+ } xXTestCompareCursorReply;
+ #define sz_xXTestCompareCursorReply 32
+ 
+ /* used only on the client side */
+ typedef struct {
+     CARD8	reqType;	/* always XTestReqCode */
+     CARD8	xtReqType;	/* always X_XTestFakeInput */
+     CARD16	length B16;
+     BYTE	type;
+     BYTE	detail;
+     CARD16	pad0 B16;
+     Time	time B32;
+     Window	root B32;
+     CARD32	pad1 B32;
+     CARD32	pad2 B32;
+     INT16	rootX B16, rootY B16;
+     CARD32	pad3 B32;
+     CARD32	pad4 B32;
+ } xXTestFakeInputReq;
+ #define sz_xXTestFakeInputReq 36
*** /tmp/,RCSt1016576	Wed Sep  9 15:43:55 1992
--- mit/extensions/lib/Imakefile	Wed Sep  9 15:43:56 1992
***************
*** 1,4 ****
! XCOMM $XConsortium: Imakefile,v 1.33 91/07/22 22:56:37 rws Exp $
  #define DoNormalLib NormalLibXext
  #define DoSharedLib SharedLibXext
  #define DoDebugLib DebugLibXext
--- 1,4 ----
! XCOMM $XConsortium: Imakefile,v 1.33.1.1 92/09/09 15:29:32 rws Exp $
  #define DoNormalLib NormalLibXext
  #define DoSharedLib SharedLibXext
  #define DoDebugLib DebugLibXext
***************
*** 9,15 ****
  REQUIREDLIBS = $(XLIBSRC)/libX11.a
  #endif
  
- #if BuildXInputLib || BuildPexClients
  #define IHaveSubdirs
  #define PassCDebugFlags 'CDEBUGFLAGS=$(CDEBUGFLAGS)'
  #if BuildXInputLib
--- 9,14 ----
***************
*** 18,25 ****
  #if BuildPexClients
        PEXDIRS = PEX
  #endif
!       SUBDIRS = $(XINPUTDIRS) $(PEXDIRS)
! #endif
  
  #if HasShm
        SHMSRCS = XShm.c
--- 17,23 ----
  #if BuildPexClients
        PEXDIRS = PEX
  #endif
!       SUBDIRS = $(XINPUTDIRS) $(PEXDIRS) xtest
  
  #if HasShm
        SHMSRCS = XShm.c
*** /dev/null	Wed Sep  9 15:40:33 1992
--- mit/extensions/lib/xtest/Imakefile	Wed Sep  9 15:44:55 1992
***************
*** 0 ****
--- 1,49 ----
+ XCOMM $XConsortium: Imakefile,v 1.2.1.1 92/09/09 15:38:45 rws Exp $
+ #ifndef NormalLibXTest
+ #define NormalLibXTest YES
+ #endif
+ #define DoNormalLib NormalLibXTest
+ #define DoSharedLib SharedLibXTest
+ #define DoDebugLib DebugLibXTest
+ #define DoProfileLib ProfileLibXTest
+ #include <Library.tmpl>
+ 
+ #ifdef RsArchitecture
+ REQUIREDLIBS = $(EXTENSIONSRC)/lib/libXext.a $(XLIBSRC)/libX11.a
+ #endif
+ 
+ INCLUDES = -I$(TOP) -I$(XLIBSRC) -I../../include
+ 
+ SRCS = XTest.c
+ OBJS = XTest.o
+ 
+ LINTLIBS = $(LINTXLIB)
+ 
+ LibraryObjectRule()
+ 
+ #if DoSharedLib
+ #if DoNormalLib
+ SharedLibraryTarget(Xtst,$(SOXTESTREV),$(OBJS),shared,..)
+ #else
+ SharedLibraryTarget(Xtst,$(SOXTESTREV),$(OBJS),.,.)
+ #endif
+ InstallSharedLibrary(Xtst,$(SOXTESTREV),$(USRLIBDIR))
+ #endif
+ #if DoNormalLib
+ NormalLibraryTarget(Xtst,$(OBJS))
+ InstallLibrary(Xtst,$(USRLIBDIR))
+ #endif
+ #if DoProfileLib
+ ProfiledLibraryTarget(Xtst,$(OBJS))
+ InstallLibrary(Xtst_p,$(USRLIBDIR))
+ #endif
+ #if DoDebugLib
+ DebuggedLibraryTarget(Xtst,$(OBJS))
+ #endif
+ 
+ LintLibraryTarget(Xtst,$(SRCS))
+ InstallLintLibrary(Xtst,$(LINTLIBDIR))
+ 
+ DependTarget()
+ 
+ NormalLintTarget($(SRCS))
*** /dev/null	Wed Sep  9 15:40:33 1992
--- mit/extensions/lib/xtest/XTest.c	Mon Apr 20 13:16:12 1992
***************
*** 0 ****
--- 1,272 ----
+ /* $XConsortium: XTest.c,v 1.7 92/04/20 13:14:52 rws Exp $ */
+ /*
+ 
+ Copyright 1990, 1991 by UniSoft Group Limited
+ Copyright 1992 by the Massachusetts Institute of Technology
+ 
+ Permission to use, copy, modify, distribute, and sell this software and its
+ documentation for any purpose is hereby granted without fee, provided that
+ the above copyright notice appear in all copies and that both that
+ copyright notice and this permission notice appear in supporting
+ documentation, and that the name of M.I.T. not be used in advertising or
+ publicity pertaining to distribution of the software without specific,
+ written prior permission.  M.I.T. makes no representations about the
+ suitability of this software for any purpose.  It is provided "as is"
+ without express or implied warranty.
+ 
+ */
+ 
+ #define NEED_REPLIES
+ #include "Xlibint.h"
+ #include "XTest.h"
+ #include "xteststr.h"
+ #include "Xext.h"
+ #include "extutil.h"
+ 
+ static XExtensionInfo _xtest_info_data;
+ static XExtensionInfo *xtest_info = &_xtest_info_data;
+ static /* const */ char *xtest_extension_name = XTestExtensionName;
+ 
+ #define XTestCheckExtension(dpy,i,val) \
+   XextCheckExtension (dpy, i, xtest_extension_name, val)
+ 
+ /*****************************************************************************
+  *                                                                           *
+  *			   private utility routines                          *
+  *                                                                           *
+  *****************************************************************************/
+ 
+ static int close_display();
+ static /* const */ XExtensionHooks xtest_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, xtest_info,
+ 				   xtest_extension_name, 
+ 				   &xtest_extension_hooks, XTestNumberEvents,
+ 				   NULL)
+ 
+ static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xtest_info)
+ 
+ /*****************************************************************************
+  *                                                                           *
+  *		    public routines               			     *
+  *                                                                           *
+  *****************************************************************************/
+ 
+ Bool
+ XTestQueryExtension (dpy, event_basep, error_basep, majorp, minorp)
+     Display *dpy;
+     int *event_basep, *error_basep;
+     int *majorp, *minorp;
+ {
+     XExtDisplayInfo *info = find_display (dpy);
+     register xXTestGetVersionReq *req;
+     xXTestGetVersionReply rep;
+ 
+     if (XextHasExtension(info)) {
+ 	LockDisplay(dpy);
+ 	GetReq(XTestGetVersion, req);
+ 	req->reqType = info->codes->major_opcode;
+ 	req->xtReqType = X_XTestGetVersion;
+ 	req->majorVersion = XTestMajorVersion;
+ 	req->minorVersion = XTestMinorVersion;
+ 	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ 	    UnlockDisplay(dpy);
+ 	    SyncHandle();
+ 	    return False;
+ 	}
+ 	UnlockDisplay(dpy);
+ 	SyncHandle();
+ 	*event_basep = info->codes->first_event;
+ 	*error_basep = info->codes->first_error;
+ 	*majorp = rep.majorVersion;
+ 	*minorp = rep.minorVersion;
+ 	return True;
+     } else {
+ 	return False;
+     }
+ }
+ 
+ Bool
+ XTestCompareCursorWithWindow(dpy, window, cursor)
+     Display *dpy;
+     Window window;
+     Cursor cursor;
+ {
+     XExtDisplayInfo *info = find_display (dpy);
+     register xXTestCompareCursorReq *req;
+     xXTestCompareCursorReply rep;
+ 
+     XTestCheckExtension (dpy, info, 0);
+ 
+     LockDisplay(dpy);
+     GetReq(XTestCompareCursor, req);
+     req->reqType = info->codes->major_opcode;
+     req->xtReqType = X_XTestCompareCursor;
+     req->window = window;
+     req->cursor = cursor;
+     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ 	UnlockDisplay(dpy);
+ 	SyncHandle();
+ 	return False;
+     }
+     UnlockDisplay(dpy);
+     SyncHandle();
+     return rep.same;
+ }
+ 
+ Bool
+ XTestCompareCurrentCursorWithWindow(dpy, window)
+     Display *dpy;
+     Window window;
+ {
+     return XTestCompareCursorWithWindow(dpy, window, XTestCurrentCursor);
+ }
+ 
+ XTestFakeKeyEvent(dpy, keycode, is_press, delay)
+     Display *dpy;
+     unsigned int keycode;
+     Bool is_press;
+     unsigned long delay;
+ {
+     XExtDisplayInfo *info = find_display (dpy);
+     register xXTestFakeInputReq *req;
+ 
+     XTestCheckExtension (dpy, info, 0);
+ 
+     LockDisplay(dpy);
+     GetReq(XTestFakeInput, req);
+     req->reqType = info->codes->major_opcode;
+     req->xtReqType = X_XTestFakeInput;
+     req->type = is_press ? KeyPress : KeyRelease;
+     req->detail = keycode;
+     req->time = delay;
+     UnlockDisplay(dpy);
+     SyncHandle();
+ }
+ 
+ XTestFakeButtonEvent(dpy, button, is_press, delay)
+     Display *dpy;
+     unsigned int button;
+     Bool is_press;
+     unsigned long delay;
+ {
+     XExtDisplayInfo *info = find_display (dpy);
+     register xXTestFakeInputReq *req;
+ 
+     XTestCheckExtension (dpy, info, 0);
+ 
+     LockDisplay(dpy);
+     GetReq(XTestFakeInput, req);
+     req->reqType = info->codes->major_opcode;
+     req->xtReqType = X_XTestFakeInput;
+     req->type = is_press ? ButtonPress : ButtonRelease;
+     req->detail = button;
+     req->time = delay;
+     UnlockDisplay(dpy);
+     SyncHandle();
+ }
+ 
+ XTestFakeMotionEvent(dpy, screen, x, y, delay)
+     Display *dpy;
+     int screen;
+     int x, y;
+     unsigned long delay;
+ {
+     XExtDisplayInfo *info = find_display (dpy);
+     register xXTestFakeInputReq *req;
+ 
+     XTestCheckExtension (dpy, info, 0);
+ 
+     LockDisplay(dpy);
+     GetReq(XTestFakeInput, req);
+     req->reqType = info->codes->major_opcode;
+     req->xtReqType = X_XTestFakeInput;
+     req->type = MotionNotify;
+     req->detail = False;
+     if (screen == -1)
+ 	req->root = None;
+     else
+ 	req->root = RootWindow(dpy, screen);
+     req->rootX = x;
+     req->rootY = y;
+     req->time = delay;
+     UnlockDisplay(dpy);
+     SyncHandle();
+ }
+ 
+ XTestFakeRelativeMotionEvent(dpy, dx, dy, delay)
+     Display *dpy;
+     int dx, dy;
+     unsigned long delay;
+ {
+     XExtDisplayInfo *info = find_display (dpy);
+     register xXTestFakeInputReq *req;
+ 
+     XTestCheckExtension (dpy, info, 0);
+ 
+     LockDisplay(dpy);
+     GetReq(XTestFakeInput, req);
+     req->reqType = info->codes->major_opcode;
+     req->xtReqType = X_XTestFakeInput;
+     req->type = MotionNotify;
+     req->detail = True;
+     req->root = None;
+     req->rootX = dx;
+     req->rootY = dy;
+     req->time = delay;
+     UnlockDisplay(dpy);
+     SyncHandle();
+ }
+ 
+ void
+ XTestSetGContextOfGC(gc, gid)
+     GC gc;
+     GContext gid;
+ {
+     gc->gid = gid;
+ }
+ 
+ void
+ XTestSetVisualIDOfVisual(visual, visualid)
+     Visual *visual;
+     VisualID visualid;
+ {
+     visual->visualid = visualid;
+ }
+ 
+ static xReq _dummy_request = {
+ 	0, 0, 0
+ };
+ 
+ Status
+ XTestDiscard(dpy)
+     Display *dpy;
+ {
+     Bool something;
+     register char *ptr;
+ 
+     LockDisplay(dpy);
+     if (something = (dpy->bufptr != dpy->buffer)) {
+ 	for (ptr = dpy->buffer;
+ 	     ptr < dpy->bufptr;
+ 	     ptr += (((xReq *)ptr)->length << 2))
+ 	    dpy->request--;
+ 	dpy->bufptr = dpy->buffer;
+ 	dpy->last_req = (char *)&_dummy_request;
+     }
+     UnlockDisplay(dpy);
+     SyncHandle();
+     return something;
+ }
*** /tmp/,RCSt1016593	Wed Sep  9 15:46:33 1992
--- mit/extensions/server/Imakefile	Wed Sep  9 15:46:35 1992
***************
*** 1,4 ****
! XCOMM $XConsortium: Imakefile,v 5.15 91/07/16 23:09:51 gildea Exp $
  #include <Server.tmpl>
  
  #if BuildXInputExt || BuildPexExt || BuildPexClients
--- 1,4 ----
! XCOMM $XConsortium: Imakefile,v 5.15.1.1 92/09/09 15:32:22 rws Exp $
  #include <Server.tmpl>
  
  #if BuildXInputExt || BuildPexExt || BuildPexClients
***************
*** 19,26 ****
    SHMSRCS = shm.c
    SHMOBJS = shm.o
  #endif
!        SRCS = shape.c $(SHMSRCS) multibuf.c mitmisc.c xtest1di.c xtest1dd.c
!        OBJS = shape.o $(SHMOBJS) multibuf.o mitmisc.o xtest1di.o xtest1dd.o
     INCLUDES = -I../include -I$(INCLUDESRC) -I$(SERVERSRC)/include
     LINTLIBS = ../../server/dix/llib-ldix.ln ../../server/os/4.2bsd/llib-los.ln
          SUBDIRS = $(XINPUTDIRS) $(PEXDIRS)
--- 19,26 ----
    SHMSRCS = shm.c
    SHMOBJS = shm.o
  #endif
!        SRCS = shape.c $(SHMSRCS) multibuf.c mitmisc.c sleepuntil.c xtest.c xtest1di.c xtest1dd.c
!        OBJS = shape.o $(SHMOBJS) multibuf.o mitmisc.o sleepuntil.o xtest.o xtest1di.o xtest1dd.o
     INCLUDES = -I../include -I$(INCLUDESRC) -I$(SERVERSRC)/include
     LINTLIBS = ../../server/dix/llib-ldix.ln ../../server/os/4.2bsd/llib-los.ln
          SUBDIRS = $(XINPUTDIRS) $(PEXDIRS)
*** /dev/null	Wed Sep  9 15:40:33 1992
--- mit/extensions/server/sleepuntil.c	Mon Feb 24 19:02:47 1992
***************
*** 0 ****
--- 1,199 ----
+ /*
+  * $XConsortium: sleepuntil.c,v 1.1 92/02/24 19:02:27 keith Exp $
+  *
+  * Copyright 1992 Massachusetts Institute of Technology
+  *
+  * Permission to use, copy, modify, distribute, and sell this software and its
+  * documentation for any purpose is hereby granted without fee, provided that
+  * the above copyright notice appear in all copies and that both that
+  * copyright notice and this permission notice appear in supporting
+  * documentation, and that the name of M.I.T. not be used in advertising or
+  * publicity pertaining to distribution of the software without specific,
+  * written prior permission.  M.I.T. makes no representations about the
+  * suitability of this software for any purpose.  It is provided "as is"
+  * without express or implied warranty.
+  *
+  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
+  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+  *
+  * Author:  Keith Packard, MIT X Consortium
+  */
+ 
+ /* dixsleep.c - implement millisecond timeouts for X clients */
+ 
+ #include "X.h"
+ #include "Xmd.h"
+ #include "misc.h"
+ #include "windowstr.h"
+ #include "dixstruct.h"
+ #include "pixmapstr.h"
+ #include "scrnintstr.h"
+ 
+ typedef struct _Sertafied {
+     struct _Sertafied	*next;
+     TimeStamp		revive;
+     ClientPtr		pClient;
+     XID			id;
+     void		(*notifyFunc)();
+     pointer		closure;
+ } SertafiedRec, *SertafiedPtr;
+ 
+ static SertafiedPtr pPending;
+ static RESTYPE	    SertafiedResType;
+ static Bool	    BlockHandlerRegistered;
+ static int	    SertafiedGeneration;
+ static void	    WachetAuf();
+ static void	    SertafiedDelete();
+ static void	    SertafiedBlockHandler();
+ static void	    SertafiedWakeupHandler();
+ 
+ ClientSleepUntil (client, revive, notifyFunc, closure)
+     ClientPtr	client;
+     TimeStamp	*revive;
+     void	(*notifyFunc)();
+     pointer	closure;
+ {
+     SertafiedPtr	pRequest, pReq, pPrev;
+ 
+     if (SertafiedGeneration != serverGeneration)
+     {
+ 	SertafiedResType = CreateNewResourceType (SertafiedDelete);
+ 	if (!SertafiedResType)
+ 	    return FALSE;
+ 	SertafiedGeneration = serverGeneration;
+ 	BlockHandlerRegistered = FALSE;
+     }
+     pRequest = (SertafiedPtr) xalloc (sizeof (SertafiedRec));
+     if (!pRequest)
+ 	return FALSE;
+     pRequest->pClient = client;
+     pRequest->revive = *revive;
+     pRequest->id = FakeClientID (client->index);
+     pRequest->closure = closure;
+     if (!BlockHandlerRegistered)
+     {
+ 	if (!RegisterBlockAndWakeupHandlers (SertafiedBlockHandler,
+ 					     SertafiedWakeupHandler,
+ 					     (pointer) 0))
+ 	{
+ 	    xfree (pRequest);
+ 	    return FALSE;
+ 	}
+ 	BlockHandlerRegistered = TRUE;
+     }
+     pRequest->notifyFunc = 0;
+     if (!AddResource (pRequest->id, SertafiedResType, (pointer) pRequest))
+ 	return FALSE;
+     if (!notifyFunc)
+ 	notifyFunc = WachetAuf;
+     pRequest->notifyFunc = notifyFunc;
+     /* Insert into time-ordered queue, with earliest activation time coming first. */
+     pPrev = 0;
+     for (pReq = pPending; pReq; pReq = pReq->next)
+     {
+ 	if (CompareTimeStamps (pReq->revive, *revive) == LATER)
+ 	    break;
+ 	pPrev = pReq;
+     }
+     if (pPrev)
+ 	pPrev->next = pRequest;
+     else
+ 	pPending = pRequest;
+     pRequest->next = pReq;
+     IgnoreClient (client);
+     return TRUE;
+ }
+ 
+ static void
+ WachetAuf (client, closure)
+     ClientPtr	client;
+     pointer	closure;
+ {
+     if (!client->clientGone)
+ 	AttendClient (client);
+ }
+ 
+ 
+ static void
+ SertafiedDelete (pRequest)
+     SertafiedPtr	pRequest;
+ {
+     SertafiedPtr	pReq, pPrev;
+ 
+     pPrev = 0;
+     for (pReq = pPending; pReq; pReq = pReq->next)
+ 	if (pReq == pRequest)
+ 	{
+ 	    if (pPrev)
+ 		pPrev->next = pReq->next;
+ 	    else
+ 		pPending = pReq->next;
+ 	    break;
+ 	}
+     if (pRequest->notifyFunc)
+ 	(*pRequest->notifyFunc) (pRequest->pClient, pRequest->closure);
+     xfree (pRequest);
+ }
+ 
+ static void
+ SertafiedBlockHandler (data, wt, LastSelectMask)
+     pointer	    data;		/* unused */
+     pointer	    wt;			/* wait time */
+     long	    *LastSelectMask;
+ {
+     SertafiedPtr	    pReq, pNext;
+     unsigned long	    newdelay, olddelay;
+     TimeStamp		    now;
+ 
+     if (!pPending)
+ 	return;
+     now.milliseconds = GetTimeInMillis ();
+     now.months = currentTime.months;
+     if ((int) (now.milliseconds - currentTime.milliseconds) < 0)
+ 	now.months++;
+     for (pReq = pPending; pReq; pReq = pNext)
+     {
+ 	pNext = pReq->next;
+ 	if (CompareTimeStamps (pReq->revive, now) == LATER)
+ 	    break;
+ 	FreeResource (pReq->id, RT_NONE);
+     }
+     pReq = pPending;
+     if (!pReq)
+ 	return;
+     newdelay = pReq->revive.milliseconds - now.milliseconds;
+     AdjustWaitForDelay (wt, newdelay);
+ }
+ 
+ static void
+ SertafiedWakeupHandler (data, i, LastSelectMask)
+     pointer	    data;
+     int		    i;
+     long	    *LastSelectMask;
+ {
+     SertafiedPtr	pReq, pNext;
+     TimeStamp		now;
+ 
+     now.milliseconds = GetTimeInMillis ();
+     now.months = currentTime.months;
+     if ((int) (now.milliseconds - currentTime.milliseconds) < 0)
+ 	now.months++;
+     for (pReq = pPending; pReq; pReq = pNext)
+     {
+ 	pNext = pReq->next;
+ 	if (CompareTimeStamps (pReq->revive, now) == LATER)
+ 	    break;
+ 	FreeResource (pReq->id, RT_NONE);
+     }
+     if (!pPending)
+     {
+ 	RemoveBlockAndWakeupHandlers (SertafiedBlockHandler,
+ 				      SertafiedWakeupHandler,
+ 				      (pointer) 0);
+ 	BlockHandlerRegistered = FALSE;
+     }
+ }
*** /dev/null	Wed Sep  9 17:02:52 1992
--- mit/extensions/server/xtest.c	Wed Sep  9 17:09:49 1992
***************
*** 0 ****
--- 1,358 ----
+ /* $XConsortium: xtest.c,v 1.12.1.1 92/09/09 17:08:16 rws Exp $ */
+ /*
+ 
+ Copyright 1992 by the Massachusetts Institute of Technology
+ 
+ Permission to use, copy, modify, distribute, and sell this software and its
+ documentation for any purpose is hereby granted without fee, provided that
+ the above copyright notice appear in all copies and that both that
+ copyright notice and this permission notice appear in supporting
+ documentation, and that the name of M.I.T. not be used in advertising or
+ publicity pertaining to distribution of the software without specific,
+ written prior permission.  M.I.T. makes no representations about the
+ suitability of this software for any purpose.  It is provided "as is"
+ without express or implied warranty.
+ 
+ */
+ 
+ #include "X.h"
+ #define NEED_EVENTS
+ #include "Xproto.h"
+ #include "misc.h"
+ #include "os.h"
+ #include "dixstruct.h"
+ #include "extnsionst.h"
+ #include "windowstr.h"
+ #include "inputstr.h"
+ #include "scrnintstr.h"
+ #define _XTEST_SERVER_
+ #include "XTest.h"
+ #include "xteststr.h"
+ 
+ static unsigned char XTestReqCode;
+ static int ProcXTestDispatch(), SProcXTestDispatch();
+ static void XTestResetProc();
+ static int XTestSwapFakeInput();
+ CursorPtr GetSpriteCursor();
+ WindowPtr GetCurrentRootWindow();
+ extern int screenIsSaved;
+ 
+ void
+ XTestExtensionInit()
+ {
+     ExtensionEntry *extEntry, *AddExtension();
+ 
+     if (extEntry = AddExtension(XTestExtensionName, 0, 0,
+ 				 ProcXTestDispatch, SProcXTestDispatch,
+ 				 XTestResetProc, StandardMinorOpcode))
+ 	XTestReqCode = (unsigned char)extEntry->base;
+ }
+ 
+ /*ARGSUSED*/
+ static void
+ XTestResetProc (extEntry)
+ ExtensionEntry	*extEntry;
+ {
+ }
+ 
+ static int
+ ProcXTestGetVersion(client)
+     register ClientPtr client;
+ {
+     REQUEST(xXTestGetVersionReq);
+     xXTestGetVersionReply rep;
+     register int n;
+ 
+     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
+     rep.type = X_Reply;
+     rep.length = 0;
+     rep.sequenceNumber = client->sequence;
+     rep.majorVersion = XTestMajorVersion;
+     rep.minorVersion = XTestMinorVersion;
+     if (client->swapped) {
+     	swaps(&rep.sequenceNumber, n);
+ 	swaps(&rep.minorVersion, n);
+     }
+     WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep);
+     return(client->noClientException);
+ }
+ 
+ static int
+ ProcXTestCompareCursor(client)
+     register ClientPtr client;
+ {
+     REQUEST(xXTestCompareCursorReq);
+     xXTestCompareCursorReply rep;
+     WindowPtr pWin;
+     CursorPtr pCursor;
+     register int n;
+ 
+     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
+     pWin = (WindowPtr)LookupWindow(stuff->window, client);
+     if (!pWin)
+         return(BadWindow);
+     if (stuff->cursor == None)
+ 	pCursor = NullCursor;
+     else if (stuff->cursor == XTestCurrentCursor)
+ 	pCursor = GetSpriteCursor();
+     else {
+ 	pCursor = (CursorPtr)LookupIDByType(stuff->cursor, RT_CURSOR);
+ 	if (!pCursor) 
+ 	{
+ 	    client->errorValue = stuff->cursor;
+ 	    return (BadCursor);
+ 	}
+     }
+     rep.type = X_Reply;
+     rep.length = 0;
+     rep.sequenceNumber = client->sequence;
+     rep.same = (wCursor(pWin) == pCursor);
+     if (client->swapped) {
+     	swaps(&rep.sequenceNumber, n);
+     }
+     WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep);
+     return(client->noClientException);
+ }
+ 
+ static int
+ ProcXTestFakeInput(client)
+     register ClientPtr client;
+ {
+     REQUEST(xReq);
+     int nev;
+     int	n;
+     xEvent *ev;
+     DeviceIntPtr dev;
+     WindowPtr root;
+ 
+     nev = (stuff->length << 2) - sizeof(xReq);
+     if (nev % sizeof(xEvent))
+ 	return BadLength;
+     nev /= sizeof(xEvent);
+     if (nev != 1)
+ 	return BadLength; /* for now */
+     UpdateCurrentTime();
+     ev = (xEvent *)&stuff[1];
+     switch (ev->u.u.type & 0177)
+     {
+     case KeyPress:
+     case KeyRelease:
+     case MotionNotify:
+     case ButtonPress:
+     case ButtonRelease:
+ 	break;
+     default:
+ 	client->errorValue = ev->u.u.type;
+ 	return BadValue;
+     }
+     if (ev->u.keyButtonPointer.time)
+     {
+ 	TimeStamp activateTime;
+ 	CARD32 ms;
+ 
+ 	activateTime = currentTime;
+ 	ms = activateTime.milliseconds + ev->u.keyButtonPointer.time;
+ 	if (ms < activateTime.milliseconds)
+ 	    activateTime.months++;
+ 	activateTime.milliseconds = ms;
+ 	ev->u.keyButtonPointer.time = 0;
+ 	/* swap the request back so we can simply re-execute it */
+ 	if (client->swapped)
+ 	{
+     	    (void) XTestSwapFakeInput(client, stuff);
+ 	    swaps(&stuff->length, n);
+ 	}
+ 	ResetCurrentRequest (client);
+ 	client->sequence--;
+ 	if (!ClientSleepUntil(client, &activateTime, NULL, NULL))
+ 	{
+ 	    /* 
+ 	     * flush this request - must be in this order because
+ 	     * ResetCurrentRequest adds the client back to 
+ 	     * clientsWithInput which will cause the client to
+ 	     * keep going, instead of waiting for the timeout.
+ 	     */
+ 	    (void) ReadRequestFromClient (client);
+ 	    client->sequence++;
+ 	    return BadAlloc;
+ 	}
+ 	return Success;
+     }
+     switch (ev->u.u.type & 0177)
+     {
+     case KeyPress:
+     case KeyRelease:
+ 	dev = (DeviceIntPtr)LookupKeyboardDevice();
+ 	if (ev->u.u.detail < dev->key->curKeySyms.minKeyCode ||
+ 	    ev->u.u.detail > dev->key->curKeySyms.maxKeyCode)
+ 	{
+ 	    client->errorValue = ev->u.u.detail;
+ 	    return BadValue;
+ 	}
+ 	break;
+     case MotionNotify:
+ 	dev = (DeviceIntPtr)LookupPointerDevice();
+ 	if (ev->u.keyButtonPointer.root == None)
+ 	    root = GetCurrentRootWindow();
+ 	else
+ 	{
+ 	    root = LookupWindow(ev->u.keyButtonPointer.root, client);
+ 	    if (!root)
+ 		return BadWindow;
+ 	    if (root->parent)
+ 	    {
+ 		client->errorValue = ev->u.keyButtonPointer.root;
+ 		return BadValue;
+ 	    }
+ 	}
+ 	if (ev->u.u.detail == xTrue)
+ 	{
+ 	    int x, y;
+ 	    GetSpritePosition(&x, &y);
+ 	    ev->u.keyButtonPointer.rootX += x;
+ 	    ev->u.keyButtonPointer.rootY += y;
+ 	}
+ 	else if (ev->u.u.detail != xFalse)
+ 	{
+ 	    client->errorValue = ev->u.u.detail;
+ 	    return BadValue;
+ 	}
+ 	if (ev->u.keyButtonPointer.rootX < 0)
+ 	    ev->u.keyButtonPointer.rootX = 0;
+ 	else if (ev->u.keyButtonPointer.rootX >= root->drawable.width)
+ 	    ev->u.keyButtonPointer.rootX = root->drawable.width - 1;
+ 	if (ev->u.keyButtonPointer.rootY < 0)
+ 	    ev->u.keyButtonPointer.rootY = 0;
+ 	else if (ev->u.keyButtonPointer.rootY >= root->drawable.height)
+ 	    ev->u.keyButtonPointer.rootY = root->drawable.height - 1;
+ 	if (root != GetCurrentRootWindow())
+ 	{
+ 	    NewCurrentScreen(root->drawable.pScreen,
+ 			     ev->u.keyButtonPointer.rootX,
+ 			     ev->u.keyButtonPointer.rootY);
+ 	    return client->noClientException;
+ 	}
+ 	(*root->drawable.pScreen->SetCursorPosition)
+ 	    (root->drawable.pScreen,
+ 	     ev->u.keyButtonPointer.rootX,
+ 	     ev->u.keyButtonPointer.rootY, FALSE);
+ 	break;
+     case ButtonPress:
+     case ButtonRelease:
+ 	dev = (DeviceIntPtr)LookupPointerDevice();
+ 	if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons)
+ 	{
+ 	    client->errorValue = ev->u.u.detail;
+ 	    return BadValue;
+ 	}
+ 	break;
+     }
+     if (screenIsSaved == SCREEN_SAVER_ON)
+ 	SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);
+     ev->u.keyButtonPointer.time = currentTime.milliseconds;
+     (*dev->public.processInputProc)(ev, (DevicePtr)dev, 1); 
+     return client->noClientException;
+ }
+ 
+ static int
+ ProcXTestDispatch (client)
+     register ClientPtr	client;
+ {
+     REQUEST(xReq);
+     switch (stuff->data)
+     {
+     case X_XTestGetVersion:
+ 	return ProcXTestGetVersion(client);
+     case X_XTestCompareCursor:
+ 	return ProcXTestCompareCursor(client);
+     case X_XTestFakeInput:
+ 	return ProcXTestFakeInput(client);
+     default:
+ 	return BadRequest;
+     }
+ }
+ 
+ static int
+ SProcXTestGetVersion(client)
+     register ClientPtr	client;
+ {
+     register int n;
+     REQUEST(xXTestGetVersionReq);
+ 
+     swaps(&stuff->length, n);
+     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
+     swaps(&stuff->minorVersion, n);
+     return ProcXTestGetVersion(client);
+ }
+ 
+ static int
+ SProcXTestCompareCursor(client)
+     register ClientPtr	client;
+ {
+     register int n;
+     REQUEST(xXTestCompareCursorReq);
+ 
+     swaps(&stuff->length, n);
+     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
+     swapl(&stuff->window, n);
+     swapl(&stuff->cursor, n);
+     return ProcXTestCompareCursor(client);
+ }
+ 
+ static int
+ XTestSwapFakeInput(client, req)
+     register ClientPtr	client;
+     xReq *req;
+ {
+     register int nev;
+     register xEvent *ev;
+     xEvent sev;
+     void (*proc)(), NotImplemented();
+ 
+     nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent);
+     for (ev = (xEvent *)&req[1]; --nev >= 0; ev++)
+     {
+     	/* Swap event */
+     	proc = EventSwapVector[ev->u.u.type & 0177];
+ 	/* no swapping proc; invalid event type? */
+     	if (!proc || (int (*)()) proc == (int (*)()) NotImplemented) {
+ 	    client->errorValue = ev->u.u.type;
+ 	    return BadValue;
+ 	}
+     	(*proc)(ev, &sev);
+ 	*ev = sev;
+     }
+     return Success;
+ }
+ 
+ static int
+ SProcXTestFakeInput(client)
+     register ClientPtr	client;
+ {
+     register int n;
+     REQUEST(xReq);
+ 
+     swaps(&stuff->length, n);
+     n = XTestSwapFakeInput(client, stuff);
+     if (n != Success)
+ 	return n;
+     return ProcXTestFakeInput(client);
+ }
+ 
+ static int
+ SProcXTestDispatch (client)
+     register ClientPtr	client;
+ {
+     REQUEST(xReq);
+     switch (stuff->data)
+     {
+     case X_XTestGetVersion:
+ 	return SProcXTestGetVersion(client);
+     case X_XTestCompareCursor:
+ 	return SProcXTestCompareCursor(client);
+     case X_XTestFakeInput:
+ 	return SProcXTestFakeInput(client);
+     default:
+ 	return BadRequest;
+     }
+ }
*** /tmp/,RCSt1016604	Wed Sep  9 15:47:54 1992
--- mit/server/ddx/mi/miinitext.c	Wed Sep  9 15:47:56 1992
***************
*** 21,27 ****
  SOFTWARE.
  
  ******************************************************************/
! /* $XConsortium: miinitext.c,v 1.15 90/08/15 08:42:23 rws Exp $ */
  
  #ifdef BEZIER
  extern void BezierExtensionInit();
--- 21,27 ----
  SOFTWARE.
  
  ******************************************************************/
! /* $XConsortium: miinitext.c,v 1.15.1.1 92/09/09 15:34:45 rws Exp $ */
  
  #ifdef BEZIER
  extern void BezierExtensionInit();
***************
*** 44,49 ****
--- 44,52 ----
  #ifdef XINPUT
  extern void XInputExtensionInit();
  #endif
+ #ifdef XTEST
+ extern void XTestExtensionInit();
+ #endif
  #ifdef MITMISC
  extern void MITMiscExtensionInit();
  #endif
***************
*** 77,82 ****
--- 80,88 ----
  #endif
  #ifdef XINPUT
      XInputExtensionInit();
+ #endif
+ #ifdef XTEST
+     XTestExtensionInit();
  #endif
  #ifdef MITMISC
      MITMiscExtensionInit();
