5 files changed, 1759 insertions, 1772 deletions

diff --git a/xorg-server/xfixes/cursor.c b/xorg-server/xfixes/cursor.c
index 2aba0cec9..296836055 100644
--- a/xorg-server/xfixes/cursor.c
+++ b/xorg-server/xfixes/cursor.c
@@ -1,1104 +1,1104 @@
-/*
- * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-#include "scrnintstr.h"
-#include "cursorstr.h"
-#include "dixevents.h"
-#include "servermd.h"
-#include "inputstr.h"
-#include "windowstr.h"
-#include "xace.h"
-
-static RESTYPE		CursorClientType;
-static RESTYPE		CursorHideCountType;
-static RESTYPE		CursorWindowType;
-static CursorPtr	CursorCurrent[MAXDEVICES];
-static CursorPtr        pInvisibleCursor = NULL;
-
-static int CursorScreenPrivateKeyIndex;
-static DevPrivateKey CursorScreenPrivateKey = &CursorScreenPrivateKeyIndex;
-
-static void deleteCursorHideCountsForScreen (ScreenPtr pScreen);
-
-#define VERIFY_CURSOR(pCursor, cursor, client, access)			\
-    do {								\
-	int err;							\
-	err = dixLookupResourceByType((pointer *) &pCursor, cursor,	\
-				      RT_CURSOR, client, access);	\
-	if (err == BadValue) {						\
-	    client->errorValue = cursor;				\
-	    return BadCursor;						\
-	} else if (err != Success) {					\
-	    client->errorValue = cursor;				\
-	    return err;							\
-	}								\
-    } while (0)
-
-/*
- * There is a global list of windows selecting for cursor events
- */
-
-typedef struct _CursorEvent *CursorEventPtr;
-
-typedef struct _CursorEvent {
-    CursorEventPtr	next;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
-} CursorEventRec;
-
-static CursorEventPtr	    cursorEvents;
-
-/*
- * Each screen has a list of clients which have requested
- * that the cursor be hid, and the number of times each
- * client has requested.
-*/
-
-typedef struct _CursorHideCountRec *CursorHideCountPtr;
-
-typedef struct _CursorHideCountRec {
-    CursorHideCountPtr   pNext;  
-    ClientPtr            pClient;
-    ScreenPtr            pScreen;
-    int                  hideCount;
-    XID			 resource;
-} CursorHideCountRec;
-
-/*
- * Wrap DisplayCursor to catch cursor change events
- */
-
-typedef struct _CursorScreen {
-    DisplayCursorProcPtr	DisplayCursor;
-    CloseScreenProcPtr		CloseScreen;
-    CursorHideCountPtr          pCursorHideCounts;
-} CursorScreenRec, *CursorScreenPtr;
-
-#define GetCursorScreen(s) ((CursorScreenPtr)dixLookupPrivate(&(s)->devPrivates, CursorScreenPrivateKey))
-#define GetCursorScreenIfSet(s) GetCursorScreen(s)
-#define SetCursorScreen(s,p) dixSetPrivate(&(s)->devPrivates, CursorScreenPrivateKey, p)
-#define Wrap(as,s,elt,func)	(((as)->elt = (s)->elt), (s)->elt = func)
-#define Unwrap(as,s,elt,backup)	(((backup) = (s)->elt), (s)->elt = (as)->elt)
-
-/* The cursor doesn't show up until the first XDefineCursor() */
-static Bool CursorVisible = FALSE;
-
-Bool EnableCursor = TRUE;
-
-static Bool
-CursorDisplayCursor (DeviceIntPtr pDev,
-                     ScreenPtr pScreen,
-		     CursorPtr pCursor)
-{
-    CursorScreenPtr	cs = GetCursorScreen(pScreen);
-    Bool		ret;
-    DisplayCursorProcPtr backupProc;
-
-    Unwrap (cs, pScreen, DisplayCursor, backupProc);
-
-    /*
-     * Have to check ConnectionInfo to distinguish client requests from
-     * initial root window setup.  Not a great way to do it, I admit.
-     */
-    if (ConnectionInfo)
-	CursorVisible = EnableCursor;
-
-    if (cs->pCursorHideCounts != NULL || !CursorVisible) {
-        ret = ((*pScreen->RealizeCursor)(pDev, pScreen, pInvisibleCursor) &&
-	       (*pScreen->DisplayCursor) (pDev, pScreen, pInvisibleCursor));
-    } else {
-	ret = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);
-    }
-
-    if (pCursor != CursorCurrent[pDev->id])
-    {
-	CursorEventPtr	e;
-
-	CursorCurrent[pDev->id] = pCursor;
-	for (e = cursorEvents; e; e = e->next)
-	{
-	    if ((e->eventMask & XFixesDisplayCursorNotifyMask) &&
-		!e->pClient->clientGone)
-	    {
-		xXFixesCursorNotifyEvent	ev;
-		ev.type = XFixesEventBase + XFixesCursorNotify;
-		ev.subtype = XFixesDisplayCursorNotify;
-		ev.sequenceNumber = e->pClient->sequence;
-		ev.window = e->pWindow->drawable.id;
-		ev.cursorSerial = pCursor->serialNumber;
-		ev.timestamp = currentTime.milliseconds;
-		ev.name = pCursor->name;
-		WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
-	    }
-	}
-    }
-    Wrap (cs, pScreen, DisplayCursor, backupProc);
-
-    return ret;
-}
-
-static Bool
-CursorCloseScreen (int index, ScreenPtr pScreen)
-{
-    CursorScreenPtr	cs = GetCursorScreen (pScreen);
-    Bool		ret;
-    CloseScreenProcPtr	close_proc;
-    DisplayCursorProcPtr display_proc;
-
-    Unwrap (cs, pScreen, CloseScreen, close_proc);
-    Unwrap (cs, pScreen, DisplayCursor, display_proc);
-    deleteCursorHideCountsForScreen(pScreen);
-    ret = (*pScreen->CloseScreen) (index, pScreen);
-    xfree (cs);
-    return ret;
-}
-
-#define CursorAllEvents (XFixesDisplayCursorNotifyMask)
-
-static int
-XFixesSelectCursorInput (ClientPtr	pClient,
-			 WindowPtr	pWindow,
-			 CARD32		eventMask)
-{
-    CursorEventPtr	*prev, e;
-    pointer val;
-    int rc;
-
-    for (prev = &cursorEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
-    }
-    if (!eventMask)
-    {
-	if (e)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-	return Success;
-    }
-    if (!e)
-    {
-	e = (CursorEventPtr) xalloc (sizeof (CursorEventRec));
-	if (!e)
-	    return BadAlloc;
-
-	e->next = 0;
-	e->pClient = pClient;
-	e->pWindow = pWindow;
-	e->clientResource = FakeClientID(pClient->index);
-
-	/*
-	 * Add a resource hanging from the window to
-	 * catch window destroy
-	 */
-	rc = dixLookupResourceByType( &val, pWindow->drawable.id,
-				      CursorWindowType, serverClient,
-				      DixGetAttrAccess);
-	if (rc != Success)
-	    if (!AddResource (pWindow->drawable.id, CursorWindowType,
-			      (pointer) pWindow))
-	    {
-		xfree (e);
-		return BadAlloc;
-	    }
-
-	if (!AddResource (e->clientResource, CursorClientType, (pointer) e))
-	    return BadAlloc;
-
-	*prev = e;
-    }
-    e->eventMask = eventMask;
-    return Success;
-}
-
-int
-ProcXFixesSelectCursorInput (ClientPtr client)
-{
-    REQUEST (xXFixesSelectCursorInputReq);
-    WindowPtr	pWin;
-    int		rc;
-
-    REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq);
-    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
-    if (rc != Success)
-        return rc;
-    if (stuff->eventMask & ~CursorAllEvents)
-    {
-	client->errorValue = stuff->eventMask;
-	return( BadValue );
-    }
-    return XFixesSelectCursorInput (client, pWin, stuff->eventMask);
-}
-
-static int
-GetBit (unsigned char *line, int x)
-{
-    unsigned char   mask;
-    
-    if (screenInfo.bitmapBitOrder == LSBFirst)
-	mask = (1 << (x & 7));
-    else
-	mask = (0x80 >> (x & 7));
-    /* XXX assumes byte order is host byte order */
-    line += (x >> 3);
-    if (*line & mask)
-	return 1;
-    return 0;
-}
-
-int
-SProcXFixesSelectCursorInput (ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesSelectCursorInputReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->eventMask, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-    
-void
-SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from,
-			  xXFixesCursorNotifyEvent *to)
-{
-    to->type = from->type;
-    cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->window, to->window);
-    cpswapl (from->cursorSerial, to->cursorSerial);
-    cpswapl (from->timestamp, to->timestamp);
-    cpswapl (from->name, to->name);
-}
-
-static void
-CopyCursorToImage (CursorPtr pCursor, CARD32 *image)
-{
-    int width = pCursor->bits->width;
-    int height = pCursor->bits->height;
-    int npixels = width * height;
-    
-#ifdef ARGB_CURSOR
-    if (pCursor->bits->argb)
-	memcpy (image, pCursor->bits->argb, npixels * sizeof (CARD32));
-    else
-#endif
-    {
-	unsigned char	*srcLine = pCursor->bits->source;
-	unsigned char	*mskLine = pCursor->bits->mask;
-	int		stride = BitmapBytePad (width);
-	int		x, y;
-	CARD32		fg, bg;
-	
-	fg = (0xff000000 | 
-	      ((pCursor->foreRed & 0xff00) << 8) |
-	      (pCursor->foreGreen & 0xff00) |
-	      (pCursor->foreBlue >> 8));
-	bg = (0xff000000 | 
-	      ((pCursor->backRed & 0xff00) << 8) |
-	      (pCursor->backGreen & 0xff00) |
-	      (pCursor->backBlue >> 8));
-	for (y = 0; y < height; y++)
-	{
-	    for (x = 0; x < width; x++)
-	    {
-		if (GetBit (mskLine, x))
-		{
-		    if (GetBit (srcLine, x))
-			*image++ = fg;
-		    else
-			*image++ = bg;
-		}
-		else
-		    *image++ = 0;
-	    }
-	    srcLine += stride;
-	    mskLine += stride;
-	}
-    }
-}
-
-int
-ProcXFixesGetCursorImage (ClientPtr client)
-{
-/*    REQUEST(xXFixesGetCursorImageReq); */
-    xXFixesGetCursorImageReply	*rep;
-    CursorPtr			pCursor;
-    CARD32			*image;
-    int				npixels, width, height, rc, x, y;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorImageReq);
-    pCursor = CursorCurrent[PickPointer(client)->id];
-    if (!pCursor)
-	return BadCursor;
-    rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR,
-		  pCursor, RT_NONE, NULL, DixReadAccess);
-    if (rc != Success)
-	return rc;
-    GetSpritePosition (PickPointer(client), &x, &y);
-    width = pCursor->bits->width;
-    height = pCursor->bits->height;
-    npixels = width * height;
-    rep = xalloc (sizeof (xXFixesGetCursorImageReply) +
-		  npixels * sizeof (CARD32));
-    if (!rep)
-	return BadAlloc;
-
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels;
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
-    rep->cursorSerial = pCursor->serialNumber;
-
-    image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	SwapLongs (image, npixels);
-    }
-    WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
-			 (npixels << 2), (char *) rep);
-    xfree (rep);
-    return client->noClientException;
-}
-
-int
-SProcXFixesGetCursorImage (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesGetCursorImageReq);
-    swaps (&stuff->length, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesSetCursorName (ClientPtr client)
-{
-    CursorPtr pCursor;
-    char *tchar;
-    REQUEST(xXFixesSetCursorNameReq);
-    Atom atom;
-
-    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixSetAttrAccess);
-    tchar = (char *) &stuff[1];
-    atom = MakeAtom (tchar, stuff->nbytes, TRUE);
-    if (atom == BAD_RESOURCE)
-	return BadAlloc;
-    
-    pCursor->name = atom;
-    return(client->noClientException);
-}
-
-int
-SProcXFixesSetCursorName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesSetCursorNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    swaps (&stuff->nbytes, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesGetCursorName (ClientPtr client)
-{
-    CursorPtr			pCursor;
-    xXFixesGetCursorNameReply	reply;
-    REQUEST(xXFixesGetCursorNameReq);
-    const char *str;
-    int len;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixGetAttrAccess);
-    if (pCursor->name)
-	str = NameForAtom (pCursor->name);
-    else
-	str = "";
-    len = strlen (str);
-    
-    reply.type = X_Reply;
-    reply.length = bytes_to_int32(len);
-    reply.sequenceNumber = client->sequence;
-    reply.atom = pCursor->name;
-    reply.nbytes = len;
-    if (client->swapped)
-    {
-	int n;
-	swaps (&reply.sequenceNumber, n);
-	swapl (&reply.length, n);
-	swapl (&reply.atom, n);
-	swaps (&reply.nbytes, n);
-    }
-    WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply);
-    WriteToClient(client, len, str);
-    
-    return(client->noClientException);
-}
-
-int
-SProcXFixesGetCursorName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesGetCursorNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesGetCursorImageAndName (ClientPtr client)
-{
-/*    REQUEST(xXFixesGetCursorImageAndNameReq); */
-    xXFixesGetCursorImageAndNameReply	*rep;
-    CursorPtr			pCursor;
-    CARD32			*image;
-    int				npixels;
-    const char			*name;
-    int				nbytes, nbytesRound;
-    int				width, height;
-    int				rc, x, y;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorImageAndNameReq);
-    pCursor = CursorCurrent[PickPointer(client)->id];
-    if (!pCursor)
-	return BadCursor;
-    rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR,
-		  pCursor, RT_NONE, NULL, DixReadAccess|DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-    GetSpritePosition (PickPointer(client), &x, &y);
-    width = pCursor->bits->width;
-    height = pCursor->bits->height;
-    npixels = width * height;
-    name = pCursor->name ? NameForAtom (pCursor->name) : "";
-    nbytes = strlen (name);
-    nbytesRound = pad_to_int32(nbytes);
-    rep = xalloc (sizeof (xXFixesGetCursorImageAndNameReply) +
-		  npixels * sizeof (CARD32) + nbytesRound);
-    if (!rep)
-	return BadAlloc;
-
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels + bytes_to_int32(nbytesRound);
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
-    rep->cursorSerial = pCursor->serialNumber;
-    rep->cursorName = pCursor->name;
-    rep->nbytes = nbytes;
-
-    image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    memcpy ((image + npixels), name, nbytes);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	swapl (&rep->cursorName, n);
-	swaps (&rep->nbytes, n);
-	SwapLongs (image, npixels);
-    }
-    WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
-			 (npixels << 2) + nbytesRound, (char *) rep);
-    xfree (rep);
-    return client->noClientException;
-}
-
-int
-SProcXFixesGetCursorImageAndName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesGetCursorImageAndNameReq);
-    swaps (&stuff->length, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-/*
- * Find every cursor reference in the system, ask testCursor
- * whether it should be replaced with a reference to pCursor.
- */
-
-typedef Bool (*TestCursorFunc) (CursorPtr pOld, pointer closure);
-
-typedef struct {
-    RESTYPE type;
-    TestCursorFunc testCursor;
-    CursorPtr pNew;
-    pointer closure;
-} ReplaceCursorLookupRec, *ReplaceCursorLookupPtr;
-
-static const RESTYPE    CursorRestypes[] = {
-    RT_WINDOW, RT_PASSIVEGRAB, RT_CURSOR
-};
-
-#define NUM_CURSOR_RESTYPES (sizeof (CursorRestypes) / sizeof (CursorRestypes[0]))
-
-static Bool
-ReplaceCursorLookup (pointer value, XID id, pointer closure)
-{
-    ReplaceCursorLookupPtr  rcl = (ReplaceCursorLookupPtr) closure;
-    WindowPtr		    pWin;
-    GrabPtr		    pGrab;
-    CursorPtr		    pCursor = 0, *pCursorRef = 0;
-    XID			    cursor = 0;
-
-    switch (rcl->type) {
-    case RT_WINDOW:
-	pWin = (WindowPtr) value;
-	if (pWin->optional)
-	{
-	    pCursorRef = &pWin->optional->cursor;
-	    pCursor = *pCursorRef;
-	}
-	break;
-    case RT_PASSIVEGRAB:
-	pGrab = (GrabPtr) value;
-	pCursorRef = &pGrab->cursor;
-	pCursor = *pCursorRef;
-	break;
-    case RT_CURSOR:
-	pCursorRef = 0;
-	pCursor = (CursorPtr) value;
-	cursor = id;
-	break;
-    }
-    if (pCursor && pCursor != rcl->pNew)
-    {
-	if ((*rcl->testCursor) (pCursor, rcl->closure))
-	{
-	    rcl->pNew->refcnt++;
-	    /* either redirect reference or update resource database */
-	    if (pCursorRef)
-		*pCursorRef = rcl->pNew;
-	    else
-		ChangeResourceValue (id, RT_CURSOR, rcl->pNew);
-	    FreeCursor (pCursor, cursor);
-	}
-    }
-    return FALSE;   /* keep walking */
-}
-
-static void
-ReplaceCursor (CursorPtr pCursor,
-	       TestCursorFunc testCursor,
-	       pointer closure)
-{
-    int	clientIndex;
-    int resIndex;
-    ReplaceCursorLookupRec  rcl;
-    
-    /* 
-     * Cursors exist only in the resource database, windows and grabs.
-     * All of these are always pointed at by the resource database.  Walk
-     * the whole thing looking for cursors
-     */
-    rcl.testCursor = testCursor;
-    rcl.pNew = pCursor;
-    rcl.closure = closure;
-
-    /* for each client */
-    for (clientIndex = 0; clientIndex < currentMaxClients; clientIndex++)
-    {
-	if (!clients[clientIndex])
-	    continue;
-	for (resIndex = 0; resIndex < NUM_CURSOR_RESTYPES; resIndex++)
-	{
-	    rcl.type = CursorRestypes[resIndex];
-	    /*
-	     * This function walks the entire client resource database
-	     */
-	    LookupClientResourceComplex (clients[clientIndex], 
-					 rcl.type, 
-					 ReplaceCursorLookup,
-					 (pointer) &rcl);
-	}
-    }
-    /* this "knows" that WindowHasNewCursor doesn't depend on it's argument */
-    WindowHasNewCursor (WindowTable[0]);
-}
-
-static Bool 
-TestForCursor (CursorPtr pCursor, pointer closure)
-{
-    return (pCursor == (CursorPtr) closure);
-}
-
-int
-ProcXFixesChangeCursor (ClientPtr client)
-{
-    CursorPtr	pSource, pDestination;
-    REQUEST(xXFixesChangeCursorReq);
-
-    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    VERIFY_CURSOR (pSource, stuff->source, client,
-		   DixReadAccess|DixGetAttrAccess);
-    VERIFY_CURSOR (pDestination, stuff->destination, client,
-		   DixWriteAccess|DixSetAttrAccess);
-
-    ReplaceCursor (pSource, TestForCursor, (pointer) pDestination);
-    return (client->noClientException);
-}
-
-int
-SProcXFixesChangeCursor (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesChangeCursorReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static Bool
-TestForCursorName (CursorPtr pCursor, pointer closure)
-{
-    Atom *pName = closure;
-    return (pCursor->name == *pName);
-}
-
-int
-ProcXFixesChangeCursorByName (ClientPtr client)
-{
-    CursorPtr	pSource;
-    Atom	name;
-    char	*tchar;
-    REQUEST(xXFixesChangeCursorByNameReq);
-
-    REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes);
-    VERIFY_CURSOR(pSource, stuff->source, client,
-		  DixReadAccess|DixGetAttrAccess);
-    tchar = (char *) &stuff[1];
-    name = MakeAtom (tchar, stuff->nbytes, FALSE);
-    if (name)
-	ReplaceCursor (pSource, TestForCursorName, &name);
-    return (client->noClientException);
-}
-
-int
-SProcXFixesChangeCursorByName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesChangeCursorByNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq);
-    swapl (&stuff->source, n);
-    swaps (&stuff->nbytes, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-/*
- * Routines for manipulating the per-screen hide counts list.
- * This list indicates which clients have requested cursor hiding 
- * for that screen.
- */
-
-/* Return the screen's hide-counts list element for the given client */
-static CursorHideCountPtr
-findCursorHideCount (ClientPtr pClient, ScreenPtr pScreen) 
-{
-    CursorScreenPtr    cs = GetCursorScreen(pScreen);
-    CursorHideCountPtr pChc;
-
-    for (pChc = cs->pCursorHideCounts; pChc != NULL; pChc = pChc->pNext) {
-	if (pChc->pClient == pClient) {
-	    return pChc;
-	}
-    }
-
-    return NULL;           
-}
-
-static int
-createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen)
-{
-    CursorScreenPtr    cs = GetCursorScreen(pScreen);
-    CursorHideCountPtr pChc;
-
-    pChc = (CursorHideCountPtr) xalloc(sizeof(CursorHideCountRec));
-    if (pChc == NULL) {
-	return BadAlloc;
-    }
-    pChc->pClient = pClient;
-    pChc->pScreen = pScreen;
-    pChc->hideCount = 1;
-    pChc->resource = FakeClientID(pClient->index);
-    pChc->pNext = cs->pCursorHideCounts;
-    cs->pCursorHideCounts = pChc;
-    
-    /* 
-     * Create a resource for this element so it can be deleted
-     * when the client goes away.
-     */
-    if (!AddResource (pChc->resource, CursorHideCountType, 
-		      (pointer) pChc)) {
-	xfree(pChc);
-	return BadAlloc;
-    }
-
-    return Success;
-}
-
-/* 
- * Delete the given hide-counts list element from its screen list.
- */
-static void
-deleteCursorHideCount (CursorHideCountPtr pChcToDel, ScreenPtr pScreen)
-{
-    CursorScreenPtr    cs = GetCursorScreen(pScreen);
-    CursorHideCountPtr pChc, pNext;
-    CursorHideCountPtr pChcLast = NULL;
-
-    pChc = cs->pCursorHideCounts;
-    while (pChc != NULL) {
-	pNext = pChc->pNext;
-	if (pChc == pChcToDel) {
-	    xfree(pChc);
-	    if (pChcLast == NULL) {
-		cs->pCursorHideCounts = pNext;
-	    } else {
-		pChcLast->pNext = pNext;
-	    }
-	    return;
-	}
-	pChcLast = pChc;
-	pChc = pNext;
-    }
-}
-
-/* 
- * Delete all the hide-counts list elements for this screen.
- */
-static void
-deleteCursorHideCountsForScreen (ScreenPtr pScreen)
-{
-    CursorScreenPtr    cs = GetCursorScreen(pScreen);
-    CursorHideCountPtr pChc, pTmp;
-
-    pChc = cs->pCursorHideCounts;
-    while (pChc != NULL) {
-	pTmp = pChc->pNext;
-	FreeResource(pChc->resource, 0);
-	pChc = pTmp;
-    }
-    cs->pCursorHideCounts = NULL;   
-}
-
-int 
-ProcXFixesHideCursor (ClientPtr client) 
-{
-    WindowPtr pWin;
-    CursorHideCountPtr pChc;
-    REQUEST(xXFixesHideCursorReq);
-    int ret;
-
-    REQUEST_SIZE_MATCH (xXFixesHideCursorReq);
-
-    ret = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,
-			    client, DixGetAttrAccess);
-    if (ret != Success) {
-	client->errorValue = stuff->window;
-	return (ret == BadValue) ? BadWindow : ret;
-    }
-
-    /* 
-     * Has client hidden the cursor before on this screen? 
-     * If so, just increment the count. 
-     */
-
-    pChc = findCursorHideCount(client, pWin->drawable.pScreen);
-    if (pChc != NULL) {
-	pChc->hideCount++;
-	return client->noClientException;
-    }
-
-    /* 
-     * This is the first time this client has hid the cursor 
-     * for this screen.
-     */
-    ret = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,
-		   DixHideAccess);
-    if (ret != Success)
-	return ret;
-
-    ret = createCursorHideCount(client, pWin->drawable.pScreen);
-
-    if (ret == Success) {
-	DeviceIntPtr dev;
-	for (dev = inputInfo.devices; dev; dev = dev->next)
-	{
-	    if (IsMaster(dev) && IsPointerDevice(dev))
-		CursorDisplayCursor(dev, pWin->drawable.pScreen, CursorCurrent[dev->id]);
-	}
-    }
-
-    return ret;
-}
-
-int 
-SProcXFixesHideCursor (ClientPtr client) 
-{
-    int n;
-    REQUEST(xXFixesHideCursorReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesHideCursorReq);
-    swapl (&stuff->window, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int 
-ProcXFixesShowCursor (ClientPtr client) 
-{
-    WindowPtr pWin;
-    CursorHideCountPtr pChc;
-    int rc;
-    REQUEST(xXFixesShowCursorReq);
-
-    REQUEST_SIZE_MATCH (xXFixesShowCursorReq);
-
-    rc = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,
-			   client, DixGetAttrAccess);
-    if (rc != Success) {
-	client->errorValue = stuff->window;
-	return (rc == BadValue) ? BadWindow : rc;
-    }
-
-    /* 
-     * Has client hidden the cursor on this screen?
-     * If not, generate an error.
-     */
-    pChc = findCursorHideCount(client, pWin->drawable.pScreen);
-    if (pChc == NULL) {
-	return BadMatch;
-    }
-
-    rc = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,
-		  DixShowAccess);
-    if (rc != Success)
-	return rc;
-
-    pChc->hideCount--;
-    if (pChc->hideCount <= 0) {
-	FreeResource(pChc->resource, 0);
-    }
-
-    return (client->noClientException);
-}
-
-int 
-SProcXFixesShowCursor (ClientPtr client) 
-{
-    int n;
-    REQUEST(xXFixesShowCursorReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesShowCursorReq);
-    swapl (&stuff->window, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static int
-CursorFreeClient (pointer data, XID id)
-{
-    CursorEventPtr	old = (CursorEventPtr) data;
-    CursorEventPtr	*prev, e;
-    
-    for (prev = &cursorEvents; (e = *prev); prev = &e->next)
-    {
-	if (e == old)
-	{
-	    *prev = e->next;
-	    xfree (e);
-	    break;
-	}
-    }
-    return 1;
-}
-
-static int
-CursorFreeHideCount (pointer data, XID id)
-{
-    CursorHideCountPtr pChc = (CursorHideCountPtr) data;
-    ScreenPtr pScreen = pChc->pScreen;
-    DeviceIntPtr dev;
-
-    deleteCursorHideCount(pChc, pChc->pScreen);
-    for (dev = inputInfo.devices; dev; dev = dev->next)
-    {
-        if (IsMaster(dev) && IsPointerDevice(dev))
-            CursorDisplayCursor(dev, pScreen, CursorCurrent[dev->id]);
-    }
-
-    return 1;
-}
-
-static int
-CursorFreeWindow (pointer data, XID id)
-{
-    WindowPtr		pWindow = (WindowPtr) data;
-    CursorEventPtr	e, next;
-
-    for (e = cursorEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-    }
-    return 1;
-}
-
-static CursorPtr
-createInvisibleCursor (void)
-{
-    CursorPtr pCursor;
-    unsigned char *psrcbits, *pmaskbits;
-    CursorMetricRec cm;
-
-    psrcbits = (unsigned char *) xcalloc(4, 1);
-    pmaskbits = (unsigned char *) xcalloc(4, 1);
-    if (psrcbits == NULL || pmaskbits == NULL) {
-	return NULL;
-    }
-
-    cm.width = 1;
-    cm.height = 1;
-    cm.xhot = 0;
-    cm.yhot = 0;
-
-    if (AllocARGBCursor(psrcbits, pmaskbits,
-			NULL, &cm,
-			0, 0, 0,
-			0, 0, 0,
-			&pCursor, serverClient, (XID)0) != Success)
-	return NullCursor;
-
-    if (!AddResource(FakeClientID(0), RT_CURSOR, (pointer) pCursor))
-	return NullCursor;
-
-    return pCursor;
-}
-
-Bool
-XFixesCursorInit (void)
-{
-    int	i;
-
-    if (party_like_its_1989)
-	CursorVisible = EnableCursor;
-    
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	ScreenPtr	pScreen = screenInfo.screens[i];
-	CursorScreenPtr	cs;
-
-	cs = (CursorScreenPtr) xalloc (sizeof (CursorScreenRec));
-	if (!cs)
-	    return FALSE;
-	Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);
-	Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);
-	cs->pCursorHideCounts = NULL;
-	SetCursorScreen (pScreen, cs);
-    }
-    CursorClientType = CreateNewResourceType(CursorFreeClient,
-					     "XFixesCursorClient");
-    CursorHideCountType = CreateNewResourceType(CursorFreeHideCount,
-						"XFixesCursorHideCount");
-    CursorWindowType = CreateNewResourceType(CursorFreeWindow,
-					     "XFixesCursorWindow");
-
-    pInvisibleCursor = createInvisibleCursor();
-    if (pInvisibleCursor == NULL)
-	return BadAlloc;
-
-    return CursorClientType && CursorHideCountType && CursorWindowType;
-}
-
+/*

+ * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Copyright © 2002 Keith Packard

+ *

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

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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.

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "xfixesint.h"

+#include "scrnintstr.h"

+#include "cursorstr.h"

+#include "dixevents.h"

+#include "servermd.h"

+#include "inputstr.h"

+#include "windowstr.h"

+#include "xace.h"

+

+static RESTYPE		CursorClientType;

+static RESTYPE		CursorHideCountType;

+static RESTYPE		CursorWindowType;

+static CursorPtr	CursorCurrent[MAXDEVICES];

+static CursorPtr        pInvisibleCursor = NULL;

+

+static int CursorScreenPrivateKeyIndex;

+static DevPrivateKey CursorScreenPrivateKey = &CursorScreenPrivateKeyIndex;

+

+static void deleteCursorHideCountsForScreen (ScreenPtr pScreen);

+

+#define VERIFY_CURSOR(pCursor, cursor, client, access)			\

+    do {								\

+	int err;							\

+	err = dixLookupResourceByType((pointer *) &pCursor, cursor,	\

+				      RT_CURSOR, client, access);	\

+	if (err == BadValue) {						\

+	    client->errorValue = cursor;				\

+	    return BadCursor;						\

+	} else if (err != Success) {					\

+	    client->errorValue = cursor;				\

+	    return err;							\

+	}								\

+    } while (0)

+

+/*

+ * There is a global list of windows selecting for cursor events

+ */

