libX11 pixman mesa xserver git update 27 sep 2011

6 files changed, 2623 insertions, 2615 deletions

diff --git a/xorg-server/mi/mi.h b/xorg-server/mi/mi.h
index ea5424823..24d1af911 100644
--- a/xorg-server/mi/mi.h
+++ b/xorg-server/mi/mi.h
@@ -1,599 +1,599 @@
-/***********************************************************

-

-Copyright 1987, 1998  The Open Group

-

-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.

-

-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 THE

-OPEN GROUP 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 The Open Group shall not be

-used in advertising or otherwise to promote the sale, use or other dealings

-in this Software without prior written authorization from The Open Group.

-

-

-Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.

-

-                        All Rights Reserved

-

-Permission to use, copy, modify, and distribute this software and its 

-documentation for any purpose and without fee is hereby granted, 

-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 Digital not be

-used in advertising or publicity pertaining to distribution of the

-software without specific, written prior permission.  

-

-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

-DIGITAL 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.

-

-******************************************************************/

-

-#ifndef MI_H

-#define MI_H

-#include <X11/X.h>

-#include "region.h"

-#include "validate.h"

-#include "window.h"

-#include "gc.h"

-#include <X11/fonts/font.h>

-#include "input.h"

-#include "cursor.h"

-#include "privates.h"

-#include "colormap.h"

-#include "events.h"

-

-#define MiBits	CARD32

-

-typedef struct _miDash *miDashPtr;

-#define EVEN_DASH	0

-#define ODD_DASH	~0

-

-/* miarc.c */

-

-extern _X_EXPORT void miPolyArc(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*narcs*/,

-    xArc * /*parcs*/

-);

-

-/* mibitblt.c */

-

-extern _X_EXPORT RegionPtr miCopyArea(

-    DrawablePtr /*pSrcDrawable*/,

-    DrawablePtr /*pDstDrawable*/,

-    GCPtr /*pGC*/,

-    int /*xIn*/,

-    int /*yIn*/,

-    int /*widthSrc*/,

-    int /*heightSrc*/,

-    int /*xOut*/,

-    int /*yOut*/

-);

-

-extern _X_EXPORT RegionPtr miCopyPlane(

-    DrawablePtr /*pSrcDrawable*/,

-    DrawablePtr /*pDstDrawable*/,

-    GCPtr /*pGC*/,

-    int /*srcx*/,

-    int /*srcy*/,

-    int /*width*/,

-    int /*height*/,

-    int /*dstx*/,

-    int /*dsty*/,

-    unsigned long /*bitPlane*/

-);

-

-extern _X_EXPORT void miGetImage(

-    DrawablePtr /*pDraw*/,

-    int /*sx*/,

-    int /*sy*/,

-    int /*w*/,

-    int /*h*/,

-    unsigned int /*format*/,

-    unsigned long /*planeMask*/,

-    char * /*pdstLine*/

-);

-

-extern _X_EXPORT void miPutImage(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*depth*/,

-    int /*x*/,

-    int /*y*/,

-    int /*w*/,

-    int /*h*/,

-    int /*leftPad*/,

-    int /*format*/,

-    char * /*pImage*/

-);

-

-/* micopy.c  */

-

-#define miGetCompositeClip(pGC) ((pGC)->pCompositeClip)

-

-typedef void	(*miCopyProc) (DrawablePtr  pSrcDrawable,

-			       DrawablePtr  pDstDrawable,

-			       GCPtr	    pGC,

-			       BoxPtr	    pDstBox,

-			       int	    nbox,

-			       int	    dx,

-			       int	    dy,

-			       Bool	    reverse,

-			       Bool	    upsidedown,

-			       Pixel	    bitplane,

-			       void	    *closure);

-

-extern _X_EXPORT void

-miCopyRegion (DrawablePtr   pSrcDrawable,

-	      DrawablePtr   pDstDrawable,

-	      GCPtr	    pGC,

-	      RegionPtr	    pDstRegion,

-	      int	    dx,

-	      int	    dy,

-	      miCopyProc    copyProc,

-	      Pixel	    bitPlane,

-	      void	    *closure);

-

-extern _X_EXPORT RegionPtr

-miDoCopy (DrawablePtr	pSrcDrawable,

-	  DrawablePtr	pDstDrawable,

-	  GCPtr		pGC,

-	  int		xIn, 

-	  int		yIn,

-	  int		widthSrc, 

-	  int		heightSrc,

-	  int		xOut, 

-	  int		yOut,

-	  miCopyProc	copyProc,

-	  Pixel		bitplane,

-	  void		*closure);

-

-/* micursor.c */

-

-extern _X_EXPORT void miRecolorCursor(

-    DeviceIntPtr /* pDev */,

-    ScreenPtr /*pScr*/,

-    CursorPtr /*pCurs*/,

-    Bool /*displayed*/

-);

-

-/* midash.c */

-

-extern _X_EXPORT void miStepDash(

-    int /*dist*/,

-    int * /*pDashIndex*/,

-    unsigned char * /*pDash*/,

-    int /*numInDashList*/,

-    int * /*pDashOffset*/

-);

-

-/* mieq.c */

-

-

-#ifndef INPUT_H

-typedef struct _DeviceRec *DevicePtr;

-#endif

-

-extern _X_EXPORT Bool mieqInit(

-    void

-);

-

-extern _X_EXPORT void mieqFini(void);

-

-extern _X_EXPORT void mieqEnqueue(

-    DeviceIntPtr /*pDev*/,

-    InternalEvent* /*e*/

-);

-

-extern _X_EXPORT void mieqSwitchScreen(

-    DeviceIntPtr /* pDev */,

-    ScreenPtr /*pScreen*/,

-    Bool /*fromDIX*/

-);

-

-extern _X_EXPORT void mieqProcessDeviceEvent(

-    DeviceIntPtr /* dev*/,

-    InternalEvent* /* event */,

-    ScreenPtr /* screen*/

-);

-

-extern _X_EXPORT void mieqProcessInputEvents(

-    void

-);

-

-extern DeviceIntPtr CopyGetMasterEvent(

-    DeviceIntPtr /* sdev */,

-    InternalEvent* /* original */,

-    InternalEvent* /* copy */

-);

-

-/**

- * Custom input event handler. If you need to process input events in some

- * other way than the default path, register an input event handler for the

- * given internal event type.

- */

-typedef void (*mieqHandler)(int screen, InternalEvent* event, DeviceIntPtr dev);

-void _X_EXPORT mieqSetHandler(int event, mieqHandler handler);

-

-/* miexpose.c */

-

-extern _X_EXPORT RegionPtr miHandleExposures(

-    DrawablePtr /*pSrcDrawable*/,

-    DrawablePtr /*pDstDrawable*/,

-    GCPtr /*pGC*/,

-    int /*srcx*/,

-    int /*srcy*/,

-    int /*width*/,

-    int /*height*/,

-    int /*dstx*/,

-    int /*dsty*/,

-    unsigned long /*plane*/

-);

-

-extern _X_EXPORT void miSendGraphicsExpose(

-    ClientPtr /*client*/,

-    RegionPtr /*pRgn*/,

-    XID /*drawable*/,

-    int /*major*/,

-    int /*minor*/

-);

-

-extern _X_EXPORT void miSendExposures(

-    WindowPtr /*pWin*/,

-    RegionPtr /*pRgn*/,

-    int /*dx*/,

-    int /*dy*/

-);

-

-extern _X_EXPORT void miWindowExposures(

-    WindowPtr /*pWin*/,

-    RegionPtr /*prgn*/,

-    RegionPtr /*other_exposed*/

-);

-

-extern _X_EXPORT void miPaintWindow(

-    WindowPtr /*pWin*/,

-    RegionPtr /*prgn*/,

-    int /*what*/

-);

-

-extern _X_EXPORT void miClearDrawable(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/

-);

-

-/* mifillrct.c */

-

-extern _X_EXPORT void miPolyFillRect(

-    DrawablePtr /*pDrawable*/,

-    GCPtr /*pGC*/,

-    int /*nrectFill*/,

-    xRectangle * /*prectInit*/

-);

-

-/* miglblt.c */

-

-extern _X_EXPORT void miPolyGlyphBlt(

-    DrawablePtr /*pDrawable*/,

-    GCPtr /*pGC*/,

-    int /*x*/,

-    int /*y*/,

-    unsigned int /*nglyph*/,

-    CharInfoPtr * /*ppci*/,

-    pointer /*pglyphBase*/

-);

-

-extern _X_EXPORT void miImageGlyphBlt(

-    DrawablePtr /*pDrawable*/,

-    GCPtr /*pGC*/,

-    int /*x*/,

-    int /*y*/,

-    unsigned int /*nglyph*/,

-    CharInfoPtr * /*ppci*/,

-    pointer /*pglyphBase*/

-);

-

-/* mipoly.c */

-

-extern _X_EXPORT void miFillPolygon(

-    DrawablePtr /*dst*/,

-    GCPtr /*pgc*/,

-    int /*shape*/,

-    int /*mode*/,

-    int /*count*/,

-    DDXPointPtr /*pPts*/

-);

-

-/* mipolycon.c */

-

-extern _X_EXPORT Bool miFillConvexPoly(

-    DrawablePtr /*dst*/,

-    GCPtr /*pgc*/,

-    int /*count*/,

-    DDXPointPtr /*ptsIn*/

-);

-

-/* mipolygen.c */

-

-extern _X_EXPORT Bool miFillGeneralPoly(

-    DrawablePtr /*dst*/,

-    GCPtr /*pgc*/,

-    int /*count*/,

-    DDXPointPtr /*ptsIn*/

-);

-

-/* mipolypnt.c */

-

-extern _X_EXPORT void miPolyPoint(

-    DrawablePtr /*pDrawable*/,

-    GCPtr /*pGC*/,

-    int /*mode*/,

-    int /*npt*/,

-    xPoint * /*pptInit*/

-);

-

-/* mipolyrect.c */

-

-extern _X_EXPORT void miPolyRectangle(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*nrects*/,

-    xRectangle * /*pRects*/

-);

-

-/* mipolyseg.c */

-

-extern _X_EXPORT void miPolySegment(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*nseg*/,

-    xSegment * /*pSegs*/

-);

-

-/* mipolytext.c */

-

-extern _X_EXPORT int miPolyText8(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*x*/,

-    int /*y*/,

-    int /*count*/,

-    char * /*chars*/

-);

-

-extern _X_EXPORT int miPolyText16(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*x*/,

-    int /*y*/,

-    int /*count*/,

-    unsigned short * /*chars*/

-);

-

-extern _X_EXPORT void miImageText8(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*x*/,

-    int /*y*/,

-    int /*count*/,

-    char * /*chars*/

-);

-

-extern _X_EXPORT void miImageText16(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*x*/,

-    int /*y*/,

-    int /*count*/,

-    unsigned short * /*chars*/

-);

-

-/* mipushpxl.c */

-

-extern _X_EXPORT void miPushPixels(

-    GCPtr /*pGC*/,

-    PixmapPtr /*pBitMap*/,

-    DrawablePtr /*pDrawable*/,

-    int /*dx*/,

-    int /*dy*/,

-    int /*xOrg*/,

-    int /*yOrg*/

-);

-

-/* miscrinit.c */

-

-extern _X_EXPORT Bool miModifyPixmapHeader(

-    PixmapPtr /*pPixmap*/,

-    int /*width*/,

-    int /*height*/,

-    int /*depth*/,

-    int /*bitsPerPixel*/,

-    int /*devKind*/,

-    pointer /*pPixData*/

-);

-

-extern _X_EXPORT Bool miCreateScreenResources(

-    ScreenPtr /*pScreen*/

-);

-

-extern _X_EXPORT Bool miScreenDevPrivateInit(

-    ScreenPtr /*pScreen*/,

-    int /*width*/,

-    pointer /*pbits*/

-);

-

-extern _X_EXPORT Bool miScreenInit(

-    ScreenPtr /*pScreen*/,

-    pointer /*pbits*/,

-    int /*xsize*/,

-    int /*ysize*/,

-    int /*dpix*/,

-    int /*dpiy*/,

-    int /*width*/,

-    int /*rootDepth*/,

-    int /*numDepths*/,

-    DepthPtr /*depths*/,

-    VisualID /*rootVisual*/,

-    int /*numVisuals*/,

-    VisualPtr /*visuals*/

-);

-

-/* mivaltree.c */

-

-extern _X_EXPORT int miShapedWindowIn(

-    RegionPtr /*universe*/,

-    RegionPtr /*bounding*/,

-    BoxPtr /*rect*/,

-    int /*x*/,

-    int /*y*/

-);

-

-typedef void 

-(*SetRedirectBorderClipProcPtr) (WindowPtr pWindow, RegionPtr pRegion);

-

-typedef RegionPtr

-(*GetRedirectBorderClipProcPtr) (WindowPtr pWindow);

-

-extern _X_EXPORT void

-miRegisterRedirectBorderClipProc (SetRedirectBorderClipProcPtr setBorderClip,

-				  GetRedirectBorderClipProcPtr getBorderClip);

-

-extern _X_EXPORT int miValidateTree(

-    WindowPtr /*pParent*/,

-    WindowPtr /*pChild*/,

-    VTKind /*kind*/

-);

-

-extern _X_EXPORT void miWideLine(

-    DrawablePtr /*pDrawable*/,

-    GCPtr /*pGC*/,

-    int /*mode*/,

-    int /*npt*/,

-    DDXPointPtr /*pPts*/

-);

-

-extern _X_EXPORT void miWideDash(

-    DrawablePtr /*pDrawable*/,

-    GCPtr /*pGC*/,

-    int /*mode*/,

-    int /*npt*/,

-    DDXPointPtr /*pPts*/

-);

-

-/* miwindow.c */

-

-extern _X_EXPORT void miClearToBackground(

-    WindowPtr /*pWin*/,

-    int /*x*/,

-    int /*y*/,

-    int /*w*/,

-    int /*h*/,

-    Bool /*generateExposures*/

-);

-

-extern _X_EXPORT void miMarkWindow(

-    WindowPtr /*pWin*/

-);

-

-extern _X_EXPORT Bool miMarkOverlappedWindows(

-    WindowPtr /*pWin*/,

-    WindowPtr /*pFirst*/,

-    WindowPtr * /*ppLayerWin*/

-);

-

-extern _X_EXPORT void miHandleValidateExposures(

-    WindowPtr /*pWin*/

-);

-

-extern _X_EXPORT void miMoveWindow(

-    WindowPtr /*pWin*/,

-    int /*x*/,

-    int /*y*/,

-    WindowPtr /*pNextSib*/,

-    VTKind /*kind*/

-);

-

-extern _X_EXPORT void miSlideAndSizeWindow(

-    WindowPtr /*pWin*/,

-    int /*x*/,

-    int /*y*/,

-    unsigned int /*w*/,

-    unsigned int /*h*/,

-    WindowPtr /*pSib*/

-);

-

-extern _X_EXPORT WindowPtr miGetLayerWindow(

-    WindowPtr /*pWin*/

-);

-

-extern _X_EXPORT void miSetShape(

-    WindowPtr /*pWin*/,

-    int /*kind*/

-);

-

-extern _X_EXPORT void miChangeBorderWidth(

-    WindowPtr /*pWin*/,

-    unsigned int /*width*/

-);

-

-extern _X_EXPORT void miMarkUnrealizedWindow(

-    WindowPtr /*pChild*/,

-    WindowPtr /*pWin*/,

-    Bool /*fromConfigure*/

-);

-

-extern _X_EXPORT void miSegregateChildren(WindowPtr pWin, RegionPtr pReg, int depth);

-

-/* mizerarc.c */

-

-extern _X_EXPORT void miZeroPolyArc(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*narcs*/,

-    xArc * /*parcs*/

-);

-

-/* mizerline.c */

-

-extern _X_EXPORT void miZeroLine(

-    DrawablePtr /*dst*/,

-    GCPtr /*pgc*/,

-    int /*mode*/,

-    int /*nptInit*/,

-    DDXPointRec * /*pptInit*/

-);

-

-extern _X_EXPORT void miZeroDashLine(

-    DrawablePtr /*dst*/,

-    GCPtr /*pgc*/,

-    int /*mode*/,

-    int /*nptInit*/,

-    DDXPointRec * /*pptInit*/

-);

-

-extern _X_EXPORT void miPolyFillArc(

-    DrawablePtr /*pDraw*/,

-    GCPtr /*pGC*/,

-    int /*narcs*/,

-    xArc * /*parcs*/

-);

-

-#endif /* MI_H */