+

+typedef struct _CursorEvent *CursorEventPtr;

+

+typedef struct _CursorEvent {

+    CursorEventPtr	next;

+    CARD32		eventMask;

+    ClientPtr		pClient;

+    WindowPtr		pWindow;

+    XID			clientResource;

+} CursorEventRec;

+

+static CursorEventPtr	    cursorEvents;

+

+/*

+ * Each screen has a list of clients which have requested

+ * that the cursor be hid, and the number of times each

+ * client has requested.

+*/

+

+typedef struct _CursorHideCountRec *CursorHideCountPtr;

+

+typedef struct _CursorHideCountRec {

+    CursorHideCountPtr   pNext;  

+    ClientPtr            pClient;

+    ScreenPtr            pScreen;

+    int                  hideCount;

+    XID			 resource;

+} CursorHideCountRec;

+

+/*

+ * Wrap DisplayCursor to catch cursor change events

+ */

+

+typedef struct _CursorScreen {

+    DisplayCursorProcPtr	DisplayCursor;

+    CloseScreenProcPtr		CloseScreen;

+    CursorHideCountPtr          pCursorHideCounts;

+} CursorScreenRec, *CursorScreenPtr;

+

+#define GetCursorScreen(s) ((CursorScreenPtr)dixLookupPrivate(&(s)->devPrivates, CursorScreenPrivateKey))

+#define GetCursorScreenIfSet(s) GetCursorScreen(s)

+#define SetCursorScreen(s,p) dixSetPrivate(&(s)->devPrivates, CursorScreenPrivateKey, p)

+#define Wrap(as,s,elt,func)	(((as)->elt = (s)->elt), (s)->elt = func)

+#define Unwrap(as,s,elt,backup)	(((backup) = (s)->elt), (s)->elt = (as)->elt)

+

+/* The cursor doesn't show up until the first XDefineCursor() */

+static Bool CursorVisible = FALSE;

+

+Bool EnableCursor = TRUE;

+

+static Bool

+CursorDisplayCursor (DeviceIntPtr pDev,

+                     ScreenPtr pScreen,

+		     CursorPtr pCursor)

+{

+    CursorScreenPtr	cs = GetCursorScreen(pScreen);

+    Bool		ret;

+    DisplayCursorProcPtr backupProc;

+

+    Unwrap (cs, pScreen, DisplayCursor, backupProc);

+

+    /*

+     * Have to check ConnectionInfo to distinguish client requests from

+     * initial root window setup.  Not a great way to do it, I admit.

+     */

+    if (ConnectionInfo)

+	CursorVisible = EnableCursor;

+

+    if (cs->pCursorHideCounts != NULL || !CursorVisible) {

+        ret = ((*pScreen->RealizeCursor)(pDev, pScreen, pInvisibleCursor) &&

+	       (*pScreen->DisplayCursor) (pDev, pScreen, pInvisibleCursor));

+    } else {

+	ret = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);

+    }

+

+    if (pCursor != CursorCurrent[pDev->id])

+    {

+	CursorEventPtr	e;

+

+	CursorCurrent[pDev->id] = pCursor;

+	for (e = cursorEvents; e; e = e->next)

+	{

+	    if ((e->eventMask & XFixesDisplayCursorNotifyMask) &&

+		!e->pClient->clientGone)

+	    {

+		xXFixesCursorNotifyEvent	ev;

+		ev.type = XFixesEventBase + XFixesCursorNotify;

+		ev.subtype = XFixesDisplayCursorNotify;

+		ev.sequenceNumber = e->pClient->sequence;

+		ev.window = e->pWindow->drawable.id;

+		ev.cursorSerial = pCursor->serialNumber;

+		ev.timestamp = currentTime.milliseconds;

+		ev.name = pCursor->name;

+		WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);

+	    }

+	}

+    }

+    Wrap (cs, pScreen, DisplayCursor, backupProc);

+

+    return ret;

+}

+

+static Bool

+CursorCloseScreen (int index, ScreenPtr pScreen)

+{

+    CursorScreenPtr	cs = GetCursorScreen (pScreen);

+    Bool		ret;

+    CloseScreenProcPtr	close_proc;

+    DisplayCursorProcPtr display_proc;

+

+    Unwrap (cs, pScreen, CloseScreen, close_proc);

+    Unwrap (cs, pScreen, DisplayCursor, display_proc);

+    deleteCursorHideCountsForScreen(pScreen);

+    ret = (*pScreen->CloseScreen) (index, pScreen);

+    free(cs);

+    return ret;

+}

+

+#define CursorAllEvents (XFixesDisplayCursorNotifyMask)

+

+static int

+XFixesSelectCursorInput (ClientPtr	pClient,

+			 WindowPtr	pWindow,

+			 CARD32		eventMask)

+{

+    CursorEventPtr	*prev, e;

+    pointer val;

+    int rc;

+

+    for (prev = &cursorEvents; (e = *prev); prev = &e->next)

+    {

+	if (e->pClient == pClient &&

+	    e->pWindow == pWindow)

+	{

+	    break;

+	}

+    }

+    if (!eventMask)

+    {

+	if (e)

+	{

+	    FreeResource (e->clientResource, 0);

+	}

+	return Success;

+    }

+    if (!e)

+    {

+	e = (CursorEventPtr) malloc(sizeof (CursorEventRec));

+	if (!e)

+	    return BadAlloc;

+

+	e->next = 0;

+	e->pClient = pClient;

+	e->pWindow = pWindow;

+	e->clientResource = FakeClientID(pClient->index);

+

+	/*

+	 * Add a resource hanging from the window to

+	 * catch window destroy

+	 */

+	rc = dixLookupResourceByType( &val, pWindow->drawable.id,

+				      CursorWindowType, serverClient,

+				      DixGetAttrAccess);

+	if (rc != Success)

+	    if (!AddResource (pWindow->drawable.id, CursorWindowType,

+			      (pointer) pWindow))

+	    {

+		free(e);

+		return BadAlloc;

+	    }

+

+	if (!AddResource (e->clientResource, CursorClientType, (pointer) e))

+	    return BadAlloc;

+

+	*prev = e;

+    }

+    e->eventMask = eventMask;

+    return Success;

+}

+

+int

+ProcXFixesSelectCursorInput (ClientPtr client)

+{

+    REQUEST (xXFixesSelectCursorInputReq);

+    WindowPtr	pWin;

+    int		rc;

+

+    REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq);

+    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);

+    if (rc != Success)

+        return rc;

+    if (stuff->eventMask & ~CursorAllEvents)

+    {

+	client->errorValue = stuff->eventMask;

+	return( BadValue );

+    }

+    return XFixesSelectCursorInput (client, pWin, stuff->eventMask);

+}

+

+static int

+GetBit (unsigned char *line, int x)

+{

+    unsigned char   mask;

+    

+    if (screenInfo.bitmapBitOrder == LSBFirst)

+	mask = (1 << (x & 7));

+    else

+	mask = (0x80 >> (x & 7));

+    /* XXX assumes byte order is host byte order */

+    line += (x >> 3);

+    if (*line & mask)

+	return 1;

+    return 0;

+}

+

+int

+SProcXFixesSelectCursorInput (ClientPtr client)