+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+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.
+
+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 THE
+OPEN GROUP 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 The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+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 Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL 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.
+
+******************************************************************/
+
+#ifndef MI_H
+#define MI_H
+#include <X11/X.h>
+#include "region.h"
+#include "validate.h"
+#include "window.h"
+#include "gc.h"
+#include <X11/fonts/font.h>
+#include "input.h"
+#include "cursor.h"
+#include "privates.h"
+#include "colormap.h"
+#include "events.h"
+
+#define MiBits	CARD32
+
+typedef struct _miDash *miDashPtr;
+#define EVEN_DASH	0
+#define ODD_DASH	~0
+
+/* miarc.c */
+
+extern _X_EXPORT void miPolyArc(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+);
+
+/* mibitblt.c */
+
+extern _X_EXPORT RegionPtr miCopyArea(
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    GCPtr /*pGC*/,
+    int /*xIn*/,
+    int /*yIn*/,
+    int /*widthSrc*/,
+    int /*heightSrc*/,
+    int /*xOut*/,
+    int /*yOut*/
+);
+
+extern _X_EXPORT RegionPtr miCopyPlane(
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    GCPtr /*pGC*/,
+    int /*srcx*/,
+    int /*srcy*/,
+    int /*width*/,
+    int /*height*/,
+    int /*dstx*/,
+    int /*dsty*/,
+    unsigned long /*bitPlane*/
+);
+
+extern _X_EXPORT void miGetImage(
+    DrawablePtr /*pDraw*/,
+    int /*sx*/,
+    int /*sy*/,
+    int /*w*/,
+    int /*h*/,
+    unsigned int /*format*/,
+    unsigned long /*planeMask*/,
+    char * /*pdstLine*/
+);
+
+extern _X_EXPORT void miPutImage(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*depth*/,
+    int /*x*/,
+    int /*y*/,
+    int /*w*/,
+    int /*h*/,
+    int /*leftPad*/,
+    int /*format*/,
+    char * /*pImage*/
+);
+
+/* micopy.c  */
+
+#define miGetCompositeClip(pGC) ((pGC)->pCompositeClip)
+
+typedef void	(*miCopyProc) (DrawablePtr  pSrcDrawable,
+			       DrawablePtr  pDstDrawable,
+			       GCPtr	    pGC,
+			       BoxPtr	    pDstBox,
+			       int	    nbox,
+			       int	    dx,
+			       int	    dy,
+			       Bool	    reverse,
+			       Bool	    upsidedown,
+			       Pixel	    bitplane,
+			       void	    *closure);
+
+extern _X_EXPORT void
+miCopyRegion (DrawablePtr   pSrcDrawable,
+	      DrawablePtr   pDstDrawable,
+	      GCPtr	    pGC,
+	      RegionPtr	    pDstRegion,
+	      int	    dx,
+	      int	    dy,
+	      miCopyProc    copyProc,
+	      Pixel	    bitPlane,
+	      void	    *closure);
+
+extern _X_EXPORT RegionPtr
+miDoCopy (DrawablePtr	pSrcDrawable,
+	  DrawablePtr	pDstDrawable,
+	  GCPtr		pGC,
+	  int		xIn, 
+	  int		yIn,
+	  int		widthSrc, 
+	  int		heightSrc,
+	  int		xOut, 
+	  int		yOut,
+	  miCopyProc	copyProc,
+	  Pixel		bitplane,
+	  void		*closure);
+
+/* micursor.c */
+
+extern _X_EXPORT void miRecolorCursor(
+    DeviceIntPtr /* pDev */,
+    ScreenPtr /*pScr*/,
+    CursorPtr /*pCurs*/,
+    Bool /*displayed*/
+);
+
+/* midash.c */
+
+extern _X_EXPORT void miStepDash(
+    int /*dist*/,
+    int * /*pDashIndex*/,
+    unsigned char * /*pDash*/,
+    int /*numInDashList*/,
+    int * /*pDashOffset*/
+);
+
+/* mieq.c */
+
+
+#ifndef INPUT_H
+typedef struct _DeviceRec *DevicePtr;
+#endif
+
+extern _X_EXPORT Bool mieqInit(
+    void
+);
+
+extern _X_EXPORT void mieqFini(void);
+
+extern _X_EXPORT void mieqEnqueue(
+    DeviceIntPtr /*pDev*/,
+    InternalEvent* /*e*/
+);
+
+extern _X_EXPORT void mieqSwitchScreen(
+    DeviceIntPtr /* pDev */,
+    ScreenPtr /*pScreen*/,
+    Bool /*set_dequeue_screen*/
+);
+
+extern _X_EXPORT void mieqProcessDeviceEvent(
+    DeviceIntPtr /* dev*/,
+    InternalEvent* /* event */,
+    ScreenPtr /* screen*/
+);
+
+extern _X_EXPORT void mieqProcessInputEvents(
+    void
+);
+
+extern DeviceIntPtr CopyGetMasterEvent(
+    DeviceIntPtr /* sdev */,
+    InternalEvent* /* original */,
+    InternalEvent* /* copy */
+);
+
+/**
+ * Custom input event handler. If you need to process input events in some
+ * other way than the default path, register an input event handler for the
+ * given internal event type.
+ */
+typedef void (*mieqHandler)(int screen, InternalEvent* event, DeviceIntPtr dev);
+void _X_EXPORT mieqSetHandler(int event, mieqHandler handler);
+
+/* miexpose.c */
+
+extern _X_EXPORT RegionPtr miHandleExposures(
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    GCPtr /*pGC*/,
+    int /*srcx*/,
+    int /*srcy*/,
+    int /*width*/,
+    int /*height*/,
+    int /*dstx*/,
+    int /*dsty*/,
+    unsigned long /*plane*/
+);
+
+extern _X_EXPORT void miSendGraphicsExpose(
+    ClientPtr /*client*/,
+    RegionPtr /*pRgn*/,
+    XID /*drawable*/,
+    int /*major*/,
+    int /*minor*/
+);
+
+extern _X_EXPORT void miSendExposures(
+    WindowPtr /*pWin*/,
+    RegionPtr /*pRgn*/,
+    int /*dx*/,
+    int /*dy*/
+);
+
+extern _X_EXPORT void miWindowExposures(
+    WindowPtr /*pWin*/,
+    RegionPtr /*prgn*/,
+    RegionPtr /*other_exposed*/
+);
+
+extern _X_EXPORT void miPaintWindow(
+    WindowPtr /*pWin*/,
+    RegionPtr /*prgn*/,
+    int /*what*/
+);
+
+extern _X_EXPORT void miClearDrawable(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/
+);
+
+/* mifillrct.c */
+
+extern _X_EXPORT void miPolyFillRect(
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nrectFill*/,
+    xRectangle * /*prectInit*/
+);
+
+/* miglblt.c */
+
+extern _X_EXPORT void miPolyGlyphBlt(
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    unsigned int /*nglyph*/,
+    CharInfoPtr * /*ppci*/,
+    pointer /*pglyphBase*/
+);
+
+extern _X_EXPORT void miImageGlyphBlt(
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    unsigned int /*nglyph*/,
+    CharInfoPtr * /*ppci*/,
+    pointer /*pglyphBase*/
+);
+
+/* mipoly.c */
+
+extern _X_EXPORT void miFillPolygon(
+    DrawablePtr /*dst*/,
+    GCPtr /*pgc*/,
+    int /*shape*/,
+    int /*mode*/,
+    int /*count*/,
+    DDXPointPtr /*pPts*/
+);
+
+/* mipolycon.c */
+
+extern _X_EXPORT Bool miFillConvexPoly(
+    DrawablePtr /*dst*/,
+    GCPtr /*pgc*/,
+    int /*count*/,
+    DDXPointPtr /*ptsIn*/
+);
+
+/* mipolygen.c */
+
+extern _X_EXPORT Bool miFillGeneralPoly(
+    DrawablePtr /*dst*/,
+    GCPtr /*pgc*/,
+    int /*count*/,
+    DDXPointPtr /*ptsIn*/
+);
+
+/* mipolypnt.c */
+
+extern _X_EXPORT void miPolyPoint(
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    xPoint * /*pptInit*/
+);
+
+/* mipolyrect.c */
+
+extern _X_EXPORT void miPolyRectangle(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*nrects*/,
+    xRectangle * /*pRects*/
+);
+
+/* mipolyseg.c */
+
+extern _X_EXPORT void miPolySegment(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSegs*/
+);
+
+/* mipolytext.c */
+
+extern _X_EXPORT int miPolyText8(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    int /*count*/,
+    char * /*chars*/
+);
+
+extern _X_EXPORT int miPolyText16(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    int /*count*/,
+    unsigned short * /*chars*/
+);
+
+extern _X_EXPORT void miImageText8(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    int /*count*/,
+    char * /*chars*/
+);
+
+extern _X_EXPORT void miImageText16(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    int /*count*/,
+    unsigned short * /*chars*/
+);
+
+/* mipushpxl.c */
+
+extern _X_EXPORT void miPushPixels(
+    GCPtr /*pGC*/,
+    PixmapPtr /*pBitMap*/,
+    DrawablePtr /*pDrawable*/,
+    int /*dx*/,
+    int /*dy*/,
+    int /*xOrg*/,
+    int /*yOrg*/
+);
+
+/* miscrinit.c */
+
+extern _X_EXPORT Bool miModifyPixmapHeader(
+    PixmapPtr /*pPixmap*/,
+    int /*width*/,
+    int /*height*/,
+    int /*depth*/,
+    int /*bitsPerPixel*/,
+    int /*devKind*/,
+    pointer /*pPixData*/
+);
+
+extern _X_EXPORT Bool miCreateScreenResources(
+    ScreenPtr /*pScreen*/
+);
+
+extern _X_EXPORT Bool miScreenDevPrivateInit(
+    ScreenPtr /*pScreen*/,
+    int /*width*/,
+    pointer /*pbits*/
+);
+
+extern _X_EXPORT Bool miScreenInit(
+    ScreenPtr /*pScreen*/,
+    pointer /*pbits*/,
+    int /*xsize*/,
+    int /*ysize*/,
+    int /*dpix*/,
+    int /*dpiy*/,
+    int /*width*/,
+    int /*rootDepth*/,
+    int /*numDepths*/,
+    DepthPtr /*depths*/,
+    VisualID /*rootVisual*/,
+    int /*numVisuals*/,
+    VisualPtr /*visuals*/
+);
+
+/* mivaltree.c */
+
+extern _X_EXPORT int miShapedWindowIn(
+    RegionPtr /*universe*/,
+    RegionPtr /*bounding*/,
+    BoxPtr /*rect*/,
+    int /*x*/,
+    int /*y*/
+);
+
+typedef void 
+(*SetRedirectBorderClipProcPtr) (WindowPtr pWindow, RegionPtr pRegion);
+
+typedef RegionPtr
+(*GetRedirectBorderClipProcPtr) (WindowPtr pWindow);
+
+extern _X_EXPORT void
+miRegisterRedirectBorderClipProc (SetRedirectBorderClipProcPtr setBorderClip,
+				  GetRedirectBorderClipProcPtr getBorderClip);
+
+extern _X_EXPORT int miValidateTree(
+    WindowPtr /*pParent*/,
+    WindowPtr /*pChild*/,
+    VTKind /*kind*/
+);
+
+extern _X_EXPORT void miWideLine(
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pPts*/
+);
+
+extern _X_EXPORT void miWideDash(
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pPts*/
+);
+
+/* miwindow.c */
+
+extern _X_EXPORT void miClearToBackground(
+    WindowPtr /*pWin*/,
+    int /*x*/,
+    int /*y*/,
+    int /*w*/,
+    int /*h*/,
+    Bool /*generateExposures*/
+);
+
+extern _X_EXPORT void miMarkWindow(
+    WindowPtr /*pWin*/
+);
+
+extern _X_EXPORT Bool miMarkOverlappedWindows(
+    WindowPtr /*pWin*/,
+    WindowPtr /*pFirst*/,
+    WindowPtr * /*ppLayerWin*/
+);
+
+extern _X_EXPORT void miHandleValidateExposures(
+    WindowPtr /*pWin*/
+);
+
+extern _X_EXPORT void miMoveWindow(
+    WindowPtr /*pWin*/,
+    int /*x*/,
+    int /*y*/,
+    WindowPtr /*pNextSib*/,
+    VTKind /*kind*/
+);
+
+extern _X_EXPORT void miSlideAndSizeWindow(
+    WindowPtr /*pWin*/,
+    int /*x*/,
+    int /*y*/,
+    unsigned int /*w*/,
+    unsigned int /*h*/,
+    WindowPtr /*pSib*/
+);
+
+extern _X_EXPORT WindowPtr miGetLayerWindow(
+    WindowPtr /*pWin*/
+);
+
+extern _X_EXPORT void miSetShape(
+    WindowPtr /*pWin*/,
+    int /*kind*/
+);
+
+extern _X_EXPORT void miChangeBorderWidth(
+    WindowPtr /*pWin*/,
+    unsigned int /*width*/
+);
+
+extern _X_EXPORT void miMarkUnrealizedWindow(
+    WindowPtr /*pChild*/,
+    WindowPtr /*pWin*/,
+    Bool /*fromConfigure*/
+);
+
+extern _X_EXPORT void miSegregateChildren(WindowPtr pWin, RegionPtr pReg, int depth);
+
+/* mizerarc.c */
+
+extern _X_EXPORT void miZeroPolyArc(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+);
+
+/* mizerline.c */
+
+extern _X_EXPORT void miZeroLine(
+    DrawablePtr /*dst*/,
+    GCPtr /*pgc*/,
+    int /*mode*/,
+    int /*nptInit*/,
+    DDXPointRec * /*pptInit*/
+);
+
+extern _X_EXPORT void miZeroDashLine(
+    DrawablePtr /*dst*/,
+    GCPtr /*pgc*/,
+    int /*mode*/,
+    int /*nptInit*/,
+    DDXPointRec * /*pptInit*/
+);
+
+extern _X_EXPORT void miPolyFillArc(
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+);
+
+#endif /* MI_H */
diff --git a/xorg-server/mi/mieq.c b/xorg-server/mi/mieq.c
index fc3738a41..b75bde9de 100644
--- a/xorg-server/mi/mieq.c
+++ b/xorg-server/mi/mieq.c
@@ -209,14 +209,29 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
 #endif
 }
 
+/**
+ * Changes the screen reference events are being enqueued from.
+ * Input events are enqueued with a screen reference and dequeued and
+ * processed with a (potentially different) screen reference.
+ * This function is called whenever a new event has changed screen but is
+ * still logically on the previous screen as seen by the client.
+ * This usually happens whenever the visible cursor moves across screen
+ * boundaries during event generation, before the same event is processed
+ * and sent down the wire.
+ *
+ * @param pDev The device that triggered a screen change.
+ * @param pScreen The new screen events are being enqueued for.
+ * @param set_dequeue_screen If TRUE, pScreen is set as both enqueue screen
+ * and dequeue screen.
+ */
 void
-mieqSwitchScreen(DeviceIntPtr pDev, ScreenPtr pScreen, Bool fromDIX)
+mieqSwitchScreen(DeviceIntPtr pDev, ScreenPtr pScreen, Bool set_dequeue_screen)
 {
 #ifdef XQUARTZ
     pthread_mutex_lock(&miEventQueueMutex);
 #endif
     EnqueueScreen(pDev) = pScreen;
-    if (fromDIX)
+    if (set_dequeue_screen)
         DequeueScreen(pDev) = pScreen;
 #ifdef XQUARTZ
     pthread_mutex_unlock(&miEventQueueMutex);
diff --git a/xorg-server/mi/mipointer.c b/xorg-server/mi/mipointer.c
index 7680ca19b..670f63b6e 100644
--- a/xorg-server/mi/mipointer.c
+++ b/xorg-server/mi/mipointer.c
@@ -569,9 +569,9 @@ miPointerMoveNoEvent (DeviceIntPtr pDev, ScreenPtr pScreen,
  *
  * @param pDev The device to move
  * @param mode Movement mode (Absolute or Relative)
- * @param[in,out] x The x coordiante in screen coordinates (in regards to total
+ * @param[in,out] x The x coordinate in screen coordinates (in regards to total
  * desktop size)
- * @param[in,out] y The y coordiante in screen coordinates (in regards to total
+ * @param[in,out] y The y coordinate in screen coordinates (in regards to total
  * desktop size)
  */
 void
@@ -603,7 +603,7 @@ miPointerSetPosition(DeviceIntPtr pDev, int mode, int *x, int *y)
 		pScreen = newScreen;
 		(*pScreenPriv->screenFuncs->NewEventScreen) (pDev, pScreen,
 							     FALSE);
-	    	/* Smash the confine to the new screen */
+		/* Smash the confine to the new screen */
                 pPointer->limits.x2 = pScreen->width;
                 pPointer->limits.y2 = pScreen->height;
 	    }
@@ -622,8 +622,8 @@ miPointerSetPosition(DeviceIntPtr pDev, int mode, int *x, int *y)
     if (pScreen->ConstrainCursorHarder)
        pScreen->ConstrainCursorHarder(pDev, pScreen, mode, x, y);
 
-    if (pPointer->x == *x && pPointer->y == *y && 
-            pPointer->pScreen == pScreen) 
+    if (pPointer->x == *x && pPointer->y == *y &&
+            pPointer->pScreen == pScreen)
         return;
 
     miPointerMoveNoEvent(pDev, pScreen, *x, *y);
diff --git a/xorg-server/mi/mipointer.h b/xorg-server/mi/mipointer.h
index 426ef1650..c4265f9d8 100644
--- a/xorg-server/mi/mipointer.h
+++ b/xorg-server/mi/mipointer.h
@@ -1,154 +1,154 @@
-/*

-

-Copyright 1989, 1998  The Open Group

-

-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.

-

-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 THE

-OPEN GROUP 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 The Open Group shall not be

-used in advertising or otherwise to promote the sale, use or other dealings

-in this Software without prior written authorization from The Open Group.

-*/

-

-#ifndef MIPOINTER_H

-#define MIPOINTER_H

-

-#include "cursor.h"

-#include "input.h"

-#include "privates.h"

-

-typedef struct _miPointerSpriteFuncRec {

-    Bool	(*RealizeCursor)(

-                    DeviceIntPtr /* pDev */,

-                    ScreenPtr /* pScr */,

-                    CursorPtr /* pCurs */

-                    );

-    Bool	(*UnrealizeCursor)(

-                    DeviceIntPtr /* pDev */,

-                    ScreenPtr /* pScr */,

-                    CursorPtr /* pCurs */

-                    );

-    void	(*SetCursor)(

-                    DeviceIntPtr /* pDev */,

-                    ScreenPtr /* pScr */,

-                    CursorPtr /* pCurs */,

-                    int  /* x */,

-                    int  /* y */

-                    );

-    void	(*MoveCursor)(

-                    DeviceIntPtr /* pDev */,

-                    ScreenPtr /* pScr */,

-                    int  /* x */,

-                    int  /* y */

-                    );

-    Bool        (*DeviceCursorInitialize)(

-                    DeviceIntPtr /* pDev */,

-                    ScreenPtr /* pScr */

-                    );

-    void        (*DeviceCursorCleanup)(

-                    DeviceIntPtr /* pDev */,

-                    ScreenPtr /* pScr */

-                    );

-} miPointerSpriteFuncRec, *miPointerSpriteFuncPtr;

-

-typedef struct _miPointerScreenFuncRec {

-    Bool	(*CursorOffScreen)(

-                    ScreenPtr* /* ppScr */,

-                    int*  /* px */,

-                    int*  /* py */

-                    );

-    void	(*CrossScreen)(

-                    ScreenPtr /* pScr */,

-                    int  /* entering */

-                    );

-    void	(*WarpCursor)(

-                    DeviceIntPtr /*pDev*/, 

-                    ScreenPtr /* pScr */,

-                    int  /* x */,

-                    int  /* y */

-                    );

-    void	(*EnqueueEvent)(

-                    DeviceIntPtr /* pDev */,

-                    InternalEvent* /* event */

-                    );

-    void	(*NewEventScreen)(

-		    DeviceIntPtr /* pDev */,

-                    ScreenPtr /* pScr */,

-		    Bool /* fromDIX */

-                    );

-} miPointerScreenFuncRec, *miPointerScreenFuncPtr;

-

-extern _X_EXPORT Bool miDCInitialize(

-    ScreenPtr /*pScreen*/,

-    miPointerScreenFuncPtr /*screenFuncs*/

-);

-

-extern _X_EXPORT Bool miPointerInitialize(

-    ScreenPtr /*pScreen*/,

-    miPointerSpriteFuncPtr /*spriteFuncs*/,

-    miPointerScreenFuncPtr /*screenFuncs*/,

-    Bool /*waitForUpdate*/

-);

-

-extern _X_EXPORT void miPointerWarpCursor(

-    DeviceIntPtr /*pDev*/,

-    ScreenPtr /*pScreen*/,

-    int /*x*/,

-    int /*y*/

-);

-

-/* Deprecated in favour of miPointerGetScreen. */

-extern _X_EXPORT ScreenPtr miPointerCurrentScreen(

-    void

-) _X_DEPRECATED;

-

-extern _X_EXPORT ScreenPtr miPointerGetScreen(

-    DeviceIntPtr pDev);

-extern _X_EXPORT void miPointerSetScreen(

-    DeviceIntPtr pDev,

-    int screen_num,

-    int x,

-    int y);

-

-/* Returns the current cursor position. */

-extern _X_EXPORT void miPointerGetPosition(

-    DeviceIntPtr pDev,

-    int *x,

-    int *y);

-

-/* Moves the cursor to the specified position.  May clip the co-ordinates:

- * x and y are modified in-place. */

-extern _X_EXPORT void miPointerSetPosition(

-    DeviceIntPtr pDev,

-    int mode,

-    int *x,

-    int *y);

-

-extern _X_EXPORT void miPointerUpdateSprite(

-    DeviceIntPtr pDev);

-

-/* Sets whether the sprite should be updated immediately on pointer moves */

-extern _X_EXPORT Bool miPointerSetWaitForUpdate(

-    ScreenPtr pScreen,

-    Bool wait);

-

-extern _X_EXPORT DevPrivateKeyRec miPointerPrivKeyRec;

-#define miPointerPrivKey (&miPointerPrivKeyRec)

-

-extern _X_EXPORT DevPrivateKeyRec miPointerScreenKeyRec;

-#define miPointerScreenKey (&miPointerScreenKeyRec)

-

-#endif /* MIPOINTER_H */

+/*
+
+Copyright 1989, 1998  The Open Group
+
+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.
+
+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 THE
+OPEN GROUP 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 The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+*/
+
+#ifndef MIPOINTER_H
+#define MIPOINTER_H
+
+#include "cursor.h"
+#include "input.h"
+#include "privates.h"
+
+typedef struct _miPointerSpriteFuncRec {
+    Bool	(*RealizeCursor)(
+                    DeviceIntPtr /* pDev */,
+                    ScreenPtr /* pScr */,
+                    CursorPtr /* pCurs */
+                    );
+    Bool	(*UnrealizeCursor)(
+                    DeviceIntPtr /* pDev */,
+                    ScreenPtr /* pScr */,
+                    CursorPtr /* pCurs */
+                    );
+    void	(*SetCursor)(
+                    DeviceIntPtr /* pDev */,
+                    ScreenPtr /* pScr */,
+                    CursorPtr /* pCurs */,
+                    int  /* x */,
+                    int  /* y */
+                    );
+    void	(*MoveCursor)(
+                    DeviceIntPtr /* pDev */,
+                    ScreenPtr /* pScr */,
+                    int  /* x */,
+                    int  /* y */
+                    );
+    Bool        (*DeviceCursorInitialize)(
+                    DeviceIntPtr /* pDev */,
+                    ScreenPtr /* pScr */
+                    );
+    void        (*DeviceCursorCleanup)(
+                    DeviceIntPtr /* pDev */,
+                    ScreenPtr /* pScr */
+                    );
+} miPointerSpriteFuncRec, *miPointerSpriteFuncPtr;
+
+typedef struct _miPointerScreenFuncRec {
+    Bool	(*CursorOffScreen)(
+                    ScreenPtr* /* ppScr */,
+                    int*  /* px */,
+                    int*  /* py */
+                    );
+    void	(*CrossScreen)(
+                    ScreenPtr /* pScr */,
+                    int  /* entering */
+                    );
+    void	(*WarpCursor)(
+                    DeviceIntPtr /*pDev*/, 
+                    ScreenPtr /* pScr */,
+                    int  /* x */,
+                    int  /* y */
+                    );
+    void	(*EnqueueEvent)(
+                    DeviceIntPtr /* pDev */,
+                    InternalEvent* /* event */
+                    );
+    void	(*NewEventScreen)(
+		    DeviceIntPtr /* pDev */,
+                    ScreenPtr /* pScr */,
+		    Bool /* set_dequeue_screen */
+                    );
+} miPointerScreenFuncRec, *miPointerScreenFuncPtr;
+
+extern _X_EXPORT Bool miDCInitialize(
+    ScreenPtr /*pScreen*/,
+    miPointerScreenFuncPtr /*screenFuncs*/
+);
+
+extern _X_EXPORT Bool miPointerInitialize(
+    ScreenPtr /*pScreen*/,
+    miPointerSpriteFuncPtr /*spriteFuncs*/,
+    miPointerScreenFuncPtr /*screenFuncs*/,
+    Bool /*waitForUpdate*/
+);
+
+extern _X_EXPORT void miPointerWarpCursor(
+    DeviceIntPtr /*pDev*/,
+    ScreenPtr /*pScreen*/,
+    int /*x*/,
+    int /*y*/
+);
+
+/* Deprecated in favour of miPointerGetScreen. */
+extern _X_EXPORT ScreenPtr miPointerCurrentScreen(
+    void
+) _X_DEPRECATED;
+
+extern _X_EXPORT ScreenPtr miPointerGetScreen(
+    DeviceIntPtr pDev);
+extern _X_EXPORT void miPointerSetScreen(
+    DeviceIntPtr pDev,
+    int screen_num,
+    int x,
+    int y);
+
+/* Returns the current cursor position. */
+extern _X_EXPORT void miPointerGetPosition(
+    DeviceIntPtr pDev,
+    int *x,
+    int *y);
+
+/* Moves the cursor to the specified position.  May clip the co-ordinates:
+ * x and y are modified in-place. */
+extern _X_EXPORT void miPointerSetPosition(
+    DeviceIntPtr pDev,
+    int mode,
+    int *x,
+    int *y);
+
+extern _X_EXPORT void miPointerUpdateSprite(
+    DeviceIntPtr pDev);
+
+/* Sets whether the sprite should be updated immediately on pointer moves */
+extern _X_EXPORT Bool miPointerSetWaitForUpdate(
+    ScreenPtr pScreen,
+    Bool wait);
+
+extern _X_EXPORT DevPrivateKeyRec miPointerPrivKeyRec;
+#define miPointerPrivKey (&miPointerPrivKeyRec)
+
+extern _X_EXPORT DevPrivateKeyRec miPointerScreenKeyRec;
+#define miPointerScreenKey (&miPointerScreenKeyRec)
+
+#endif /* MIPOINTER_H */
diff --git a/xorg-server/mi/misprite.c b/xorg-server/mi/misprite.c
index 0b47592f0..1025c5a6f 100644
--- a/xorg-server/mi/misprite.c
+++ b/xorg-server/mi/misprite.c
@@ -1,1042 +1,1037 @@
-/*

- * misprite.c

- *

- * machine independent software sprite routines

- */

-

-/*

-

-Copyright 1989, 1998  The Open Group

-

-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.

-

-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 THE

-OPEN GROUP 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 The Open Group shall not be

-used in advertising or otherwise to promote the sale, use or other dealings

-in this Software without prior written authorization from The Open Group.

-*/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include   <X11/X.h>

-#include   <X11/Xproto.h>

-#include   "misc.h"

-#include   "pixmapstr.h"

-#include   "input.h"

-#include   "mi.h"

-#include   "cursorstr.h"

-#include   <X11/fonts/font.h>

-#include   "scrnintstr.h"

-#include   "colormapst.h"

-#include   "windowstr.h"

-#include   "gcstruct.h"

-#include   "mipointer.h"

-#include   "misprite.h"

-#include   "dixfontstr.h"

-#include   <X11/fonts/fontstruct.h>

-#include   "inputstr.h"

-#include   "damage.h"

-

-typedef struct {

-    CursorPtr	    pCursor;

-    int		    x;			/* cursor hotspot */

-    int		    y;

-    BoxRec	    saved;		/* saved area from the screen */

-    Bool	    isUp;		/* cursor in frame buffer */

-    Bool	    shouldBeUp;		/* cursor should be displayed */

-    WindowPtr	    pCacheWin;		/* window the cursor last seen in */

-    Bool	    isInCacheWin;

-    Bool	    checkPixels;	/* check colormap collision */

-    ScreenPtr       pScreen;

-} miCursorInfoRec, *miCursorInfoPtr;

-

-/*

- * per screen information

- */

-

-typedef struct {

-    /* screen procedures */

-    CloseScreenProcPtr			CloseScreen;

-    GetImageProcPtr			GetImage;

-    GetSpansProcPtr			GetSpans;

-    SourceValidateProcPtr		SourceValidate;

-    

-    /* window procedures */

-    CopyWindowProcPtr			CopyWindow;

-    

-    /* colormap procedures */

-    InstallColormapProcPtr		InstallColormap;

-    StoreColorsProcPtr			StoreColors;

-    

-    /* os layer procedures */

-    ScreenBlockHandlerProcPtr		BlockHandler;

-    

-    /* device cursor procedures */

-    DeviceCursorInitializeProcPtr       DeviceCursorInitialize;

-    DeviceCursorCleanupProcPtr          DeviceCursorCleanup;

-

-    xColorItem	    colors[2];

-    ColormapPtr     pInstalledMap;

-    ColormapPtr     pColormap;

-    VisualPtr	    pVisual;

-    DamagePtr	    pDamage;		/* damage tracking structure */

-    Bool            damageRegistered;

-    int             numberOfCursors;

-} miSpriteScreenRec, *miSpriteScreenPtr;

-

-#define SOURCE_COLOR	0

-#define MASK_COLOR	1

-

-/*

- * Overlap BoxPtr and Box elements

- */

-#define BOX_OVERLAP(pCbox,X1,Y1,X2,Y2) \

- 	(((pCbox)->x1 <= (X2)) && ((X1) <= (pCbox)->x2) && \

-	 ((pCbox)->y1 <= (Y2)) && ((Y1) <= (pCbox)->y2))

-

-/*

- * Overlap BoxPtr, origins, and rectangle

- */

-#define ORG_OVERLAP(pCbox,xorg,yorg,x,y,w,h) \

-    BOX_OVERLAP((pCbox),(x)+(xorg),(y)+(yorg),(x)+(xorg)+(w),(y)+(yorg)+(h))

-

-/*

- * Overlap BoxPtr, origins and RectPtr

- */

-#define ORGRECT_OVERLAP(pCbox,xorg,yorg,pRect) \

-    ORG_OVERLAP((pCbox),(xorg),(yorg),(pRect)->x,(pRect)->y, \

-		(int)((pRect)->width), (int)((pRect)->height))

-/*

- * Overlap BoxPtr and horizontal span

- */

-#define SPN_OVERLAP(pCbox,y,x,w) BOX_OVERLAP((pCbox),(x),(y),(x)+(w),(y))

-

-#define LINE_SORT(x1,y1,x2,y2) \

-{ int _t; \

-  if (x1 > x2) { _t = x1; x1 = x2; x2 = _t; } \

-  if (y1 > y2) { _t = y1; y1 = y2; y2 = _t; } }

-

-#define LINE_OVERLAP(pCbox,x1,y1,x2,y2,lw2) \

-    BOX_OVERLAP((pCbox), (x1)-(lw2), (y1)-(lw2), (x2)+(lw2), (y2)+(lw2))

-

-

-#define SPRITE_DEBUG_ENABLE 0

-#if SPRITE_DEBUG_ENABLE

-#define SPRITE_DEBUG(x)	ErrorF x

-#else

-#define SPRITE_DEBUG(x)

-#endif

-

-#define MISPRITE(dev) \

-    (IsFloating(dev) ? \

-       (miCursorInfoPtr)dixLookupPrivate(&dev->devPrivates, miSpriteDevPrivatesKey) : \

-       (miCursorInfoPtr)dixLookupPrivate(&(GetMaster(dev, MASTER_POINTER))->devPrivates, miSpriteDevPrivatesKey))

-

-static void

-miSpriteDisableDamage(ScreenPtr pScreen, miSpriteScreenPtr pScreenPriv)

-{

-    if (pScreenPriv->damageRegistered) {

-	DamageUnregister (&(pScreen->GetScreenPixmap(pScreen)->drawable),

-			  pScreenPriv->pDamage);

-	pScreenPriv->damageRegistered = 0;

-    }

-}

-

-static void

-miSpriteEnableDamage(ScreenPtr pScreen, miSpriteScreenPtr pScreenPriv)

-{

-    if (!pScreenPriv->damageRegistered) {

-	pScreenPriv->damageRegistered = 1;

-	DamageRegister (&(pScreen->GetScreenPixmap(pScreen)->drawable),

-			pScreenPriv->pDamage);

-    }

-}

-

-static void

-miSpriteIsUp(miCursorInfoPtr pDevCursor)

-{

-    pDevCursor->isUp = TRUE;

-}

-

-static void

-miSpriteIsDown(miCursorInfoPtr pDevCursor)

-{

-    pDevCursor->isUp = FALSE;

-}

-

-/*

- * screen wrappers

- */

-

-static DevPrivateKeyRec miSpriteScreenKeyRec;

-#define miSpriteScreenKey (&miSpriteScreenKeyRec)

-#define GetSpriteScreen(pScreen) \

-	(dixLookupPrivate(&(pScreen)->devPrivates, miSpriteScreenKey))

-static DevPrivateKeyRec miSpriteDevPrivatesKeyRec;

-#define miSpriteDevPrivatesKey (&miSpriteDevPrivatesKeyRec)

-

-static Bool	    miSpriteCloseScreen(int i, ScreenPtr pScreen);

-static void	    miSpriteGetImage(DrawablePtr pDrawable, int sx, int sy,

-				     int w, int h, unsigned int format,

-				     unsigned long planemask, char *pdstLine);

-static void	    miSpriteGetSpans(DrawablePtr pDrawable, int wMax,

-				     DDXPointPtr ppt, int *pwidth, int nspans,

-				     char *pdstStart);

-static void	    miSpriteSourceValidate(DrawablePtr pDrawable, int x, int y,

-					   int width, int height,

-					   unsigned int subWindowMode);

-static void	    miSpriteCopyWindow (WindowPtr pWindow,

-					DDXPointRec ptOldOrg,

-					RegionPtr prgnSrc);

-static void	    miSpriteBlockHandler(int i, pointer blockData,

-					 pointer pTimeout,

-					 pointer pReadMask);

-static void	    miSpriteInstallColormap(ColormapPtr pMap);

-static void	    miSpriteStoreColors(ColormapPtr pMap, int ndef,

-					xColorItem *pdef);

-

-static void	    miSpriteComputeSaved(DeviceIntPtr pDev,

-                                         ScreenPtr pScreen);

-

-static Bool         miSpriteDeviceCursorInitialize(DeviceIntPtr pDev,

-                                                   ScreenPtr pScreen);

-static void         miSpriteDeviceCursorCleanup(DeviceIntPtr pDev,

-                                                ScreenPtr pScreen);

-

-#define SCREEN_PROLOGUE(pPriv, pScreen, field) ((pScreen)->field = \

-   (pPriv)->field)

-#define SCREEN_EPILOGUE(pPriv, pScreen, field)\

-    ((pPriv)->field = (pScreen)->field, (pScreen)->field = miSprite##field)

-

-/*

- * pointer-sprite method table

- */

-

-static Bool miSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,

-                                  CursorPtr pCursor);

-static Bool miSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,

-                                    CursorPtr pCursor);

-static void miSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen,

-                              CursorPtr pCursor, int x, int y);

-static void miSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen,

-                               int x, int y);

-

-miPointerSpriteFuncRec miSpritePointerFuncs = {

-    miSpriteRealizeCursor,

-    miSpriteUnrealizeCursor,

-    miSpriteSetCursor,

-    miSpriteMoveCursor,

-    miSpriteDeviceCursorInitialize,

-    miSpriteDeviceCursorCleanup,

-};

-

-/*

- * other misc functions

- */

-

-static void miSpriteRemoveCursor(DeviceIntPtr pDev,

-                                 ScreenPtr pScreen);

-static void miSpriteSaveUnderCursor(DeviceIntPtr pDev,

-                                 ScreenPtr pScreen);

-static void miSpriteRestoreCursor(DeviceIntPtr pDev,

-                                 ScreenPtr pScreen);

-

-static void

-miSpriteRegisterBlockHandler(ScreenPtr pScreen, miSpriteScreenPtr pScreenPriv)

-{

-    if (!pScreenPriv->BlockHandler) {

-        pScreenPriv->BlockHandler = pScreen->BlockHandler;

-        pScreen->BlockHandler = miSpriteBlockHandler;

-    }

-}

-

-static void

-miSpriteReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)

-{

-    ScreenPtr		    pScreen = closure;

-    miCursorInfoPtr         pCursorInfo;

-    DeviceIntPtr            pDev;

-

-    for (pDev = inputInfo.devices; pDev; pDev = pDev->next)

-    {

-        if (DevHasCursor(pDev))

-        {

-            pCursorInfo = MISPRITE(pDev);

-

-            if (pCursorInfo->isUp &&

-                pCursorInfo->pScreen == pScreen &&

-                RegionContainsRect(pRegion, &pCursorInfo->saved) != rgnOUT)

-            {

-                SPRITE_DEBUG(("Damage remove\n"));

-                miSpriteRemoveCursor (pDev, pScreen);

-            }

-        }

-    }

-}

-

-/*

- * miSpriteInitialize -- called from device-dependent screen

- * initialization proc after all of the function pointers have

- * been stored in the screen structure.

- */

-

-Bool

-miSpriteInitialize (ScreenPtr               pScreen,

-                    miPointerScreenFuncPtr  screenFuncs)

-{

-    miSpriteScreenPtr	pScreenPriv;

-    VisualPtr		pVisual;

-

-    if (!DamageSetup (pScreen))

-	return FALSE;

-

-    if (!dixRegisterPrivateKey(&miSpriteScreenKeyRec, PRIVATE_SCREEN, 0))

-	return FALSE;

-

-    if (!dixRegisterPrivateKey(&miSpriteDevPrivatesKeyRec, PRIVATE_DEVICE, sizeof(miCursorInfoRec)))

-	return FALSE;

-

-    pScreenPriv = malloc(sizeof (miSpriteScreenRec));

-    if (!pScreenPriv)

-	return FALSE;

-

-    pScreenPriv->pDamage = DamageCreate (miSpriteReportDamage,

-					 NULL,

-					 DamageReportRawRegion,

-					 TRUE,

-					 pScreen,

-					 pScreen);

-

-    if (!miPointerInitialize (pScreen, &miSpritePointerFuncs, screenFuncs,TRUE))

-    {

-	free(pScreenPriv);

-	return FALSE;

-    }

-    for (pVisual = pScreen->visuals;

-	 pVisual->vid != pScreen->rootVisual;

-	 pVisual++)

-	;

-    pScreenPriv->pVisual = pVisual;

-    pScreenPriv->CloseScreen = pScreen->CloseScreen;

-    pScreenPriv->GetImage = pScreen->GetImage;

-    pScreenPriv->GetSpans = pScreen->GetSpans;

-    pScreenPriv->SourceValidate = pScreen->SourceValidate;

-

-    pScreenPriv->CopyWindow = pScreen->CopyWindow;

-

-    pScreenPriv->InstallColormap = pScreen->InstallColormap;

-    pScreenPriv->StoreColors = pScreen->StoreColors;

-

-    pScreenPriv->BlockHandler = NULL;

-

-    pScreenPriv->DeviceCursorInitialize = pScreen->DeviceCursorInitialize;

-    pScreenPriv->DeviceCursorCleanup = pScreen->DeviceCursorCleanup;

-

-    pScreenPriv->pInstalledMap = NULL;

-    pScreenPriv->pColormap = NULL;

-    pScreenPriv->colors[SOURCE_COLOR].red = 0;

-    pScreenPriv->colors[SOURCE_COLOR].green = 0;

-    pScreenPriv->colors[SOURCE_COLOR].blue = 0;

-    pScreenPriv->colors[MASK_COLOR].red = 0;

-    pScreenPriv->colors[MASK_COLOR].green = 0;

-    pScreenPriv->colors[MASK_COLOR].blue = 0;

-    pScreenPriv->damageRegistered = 0;

-    pScreenPriv->numberOfCursors = 0;

-

-    dixSetPrivate(&pScreen->devPrivates, miSpriteScreenKey, pScreenPriv);

-

-    pScreen->CloseScreen = miSpriteCloseScreen;

-    pScreen->GetImage = miSpriteGetImage;

-    pScreen->GetSpans = miSpriteGetSpans;

-    pScreen->SourceValidate = miSpriteSourceValidate;

-

-    pScreen->CopyWindow = miSpriteCopyWindow;

-    pScreen->InstallColormap = miSpriteInstallColormap;

-    pScreen->StoreColors = miSpriteStoreColors;

-

-    return TRUE;

-}

-

-/*

- * Screen wrappers

- */

-

-/*

- * CloseScreen wrapper -- unwrap everything, free the private data

- * and call the wrapped function

- */

-

-static Bool

-miSpriteCloseScreen (int i, ScreenPtr pScreen)

-{

-    miSpriteScreenPtr   pScreenPriv = GetSpriteScreen(pScreen);

-

-    pScreen->CloseScreen = pScreenPriv->CloseScreen;

-    pScreen->GetImage = pScreenPriv->GetImage;

-    pScreen->GetSpans = pScreenPriv->GetSpans;

-    pScreen->SourceValidate = pScreenPriv->SourceValidate;

-    pScreen->InstallColormap = pScreenPriv->InstallColormap;

-    pScreen->StoreColors = pScreenPriv->StoreColors;

-

-    DamageDestroy (pScreenPriv->pDamage);

-

-    free(pScreenPriv);

-

-    return (*pScreen->CloseScreen) (i, pScreen);

-}

-

-static void

-miSpriteGetImage (DrawablePtr pDrawable, int sx, int sy, int w, int h,

-                  unsigned int format, unsigned long planemask,

-                  char *pdstLine)

-{

-    ScreenPtr           pScreen = pDrawable->pScreen;

-    DeviceIntPtr        pDev;

-    miCursorInfoPtr     pCursorInfo;

-    miSpriteScreenPtr   pPriv = GetSpriteScreen(pScreen);

-

-    SCREEN_PROLOGUE (pPriv, pScreen, GetImage);

-

-    if (pDrawable->type == DRAWABLE_WINDOW)

-    {

-        for(pDev = inputInfo.devices; pDev; pDev = pDev->next)

-        {

-            if (DevHasCursor(pDev))

-            {

-                 pCursorInfo = MISPRITE(pDev);

-                 if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen &&

-                      ORG_OVERLAP(&pCursorInfo->saved,pDrawable->x,pDrawable->y,

-                                  sx, sy, w, h))

-                 {

-                     SPRITE_DEBUG (("GetImage remove\n"));

-                     miSpriteRemoveCursor (pDev, pScreen);

-                 }

-            }

-        }

-    }

-

-    (*pScreen->GetImage) (pDrawable, sx, sy, w, h,

-			  format, planemask, pdstLine);

-

-    SCREEN_EPILOGUE (pPriv, pScreen, GetImage);

-}

-

-static void

-miSpriteGetSpans (DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,

-                  int *pwidth, int nspans, char *pdstStart)

-{

-    ScreenPtr		    pScreen = pDrawable->pScreen;

-    DeviceIntPtr            pDev;

-    miCursorInfoPtr         pCursorInfo;

-    miSpriteScreenPtr       pPriv = GetSpriteScreen(pScreen);

-

-    SCREEN_PROLOGUE (pPriv, pScreen, GetSpans);

-

-    if (pDrawable->type == DRAWABLE_WINDOW)

-    {

-        for(pDev = inputInfo.devices; pDev; pDev = pDev->next)

-        {

-            if (DevHasCursor(pDev))

-            {

-                pCursorInfo = MISPRITE(pDev);

-

-                if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen)

-                {

-                    DDXPointPtr    pts;

-                    int    	       *widths;

-                    int    	       nPts;

-                    int    	       xorg,

-                                   yorg;

-

-                    xorg = pDrawable->x;

-                    yorg = pDrawable->y;

-

-                    for (pts = ppt, widths = pwidth, nPts = nspans;

-                            nPts--;

-                            pts++, widths++)

-                    {

-                        if (SPN_OVERLAP(&pCursorInfo->saved,pts->y+yorg,

-                                    pts->x+xorg,*widths))

-                        {

-                            SPRITE_DEBUG (("GetSpans remove\n"));

-                            miSpriteRemoveCursor (pDev, pScreen);

-                            break;

-                        }

-                    }

-                }

-            }

-        }

-    }

-

-    (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);

-

-    SCREEN_EPILOGUE (pPriv, pScreen, GetSpans);

-}

-

-static void

-miSpriteSourceValidate (DrawablePtr pDrawable, int x, int y, int width,

-                        int height, unsigned int subWindowMode)