+{

+    register int n;

+    REQUEST(xXFixesSelectCursorInputReq);

+

+    swaps(&stuff->length, n);

+    swapl(&stuff->window, n);

+    swapl(&stuff->eventMask, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+    

+void

+SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from,

+			  xXFixesCursorNotifyEvent *to)

+{

+    to->type = from->type;

+    cpswaps (from->sequenceNumber, to->sequenceNumber);

+    cpswapl (from->window, to->window);

+    cpswapl (from->cursorSerial, to->cursorSerial);

+    cpswapl (from->timestamp, to->timestamp);

+    cpswapl (from->name, to->name);

+}

+

+static void

+CopyCursorToImage (CursorPtr pCursor, CARD32 *image)

+{

+    int width = pCursor->bits->width;

+    int height = pCursor->bits->height;

+    int npixels = width * height;

+    

+#ifdef ARGB_CURSOR

+    if (pCursor->bits->argb)

+	memcpy (image, pCursor->bits->argb, npixels * sizeof (CARD32));

+    else

+#endif

+    {

+	unsigned char	*srcLine = pCursor->bits->source;

+	unsigned char	*mskLine = pCursor->bits->mask;

+	int		stride = BitmapBytePad (width);

+	int		x, y;

+	CARD32		fg, bg;

+	

+	fg = (0xff000000 | 

+	      ((pCursor->foreRed & 0xff00) << 8) |

+	      (pCursor->foreGreen & 0xff00) |

+	      (pCursor->foreBlue >> 8));

+	bg = (0xff000000 | 

+	      ((pCursor->backRed & 0xff00) << 8) |

+	      (pCursor->backGreen & 0xff00) |

+	      (pCursor->backBlue >> 8));

+	for (y = 0; y < height; y++)

+	{

+	    for (x = 0; x < width; x++)

+	    {

+		if (GetBit (mskLine, x))

+		{

+		    if (GetBit (srcLine, x))

+			*image++ = fg;

+		    else

+			*image++ = bg;

+		}

+		else

+		    *image++ = 0;

+	    }

+	    srcLine += stride;

+	    mskLine += stride;

+	}

+    }

+}

+

+int

+ProcXFixesGetCursorImage (ClientPtr client)

+{

+/*    REQUEST(xXFixesGetCursorImageReq); */

+    xXFixesGetCursorImageReply	*rep;

+    CursorPtr			pCursor;

+    CARD32			*image;

+    int				npixels, width, height, rc, x, y;

+

+    REQUEST_SIZE_MATCH(xXFixesGetCursorImageReq);

+    pCursor = CursorCurrent[PickPointer(client)->id];

+    if (!pCursor)

+	return BadCursor;

+    rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR,

+		  pCursor, RT_NONE, NULL, DixReadAccess);

+    if (rc != Success)

+	return rc;

+    GetSpritePosition (PickPointer(client), &x, &y);

+    width = pCursor->bits->width;

+    height = pCursor->bits->height;

+    npixels = width * height;

+    rep = malloc(sizeof (xXFixesGetCursorImageReply) +

+		  npixels * sizeof (CARD32));

+    if (!rep)

+	return BadAlloc;

+

+    rep->type = X_Reply;

+    rep->sequenceNumber = client->sequence;

+    rep->length = npixels;

+    rep->width = width;

+    rep->height = height;

+    rep->x = x;

+    rep->y = y;

+    rep->xhot = pCursor->bits->xhot;

+    rep->yhot = pCursor->bits->yhot; 

+    rep->cursorSerial = pCursor->serialNumber;

+

+    image = (CARD32 *) (rep + 1);

+    CopyCursorToImage (pCursor, image);

+    if (client->swapped)

+    {

+	int n;

+	swaps (&rep->sequenceNumber, n);

+	swapl (&rep->length, n);

+	swaps (&rep->x, n);

+	swaps (&rep->y, n);

+	swaps (&rep->width, n);

+	swaps (&rep->height, n);

+	swaps (&rep->xhot, n);

+	swaps (&rep->yhot, n);

+	swapl (&rep->cursorSerial, n);

+	SwapLongs (image, npixels);

+    }

+    WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +

+			 (npixels << 2), (char *) rep);

+    free(rep);

+    return Success;

+}

+

+int

+SProcXFixesGetCursorImage (ClientPtr client)

+{

+    int n;

+    REQUEST(xXFixesGetCursorImageReq);

+    swaps (&stuff->length, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+int

+ProcXFixesSetCursorName (ClientPtr client)

+{

+    CursorPtr pCursor;

+    char *tchar;

+    REQUEST(xXFixesSetCursorNameReq);

+    Atom atom;

+

+    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);

+    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixSetAttrAccess);

+    tchar = (char *) &stuff[1];

+    atom = MakeAtom (tchar, stuff->nbytes, TRUE);

+    if (atom == BAD_RESOURCE)

+	return BadAlloc;

+    

+    pCursor->name = atom;

+    return Success;

+}

+

+int

+SProcXFixesSetCursorName (ClientPtr client)

+{

+    int n;

+    REQUEST(xXFixesSetCursorNameReq);

+

+    swaps (&stuff->length, n);

+    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);

+    swapl (&stuff->cursor, n);

+    swaps (&stuff->nbytes, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+int

+ProcXFixesGetCursorName (ClientPtr client)

+{

+    CursorPtr			pCursor;

+    xXFixesGetCursorNameReply	reply;

+    REQUEST(xXFixesGetCursorNameReq);

+    const char *str;

+    int len;

+

+    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);

+    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixGetAttrAccess);

+    if (pCursor->name)

+	str = NameForAtom (pCursor->name);

+    else

+	str = "";

+    len = strlen (str);

+    

+    reply.type = X_Reply;

+    reply.length = bytes_to_int32(len);

+    reply.sequenceNumber = client->sequence;

+    reply.atom = pCursor->name;

+    reply.nbytes = len;

+    if (client->swapped)

+    {

+	int n;

+	swaps (&reply.sequenceNumber, n);

+	swapl (&reply.length, n);

+	swapl (&reply.atom, n);

+	swaps (&reply.nbytes, n);

+    }

+    WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply);

+    WriteToClient(client, len, str);

+    

+    return Success;

+}

+

+int

+SProcXFixesGetCursorName (ClientPtr client)

+{

+    int n;

+    REQUEST(xXFixesGetCursorNameReq);

+

+    swaps (&stuff->length, n);

+    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);

+    swapl (&stuff->cursor, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+int

+ProcXFixesGetCursorImageAndName (ClientPtr client)

+{

+/*    REQUEST(xXFixesGetCursorImageAndNameReq); */

+    xXFixesGetCursorImageAndNameReply	*rep;

+    CursorPtr			pCursor;

+    CARD32			*image;

+    int				npixels;

+    const char			*name;

+    int				nbytes, nbytesRound;

+    int				width, height;

+    int				rc, x, y;

+

+    REQUEST_SIZE_MATCH(xXFixesGetCursorImageAndNameReq);

+    pCursor = CursorCurrent[PickPointer(client)->id];

+    if (!pCursor)

+	return BadCursor;

+    rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR,

+		  pCursor, RT_NONE, NULL, DixReadAccess|DixGetAttrAccess);

+    if (rc != Success)

+	return rc;

+    GetSpritePosition (PickPointer(client), &x, &y);

+    width = pCursor->bits->width;

+    height = pCursor->bits->height;

+    npixels = width * height;

+    name = pCursor->name ? NameForAtom (pCursor->name) : "";

+    nbytes = strlen (name);

+    nbytesRound = pad_to_int32(nbytes);

+    rep = malloc(sizeof (xXFixesGetCursorImageAndNameReply) +

+		  npixels * sizeof (CARD32) + nbytesRound);

+    if (!rep)

+	return BadAlloc;

+

+    rep->type = X_Reply;

+    rep->sequenceNumber = client->sequence;

+    rep->length = npixels + bytes_to_int32(nbytesRound);

+    rep->width = width;

+    rep->height = height;

+    rep->x = x;

+    rep->y = y;

+    rep->xhot = pCursor->bits->xhot;

+    rep->yhot = pCursor->bits->yhot; 

+    rep->cursorSerial = pCursor->serialNumber;

+    rep->cursorName = pCursor->name;

+    rep->nbytes = nbytes;

+

+    image = (CARD32 *) (rep + 1);

+    CopyCursorToImage (pCursor, image);

+    memcpy ((image + npixels), name, nbytes);

+    if (client->swapped)

+    {

+	int n;

+	swaps (&rep->sequenceNumber, n);

+	swapl (&rep->length, n);

+	swaps (&rep->x, n);

+	swaps (&rep->y, n);

+	swaps (&rep->width, n);

+	swaps (&rep->height, n);

+	swaps (&rep->xhot, n);

+	swaps (&rep->yhot, n);

+	swapl (&rep->cursorSerial, n);

+	swapl (&rep->cursorName, n);

+	swaps (&rep->nbytes, n);

+	SwapLongs (image, npixels);

+    }

+    WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +

+			 (npixels << 2) + nbytesRound, (char *) rep);

+    free(rep);

+    return Success;

+}

+

+int

+SProcXFixesGetCursorImageAndName (ClientPtr client)

+{

+    int n;

+    REQUEST(xXFixesGetCursorImageAndNameReq);

+    swaps (&stuff->length, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+/*

+ * Find every cursor reference in the system, ask testCursor

+ * whether it should be replaced with a reference to pCursor.

+ */

+

+typedef Bool (*TestCursorFunc) (CursorPtr pOld, pointer closure);

+

+typedef struct {

+    RESTYPE type;

+    TestCursorFunc testCursor;

+    CursorPtr pNew;

+    pointer closure;

+} ReplaceCursorLookupRec, *ReplaceCursorLookupPtr;

+

+static const RESTYPE    CursorRestypes[] = {

+    RT_WINDOW, RT_PASSIVEGRAB, RT_CURSOR

+};

+

+#define NUM_CURSOR_RESTYPES (sizeof (CursorRestypes) / sizeof (CursorRestypes[0]))

+

+static Bool

+ReplaceCursorLookup (pointer value, XID id, pointer closure)

+{

+    ReplaceCursorLookupPtr  rcl = (ReplaceCursorLookupPtr) closure;

+    WindowPtr		    pWin;

+    GrabPtr		    pGrab;

+    CursorPtr		    pCursor = 0, *pCursorRef = 0;

+    XID			    cursor = 0;

+

+    switch (rcl->type) {

+    case RT_WINDOW:

+	pWin = (WindowPtr) value;

+	if (pWin->optional)

+	{

+	    pCursorRef = &pWin->optional->cursor;

+	    pCursor = *pCursorRef;

+	}

+	break;

+    case RT_PASSIVEGRAB:

+	pGrab = (GrabPtr) value;

+	pCursorRef = &pGrab->cursor;

+	pCursor = *pCursorRef;

+	break;

+    case RT_CURSOR:

+	pCursorRef = 0;

+	pCursor = (CursorPtr) value;

+	cursor = id;

+	break;

+    }

+    if (pCursor && pCursor != rcl->pNew)

+    {

+	if ((*rcl->testCursor) (pCursor, rcl->closure))

+	{

+	    rcl->pNew->refcnt++;

+	    /* either redirect reference or update resource database */

+	    if (pCursorRef)

+		*pCursorRef = rcl->pNew;

+	    else

+		ChangeResourceValue (id, RT_CURSOR, rcl->pNew);

+	    FreeCursor (pCursor, cursor);

+	}

+    }

+    return FALSE;   /* keep walking */

+}

+

+static void

+ReplaceCursor (CursorPtr pCursor,

+	       TestCursorFunc testCursor,

+	       pointer closure)

+{

+    int	clientIndex;

+    int resIndex;

+    ReplaceCursorLookupRec  rcl;

+    

+    /* 

+     * Cursors exist only in the resource database, windows and grabs.

+     * All of these are always pointed at by the resource database.  Walk

+     * the whole thing looking for cursors

+     */

+    rcl.testCursor = testCursor;

+    rcl.pNew = pCursor;

+    rcl.closure = closure;

+

+    /* for each client */

+    for (clientIndex = 0; clientIndex < currentMaxClients; clientIndex++)

+    {

+	if (!clients[clientIndex])

+	    continue;

+	for (resIndex = 0; resIndex < NUM_CURSOR_RESTYPES; resIndex++)

+	{

+	    rcl.type = CursorRestypes[resIndex];

+	    /*

+	     * This function walks the entire client resource database

+	     */

+	    LookupClientResourceComplex (clients[clientIndex], 

+					 rcl.type, 

+					 ReplaceCursorLookup,

+					 (pointer) &rcl);

+	}

+    }

+    /* this "knows" that WindowHasNewCursor doesn't depend on it's argument */

+    WindowHasNewCursor (WindowTable[0]);

+}

+

+static Bool 

+TestForCursor (CursorPtr pCursor, pointer closure)

+{

+    return (pCursor == (CursorPtr) closure);

+}

+

+int

+ProcXFixesChangeCursor (ClientPtr client)

+{

+    CursorPtr	pSource, pDestination;

+    REQUEST(xXFixesChangeCursorReq);

+

+    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);

+    VERIFY_CURSOR (pSource, stuff->source, client,

+		   DixReadAccess|DixGetAttrAccess);

+    VERIFY_CURSOR (pDestination, stuff->destination, client,

+		   DixWriteAccess|DixSetAttrAccess);

+

+    ReplaceCursor (pSource, TestForCursor, (pointer) pDestination);

+    return Success;

+}

+

+int

+SProcXFixesChangeCursor (ClientPtr client)

+{

+    int n;

+    REQUEST(xXFixesChangeCursorReq);

+

+    swaps (&stuff->length, n);

+    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);

+    swapl (&stuff->source, n);

+    swapl (&stuff->destination, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+static Bool

+TestForCursorName (CursorPtr pCursor, pointer closure)

+{

+    Atom *pName = closure;

+    return (pCursor->name == *pName);

+}

+

+int

+ProcXFixesChangeCursorByName (ClientPtr client)

+{

+    CursorPtr	pSource;

+    Atom	name;

+    char	*tchar;

+    REQUEST(xXFixesChangeCursorByNameReq);

+

+    REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes);

+    VERIFY_CURSOR(pSource, stuff->source, client,

+		  DixReadAccess|DixGetAttrAccess);

+    tchar = (char *) &stuff[1];

+    name = MakeAtom (tchar, stuff->nbytes, FALSE);

+    if (name)

+	ReplaceCursor (pSource, TestForCursorName, &name);

+    return Success;

+}

+

+int

+SProcXFixesChangeCursorByName (ClientPtr client)

+{

+    int n;

+    REQUEST(xXFixesChangeCursorByNameReq);

+

+    swaps (&stuff->length, n);

+    REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq);

+    swapl (&stuff->source, n);

+    swaps (&stuff->nbytes, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+/*

+ * Routines for manipulating the per-screen hide counts list.

+ * This list indicates which clients have requested cursor hiding 

+ * for that screen.

+ */

+

+/* Return the screen's hide-counts list element for the given client */

+static CursorHideCountPtr

+findCursorHideCount (ClientPtr pClient, ScreenPtr pScreen) 

+{

+    CursorScreenPtr    cs = GetCursorScreen(pScreen);

+    CursorHideCountPtr pChc;

+

+    for (pChc = cs->pCursorHideCounts; pChc != NULL; pChc = pChc->pNext) {

+	if (pChc->pClient == pClient) {

+	    return pChc;

+	}

+    }

+

+    return NULL;           

+}

+

+static int

+createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen)

+{

+    CursorScreenPtr    cs = GetCursorScreen(pScreen);

+    CursorHideCountPtr pChc;

+

+    pChc = (CursorHideCountPtr) malloc(sizeof(CursorHideCountRec));

+    if (pChc == NULL) {

+	return BadAlloc;

+    }

+    pChc->pClient = pClient;

+    pChc->pScreen = pScreen;

+    pChc->hideCount = 1;

+    pChc->resource = FakeClientID(pClient->index);

+    pChc->pNext = cs->pCursorHideCounts;

+    cs->pCursorHideCounts = pChc;

+    

+    /* 

+     * Create a resource for this element so it can be deleted

+     * when the client goes away.

+     */

+    if (!AddResource (pChc->resource, CursorHideCountType, 

+		      (pointer) pChc)) {

+	free(pChc);

+	return BadAlloc;

+    }

+

+    return Success;

+}

+

+/* 

+ * Delete the given hide-counts list element from its screen list.

+ */

+static void

+deleteCursorHideCount (CursorHideCountPtr pChcToDel, ScreenPtr pScreen)

+{

+    CursorScreenPtr    cs = GetCursorScreen(pScreen);

+    CursorHideCountPtr pChc, pNext;

+    CursorHideCountPtr pChcLast = NULL;

+

+    pChc = cs->pCursorHideCounts;

+    while (pChc != NULL) {

+	pNext = pChc->pNext;

+	if (pChc == pChcToDel) {

+	    free(pChc);

+	    if (pChcLast == NULL) {

+		cs->pCursorHideCounts = pNext;

+	    } else {

+		pChcLast->pNext = pNext;

+	    }

+	    return;

+	}

+	pChcLast = pChc;

+	pChc = pNext;

+    }

+}

+

+/* 

+ * Delete all the hide-counts list elements for this screen.

+ */

+static void

+deleteCursorHideCountsForScreen (ScreenPtr pScreen)

+{

+    CursorScreenPtr    cs = GetCursorScreen(pScreen);

+    CursorHideCountPtr pChc, pTmp;

+

+    pChc = cs->pCursorHideCounts;

+    while (pChc != NULL) {

+	pTmp = pChc->pNext;

+	FreeResource(pChc->resource, 0);

+	pChc = pTmp;

+    }

+    cs->pCursorHideCounts = NULL;   

+}

+

+int 

+ProcXFixesHideCursor (ClientPtr client) 

+{

+    WindowPtr pWin;

+    CursorHideCountPtr pChc;

+    REQUEST(xXFixesHideCursorReq);

+    int ret;

+

+    REQUEST_SIZE_MATCH (xXFixesHideCursorReq);

+

+    ret = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,

+			    client, DixGetAttrAccess);

+    if (ret != Success) {

+	client->errorValue = stuff->window;

+	return (ret == BadValue) ? BadWindow : ret;

+    }

+

+    /* 

+     * Has client hidden the cursor before on this screen? 

+     * If so, just increment the count. 

+     */

+

+    pChc = findCursorHideCount(client, pWin->drawable.pScreen);

+    if (pChc != NULL) {

+	pChc->hideCount++;

+	return Success;

+    }

+

+    /* 

+     * This is the first time this client has hid the cursor 

+     * for this screen.

+     */

+    ret = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,

+		   DixHideAccess);