-{

-    ScreenPtr		    pScreen = pDrawable->pScreen;

-    DeviceIntPtr            pDev;

-    miCursorInfoPtr         pCursorInfo;

-    miSpriteScreenPtr       pPriv = GetSpriteScreen(pScreen);

-

-    SCREEN_PROLOGUE (pPriv, pScreen, SourceValidate);

-

-    if (pDrawable->type == DRAWABLE_WINDOW)

-    {

-	for(pDev = inputInfo.devices; pDev; pDev = pDev->next)

-	{

-	    if (DevHasCursor(pDev))

-	    {

-		pCursorInfo = MISPRITE(pDev);

-		if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen &&

-		    ORG_OVERLAP(&pCursorInfo->saved, pDrawable->x, pDrawable->y,

-				x, y, width, height))

-		{

-		    SPRITE_DEBUG (("SourceValidate remove\n"));

-		    miSpriteRemoveCursor (pDev, pScreen);

-		}

-	    }

-	}

-    }

-

-    if (pScreen->SourceValidate)

-	(*pScreen->SourceValidate) (pDrawable, x, y, width, height, subWindowMode);

-

-    SCREEN_EPILOGUE (pPriv, pScreen, SourceValidate);

-}

-

-static void

-miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)

-{

-    ScreenPtr	pScreen = pWindow->drawable.pScreen;

-    DeviceIntPtr            pDev;

-    miCursorInfoPtr         pCursorInfo;

-    miSpriteScreenPtr       pPriv = GetSpriteScreen(pScreen);

-

-    SCREEN_PROLOGUE (pPriv, pScreen, CopyWindow);

-

-    for(pDev = inputInfo.devices; pDev; pDev = pDev->next)

-    {

-        if (DevHasCursor(pDev))

-        {

-            pCursorInfo = MISPRITE(pDev);

-            /*

-             * Damage will take care of destination check

-             */

-            if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen &&

-                    RegionContainsRect(prgnSrc, &pCursorInfo->saved) != rgnOUT)

-            {

-                SPRITE_DEBUG (("CopyWindow remove\n"));

-                miSpriteRemoveCursor (pDev, pScreen);

-            }

-        }

-    }

-

-    (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);

-    SCREEN_EPILOGUE (pPriv, pScreen, CopyWindow);

-}

-

-static void

-miSpriteBlockHandler (int i, pointer blockData, pointer pTimeout,

-                      pointer pReadmask)

-{

-    ScreenPtr		pScreen = screenInfo.screens[i];

-    miSpriteScreenPtr	pPriv = GetSpriteScreen(pScreen);

-    DeviceIntPtr            pDev;

-    miCursorInfoPtr         pCursorInfo;

-    Bool                WorkToDo = FALSE;

-

-    for(pDev = inputInfo.devices; pDev; pDev = pDev->next)

-    {

-        if (DevHasCursor(pDev))

-        {

-            pCursorInfo = MISPRITE(pDev);

-            if (pCursorInfo && !pCursorInfo->isUp

-                    && pCursorInfo->pScreen == pScreen

-                    && pCursorInfo->shouldBeUp)

-            {

-                SPRITE_DEBUG (("BlockHandler save"));

-                miSpriteSaveUnderCursor (pDev, pScreen);

-            }

-        }

-    }

-    for(pDev = inputInfo.devices; pDev; pDev = pDev->next)

-    {

-        if (DevHasCursor(pDev))

-        {

-            pCursorInfo = MISPRITE(pDev);

-            if (pCursorInfo && !pCursorInfo->isUp &&

-                    pCursorInfo->pScreen == pScreen &&

-                    pCursorInfo->shouldBeUp)

-            {

-                SPRITE_DEBUG (("BlockHandler restore\n"));

-                miSpriteRestoreCursor (pDev, pScreen);

-                if (!pCursorInfo->isUp)

-                    WorkToDo = TRUE;

-            }

-        }

-    }

-

-    SCREEN_PROLOGUE(pPriv, pScreen, BlockHandler);

-

-    (*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);

-

-    if (WorkToDo)

-        SCREEN_EPILOGUE(pPriv, pScreen, BlockHandler);

-    else

-        pPriv->BlockHandler = NULL;

-}

-

-static void

-miSpriteInstallColormap (ColormapPtr pMap)

-{

-    ScreenPtr		pScreen = pMap->pScreen;

-    miSpriteScreenPtr	pPriv = GetSpriteScreen(pScreen);

-

-    SCREEN_PROLOGUE(pPriv, pScreen, InstallColormap);

-

-    (*pScreen->InstallColormap) (pMap);

-

-    SCREEN_EPILOGUE(pPriv, pScreen, InstallColormap);

-

-    /* InstallColormap can be called before devices are initialized. */

-    pPriv->pInstalledMap = pMap;

-    if (pPriv->pColormap != pMap)

-    {

-        DeviceIntPtr pDev;

-        miCursorInfoPtr     pCursorInfo;

-        for (pDev = inputInfo.devices; pDev; pDev = pDev->next)

-        {

-            if (DevHasCursor(pDev))

-            {

-                pCursorInfo = MISPRITE(pDev);

-                pCursorInfo->checkPixels = TRUE;

-                if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen)

-                    miSpriteRemoveCursor(pDev, pScreen);

-            }

-        }

-

-    }

-}

-

-static void

-miSpriteStoreColors (ColormapPtr pMap, int ndef, xColorItem *pdef)

-{

-    ScreenPtr		pScreen = pMap->pScreen;

-    miSpriteScreenPtr	pPriv = GetSpriteScreen(pScreen);

-    int			i;

-    int			updated;

-    VisualPtr		pVisual;

-    DeviceIntPtr        pDev;

-    miCursorInfoPtr     pCursorInfo;

-

-    SCREEN_PROLOGUE(pPriv, pScreen, StoreColors);

-

-    (*pScreen->StoreColors) (pMap, ndef, pdef);

-

-    SCREEN_EPILOGUE(pPriv, pScreen, StoreColors);

-

-    if (pPriv->pColormap == pMap)

-    {

-        updated = 0;

-        pVisual = pMap->pVisual;

-        if (pVisual->class == DirectColor)

-        {

-            /* Direct color - match on any of the subfields */

-

-#define MaskMatch(a,b,mask) (((a) & (pVisual->mask)) == ((b) & (pVisual->mask)))

-

-#define UpdateDAC(dev, plane,dac,mask) {\

-    if (MaskMatch (dev->colors[plane].pixel,pdef[i].pixel,mask)) {\

-	dev->colors[plane].dac = pdef[i].dac; \

-	updated = 1; \

-    } \

-}

-

-#define CheckDirect(dev, plane) \

-	    UpdateDAC(dev, plane,red,redMask) \

-	    UpdateDAC(dev, plane,green,greenMask) \

-	    UpdateDAC(dev, plane,blue,blueMask)

-

-            for (i = 0; i < ndef; i++)

-            {

-                CheckDirect (pPriv, SOURCE_COLOR)

-                CheckDirect (pPriv, MASK_COLOR)

-            }

-        }

-        else

-        {

-            /* PseudoColor/GrayScale - match on exact pixel */

-            for (i = 0; i < ndef; i++)

-            {

-                if (pdef[i].pixel ==

-                        pPriv->colors[SOURCE_COLOR].pixel)

-                {

-                    pPriv->colors[SOURCE_COLOR] = pdef[i];

-                    if (++updated == 2)

-                        break;

-                }

-                if (pdef[i].pixel ==

-                        pPriv->colors[MASK_COLOR].pixel)

-                {

-                    pPriv->colors[MASK_COLOR] = pdef[i];

-                    if (++updated == 2)

-                        break;

-                }

-            }

-        }

-        if (updated)

-        {

-            for(pDev = inputInfo.devices; pDev; pDev = pDev->next)

-            {

-                if (DevHasCursor(pDev))

-                {

-                    pCursorInfo = MISPRITE(pDev);

-                    pCursorInfo->checkPixels = TRUE;

-                    if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen)

-                        miSpriteRemoveCursor (pDev, pScreen);

-                }

-            }

-        }

-    }

-}

-

-static void

-miSpriteFindColors (miCursorInfoPtr pDevCursor, ScreenPtr pScreen)

-{

-    miSpriteScreenPtr	pScreenPriv = GetSpriteScreen(pScreen);

-    CursorPtr		pCursor;

-    xColorItem		*sourceColor, *maskColor;

-

-    pCursor = pDevCursor->pCursor;

-    sourceColor = &pScreenPriv->colors[SOURCE_COLOR];

-    maskColor = &pScreenPriv->colors[MASK_COLOR];

-    if (pScreenPriv->pColormap != pScreenPriv->pInstalledMap ||

-	!(pCursor->foreRed == sourceColor->red &&

-	  pCursor->foreGreen == sourceColor->green &&

-          pCursor->foreBlue == sourceColor->blue &&

-	  pCursor->backRed == maskColor->red &&

-	  pCursor->backGreen == maskColor->green &&

-	  pCursor->backBlue == maskColor->blue))

-    {

-	pScreenPriv->pColormap = pScreenPriv->pInstalledMap;

-	sourceColor->red = pCursor->foreRed;

-	sourceColor->green = pCursor->foreGreen;

-	sourceColor->blue = pCursor->foreBlue;

-	FakeAllocColor (pScreenPriv->pColormap, sourceColor);

-	maskColor->red = pCursor->backRed;

-	maskColor->green = pCursor->backGreen;

-	maskColor->blue = pCursor->backBlue;

-	FakeAllocColor (pScreenPriv->pColormap, maskColor);

-	/* "free" the pixels right away, don't let this confuse you */

-	FakeFreeColor(pScreenPriv->pColormap, sourceColor->pixel);

-	FakeFreeColor(pScreenPriv->pColormap, maskColor->pixel);

-    }

-

-    pDevCursor->checkPixels = FALSE;

-

-}

-

-/*

- * miPointer interface routines

- */

-

-#define SPRITE_PAD  8

-

-static Bool

-miSpriteRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

-{

-    miCursorInfoPtr pCursorInfo;

-

-    if (IsFloating(pDev))

-        return FALSE;

-

-    pCursorInfo = MISPRITE(pDev);

-

-    if (pCursor == pCursorInfo->pCursor)

-	pCursorInfo->checkPixels = TRUE;

-

-    return miDCRealizeCursor(pScreen, pCursor);

-}

-

-static Bool

-miSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

-{

-    return miDCUnrealizeCursor(pScreen, pCursor);

-}

-

-static void

-miSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen,

-                   CursorPtr pCursor, int x, int y)

-{

-    miCursorInfoPtr     pPointer;

-    miSpriteScreenPtr   pScreenPriv;

-

-    if (IsFloating(pDev))

-        return;

-

-    pPointer = MISPRITE(pDev);

-    pScreenPriv = GetSpriteScreen(pScreen);

-

-    if (!pCursor)

-    {

-	if (pPointer->shouldBeUp)

-	    --pScreenPriv->numberOfCursors;

-    	pPointer->shouldBeUp = FALSE;

-    	if (pPointer->isUp)

-	    miSpriteRemoveCursor (pDev, pScreen);

-	if (pScreenPriv->numberOfCursors == 0)

-	    miSpriteDisableDamage(pScreen, pScreenPriv);

-	pPointer->pCursor = 0;

-	return;

-    }

-    if (!pPointer->shouldBeUp)

-	pScreenPriv->numberOfCursors++;

-    pPointer->shouldBeUp = TRUE;

-    if (!pPointer->isUp)

-	miSpriteRegisterBlockHandler(pScreen, pScreenPriv);

-    if (pPointer->x == x &&

-	pPointer->y == y &&

-	pPointer->pCursor == pCursor &&

-	!pPointer->checkPixels)

-    {

-	return;

-    }

-    pPointer->x = x;

-    pPointer->y = y;

-    pPointer->pCacheWin = NullWindow;

-    if (pPointer->checkPixels || pPointer->pCursor != pCursor)

-    {

-	pPointer->pCursor = pCursor;

-	miSpriteFindColors (pPointer, pScreen);

-    }

-    if (pPointer->isUp) {

-	/* TODO: reimplement flicker-free MoveCursor */

-	SPRITE_DEBUG (("SetCursor remove %d\n", pDev->id));

-	miSpriteRemoveCursor (pDev, pScreen);

-    }

-

-    if (!pPointer->isUp && pPointer->pCursor)

-    {

-	SPRITE_DEBUG (("SetCursor restore %d\n", pDev->id));

-        miSpriteSaveUnderCursor(pDev, pScreen);

-	miSpriteRestoreCursor (pDev, pScreen);

-    }

-

-}

-

-static void

-miSpriteMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

-{

-    CursorPtr pCursor;

-

-    if (IsFloating(pDev))

-        return;

-

-    pCursor = MISPRITE(pDev)->pCursor;

-

-    miSpriteSetCursor (pDev, pScreen, pCursor, x, y);

-}

-

-

-static Bool

-miSpriteDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    int ret = miDCDeviceInitialize(pDev, pScreen);

-

-    if (ret)

-    {

-        miCursorInfoPtr pCursorInfo;

-        pCursorInfo = dixLookupPrivate(&pDev->devPrivates, miSpriteDevPrivatesKey);

-        pCursorInfo->pCursor = NULL;

-        pCursorInfo->x = 0;

-        pCursorInfo->y = 0;

-        pCursorInfo->isUp = FALSE;

-        pCursorInfo->shouldBeUp = FALSE;

-        pCursorInfo->pCacheWin = NullWindow;

-        pCursorInfo->isInCacheWin = FALSE;

-        pCursorInfo->checkPixels = TRUE;

-        pCursorInfo->pScreen = FALSE;

-    }

-

-    return ret;

-}

-

-static void

-miSpriteDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    miCursorInfoPtr pCursorInfo = dixLookupPrivate(&pDev->devPrivates, miSpriteDevPrivatesKey);

-

-    if (DevHasCursor(pDev))

-        miDCDeviceCleanup(pDev, pScreen);

-

-    memset(pCursorInfo, 0, sizeof(miCursorInfoRec));

-}

-

-/*

- * undraw/draw cursor

- */

-

-static void

-miSpriteRemoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    miSpriteScreenPtr   pScreenPriv;

-    miCursorInfoPtr     pCursorInfo;

-

-

-    if (IsFloating(pDev))

-        return;

-

-    DamageDrawInternal (pScreen, TRUE);

-    pScreenPriv = GetSpriteScreen(pScreen);

-    pCursorInfo = MISPRITE(pDev);

-

-    miSpriteIsDown(pCursorInfo);

-    miSpriteRegisterBlockHandler(pScreen, pScreenPriv);

-    pCursorInfo->pCacheWin = NullWindow;

-    miSpriteDisableDamage(pScreen, pScreenPriv);

-    if (!miDCRestoreUnderCursor(pDev,

-                                pScreen,

-                                pCursorInfo->saved.x1,

-                                pCursorInfo->saved.y1,

-                                pCursorInfo->saved.x2 -

-                                pCursorInfo->saved.x1,

-                                pCursorInfo->saved.y2 -

-                                pCursorInfo->saved.y1))

-    {

-        miSpriteIsUp(pCursorInfo);

-    }

-    miSpriteEnableDamage(pScreen, pScreenPriv);

-    DamageDrawInternal (pScreen, FALSE);

-}

-

-/*

- * Called from the block handler, saves area under cursor

- * before waiting for something to do.

- */

-

-static void

-miSpriteSaveUnderCursor(DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    miSpriteScreenPtr   pScreenPriv;

-    int			x, y;

-    CursorPtr		pCursor;

-    miCursorInfoPtr     pCursorInfo;

-

-    if (IsFloating(pDev))

-        return;

-

-    DamageDrawInternal (pScreen, TRUE);

-    pScreenPriv = GetSpriteScreen(pScreen);

-    pCursorInfo = MISPRITE(pDev);

-

-    miSpriteComputeSaved (pDev, pScreen);

-    pCursor = pCursorInfo->pCursor;

-

-    x = pCursorInfo->x - (int)pCursor->bits->xhot;

-    y = pCursorInfo->y - (int)pCursor->bits->yhot;

-    miSpriteDisableDamage(pScreen, pScreenPriv);

-

-    miDCSaveUnderCursor(pDev,

-                        pScreen,

-                        pCursorInfo->saved.x1,

-                        pCursorInfo->saved.y1,

-                        pCursorInfo->saved.x2 -

-                        pCursorInfo->saved.x1,

-                        pCursorInfo->saved.y2 -

-                        pCursorInfo->saved.y1);

-    SPRITE_DEBUG(("SaveUnderCursor %d\n", pDev->id));

-    miSpriteEnableDamage(pScreen, pScreenPriv);

-    DamageDrawInternal (pScreen, FALSE);

-}

-

-

-/*

- * Called from the block handler, restores the cursor

- * before waiting for something to do.

- */

-

-static void

-miSpriteRestoreCursor (DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    miSpriteScreenPtr   pScreenPriv;

-    int			x, y;

-    CursorPtr		pCursor;

-    miCursorInfoPtr     pCursorInfo;

-

-    if (IsFloating(pDev))

-        return;

-

-    DamageDrawInternal (pScreen, TRUE);

-    pScreenPriv = GetSpriteScreen(pScreen);

-    pCursorInfo = MISPRITE(pDev);

-

-    miSpriteComputeSaved (pDev, pScreen);

-    pCursor = pCursorInfo->pCursor;

-

-    x = pCursorInfo->x - (int)pCursor->bits->xhot;

-    y = pCursorInfo->y - (int)pCursor->bits->yhot;

-    miSpriteDisableDamage(pScreen, pScreenPriv);

-    SPRITE_DEBUG(("RestoreCursor %d\n", pDev->id));

-    if (pCursorInfo->checkPixels)

-        miSpriteFindColors (pCursorInfo, pScreen);

-    if (miDCPutUpCursor(pDev, pScreen,

-                pCursor, x, y,

-                pScreenPriv->colors[SOURCE_COLOR].pixel,

-                pScreenPriv->colors[MASK_COLOR].pixel))

-    {

-        miSpriteIsUp(pCursorInfo);

-        pCursorInfo->pScreen = pScreen;

-    }

-    miSpriteEnableDamage(pScreen, pScreenPriv);

-    DamageDrawInternal (pScreen, FALSE);

-}

-

-/*

- * compute the desired area of the screen to save

- */

-

-static void

-miSpriteComputeSaved (DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    int		    x, y, w, h;

-    int		    wpad, hpad;

-    CursorPtr	    pCursor;

-    miCursorInfoPtr pCursorInfo;

-

-    if (IsFloating(pDev))

-        return;

-

-    pCursorInfo = MISPRITE(pDev);

-

-    pCursor = pCursorInfo->pCursor;

-    x = pCursorInfo->x - (int)pCursor->bits->xhot;

-    y = pCursorInfo->y - (int)pCursor->bits->yhot;

-    w = pCursor->bits->width;

-    h = pCursor->bits->height;

-    wpad = SPRITE_PAD;

-    hpad = SPRITE_PAD;

-    pCursorInfo->saved.x1 = x - wpad;

-    pCursorInfo->saved.y1 = y - hpad;

-    pCursorInfo->saved.x2 = pCursorInfo->saved.x1 + w + wpad * 2;

-    pCursorInfo->saved.y2 = pCursorInfo->saved.y1 + h + hpad * 2;

-}

-