+    if (ret != Success)

+	return ret;

+

+    ret = createCursorHideCount(client, pWin->drawable.pScreen);

+

+    if (ret == Success) {

+	DeviceIntPtr dev;

+	for (dev = inputInfo.devices; dev; dev = dev->next)

+	{

+	    if (IsMaster(dev) && IsPointerDevice(dev))

+		CursorDisplayCursor(dev, pWin->drawable.pScreen, CursorCurrent[dev->id]);

+	}

+    }

+

+    return ret;

+}

+

+int 

+SProcXFixesHideCursor (ClientPtr client) 

+{

+    int n;

+    REQUEST(xXFixesHideCursorReq);

+

+    swaps (&stuff->length, n);

+    REQUEST_SIZE_MATCH (xXFixesHideCursorReq);

+    swapl (&stuff->window, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+int 

+ProcXFixesShowCursor (ClientPtr client) 

+{

+    WindowPtr pWin;

+    CursorHideCountPtr pChc;

+    int rc;

+    REQUEST(xXFixesShowCursorReq);

+

+    REQUEST_SIZE_MATCH (xXFixesShowCursorReq);

+

+    rc = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,

+			   client, DixGetAttrAccess);

+    if (rc != Success) {

+	client->errorValue = stuff->window;

+	return (rc == BadValue) ? BadWindow : rc;

+    }

+

+    /* 

+     * Has client hidden the cursor on this screen?

+     * If not, generate an error.

+     */

+    pChc = findCursorHideCount(client, pWin->drawable.pScreen);

+    if (pChc == NULL) {

+	return BadMatch;

+    }

+

+    rc = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,

+		  DixShowAccess);

+    if (rc != Success)

+	return rc;

+

+    pChc->hideCount--;

+    if (pChc->hideCount <= 0) {

+	FreeResource(pChc->resource, 0);

+    }

+

+    return Success;

+}

+

+int 

+SProcXFixesShowCursor (ClientPtr client) 

+{

+    int n;

+    REQUEST(xXFixesShowCursorReq);

+

+    swaps (&stuff->length, n);

+    REQUEST_SIZE_MATCH (xXFixesShowCursorReq);

+    swapl (&stuff->window, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+static int

+CursorFreeClient (pointer data, XID id)

+{

+    CursorEventPtr	old = (CursorEventPtr) data;

+    CursorEventPtr	*prev, e;

+    

+    for (prev = &cursorEvents; (e = *prev); prev = &e->next)

+    {

+	if (e == old)

+	{

+	    *prev = e->next;

+	    free(e);

+	    break;

+	}

+    }

+    return 1;

+}

+

+static int

+CursorFreeHideCount (pointer data, XID id)

+{

+    CursorHideCountPtr pChc = (CursorHideCountPtr) data;

+    ScreenPtr pScreen = pChc->pScreen;

+    DeviceIntPtr dev;

+

+    deleteCursorHideCount(pChc, pChc->pScreen);

+    for (dev = inputInfo.devices; dev; dev = dev->next)

+    {

+        if (IsMaster(dev) && IsPointerDevice(dev))

+            CursorDisplayCursor(dev, pScreen, CursorCurrent[dev->id]);

+    }

+

+    return 1;

+}

+

+static int

+CursorFreeWindow (pointer data, XID id)

+{

+    WindowPtr		pWindow = (WindowPtr) data;

+    CursorEventPtr	e, next;

+

+    for (e = cursorEvents; e; e = next)

+    {

+	next = e->next;

+	if (e->pWindow == pWindow)

+	{

+	    FreeResource (e->clientResource, 0);

+	}

+    }

+    return 1;

+}

+

+static CursorPtr

+createInvisibleCursor (void)

+{

+    CursorPtr pCursor;

+    unsigned char *psrcbits, *pmaskbits;

+    CursorMetricRec cm;

+

+    psrcbits = (unsigned char *) calloc(4, 1);

+    pmaskbits = (unsigned char *) calloc(4, 1);

+    if (psrcbits == NULL || pmaskbits == NULL) {

+	return NULL;

+    }

+

+    cm.width = 1;

+    cm.height = 1;

+    cm.xhot = 0;

+    cm.yhot = 0;

+

+    if (AllocARGBCursor(psrcbits, pmaskbits,

+			NULL, &cm,

+			0, 0, 0,

+			0, 0, 0,

+			&pCursor, serverClient, (XID)0) != Success)

+	return NullCursor;

+

+    if (!AddResource(FakeClientID(0), RT_CURSOR, (pointer) pCursor))

+	return NullCursor;

+

+    return pCursor;

+}

+

+Bool

+XFixesCursorInit (void)

+{

+    int	i;

+

+    if (party_like_its_1989)

+	CursorVisible = EnableCursor;

+    

+    for (i = 0; i < screenInfo.numScreens; i++)

+    {

+	ScreenPtr	pScreen = screenInfo.screens[i];

+	CursorScreenPtr	cs;

+

+	cs = (CursorScreenPtr) malloc(sizeof (CursorScreenRec));

+	if (!cs)

+	    return FALSE;

+	Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);

+	Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);

+	cs->pCursorHideCounts = NULL;

+	SetCursorScreen (pScreen, cs);

+    }

+    CursorClientType = CreateNewResourceType(CursorFreeClient,

+					     "XFixesCursorClient");

+    CursorHideCountType = CreateNewResourceType(CursorFreeHideCount,

+						"XFixesCursorHideCount");

+    CursorWindowType = CreateNewResourceType(CursorFreeWindow,

+					     "XFixesCursorWindow");

+

+    pInvisibleCursor = createInvisibleCursor();

+    if (pInvisibleCursor == NULL)

+	return BadAlloc;

+

+    return CursorClientType && CursorHideCountType && CursorWindowType;

+}

+

diff --git a/xorg-server/xfixes/region.c b/xorg-server/xfixes/region.c
index dc050c9fc..2276ab8b6 100644
--- a/xorg-server/xfixes/region.c
+++ b/xorg-server/xfixes/region.c
@@ -87,7 +87,7 @@ ProcXFixesCreateRegion (ClientPtr client)
     if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))

 	return BadAlloc;

     

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -132,7 +132,7 @@ ProcXFixesCreateRegionFromBitmap (ClientPtr client)
     if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))

 	return BadAlloc;

     

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -194,7 +194,7 @@ ProcXFixesCreateRegionFromWindow (ClientPtr client)
     if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))

 	return BadAlloc;

     

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -244,7 +244,7 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
     if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))

 	return BadAlloc;

     

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -291,7 +291,7 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
     if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))

 	return BadAlloc;

     

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -316,7 +316,7 @@ ProcXFixesDestroyRegion (ClientPtr client)
     REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);

     VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);

     FreeResource (stuff->region, RT_NONE);

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -355,7 +355,7 @@ ProcXFixesSetRegion (ClientPtr client)
 	return BadAlloc;

     }

     REGION_DESTROY (0, pNew);

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -383,7 +383,7 @@ ProcXFixesCopyRegion (ClientPtr client)
     if (!REGION_COPY(pScreen, pDestination, pSource))

 	return BadAlloc;

 

-    return(client->noClientException);

+    return Success;

 }

 

 int

@@ -403,7 +403,6 @@ int
 ProcXFixesCombineRegion (ClientPtr client)

 {

     RegionPtr	pSource1, pSource2, pDestination;

-    int		ret = Success;

     REQUEST (xXFixesCombineRegionReq);

 

     REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);

@@ -414,21 +413,19 @@ ProcXFixesCombineRegion (ClientPtr client)
     switch (stuff->xfixesReqType) {

     case X_XFixesUnionRegion:

 	if (!REGION_UNION (0, pDestination, pSource1, pSource2))

-	    ret = BadAlloc;

+	    return BadAlloc;

 	break;

     case X_XFixesIntersectRegion:

 	if (!REGION_INTERSECT (0, pDestination, pSource1, pSource2))

-	    ret = BadAlloc;

+	    return BadAlloc;

 	break;

     case X_XFixesSubtractRegion:

 	if (!REGION_SUBTRACT (0, pDestination, pSource1, pSource2))

-	    ret = BadAlloc;

+	    return BadAlloc;

 	break;

     }

     

-    if (ret == Success) 

-	ret = client->noClientException;

-    return ret;

+    return Success;

 }

 

 int

@@ -450,7 +447,6 @@ ProcXFixesInvertRegion (ClientPtr client)
 {

     RegionPtr	pSource, pDestination;

     BoxRec	bounds;

-    int		ret = Success;

     REQUEST(xXFixesInvertRegionReq);

 

     REQUEST_SIZE_MATCH(xXFixesInvertRegionReq);

@@ -471,11 +467,9 @@ ProcXFixesInvertRegion (ClientPtr client)
 	bounds.y2 = stuff->y + stuff->height;

 

     if (!REGION_INVERSE(0, pDestination, pSource, &bounds))

-	ret = BadAlloc;

+	return BadAlloc;

 

-    if (ret == Success)

-	ret = client->noClientException;

-    return ret;

+    return Success;

 }

 

 int

@@ -505,7 +499,7 @@ ProcXFixesTranslateRegion (ClientPtr client)
     VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);

 

     REGION_TRANSLATE(pScreen, pRegion, stuff->dx, stuff->dy);

-    return (client->noClientException);

+    return Success;

 }

 

 int

@@ -534,7 +528,7 @@ ProcXFixesRegionExtents (ClientPtr client)
 

     REGION_RESET (0, pDestination, REGION_EXTENTS (0, pSource));

 

-    return (client->noClientException);

+    return Success;

 }

 

 int

@@ -568,7 +562,7 @@ ProcXFixesFetchRegion (ClientPtr client)
     pBox = REGION_RECTS (pRegion);

     nBox = REGION_NUM_RECTS (pRegion);

     

-    reply = xalloc (sizeof (xXFixesFetchRegionReply) +

+    reply = malloc(sizeof (xXFixesFetchRegionReply) +

 		    nBox * sizeof (xRectangle));

     if (!reply)

 	return BadAlloc;

@@ -601,8 +595,8 @@ ProcXFixesFetchRegion (ClientPtr client)
     }

     (void) WriteToClient(client, sizeof (xXFixesFetchRegionReply) +

 			 nBox * sizeof (xRectangle), (char *) reply);

-    xfree (reply);

-    return (client->noClientException);

+    free(reply);

+    return Success;

 }

 

 int

@@ -622,7 +616,7 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
 {

     GCPtr	pGC;

     RegionPtr	pRegion;

-    XID		vals[2];

+    ChangeGCVal	vals[2];

     int		rc;

     REQUEST(xXFixesSetGCClipRegionReq);

     REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);

@@ -640,12 +634,12 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
 	    return BadAlloc;

     }

     

-    vals[0] = stuff->xOrigin;

-    vals[1] = stuff->yOrigin;

-    DoChangeGC (pGC, GCClipXOrigin|GCClipYOrigin, vals, 0);

+    vals[0].val = stuff->xOrigin;

+    vals[1].val = stuff->yOrigin;

+    ChangeGC (NullClient, pGC, GCClipXOrigin|GCClipYOrigin, vals);

     (*pGC->funcs->ChangeClip)(pGC, pRegion ? CT_REGION : CT_NONE, (pointer)pRegion, 0);

 

-    return (client->noClientException);

+    return Success;

 }

 

 int

@@ -741,7 +735,7 @@ ProcXFixesSetWindowShapeRegion (ClientPtr client)
     *pDestRegion = pRegion;

     (*pScreen->SetShape) (pWin);

     SendShapeNotify (pWin, stuff->destKind);

-    return (client->noClientException);

+    return Success;

 }

 

 int

@@ -797,7 +791,6 @@ int
 ProcXFixesExpandRegion (ClientPtr client)

 {

     RegionPtr	pSource, pDestination;

-    int		ret = Success;

     REQUEST (xXFixesExpandRegionReq);

     BoxPtr	pTmp;

     BoxPtr	pSrc;

@@ -812,7 +805,7 @@ ProcXFixesExpandRegion (ClientPtr client)
     pSrc = REGION_RECTS(pSource);

     if (nBoxes)

     {

-	pTmp = xalloc (nBoxes * sizeof (BoxRec));

+	pTmp = malloc(nBoxes * sizeof (BoxRec));

 	if (!pTmp)

 	    return BadAlloc;

 	for (i = 0; i < nBoxes; i++)

@@ -829,11 +822,9 @@ ProcXFixesExpandRegion (ClientPtr client)
 	    REGION_INIT (pScreen, &r, &pTmp[i], 0);

 	    REGION_UNION (pScreen, pDestination, pDestination, &r);

 	}

-	xfree(pTmp);

+	free(pTmp);

     }

-    if (ret == Success) 

-	ret = client->noClientException;

-    return ret;

+    return Success;

 }

 

 int

diff --git a/xorg-server/xfixes/saveset.c b/xorg-server/xfixes/saveset.c
index 29de0d8f2..72bbb4952 100644
--- a/xorg-server/xfixes/saveset.c
+++ b/xorg-server/xfixes/saveset.c
@@ -1,76 +1,72 @@
-/*
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-
-int
-ProcXFixesChangeSaveSet(ClientPtr client)
-{
-    Bool	toRoot, map;
-    int		result;
-    WindowPtr	pWin;
-    REQUEST(xXFixesChangeSaveSetReq);
-		  
-    REQUEST_SIZE_MATCH(xXFixesChangeSaveSetReq);
-    result = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
-    if (result != Success)
-        return result;
-    if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))
-        return BadMatch;
-    if ((stuff->mode != SetModeInsert) && (stuff->mode != SetModeDelete))
-    {
-	client->errorValue = stuff->mode;
-	return( BadValue );
-    }
-    if ((stuff->target != SaveSetNearest) && (stuff->target != SaveSetRoot))
-    {
-	client->errorValue = stuff->target;
-	return( BadValue );
-    }
-    if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap))
-    {
-	client->errorValue = stuff->map;
-	return( BadValue );
-    }
-    toRoot = (stuff->target == SaveSetRoot);
-    map = (stuff->map == SaveSetMap);
-    result = AlterSaveSetForClient(client, pWin, stuff->mode, toRoot, map);
-    if (client->noClientException != Success)
-	return(client->noClientException);
-    else
-	return(result);
-}
-
-int
-SProcXFixesChangeSaveSet(ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesChangeSaveSetReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType])(client);
-}
+/*

+ * Copyright © 2002 Keith Packard

+ *

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

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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.

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "xfixesint.h"

+

+int

+ProcXFixesChangeSaveSet(ClientPtr client)

+{

+    Bool	toRoot, map;

+    int		result;

+    WindowPtr	pWin;

+    REQUEST(xXFixesChangeSaveSetReq);

+		  

+    REQUEST_SIZE_MATCH(xXFixesChangeSaveSetReq);

+    result = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);

+    if (result != Success)

+        return result;

+    if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))

+        return BadMatch;

+    if ((stuff->mode != SetModeInsert) && (stuff->mode != SetModeDelete))

+    {

+	client->errorValue = stuff->mode;

+	return( BadValue );

+    }

+    if ((stuff->target != SaveSetNearest) && (stuff->target != SaveSetRoot))

+    {

+	client->errorValue = stuff->target;

+	return( BadValue );

+    }

+    if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap))

+    {

+	client->errorValue = stuff->map;

+	return( BadValue );

+    }

+    toRoot = (stuff->target == SaveSetRoot);

+    map = (stuff->map == SaveSetMap);

+    return AlterSaveSetForClient(client, pWin, stuff->mode, toRoot, map);

+}

+

+int

+SProcXFixesChangeSaveSet(ClientPtr client)

+{

+    register int n;

+    REQUEST(xXFixesChangeSaveSetReq);

+

+    swaps(&stuff->length, n);

+    swapl(&stuff->window, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType])(client);

+}

diff --git a/xorg-server/xfixes/select.c b/xorg-server/xfixes/select.c
index 5ba7896cb..044294ee1 100644
--- a/xorg-server/xfixes/select.c
+++ b/xorg-server/xfixes/select.c
@@ -1,292 +1,292 @@
-/*
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-#include "xace.h"
-
-static RESTYPE		SelectionClientType, SelectionWindowType;
-static Bool		SelectionCallbackRegistered = FALSE;
-
-/*
- * There is a global list of windows selecting for selection events
- * on every selection.  This should be plenty efficient for the
- * expected usage, if it does become a problem, it should be easily
- * replaced with a hash table of some kind keyed off the selection atom
- */
-
-typedef struct _SelectionEvent *SelectionEventPtr;
-
-typedef struct _SelectionEvent {
-    SelectionEventPtr	next;
-    Atom		selection;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
-} SelectionEventRec;
-
-static SelectionEventPtr	selectionEvents;
-
-static void
-XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
-{
-    SelectionEventPtr	e;
-    SelectionInfoRec	*info = (SelectionInfoRec *) args;
-    Selection		*selection = info->selection;
-    int			subtype;
-    CARD32		eventMask;
-    
-    switch (info->kind) {
-    case SelectionSetOwner:
-	subtype = XFixesSetSelectionOwnerNotify;
-	eventMask = XFixesSetSelectionOwnerNotifyMask;
-	break;
-    case SelectionWindowDestroy:
-	subtype = XFixesSelectionWindowDestroyNotify;
-	eventMask = XFixesSelectionWindowDestroyNotifyMask;
-	break;
-    case SelectionClientClose:
-	subtype = XFixesSelectionClientCloseNotify;
-	eventMask = XFixesSelectionClientCloseNotifyMask;
-	break;
-    default:
-	return;
-    }
-    for (e = selectionEvents; e; e = e->next)
-    {
-	if (e->selection == selection->selection && 
-	    (e->eventMask & eventMask) &&
-	    !e->pClient->clientGone)
-	{
-	    xXFixesSelectionNotifyEvent	ev;
-
-	    memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
-	    ev.type = XFixesEventBase + XFixesSelectionNotify;
-	    ev.subtype = subtype;
-	    ev.sequenceNumber = e->pClient->sequence;
-	    ev.window = e->pWindow->drawable.id;
-	    if (subtype == XFixesSetSelectionOwnerNotify)
-		ev.owner = selection->window;
-	    else
-		ev.owner = 0;
-	    ev.selection = e->selection;
-	    ev.timestamp = currentTime.milliseconds;
-	    ev.selectionTimestamp = selection->lastTimeChanged.milliseconds;
-	    WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
-	}
-    }
-}
-
-static Bool
-CheckSelectionCallback (void)
-{
-    if (selectionEvents)
-    {
-	if (!SelectionCallbackRegistered)
-	{
-	    if (!AddCallback (&SelectionCallback, XFixesSelectionCallback, NULL))
-		return FALSE;
-	    SelectionCallbackRegistered = TRUE;
-	}
-    }
-    else
-    {
-	if (SelectionCallbackRegistered)
-	{
-	    DeleteCallback (&SelectionCallback, XFixesSelectionCallback, NULL);
-	    SelectionCallbackRegistered = FALSE;
-	}
-    }
-    return TRUE;
-}
-
-#define SelectionAllEvents (XFixesSetSelectionOwnerNotifyMask |\
-			    XFixesSelectionWindowDestroyNotifyMask |\
-			    XFixesSelectionClientCloseNotifyMask)
-
-static int
-XFixesSelectSelectionInput (ClientPtr	pClient,
-			    Atom	selection,
-			    WindowPtr	pWindow,
-			    CARD32	eventMask)
-{
-    pointer val;
-    int rc;
-    SelectionEventPtr	*prev, e;
-
-    rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-
-    for (prev = &selectionEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->selection == selection &&
-	    e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
-    }
-    if (!eventMask)
-    {
-	if (e)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-	return Success;
-    }
-    if (!e)
-    {
-	e = (SelectionEventPtr) xalloc (sizeof (SelectionEventRec));
-	if (!e)
-	    return BadAlloc;
-
-	e->next = 0;
-	e->selection = selection;
-	e->pClient = pClient;
-	e->pWindow = pWindow;
-	e->clientResource = FakeClientID(pClient->index);
-
-	/*
-	 * Add a resource hanging from the window to
-	 * catch window destroy
-	 */
-	rc = dixLookupResourceByType (&val, pWindow->drawable.id,
-				      SelectionWindowType, serverClient,
-				      DixGetAttrAccess);
-	if (rc != Success)
-	    if (!AddResource (pWindow->drawable.id, SelectionWindowType,
-			      (pointer) pWindow))
-	    {
-		xfree (e);
-		return BadAlloc;
-	    }
-
-	if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))
-	    return BadAlloc;
-
-	*prev = e;
-	if (!CheckSelectionCallback ())
-	{
-	    FreeResource (e->clientResource, 0);
-	    return BadAlloc;
-	}
-    }
-    e->eventMask = eventMask;
-    return Success;
-}
-
-int
-ProcXFixesSelectSelectionInput (ClientPtr client)
-{
-    REQUEST (xXFixesSelectSelectionInputReq);
-    WindowPtr	pWin;
-    int		rc;
-
-    REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
-    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
-    if (rc != Success)
-        return rc;
-    if (stuff->eventMask & ~SelectionAllEvents)
-    {
-	client->errorValue = stuff->eventMask;
-	return( BadValue );
-    }
-    return XFixesSelectSelectionInput (client, stuff->selection,
-				       pWin, stuff->eventMask);
-}
-
-int
-SProcXFixesSelectSelectionInput (ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesSelectSelectionInputReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->selection, n);
-    swapl(&stuff->eventMask, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType])(client);
-}
-    
-void
-SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
-			     xXFixesSelectionNotifyEvent *to)
-{
-    to->type = from->type;
-    cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->window, to->window);
-    cpswapl (from->owner, to->owner);
-    cpswapl (from->selection, to->selection);
-    cpswapl (from->timestamp, to->timestamp);
-    cpswapl (from->selectionTimestamp, to->selectionTimestamp);
-}
-
-static int
-SelectionFreeClient (pointer data, XID id)
-{
-    SelectionEventPtr	old = (SelectionEventPtr) data;
-    SelectionEventPtr	*prev, e;
-    
-    for (prev = &selectionEvents; (e = *prev); prev = &e->next)
-    {
-	if (e == old)
-	{
-	    *prev = e->next;
-	    xfree (e);
-	    CheckSelectionCallback ();
-	    break;
-	}
-    }
-    return 1;
-}
-
-static int
-SelectionFreeWindow (pointer data, XID id)
-{
-    WindowPtr		pWindow = (WindowPtr) data;
-    SelectionEventPtr	e, next;
-
-    for (e = selectionEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-    }
-    return 1;
-}
-
-Bool
-XFixesSelectionInit (void)
-{
-    SelectionClientType = CreateNewResourceType(SelectionFreeClient,
-						"XFixesSelectionClient");
-    SelectionWindowType = CreateNewResourceType(SelectionFreeWindow,
-						"XFixesSelectionWindow");
-    return SelectionClientType && SelectionWindowType;
-}
+/*

+ * Copyright © 2002 Keith Packard

+ *

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

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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.

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "xfixesint.h"

+#include "xace.h"

+

+static RESTYPE		SelectionClientType, SelectionWindowType;

+static Bool		SelectionCallbackRegistered = FALSE;

+

+/*

+ * There is a global list of windows selecting for selection events

+ * on every selection.  This should be plenty efficient for the

+ * expected usage, if it does become a problem, it should be easily

+ * replaced with a hash table of some kind keyed off the selection atom

+ */