+/*
+ * misprite.c
+ *
+ * machine independent software sprite routines
+ */
+
+/*
+
+Copyright 1989, 1998  The Open Group
+
+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.
+
+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 THE
+OPEN GROUP 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 The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+*/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include   <X11/X.h>
+#include   <X11/Xproto.h>
+#include   "misc.h"
+#include   "pixmapstr.h"
+#include   "input.h"
+#include   "mi.h"
+#include   "cursorstr.h"
+#include   <X11/fonts/font.h>
+#include   "scrnintstr.h"
+#include   "colormapst.h"
+#include   "windowstr.h"
+#include   "gcstruct.h"
+#include   "mipointer.h"
+#include   "misprite.h"
+#include   "dixfontstr.h"
+#include   <X11/fonts/fontstruct.h>
+#include   "inputstr.h"
+#include   "damage.h"
+
+typedef struct {
+    CursorPtr	    pCursor;
+    int		    x;			/* cursor hotspot */
+    int		    y;
+    BoxRec	    saved;		/* saved area from the screen */
+    Bool	    isUp;		/* cursor in frame buffer */
+    Bool	    shouldBeUp;		/* cursor should be displayed */
+    WindowPtr	    pCacheWin;		/* window the cursor last seen in */
+    Bool	    isInCacheWin;
+    Bool	    checkPixels;	/* check colormap collision */
+    ScreenPtr       pScreen;
+} miCursorInfoRec, *miCursorInfoPtr;
+
+/*
+ * per screen information
+ */
+
+typedef struct {
+    /* screen procedures */
+    CloseScreenProcPtr			CloseScreen;
+    GetImageProcPtr			GetImage;
+    GetSpansProcPtr			GetSpans;
+    SourceValidateProcPtr		SourceValidate;
+    
+    /* window procedures */
+    CopyWindowProcPtr			CopyWindow;
+    
+    /* colormap procedures */
+    InstallColormapProcPtr		InstallColormap;
+    StoreColorsProcPtr			StoreColors;
+    
+    /* os layer procedures */
+    ScreenBlockHandlerProcPtr		BlockHandler;
+    
+    /* device cursor procedures */
+    DeviceCursorInitializeProcPtr       DeviceCursorInitialize;
+    DeviceCursorCleanupProcPtr          DeviceCursorCleanup;
+
+    xColorItem	    colors[2];
+    ColormapPtr     pInstalledMap;
+    ColormapPtr     pColormap;
+    VisualPtr	    pVisual;
+    DamagePtr	    pDamage;		/* damage tracking structure */
+    Bool            damageRegistered;
+    int             numberOfCursors;
+} miSpriteScreenRec, *miSpriteScreenPtr;
+
+#define SOURCE_COLOR	0
+#define MASK_COLOR	1
+
+/*
+ * Overlap BoxPtr and Box elements
+ */
+#define BOX_OVERLAP(pCbox,X1,Y1,X2,Y2) \
+ 	(((pCbox)->x1 <= (X2)) && ((X1) <= (pCbox)->x2) && \
+	 ((pCbox)->y1 <= (Y2)) && ((Y1) <= (pCbox)->y2))
+
+/*
+ * Overlap BoxPtr, origins, and rectangle
+ */
+#define ORG_OVERLAP(pCbox,xorg,yorg,x,y,w,h) \
+    BOX_OVERLAP((pCbox),(x)+(xorg),(y)+(yorg),(x)+(xorg)+(w),(y)+(yorg)+(h))
+
+/*
+ * Overlap BoxPtr, origins and RectPtr
+ */
+#define ORGRECT_OVERLAP(pCbox,xorg,yorg,pRect) \
+    ORG_OVERLAP((pCbox),(xorg),(yorg),(pRect)->x,(pRect)->y, \
+		(int)((pRect)->width), (int)((pRect)->height))
+/*
+ * Overlap BoxPtr and horizontal span
+ */
+#define SPN_OVERLAP(pCbox,y,x,w) BOX_OVERLAP((pCbox),(x),(y),(x)+(w),(y))
+
+#define LINE_SORT(x1,y1,x2,y2) \
+{ int _t; \
+  if (x1 > x2) { _t = x1; x1 = x2; x2 = _t; } \
+  if (y1 > y2) { _t = y1; y1 = y2; y2 = _t; } }
+
+#define LINE_OVERLAP(pCbox,x1,y1,x2,y2,lw2) \
+    BOX_OVERLAP((pCbox), (x1)-(lw2), (y1)-(lw2), (x2)+(lw2), (y2)+(lw2))
+
+
+#define SPRITE_DEBUG_ENABLE 0
+#if SPRITE_DEBUG_ENABLE
+#define SPRITE_DEBUG(x)	ErrorF x
+#else
+#define SPRITE_DEBUG(x)
+#endif
+
+#define MISPRITE(dev) \
+    (IsFloating(dev) ? \
+       (miCursorInfoPtr)dixLookupPrivate(&dev->devPrivates, miSpriteDevPrivatesKey) : \
+       (miCursorInfoPtr)dixLookupPrivate(&(GetMaster(dev, MASTER_POINTER))->devPrivates, miSpriteDevPrivatesKey))
+
+static void
+miSpriteDisableDamage(ScreenPtr pScreen, miSpriteScreenPtr pScreenPriv)
+{
+    if (pScreenPriv->damageRegistered) {
+	DamageUnregister (&(pScreen->GetScreenPixmap(pScreen)->drawable),
+			  pScreenPriv->pDamage);
+	pScreenPriv->damageRegistered = 0;
+    }
+}
+
+static void
+miSpriteEnableDamage(ScreenPtr pScreen, miSpriteScreenPtr pScreenPriv)
+{
+    if (!pScreenPriv->damageRegistered) {
+	pScreenPriv->damageRegistered = 1;
+	DamageRegister (&(pScreen->GetScreenPixmap(pScreen)->drawable),
+			pScreenPriv->pDamage);
+    }
+}
+
+static void
+miSpriteIsUp(miCursorInfoPtr pDevCursor)
+{
+    pDevCursor->isUp = TRUE;
+}
+
+static void
+miSpriteIsDown(miCursorInfoPtr pDevCursor)
+{
+    pDevCursor->isUp = FALSE;
+}
+
+/*
+ * screen wrappers
+ */
+
+static DevPrivateKeyRec miSpriteScreenKeyRec;
+#define miSpriteScreenKey (&miSpriteScreenKeyRec)
+#define GetSpriteScreen(pScreen) \
+	(dixLookupPrivate(&(pScreen)->devPrivates, miSpriteScreenKey))
+static DevPrivateKeyRec miSpriteDevPrivatesKeyRec;
+#define miSpriteDevPrivatesKey (&miSpriteDevPrivatesKeyRec)
+
+static Bool	    miSpriteCloseScreen(int i, ScreenPtr pScreen);
+static void	    miSpriteGetImage(DrawablePtr pDrawable, int sx, int sy,
+				     int w, int h, unsigned int format,
+				     unsigned long planemask, char *pdstLine);
+static void	    miSpriteGetSpans(DrawablePtr pDrawable, int wMax,
+				     DDXPointPtr ppt, int *pwidth, int nspans,
+				     char *pdstStart);
+static void	    miSpriteSourceValidate(DrawablePtr pDrawable, int x, int y,
+					   int width, int height,
+					   unsigned int subWindowMode);
+static void	    miSpriteCopyWindow (WindowPtr pWindow,
+					DDXPointRec ptOldOrg,
+					RegionPtr prgnSrc);
+static void	    miSpriteBlockHandler(int i, pointer blockData,
+					 pointer pTimeout,
+					 pointer pReadMask);
+static void	    miSpriteInstallColormap(ColormapPtr pMap);
+static void	    miSpriteStoreColors(ColormapPtr pMap, int ndef,
+					xColorItem *pdef);
+
+static void	    miSpriteComputeSaved(DeviceIntPtr pDev,
+                                         ScreenPtr pScreen);
+
+static Bool         miSpriteDeviceCursorInitialize(DeviceIntPtr pDev,
+                                                   ScreenPtr pScreen);
+static void         miSpriteDeviceCursorCleanup(DeviceIntPtr pDev,
+                                                ScreenPtr pScreen);
+
+#define SCREEN_PROLOGUE(pPriv, pScreen, field) ((pScreen)->field = \
+   (pPriv)->field)
+#define SCREEN_EPILOGUE(pPriv, pScreen, field)\
+    ((pPriv)->field = (pScreen)->field, (pScreen)->field = miSprite##field)
+
+/*
+ * pointer-sprite method table
+ */
+
+static Bool miSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
+                                  CursorPtr pCursor);
+static Bool miSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
+                                    CursorPtr pCursor);
+static void miSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
+                              CursorPtr pCursor, int x, int y);
+static void miSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
+                               int x, int y);
+
+miPointerSpriteFuncRec miSpritePointerFuncs = {
+    miSpriteRealizeCursor,
+    miSpriteUnrealizeCursor,
+    miSpriteSetCursor,
+    miSpriteMoveCursor,
+    miSpriteDeviceCursorInitialize,
+    miSpriteDeviceCursorCleanup,
+};
+
+/*
+ * other misc functions
+ */
+
+static void miSpriteRemoveCursor(DeviceIntPtr pDev,
+                                 ScreenPtr pScreen);
+static void miSpriteSaveUnderCursor(DeviceIntPtr pDev,
+                                 ScreenPtr pScreen);
+static void miSpriteRestoreCursor(DeviceIntPtr pDev,
+                                 ScreenPtr pScreen);
+
+static void
+miSpriteRegisterBlockHandler(ScreenPtr pScreen, miSpriteScreenPtr pScreenPriv)
+{
+    if (!pScreenPriv->BlockHandler) {
+        pScreenPriv->BlockHandler = pScreen->BlockHandler;
+        pScreen->BlockHandler = miSpriteBlockHandler;
+    }
+}
+
+static void
+miSpriteReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
+{
+    ScreenPtr		    pScreen = closure;
+    miCursorInfoPtr         pCursorInfo;
+    DeviceIntPtr            pDev;
+
+    for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
+    {
+        if (DevHasCursor(pDev))
+        {
+            pCursorInfo = MISPRITE(pDev);
+
+            if (pCursorInfo->isUp &&
+                pCursorInfo->pScreen == pScreen &&
+                RegionContainsRect(pRegion, &pCursorInfo->saved) != rgnOUT)
+            {
+                SPRITE_DEBUG(("Damage remove\n"));
+                miSpriteRemoveCursor (pDev, pScreen);
+            }
+        }
+    }
+}
+
+/*
+ * miSpriteInitialize -- called from device-dependent screen
+ * initialization proc after all of the function pointers have
+ * been stored in the screen structure.
+ */
+
+Bool
+miSpriteInitialize (ScreenPtr               pScreen,
+                    miPointerScreenFuncPtr  screenFuncs)
+{
+    miSpriteScreenPtr	pScreenPriv;
+    VisualPtr		pVisual;
+
+    if (!DamageSetup (pScreen))
+	return FALSE;
+
+    if (!dixRegisterPrivateKey(&miSpriteScreenKeyRec, PRIVATE_SCREEN, 0))
+	return FALSE;
+
+    if (!dixRegisterPrivateKey(&miSpriteDevPrivatesKeyRec, PRIVATE_DEVICE, sizeof(miCursorInfoRec)))
+	return FALSE;
+
+    pScreenPriv = malloc(sizeof (miSpriteScreenRec));
+    if (!pScreenPriv)
+	return FALSE;
+
+    pScreenPriv->pDamage = DamageCreate (miSpriteReportDamage,
+					 NULL,
+					 DamageReportRawRegion,
+					 TRUE,
+					 pScreen,
+					 pScreen);
+
+    if (!miPointerInitialize (pScreen, &miSpritePointerFuncs, screenFuncs,TRUE))
+    {
+	free(pScreenPriv);
+	return FALSE;
+    }
+    for (pVisual = pScreen->visuals;
+	 pVisual->vid != pScreen->rootVisual;
+	 pVisual++)
+	;
+    pScreenPriv->pVisual = pVisual;
+    pScreenPriv->CloseScreen = pScreen->CloseScreen;
+    pScreenPriv->GetImage = pScreen->GetImage;
+    pScreenPriv->GetSpans = pScreen->GetSpans;
+    pScreenPriv->SourceValidate = pScreen->SourceValidate;
+
+    pScreenPriv->CopyWindow = pScreen->CopyWindow;
+
+    pScreenPriv->InstallColormap = pScreen->InstallColormap;
+    pScreenPriv->StoreColors = pScreen->StoreColors;
+
+    pScreenPriv->BlockHandler = NULL;
+
+    pScreenPriv->DeviceCursorInitialize = pScreen->DeviceCursorInitialize;
+    pScreenPriv->DeviceCursorCleanup = pScreen->DeviceCursorCleanup;
+
+    pScreenPriv->pInstalledMap = NULL;
+    pScreenPriv->pColormap = NULL;
+    pScreenPriv->colors[SOURCE_COLOR].red = 0;
+    pScreenPriv->colors[SOURCE_COLOR].green = 0;
+    pScreenPriv->colors[SOURCE_COLOR].blue = 0;
+    pScreenPriv->colors[MASK_COLOR].red = 0;
+    pScreenPriv->colors[MASK_COLOR].green = 0;
+    pScreenPriv->colors[MASK_COLOR].blue = 0;
+    pScreenPriv->damageRegistered = 0;
+    pScreenPriv->numberOfCursors = 0;
+
+    dixSetPrivate(&pScreen->devPrivates, miSpriteScreenKey, pScreenPriv);
+
+    pScreen->CloseScreen = miSpriteCloseScreen;
+    pScreen->GetImage = miSpriteGetImage;
+    pScreen->GetSpans = miSpriteGetSpans;
+    pScreen->SourceValidate = miSpriteSourceValidate;
+
+    pScreen->CopyWindow = miSpriteCopyWindow;
+    pScreen->InstallColormap = miSpriteInstallColormap;
+    pScreen->StoreColors = miSpriteStoreColors;
+
+    return TRUE;
+}
+
+/*
+ * Screen wrappers
+ */
+
+/*
+ * CloseScreen wrapper -- unwrap everything, free the private data
+ * and call the wrapped function
+ */
+
+static Bool
+miSpriteCloseScreen (int i, ScreenPtr pScreen)
+{
+    miSpriteScreenPtr   pScreenPriv = GetSpriteScreen(pScreen);
+
+    pScreen->CloseScreen = pScreenPriv->CloseScreen;
+    pScreen->GetImage = pScreenPriv->GetImage;
+    pScreen->GetSpans = pScreenPriv->GetSpans;
+    pScreen->SourceValidate = pScreenPriv->SourceValidate;
+    pScreen->InstallColormap = pScreenPriv->InstallColormap;
+    pScreen->StoreColors = pScreenPriv->StoreColors;
+
+    DamageDestroy (pScreenPriv->pDamage);
+
+    free(pScreenPriv);
+
+    return (*pScreen->CloseScreen) (i, pScreen);
+}
+
+static void
+miSpriteGetImage (DrawablePtr pDrawable, int sx, int sy, int w, int h,
+                  unsigned int format, unsigned long planemask,
+                  char *pdstLine)
+{
+    ScreenPtr           pScreen = pDrawable->pScreen;
+    DeviceIntPtr        pDev;
+    miCursorInfoPtr     pCursorInfo;
+    miSpriteScreenPtr   pPriv = GetSpriteScreen(pScreen);
+
+    SCREEN_PROLOGUE (pPriv, pScreen, GetImage);
+
+    if (pDrawable->type == DRAWABLE_WINDOW)
+    {
+        for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
+        {
+            if (DevHasCursor(pDev))
+            {
+                 pCursorInfo = MISPRITE(pDev);
+                 if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen &&
+                      ORG_OVERLAP(&pCursorInfo->saved,pDrawable->x,pDrawable->y,
+                                  sx, sy, w, h))
+                 {
+                     SPRITE_DEBUG (("GetImage remove\n"));
+                     miSpriteRemoveCursor (pDev, pScreen);
+                 }
+            }
+        }
+    }
+
+    (*pScreen->GetImage) (pDrawable, sx, sy, w, h,
+			  format, planemask, pdstLine);
+
+    SCREEN_EPILOGUE (pPriv, pScreen, GetImage);
+}
+
+static void
+miSpriteGetSpans (DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
+                  int *pwidth, int nspans, char *pdstStart)
+{
+    ScreenPtr		    pScreen = pDrawable->pScreen;
+    DeviceIntPtr            pDev;
+    miCursorInfoPtr         pCursorInfo;
+    miSpriteScreenPtr       pPriv = GetSpriteScreen(pScreen);
+
+    SCREEN_PROLOGUE (pPriv, pScreen, GetSpans);
+
+    if (pDrawable->type == DRAWABLE_WINDOW)
+    {
+        for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
+        {
+            if (DevHasCursor(pDev))
+            {
+                pCursorInfo = MISPRITE(pDev);
+
+                if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen)
+                {
+                    DDXPointPtr    pts;
+                    int    	       *widths;
+                    int    	       nPts;
+                    int    	       xorg,
+                                   yorg;
+
+                    xorg = pDrawable->x;
+                    yorg = pDrawable->y;
+
+                    for (pts = ppt, widths = pwidth, nPts = nspans;
+                            nPts--;
+                            pts++, widths++)
+                    {
+                        if (SPN_OVERLAP(&pCursorInfo->saved,pts->y+yorg,
+                                    pts->x+xorg,*widths))
+                        {
+                            SPRITE_DEBUG (("GetSpans remove\n"));
+                            miSpriteRemoveCursor (pDev, pScreen);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
+
+    SCREEN_EPILOGUE (pPriv, pScreen, GetSpans);
+}
+
+static void
+miSpriteSourceValidate (DrawablePtr pDrawable, int x, int y, int width,
+                        int height, unsigned int subWindowMode)
+{
+    ScreenPtr		    pScreen = pDrawable->pScreen;
+    DeviceIntPtr            pDev;
+    miCursorInfoPtr         pCursorInfo;
+    miSpriteScreenPtr       pPriv = GetSpriteScreen(pScreen);
+
+    SCREEN_PROLOGUE (pPriv, pScreen, SourceValidate);
+
+    if (pDrawable->type == DRAWABLE_WINDOW)
+    {
+	for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
+	{
+	    if (DevHasCursor(pDev))
+	    {
+		pCursorInfo = MISPRITE(pDev);
+		if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen &&
+		    ORG_OVERLAP(&pCursorInfo->saved, pDrawable->x, pDrawable->y,
+				x, y, width, height))
+		{
+		    SPRITE_DEBUG (("SourceValidate remove\n"));
+		    miSpriteRemoveCursor (pDev, pScreen);
+		}
+	    }
+	}
+    }
+
+    if (pScreen->SourceValidate)
+	(*pScreen->SourceValidate) (pDrawable, x, y, width, height, subWindowMode);
+
+    SCREEN_EPILOGUE (pPriv, pScreen, SourceValidate);
+}
+
+static void
+miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
+{
+    ScreenPtr	pScreen = pWindow->drawable.pScreen;
+    DeviceIntPtr            pDev;
+    miCursorInfoPtr         pCursorInfo;
+    miSpriteScreenPtr       pPriv = GetSpriteScreen(pScreen);
+
+    SCREEN_PROLOGUE (pPriv, pScreen, CopyWindow);
+
+    for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
+    {
+        if (DevHasCursor(pDev))
+        {
+            pCursorInfo = MISPRITE(pDev);
+            /*
+             * Damage will take care of destination check
+             */
+            if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen &&
+                    RegionContainsRect(prgnSrc, &pCursorInfo->saved) != rgnOUT)
+            {
+                SPRITE_DEBUG (("CopyWindow remove\n"));
+                miSpriteRemoveCursor (pDev, pScreen);
+            }
+        }
+    }
+
+    (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
+    SCREEN_EPILOGUE (pPriv, pScreen, CopyWindow);
+}
+
+static void
+miSpriteBlockHandler (int i, pointer blockData, pointer pTimeout,
+                      pointer pReadmask)
+{
+    ScreenPtr		pScreen = screenInfo.screens[i];
+    miSpriteScreenPtr	pPriv = GetSpriteScreen(pScreen);
+    DeviceIntPtr            pDev;
+    miCursorInfoPtr         pCursorInfo;
+    Bool                WorkToDo = FALSE;
+
+    for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
+    {
+        if (DevHasCursor(pDev))
+        {
+            pCursorInfo = MISPRITE(pDev);
+            if (pCursorInfo && !pCursorInfo->isUp
+                    && pCursorInfo->pScreen == pScreen
+                    && pCursorInfo->shouldBeUp)
+            {
+                SPRITE_DEBUG (("BlockHandler save"));
+                miSpriteSaveUnderCursor (pDev, pScreen);
+            }
+        }
+    }
+    for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
+    {
+        if (DevHasCursor(pDev))
+        {
+            pCursorInfo = MISPRITE(pDev);
+            if (pCursorInfo && !pCursorInfo->isUp &&
+                    pCursorInfo->pScreen == pScreen &&
+                    pCursorInfo->shouldBeUp)
+            {
+                SPRITE_DEBUG (("BlockHandler restore\n"));
+                miSpriteRestoreCursor (pDev, pScreen);
+                if (!pCursorInfo->isUp)
+                    WorkToDo = TRUE;
+            }
+        }
+    }
+
+    SCREEN_PROLOGUE(pPriv, pScreen, BlockHandler);
+
+    (*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);
+
+    if (WorkToDo)
+        SCREEN_EPILOGUE(pPriv, pScreen, BlockHandler);
+    else
+        pPriv->BlockHandler = NULL;
+}
+
+static void
+miSpriteInstallColormap (ColormapPtr pMap)
+{
+    ScreenPtr		pScreen = pMap->pScreen;
+    miSpriteScreenPtr	pPriv = GetSpriteScreen(pScreen);
+
+    SCREEN_PROLOGUE(pPriv, pScreen, InstallColormap);
+
+    (*pScreen->InstallColormap) (pMap);
+
+    SCREEN_EPILOGUE(pPriv, pScreen, InstallColormap);
+
+    /* InstallColormap can be called before devices are initialized. */
+    pPriv->pInstalledMap = pMap;
+    if (pPriv->pColormap != pMap)
+    {
+        DeviceIntPtr pDev;
+        miCursorInfoPtr     pCursorInfo;
+        for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
+        {
+            if (DevHasCursor(pDev))
+            {
+                pCursorInfo = MISPRITE(pDev);
+                pCursorInfo->checkPixels = TRUE;
+                if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen)
+                    miSpriteRemoveCursor(pDev, pScreen);
+            }
+        }
+
+    }
+}
+
+static void
+miSpriteStoreColors (ColormapPtr pMap, int ndef, xColorItem *pdef)
+{
+    ScreenPtr		pScreen = pMap->pScreen;
+    miSpriteScreenPtr	pPriv = GetSpriteScreen(pScreen);
+    int			i;
+    int			updated;
+    VisualPtr		pVisual;
+    DeviceIntPtr        pDev;
+    miCursorInfoPtr     pCursorInfo;
+
+    SCREEN_PROLOGUE(pPriv, pScreen, StoreColors);
+
+    (*pScreen->StoreColors) (pMap, ndef, pdef);
+
+    SCREEN_EPILOGUE(pPriv, pScreen, StoreColors);
+
+    if (pPriv->pColormap == pMap)
+    {
+        updated = 0;
+        pVisual = pMap->pVisual;
+        if (pVisual->class == DirectColor)
+        {
+            /* Direct color - match on any of the subfields */
+
+#define MaskMatch(a,b,mask) (((a) & (pVisual->mask)) == ((b) & (pVisual->mask)))
+
+#define UpdateDAC(dev, plane,dac,mask) {\
+    if (MaskMatch (dev->colors[plane].pixel,pdef[i].pixel,mask)) {\
+	dev->colors[plane].dac = pdef[i].dac; \
+	updated = 1; \
+    } \
+}
+
+#define CheckDirect(dev, plane) \
+	    UpdateDAC(dev, plane,red,redMask) \
+	    UpdateDAC(dev, plane,green,greenMask) \
+	    UpdateDAC(dev, plane,blue,blueMask)
+
+            for (i = 0; i < ndef; i++)
+            {
+                CheckDirect (pPriv, SOURCE_COLOR)
+                CheckDirect (pPriv, MASK_COLOR)
+            }
+        }
+        else
+        {
+            /* PseudoColor/GrayScale - match on exact pixel */
+            for (i = 0; i < ndef; i++)
+            {
+                if (pdef[i].pixel ==
+                        pPriv->colors[SOURCE_COLOR].pixel)
+                {
+                    pPriv->colors[SOURCE_COLOR] = pdef[i];
+                    if (++updated == 2)
+                        break;
+                }
+                if (pdef[i].pixel ==
+                        pPriv->colors[MASK_COLOR].pixel)
+                {
+                    pPriv->colors[MASK_COLOR] = pdef[i];
+                    if (++updated == 2)
+                        break;
+                }
+            }
+        }
+        if (updated)
+        {
+            for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
+            {
+                if (DevHasCursor(pDev))
+                {
+                    pCursorInfo = MISPRITE(pDev);
+                    pCursorInfo->checkPixels = TRUE;
+                    if (pCursorInfo->isUp && pCursorInfo->pScreen == pScreen)
+                        miSpriteRemoveCursor (pDev, pScreen);
+                }
+            }
+        }
+    }
+}
+
+static void
+miSpriteFindColors (miCursorInfoPtr pDevCursor, ScreenPtr pScreen)
+{
+    miSpriteScreenPtr	pScreenPriv = GetSpriteScreen(pScreen);
+    CursorPtr		pCursor;
+    xColorItem		*sourceColor, *maskColor;
+
+    pCursor = pDevCursor->pCursor;
+    sourceColor = &pScreenPriv->colors[SOURCE_COLOR];
+    maskColor = &pScreenPriv->colors[MASK_COLOR];
+    if (pScreenPriv->pColormap != pScreenPriv->pInstalledMap ||
+	!(pCursor->foreRed == sourceColor->red &&
+	  pCursor->foreGreen == sourceColor->green &&
+          pCursor->foreBlue == sourceColor->blue &&
+	  pCursor->backRed == maskColor->red &&
+	  pCursor->backGreen == maskColor->green &&
+	  pCursor->backBlue == maskColor->blue))
+    {
+	pScreenPriv->pColormap = pScreenPriv->pInstalledMap;
+	sourceColor->red = pCursor->foreRed;
+	sourceColor->green = pCursor->foreGreen;
+	sourceColor->blue = pCursor->foreBlue;
+	FakeAllocColor (pScreenPriv->pColormap, sourceColor);
+	maskColor->red = pCursor->backRed;
+	maskColor->green = pCursor->backGreen;
+	maskColor->blue = pCursor->backBlue;
+	FakeAllocColor (pScreenPriv->pColormap, maskColor);
+	/* "free" the pixels right away, don't let this confuse you */
+	FakeFreeColor(pScreenPriv->pColormap, sourceColor->pixel);
+	FakeFreeColor(pScreenPriv->pColormap, maskColor->pixel);
+    }
+
+    pDevCursor->checkPixels = FALSE;
+
+}
+
+/*
+ * miPointer interface routines
+ */
+
+#define SPRITE_PAD  8
+
+static Bool
+miSpriteRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
+{
+    miCursorInfoPtr pCursorInfo;
+
+    if (IsFloating(pDev))
+        return FALSE;
+
+    pCursorInfo = MISPRITE(pDev);
+
+    if (pCursor == pCursorInfo->pCursor)
+	pCursorInfo->checkPixels = TRUE;
+
+    return miDCRealizeCursor(pScreen, pCursor);
+}
+
+static Bool
+miSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
+{
+    return miDCUnrealizeCursor(pScreen, pCursor);
+}
+
+static void
+miSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
+                   CursorPtr pCursor, int x, int y)
+{
+    miCursorInfoPtr     pPointer;
+    miSpriteScreenPtr   pScreenPriv;
+
+    if (IsFloating(pDev))
+        return;
+
+    pPointer = MISPRITE(pDev);
+    pScreenPriv = GetSpriteScreen(pScreen);
+
+    if (!pCursor)
+    {
+	if (pPointer->shouldBeUp)
+	    --pScreenPriv->numberOfCursors;
+    	pPointer->shouldBeUp = FALSE;
+    	if (pPointer->isUp)
+	    miSpriteRemoveCursor (pDev, pScreen);
+	if (pScreenPriv->numberOfCursors == 0)
+	    miSpriteDisableDamage(pScreen, pScreenPriv);
+	pPointer->pCursor = 0;
+	return;
+    }
+    if (!pPointer->shouldBeUp)
+	pScreenPriv->numberOfCursors++;
+    pPointer->shouldBeUp = TRUE;
+    if (!pPointer->isUp)
+	miSpriteRegisterBlockHandler(pScreen, pScreenPriv);
+    if (pPointer->x == x &&
+	pPointer->y == y &&
+	pPointer->pCursor == pCursor &&
+	!pPointer->checkPixels)
+    {
+	return;
+    }
+    pPointer->x = x;
+    pPointer->y = y;
+    pPointer->pCacheWin = NullWindow;
+    if (pPointer->checkPixels || pPointer->pCursor != pCursor)
+    {
+	pPointer->pCursor = pCursor;
+	miSpriteFindColors (pPointer, pScreen);
+    }
+    if (pPointer->isUp) {
+	/* TODO: reimplement flicker-free MoveCursor */
+	SPRITE_DEBUG (("SetCursor remove %d\n", pDev->id));
+	miSpriteRemoveCursor (pDev, pScreen);
+    }
+
+    if (!pPointer->isUp && pPointer->pCursor)
+    {
+	SPRITE_DEBUG (("SetCursor restore %d\n", pDev->id));
+        miSpriteSaveUnderCursor(pDev, pScreen);
+	miSpriteRestoreCursor (pDev, pScreen);
+    }
+
+}
+
+static void
+miSpriteMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+{
+    CursorPtr pCursor;
+
+    if (IsFloating(pDev))
+        return;
+
+    pCursor = MISPRITE(pDev)->pCursor;
+
+    miSpriteSetCursor (pDev, pScreen, pCursor, x, y);
+}
+
+
+static Bool
+miSpriteDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    int ret = miDCDeviceInitialize(pDev, pScreen);
+
+    if (ret)
+    {
+        miCursorInfoPtr pCursorInfo;
+        pCursorInfo = dixLookupPrivate(&pDev->devPrivates, miSpriteDevPrivatesKey);
+        pCursorInfo->pCursor = NULL;
+        pCursorInfo->x = 0;
+        pCursorInfo->y = 0;
+        pCursorInfo->isUp = FALSE;
+        pCursorInfo->shouldBeUp = FALSE;
+        pCursorInfo->pCacheWin = NullWindow;
+        pCursorInfo->isInCacheWin = FALSE;
+        pCursorInfo->checkPixels = TRUE;
+        pCursorInfo->pScreen = FALSE;
+    }
+
+    return ret;
+}
+
+static void
+miSpriteDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    miCursorInfoPtr pCursorInfo = dixLookupPrivate(&pDev->devPrivates, miSpriteDevPrivatesKey);
+
+    if (DevHasCursor(pDev))
+        miDCDeviceCleanup(pDev, pScreen);
+
+    memset(pCursorInfo, 0, sizeof(miCursorInfoRec));
+}
+
+/*
+ * undraw/draw cursor
+ */
+
+static void
+miSpriteRemoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    miSpriteScreenPtr   pScreenPriv;
+    miCursorInfoPtr     pCursorInfo;
+
+
+    if (IsFloating(pDev))
+        return;
+
+    DamageDrawInternal (pScreen, TRUE);
+    pScreenPriv = GetSpriteScreen(pScreen);
+    pCursorInfo = MISPRITE(pDev);
+
+    miSpriteIsDown(pCursorInfo);
+    miSpriteRegisterBlockHandler(pScreen, pScreenPriv);
+    pCursorInfo->pCacheWin = NullWindow;
+    miSpriteDisableDamage(pScreen, pScreenPriv);
+    if (!miDCRestoreUnderCursor(pDev,
+                                pScreen,
+                                pCursorInfo->saved.x1,
+                                pCursorInfo->saved.y1,
+                                pCursorInfo->saved.x2 -
+                                pCursorInfo->saved.x1,
+                                pCursorInfo->saved.y2 -
+                                pCursorInfo->saved.y1))
+    {
+        miSpriteIsUp(pCursorInfo);
+    }
+    miSpriteEnableDamage(pScreen, pScreenPriv);
+    DamageDrawInternal (pScreen, FALSE);
+}
+
+/*
+ * Called from the block handler, saves area under cursor
+ * before waiting for something to do.
+ */
+
+static void
+miSpriteSaveUnderCursor(DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    miSpriteScreenPtr   pScreenPriv;
+    miCursorInfoPtr     pCursorInfo;
+
+    if (IsFloating(pDev))
+        return;
+
+    DamageDrawInternal (pScreen, TRUE);
+    pScreenPriv = GetSpriteScreen(pScreen);
+    pCursorInfo = MISPRITE(pDev);
+
+    miSpriteComputeSaved (pDev, pScreen);
+
+    miSpriteDisableDamage(pScreen, pScreenPriv);
+
+    miDCSaveUnderCursor(pDev,
+                        pScreen,
+                        pCursorInfo->saved.x1,
+                        pCursorInfo->saved.y1,
+                        pCursorInfo->saved.x2 -
+                        pCursorInfo->saved.x1,
+                        pCursorInfo->saved.y2 -
+                        pCursorInfo->saved.y1);
+    SPRITE_DEBUG(("SaveUnderCursor %d\n", pDev->id));
+    miSpriteEnableDamage(pScreen, pScreenPriv);
+    DamageDrawInternal (pScreen, FALSE);
+}
+
+
+/*
+ * Called from the block handler, restores the cursor
+ * before waiting for something to do.
+ */
+
+static void
+miSpriteRestoreCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    miSpriteScreenPtr   pScreenPriv;
+    int			x, y;
+    CursorPtr		pCursor;
+    miCursorInfoPtr     pCursorInfo;
+
+    if (IsFloating(pDev))
+        return;
+
+    DamageDrawInternal (pScreen, TRUE);
+    pScreenPriv = GetSpriteScreen(pScreen);
+    pCursorInfo = MISPRITE(pDev);
+
+    miSpriteComputeSaved (pDev, pScreen);
+    pCursor = pCursorInfo->pCursor;
+
+    x = pCursorInfo->x - (int)pCursor->bits->xhot;
+    y = pCursorInfo->y - (int)pCursor->bits->yhot;
+    miSpriteDisableDamage(pScreen, pScreenPriv);
+    SPRITE_DEBUG(("RestoreCursor %d\n", pDev->id));
+    if (pCursorInfo->checkPixels)
+        miSpriteFindColors (pCursorInfo, pScreen);
+    if (miDCPutUpCursor(pDev, pScreen,
+                pCursor, x, y,
+                pScreenPriv->colors[SOURCE_COLOR].pixel,
+                pScreenPriv->colors[MASK_COLOR].pixel))
+    {
+        miSpriteIsUp(pCursorInfo);
+        pCursorInfo->pScreen = pScreen;
+    }
+    miSpriteEnableDamage(pScreen, pScreenPriv);
+    DamageDrawInternal (pScreen, FALSE);
+}
+
+/*
+ * compute the desired area of the screen to save
+ */
+
+static void
+miSpriteComputeSaved (DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    int		    x, y, w, h;
+    int		    wpad, hpad;
+    CursorPtr	    pCursor;
+    miCursorInfoPtr pCursorInfo;
+
+    if (IsFloating(pDev))
+        return;
+
+    pCursorInfo = MISPRITE(pDev);
+
+    pCursor = pCursorInfo->pCursor;
+    x = pCursorInfo->x - (int)pCursor->bits->xhot;
+    y = pCursorInfo->y - (int)pCursor->bits->yhot;
+    w = pCursor->bits->width;
+    h = pCursor->bits->height;
+    wpad = SPRITE_PAD;
+    hpad = SPRITE_PAD;
+    pCursorInfo->saved.x1 = x - wpad;
+    pCursorInfo->saved.y1 = y - hpad;
+    pCursorInfo->saved.x2 = pCursorInfo->saved.x1 + w + wpad * 2;
+    pCursorInfo->saved.y2 = pCursorInfo->saved.y1 + h + hpad * 2;
+}
+
diff --git a/xorg-server/mi/mivaltree.c b/xorg-server/mi/mivaltree.c
index 36ec8e60a..e1d47c06f 100644
--- a/xorg-server/mi/mivaltree.c
+++ b/xorg-server/mi/mivaltree.c
@@ -1,813 +1,811 @@
-/*

- * mivaltree.c --

- *	Functions for recalculating window clip lists. Main function

- *	is miValidateTree.

- *

-

-Copyright 1987, 1988, 1989, 1998  The Open Group

-

-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.

-

-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 THE

-OPEN GROUP 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 The Open Group shall not be

-used in advertising or otherwise to promote the sale, use or other dealings

-in this Software without prior written authorization from The Open Group.

-

- *

- * Copyright 1987, 1988, 1989 by 

- * Digital Equipment Corporation, Maynard, Massachusetts,

- * 

- *                         All Rights Reserved

- * 

- * Permission to use, copy, modify, and distribute this software and its 

- * documentation for any purpose and without fee is hereby granted, 

- * 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 Digital not be

- * used in advertising or publicity pertaining to distribution of the

- * software without specific, written prior permission.  

- * 

- * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * DIGITAL 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.

- * 

- ******************************************************************/

-

-/* The panoramix components contained the following notice */

-/*****************************************************************

-

-Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.

-

-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.

-

-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

-DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,

-BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL 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 Digital Equipment Corporation

-shall not be used in advertising or otherwise to promote the sale, use or other

-dealings in this Software without prior written authorization from Digital

-Equipment Corporation.

-

-******************************************************************/

-

-

- /* 

-  * Aug '86: Susan Angebranndt -- original code

-  * July '87: Adam de Boor -- substantially modified and commented

-  * Summer '89: Joel McCormack -- so fast you wouldn't believe it possible.

-  *             In particular, much improved code for window mapping and

-  *             circulating.

-  *		Bob Scheifler -- avoid miComputeClips for unmapped windows,

-  *				 valdata changes

-  */

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include    <X11/X.h>

-#include    "scrnintstr.h"

-#include    "validate.h"

-#include    "windowstr.h"

-#include    "mi.h"

-#include    "regionstr.h"

-#include    "mivalidate.h"

-

-#include    "globals.h"

-

-/*

- * Compute the visibility of a shaped window

- */

-int

-miShapedWindowIn (RegionPtr universe, RegionPtr bounding,

-                  BoxPtr rect, int x, int y)

-{

-    BoxRec  	box;

-    BoxPtr	boundBox;

-    int		nbox;

-    Bool	someIn, someOut;

-    int 	t, x1, y1, x2, y2;

-

-    nbox = RegionNumRects (bounding);

-    boundBox = RegionRects (bounding);

-    someIn = someOut = FALSE;

-    x1 = rect->x1;

-    y1 = rect->y1;

-    x2 = rect->x2;

-    y2 = rect->y2;

-    while (nbox--)

-    {

-	if ((t = boundBox->x1 + x) < x1)

-	    t = x1;

-	box.x1 = t;

-	if ((t = boundBox->y1 + y) < y1)

-	    t = y1;

-	box.y1 = t;

-	if ((t = boundBox->x2 + x) > x2)

-	    t = x2;

-	box.x2 = t;

-	if ((t = boundBox->y2 + y) > y2)

-	    t = y2;

-	box.y2 = t;

-	if (box.x1 > box.x2)

-	    box.x2 = box.x1;

-	if (box.y1 > box.y2)

-	    box.y2 = box.y1;

-	switch (RegionContainsRect(universe, &box))

-	{

-	case rgnIN:

-	    if (someOut)

-		return rgnPART;

-	    someIn = TRUE;

-	    break;

-	case rgnOUT:

-	    if (someIn)

-		return rgnPART;

-	    someOut = TRUE;

-	    break;

-	default:

-	    return rgnPART;

-	}

-	boundBox++;

-    }

-    if (someIn)

-	return rgnIN;

-    return rgnOUT;

-}

-

-static GetRedirectBorderClipProcPtr	miGetRedirectBorderClipProc;

-static SetRedirectBorderClipProcPtr	miSetRedirectBorderClipProc;

-

-void

-miRegisterRedirectBorderClipProc (SetRedirectBorderClipProcPtr setBorderClip,

-				  GetRedirectBorderClipProcPtr getBorderClip)

-{

-    miSetRedirectBorderClipProc = setBorderClip;

-    miGetRedirectBorderClipProc = getBorderClip;

-}

-

-/*

- * Manual redirected windows are treated as transparent; they do not obscure

- * siblings or parent windows

- */

-

-#ifdef COMPOSITE

-#define TreatAsTransparent(w)	((w)->redirectDraw == RedirectDrawManual)

-#else

-#define TreatAsTransparent(w)	FALSE

-#endif

-

-#define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \

-				    HasBorder(w) && \

-				    (w)->backgroundState == ParentRelative)

-

-

-/*

- *-----------------------------------------------------------------------

- * miComputeClips --

- *	Recompute the clipList, borderClip, exposed and borderExposed

- *	regions for pParent and its children. Only viewable windows are

- *	taken into account.

- *

- * Results:

- *	None.

- *

- * Side Effects:

- *	clipList, borderClip, exposed and borderExposed are altered.

- *	A VisibilityNotify event may be generated on the parent window.

- *

- *-----------------------------------------------------------------------

- */

-static void

-miComputeClips (

-    WindowPtr	pParent,

-    ScreenPtr	pScreen,

-    RegionPtr	universe,

-    VTKind		kind,

-    RegionPtr		exposed ) /* for intermediate calculations */