+

+typedef struct _SelectionEvent *SelectionEventPtr;

+

+typedef struct _SelectionEvent {

+    SelectionEventPtr	next;

+    Atom		selection;

+    CARD32		eventMask;

+    ClientPtr		pClient;

+    WindowPtr		pWindow;

+    XID			clientResource;

+} SelectionEventRec;

+

+static SelectionEventPtr	selectionEvents;

+

+static void

+XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)

+{

+    SelectionEventPtr	e;

+    SelectionInfoRec	*info = (SelectionInfoRec *) args;

+    Selection		*selection = info->selection;

+    int			subtype;

+    CARD32		eventMask;

+    

+    switch (info->kind) {

+    case SelectionSetOwner:

+	subtype = XFixesSetSelectionOwnerNotify;

+	eventMask = XFixesSetSelectionOwnerNotifyMask;

+	break;

+    case SelectionWindowDestroy:

+	subtype = XFixesSelectionWindowDestroyNotify;

+	eventMask = XFixesSelectionWindowDestroyNotifyMask;

+	break;

+    case SelectionClientClose:

+	subtype = XFixesSelectionClientCloseNotify;

+	eventMask = XFixesSelectionClientCloseNotifyMask;

+	break;

+    default:

+	return;

+    }

+    for (e = selectionEvents; e; e = e->next)

+    {

+	if (e->selection == selection->selection && 

+	    (e->eventMask & eventMask) &&

+	    !e->pClient->clientGone)

+	{

+	    xXFixesSelectionNotifyEvent	ev;

+

+	    memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));

+	    ev.type = XFixesEventBase + XFixesSelectionNotify;

+	    ev.subtype = subtype;

+	    ev.sequenceNumber = e->pClient->sequence;

+	    ev.window = e->pWindow->drawable.id;

+	    if (subtype == XFixesSetSelectionOwnerNotify)

+		ev.owner = selection->window;

+	    else

+		ev.owner = 0;

+	    ev.selection = e->selection;

+	    ev.timestamp = currentTime.milliseconds;

+	    ev.selectionTimestamp = selection->lastTimeChanged.milliseconds;

+	    WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);

+	}

+    }

+}

+

+static Bool

+CheckSelectionCallback (void)

+{

+    if (selectionEvents)

+    {

+	if (!SelectionCallbackRegistered)

+	{

+	    if (!AddCallback (&SelectionCallback, XFixesSelectionCallback, NULL))

+		return FALSE;

+	    SelectionCallbackRegistered = TRUE;

+	}

+    }

+    else

+    {

+	if (SelectionCallbackRegistered)

+	{

+	    DeleteCallback (&SelectionCallback, XFixesSelectionCallback, NULL);

+	    SelectionCallbackRegistered = FALSE;

+	}

+    }

+    return TRUE;

+}

+

+#define SelectionAllEvents (XFixesSetSelectionOwnerNotifyMask |\

+			    XFixesSelectionWindowDestroyNotifyMask |\

+			    XFixesSelectionClientCloseNotifyMask)

+

+static int

+XFixesSelectSelectionInput (ClientPtr	pClient,

+			    Atom	selection,

+			    WindowPtr	pWindow,

+			    CARD32	eventMask)

+{

+    pointer val;

+    int rc;

+    SelectionEventPtr	*prev, e;

+

+    rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess);

+    if (rc != Success)

+	return rc;

+

+    for (prev = &selectionEvents; (e = *prev); prev = &e->next)

+    {

+	if (e->selection == selection &&

+	    e->pClient == pClient &&

+	    e->pWindow == pWindow)

+	{

+	    break;

+	}

+    }

+    if (!eventMask)

+    {

+	if (e)

+	{

+	    FreeResource (e->clientResource, 0);

+	}

+	return Success;

+    }

+    if (!e)

+    {

+	e = (SelectionEventPtr) malloc(sizeof (SelectionEventRec));

+	if (!e)

+	    return BadAlloc;

+

+	e->next = 0;

+	e->selection = selection;

+	e->pClient = pClient;

+	e->pWindow = pWindow;

+	e->clientResource = FakeClientID(pClient->index);

+

+	/*

+	 * Add a resource hanging from the window to

+	 * catch window destroy

+	 */

+	rc = dixLookupResourceByType (&val, pWindow->drawable.id,

+				      SelectionWindowType, serverClient,

+				      DixGetAttrAccess);

+	if (rc != Success)

+	    if (!AddResource (pWindow->drawable.id, SelectionWindowType,

+			      (pointer) pWindow))

+	    {

+		free(e);

+		return BadAlloc;

+	    }

+

+	if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))

+	    return BadAlloc;

+

+	*prev = e;

+	if (!CheckSelectionCallback ())

+	{

+	    FreeResource (e->clientResource, 0);

+	    return BadAlloc;

+	}

+    }

+    e->eventMask = eventMask;

+    return Success;

+}

+

+int

+ProcXFixesSelectSelectionInput (ClientPtr client)

+{

+    REQUEST (xXFixesSelectSelectionInputReq);

+    WindowPtr	pWin;

+    int		rc;

+

+    REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);

+    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);

+    if (rc != Success)

+        return rc;

+    if (stuff->eventMask & ~SelectionAllEvents)

+    {

+	client->errorValue = stuff->eventMask;

+	return( BadValue );

+    }

+    return XFixesSelectSelectionInput (client, stuff->selection,

+				       pWin, stuff->eventMask);

+}

+

+int

+SProcXFixesSelectSelectionInput (ClientPtr client)

+{

+    register int n;

+    REQUEST(xXFixesSelectSelectionInputReq);

+

+    swaps(&stuff->length, n);

+    swapl(&stuff->window, n);

+    swapl(&stuff->selection, n);

+    swapl(&stuff->eventMask, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType])(client);

+}

+    

+void

+SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,

+			     xXFixesSelectionNotifyEvent *to)

+{

+    to->type = from->type;

+    cpswaps (from->sequenceNumber, to->sequenceNumber);

+    cpswapl (from->window, to->window);

+    cpswapl (from->owner, to->owner);

+    cpswapl (from->selection, to->selection);

+    cpswapl (from->timestamp, to->timestamp);

+    cpswapl (from->selectionTimestamp, to->selectionTimestamp);

+}

+

+static int

+SelectionFreeClient (pointer data, XID id)

+{

+    SelectionEventPtr	old = (SelectionEventPtr) data;

+    SelectionEventPtr	*prev, e;

+    

+    for (prev = &selectionEvents; (e = *prev); prev = &e->next)

+    {

+	if (e == old)

+	{

+	    *prev = e->next;

+	    free(e);

+	    CheckSelectionCallback ();

+	    break;

+	}

+    }

+    return 1;

+}

+

+static int

+SelectionFreeWindow (pointer data, XID id)

+{

+    WindowPtr		pWindow = (WindowPtr) data;

+    SelectionEventPtr	e, next;

+

+    for (e = selectionEvents; e; e = next)

+    {

+	next = e->next;

+	if (e->pWindow == pWindow)

+	{

+	    FreeResource (e->clientResource, 0);

+	}

+    }

+    return 1;

+}

+

+Bool

+XFixesSelectionInit (void)

+{

+    SelectionClientType = CreateNewResourceType(SelectionFreeClient,

+						"XFixesSelectionClient");

+    SelectionWindowType = CreateNewResourceType(SelectionFreeWindow,

+						"XFixesSelectionWindow");

+    return SelectionClientType && SelectionWindowType;

+}

diff --git a/xorg-server/xfixes/xfixes.c b/xorg-server/xfixes/xfixes.c
index 5163dc11e..fd23a5cb7 100644
--- a/xorg-server/xfixes/xfixes.c
+++ b/xorg-server/xfixes/xfixes.c
@@ -1,263 +1,263 @@
-/*
- * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-#include "protocol-versions.h"
-/*
- * Must use these instead of the constants from xfixeswire.h.  They advertise
- * what we implement, not what the protocol headers define.
- */
-
-static unsigned char	XFixesReqCode;
-int		XFixesEventBase;
-int		XFixesErrorBase;
-
-static int XFixesClientPrivateKeyIndex;
-static DevPrivateKey XFixesClientPrivateKey = &XFixesClientPrivateKeyIndex;
-
-static int
-ProcXFixesQueryVersion(ClientPtr client)
-{
-    XFixesClientPtr pXFixesClient = GetXFixesClient (client);
-    xXFixesQueryVersionReply rep;
-    register int n;
-    REQUEST(xXFixesQueryVersionReq);
-
-    REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
-    memset(&rep, 0, sizeof(xXFixesQueryVersionReply));
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    if (stuff->majorVersion < SERVER_XFIXES_MAJOR_VERSION) {
-	rep.majorVersion = stuff->majorVersion;
-	rep.minorVersion = stuff->minorVersion;
-    } else {
-	rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
-	if (stuff->majorVersion == SERVER_XFIXES_MAJOR_VERSION &&
-	    stuff->minorVersion < SERVER_XFIXES_MINOR_VERSION)
-	    rep.minorVersion = stuff->minorVersion;
-	else
-	    rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;
-    }
-    pXFixesClient->major_version = rep.majorVersion;
-    pXFixesClient->minor_version = rep.minorVersion;
-    if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
-    }
-    WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep);
-    return(client->noClientException);
-}
-
-/* Major version controls available requests */
-static const int version_requests[] = {
-    X_XFixesQueryVersion,	/* before client sends QueryVersion */
-    X_XFixesGetCursorImage,	/* Version 1 */
-    X_XFixesChangeCursorByName,	/* Version 2 */
-    X_XFixesExpandRegion,	/* Version 3 */
-    X_XFixesShowCursor,	        /* Version 4 */
-};
-
-#define NUM_VERSION_REQUESTS	(sizeof (version_requests) / sizeof (version_requests[0]))
-    
-int	(*ProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {
-/*************** Version 1 ******************/
-    ProcXFixesQueryVersion,
-    ProcXFixesChangeSaveSet,
-    ProcXFixesSelectSelectionInput,
-    ProcXFixesSelectCursorInput,
-    ProcXFixesGetCursorImage,
-/*************** Version 2 ******************/
-    ProcXFixesCreateRegion,
-    ProcXFixesCreateRegionFromBitmap,
-    ProcXFixesCreateRegionFromWindow,
-    ProcXFixesCreateRegionFromGC,
-    ProcXFixesCreateRegionFromPicture,
-    ProcXFixesDestroyRegion,
-    ProcXFixesSetRegion,
-    ProcXFixesCopyRegion,
-    ProcXFixesCombineRegion,
-    ProcXFixesCombineRegion,
-    ProcXFixesCombineRegion,
-    ProcXFixesInvertRegion,
-    ProcXFixesTranslateRegion,
-    ProcXFixesRegionExtents,
-    ProcXFixesFetchRegion,
-    ProcXFixesSetGCClipRegion,
-    ProcXFixesSetWindowShapeRegion,
-    ProcXFixesSetPictureClipRegion,
-    ProcXFixesSetCursorName,
-    ProcXFixesGetCursorName,
-    ProcXFixesGetCursorImageAndName,
-    ProcXFixesChangeCursor,
-    ProcXFixesChangeCursorByName,
-/*************** Version 3 ******************/
-    ProcXFixesExpandRegion,
-/*************** Version 4 ****************/
-    ProcXFixesHideCursor,
-    ProcXFixesShowCursor,
-};
-
-static int
-ProcXFixesDispatch (ClientPtr client)
-{
-    REQUEST(xXFixesReq);
-    XFixesClientPtr pXFixesClient = GetXFixesClient (client);
-
-    if (pXFixesClient->major_version >= NUM_VERSION_REQUESTS)
-	return BadRequest;
-    if (stuff->xfixesReqType > version_requests[pXFixesClient->major_version])
-	return BadRequest;
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static int
-SProcXFixesQueryVersion(ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesQueryVersionReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static int (*SProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {
-/*************** Version 1 ******************/
-    SProcXFixesQueryVersion,
-    SProcXFixesChangeSaveSet,
-    SProcXFixesSelectSelectionInput,
-    SProcXFixesSelectCursorInput,
-    SProcXFixesGetCursorImage,
-/*************** Version 2 ******************/
-    SProcXFixesCreateRegion,
-    SProcXFixesCreateRegionFromBitmap,
-    SProcXFixesCreateRegionFromWindow,
-    SProcXFixesCreateRegionFromGC,
-    SProcXFixesCreateRegionFromPicture,
-    SProcXFixesDestroyRegion,
-    SProcXFixesSetRegion,
-    SProcXFixesCopyRegion,
-    SProcXFixesCombineRegion,
-    SProcXFixesCombineRegion,
-    SProcXFixesCombineRegion,
-    SProcXFixesInvertRegion,
-    SProcXFixesTranslateRegion,
-    SProcXFixesRegionExtents,
-    SProcXFixesFetchRegion,
-    SProcXFixesSetGCClipRegion,
-    SProcXFixesSetWindowShapeRegion,
-    SProcXFixesSetPictureClipRegion,
-    SProcXFixesSetCursorName,
-    SProcXFixesGetCursorName,
-    SProcXFixesGetCursorImageAndName,
-    SProcXFixesChangeCursor,
-    SProcXFixesChangeCursorByName,
-/*************** Version 3 ******************/
-    SProcXFixesExpandRegion,
-/*************** Version 4 ****************/
-    SProcXFixesHideCursor,
-    SProcXFixesShowCursor,
-};
-
-static int
-SProcXFixesDispatch (ClientPtr client)
-{
-    REQUEST(xXFixesReq);
-    if (stuff->xfixesReqType >= XFixesNumberRequests)
-	return BadRequest;
-    return (*SProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static void
-XFixesClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
-{
-    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
-    ClientPtr		pClient = clientinfo->client;
-    XFixesClientPtr	pXFixesClient = GetXFixesClient (pClient);
-
-    pXFixesClient->major_version = 0;
-    pXFixesClient->minor_version = 0;
-}
-
-/*ARGSUSED*/
-static void
-XFixesResetProc (ExtensionEntry *extEntry)
-{
-    DeleteCallback (&ClientStateCallback, XFixesClientCallback, 0);
-}
-
-void
-XFixesExtensionInit(void)
-{
-    ExtensionEntry *extEntry;
-
-    if (!dixRequestPrivate(XFixesClientPrivateKey, sizeof (XFixesClientRec)))
-	return;
-    if (!AddCallback (&ClientStateCallback, XFixesClientCallback, 0))
-	return;
-
-    if (XFixesSelectionInit() && XFixesCursorInit () && XFixesRegionInit () &&
-	(extEntry = AddExtension(XFIXES_NAME, XFixesNumberEvents, 
-				 XFixesNumberErrors,
-				 ProcXFixesDispatch, SProcXFixesDispatch,
-				 XFixesResetProc, StandardMinorOpcode)) != 0)
-    {
-	XFixesReqCode = (unsigned char)extEntry->base;
-	XFixesEventBase = extEntry->eventBase;
-	XFixesErrorBase = extEntry->errorBase;
-	EventSwapVector[XFixesEventBase + XFixesSelectionNotify] =
-	    (EventSwapPtr) SXFixesSelectionNotifyEvent;
-	EventSwapVector[XFixesEventBase + XFixesCursorNotify] =
-	    (EventSwapPtr) SXFixesCursorNotifyEvent;
-    }
-}
+/*

+ * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Copyright © 2002 Keith Packard

+ *

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

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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.

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "xfixesint.h"

+#include "protocol-versions.h"

+/*

+ * Must use these instead of the constants from xfixeswire.h.  They advertise

+ * what we implement, not what the protocol headers define.

+ */

+

+static unsigned char	XFixesReqCode;

+int		XFixesEventBase;

+int		XFixesErrorBase;

+

+static int XFixesClientPrivateKeyIndex;

+static DevPrivateKey XFixesClientPrivateKey = &XFixesClientPrivateKeyIndex;

+

+static int

+ProcXFixesQueryVersion(ClientPtr client)

+{

+    XFixesClientPtr pXFixesClient = GetXFixesClient (client);

+    xXFixesQueryVersionReply rep;

+    register int n;

+    REQUEST(xXFixesQueryVersionReq);

+

+    REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);

+    memset(&rep, 0, sizeof(xXFixesQueryVersionReply));

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    if (stuff->majorVersion < SERVER_XFIXES_MAJOR_VERSION) {

+	rep.majorVersion = stuff->majorVersion;

+	rep.minorVersion = stuff->minorVersion;

+    } else {

+	rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;

+	if (stuff->majorVersion == SERVER_XFIXES_MAJOR_VERSION &&

+	    stuff->minorVersion < SERVER_XFIXES_MINOR_VERSION)

+	    rep.minorVersion = stuff->minorVersion;

+	else

+	    rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;

+    }

+    pXFixesClient->major_version = rep.majorVersion;

+    pXFixesClient->minor_version = rep.minorVersion;

+    if (client->swapped) {

+    	swaps(&rep.sequenceNumber, n);

+    	swapl(&rep.length, n);

+	swapl(&rep.majorVersion, n);

+	swapl(&rep.minorVersion, n);

+    }

+    WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep);

+    return Success;

+}

+

+/* Major version controls available requests */

+static const int version_requests[] = {

+    X_XFixesQueryVersion,	/* before client sends QueryVersion */

+    X_XFixesGetCursorImage,	/* Version 1 */

+    X_XFixesChangeCursorByName,	/* Version 2 */

+    X_XFixesExpandRegion,	/* Version 3 */

+    X_XFixesShowCursor,	        /* Version 4 */

+};

+

+#define NUM_VERSION_REQUESTS	(sizeof (version_requests) / sizeof (version_requests[0]))

+    

+int	(*ProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {

+/*************** Version 1 ******************/

+    ProcXFixesQueryVersion,

+    ProcXFixesChangeSaveSet,

+    ProcXFixesSelectSelectionInput,

+    ProcXFixesSelectCursorInput,

+    ProcXFixesGetCursorImage,

+/*************** Version 2 ******************/

+    ProcXFixesCreateRegion,

+    ProcXFixesCreateRegionFromBitmap,

+    ProcXFixesCreateRegionFromWindow,

+    ProcXFixesCreateRegionFromGC,

+    ProcXFixesCreateRegionFromPicture,

+    ProcXFixesDestroyRegion,

+    ProcXFixesSetRegion,

+    ProcXFixesCopyRegion,

+    ProcXFixesCombineRegion,

+    ProcXFixesCombineRegion,

+    ProcXFixesCombineRegion,

+    ProcXFixesInvertRegion,

+    ProcXFixesTranslateRegion,

+    ProcXFixesRegionExtents,

+    ProcXFixesFetchRegion,

+    ProcXFixesSetGCClipRegion,

+    ProcXFixesSetWindowShapeRegion,

+    ProcXFixesSetPictureClipRegion,

+    ProcXFixesSetCursorName,

+    ProcXFixesGetCursorName,

+    ProcXFixesGetCursorImageAndName,

+    ProcXFixesChangeCursor,

+    ProcXFixesChangeCursorByName,

+/*************** Version 3 ******************/

+    ProcXFixesExpandRegion,

+/*************** Version 4 ****************/

+    ProcXFixesHideCursor,

+    ProcXFixesShowCursor,

+};

+

+static int

+ProcXFixesDispatch (ClientPtr client)

+{

+    REQUEST(xXFixesReq);

+    XFixesClientPtr pXFixesClient = GetXFixesClient (client);

+

+    if (pXFixesClient->major_version >= NUM_VERSION_REQUESTS)

+	return BadRequest;

+    if (stuff->xfixesReqType > version_requests[pXFixesClient->major_version])

+	return BadRequest;

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+static int

+SProcXFixesQueryVersion(ClientPtr client)

+{

+    register int n;

+    REQUEST(xXFixesQueryVersionReq);

+

+    swaps(&stuff->length, n);

+    swapl(&stuff->majorVersion, n);

+    swapl(&stuff->minorVersion, n);

+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+static int (*SProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {

+/*************** Version 1 ******************/

+    SProcXFixesQueryVersion,

+    SProcXFixesChangeSaveSet,

+    SProcXFixesSelectSelectionInput,

+    SProcXFixesSelectCursorInput,

+    SProcXFixesGetCursorImage,

+/*************** Version 2 ******************/

+    SProcXFixesCreateRegion,

+    SProcXFixesCreateRegionFromBitmap,

+    SProcXFixesCreateRegionFromWindow,

+    SProcXFixesCreateRegionFromGC,

+    SProcXFixesCreateRegionFromPicture,

+    SProcXFixesDestroyRegion,

+    SProcXFixesSetRegion,

+    SProcXFixesCopyRegion,

+    SProcXFixesCombineRegion,

+    SProcXFixesCombineRegion,

+    SProcXFixesCombineRegion,

+    SProcXFixesInvertRegion,

+    SProcXFixesTranslateRegion,

+    SProcXFixesRegionExtents,

+    SProcXFixesFetchRegion,

+    SProcXFixesSetGCClipRegion,

+    SProcXFixesSetWindowShapeRegion,

+    SProcXFixesSetPictureClipRegion,

+    SProcXFixesSetCursorName,

+    SProcXFixesGetCursorName,

+    SProcXFixesGetCursorImageAndName,

+    SProcXFixesChangeCursor,

+    SProcXFixesChangeCursorByName,

+/*************** Version 3 ******************/

+    SProcXFixesExpandRegion,

+/*************** Version 4 ****************/

+    SProcXFixesHideCursor,

+    SProcXFixesShowCursor,

+};

+

+static int

+SProcXFixesDispatch (ClientPtr client)

+{

+    REQUEST(xXFixesReq);

+    if (stuff->xfixesReqType >= XFixesNumberRequests)

+	return BadRequest;

+    return (*SProcXFixesVector[stuff->xfixesReqType]) (client);

+}

+

+static void

+XFixesClientCallback (CallbackListPtr	*list,

+		      pointer		closure,

+		      pointer		data)

+{

+    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;

+    ClientPtr		pClient = clientinfo->client;

+    XFixesClientPtr	pXFixesClient = GetXFixesClient (pClient);

+

+    pXFixesClient->major_version = 0;

+    pXFixesClient->minor_version = 0;

+}

+

+/*ARGSUSED*/

+static void

+XFixesResetProc (ExtensionEntry *extEntry)

+{

+    DeleteCallback (&ClientStateCallback, XFixesClientCallback, 0);

+}

+

+void

+XFixesExtensionInit(void)

+{

+    ExtensionEntry *extEntry;

+

+    if (!dixRequestPrivate(XFixesClientPrivateKey, sizeof (XFixesClientRec)))

+	return;

+    if (!AddCallback (&ClientStateCallback, XFixesClientCallback, 0))

+	return;

+

+    if (XFixesSelectionInit() && XFixesCursorInit () && XFixesRegionInit () &&

+	(extEntry = AddExtension(XFIXES_NAME, XFixesNumberEvents, 

+				 XFixesNumberErrors,

+				 ProcXFixesDispatch, SProcXFixesDispatch,

+				 XFixesResetProc, StandardMinorOpcode)) != 0)

+    {

+	XFixesReqCode = (unsigned char)extEntry->base;

+	XFixesEventBase = extEntry->eventBase;

+	XFixesErrorBase = extEntry->errorBase;

+	EventSwapVector[XFixesEventBase + XFixesSelectionNotify] =

+	    (EventSwapPtr) SXFixesSelectionNotifyEvent;

+	EventSwapVector[XFixesEventBase + XFixesCursorNotify] =

+	    (EventSwapPtr) SXFixesCursorNotifyEvent;

+    }

+}