-{

-    int			dx,

-			dy;

-    RegionRec		childUniverse;

-    WindowPtr		pChild;

-    int     	  	oldVis, newVis;

-    BoxRec		borderSize;

-    RegionRec		childUnion;

-    Bool		overlap;

-    RegionPtr		borderVisible;

-    Bool		resized;

-    /*

-     * Figure out the new visibility of this window.

-     * The extent of the universe should be the same as the extent of

-     * the borderSize region. If the window is unobscured, this rectangle

-     * will be completely inside the universe (the universe will cover it

-     * completely). If the window is completely obscured, none of the

-     * universe will cover the rectangle.

-     */

-    borderSize.x1 = pParent->drawable.x - wBorderWidth(pParent);

-    borderSize.y1 = pParent->drawable.y - wBorderWidth(pParent);

-    dx = (int) pParent->drawable.x + (int) pParent->drawable.width + wBorderWidth(pParent);

-    if (dx > 32767)

-	dx = 32767;

-    borderSize.x2 = dx;

-    dy = (int) pParent->drawable.y + (int) pParent->drawable.height + wBorderWidth(pParent);

-    if (dy > 32767)

-	dy = 32767;

-    borderSize.y2 = dy;

-

-#ifdef COMPOSITE

-    /*

-     * In redirected drawing case, reset universe to borderSize

-     */

-    if (pParent->redirectDraw != RedirectDrawNone)

-    {

-	if (miSetRedirectBorderClipProc)

-	{

-	    if (TreatAsTransparent (pParent))

-		RegionEmpty(universe);

-	    (*miSetRedirectBorderClipProc) (pParent, universe);

-	}

-	RegionCopy(universe, &pParent->borderSize);

-    }

-#endif

-

-    oldVis = pParent->visibility;

-    switch (RegionContainsRect(universe, &borderSize))

-    {

-	case rgnIN:

-	    newVis = VisibilityUnobscured;

-	    break;

-	case rgnPART:

-	    newVis = VisibilityPartiallyObscured;

-	    {

-		RegionPtr   pBounding;

-

-		if ((pBounding = wBoundingShape (pParent)))

-		{

-		    switch (miShapedWindowIn (universe, pBounding,

-					      &borderSize,

-					      pParent->drawable.x,

- 					      pParent->drawable.y))

-		    {

-		    case rgnIN:

-			newVis = VisibilityUnobscured;

-			break;

-		    case rgnOUT:

-			newVis = VisibilityFullyObscured;

-			break;

-		    }

-		}

-	    }

-	    break;

-	default:

-	    newVis = VisibilityFullyObscured;

-	    break;

-    }

-    pParent->visibility = newVis;

-    if (oldVis != newVis &&

-	((pParent->eventMask | wOtherEventMasks(pParent)) & VisibilityChangeMask))

-	SendVisibilityNotify(pParent);

-

-    dx = pParent->drawable.x - pParent->valdata->before.oldAbsCorner.x;

-    dy = pParent->drawable.y - pParent->valdata->before.oldAbsCorner.y;

-

-    /*

-     * avoid computations when dealing with simple operations

-     */

-

-    switch (kind) {

-    case VTMap:

-    case VTStack:

-    case VTUnmap:

-	break;

-    case VTMove:

-	if ((oldVis == newVis) &&

-	    ((oldVis == VisibilityFullyObscured) ||

-	     (oldVis == VisibilityUnobscured)))

-	{

-	    pChild = pParent;

-	    while (1)

-	    {

-		if (pChild->viewable)

-		{

-		    if (pChild->visibility != VisibilityFullyObscured)

-		    {

-			RegionTranslate(&pChild->borderClip,

-						      dx, dy);

-			RegionTranslate(&pChild->clipList,

-						      dx, dy);

-			pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;

-			if (pScreen->ClipNotify)

-			    (* pScreen->ClipNotify) (pChild, dx, dy);

-

-		    }

-		    if (pChild->valdata)

-		    {

-			RegionNull(&pChild->valdata->after.borderExposed);

-			if (HasParentRelativeBorder(pChild))

-			{

-			    RegionSubtract(&pChild->valdata->after.borderExposed,

-					   &pChild->borderClip,

-					   &pChild->winSize);

-			}

-			RegionNull(&pChild->valdata->after.exposed);

-		    }

-		    if (pChild->firstChild)

-		    {

-			pChild = pChild->firstChild;

-			continue;

-		    }

-		}

-		while (!pChild->nextSib && (pChild != pParent))

-		    pChild = pChild->parent;

-		if (pChild == pParent)

-		    break;

-		pChild = pChild->nextSib;

-	    }

-	    return;

-	}

-	/* fall through */

-    default:

-    	/*

-     	 * To calculate exposures correctly, we have to translate the old

-     	 * borderClip and clipList regions to the window's new location so there

-     	 * is a correspondence between pieces of the new and old clipping regions.

-     	 */

-    	if (dx || dy) 

-    	{

-	    /*

-	     * We translate the old clipList because that will be exposed or copied

-	     * if gravity is right.

-	     */

-	    RegionTranslate(&pParent->borderClip, dx, dy);

-	    RegionTranslate(&pParent->clipList, dx, dy);

-    	} 

-	break;

-    case VTBroken:

-	RegionEmpty(&pParent->borderClip);

-	RegionEmpty(&pParent->clipList);

-	break;

-    }

-

-    borderVisible = pParent->valdata->before.borderVisible;

-    resized = pParent->valdata->before.resized;

-    RegionNull(&pParent->valdata->after.borderExposed);

-    RegionNull(&pParent->valdata->after.exposed);

-

-    /*

-     * Since the borderClip must not be clipped by the children, we do

-     * the border exposure first...

-     *

-     * 'universe' is the window's borderClip. To figure the exposures, remove

-     * the area that used to be exposed from the new.

-     * This leaves a region of pieces that weren't exposed before.

-     */

-

-    if (HasBorder (pParent))

-    {

-    	if (borderVisible)

-    	{

-	    /*

-	     * when the border changes shape, the old visible portions

-	     * of the border will be saved by DIX in borderVisible --

-	     * use that region and destroy it

-	     */

-	    RegionSubtract(exposed, universe, borderVisible);

-	    RegionDestroy(borderVisible);

-    	}

-    	else

-    	{

-	    RegionSubtract(exposed, universe, &pParent->borderClip);

-    	}

-	if (HasParentRelativeBorder(pParent) && (dx || dy))

-	    RegionSubtract(&pParent->valdata->after.borderExposed,

-				  universe,

-				  &pParent->winSize);

-	else

-	    RegionSubtract(&pParent->valdata->after.borderExposed,

-			       exposed, &pParent->winSize);

-

-	RegionCopy(&pParent->borderClip, universe);

-    

-    	/*

-     	 * To get the right clipList for the parent, and to make doubly sure

-     	 * that no child overlaps the parent's border, we remove the parent's

-     	 * border from the universe before proceeding.

-     	 */

-    

-	RegionIntersect(universe, universe, &pParent->winSize);

-    }

-    else

-	RegionCopy(&pParent->borderClip, universe);

-    

-    if ((pChild = pParent->firstChild) && pParent->mapped)

-    {

-	RegionNull(&childUniverse);

-	RegionNull(&childUnion);

-	if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||

-	    ((pChild->drawable.y == pParent->lastChild->drawable.y) &&

-	     (pChild->drawable.x < pParent->lastChild->drawable.x)))

-	{

-	    for (; pChild; pChild = pChild->nextSib)

-	    {

-		if (pChild->viewable && !TreatAsTransparent(pChild))

-		    RegionAppend(&childUnion, &pChild->borderSize);

-	    }

-	}

-	else

-	{

-	    for (pChild = pParent->lastChild; pChild; pChild = pChild->prevSib)

-	    {

-		if (pChild->viewable && !TreatAsTransparent(pChild))

-		    RegionAppend(&childUnion, &pChild->borderSize);

-	    }

-	}

-	RegionValidate(&childUnion, &overlap);

-

-	for (pChild = pParent->firstChild;

-	     pChild;

-	     pChild = pChild->nextSib)

- 	{

-	    if (pChild->viewable) {

-		/*

-		 * If the child is viewable, we want to remove its extents

-		 * from the current universe, but we only re-clip it if

-		 * it's been marked.

-		 */

-		if (pChild->valdata) {

-		    /*

-		     * Figure out the new universe from the child's

-		     * perspective and recurse.

-		     */

-		    RegionIntersect(&childUniverse,

-					    universe,

-					    &pChild->borderSize);

-		    miComputeClips (pChild, pScreen, &childUniverse, kind,

-				    exposed);

-		}

-		/*

-		 * Once the child has been processed, we remove its extents

-		 * from the current universe, thus denying its space to any

-		 * other sibling.

-		 */

-		if (overlap && !TreatAsTransparent (pChild))

-		    RegionSubtract(universe, universe,

-					  &pChild->borderSize);

-	    }

-	}

-	if (!overlap)

-	    RegionSubtract(universe, universe, &childUnion);

-	RegionUninit(&childUnion);

-	RegionUninit(&childUniverse);

-    } /* if any children */

-

-    /*

-     * 'universe' now contains the new clipList for the parent window.

-     *

-     * To figure the exposure of the window we subtract the old clip from the

-     * new, just as for the border.

-     */

-

-    if (oldVis == VisibilityFullyObscured ||

-	oldVis == VisibilityNotViewable)

-    {

-	RegionCopy(&pParent->valdata->after.exposed, universe);

-    }

-    else if (newVis != VisibilityFullyObscured &&

-	     newVis != VisibilityNotViewable)

-    {

-	RegionSubtract(&pParent->valdata->after.exposed,

-			       universe, &pParent->clipList);

-    }

-

-    /* HACK ALERT - copying contents of regions, instead of regions */

-    {

-	RegionRec   tmp;

-

-	tmp = pParent->clipList;

-	pParent->clipList = *universe;

-	*universe = tmp;

-    }

-

-#ifdef NOTDEF

-    RegionCopy(&pParent->clipList, universe);

-#endif

-

-    pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;

-

-    if (pScreen->ClipNotify)

-	(* pScreen->ClipNotify) (pParent, dx, dy);

-}

-

-static void

-miTreeObscured(

-    WindowPtr pParent )

-{

-    WindowPtr 	pChild;

-    int    	oldVis;

-

-    pChild = pParent;

-    while (1)

-    {

-	if (pChild->viewable)

-	{

-	    oldVis = pChild->visibility;

-	    if (oldVis != (pChild->visibility = VisibilityFullyObscured) &&

-		((pChild->eventMask | wOtherEventMasks(pChild)) & VisibilityChangeMask))

-		SendVisibilityNotify(pChild);

-	    if (pChild->firstChild)

-	    {

-		pChild = pChild->firstChild;

-		continue;

-	    }

-	}

-	while (!pChild->nextSib && (pChild != pParent))

-	    pChild = pChild->parent;

-	if (pChild == pParent)

-	    break;

-	pChild = pChild->nextSib;

-    }

-}

-

-/*

- *-----------------------------------------------------------------------

- * miValidateTree --

- *	Recomputes the clip list for pParent and all its inferiors.

- *

- * Results:

- *	Always returns 1.

- *

- * Side Effects:

- *	The clipList, borderClip, exposed, and borderExposed regions for

- *	each marked window are altered.

- *

- * Notes:

- *	This routine assumes that all affected windows have been marked

- *	(valdata created) and their winSize and borderSize regions

- *	adjusted to correspond to their new positions. The borderClip and

- *	clipList regions should not have been touched.

- *

- *	The top-most level is treated differently from all lower levels

- *	because pParent is unchanged. For the top level, we merge the

- *	regions taken up by the marked children back into the clipList

- *	for pParent, thus forming a region from which the marked children

- *	can claim their areas. For lower levels, where the old clipList

- *	and borderClip are invalid, we can't do this and have to do the

- *	extra operations done in miComputeClips, but this is much faster

- *	e.g. when only one child has moved...

- *

- *-----------------------------------------------------------------------

- */

-/*ARGSUSED*/

-int

-miValidateTree (

-    WindowPtr		pParent,    /* Parent to validate */

-    WindowPtr		pChild,     /* First child of pParent that was

-				     * affected */

-    VTKind		kind        /* What kind of configuration caused call */

-    )

-{

-    RegionRec	  	totalClip;  /* Total clipping region available to

-				     * the marked children. pParent's clipList

-				     * merged with the borderClips of all

-				     * the marked children. */

-    RegionRec	  	childClip;  /* The new borderClip for the current

-				     * child */

-    RegionRec		childUnion; /* the space covered by borderSize for

-				     * all marked children */

-    RegionRec		exposed;    /* For intermediate calculations */

-    ScreenPtr		pScreen;

-    WindowPtr		pWin;

-    Bool		overlap;

-    int			viewvals;

-    Bool		forward;

-

-    pScreen = pParent->drawable.pScreen;

-    if (pChild == NullWindow)

-	pChild = pParent->firstChild;

-

-    RegionNull(&childClip);

-    RegionNull(&exposed);

-

-    /*

-     * compute the area of the parent window occupied

-     * by the marked children + the parent itself.  This

-     * is the area which can be divied up among the marked

-     * children in their new configuration.

-     */

-    RegionNull(&totalClip);

-    viewvals = 0;

-    if (RegionBroken(&pParent->clipList) &&

-	!RegionBroken(&pParent->borderClip))

-    {

-	kind = VTBroken;

-	/*

-	 * When rebuilding clip lists after out of memory,

-	 * assume everything is busted.

-	 */

-	forward = TRUE;

-	RegionCopy(&totalClip, &pParent->borderClip);

-	RegionIntersect(&totalClip, &totalClip, &pParent->winSize);

-	

-	for (pWin = pParent->firstChild; pWin != pChild; pWin = pWin->nextSib)

-	{

-	    if (pWin->viewable && !TreatAsTransparent (pWin))

-		RegionSubtract(&totalClip, &totalClip, &pWin->borderSize);

-	}

-	for (pWin = pChild; pWin; pWin = pWin->nextSib)

-	    if (pWin->valdata && pWin->viewable)

-		viewvals++;

-	

-	RegionEmpty(&pParent->clipList);

-    }

-    else 

-    {

-	if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||

-	    ((pChild->drawable.y == pParent->lastChild->drawable.y) &&

-	     (pChild->drawable.x < pParent->lastChild->drawable.x)))

-	{

-	    forward = TRUE;

-	    for (pWin = pChild; pWin; pWin = pWin->nextSib)

-	    {

-		if (pWin->valdata)

-		{

-		    RegionPtr	pBorderClip = &pWin->borderClip;

-#ifdef COMPOSITE

-		    if (pWin->redirectDraw != RedirectDrawNone && miGetRedirectBorderClipProc)

-			pBorderClip = (*miGetRedirectBorderClipProc)(pWin);

-#endif

-		    RegionAppend(&totalClip, pBorderClip );

-		    if (pWin->viewable)

-			viewvals++;

-		}

-	    }

-	}

-	else

-	{

-	    forward = FALSE;

-	    pWin = pParent->lastChild;

-	    while (1)

-	    {

-		if (pWin->valdata)

-		{

-		    RegionPtr	pBorderClip = &pWin->borderClip;

-#ifdef COMPOSITE

-		    if (pWin->redirectDraw != RedirectDrawNone && miGetRedirectBorderClipProc)

-			pBorderClip = (*miGetRedirectBorderClipProc)(pWin);

-#endif

-		    RegionAppend(&totalClip, pBorderClip );

-		    if (pWin->viewable)

-			viewvals++;

-		}

-		if (pWin == pChild)

-		    break;

-		pWin = pWin->prevSib;

-	    }

-	}

-	RegionValidate(&totalClip, &overlap);

-    }

-

-    /*

-     * Now go through the children of the root and figure their new

-     * borderClips from the totalClip, passing that off to miComputeClips

-     * to handle recursively. Once that's done, we remove the child

-     * from the totalClip to clip any siblings below it.

-     */

-

-    overlap = TRUE;

-    if (kind != VTStack)

-    {

-	RegionUnion(&totalClip, &totalClip, &pParent->clipList);

-	if (viewvals > 1)

-	{

-	    /*

-	     * precompute childUnion to discover whether any of them

-	     * overlap.  This seems redundant, but performance studies

-	     * have demonstrated that the cost of this loop is

-	     * lower than the cost of multiple Subtracts in the

-	     * loop below.

-	     */

-	    RegionNull(&childUnion);

-	    if (forward)

-	    {

-		for (pWin = pChild; pWin; pWin = pWin->nextSib)

-		    if (pWin->valdata && pWin->viewable && !TreatAsTransparent (pWin))

-			RegionAppend(&childUnion,

-						   &pWin->borderSize);

-	    }

-	    else

-	    {

-		pWin = pParent->lastChild;

-		while (1)

-		{

-		    if (pWin->valdata && pWin->viewable && !TreatAsTransparent (pWin))

-			RegionAppend(&childUnion,

-						   &pWin->borderSize);

-		    if (pWin == pChild)

-			break;

-		    pWin = pWin->prevSib;

-		}

-	    }

-	    RegionValidate(&childUnion, &overlap);

-	    if (overlap)

-		RegionUninit(&childUnion);

-	}

-    }

-

-    for (pWin = pChild;

-	 pWin != NullWindow;

-	 pWin = pWin->nextSib)

-    {

-	if (pWin->viewable) {

-	    if (pWin->valdata) {

-		RegionIntersect(&childClip,

-					&totalClip,

- 					&pWin->borderSize);

-		miComputeClips (pWin, pScreen, &childClip, kind, &exposed);

-		if (overlap && !TreatAsTransparent (pWin))

-		{

-		    RegionSubtract(&totalClip,

-				       	   &totalClip,

-				       	   &pWin->borderSize);

-		}

-	    } else if (pWin->visibility == VisibilityNotViewable) {

-		miTreeObscured(pWin);

-	    }

-	} else {

-	    if (pWin->valdata) {

-		RegionEmpty(&pWin->clipList);

-		if (pScreen->ClipNotify)

-		    (* pScreen->ClipNotify) (pWin, 0, 0);

-		RegionEmpty(&pWin->borderClip);

-		pWin->valdata = NULL;

-	    }

-	}

-    }

-

-    RegionUninit(&childClip);

-    if (!overlap)

-    {

-	RegionSubtract(&totalClip, &totalClip, &childUnion);

-	RegionUninit(&childUnion);

-    }

-

-    RegionNull(&pParent->valdata->after.exposed);

-    RegionNull(&pParent->valdata->after.borderExposed);

-

-    /*

-     * each case below is responsible for updating the

-     * clipList and serial number for the parent window

-     */

-

-    switch (kind) {

-    case VTStack:

-	break;

-    default:

-	/*

-	 * totalClip contains the new clipList for the parent. Figure out

-	 * exposures and obscures as per miComputeClips and reset the parent's

-	 * clipList.

-	 */

-	RegionSubtract(&pParent->valdata->after.exposed,

-			       &totalClip, &pParent->clipList);

-	/* fall through */

-    case VTMap:

-	RegionCopy(&pParent->clipList, &totalClip);

-	pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;

-	break;

-    }

-

-    RegionUninit(&totalClip);

-    RegionUninit(&exposed);

-    if (pScreen->ClipNotify)

-	(*pScreen->ClipNotify) (pParent, 0, 0);

-    return 1;

-}

+/*
+ * mivaltree.c --
+ *	Functions for recalculating window clip lists. Main function
+ *	is miValidateTree.
+ *
+
+Copyright 1987, 1988, 1989, 1998  The Open Group
+
+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.
+
+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 THE
+OPEN GROUP 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 The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+ *
+ * Copyright 1987, 1988, 1989 by 
+ * Digital Equipment Corporation, Maynard, Massachusetts,
+ * 
+ *                         All Rights Reserved
+ * 
+ * Permission to use, copy, modify, and distribute this software and its 
+ * documentation for any purpose and without fee is hereby granted, 
+ * 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 Digital not be
+ * used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  
+ * 
+ * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * DIGITAL 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.
+ * 
+ ******************************************************************/
+
+/* The panoramix components contained the following notice */
+/*****************************************************************
+
+Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.
+
+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.
+
+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
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL 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 Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+
+******************************************************************/
+
+
+ /* 
+  * Aug '86: Susan Angebranndt -- original code
+  * July '87: Adam de Boor -- substantially modified and commented
+  * Summer '89: Joel McCormack -- so fast you wouldn't believe it possible.
+  *             In particular, much improved code for window mapping and
+  *             circulating.
+  *		Bob Scheifler -- avoid miComputeClips for unmapped windows,
+  *				 valdata changes
+  */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "validate.h"
+#include    "windowstr.h"
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "mivalidate.h"
+
+#include    "globals.h"
+
+/*
+ * Compute the visibility of a shaped window
+ */
+int
+miShapedWindowIn (RegionPtr universe, RegionPtr bounding,
+                  BoxPtr rect, int x, int y)
+{
+    BoxRec  	box;
+    BoxPtr	boundBox;
+    int		nbox;
+    Bool	someIn, someOut;
+    int 	t, x1, y1, x2, y2;
+
+    nbox = RegionNumRects (bounding);
+    boundBox = RegionRects (bounding);
+    someIn = someOut = FALSE;
+    x1 = rect->x1;
+    y1 = rect->y1;
+    x2 = rect->x2;
+    y2 = rect->y2;
+    while (nbox--)
+    {
+	if ((t = boundBox->x1 + x) < x1)
+	    t = x1;
+	box.x1 = t;
+	if ((t = boundBox->y1 + y) < y1)
+	    t = y1;
+	box.y1 = t;
+	if ((t = boundBox->x2 + x) > x2)
+	    t = x2;
+	box.x2 = t;
+	if ((t = boundBox->y2 + y) > y2)
+	    t = y2;
+	box.y2 = t;
+	if (box.x1 > box.x2)
+	    box.x2 = box.x1;
+	if (box.y1 > box.y2)
+	    box.y2 = box.y1;
+	switch (RegionContainsRect(universe, &box))
+	{
+	case rgnIN:
+	    if (someOut)
+		return rgnPART;
+	    someIn = TRUE;
+	    break;
+	case rgnOUT:
+	    if (someIn)
+		return rgnPART;
+	    someOut = TRUE;
+	    break;
+	default:
+	    return rgnPART;
+	}
+	boundBox++;
+    }
+    if (someIn)
+	return rgnIN;
+    return rgnOUT;
+}
+
+static GetRedirectBorderClipProcPtr	miGetRedirectBorderClipProc;
+static SetRedirectBorderClipProcPtr	miSetRedirectBorderClipProc;
+
+void
+miRegisterRedirectBorderClipProc (SetRedirectBorderClipProcPtr setBorderClip,
+				  GetRedirectBorderClipProcPtr getBorderClip)
+{
+    miSetRedirectBorderClipProc = setBorderClip;
+    miGetRedirectBorderClipProc = getBorderClip;
+}
+
+/*
+ * Manual redirected windows are treated as transparent; they do not obscure
+ * siblings or parent windows
+ */
+
+#ifdef COMPOSITE
+#define TreatAsTransparent(w)	((w)->redirectDraw == RedirectDrawManual)
+#else
+#define TreatAsTransparent(w)	FALSE
+#endif
+
+#define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
+				    HasBorder(w) && \
+				    (w)->backgroundState == ParentRelative)
+
+
+/*
+ *-----------------------------------------------------------------------
+ * miComputeClips --
+ *	Recompute the clipList, borderClip, exposed and borderExposed
+ *	regions for pParent and its children. Only viewable windows are
+ *	taken into account.
+ *
+ * Results:
+ *	None.
+ *
+ * Side Effects:
+ *	clipList, borderClip, exposed and borderExposed are altered.
+ *	A VisibilityNotify event may be generated on the parent window.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void
+miComputeClips (
+    WindowPtr	pParent,
+    ScreenPtr	pScreen,
+    RegionPtr	universe,
+    VTKind		kind,
+    RegionPtr		exposed ) /* for intermediate calculations */
+{
+    int			dx,
+			dy;
+    RegionRec		childUniverse;
+    WindowPtr		pChild;
+    int     	  	oldVis, newVis;
+    BoxRec		borderSize;
+    RegionRec		childUnion;
+    Bool		overlap;
+    RegionPtr		borderVisible;
+    /*
+     * Figure out the new visibility of this window.
+     * The extent of the universe should be the same as the extent of
+     * the borderSize region. If the window is unobscured, this rectangle
+     * will be completely inside the universe (the universe will cover it
+     * completely). If the window is completely obscured, none of the
+     * universe will cover the rectangle.
+     */
+    borderSize.x1 = pParent->drawable.x - wBorderWidth(pParent);
+    borderSize.y1 = pParent->drawable.y - wBorderWidth(pParent);
+    dx = (int) pParent->drawable.x + (int) pParent->drawable.width + wBorderWidth(pParent);
+    if (dx > 32767)
+	dx = 32767;
+    borderSize.x2 = dx;
+    dy = (int) pParent->drawable.y + (int) pParent->drawable.height + wBorderWidth(pParent);
+    if (dy > 32767)
+	dy = 32767;
+    borderSize.y2 = dy;
+
+#ifdef COMPOSITE
+    /*
+     * In redirected drawing case, reset universe to borderSize
+     */
+    if (pParent->redirectDraw != RedirectDrawNone)
+    {
+	if (miSetRedirectBorderClipProc)
+	{
+	    if (TreatAsTransparent (pParent))
+		RegionEmpty(universe);
+	    (*miSetRedirectBorderClipProc) (pParent, universe);
+	}
+	RegionCopy(universe, &pParent->borderSize);
+    }
+#endif
+
+    oldVis = pParent->visibility;
+    switch (RegionContainsRect(universe, &borderSize))
+    {
+	case rgnIN:
+	    newVis = VisibilityUnobscured;
+	    break;
+	case rgnPART:
+	    newVis = VisibilityPartiallyObscured;
+	    {
+		RegionPtr   pBounding;
+
+		if ((pBounding = wBoundingShape (pParent)))
+		{
+		    switch (miShapedWindowIn (universe, pBounding,
+					      &borderSize,
+					      pParent->drawable.x,
+ 					      pParent->drawable.y))
+		    {
+		    case rgnIN:
+			newVis = VisibilityUnobscured;
+			break;
+		    case rgnOUT:
+			newVis = VisibilityFullyObscured;
+			break;
+		    }
+		}
+	    }
+	    break;
+	default:
+	    newVis = VisibilityFullyObscured;
+	    break;
+    }
+    pParent->visibility = newVis;
+    if (oldVis != newVis &&
+	((pParent->eventMask | wOtherEventMasks(pParent)) & VisibilityChangeMask))
+	SendVisibilityNotify(pParent);
+
+    dx = pParent->drawable.x - pParent->valdata->before.oldAbsCorner.x;
+    dy = pParent->drawable.y - pParent->valdata->before.oldAbsCorner.y;
+
+    /*
+     * avoid computations when dealing with simple operations
+     */
+
+    switch (kind) {
+    case VTMap:
+    case VTStack:
+    case VTUnmap:
+	break;
+    case VTMove:
+	if ((oldVis == newVis) &&
+	    ((oldVis == VisibilityFullyObscured) ||
+	     (oldVis == VisibilityUnobscured)))
+	{
+	    pChild = pParent;
+	    while (1)
+	    {
+		if (pChild->viewable)
+		{
+		    if (pChild->visibility != VisibilityFullyObscured)
+		    {
+			RegionTranslate(&pChild->borderClip,
+						      dx, dy);
+			RegionTranslate(&pChild->clipList,
+						      dx, dy);
+			pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+			if (pScreen->ClipNotify)
+			    (* pScreen->ClipNotify) (pChild, dx, dy);
+
+		    }
+		    if (pChild->valdata)
+		    {
+			RegionNull(&pChild->valdata->after.borderExposed);
+			if (HasParentRelativeBorder(pChild))
+			{
+			    RegionSubtract(&pChild->valdata->after.borderExposed,
+					   &pChild->borderClip,
+					   &pChild->winSize);
+			}
+			RegionNull(&pChild->valdata->after.exposed);
+		    }
+		    if (pChild->firstChild)
+		    {
+			pChild = pChild->firstChild;
+			continue;
+		    }
+		}
+		while (!pChild->nextSib && (pChild != pParent))
+		    pChild = pChild->parent;
+		if (pChild == pParent)
+		    break;
+		pChild = pChild->nextSib;
+	    }
+	    return;
+	}
+	/* fall through */
+    default:
+    	/*
+     	 * To calculate exposures correctly, we have to translate the old
+     	 * borderClip and clipList regions to the window's new location so there
+     	 * is a correspondence between pieces of the new and old clipping regions.
+     	 */
+    	if (dx || dy) 
+    	{
+	    /*
+	     * We translate the old clipList because that will be exposed or copied
+	     * if gravity is right.
+	     */
+	    RegionTranslate(&pParent->borderClip, dx, dy);
+	    RegionTranslate(&pParent->clipList, dx, dy);
+    	} 
+	break;
+    case VTBroken:
+	RegionEmpty(&pParent->borderClip);
+	RegionEmpty(&pParent->clipList);
+	break;
+    }
+
+    borderVisible = pParent->valdata->before.borderVisible;
+    RegionNull(&pParent->valdata->after.borderExposed);
+    RegionNull(&pParent->valdata->after.exposed);
+
+    /*
+     * Since the borderClip must not be clipped by the children, we do
+     * the border exposure first...
+     *
+     * 'universe' is the window's borderClip. To figure the exposures, remove
+     * the area that used to be exposed from the new.
+     * This leaves a region of pieces that weren't exposed before.
+     */
+
+    if (HasBorder (pParent))
+    {
+    	if (borderVisible)
+    	{
+	    /*
+	     * when the border changes shape, the old visible portions
+	     * of the border will be saved by DIX in borderVisible --
+	     * use that region and destroy it
+	     */
+	    RegionSubtract(exposed, universe, borderVisible);
+	    RegionDestroy(borderVisible);
+    	}
+    	else
+    	{
+	    RegionSubtract(exposed, universe, &pParent->borderClip);
+    	}
+	if (HasParentRelativeBorder(pParent) && (dx || dy))
+	    RegionSubtract(&pParent->valdata->after.borderExposed,
+				  universe,
+				  &pParent->winSize);
+	else
+	    RegionSubtract(&pParent->valdata->after.borderExposed,
+			       exposed, &pParent->winSize);
+
+	RegionCopy(&pParent->borderClip, universe);
+    
+    	/*
+     	 * To get the right clipList for the parent, and to make doubly sure
+     	 * that no child overlaps the parent's border, we remove the parent's
+     	 * border from the universe before proceeding.
+     	 */
+    
+	RegionIntersect(universe, universe, &pParent->winSize);
+    }
+    else
+	RegionCopy(&pParent->borderClip, universe);
+    
+    if ((pChild = pParent->firstChild) && pParent->mapped)
+    {
+	RegionNull(&childUniverse);
+	RegionNull(&childUnion);
+	if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||
+	    ((pChild->drawable.y == pParent->lastChild->drawable.y) &&
+	     (pChild->drawable.x < pParent->lastChild->drawable.x)))
+	{
+	    for (; pChild; pChild = pChild->nextSib)
+	    {
+		if (pChild->viewable && !TreatAsTransparent(pChild))
+		    RegionAppend(&childUnion, &pChild->borderSize);
+	    }
+	}
+	else
+	{
+	    for (pChild = pParent->lastChild; pChild; pChild = pChild->prevSib)
+	    {
+		if (pChild->viewable && !TreatAsTransparent(pChild))
+		    RegionAppend(&childUnion, &pChild->borderSize);
+	    }
+	}
+	RegionValidate(&childUnion, &overlap);
+
+	for (pChild = pParent->firstChild;
+	     pChild;
+	     pChild = pChild->nextSib)
+ 	{
+	    if (pChild->viewable) {
+		/*
+		 * If the child is viewable, we want to remove its extents
+		 * from the current universe, but we only re-clip it if
+		 * it's been marked.
+		 */
+		if (pChild->valdata) {
+		    /*
+		     * Figure out the new universe from the child's
+		     * perspective and recurse.
+		     */
+		    RegionIntersect(&childUniverse,
+					    universe,
+					    &pChild->borderSize);
+		    miComputeClips (pChild, pScreen, &childUniverse, kind,
+				    exposed);
+		}
+		/*
+		 * Once the child has been processed, we remove its extents
+		 * from the current universe, thus denying its space to any
+		 * other sibling.
+		 */
+		if (overlap && !TreatAsTransparent (pChild))
+		    RegionSubtract(universe, universe,
+					  &pChild->borderSize);
+	    }
+	}
+	if (!overlap)
+	    RegionSubtract(universe, universe, &childUnion);
+	RegionUninit(&childUnion);
+	RegionUninit(&childUniverse);
+    } /* if any children */
+
+    /*
+     * 'universe' now contains the new clipList for the parent window.
+     *
+     * To figure the exposure of the window we subtract the old clip from the
+     * new, just as for the border.
+     */
+
+    if (oldVis == VisibilityFullyObscured ||
+	oldVis == VisibilityNotViewable)
+    {
+	RegionCopy(&pParent->valdata->after.exposed, universe);
+    }
+    else if (newVis != VisibilityFullyObscured &&
+	     newVis != VisibilityNotViewable)
+    {
+	RegionSubtract(&pParent->valdata->after.exposed,
+			       universe, &pParent->clipList);
+    }
+
+    /* HACK ALERT - copying contents of regions, instead of regions */
+    {
+	RegionRec   tmp;
+
+	tmp = pParent->clipList;
+	pParent->clipList = *universe;
+	*universe = tmp;
+    }
+
+#ifdef NOTDEF
+    RegionCopy(&pParent->clipList, universe);
+#endif
+
+    pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+
+    if (pScreen->ClipNotify)
+	(* pScreen->ClipNotify) (pParent, dx, dy);
+}
+
+static void
+miTreeObscured(
+    WindowPtr pParent )
+{
+    WindowPtr 	pChild;
+    int    	oldVis;
+
+    pChild = pParent;
+    while (1)
+    {
+	if (pChild->viewable)
+	{
+	    oldVis = pChild->visibility;
+	    if (oldVis != (pChild->visibility = VisibilityFullyObscured) &&
+		((pChild->eventMask | wOtherEventMasks(pChild)) & VisibilityChangeMask))
+		SendVisibilityNotify(pChild);
+	    if (pChild->firstChild)
+	    {
+		pChild = pChild->firstChild;
+		continue;
+	    }
+	}
+	while (!pChild->nextSib && (pChild != pParent))
+	    pChild = pChild->parent;
+	if (pChild == pParent)
+	    break;
+	pChild = pChild->nextSib;
+    }
+}
+
+/*
+ *-----------------------------------------------------------------------
+ * miValidateTree --
+ *	Recomputes the clip list for pParent and all its inferiors.
+ *
+ * Results:
+ *	Always returns 1.
+ *
+ * Side Effects:
+ *	The clipList, borderClip, exposed, and borderExposed regions for
+ *	each marked window are altered.
+ *
+ * Notes:
+ *	This routine assumes that all affected windows have been marked
+ *	(valdata created) and their winSize and borderSize regions
+ *	adjusted to correspond to their new positions. The borderClip and
+ *	clipList regions should not have been touched.
+ *
+ *	The top-most level is treated differently from all lower levels
+ *	because pParent is unchanged. For the top level, we merge the
+ *	regions taken up by the marked children back into the clipList
+ *	for pParent, thus forming a region from which the marked children
+ *	can claim their areas. For lower levels, where the old clipList
+ *	and borderClip are invalid, we can't do this and have to do the
+ *	extra operations done in miComputeClips, but this is much faster
+ *	e.g. when only one child has moved...
+ *
+ *-----------------------------------------------------------------------
+ */
+/*ARGSUSED*/
+int
+miValidateTree (
+    WindowPtr		pParent,    /* Parent to validate */
+    WindowPtr		pChild,     /* First child of pParent that was
+				     * affected */
+    VTKind		kind        /* What kind of configuration caused call */
+    )
+{
+    RegionRec	  	totalClip;  /* Total clipping region available to
+				     * the marked children. pParent's clipList
+				     * merged with the borderClips of all
+				     * the marked children. */
+    RegionRec	  	childClip;  /* The new borderClip for the current
+				     * child */
+    RegionRec		childUnion; /* the space covered by borderSize for
+				     * all marked children */
+    RegionRec		exposed;    /* For intermediate calculations */
+    ScreenPtr		pScreen;
+    WindowPtr		pWin;
+    Bool		overlap;
+    int			viewvals;
+    Bool		forward;
+
+    pScreen = pParent->drawable.pScreen;
+    if (pChild == NullWindow)
+	pChild = pParent->firstChild;
+
+    RegionNull(&childClip);
+    RegionNull(&exposed);
+
+    /*
+     * compute the area of the parent window occupied
+     * by the marked children + the parent itself.  This
+     * is the area which can be divied up among the marked
+     * children in their new configuration.
+     */
+    RegionNull(&totalClip);
+    viewvals = 0;
+    if (RegionBroken(&pParent->clipList) &&
+	!RegionBroken(&pParent->borderClip))
+    {
+	kind = VTBroken;
+	/*
+	 * When rebuilding clip lists after out of memory,
+	 * assume everything is busted.
+	 */
+	forward = TRUE;
+	RegionCopy(&totalClip, &pParent->borderClip);
+	RegionIntersect(&totalClip, &totalClip, &pParent->winSize);
+	
+	for (pWin = pParent->firstChild; pWin != pChild; pWin = pWin->nextSib)
+	{
+	    if (pWin->viewable && !TreatAsTransparent (pWin))
+		RegionSubtract(&totalClip, &totalClip, &pWin->borderSize);
+	}
+	for (pWin = pChild; pWin; pWin = pWin->nextSib)
+	    if (pWin->valdata && pWin->viewable)
+		viewvals++;
+	
+	RegionEmpty(&pParent->clipList);
+    }
+    else 
+    {
+	if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||
+	    ((pChild->drawable.y == pParent->lastChild->drawable.y) &&
+	     (pChild->drawable.x < pParent->lastChild->drawable.x)))
+	{
+	    forward = TRUE;
+	    for (pWin = pChild; pWin; pWin = pWin->nextSib)
+	    {
+		if (pWin->valdata)
+		{
+		    RegionPtr	pBorderClip = &pWin->borderClip;
+#ifdef COMPOSITE
+		    if (pWin->redirectDraw != RedirectDrawNone && miGetRedirectBorderClipProc)
+			pBorderClip = (*miGetRedirectBorderClipProc)(pWin);
+#endif
+		    RegionAppend(&totalClip, pBorderClip );
+		    if (pWin->viewable)
+			viewvals++;
+		}
+	    }
+	}
+	else
+	{
+	    forward = FALSE;
+	    pWin = pParent->lastChild;
+	    while (1)
+	    {
+		if (pWin->valdata)
+		{
+		    RegionPtr	pBorderClip = &pWin->borderClip;
+#ifdef COMPOSITE
+		    if (pWin->redirectDraw != RedirectDrawNone && miGetRedirectBorderClipProc)
+			pBorderClip = (*miGetRedirectBorderClipProc)(pWin);
+#endif
+		    RegionAppend(&totalClip, pBorderClip );
+		    if (pWin->viewable)
+			viewvals++;
+		}
+		if (pWin == pChild)
+		    break;
+		pWin = pWin->prevSib;
+	    }
+	}
+	RegionValidate(&totalClip, &overlap);
+    }
+
+    /*
+     * Now go through the children of the root and figure their new
+     * borderClips from the totalClip, passing that off to miComputeClips
+     * to handle recursively. Once that's done, we remove the child
+     * from the totalClip to clip any siblings below it.
+     */
+
+    overlap = TRUE;
+    if (kind != VTStack)
+    {
+	RegionUnion(&totalClip, &totalClip, &pParent->clipList);
+	if (viewvals > 1)
+	{
+	    /*
+	     * precompute childUnion to discover whether any of them
+	     * overlap.  This seems redundant, but performance studies
+	     * have demonstrated that the cost of this loop is
+	     * lower than the cost of multiple Subtracts in the
+	     * loop below.
+	     */
+	    RegionNull(&childUnion);
+	    if (forward)
+	    {
+		for (pWin = pChild; pWin; pWin = pWin->nextSib)
+		    if (pWin->valdata && pWin->viewable && !TreatAsTransparent (pWin))
+			RegionAppend(&childUnion,
+						   &pWin->borderSize);
+	    }
+	    else
+	    {
+		pWin = pParent->lastChild;
+		while (1)
+		{
+		    if (pWin->valdata && pWin->viewable && !TreatAsTransparent (pWin))
+			RegionAppend(&childUnion,
+						   &pWin->borderSize);
+		    if (pWin == pChild)
+			break;
+		    pWin = pWin->prevSib;
+		}
+	    }
+	    RegionValidate(&childUnion, &overlap);
+	    if (overlap)
+		RegionUninit(&childUnion);
+	}
+    }
+
+    for (pWin = pChild;
+	 pWin != NullWindow;
+	 pWin = pWin->nextSib)
+    {
+	if (pWin->viewable) {
+	    if (pWin->valdata) {
+		RegionIntersect(&childClip,
+					&totalClip,
+ 					&pWin->borderSize);
+		miComputeClips (pWin, pScreen, &childClip, kind, &exposed);
+		if (overlap && !TreatAsTransparent (pWin))
+		{
+		    RegionSubtract(&totalClip,
+				       	   &totalClip,
+				       	   &pWin->borderSize);
+		}
+	    } else if (pWin->visibility == VisibilityNotViewable) {
+		miTreeObscured(pWin);
+	    }
+	} else {
+	    if (pWin->valdata) {
+		RegionEmpty(&pWin->clipList);
+		if (pScreen->ClipNotify)
+		    (* pScreen->ClipNotify) (pWin, 0, 0);
+		RegionEmpty(&pWin->borderClip);
+		pWin->valdata = NULL;
+	    }
+	}
+    }
+
+    RegionUninit(&childClip);
+    if (!overlap)
+    {
+	RegionSubtract(&totalClip, &totalClip, &childUnion);
+	RegionUninit(&childUnion);
+    }
+
+    RegionNull(&pParent->valdata->after.exposed);
+    RegionNull(&pParent->valdata->after.borderExposed);
+
+    /*
+     * each case below is responsible for updating the
+     * clipList and serial number for the parent window
+     */
+
+    switch (kind) {
+    case VTStack:
+	break;
+    default:
+	/*
+	 * totalClip contains the new clipList for the parent. Figure out
+	 * exposures and obscures as per miComputeClips and reset the parent's
+	 * clipList.
+	 */
+	RegionSubtract(&pParent->valdata->after.exposed,
+			       &totalClip, &pParent->clipList);
+	/* fall through */
+    case VTMap:
+	RegionCopy(&pParent->clipList, &totalClip);
+	pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+	break;
+    }
+
+    RegionUninit(&totalClip);
+    RegionUninit(&exposed);
+    if (pScreen->ClipNotify)
+	(*pScreen->ClipNotify) (pParent, 0, 0);
+    return 1;
+}