Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>

7 files changed, 1331 insertions, 1377 deletions

diff --git a/xfixes/cursor.c b/xfixes/cursor.c
index 7c46269bf..602b9061e 100644
--- a/xfixes/cursor.c
+++ b/xfixes/cursor.c
@@ -57,16 +57,17 @@
 #include "xace.h"
 #include "list.h"
 
-static RESTYPE		CursorClientType;
-static RESTYPE		CursorHideCountType;
-static RESTYPE		CursorWindowType;
-RESTYPE			PointerBarrierType;
-static CursorPtr	CursorCurrent[MAXDEVICES];
+static RESTYPE CursorClientType;
+static RESTYPE CursorHideCountType;
+static RESTYPE CursorWindowType;
+RESTYPE PointerBarrierType;
+static CursorPtr CursorCurrent[MAXDEVICES];
 
 static DevPrivateKeyRec CursorScreenPrivateKeyRec;
+
 #define CursorScreenPrivateKey (&CursorScreenPrivateKeyRec)
 
-static void deleteCursorHideCountsForScreen (ScreenPtr pScreen);
+static void deleteCursorHideCountsForScreen(ScreenPtr pScreen);
 
 #define VERIFY_CURSOR(pCursor, cursor, client, access)			\
     do {								\
@@ -86,14 +87,14 @@ static void deleteCursorHideCountsForScreen (ScreenPtr pScreen);
 typedef struct _CursorEvent *CursorEventPtr;
 
 typedef struct _CursorEvent {
-    CursorEventPtr	next;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
+    CursorEventPtr next;
+    CARD32 eventMask;
+    ClientPtr pClient;
+    WindowPtr pWindow;
+    XID clientResource;
 } CursorEventRec;
 
-static CursorEventPtr	    cursorEvents;
+static CursorEventPtr cursorEvents;
 
 /*
  * Each screen has a list of clients which have requested
@@ -104,11 +105,11 @@ static CursorEventPtr	    cursorEvents;
 typedef struct _CursorHideCountRec *CursorHideCountPtr;
 
 typedef struct _CursorHideCountRec {
-    CursorHideCountPtr   pNext;  
-    ClientPtr            pClient;
-    ScreenPtr            pScreen;
-    int                  hideCount;
-    XID			 resource;
+    CursorHideCountPtr pNext;
+    ClientPtr pClient;
+    ScreenPtr pScreen;
+    int hideCount;
+    XID resource;
 } CursorHideCountRec;
 
 typedef struct PointerBarrierClient *PointerBarrierClientPtr;
@@ -124,11 +125,11 @@ struct PointerBarrierClient {
  */
 
 typedef struct _CursorScreen {
-    DisplayCursorProcPtr	DisplayCursor;
-    CloseScreenProcPtr		CloseScreen;
+    DisplayCursorProcPtr DisplayCursor;
+    CloseScreenProcPtr CloseScreen;
     ConstrainCursorHarderProcPtr ConstrainCursorHarder;
-    CursorHideCountPtr          pCursorHideCounts;
-    struct xorg_list            barriers;
+    CursorHideCountPtr pCursorHideCounts;
+    struct xorg_list barriers;
 } CursorScreenRec, *CursorScreenPtr;
 
 #define GetCursorScreen(s) ((CursorScreenPtr)dixLookupPrivate(&(s)->devPrivates, CursorScreenPrivateKey))
@@ -143,66 +144,63 @@ static Bool CursorVisible = FALSE;
 Bool EnableCursor = TRUE;
 
 static Bool
-CursorDisplayCursor (DeviceIntPtr pDev,
-                     ScreenPtr pScreen,
-		     CursorPtr pCursor)
+CursorDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 {
-    CursorScreenPtr	cs = GetCursorScreen(pScreen);
-    Bool		ret;
+    CursorScreenPtr cs = GetCursorScreen(pScreen);
+    Bool ret;
     DisplayCursorProcPtr backupProc;
 
-    Unwrap (cs, pScreen, DisplayCursor, 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;
+        CursorVisible = EnableCursor;
 
     if (cs->pCursorHideCounts != NULL || !CursorVisible) {
-	ret = (*pScreen->DisplayCursor) (pDev, pScreen, NullCursor);
-    } else {
-	ret = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);
+        ret = (*pScreen->DisplayCursor) (pDev, pScreen, NullCursor);
+    }
+    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))
-	    {
-		xXFixesCursorNotifyEvent	ev;
-		ev.type = XFixesEventBase + XFixesCursorNotify;
-		ev.subtype = XFixesDisplayCursorNotify;
-		ev.window = e->pWindow->drawable.id;
-		ev.cursorSerial = pCursor ? pCursor->serialNumber : 0;
-		ev.timestamp = currentTime.milliseconds;
-		ev.name = pCursor ? pCursor->name : None;
-		WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
-	    }
-	}
+    if (pCursor != CursorCurrent[pDev->id]) {
+        CursorEventPtr e;
+
+        CursorCurrent[pDev->id] = pCursor;
+        for (e = cursorEvents; e; e = e->next) {
+            if ((e->eventMask & XFixesDisplayCursorNotifyMask)) {
+                xXFixesCursorNotifyEvent ev;
+
+                ev.type = XFixesEventBase + XFixesCursorNotify;
+                ev.subtype = XFixesDisplayCursorNotify;
+                ev.window = e->pWindow->drawable.id;
+                ev.cursorSerial = pCursor ? pCursor->serialNumber : 0;
+                ev.timestamp = currentTime.milliseconds;
+                ev.name = pCursor ? pCursor->name : None;
+                WriteEventsToClient(e->pClient, 1, (xEvent *) &ev);
+            }
+        }
     }
-    Wrap (cs, pScreen, DisplayCursor, backupProc);
+    Wrap(cs, pScreen, DisplayCursor, backupProc);
 
     return ret;
 }
 
 static Bool
-CursorCloseScreen (int index, ScreenPtr pScreen)
+CursorCloseScreen(int index, ScreenPtr pScreen)
 {
-    CursorScreenPtr	cs = GetCursorScreen (pScreen);
-    Bool		ret;
-    _X_UNUSED CloseScreenProcPtr	close_proc;
-    _X_UNUSED DisplayCursorProcPtr	display_proc;
+    CursorScreenPtr cs = GetCursorScreen(pScreen);
+    Bool ret;
+    _X_UNUSED CloseScreenProcPtr close_proc;
+    _X_UNUSED DisplayCursorProcPtr display_proc;
     ConstrainCursorHarderProcPtr constrain_proc;
 
-    Unwrap (cs, pScreen, CloseScreen, close_proc);
-    Unwrap (cs, pScreen, DisplayCursor, display_proc);
-    Unwrap (cs, pScreen, ConstrainCursorHarder, constrain_proc);
+    Unwrap(cs, pScreen, CloseScreen, close_proc);
+    Unwrap(cs, pScreen, DisplayCursor, display_proc);
+    Unwrap(cs, pScreen, ConstrainCursorHarder, constrain_proc);
     deleteCursorHideCountsForScreen(pScreen);
     ret = (*pScreen->CloseScreen) (index, pScreen);
     free(cs);
@@ -212,102 +210,92 @@ CursorCloseScreen (int index, ScreenPtr pScreen)
 #define CursorAllEvents (XFixesDisplayCursorNotifyMask)
 
 static int
-XFixesSelectCursorInput (ClientPtr	pClient,
-			 WindowPtr	pWindow,
-			 CARD32		eventMask)
+XFixesSelectCursorInput(ClientPtr pClient, WindowPtr pWindow, CARD32 eventMask)
 {
-    CursorEventPtr	*prev, e;
+    CursorEventPtr *prev, e;
     pointer val;
     int rc;
 
-    for (prev = &cursorEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
+    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 (!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;
+    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)
+ProcXFixesSelectCursorInput(ClientPtr client)
 {
-    REQUEST (xXFixesSelectCursorInputReq);
-    WindowPtr	pWin;
-    int		rc;
+    REQUEST(xXFixesSelectCursorInputReq);
+    WindowPtr pWin;
+    int rc;
 
-    REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq);
+    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;
+    if (stuff->eventMask & ~CursorAllEvents) {
+        client->errorValue = stuff->eventMask;
+        return BadValue;
     }
-    return XFixesSelectCursorInput (client, pWin, stuff->eventMask);
+    return XFixesSelectCursorInput(client, pWin, stuff->eventMask);
 }
 
 static int
-GetBit (unsigned char *line, int x)
+GetBit(unsigned char *line, int x)
 {
-    unsigned char   mask;
-    
+    unsigned char mask;
+
     if (screenInfo.bitmapBitOrder == LSBFirst)
-	mask = (1 << (x & 7));
+        mask = (1 << (x & 7));
     else
-	mask = (0x80 >> (x & 7));
+        mask = (0x80 >> (x & 7));
     /* XXX assumes byte order is host byte order */
     line += (x >> 3);
     if (*line & mask)
-	return 1;
+        return 1;
     return 0;
 }
 
 int
-SProcXFixesSelectCursorInput (ClientPtr client)
+SProcXFixesSelectCursorInput(ClientPtr client)
 {
     REQUEST(xXFixesSelectCursorInputReq);
 
@@ -316,91 +304,85 @@ SProcXFixesSelectCursorInput (ClientPtr client)
     swapl(&stuff->eventMask);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
-    
+
 void
-SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from,
-			  xXFixesCursorNotifyEvent *to)
+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);
+    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)
+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));
+        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;
-	}
+        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)
+ProcXFixesGetCursorImage(ClientPtr client)
 {
 /*    REQUEST(xXFixesGetCursorImageReq); */
-    xXFixesGetCursorImageReply	*rep;
-    CursorPtr			pCursor;
-    CARD32			*image;
-    int				npixels, width, height, rc, x, y;
+    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;
+        return BadCursor;
     rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR,
-		  pCursor, RT_NONE, NULL, DixReadAccess);
+                  pCursor, RT_NONE, NULL, DixReadAccess);
     if (rc != Success)
-	return rc;
-    GetSpritePosition (PickPointer(client), &x, &y);
+        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));
+    rep = malloc(sizeof(xXFixesGetCursorImageReply) + npixels * sizeof(CARD32));
     if (!rep)
-	return BadAlloc;
+        return BadAlloc;
 
     rep->type = X_Reply;
     rep->sequenceNumber = client->sequence;
@@ -410,32 +392,31 @@ ProcXFixesGetCursorImage (ClientPtr client)
     rep->x = x;
     rep->y = y;
     rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
+    rep->yhot = pCursor->bits->yhot;
     rep->cursorSerial = pCursor->serialNumber;
 
     image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    if (client->swapped)
-    {
-	swaps(&rep->sequenceNumber);
-	swapl(&rep->length);
-	swaps(&rep->x);
-	swaps(&rep->y);
-	swaps(&rep->width);
-	swaps(&rep->height);
-	swaps(&rep->xhot);
-	swaps(&rep->yhot);
-	swapl(&rep->cursorSerial);
-	SwapLongs (image, npixels);
+    CopyCursorToImage(pCursor, image);
+    if (client->swapped) {
+        swaps(&rep->sequenceNumber);
+        swapl(&rep->length);
+        swaps(&rep->x);
+        swaps(&rep->y);
+        swaps(&rep->width);
+        swaps(&rep->height);
+        swaps(&rep->xhot);
+        swaps(&rep->yhot);
+        swapl(&rep->cursorSerial);
+        SwapLongs(image, npixels);
     }
-    WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
-			 (npixels << 2), (char *) rep);
+    WriteToClient(client, sizeof(xXFixesGetCursorImageReply) +
+                  (npixels << 2), (char *) rep);
     free(rep);
     return Success;
 }
 
 int
-SProcXFixesGetCursorImage (ClientPtr client)
+SProcXFixesGetCursorImage(ClientPtr client)
 {
     REQUEST(xXFixesGetCursorImageReq);
     swaps(&stuff->length);
@@ -443,26 +424,27 @@ SProcXFixesGetCursorImage (ClientPtr client)
 }
 
 int
-ProcXFixesSetCursorName (ClientPtr client)
+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);
+    atom = MakeAtom(tchar, stuff->nbytes, TRUE);
     if (atom == BAD_RESOURCE)
-	return BadAlloc;
-    
+        return BadAlloc;
+
     pCursor->name = atom;
     return Success;
 }
 
 int
-SProcXFixesSetCursorName (ClientPtr client)
+SProcXFixesSetCursorName(ClientPtr client)
 {
     REQUEST(xXFixesSetCursorNameReq);
 
@@ -474,10 +456,11 @@ SProcXFixesSetCursorName (ClientPtr client)
 }
 
 int
-ProcXFixesGetCursorName (ClientPtr client)
+ProcXFixesGetCursorName(ClientPtr client)
 {
-    CursorPtr			pCursor;
-    xXFixesGetCursorNameReply	reply;
+    CursorPtr pCursor;
+    xXFixesGetCursorNameReply reply;
+
     REQUEST(xXFixesGetCursorNameReq);
     const char *str;
     int len;
@@ -485,31 +468,30 @@ ProcXFixesGetCursorName (ClientPtr client)
     REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
     VERIFY_CURSOR(pCursor, stuff->cursor, client, DixGetAttrAccess);
     if (pCursor->name)
-	str = NameForAtom (pCursor->name);
+        str = NameForAtom(pCursor->name);
     else
-	str = "";
-    len = strlen (str);
-    
+        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)
-    {
-	swaps(&reply.sequenceNumber);
-	swapl(&reply.length);
-	swapl(&reply.atom);
-	swaps(&reply.nbytes);
+    if (client->swapped) {
+        swaps(&reply.sequenceNumber);
+        swapl(&reply.length);
+        swapl(&reply.atom);
+        swaps(&reply.nbytes);
     }
     WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply);
     WriteToClient(client, len, str);
-    
+
     return Success;
 }
 
 int
-SProcXFixesGetCursorName (ClientPtr client)
+SProcXFixesGetCursorName(ClientPtr client)
 {
     REQUEST(xXFixesGetCursorNameReq);
 
@@ -520,37 +502,37 @@ SProcXFixesGetCursorName (ClientPtr client)
 }
 
 int
-ProcXFixesGetCursorImageAndName (ClientPtr client)
+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;
+    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;
+        return BadCursor;
     rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR,
-		  pCursor, RT_NONE, NULL, DixReadAccess|DixGetAttrAccess);
+                  pCursor, RT_NONE, NULL, DixReadAccess | DixGetAttrAccess);
     if (rc != Success)
-	return rc;
-    GetSpritePosition (PickPointer(client), &x, &y);
+        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);
+    name = pCursor->name ? NameForAtom(pCursor->name) : "";
+    nbytes = strlen(name);
     nbytesRound = pad_to_int32(nbytes);
-    rep = malloc(sizeof (xXFixesGetCursorImageAndNameReply) +
-		  npixels * sizeof (CARD32) + nbytesRound);
+    rep = malloc(sizeof(xXFixesGetCursorImageAndNameReply) +
+                 npixels * sizeof(CARD32) + nbytesRound);
     if (!rep)
-	return BadAlloc;
+        return BadAlloc;
 
     rep->type = X_Reply;
     rep->sequenceNumber = client->sequence;
@@ -560,37 +542,36 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
     rep->x = x;
     rep->y = y;
     rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
+    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)
-    {
-	swaps(&rep->sequenceNumber);
-	swapl(&rep->length);
-	swaps(&rep->x);
-	swaps(&rep->y);
-	swaps(&rep->width);
-	swaps(&rep->height);
-	swaps(&rep->xhot);
-	swaps(&rep->yhot);
-	swapl(&rep->cursorSerial);
-	swapl(&rep->cursorName);
-	swaps(&rep->nbytes);
-	SwapLongs (image, npixels);
+    CopyCursorToImage(pCursor, image);
+    memcpy((image + npixels), name, nbytes);
+    if (client->swapped) {
+        swaps(&rep->sequenceNumber);
+        swapl(&rep->length);
+        swaps(&rep->x);
+        swaps(&rep->y);
+        swaps(&rep->width);
+        swaps(&rep->height);
+        swaps(&rep->xhot);
+        swaps(&rep->yhot);
+        swapl(&rep->cursorSerial);
+        swapl(&rep->cursorName);
+        swaps(&rep->nbytes);
+        SwapLongs(image, npixels);
     }
-    WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
-			 (npixels << 2) + nbytesRound, (char *) rep);
+    WriteToClient(client, sizeof(xXFixesGetCursorImageAndNameReply) +
+                  (npixels << 2) + nbytesRound, (char *) rep);
     free(rep);
     return Success;
 }
 
 int
-SProcXFixesGetCursorImageAndName (ClientPtr client)
+SProcXFixesGetCursorImageAndName(ClientPtr client)
 {
     REQUEST(xXFixesGetCursorImageAndNameReq);
     swaps(&stuff->length);
@@ -611,66 +592,61 @@ typedef struct {
     pointer closure;
 } ReplaceCursorLookupRec, *ReplaceCursorLookupPtr;
 
-static const RESTYPE    CursorRestypes[] = {
+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)
+ReplaceCursorLookup(pointer value, XID id, pointer closure)
 {
-    ReplaceCursorLookupPtr  rcl = (ReplaceCursorLookupPtr) closure;
-    WindowPtr		    pWin;
-    GrabPtr		    pGrab;
-    CursorPtr		    pCursor = 0, *pCursorRef = 0;
-    XID			    cursor = 0;
+    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;
+        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;
+        pGrab = (GrabPtr) value;
+        pCursorRef = &pGrab->cursor;
+        pCursor = *pCursorRef;
+        break;
     case RT_CURSOR:
-	pCursorRef = 0;
-	pCursor = (CursorPtr) value;
-	cursor = id;
-	break;
+        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);
-	}
+    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 */
+    return FALSE;               /* keep walking */
 }
 
 static void
-ReplaceCursor (CursorPtr pCursor,
-	       TestCursorFunc testCursor,
-	       pointer closure)
+ReplaceCursor(CursorPtr pCursor, TestCursorFunc testCursor, pointer closure)
 {
-    int	clientIndex;
+    int clientIndex;
     int resIndex;
-    ReplaceCursorLookupRec  rcl;
-    
+    ReplaceCursorLookupRec rcl;
+
     /* 
      * Cursors exist only in the resource database, windows and grabs.
      * All of these are always pointed at by the resource database.  Walk
@@ -681,50 +657,48 @@ ReplaceCursor (CursorPtr 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);
-	}
+    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 (screenInfo.screens[0]->root);
+    WindowHasNewCursor(screenInfo.screens[0]->root);
 }
 
-static Bool 
-TestForCursor (CursorPtr pCursor, pointer closure)
+static Bool
+TestForCursor(CursorPtr pCursor, pointer closure)
 {
     return (pCursor == (CursorPtr) closure);
 }
 
 int
-ProcXFixesChangeCursor (ClientPtr client)
+ProcXFixesChangeCursor(ClientPtr client)
 {
-    CursorPtr	pSource, pDestination;
+    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);
+    VERIFY_CURSOR(pSource, stuff->source, client,
+                  DixReadAccess | DixGetAttrAccess);
+    VERIFY_CURSOR(pDestination, stuff->destination, client,
+                  DixWriteAccess | DixSetAttrAccess);
 
-    ReplaceCursor (pSource, TestForCursor, (pointer) pDestination);
+    ReplaceCursor(pSource, TestForCursor, (pointer) pDestination);
     return Success;
 }
 
 int
-SProcXFixesChangeCursor (ClientPtr client)
+SProcXFixesChangeCursor(ClientPtr client)
 {
     REQUEST(xXFixesChangeCursorReq);
 
@@ -736,37 +710,39 @@ SProcXFixesChangeCursor (ClientPtr client)
 }
 
 static Bool
-TestForCursorName (CursorPtr pCursor, pointer closure)
+TestForCursorName(CursorPtr pCursor, pointer closure)
 {
     Atom *pName = closure;
+
     return pCursor->name == *pName;
 }
 
 int
-ProcXFixesChangeCursorByName (ClientPtr client)
+ProcXFixesChangeCursorByName(ClientPtr client)
 {
-    CursorPtr	pSource;
-    Atom	name;
-    char	*tchar;
+    CursorPtr pSource;
+    Atom name;
+    char *tchar;
+
     REQUEST(xXFixesChangeCursorByNameReq);
 
     REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes);
     VERIFY_CURSOR(pSource, stuff->source, client,
-		  DixReadAccess|DixGetAttrAccess);
+                  DixReadAccess | DixGetAttrAccess);
     tchar = (char *) &stuff[1];
-    name = MakeAtom (tchar, stuff->nbytes, FALSE);
+    name = MakeAtom(tchar, stuff->nbytes, FALSE);
     if (name)
-	ReplaceCursor (pSource, TestForCursorName, &name);
+        ReplaceCursor(pSource, TestForCursorName, &name);
     return Success;
 }
 
 int
-SProcXFixesChangeCursorByName (ClientPtr client)
+SProcXFixesChangeCursorByName(ClientPtr client)
 {
     REQUEST(xXFixesChangeCursorByNameReq);
 
     swaps(&stuff->length);
-    REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq);
+    REQUEST_AT_LEAST_SIZE(xXFixesChangeCursorByNameReq);
     swapl(&stuff->source);
     swaps(&stuff->nbytes);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
@@ -780,29 +756,29 @@ SProcXFixesChangeCursorByName (ClientPtr client)
 
 /* Return the screen's hide-counts list element for the given client */
 static CursorHideCountPtr
-findCursorHideCount (ClientPtr pClient, ScreenPtr pScreen) 
+findCursorHideCount(ClientPtr pClient, ScreenPtr pScreen)
 {
-    CursorScreenPtr    cs = GetCursorScreen(pScreen);
+    CursorScreenPtr cs = GetCursorScreen(pScreen);
     CursorHideCountPtr pChc;
 
     for (pChc = cs->pCursorHideCounts; pChc != NULL; pChc = pChc->pNext) {
-	if (pChc->pClient == pClient) {
-	    return pChc;
-	}
+        if (pChc->pClient == pClient) {
+            return pChc;
+        }
     }
 
-    return NULL;           
+    return NULL;
 }
 
 static int
-createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen)
+createCursorHideCount(ClientPtr pClient, ScreenPtr pScreen)
 {
-    CursorScreenPtr    cs = GetCursorScreen(pScreen);
+    CursorScreenPtr cs = GetCursorScreen(pScreen);
     CursorHideCountPtr pChc;
 
     pChc = (CursorHideCountPtr) malloc(sizeof(CursorHideCountRec));
     if (pChc == NULL) {
-	return BadAlloc;
+        return BadAlloc;
     }
     pChc->pClient = pClient;
     pChc->pScreen = pScreen;
@@ -810,15 +786,14 @@ createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen)
     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;
+    if (!AddResource(pChc->resource, CursorHideCountType, (pointer) pChc)) {
+        free(pChc);
+        return BadAlloc;
     }
 
     return Success;
@@ -828,26 +803,27 @@ createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen)
  * Delete the given hide-counts list element from its screen list.
  */
 static void
-deleteCursorHideCount (CursorHideCountPtr pChcToDel, ScreenPtr pScreen)
+deleteCursorHideCount(CursorHideCountPtr pChcToDel, ScreenPtr pScreen)
 {
-    CursorScreenPtr    cs = GetCursorScreen(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;
+        pNext = pChc->pNext;
+        if (pChc == pChcToDel) {
+            free(pChc);
+            if (pChcLast == NULL) {
+                cs->pCursorHideCounts = pNext;
+            }
+            else {
+                pChcLast->pNext = pNext;
+            }
+            return;
+        }
+        pChcLast = pChc;
+        pChc = pNext;
     }
 }
 
@@ -855,35 +831,36 @@ deleteCursorHideCount (CursorHideCountPtr pChcToDel, ScreenPtr pScreen)
  * Delete all the hide-counts list elements for this screen.
  */
 static void
-deleteCursorHideCountsForScreen (ScreenPtr pScreen)
+deleteCursorHideCountsForScreen(ScreenPtr pScreen)
 {
-    CursorScreenPtr    cs = GetCursorScreen(pScreen);
+    CursorScreenPtr cs = GetCursorScreen(pScreen);
     CursorHideCountPtr pChc, pTmp;
 
     pChc = cs->pCursorHideCounts;
     while (pChc != NULL) {
-	pTmp = pChc->pNext;
-	FreeResource(pChc->resource, 0);
-	pChc = pTmp;
+        pTmp = pChc->pNext;
+        FreeResource(pChc->resource, 0);
+        pChc = pTmp;
     }
-    cs->pCursorHideCounts = NULL;   
+    cs->pCursorHideCounts = NULL;
 }
 
-int 
-ProcXFixesHideCursor (ClientPtr client) 
+int
+ProcXFixesHideCursor(ClientPtr client)
 {
     WindowPtr pWin;
     CursorHideCountPtr pChc;
+
     REQUEST(xXFixesHideCursorReq);
     int ret;
 
-    REQUEST_SIZE_MATCH (xXFixesHideCursorReq);
+    REQUEST_SIZE_MATCH(xXFixesHideCursorReq);
 
-    ret = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,
-			    client, DixGetAttrAccess);
+    ret = dixLookupResourceByType((pointer *) &pWin, stuff->window, RT_WINDOW,
+                                  client, DixGetAttrAccess);
     if (ret != Success) {
-	client->errorValue = stuff->window;
-	return ret;
+        client->errorValue = stuff->window;
+        return ret;
     }
 
     /* 
@@ -893,8 +870,8 @@ ProcXFixesHideCursor (ClientPtr client)
 
     pChc = findCursorHideCount(client, pWin->drawable.pScreen);
     if (pChc != NULL) {
-	pChc->hideCount++;
-	return Success;
+        pChc->hideCount++;
+        return Success;
     }
 
     /* 
@@ -902,50 +879,52 @@ ProcXFixesHideCursor (ClientPtr client)
      * for this screen.
      */
     ret = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,
-		   DixHideAccess);
+                   DixHideAccess);
     if (ret != Success)
-	return ret;
+        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]);
-	}
+        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
+SProcXFixesHideCursor(ClientPtr client)
 {
     REQUEST(xXFixesHideCursorReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesHideCursorReq);
+    REQUEST_SIZE_MATCH(xXFixesHideCursorReq);
     swapl(&stuff->window);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
-int 
-ProcXFixesShowCursor (ClientPtr client) 
+int
+ProcXFixesShowCursor(ClientPtr client)
 {
     WindowPtr pWin;
     CursorHideCountPtr pChc;
     int rc;
+
     REQUEST(xXFixesShowCursorReq);
 
-    REQUEST_SIZE_MATCH (xXFixesShowCursorReq);
+    REQUEST_SIZE_MATCH(xXFixesShowCursorReq);
 
-    rc = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,
-			   client, DixGetAttrAccess);
+    rc = dixLookupResourceByType((pointer *) &pWin, stuff->window, RT_WINDOW,
+                                 client, DixGetAttrAccess);
     if (rc != Success) {
-	client->errorValue = stuff->window;
-	return rc;
+        client->errorValue = stuff->window;
+        return rc;
     }
 
     /* 
@@ -954,61 +933,58 @@ ProcXFixesShowCursor (ClientPtr client)
      */
     pChc = findCursorHideCount(client, pWin->drawable.pScreen);
     if (pChc == NULL) {
-	return BadMatch;
+        return BadMatch;
     }
 
     rc = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,
-		  DixShowAccess);
+                  DixShowAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     pChc->hideCount--;
     if (pChc->hideCount <= 0) {
-	FreeResource(pChc->resource, 0);
+        FreeResource(pChc->resource, 0);
     }
 
     return Success;
 }
 
-int 
-SProcXFixesShowCursor (ClientPtr client) 
+int
+SProcXFixesShowCursor(ClientPtr client)
 {
     REQUEST(xXFixesShowCursorReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesShowCursorReq);
+    REQUEST_SIZE_MATCH(xXFixesShowCursorReq);
     swapl(&stuff->window);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 static int
-CursorFreeClient (pointer data, XID id)
+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;
-	}
+    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)
+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)
-    {
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
         if (IsMaster(dev) && IsPointerDevice(dev))
             CursorDisplayCursor(dev, pScreen, CursorCurrent[dev->id]);
     }
@@ -1017,18 +993,16 @@ CursorFreeHideCount (pointer data, XID id)
 }
 
 static int
-CursorFreeWindow (pointer data, XID id)
+CursorFreeWindow(pointer data, XID id)
 {
-    WindowPtr		pWindow = (WindowPtr) data;
-    CursorEventPtr	e, next;
+    WindowPtr pWindow = (WindowPtr) data;
+    CursorEventPtr e, next;
 
-    for (e = cursorEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
+    for (e = cursorEvents; e; e = next) {
+        next = e->next;
+        if (e->pWindow == pWindow) {
+            FreeResource(e->clientResource, 0);
+        }
     }
     return 1;
 }
@@ -1056,13 +1030,13 @@ barrier_get_direction(int x1, int y1, int x2, int y2)
 
     /* which way are we trying to go */
     if (x2 > x1)
-	direction |= BarrierPositiveX;
+        direction |= BarrierPositiveX;
     if (x2 < x1)
-	direction |= BarrierNegativeX;
+        direction |= BarrierNegativeX;
     if (y2 > y1)
-	direction |= BarrierPositiveY;
+        direction |= BarrierPositiveY;
     if (y2 < y1)
-	direction |= BarrierNegativeY;
+        direction |= BarrierNegativeY;
 
     return direction;
 }
@@ -1076,7 +1050,8 @@ barrier_get_direction(int x1, int y1, int x2, int y2)
  * otherwise.
  */
 BOOL
-barrier_is_blocking_direction(const struct PointerBarrier *barrier, int direction)
+barrier_is_blocking_direction(const struct PointerBarrier * barrier,
+                              int direction)
 {
     /* Barriers define which way is ok, not which way is blocking */
     return (barrier->directions & direction) != direction;
@@ -1096,9 +1071,8 @@ barrier_is_blocking_direction(const struct PointerBarrier *barrier, int directio
  * @return TRUE if the barrier intersects with the given vector
  */
 BOOL
-barrier_is_blocking(const struct PointerBarrier *barrier,
-		    int x1, int y1, int x2, int y2,
-		    double *distance)
+barrier_is_blocking(const struct PointerBarrier * barrier,
+                    int x1, int y1, int x2, int y2, double *distance)
 {
     BOOL rc = FALSE;
     float ua, ub, ud;
@@ -1107,48 +1081,49 @@ barrier_is_blocking(const struct PointerBarrier *barrier,
     /* Algorithm below doesn't handle edge cases well, hence the extra
      * checks. */
     if (barrier_is_vertical(barrier)) {
-	/* handle immediate barrier adjacency, moving away */
-	if (dir & BarrierPositiveX && x1 == barrier->x1)
-	    return FALSE;
-	if (dir & BarrierNegativeX && x1 == (barrier->x1 - 1))
-	    return FALSE;
-	/* startpoint adjacent to barrier, moving towards -> block */
-	if (x1 == barrier->x1 && y1 >= barrier->y1 && y1 <= barrier->y2) {
-	    *distance = 0;
-	    return TRUE;
-	}
-    } else {
-	/* handle immediate barrier adjacency, moving away */
-	if (dir & BarrierPositiveY && y1 == barrier->y1)
-	    return FALSE;
-	if (dir & BarrierNegativeY && y1 == (barrier->y1 - 1))
-	    return FALSE;
-	/* startpoint adjacent to barrier, moving towards -> block */
-	if (y1 == barrier->y1 && x1 >= barrier->x1 && x1 <= barrier->x2) {
-	    *distance = 0;
-	    return TRUE;
+        /* handle immediate barrier adjacency, moving away */
+        if (dir & BarrierPositiveX && x1 == barrier->x1)
+            return FALSE;
+        if (dir & BarrierNegativeX && x1 == (barrier->x1 - 1))
+            return FALSE;
+        /* startpoint adjacent to barrier, moving towards -> block */
+        if (x1 == barrier->x1 && y1 >= barrier->y1 && y1 <= barrier->y2) {
+            *distance = 0;
+            return TRUE;
+        }
+    }
+    else {
+        /* handle immediate barrier adjacency, moving away */
+        if (dir & BarrierPositiveY && y1 == barrier->y1)
+            return FALSE;
+        if (dir & BarrierNegativeY && y1 == (barrier->y1 - 1))
+            return FALSE;
+        /* startpoint adjacent to barrier, moving towards -> block */
+        if (y1 == barrier->y1 && x1 >= barrier->x1 && x1 <= barrier->x2) {
+            *distance = 0;
+            return TRUE;
         }
     }
 
     /* not an edge case, compute distance */
     ua = 0;
-    ud = (barrier->y2 - barrier->y1) * (x2 - x1) - (barrier->x2 - barrier->x1) * (y2 - y1);
+    ud = (barrier->y2 - barrier->y1) * (x2 - x1) - (barrier->x2 -
+                                                    barrier->x1) * (y2 - y1);
     if (ud != 0) {
-	ua = ((barrier->x2 - barrier->x1) * (y1 - barrier->y1) -
-	     (barrier->y2 - barrier->y1) * (x1 - barrier->x1)) / ud;
-	ub = ((x2 - x1) * (y1 - barrier->y1) -
-	     (y2 - y1) * (x1 - barrier->x1)) / ud;
-	if (ua < 0 || ua > 1 || ub < 0 || ub > 1)
-	    ua = 0;
+        ua = ((barrier->x2 - barrier->x1) * (y1 - barrier->y1) -
+              (barrier->y2 - barrier->y1) * (x1 - barrier->x1)) / ud;
+        ub = ((x2 - x1) * (y1 - barrier->y1) -
+              (y2 - y1) * (x1 - barrier->x1)) / ud;
+        if (ua < 0 || ua > 1 || ub < 0 || ub > 1)
+            ua = 0;
     }
 
-    if (ua > 0 && ua <= 1)
-    {
-	double ix = barrier->x1 + ua * (barrier->x2 - barrier->x1);
-	double iy = barrier->y1 + ua * (barrier->y2 - barrier->y1);
+    if (ua > 0 && ua <= 1) {
+        double ix = barrier->x1 + ua * (barrier->x2 - barrier->x1);
+        double iy = barrier->y1 + ua * (barrier->y2 - barrier->y1);
 
-	*distance = sqrt(pow(x1 - ix, 2) + pow(y1 - iy, 2));
-	rc = TRUE;
+        *distance = sqrt(pow(x1 - ix, 2) + pow(y1 - iy, 2));
+        rc = TRUE;
     }
 
     return rc;
@@ -1164,29 +1139,27 @@ barrier_is_blocking(const struct PointerBarrier *barrier,
  * @param y2 Y end coordinate of movement vector
  * @return The barrier nearest to the movement origin that blocks this movement.
  */
-static struct PointerBarrier*
+static struct PointerBarrier *
 barrier_find_nearest(CursorScreenPtr cs, int dir,
-		     int x1, int y1, int x2, int y2)
+                     int x1, int y1, int x2, int y2)
 {
     struct PointerBarrierClient *c;
     struct PointerBarrier *nearest = NULL;
-    double min_distance = INT_MAX; /* can't get higher than that in X anyway */
+    double min_distance = INT_MAX;      /* can't get higher than that in X anyway */
 
     xorg_list_for_each_entry(c, &cs->barriers, entry) {
-	struct PointerBarrier *b = &c->barrier;
-	double distance;
-
-	if (!barrier_is_blocking_direction(b, dir))
-	    continue;
-
-	if (barrier_is_blocking(b, x1, y1, x2, y2, &distance))
-	{
-	    if (min_distance > distance)
-	    {
-		min_distance = distance;
-		nearest = b;
-	    }
-	}
+        struct PointerBarrier *b = &c->barrier;
+        double distance;
+
+        if (!barrier_is_blocking_direction(b, dir))
+            continue;
+
+        if (barrier_is_blocking(b, x1, y1, x2, y2, &distance)) {
+            if (min_distance > distance) {
+                min_distance = distance;
+                nearest = b;
+            }
+        }
     }
 
     return nearest;
@@ -1201,117 +1174,120 @@ barrier_find_nearest(CursorScreenPtr cs, int dir,
  * @param[out] y The clamped x coordinate.
  */
 void
-barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, int *y)
+barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x,
+                         int *y)
 {
-    if (barrier_is_vertical(barrier))
-    {
-	if ((dir & BarrierNegativeX) & ~barrier->directions)
-	    *x = barrier->x1;
-	if ((dir & BarrierPositiveX) & ~barrier->directions)
-	    *x = barrier->x1 - 1;
+    if (barrier_is_vertical(barrier)) {
+        if ((dir & BarrierNegativeX) & ~barrier->directions)
+            *x = barrier->x1;
+        if ((dir & BarrierPositiveX) & ~barrier->directions)
+            *x = barrier->x1 - 1;
     }
-    if (barrier_is_horizontal(barrier))
-    {
-	if ((dir & BarrierNegativeY) & ~barrier->directions)
-	    *y = barrier->y1;
-	if ((dir & BarrierPositiveY) & ~barrier->directions)
-	    *y = barrier->y1 - 1;
+    if (barrier_is_horizontal(barrier)) {
+        if ((dir & BarrierNegativeY) & ~barrier->directions)
+            *y = barrier->y1;
+        if ((dir & BarrierPositiveY) & ~barrier->directions)
+            *y = barrier->y1 - 1;
     }
 }
 
 static void
-CursorConstrainCursorHarder(DeviceIntPtr dev, ScreenPtr screen, int mode, int *x, int *y)
+CursorConstrainCursorHarder(DeviceIntPtr dev, ScreenPtr screen, int mode,
+                            int *x, int *y)
 {
     CursorScreenPtr cs = GetCursorScreen(screen);
 
-    if (!xorg_list_is_empty(&cs->barriers) && !IsFloating(dev) && mode == Relative) {
-	int ox, oy;
-	int dir;
-	struct PointerBarrier *nearest = NULL;
-
-	/* where are we coming from */
-	miPointerGetPosition(dev, &ox, &oy);
-
-	/* How this works:
-	 * Given the origin and the movement vector, get the nearest barrier
-	 * to the origin that is blocking the movement.
-	 * Clamp to that barrier.
-	 * Then, check from the clamped intersection to the original
-	 * destination, again finding the nearest barrier and clamping.
-	 */
-	dir = barrier_get_direction(ox, oy, *x, *y);
-
-	nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y);
-	if (nearest) {
-	    barrier_clamp_to_barrier(nearest, dir, x, y);
-
-	    if (barrier_is_vertical(nearest)) {
-		dir &= ~(BarrierNegativeX | BarrierPositiveX);
-		ox = *x;
-	    } else if (barrier_is_horizontal(nearest)) {
-		dir &= ~(BarrierNegativeY | BarrierPositiveY);
-		oy = *y;
-	    }
-
-	    nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y);
-	    if (nearest) {
-		barrier_clamp_to_barrier(nearest, dir, x, y);
-	    }
-	}
+    if (!xorg_list_is_empty(&cs->barriers) && !IsFloating(dev) &&
+        mode == Relative) {
+        int ox, oy;
+        int dir;
+        struct PointerBarrier *nearest = NULL;
+
+        /* where are we coming from */
+        miPointerGetPosition(dev, &ox, &oy);
+
+        /* How this works:
+         * Given the origin and the movement vector, get the nearest barrier
+         * to the origin that is blocking the movement.
+         * Clamp to that barrier.
+         * Then, check from the clamped intersection to the original
+         * destination, again finding the nearest barrier and clamping.
+         */
+        dir = barrier_get_direction(ox, oy, *x, *y);
+
+        nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y);
+        if (nearest) {
+            barrier_clamp_to_barrier(nearest, dir, x, y);
+
+            if (barrier_is_vertical(nearest)) {
+                dir &= ~(BarrierNegativeX | BarrierPositiveX);
+                ox = *x;
+            }
+            else if (barrier_is_horizontal(nearest)) {
+                dir &= ~(BarrierNegativeY | BarrierPositiveY);
+                oy = *y;
+            }
+
+            nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y);
+            if (nearest) {
+                barrier_clamp_to_barrier(nearest, dir, x, y);
+            }
+        }
     }
 
     if (cs->ConstrainCursorHarder) {
-	screen->ConstrainCursorHarder = cs->ConstrainCursorHarder;
-	screen->ConstrainCursorHarder(dev, screen, mode, x, y);
-	screen->ConstrainCursorHarder = CursorConstrainCursorHarder;
+        screen->ConstrainCursorHarder = cs->ConstrainCursorHarder;
+        screen->ConstrainCursorHarder(dev, screen, mode, x, y);
+        screen->ConstrainCursorHarder = CursorConstrainCursorHarder;
     }
 }
 
 static struct PointerBarrierClient *
 CreatePointerBarrierClient(ScreenPtr screen, ClientPtr client,
-			   xXFixesCreatePointerBarrierReq *stuff)
+                           xXFixesCreatePointerBarrierReq * stuff)
 {
     CursorScreenPtr cs = GetCursorScreen(screen);
     struct PointerBarrierClient *ret = malloc(sizeof(*ret));
 
     if (ret) {
-	ret->screen = screen;
-	ret->barrier.x1 = min(stuff->x1, stuff->x2);
-	ret->barrier.x2 = max(stuff->x1, stuff->x2);
-	ret->barrier.y1 = min(stuff->y1, stuff->y2);
-	ret->barrier.y2 = max(stuff->y1, stuff->y2);
-	ret->barrier.directions = stuff->directions & 0x0f;
-	if (barrier_is_horizontal(&ret->barrier))
-	    ret->barrier.directions &= ~(BarrierPositiveX | BarrierNegativeX);
-	if (barrier_is_vertical(&ret->barrier))
-	    ret->barrier.directions &= ~(BarrierPositiveY | BarrierNegativeY);
-	xorg_list_add(&ret->entry, &cs->barriers);
+        ret->screen = screen;
+        ret->barrier.x1 = min(stuff->x1, stuff->x2);
+        ret->barrier.x2 = max(stuff->x1, stuff->x2);
+        ret->barrier.y1 = min(stuff->y1, stuff->y2);
+        ret->barrier.y2 = max(stuff->y1, stuff->y2);
+        ret->barrier.directions = stuff->directions & 0x0f;
+        if (barrier_is_horizontal(&ret->barrier))
+            ret->barrier.directions &= ~(BarrierPositiveX | BarrierNegativeX);
+        if (barrier_is_vertical(&ret->barrier))
+            ret->barrier.directions &= ~(BarrierPositiveY | BarrierNegativeY);
+        xorg_list_add(&ret->entry, &cs->barriers);
     }
 
     return ret;
 }
 
 int
-ProcXFixesCreatePointerBarrier (ClientPtr client)
+ProcXFixesCreatePointerBarrier(ClientPtr client)
 {
     int err;
     WindowPtr pWin;
     struct PointerBarrierClient *barrier;
     struct PointerBarrier b;
-    REQUEST (xXFixesCreatePointerBarrierReq);
+
+    REQUEST(xXFixesCreatePointerBarrierReq);
 
     REQUEST_SIZE_MATCH(xXFixesCreatePointerBarrierReq);
     LEGAL_NEW_RESOURCE(stuff->barrier, client);
 
     err = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess);
     if (err != Success) {
-	client->errorValue = stuff->window;
-	return err;
+        client->errorValue = stuff->window;
+        return err;
     }
 
     /* This sure does need fixing. */
     if (stuff->num_devices)
-	return BadImplementation;
+        return BadImplementation;
 
     b.x1 = stuff->x1;
     b.x2 = stuff->x2;
@@ -1319,24 +1295,24 @@ ProcXFixesCreatePointerBarrier (ClientPtr client)
     b.y2 = stuff->y2;
 
     if (!barrier_is_horizontal(&b) && !barrier_is_vertical(&b))
-	return BadValue;
+        return BadValue;
 
     /* no 0-sized barriers */
     if (barrier_is_horizontal(&b) && barrier_is_vertical(&b))
-	return BadValue;
+        return BadValue;
 
     if (!(barrier = CreatePointerBarrierClient(pWin->drawable.pScreen,
-					       client, stuff)))
-	return BadAlloc;
+                                               client, stuff)))
+        return BadAlloc;
 
     if (!AddResource(stuff->barrier, PointerBarrierType, &barrier->barrier))
-	return BadAlloc;
+        return BadAlloc;
 
     return Success;
 }
 
 int
-SProcXFixesCreatePointerBarrier (ClientPtr client)
+SProcXFixesCreatePointerBarrier(ClientPtr client)
 {
     REQUEST(xXFixesCreatePointerBarrierReq);
 
@@ -1349,7 +1325,7 @@ SProcXFixesCreatePointerBarrier (ClientPtr client)
     swaps(&stuff->x2);
     swaps(&stuff->y2);
     swapl(&stuff->directions);
-    return ProcXFixesVector[stuff->xfixesReqType](client);
+    return ProcXFixesVector[stuff->xfixesReqType] (client);
 }
 
 static int
@@ -1360,15 +1336,16 @@ CursorFreeBarrier(void *data, XID id)
     CursorScreenPtr cs;
 
     barrier = container_of(data, struct PointerBarrierClient, barrier);
+
     screen = barrier->screen;
     cs = GetCursorScreen(screen);
 
     /* find and unlink from the screen private */
     xorg_list_for_each_entry(b, &cs->barriers, entry) {
-	if (b == barrier) {
-	    xorg_list_del(&b->entry);
-	    break;
-	}
+        if (b == barrier) {
+            xorg_list_del(&b->entry);
+            break;
+        }
     }
 
     free(barrier);
@@ -1376,20 +1353,20 @@ CursorFreeBarrier(void *data, XID id)
 }
 
 int
-ProcXFixesDestroyPointerBarrier (ClientPtr client)
+ProcXFixesDestroyPointerBarrier(ClientPtr client)
 {
     int err;
     void *barrier;
-    REQUEST (xXFixesDestroyPointerBarrierReq);
+
+    REQUEST(xXFixesDestroyPointerBarrierReq);
 
     REQUEST_SIZE_MATCH(xXFixesDestroyPointerBarrierReq);
 
-    err = dixLookupResourceByType((void **)&barrier, stuff->barrier,
-				  PointerBarrierType, client,
-				  DixDestroyAccess);
+    err = dixLookupResourceByType((void **) &barrier, stuff->barrier,
+                                  PointerBarrierType, client, DixDestroyAccess);
     if (err != Success) {
-	client->errorValue = stuff->barrier;
-	return err;
+        client->errorValue = stuff->barrier;
+        return err;
     }
 
     FreeResource(stuff->barrier, RT_NONE);
@@ -1397,52 +1374,50 @@ ProcXFixesDestroyPointerBarrier (ClientPtr client)
 }
 
 int
-SProcXFixesDestroyPointerBarrier (ClientPtr client)
+SProcXFixesDestroyPointerBarrier(ClientPtr client)
 {
     REQUEST(xXFixesDestroyPointerBarrierReq);
 
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesDestroyPointerBarrierReq);
     swapl(&stuff->barrier);
-    return ProcXFixesVector[stuff->xfixesReqType](client);
+    return ProcXFixesVector[stuff->xfixesReqType] (client);
 }
 
 Bool
-XFixesCursorInit (void)
+XFixesCursorInit(void)
 {
-    int	i;
+    int i;
 
     if (party_like_its_1989)
-	CursorVisible = EnableCursor;
-    
-    if (!dixRegisterPrivateKey(&CursorScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        CursorVisible = EnableCursor;
 
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	ScreenPtr	pScreen = screenInfo.screens[i];
-	CursorScreenPtr	cs;
-
-	cs = (CursorScreenPtr) calloc(1, sizeof (CursorScreenRec));
-	if (!cs)
-	    return FALSE;
-	xorg_list_init(&cs->barriers);
-	Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);
-	Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);
-	Wrap (cs, pScreen, ConstrainCursorHarder, CursorConstrainCursorHarder);
-	cs->pCursorHideCounts = NULL;
-	SetCursorScreen (pScreen, cs);
+    if (!dixRegisterPrivateKey(&CursorScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
+        return FALSE;
+
+    for (i = 0; i < screenInfo.numScreens; i++) {
+        ScreenPtr pScreen = screenInfo.screens[i];
+        CursorScreenPtr cs;
+
+        cs = (CursorScreenPtr) calloc(1, sizeof(CursorScreenRec));
+        if (!cs)
+            return FALSE;
+        xorg_list_init(&cs->barriers);
+        Wrap(cs, pScreen, CloseScreen, CursorCloseScreen);
+        Wrap(cs, pScreen, DisplayCursor, CursorDisplayCursor);
+        Wrap(cs, pScreen, ConstrainCursorHarder, CursorConstrainCursorHarder);
+        cs->pCursorHideCounts = NULL;
+        SetCursorScreen(pScreen, cs);
     }
     CursorClientType = CreateNewResourceType(CursorFreeClient,
-					     "XFixesCursorClient");
+                                             "XFixesCursorClient");
     CursorHideCountType = CreateNewResourceType(CursorFreeHideCount,
-						"XFixesCursorHideCount");
+                                                "XFixesCursorHideCount");
     CursorWindowType = CreateNewResourceType(CursorFreeWindow,
-					     "XFixesCursorWindow");
+                                             "XFixesCursorWindow");
     PointerBarrierType = CreateNewResourceType(CursorFreeBarrier,
-					      "XFixesPointerBarrier");
+                                               "XFixesPointerBarrier");
 
     return CursorClientType && CursorHideCountType && CursorWindowType &&
-	   PointerBarrierType;
+        PointerBarrierType;
 }
-
diff --git a/xfixes/region.c b/xfixes/region.c
index 4c2263702..624109de1 100644
--- a/xfixes/region.c
+++ b/xfixes/region.c
@@ -28,6 +28,7 @@
 #include "scrnintstr.h"
 #include <picturestr.h>
 extern int RenderErrBase;
+
 #include <regionstr.h>
 #include <gcstruct.h>
 #include <window.h>
@@ -35,31 +36,31 @@ extern int RenderErrBase;
 RESTYPE RegionResType;
 
 static int
-RegionResFree (pointer data, XID id)
+RegionResFree(pointer data, XID id)
 {
-    RegionPtr    pRegion = (RegionPtr) data;
+    RegionPtr pRegion = (RegionPtr) data;
 
     RegionDestroy(pRegion);
     return Success;
 }
 
 RegionPtr
-XFixesRegionCopy (RegionPtr pRegion)
+XFixesRegionCopy(RegionPtr pRegion)
 {
-    RegionPtr   pNew = RegionCreate(RegionExtents(pRegion),
-				      RegionNumRects(pRegion));
+    RegionPtr pNew = RegionCreate(RegionExtents(pRegion),
+                                  RegionNumRects(pRegion));
+
     if (!pNew)
-	return 0;
-    if (!RegionCopy(pNew, pRegion))
-    {
-	RegionDestroy(pNew);
-	return 0;
+        return 0;
+    if (!RegionCopy(pNew, pRegion)) {
+        RegionDestroy(pNew);
+        return 0;
     }
     return pNew;
 }
 
 Bool
-XFixesRegionInit (void)
+XFixesRegionInit(void)
 {
     RegionResType = CreateNewResourceType(RegionResFree, "XFixesRegion");
 
@@ -67,34 +68,35 @@ XFixesRegionInit (void)
 }
 
 int
-ProcXFixesCreateRegion (ClientPtr client)
+ProcXFixesCreateRegion(ClientPtr client)
 {
-    int		things;
-    RegionPtr	pRegion;
-    REQUEST (xXFixesCreateRegionReq);
-    
+    int things;
+    RegionPtr pRegion;
+
+    REQUEST(xXFixesCreateRegionReq);
+
     REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq);
-    LEGAL_NEW_RESOURCE (stuff->region, client);
-    
-    things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq);
+    LEGAL_NEW_RESOURCE(stuff->region, client);
+
+    things = (client->req_len << 2) - sizeof(xXFixesCreateRegionReq);
     if (things & 4)
-	return BadLength;
+        return BadLength;
     things >>= 3;
 
     pRegion = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED);
     if (!pRegion)
-	return BadAlloc;
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
-	return BadAlloc;
-    
+        return BadAlloc;
+    if (!AddResource(stuff->region, RegionResType, (pointer) pRegion))
+        return BadAlloc;
+
     return Success;
 }
 
 int
-SProcXFixesCreateRegion (ClientPtr client)
+SProcXFixesCreateRegion(ClientPtr client)
 {
     REQUEST(xXFixesCreateRegionReq);
-    
+
     swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq);
     swapl(&stuff->region);
@@ -103,221 +105,221 @@ SProcXFixesCreateRegion (ClientPtr client)
 }
 
 int
-ProcXFixesCreateRegionFromBitmap (ClientPtr client)
+ProcXFixesCreateRegionFromBitmap(ClientPtr client)
 {
-    RegionPtr	pRegion;
-    PixmapPtr	pPixmap;
+    RegionPtr pRegion;
+    PixmapPtr pPixmap;
     int rc;
-    REQUEST (xXFixesCreateRegionFromBitmapReq);
 
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromBitmapReq);
-    LEGAL_NEW_RESOURCE (stuff->region, client);
+    REQUEST(xXFixesCreateRegionFromBitmapReq);
 
-    rc = dixLookupResourceByType((pointer *)&pPixmap, stuff->bitmap, RT_PIXMAP,
-			   client, DixReadAccess);
-    if (rc != Success)
-    {
-	client->errorValue = stuff->bitmap;
-	return rc;
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromBitmapReq);
+    LEGAL_NEW_RESOURCE(stuff->region, client);
+
+    rc = dixLookupResourceByType((pointer *) &pPixmap, stuff->bitmap, RT_PIXMAP,
+                                 client, DixReadAccess);
+    if (rc != Success) {
+        client->errorValue = stuff->bitmap;
+        return rc;
     }
     if (pPixmap->drawable.depth != 1)
-	return BadMatch;
+        return BadMatch;
 
     pRegion = BitmapToRegion(pPixmap->drawable.pScreen, pPixmap);
 
     if (!pRegion)
-	return BadAlloc;
-    
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
-	return BadAlloc;
-    
+        return BadAlloc;
+
+    if (!AddResource(stuff->region, RegionResType, (pointer) pRegion))
+        return BadAlloc;
+
     return Success;
 }
 
 int
-SProcXFixesCreateRegionFromBitmap (ClientPtr client)
+SProcXFixesCreateRegionFromBitmap(ClientPtr client)
 {
-    REQUEST (xXFixesCreateRegionFromBitmapReq);
+    REQUEST(xXFixesCreateRegionFromBitmapReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromBitmapReq);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromBitmapReq);
     swapl(&stuff->region);
     swapl(&stuff->bitmap);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 int
-ProcXFixesCreateRegionFromWindow (ClientPtr client)
+ProcXFixesCreateRegionFromWindow(ClientPtr client)
 {
-    RegionPtr	pRegion;
-    Bool	copy = TRUE;
-    WindowPtr	pWin;
+    RegionPtr pRegion;
+    Bool copy = TRUE;
+    WindowPtr pWin;
     int rc;
-    REQUEST (xXFixesCreateRegionFromWindowReq);
-    
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq);
-    LEGAL_NEW_RESOURCE (stuff->region, client);
-    rc = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,
-			   client, DixGetAttrAccess);
-    if (rc != Success)
-    {
-	client->errorValue = stuff->window;
-	return rc;
+
+    REQUEST(xXFixesCreateRegionFromWindowReq);
+
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromWindowReq);
+    LEGAL_NEW_RESOURCE(stuff->region, client);
+    rc = dixLookupResourceByType((pointer *) &pWin, stuff->window, RT_WINDOW,
+                                 client, DixGetAttrAccess);
+    if (rc != Success) {
+        client->errorValue = stuff->window;
+        return rc;
     }
     switch (stuff->kind) {
     case WindowRegionBounding:
-	pRegion = wBoundingShape(pWin);
-	if (!pRegion)
-	{
-	    pRegion = CreateBoundingShape (pWin);
-	    copy = FALSE;
-	}
-	break;
+        pRegion = wBoundingShape(pWin);
+        if (!pRegion) {
+            pRegion = CreateBoundingShape(pWin);
+            copy = FALSE;
+        }
+        break;
     case WindowRegionClip:
-	pRegion = wClipShape(pWin);
-	if (!pRegion)
-	{
-	    pRegion = CreateClipShape (pWin);
-	    copy = FALSE;
-	}
-	break;
+        pRegion = wClipShape(pWin);
+        if (!pRegion) {
+            pRegion = CreateClipShape(pWin);
+            copy = FALSE;
+        }
+        break;
     default:
-	client->errorValue = stuff->kind;
-	return BadValue;
+        client->errorValue = stuff->kind;
+        return BadValue;
     }
     if (copy && pRegion)
-	pRegion = XFixesRegionCopy (pRegion);
+        pRegion = XFixesRegionCopy(pRegion);
     if (!pRegion)
-	return BadAlloc;
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
-	return BadAlloc;
-    
+        return BadAlloc;
+    if (!AddResource(stuff->region, RegionResType, (pointer) pRegion))
+        return BadAlloc;
+
     return Success;
 }
 
 int
-SProcXFixesCreateRegionFromWindow (ClientPtr client)
+SProcXFixesCreateRegionFromWindow(ClientPtr client)
 {
-    REQUEST (xXFixesCreateRegionFromWindowReq);
+    REQUEST(xXFixesCreateRegionFromWindowReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromWindowReq);
     swapl(&stuff->region);
     swapl(&stuff->window);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 int
-ProcXFixesCreateRegionFromGC (ClientPtr client)
+ProcXFixesCreateRegionFromGC(ClientPtr client)
 {
-    RegionPtr	pRegion, pClip;
-    GCPtr	pGC;
-    int 	rc;
-    REQUEST (xXFixesCreateRegionFromGCReq);
+    RegionPtr pRegion, pClip;
+    GCPtr pGC;
+    int rc;
+
+    REQUEST(xXFixesCreateRegionFromGCReq);
 
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq);
-    LEGAL_NEW_RESOURCE (stuff->region, client);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromGCReq);
+    LEGAL_NEW_RESOURCE(stuff->region, client);
 
     rc = dixLookupGC(&pGC, stuff->gc, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
-    
+        return rc;
+
     switch (pGC->clientClipType) {
     case CT_PIXMAP:
-	pRegion = BitmapToRegion(pGC->pScreen, (PixmapPtr) pGC->clientClip);
-	if (!pRegion)
-	    return BadAlloc;
-	break;
+        pRegion = BitmapToRegion(pGC->pScreen, (PixmapPtr) pGC->clientClip);
+        if (!pRegion)
+            return BadAlloc;
+        break;
     case CT_REGION:
-	pClip = (RegionPtr) pGC->clientClip;
-	pRegion = XFixesRegionCopy (pClip);
-	if (!pRegion)
-	    return BadAlloc;
-	break;
+        pClip = (RegionPtr) pGC->clientClip;
+        pRegion = XFixesRegionCopy(pClip);
+        if (!pRegion)
+            return BadAlloc;
+        break;
     default:
-	return BadImplementation;   /* assume sane server bits */
+        return BadImplementation;       /* assume sane server bits */
     }
-    
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
-	return BadAlloc;
-    
+
+    if (!AddResource(stuff->region, RegionResType, (pointer) pRegion))
+        return BadAlloc;
+
     return Success;
 }
 
 int
-SProcXFixesCreateRegionFromGC (ClientPtr client)
+SProcXFixesCreateRegionFromGC(ClientPtr client)
 {
-    REQUEST (xXFixesCreateRegionFromGCReq);
+    REQUEST(xXFixesCreateRegionFromGCReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromGCReq);
     swapl(&stuff->region);
     swapl(&stuff->gc);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 int
-ProcXFixesCreateRegionFromPicture (ClientPtr client)
+ProcXFixesCreateRegionFromPicture(ClientPtr client)
 {
-    RegionPtr	pRegion;
-    PicturePtr	pPicture;
-    REQUEST (xXFixesCreateRegionFromPictureReq);
+    RegionPtr pRegion;
+    PicturePtr pPicture;
 
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
-    LEGAL_NEW_RESOURCE (stuff->region, client);
+    REQUEST(xXFixesCreateRegionFromPictureReq);
+
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromPictureReq);
+    LEGAL_NEW_RESOURCE(stuff->region, client);
 
     VERIFY_PICTURE(pPicture, stuff->picture, client, DixGetAttrAccess);
-    
+
     switch (pPicture->clientClipType) {
     case CT_PIXMAP:
-	pRegion = BitmapToRegion(pPicture->pDrawable->pScreen,
-				   (PixmapPtr) pPicture->clientClip);
-	if (!pRegion)
-	    return BadAlloc;
-	break;
+        pRegion = BitmapToRegion(pPicture->pDrawable->pScreen,
+                                 (PixmapPtr) pPicture->clientClip);
+        if (!pRegion)
+            return BadAlloc;
+        break;
     case CT_REGION:
-	pRegion = XFixesRegionCopy ((RegionPtr) pPicture->clientClip);
-	if (!pRegion)
-	    return BadAlloc;
-	break;
+        pRegion = XFixesRegionCopy((RegionPtr) pPicture->clientClip);
+        if (!pRegion)
+            return BadAlloc;
+        break;
     default:
-	return BadImplementation;   /* assume sane server bits */
+        return BadImplementation;       /* assume sane server bits */
     }
-    
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
-	return BadAlloc;
-    
+
+    if (!AddResource(stuff->region, RegionResType, (pointer) pRegion))
+        return BadAlloc;
+
     return Success;
 }
 
 int
-SProcXFixesCreateRegionFromPicture (ClientPtr client)
+SProcXFixesCreateRegionFromPicture(ClientPtr client)
 {
-    REQUEST (xXFixesCreateRegionFromPictureReq);
+    REQUEST(xXFixesCreateRegionFromPictureReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromPictureReq);
     swapl(&stuff->region);
     swapl(&stuff->picture);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 int
-ProcXFixesDestroyRegion (ClientPtr client)
+ProcXFixesDestroyRegion(ClientPtr client)
 {
-    REQUEST (xXFixesDestroyRegionReq);
-    RegionPtr	pRegion;
+    REQUEST(xXFixesDestroyRegionReq);
+    RegionPtr pRegion;
 
     REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);
     VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
-    FreeResource (stuff->region, RT_NONE);
+    FreeResource(stuff->region, RT_NONE);
     return Success;
 }
 
 int
-SProcXFixesDestroyRegion (ClientPtr client)
+SProcXFixesDestroyRegion(ClientPtr client)
 {
-    REQUEST (xXFixesDestroyRegionReq);
+    REQUEST(xXFixesDestroyRegionReq);
 
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);
@@ -326,36 +328,36 @@ SProcXFixesDestroyRegion (ClientPtr client)
 }
 
 int
-ProcXFixesSetRegion (ClientPtr client)
+ProcXFixesSetRegion(ClientPtr client)
 {
-    int		things;
-    RegionPtr	pRegion, pNew;
-    REQUEST (xXFixesSetRegionReq);
+    int things;
+    RegionPtr pRegion, pNew;
+
+    REQUEST(xXFixesSetRegionReq);
 
     REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
     VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
-    
-    things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq);
+
+    things = (client->req_len << 2) - sizeof(xXFixesCreateRegionReq);
     if (things & 4)
-	return BadLength;
+        return BadLength;
     things >>= 3;
 
     pNew = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED);
     if (!pNew)
-	return BadAlloc;
-    if (!RegionCopy(pRegion, pNew))
-    {
-	RegionDestroy(pNew);
-	return BadAlloc;
+        return BadAlloc;
+    if (!RegionCopy(pRegion, pNew)) {
+        RegionDestroy(pNew);
+        return BadAlloc;
     }
     RegionDestroy(pNew);
     return Success;
 }
 
 int
-SProcXFixesSetRegion (ClientPtr client)
+SProcXFixesSetRegion(ClientPtr client)
 {
-    REQUEST (xXFixesSetRegionReq);
+    REQUEST(xXFixesSetRegionReq);
 
     swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
@@ -365,24 +367,25 @@ SProcXFixesSetRegion (ClientPtr client)
 }
 
 int
-ProcXFixesCopyRegion (ClientPtr client)
+ProcXFixesCopyRegion(ClientPtr client)
 {
-    RegionPtr	pSource, pDestination;
-    REQUEST (xXFixesCopyRegionReq);
-    
+    RegionPtr pSource, pDestination;
+
+    REQUEST(xXFixesCopyRegionReq);
+
     VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
     VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
-    
+
     if (!RegionCopy(pDestination, pSource))
-	return BadAlloc;
+        return BadAlloc;
 
     return Success;
 }
 
 int
-SProcXFixesCopyRegion (ClientPtr client)
+SProcXFixesCopyRegion(ClientPtr client)
 {
-    REQUEST (xXFixesCopyRegionReq);
+    REQUEST(xXFixesCopyRegionReq);
 
     swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesCopyRegionReq);
@@ -392,41 +395,42 @@ SProcXFixesCopyRegion (ClientPtr client)
 }
 
 int
-ProcXFixesCombineRegion (ClientPtr client)
+ProcXFixesCombineRegion(ClientPtr client)
 {
-    RegionPtr	pSource1, pSource2, pDestination;
-    REQUEST (xXFixesCombineRegionReq);
+    RegionPtr pSource1, pSource2, pDestination;
 
-    REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);
+    REQUEST(xXFixesCombineRegionReq);
+
+    REQUEST_SIZE_MATCH(xXFixesCombineRegionReq);
     VERIFY_REGION(pSource1, stuff->source1, client, DixReadAccess);
     VERIFY_REGION(pSource2, stuff->source2, client, DixReadAccess);
     VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
-    
+
     switch (stuff->xfixesReqType) {
     case X_XFixesUnionRegion:
-	if (!RegionUnion(pDestination, pSource1, pSource2))
-	    return BadAlloc;
-	break;
+        if (!RegionUnion(pDestination, pSource1, pSource2))
+            return BadAlloc;
+        break;
     case X_XFixesIntersectRegion:
-	if (!RegionIntersect(pDestination, pSource1, pSource2))
-	    return BadAlloc;
-	break;
+        if (!RegionIntersect(pDestination, pSource1, pSource2))
+            return BadAlloc;
+        break;
     case X_XFixesSubtractRegion:
-	if (!RegionSubtract(pDestination, pSource1, pSource2))
-	    return BadAlloc;
-	break;
+        if (!RegionSubtract(pDestination, pSource1, pSource2))
+            return BadAlloc;
+        break;
     }
-    
+
     return Success;
 }
 
 int
-SProcXFixesCombineRegion (ClientPtr client)
+SProcXFixesCombineRegion(ClientPtr client)
 {
-    REQUEST (xXFixesCombineRegionReq);
+    REQUEST(xXFixesCombineRegionReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);
+    REQUEST_SIZE_MATCH(xXFixesCombineRegionReq);
     swapl(&stuff->source1);
     swapl(&stuff->source2);
     swapl(&stuff->destination);
@@ -434,10 +438,11 @@ SProcXFixesCombineRegion (ClientPtr client)
 }
 
 int
-ProcXFixesInvertRegion (ClientPtr client)
+ProcXFixesInvertRegion(ClientPtr client)
 {
-    RegionPtr	pSource, pDestination;
-    BoxRec	bounds;
+    RegionPtr pSource, pDestination;
+    BoxRec bounds;
+
     REQUEST(xXFixesInvertRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesInvertRegionReq);
@@ -448,23 +453,23 @@ ProcXFixesInvertRegion (ClientPtr client)
     bounds.x1 = stuff->x;
     bounds.y1 = stuff->y;
     if ((int) stuff->x + (int) stuff->width > MAXSHORT)
-	bounds.x2 = MAXSHORT;
+        bounds.x2 = MAXSHORT;
     else
-	bounds.x2 = stuff->x + stuff->width;
-    
+        bounds.x2 = stuff->x + stuff->width;
+
     if ((int) stuff->y + (int) stuff->height > MAXSHORT)
-	bounds.y2 = MAXSHORT;
+        bounds.y2 = MAXSHORT;
     else
-	bounds.y2 = stuff->y + stuff->height;
+        bounds.y2 = stuff->y + stuff->height;
 
     if (!RegionInverse(pDestination, pSource, &bounds))
-	return BadAlloc;
+        return BadAlloc;
 
     return Success;
 }
 
 int
-SProcXFixesInvertRegion (ClientPtr client)
+SProcXFixesInvertRegion(ClientPtr client)
 {
     REQUEST(xXFixesInvertRegionReq);
 
@@ -480,9 +485,10 @@ SProcXFixesInvertRegion (ClientPtr client)
 }
 
 int
-ProcXFixesTranslateRegion (ClientPtr client)
+ProcXFixesTranslateRegion(ClientPtr client)
 {
-    RegionPtr	pRegion;
+    RegionPtr pRegion;
+
     REQUEST(xXFixesTranslateRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
@@ -493,7 +499,7 @@ ProcXFixesTranslateRegion (ClientPtr client)
 }
 
 int
-SProcXFixesTranslateRegion (ClientPtr client)
+SProcXFixesTranslateRegion(ClientPtr client)
 {
     REQUEST(xXFixesTranslateRegionReq);
 
@@ -506,9 +512,10 @@ SProcXFixesTranslateRegion (ClientPtr client)
 }
 
 int
-ProcXFixesRegionExtents (ClientPtr client)
+ProcXFixesRegionExtents(ClientPtr client)
 {
-    RegionPtr	pSource, pDestination;
+    RegionPtr pSource, pDestination;
+
     REQUEST(xXFixesRegionExtentsReq);
 
     REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
@@ -521,10 +528,10 @@ ProcXFixesRegionExtents (ClientPtr client)
 }
 
 int
-SProcXFixesRegionExtents (ClientPtr client)
+SProcXFixesRegionExtents(ClientPtr client)
 {
     REQUEST(xXFixesRegionExtentsReq);
-    
+
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
     swapl(&stuff->source);
@@ -533,27 +540,27 @@ SProcXFixesRegionExtents (ClientPtr client)
 }
 
 int
-ProcXFixesFetchRegion (ClientPtr client)
+ProcXFixesFetchRegion(ClientPtr client)
 {
-    RegionPtr		    pRegion;
+    RegionPtr pRegion;
     xXFixesFetchRegionReply *reply;
-    xRectangle		    *pRect;
-    BoxPtr		    pExtent;
-    BoxPtr		    pBox;
-    int			    i, nBox;
+    xRectangle *pRect;
+    BoxPtr pExtent;
+    BoxPtr pBox;
+    int i, nBox;
+
     REQUEST(xXFixesFetchRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesFetchRegionReq);
     VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);
 
     pExtent = RegionExtents(pRegion);
-    pBox = RegionRects (pRegion);
-    nBox = RegionNumRects (pRegion);
-    
-    reply = malloc(sizeof (xXFixesFetchRegionReply) +
-		    nBox * sizeof (xRectangle));
+    pBox = RegionRects(pRegion);
+    nBox = RegionNumRects(pRegion);
+
+    reply = malloc(sizeof(xXFixesFetchRegionReply) + nBox * sizeof(xRectangle));
     if (!reply)
-	return BadAlloc;
+        return BadAlloc;
     reply->type = X_Reply;
     reply->sequenceNumber = client->sequence;
     reply->length = nBox << 1;
@@ -563,31 +570,29 @@ ProcXFixesFetchRegion (ClientPtr client)
     reply->height = pExtent->y2 - pExtent->y1;
 
     pRect = (xRectangle *) (reply + 1);
-    for (i = 0; i < nBox; i++)
-    {
-	pRect[i].x = pBox[i].x1;
-	pRect[i].y = pBox[i].y1;
-	pRect[i].width = pBox[i].x2 - pBox[i].x1;
-	pRect[i].height = pBox[i].y2 - pBox[i].y1;
+    for (i = 0; i < nBox; i++) {
+        pRect[i].x = pBox[i].x1;
+        pRect[i].y = pBox[i].y1;
+        pRect[i].width = pBox[i].x2 - pBox[i].x1;
+        pRect[i].height = pBox[i].y2 - pBox[i].y1;
     }
-    if (client->swapped)
-    {
-	swaps(&reply->sequenceNumber);
-	swapl(&reply->length);
-	swaps(&reply->x);
-	swaps(&reply->y);
-	swaps(&reply->width);
-	swaps(&reply->height);
-	SwapShorts ((INT16 *) pRect, nBox * 4);
+    if (client->swapped) {
+        swaps(&reply->sequenceNumber);
+        swapl(&reply->length);
+        swaps(&reply->x);
+        swaps(&reply->y);
+        swaps(&reply->width);
+        swaps(&reply->height);
+        SwapShorts((INT16 *) pRect, nBox * 4);
     }
-    (void) WriteToClient(client, sizeof (xXFixesFetchRegionReply) +
-			 nBox * sizeof (xRectangle), (char *) reply);
+    (void) WriteToClient(client, sizeof(xXFixesFetchRegionReply) +
+                         nBox * sizeof(xRectangle), (char *) reply);
     free(reply);
     return Success;
 }
 
 int
-SProcXFixesFetchRegion (ClientPtr client)
+SProcXFixesFetchRegion(ClientPtr client)
 {
     REQUEST(xXFixesFetchRegionReq);
 
@@ -598,38 +603,39 @@ SProcXFixesFetchRegion (ClientPtr client)
 }
 
 int
-ProcXFixesSetGCClipRegion (ClientPtr client)
+ProcXFixesSetGCClipRegion(ClientPtr client)
 {
-    GCPtr	pGC;
-    RegionPtr	pRegion;
-    ChangeGCVal	vals[2];
-    int		rc;
+    GCPtr pGC;
+    RegionPtr pRegion;
+    ChangeGCVal vals[2];
+    int rc;
+
     REQUEST(xXFixesSetGCClipRegionReq);
     REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
 
     rc = dixLookupGC(&pGC, stuff->gc, client, DixSetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    VERIFY_REGION_OR_NONE (pRegion, stuff->region, client, DixReadAccess);
+    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
 
-    if (pRegion)
-    {
-	pRegion = XFixesRegionCopy (pRegion);
-	if (!pRegion)
-	    return BadAlloc;
+    if (pRegion) {
+        pRegion = XFixesRegionCopy(pRegion);
+        if (!pRegion)
+            return BadAlloc;
     }
-    
+
     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);
+    ChangeGC(NullClient, pGC, GCClipXOrigin | GCClipYOrigin, vals);
+    (*pGC->funcs->ChangeClip) (pGC, pRegion ? CT_REGION : CT_NONE,
+                               (pointer) pRegion, 0);
 
     return Success;
 }
 
 int
-SProcXFixesSetGCClipRegion (ClientPtr client)
+SProcXFixesSetGCClipRegion(ClientPtr client)
 {
     REQUEST(xXFixesSetGCClipRegionReq);
 
@@ -642,87 +648,84 @@ SProcXFixesSetGCClipRegion (ClientPtr client)
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
-typedef	RegionPtr (*CreateDftPtr)(WindowPtr pWin);
+typedef RegionPtr (*CreateDftPtr) (WindowPtr pWin);
 
 int
-ProcXFixesSetWindowShapeRegion (ClientPtr client)
+ProcXFixesSetWindowShapeRegion(ClientPtr client)
 {
-    WindowPtr	    pWin;
-    RegionPtr	    pRegion;
-    RegionPtr	    *pDestRegion;
+    WindowPtr pWin;
+    RegionPtr pRegion;
+    RegionPtr *pDestRegion;
     int rc;
+
     REQUEST(xXFixesSetWindowShapeRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq);
-    rc = dixLookupResourceByType((pointer *)&pWin, stuff->dest, RT_WINDOW,
-			   client, DixSetAttrAccess);
-    if (rc != Success)
-    {
-	client->errorValue = stuff->dest;
-	return rc;
+    rc = dixLookupResourceByType((pointer *) &pWin, stuff->dest, RT_WINDOW,
+                                 client, DixSetAttrAccess);
+    if (rc != Success) {
+        client->errorValue = stuff->dest;
+        return rc;
     }
     VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixWriteAccess);
     switch (stuff->destKind) {
     case ShapeBounding:
     case ShapeClip:
     case ShapeInput:
-	break;
+        break;
     default:
-	client->errorValue = stuff->destKind;
-	return BadValue;
+        client->errorValue = stuff->destKind;
+        return BadValue;
     }
-    if (pRegion)
-    {
-	pRegion = XFixesRegionCopy (pRegion);
-	if (!pRegion)
-	    return BadAlloc;
-	if (!pWin->optional)
-	    MakeWindowOptional (pWin);
-	switch (stuff->destKind) {
-	default:
-	case ShapeBounding:
-	    pDestRegion = &pWin->optional->boundingShape;
-	    break;
-	case ShapeClip:
-	    pDestRegion = &pWin->optional->clipShape;
-	    break;
-	case ShapeInput:
-	    pDestRegion = &pWin->optional->inputShape;
-	    break;
-	}
-	if (stuff->xOff || stuff->yOff)
-	    RegionTranslate(pRegion, stuff->xOff, stuff->yOff);
+    if (pRegion) {
+        pRegion = XFixesRegionCopy(pRegion);
+        if (!pRegion)
+            return BadAlloc;
+        if (!pWin->optional)
+            MakeWindowOptional(pWin);
+        switch (stuff->destKind) {
+        default:
+        case ShapeBounding:
+            pDestRegion = &pWin->optional->boundingShape;
+            break;
+        case ShapeClip:
+            pDestRegion = &pWin->optional->clipShape;
+            break;
+        case ShapeInput:
+            pDestRegion = &pWin->optional->inputShape;
+            break;
+        }
+        if (stuff->xOff || stuff->yOff)
+            RegionTranslate(pRegion, stuff->xOff, stuff->yOff);
     }
-    else
-    {
-	if (pWin->optional)
-	{
-	    switch (stuff->destKind) {
-	    default:
-	    case ShapeBounding:
-		pDestRegion = &pWin->optional->boundingShape;
-		break;
-	    case ShapeClip:
-		pDestRegion = &pWin->optional->clipShape;
-		break;
-	    case ShapeInput:
-		pDestRegion = &pWin->optional->inputShape;
-		break;
-	    }
-	}
-	else
-	    pDestRegion = &pRegion; /* a NULL region pointer */
+    else {
+        if (pWin->optional) {
+            switch (stuff->destKind) {
+            default:
+            case ShapeBounding:
+                pDestRegion = &pWin->optional->boundingShape;
+                break;
+            case ShapeClip:
+                pDestRegion = &pWin->optional->clipShape;
+                break;
+            case ShapeInput:
+                pDestRegion = &pWin->optional->inputShape;
+                break;
+            }
+        }
+        else
+            pDestRegion = &pRegion;     /* a NULL region pointer */
     }
     if (*pDestRegion)
-	RegionDestroy(*pDestRegion);
+        RegionDestroy(*pDestRegion);
     *pDestRegion = pRegion;
     (*pWin->drawable.pScreen->SetShape) (pWin, stuff->destKind);
-    SendShapeNotify (pWin, stuff->destKind);
+    SendShapeNotify(pWin, stuff->destKind);
     return Success;
 }
 
 int
-SProcXFixesSetWindowShapeRegion (ClientPtr client)
+SProcXFixesSetWindowShapeRegion(ClientPtr client)
 {
     REQUEST(xXFixesSetWindowShapeRegionReq);
 
@@ -736,27 +739,28 @@ SProcXFixesSetWindowShapeRegion (ClientPtr client)
 }
 
 int
-ProcXFixesSetPictureClipRegion (ClientPtr client)
+ProcXFixesSetPictureClipRegion(ClientPtr client)
 {
-    PicturePtr		pPicture;
-    RegionPtr		pRegion;
+    PicturePtr pPicture;
+    RegionPtr pRegion;
+
     REQUEST(xXFixesSetPictureClipRegionReq);
-    
-    REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
+
+    REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
     VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
     VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
-    
-    return SetPictureClipRegion (pPicture, stuff->xOrigin, stuff->yOrigin,
-				 pRegion);
+
+    return SetPictureClipRegion(pPicture, stuff->xOrigin, stuff->yOrigin,
+                                pRegion);
 }
 
 int
-SProcXFixesSetPictureClipRegion (ClientPtr client)
+SProcXFixesSetPictureClipRegion(ClientPtr client)
 {
     REQUEST(xXFixesSetPictureClipRegionReq);
-    
+
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
+    REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
     swapl(&stuff->picture);
     swapl(&stuff->region);
     swaps(&stuff->xOrigin);
@@ -765,52 +769,51 @@ SProcXFixesSetPictureClipRegion (ClientPtr client)
 }
 
 int
-ProcXFixesExpandRegion (ClientPtr client)
+ProcXFixesExpandRegion(ClientPtr client)
 {
-    RegionPtr	pSource, pDestination;
-    REQUEST (xXFixesExpandRegionReq);
-    BoxPtr	pTmp;
-    BoxPtr	pSrc;
-    int		nBoxes;
-    int		i;
+    RegionPtr pSource, pDestination;
+
+    REQUEST(xXFixesExpandRegionReq);
+    BoxPtr pTmp;
+    BoxPtr pSrc;
+    int nBoxes;
+    int i;
 
-    REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
+    REQUEST_SIZE_MATCH(xXFixesExpandRegionReq);
     VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
     VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
-    
+
     nBoxes = RegionNumRects(pSource);
     pSrc = RegionRects(pSource);
-    if (nBoxes)
-    {
-	pTmp = malloc(nBoxes * sizeof (BoxRec));
-	if (!pTmp)
-	    return BadAlloc;
-	for (i = 0; i < nBoxes; i++)
-	{
-	    pTmp[i].x1 = pSrc[i].x1 - stuff->left;
-	    pTmp[i].x2 = pSrc[i].x2 + stuff->right;
-	    pTmp[i].y1 = pSrc[i].y1 - stuff->top;
-	    pTmp[i].y2 = pSrc[i].y2 + stuff->bottom;
-	}
-	RegionEmpty(pDestination);
-	for (i = 0; i < nBoxes; i++)
-	{
-	    RegionRec	r;
-	    RegionInit(&r, &pTmp[i], 0);
-	    RegionUnion(pDestination, pDestination, &r);
-	}
-	free(pTmp);
+    if (nBoxes) {
+        pTmp = malloc(nBoxes * sizeof(BoxRec));
+        if (!pTmp)
+            return BadAlloc;
+        for (i = 0; i < nBoxes; i++) {
+            pTmp[i].x1 = pSrc[i].x1 - stuff->left;
+            pTmp[i].x2 = pSrc[i].x2 + stuff->right;
+            pTmp[i].y1 = pSrc[i].y1 - stuff->top;
+            pTmp[i].y2 = pSrc[i].y2 + stuff->bottom;
+        }
+        RegionEmpty(pDestination);
+        for (i = 0; i < nBoxes; i++) {
+            RegionRec r;
+
+            RegionInit(&r, &pTmp[i], 0);
+            RegionUnion(pDestination, pDestination, &r);
+        }
+        free(pTmp);
     }
     return Success;
 }
 
 int
-SProcXFixesExpandRegion (ClientPtr client)
+SProcXFixesExpandRegion(ClientPtr client)
 {
-    REQUEST (xXFixesExpandRegionReq);
+    REQUEST(xXFixesExpandRegionReq);
 
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
+    REQUEST_SIZE_MATCH(xXFixesExpandRegionReq);
     swapl(&stuff->source);
     swapl(&stuff->destination);
     swaps(&stuff->left);
@@ -825,73 +828,80 @@ SProcXFixesExpandRegion (ClientPtr client)
 #include "panoramiXsrv.h"
 
 int
-PanoramiXFixesSetGCClipRegion (ClientPtr client)
+PanoramiXFixesSetGCClipRegion(ClientPtr client)
 {
     REQUEST(xXFixesSetGCClipRegionReq);
-    int		    result = Success, j;
-    PanoramiXRes    *gc;
+    int result = Success, j;
+    PanoramiXRes *gc;
+
     REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
 
-    if ((result = dixLookupResourceByType((void **)&gc, stuff->gc, XRT_GC,
-					  client, DixWriteAccess))) {
-	client->errorValue = stuff->gc;
-	return result;
+    if ((result = dixLookupResourceByType((void **) &gc, stuff->gc, XRT_GC,
+                                          client, DixWriteAccess))) {
+        client->errorValue = stuff->gc;
+        return result;
     }
 
     FOR_NSCREENS_BACKWARD(j) {
         stuff->gc = gc->info[j].id;
         result = (*PanoramiXSaveXFixesVector[X_XFixesSetGCClipRegion]) (client);
-        if(result != Success) break;
+        if (result != Success)
+            break;
     }
 
     return result;
 }
 
 int
-PanoramiXFixesSetWindowShapeRegion (ClientPtr client)
+PanoramiXFixesSetWindowShapeRegion(ClientPtr client)
 {
-    int		    result = Success, j;
-    PanoramiXRes    *win;
+    int result = Success, j;
+    PanoramiXRes *win;
+
     REQUEST(xXFixesSetWindowShapeRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq);
 
-    if ((result = dixLookupResourceByType((void **)&win, stuff->dest,
-					  XRT_WINDOW, client,
-					  DixWriteAccess))) {
-	client->errorValue = stuff->dest;
-	return result;
+    if ((result = dixLookupResourceByType((void **) &win, stuff->dest,
+                                          XRT_WINDOW, client,
+                                          DixWriteAccess))) {
+        client->errorValue = stuff->dest;
+        return result;
     }
 
     FOR_NSCREENS_FORWARD(j) {
-	stuff->dest = win->info[j].id;
-	result = (*PanoramiXSaveXFixesVector[X_XFixesSetWindowShapeRegion]) (client);
-        if(result != Success) break;
+        stuff->dest = win->info[j].id;
+        result =
+            (*PanoramiXSaveXFixesVector[X_XFixesSetWindowShapeRegion]) (client);
+        if (result != Success)
+            break;
     }
 
     return result;
 }
 
 int
-PanoramiXFixesSetPictureClipRegion (ClientPtr client)
+PanoramiXFixesSetPictureClipRegion(ClientPtr client)
 {
     REQUEST(xXFixesSetPictureClipRegionReq);
-    int		    result = Success, j;
-    PanoramiXRes    *pict;
+    int result = Success, j;
+    PanoramiXRes *pict;
 
-    REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
+    REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
 
-    if ((result = dixLookupResourceByType((void **)&pict, stuff->picture,
-					  XRT_PICTURE, client,
-					  DixWriteAccess))) {
-	client->errorValue = stuff->picture;
-	return result;
+    if ((result = dixLookupResourceByType((void **) &pict, stuff->picture,
+                                          XRT_PICTURE, client,
+                                          DixWriteAccess))) {
+        client->errorValue = stuff->picture;
+        return result;
     }
 
     FOR_NSCREENS_BACKWARD(j) {
         stuff->picture = pict->info[j].id;
-	result = (*PanoramiXSaveXFixesVector[X_XFixesSetPictureClipRegion]) (client);
-        if(result != Success) break;
+        result =
+            (*PanoramiXSaveXFixesVector[X_XFixesSetPictureClipRegion]) (client);
+        if (result != Success)
+            break;
     }
 
     return result;
diff --git a/xfixes/saveset.c b/xfixes/saveset.c
index ba959c22b..eb3f6589e 100644
--- a/xfixes/saveset.c
+++ b/xfixes/saveset.c
@@ -29,31 +29,29 @@
 int
 ProcXFixesChangeSaveSet(ClientPtr client)
 {
-    Bool	toRoot, map;
-    int		result;
-    WindowPtr	pWin;
+    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->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->target != SaveSetNearest) && (stuff->target != SaveSetRoot)) {
+        client->errorValue = stuff->target;
+        return BadValue;
     }
-    if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap))
-    {
-	client->errorValue = stuff->map;
-	return BadValue;
+    if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap)) {
+        client->errorValue = stuff->map;
+        return BadValue;
     }
     toRoot = (stuff->target == SaveSetRoot);
     map = (stuff->map == SaveSetMap);
@@ -67,5 +65,5 @@ SProcXFixesChangeSaveSet(ClientPtr client)
 
     swaps(&stuff->length);
     swapl(&stuff->window);
-    return (*ProcXFixesVector[stuff->xfixesReqType])(client);
+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
diff --git a/xfixes/select.c b/xfixes/select.c
index 2bf13f3fd..a896846a7 100644
--- a/xfixes/select.c
+++ b/xfixes/select.c
@@ -27,8 +27,8 @@
 #include "xfixesint.h"
 #include "xace.h"
 
-static RESTYPE		SelectionClientType, SelectionWindowType;
-static Bool		SelectionCallbackRegistered = FALSE;
+static RESTYPE SelectionClientType, SelectionWindowType;
+static Bool SelectionCallbackRegistered = FALSE;
 
 /*
  * There is a global list of windows selecting for selection events
@@ -40,83 +40,76 @@ static Bool		SelectionCallbackRegistered = FALSE;
 typedef struct _SelectionEvent *SelectionEventPtr;
 
 typedef struct _SelectionEvent {
-    SelectionEventPtr	next;
-    Atom		selection;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
+    SelectionEventPtr next;
+    Atom selection;
+    CARD32 eventMask;
+    ClientPtr pClient;
+    WindowPtr pWindow;
+    XID clientResource;
 } SelectionEventRec;
 
-static SelectionEventPtr	selectionEvents;
+static SelectionEventPtr selectionEvents;
 
 static void
-XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
+XFixesSelectionCallback(CallbackListPtr *callbacks, pointer data, pointer args)
 {
-    SelectionEventPtr	e;
-    SelectionInfoRec	*info = (SelectionInfoRec *) args;
-    Selection		*selection = info->selection;
-    int			subtype;
-    CARD32		eventMask;
-    
+    SelectionEventPtr e;
+    SelectionInfoRec *info = (SelectionInfoRec *) args;
+    Selection *selection = info->selection;
+    int subtype;
+    CARD32 eventMask;
+
     switch (info->kind) {
     case SelectionSetOwner:
-	subtype = XFixesSetSelectionOwnerNotify;
-	eventMask = XFixesSetSelectionOwnerNotifyMask;
-	break;
+        subtype = XFixesSetSelectionOwnerNotify;
+        eventMask = XFixesSetSelectionOwnerNotifyMask;
+        break;
     case SelectionWindowDestroy:
-	subtype = XFixesSelectionWindowDestroyNotify;
-	eventMask = XFixesSelectionWindowDestroyNotifyMask;
-	break;
+        subtype = XFixesSelectionWindowDestroyNotify;
+        eventMask = XFixesSelectionWindowDestroyNotifyMask;
+        break;
     case SelectionClientClose:
-	subtype = XFixesSelectionClientCloseNotify;
-	eventMask = XFixesSelectionClientCloseNotifyMask;
-	break;
+        subtype = XFixesSelectionClientCloseNotify;
+        eventMask = XFixesSelectionClientCloseNotifyMask;
+        break;
     default:
-	return;
+        return;
     }
-    for (e = selectionEvents; e; e = e->next)
-    {
-	if (e->selection == selection->selection && 
-	    (e->eventMask & eventMask))
-	{
-	    xXFixesSelectionNotifyEvent	ev;
+    for (e = selectionEvents; e; e = e->next) {
+        if (e->selection == selection->selection && (e->eventMask & eventMask)) {
+            xXFixesSelectionNotifyEvent ev;
 
-	    memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
-	    ev.type = XFixesEventBase + XFixesSelectionNotify;
-	    ev.subtype = subtype;
-	    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);
-	}
+            memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
+            ev.type = XFixesEventBase + XFixesSelectionNotify;
+            ev.subtype = subtype;
+            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)
+CheckSelectionCallback(void)
 {
-    if (selectionEvents)
-    {
-	if (!SelectionCallbackRegistered)
-	{
-	    if (!AddCallback (&SelectionCallback, XFixesSelectionCallback, NULL))
-		return FALSE;
-	    SelectionCallbackRegistered = TRUE;
-	}
+    if (selectionEvents) {
+        if (!SelectionCallbackRegistered) {
+            if (!AddCallback(&SelectionCallback, XFixesSelectionCallback, NULL))
+                return FALSE;
+            SelectionCallbackRegistered = TRUE;
+        }
     }
-    else
-    {
-	if (SelectionCallbackRegistered)
-	{
-	    DeleteCallback (&SelectionCallback, XFixesSelectionCallback, NULL);
-	    SelectionCallbackRegistered = FALSE;
-	}
+    else {
+        if (SelectionCallbackRegistered) {
+            DeleteCallback(&SelectionCallback, XFixesSelectionCallback, NULL);
+            SelectionCallbackRegistered = FALSE;
+        }
     }
     return TRUE;
 }
@@ -126,99 +119,88 @@ CheckSelectionCallback (void)
 			    XFixesSelectionClientCloseNotifyMask)
 
 static int
-XFixesSelectSelectionInput (ClientPtr	pClient,
-			    Atom	selection,
-			    WindowPtr	pWindow,
-			    CARD32	eventMask)
+XFixesSelectSelectionInput(ClientPtr pClient,
+                           Atom selection, WindowPtr pWindow, CARD32 eventMask)
 {
     pointer val;
     int rc;
-    SelectionEventPtr	*prev, e;
+    SelectionEventPtr *prev, e;
 
     rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    for (prev = &selectionEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->selection == selection &&
-	    e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
+    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 (!eventMask) {
+        if (e) {
+            FreeResource(e->clientResource, 0);
+        }
+        return Success;
     }
-    if (!e)
-    {
-	e = (SelectionEventPtr) malloc(sizeof (SelectionEventRec));
-	if (!e)
-	    return BadAlloc;
+    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);
+        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;
-	    }
+        /*
+         * 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;
+        if (!AddResource(e->clientResource, SelectionClientType, (pointer) e))
+            return BadAlloc;
 
-	*prev = e;
-	if (!CheckSelectionCallback ())
-	{
-	    FreeResource (e->clientResource, 0);
-	    return BadAlloc;
-	}
+        *prev = e;
+        if (!CheckSelectionCallback()) {
+            FreeResource(e->clientResource, 0);
+            return BadAlloc;
+        }
     }
     e->eventMask = eventMask;
     return Success;
 }
 
 int
-ProcXFixesSelectSelectionInput (ClientPtr client)
+ProcXFixesSelectSelectionInput(ClientPtr client)
 {
-    REQUEST (xXFixesSelectSelectionInputReq);
-    WindowPtr	pWin;
-    int		rc;
+    REQUEST(xXFixesSelectSelectionInputReq);
+    WindowPtr pWin;
+    int rc;
 
-    REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
+    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;
+    if (stuff->eventMask & ~SelectionAllEvents) {
+        client->errorValue = stuff->eventMask;
+        return BadValue;
     }
-    return XFixesSelectSelectionInput (client, stuff->selection,
-				       pWin, stuff->eventMask);
+    return XFixesSelectSelectionInput(client, stuff->selection,
+                                      pWin, stuff->eventMask);
 }
 
 int
-SProcXFixesSelectSelectionInput (ClientPtr client)
+SProcXFixesSelectSelectionInput(ClientPtr client)
 {
     REQUEST(xXFixesSelectSelectionInputReq);
 
@@ -226,64 +208,60 @@ SProcXFixesSelectSelectionInput (ClientPtr client)
     swapl(&stuff->window);
     swapl(&stuff->selection);
     swapl(&stuff->eventMask);
-    return (*ProcXFixesVector[stuff->xfixesReqType])(client);
+    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
-    
+
 void
-SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
-			     xXFixesSelectionNotifyEvent *to)
+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);
+    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)
+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;
-	}
+    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)
+SelectionFreeWindow(pointer data, XID id)
 {
-    WindowPtr		pWindow = (WindowPtr) data;
-    SelectionEventPtr	e, next;
+    WindowPtr pWindow = (WindowPtr) data;
+    SelectionEventPtr e, next;
 
-    for (e = selectionEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
+    for (e = selectionEvents; e; e = next) {
+        next = e->next;
+        if (e->pWindow == pWindow) {
+            FreeResource(e->clientResource, 0);
+        }
     }
     return 1;
 }
 
 Bool
-XFixesSelectionInit (void)
+XFixesSelectionInit(void)
 {
     SelectionClientType = CreateNewResourceType(SelectionFreeClient,
-						"XFixesSelectionClient");
+                                                "XFixesSelectionClient");
     SelectionWindowType = CreateNewResourceType(SelectionFreeWindow,
-						"XFixesSelectionWindow");
+                                                "XFixesSelectionWindow");
     return SelectionClientType && SelectionWindowType;
 }
diff --git a/xfixes/xfixes.c b/xfixes/xfixes.c
index 96d33c00b..f80230fd3 100644
--- a/xfixes/xfixes.c
+++ b/xfixes/xfixes.c
@@ -49,18 +49,20 @@
 #include "xfixesint.h"
 #include "protocol-versions.h"
 
-static unsigned char	XFixesReqCode;
-int		XFixesEventBase;
-int		XFixesErrorBase;
+static unsigned char XFixesReqCode;
+int XFixesEventBase;
+int XFixesErrorBase;
 
 static DevPrivateKeyRec XFixesClientPrivateKeyRec;
+
 #define XFixesClientPrivateKey (&XFixesClientPrivateKeyRec)
 
 static int
 ProcXFixesQueryVersion(ClientPtr client)
 {
-    XFixesClientPtr pXFixesClient = GetXFixesClient (client);
+    XFixesClientPtr pXFixesClient = GetXFixesClient(client);
     xXFixesQueryVersionReply rep;
+
     REQUEST(xXFixesQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
@@ -70,90 +72,86 @@ ProcXFixesQueryVersion(ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     if (version_compare(stuff->majorVersion, stuff->minorVersion,
-                        SERVER_XFIXES_MAJOR_VERSION, SERVER_XFIXES_MAJOR_VERSION) < 0)
-    {
-	rep.majorVersion = stuff->majorVersion;
-	rep.minorVersion = stuff->minorVersion;
-    } else {
-	rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
+                        SERVER_XFIXES_MAJOR_VERSION,
+                        SERVER_XFIXES_MAJOR_VERSION) < 0) {
+        rep.majorVersion = stuff->majorVersion;
+        rep.minorVersion = stuff->minorVersion;
+    }
+    else {
+        rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
         rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;
     }
 
     pXFixesClient->major_version = rep.majorVersion;
     pXFixesClient->minor_version = rep.minorVersion;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.majorVersion);
-	swapl(&rep.minorVersion);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.majorVersion);
+        swapl(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep);
+    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 */
-    X_XFixesDestroyPointerBarrier,  /* Version 5 */
+    X_XFixesQueryVersion,       /* before client sends QueryVersion */
+    X_XFixesGetCursorImage,     /* Version 1 */
+    X_XFixesChangeCursorByName, /* Version 2 */
+    X_XFixesExpandRegion,       /* Version 3 */
+    X_XFixesShowCursor,         /* Version 4 */
+    X_XFixesDestroyPointerBarrier,      /* Version 5 */
 };
 
 #define NUM_VERSION_REQUESTS	(sizeof (version_requests) / sizeof (version_requests[0]))
-    
-int	(*ProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {
+
+int (*ProcXFixesVector[XFixesNumberRequests]) (ClientPtr) = {
 /*************** Version 1 ******************/
     ProcXFixesQueryVersion,
-    ProcXFixesChangeSaveSet,
-    ProcXFixesSelectSelectionInput,
-    ProcXFixesSelectCursorInput,
-    ProcXFixesGetCursorImage,
+        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,
+        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,
+        ProcXFixesExpandRegion,
 /*************** Version 4 ****************/
-    ProcXFixesHideCursor,
-    ProcXFixesShowCursor,
+        ProcXFixesHideCursor, ProcXFixesShowCursor,
 /*************** Version 5 ****************/
-    ProcXFixesCreatePointerBarrier,
-    ProcXFixesDestroyPointerBarrier,
-};
+ProcXFixesCreatePointerBarrier, ProcXFixesDestroyPointerBarrier,};
 
 static int
-ProcXFixesDispatch (ClientPtr client)
+ProcXFixesDispatch(ClientPtr client)
 {
     REQUEST(xXFixesReq);
-    XFixesClientPtr pXFixesClient = GetXFixesClient (client);
+    XFixesClientPtr pXFixesClient = GetXFixesClient(client);
 
     if (pXFixesClient->major_version >= NUM_VERSION_REQUESTS)
-	return BadRequest;
+        return BadRequest;
     if (stuff->xfixesReqType > version_requests[pXFixesClient->major_version])
-	return BadRequest;
+        return BadRequest;
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -168,74 +166,66 @@ SProcXFixesQueryVersion(ClientPtr client)
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
-static int (*SProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {
+static int (*SProcXFixesVector[XFixesNumberRequests]) (ClientPtr) = {
 /*************** Version 1 ******************/
     SProcXFixesQueryVersion,
-    SProcXFixesChangeSaveSet,
-    SProcXFixesSelectSelectionInput,
-    SProcXFixesSelectCursorInput,
-    SProcXFixesGetCursorImage,
+        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,
+        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,
+        SProcXFixesExpandRegion,
 /*************** Version 4 ****************/
-    SProcXFixesHideCursor,
-    SProcXFixesShowCursor,
+        SProcXFixesHideCursor, SProcXFixesShowCursor,
 /*************** Version 5 ****************/
-    SProcXFixesCreatePointerBarrier,
-    SProcXFixesDestroyPointerBarrier,
-};
+SProcXFixesCreatePointerBarrier, SProcXFixesDestroyPointerBarrier,};
 
 static int
-SProcXFixesDispatch (ClientPtr client)
+SProcXFixesDispatch(ClientPtr client)
 {
     REQUEST(xXFixesReq);
     if (stuff->xfixesReqType >= XFixesNumberRequests)
-	return BadRequest;
+        return BadRequest;
     return (*SProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 static void
-XFixesClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+XFixesClientCallback(CallbackListPtr *list, pointer closure, pointer data)
 {
-    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
-    ClientPtr		pClient = clientinfo->client;
-    XFixesClientPtr	pXFixesClient = GetXFixesClient (pClient);
+    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)
+ /*ARGSUSED*/ static void
+XFixesResetProc(ExtensionEntry * extEntry)
 {
-    DeleteCallback (&ClientStateCallback, XFixesClientCallback, 0);
+    DeleteCallback(&ClientStateCallback, XFixesClientCallback, 0);
 }
 
 void
@@ -243,56 +233,58 @@ XFixesExtensionInit(void)
 {
     ExtensionEntry *extEntry;
 
-    if (!dixRegisterPrivateKey(&XFixesClientPrivateKeyRec, PRIVATE_CLIENT, 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;
-	SetResourceTypeErrorValue(RegionResType, XFixesErrorBase + BadRegion);
-	SetResourceTypeErrorValue(PointerBarrierType,
-				  XFixesErrorBase + BadBarrier);
+    if (!dixRegisterPrivateKey
+        (&XFixesClientPrivateKeyRec, PRIVATE_CLIENT, 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;
+        SetResourceTypeErrorValue(RegionResType, XFixesErrorBase + BadRegion);
+        SetResourceTypeErrorValue(PointerBarrierType,
+                                  XFixesErrorBase + BadBarrier);
     }
 }
 
 #ifdef PANORAMIX
 
-int (*PanoramiXSaveXFixesVector[XFixesNumberRequests])(ClientPtr);
+int (*PanoramiXSaveXFixesVector[XFixesNumberRequests]) (ClientPtr);
 
 void
-PanoramiXFixesInit (void)
+PanoramiXFixesInit(void)
 {
     int i;
 
     for (i = 0; i < XFixesNumberRequests; i++)
-	PanoramiXSaveXFixesVector[i] = ProcXFixesVector[i];
+        PanoramiXSaveXFixesVector[i] = ProcXFixesVector[i];
     /*
      * Stuff in Xinerama aware request processing hooks
      */
     ProcXFixesVector[X_XFixesSetGCClipRegion] = PanoramiXFixesSetGCClipRegion;
-    ProcXFixesVector[X_XFixesSetWindowShapeRegion] = PanoramiXFixesSetWindowShapeRegion;
-    ProcXFixesVector[X_XFixesSetPictureClipRegion] = PanoramiXFixesSetPictureClipRegion;
+    ProcXFixesVector[X_XFixesSetWindowShapeRegion] =
+        PanoramiXFixesSetWindowShapeRegion;
+    ProcXFixesVector[X_XFixesSetPictureClipRegion] =
+        PanoramiXFixesSetPictureClipRegion;
 }
 
 void
-PanoramiXFixesReset (void)
+PanoramiXFixesReset(void)
 {
     int i;
 
     for (i = 0; i < XFixesNumberRequests; i++)
-	ProcXFixesVector[i] = PanoramiXSaveXFixesVector[i];
+        ProcXFixesVector[i] = PanoramiXSaveXFixesVector[i];
 }
 
 #endif
diff --git a/xfixes/xfixes.h b/xfixes/xfixes.h
index 5765e64b5..19af09f7d 100644
--- a/xfixes/xfixes.h
+++ b/xfixes/xfixes.h
@@ -50,23 +50,22 @@ extern _X_EXPORT int XFixesErrorBase;
 }
 
 extern _X_EXPORT RegionPtr
-XFixesRegionCopy (RegionPtr pRegion);
+ XFixesRegionCopy(RegionPtr pRegion);
 
 struct PointerBarrier {
     CARD16 x1, x2, y1, y2;
     CARD32 directions;
 };
 
-
 extern int
-barrier_get_direction(int, int, int, int);
-extern BOOL
-barrier_is_blocking(const struct PointerBarrier*, int, int, int, int, double*);
+ barrier_get_direction(int, int, int, int);
 extern BOOL
-barrier_is_blocking_direction(const struct PointerBarrier*, int);
+barrier_is_blocking(const struct PointerBarrier *, int, int, int, int,
+                    double *);
+extern BOOL barrier_is_blocking_direction(const struct PointerBarrier *, int);
 extern void
-barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, int *y);
-
 
+barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x,
+                         int *y);
 
-#endif /* _XFIXES_H_ */
+#endif                          /* _XFIXES_H_ */
diff --git a/xfixes/xfixesint.h b/xfixes/xfixesint.h
index 6ba276e8c..71f88a93d 100644
--- a/xfixes/xfixesint.h
+++ b/xfixes/xfixesint.h
@@ -60,242 +60,244 @@
 #include "selection.h"
 #include "xfixes.h"
 
-extern int		XFixesEventBase;
+extern int XFixesEventBase;
 
 typedef struct _XFixesClient {
-    CARD32	major_version;
-    CARD32	minor_version;
+    CARD32 major_version;
+    CARD32 minor_version;
 } XFixesClientRec, *XFixesClientPtr;
 
 #define GetXFixesClient(pClient) ((XFixesClientPtr)dixLookupPrivate(&(pClient)->devPrivates, XFixesClientPrivateKey))
 
-extern int	(*ProcXFixesVector[XFixesNumberRequests])(ClientPtr);
+extern int (*ProcXFixesVector[XFixesNumberRequests]) (ClientPtr);
 
 /* Initialize extension at server startup time */
 
 void
-XFixesExtensionInit(void);
+ XFixesExtensionInit(void);
 
 /* Save set */
 int
-ProcXFixesChangeSaveSet(ClientPtr client);
-    
+ ProcXFixesChangeSaveSet(ClientPtr client);
+
 int
-SProcXFixesChangeSaveSet(ClientPtr client);
-    
+ SProcXFixesChangeSaveSet(ClientPtr client);
+
 /* Selection events */
 int
-ProcXFixesSelectSelectionInput (ClientPtr client);
+ ProcXFixesSelectSelectionInput(ClientPtr client);
 
 int
-SProcXFixesSelectSelectionInput (ClientPtr client);
+ SProcXFixesSelectSelectionInput(ClientPtr client);
 
 void
-SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
-			     xXFixesSelectionNotifyEvent *to);
+
+SXFixesSelectionNotifyEvent(xXFixesSelectionNotifyEvent * from,
+                            xXFixesSelectionNotifyEvent * to);
 Bool
-XFixesSelectionInit (void);
+ XFixesSelectionInit(void);
 
 /* Cursor notification */
 Bool
-XFixesCursorInit (void);
-    
+ XFixesCursorInit(void);
+
 int
-ProcXFixesSelectCursorInput (ClientPtr client);
+ ProcXFixesSelectCursorInput(ClientPtr client);
 
 int
-SProcXFixesSelectCursorInput (ClientPtr client);
+ SProcXFixesSelectCursorInput(ClientPtr client);
 
 void
-SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from,
-			  xXFixesCursorNotifyEvent *to);
+
+SXFixesCursorNotifyEvent(xXFixesCursorNotifyEvent * from,
+                         xXFixesCursorNotifyEvent * to);
 
 int
-ProcXFixesGetCursorImage (ClientPtr client);
+ ProcXFixesGetCursorImage(ClientPtr client);
 
 int
-SProcXFixesGetCursorImage (ClientPtr client);
+ SProcXFixesGetCursorImage(ClientPtr client);
 
 /* Cursor names (Version 2) */
 
 int
-ProcXFixesSetCursorName (ClientPtr client);
+ ProcXFixesSetCursorName(ClientPtr client);
 
 int
-SProcXFixesSetCursorName (ClientPtr client);
+ SProcXFixesSetCursorName(ClientPtr client);
 
 int
-ProcXFixesGetCursorName (ClientPtr client);
+ ProcXFixesGetCursorName(ClientPtr client);
 
 int
-SProcXFixesGetCursorName (ClientPtr client);
+ SProcXFixesGetCursorName(ClientPtr client);
 
 int
-ProcXFixesGetCursorImageAndName (ClientPtr client);
+ ProcXFixesGetCursorImageAndName(ClientPtr client);
 
 int
-SProcXFixesGetCursorImageAndName (ClientPtr client);
+ SProcXFixesGetCursorImageAndName(ClientPtr client);
 
 /* Cursor replacement (Version 2) */
 
 int
-ProcXFixesChangeCursor (ClientPtr client);
+ ProcXFixesChangeCursor(ClientPtr client);
 
 int
-SProcXFixesChangeCursor (ClientPtr client);
+ SProcXFixesChangeCursor(ClientPtr client);
 
 int
-ProcXFixesChangeCursorByName (ClientPtr client);
+ ProcXFixesChangeCursorByName(ClientPtr client);
 
 int
-SProcXFixesChangeCursorByName (ClientPtr client);
+ SProcXFixesChangeCursorByName(ClientPtr client);
 
 /* Region objects (Version 2* */
 Bool
-XFixesRegionInit (void);
+ XFixesRegionInit(void);
 
 int
-ProcXFixesCreateRegion (ClientPtr client);
+ ProcXFixesCreateRegion(ClientPtr client);
 
 int
-SProcXFixesCreateRegion (ClientPtr client);
+ SProcXFixesCreateRegion(ClientPtr client);
 
 int
-ProcXFixesCreateRegionFromBitmap (ClientPtr client);
+ ProcXFixesCreateRegionFromBitmap(ClientPtr client);
 
 int
-SProcXFixesCreateRegionFromBitmap (ClientPtr client);
+ SProcXFixesCreateRegionFromBitmap(ClientPtr client);
 
 int
-ProcXFixesCreateRegionFromWindow (ClientPtr client);
+ ProcXFixesCreateRegionFromWindow(ClientPtr client);
 
 int
-SProcXFixesCreateRegionFromWindow (ClientPtr client);
+ SProcXFixesCreateRegionFromWindow(ClientPtr client);
 
 int
-ProcXFixesCreateRegionFromGC (ClientPtr client);
+ ProcXFixesCreateRegionFromGC(ClientPtr client);
 
 int
-SProcXFixesCreateRegionFromGC (ClientPtr client);
+ SProcXFixesCreateRegionFromGC(ClientPtr client);
 
 int
-ProcXFixesCreateRegionFromPicture (ClientPtr client);
+ ProcXFixesCreateRegionFromPicture(ClientPtr client);
 
 int
-SProcXFixesCreateRegionFromPicture (ClientPtr client);
+ SProcXFixesCreateRegionFromPicture(ClientPtr client);
 
 int
-ProcXFixesDestroyRegion (ClientPtr client);
+ ProcXFixesDestroyRegion(ClientPtr client);
 
 int
-SProcXFixesDestroyRegion (ClientPtr client);
+ SProcXFixesDestroyRegion(ClientPtr client);
 
 int
-ProcXFixesSetRegion (ClientPtr client);
+ ProcXFixesSetRegion(ClientPtr client);
 
 int
-SProcXFixesSetRegion (ClientPtr client);
+ SProcXFixesSetRegion(ClientPtr client);
 
 int
-ProcXFixesCopyRegion (ClientPtr client);
+ ProcXFixesCopyRegion(ClientPtr client);
 
 int
-SProcXFixesCopyRegion (ClientPtr client);
+ SProcXFixesCopyRegion(ClientPtr client);
 
 int
-ProcXFixesCombineRegion (ClientPtr client);
+ ProcXFixesCombineRegion(ClientPtr client);
 
 int
-SProcXFixesCombineRegion (ClientPtr client);
+ SProcXFixesCombineRegion(ClientPtr client);
 
 int
-ProcXFixesInvertRegion (ClientPtr client);
+ ProcXFixesInvertRegion(ClientPtr client);
 
 int
-SProcXFixesInvertRegion (ClientPtr client);
+ SProcXFixesInvertRegion(ClientPtr client);
 
 int
-ProcXFixesTranslateRegion (ClientPtr client);
+ ProcXFixesTranslateRegion(ClientPtr client);
 
 int
-SProcXFixesTranslateRegion (ClientPtr client);
+ SProcXFixesTranslateRegion(ClientPtr client);
 
 int
-ProcXFixesRegionExtents (ClientPtr client);
+ ProcXFixesRegionExtents(ClientPtr client);
 
 int
-SProcXFixesRegionExtents (ClientPtr client);
+ SProcXFixesRegionExtents(ClientPtr client);
 
 int
-ProcXFixesFetchRegion (ClientPtr client);
+ ProcXFixesFetchRegion(ClientPtr client);
 
 int
-SProcXFixesFetchRegion (ClientPtr client);
+ SProcXFixesFetchRegion(ClientPtr client);
 
 int
-ProcXFixesSetGCClipRegion (ClientPtr client);
+ ProcXFixesSetGCClipRegion(ClientPtr client);
 
 int
-SProcXFixesSetGCClipRegion (ClientPtr client);
+ SProcXFixesSetGCClipRegion(ClientPtr client);
 
 int
-ProcXFixesSetWindowShapeRegion (ClientPtr client);
+ ProcXFixesSetWindowShapeRegion(ClientPtr client);
 
 int
-SProcXFixesSetWindowShapeRegion (ClientPtr client);
+ SProcXFixesSetWindowShapeRegion(ClientPtr client);
 
 int
-ProcXFixesSetPictureClipRegion (ClientPtr client);
+ ProcXFixesSetPictureClipRegion(ClientPtr client);
 
 int
-SProcXFixesSetPictureClipRegion (ClientPtr client);
+ SProcXFixesSetPictureClipRegion(ClientPtr client);
 
 int
-ProcXFixesExpandRegion (ClientPtr client);
+ ProcXFixesExpandRegion(ClientPtr client);
 
 int
-SProcXFixesExpandRegion (ClientPtr client);
+ SProcXFixesExpandRegion(ClientPtr client);
 
 int
-PanoramiXFixesSetGCClipRegion (ClientPtr client);
+ PanoramiXFixesSetGCClipRegion(ClientPtr client);
 
 int
-PanoramiXFixesSetWindowShapeRegion (ClientPtr client);
+ PanoramiXFixesSetWindowShapeRegion(ClientPtr client);
 
 int
-PanoramiXFixesSetPictureClipRegion (ClientPtr client);
+ PanoramiXFixesSetPictureClipRegion(ClientPtr client);
 
 /* Cursor Visibility (Version 4) */
 
-int 
-ProcXFixesHideCursor (ClientPtr client);
+int
+ ProcXFixesHideCursor(ClientPtr client);
 
-int 
-SProcXFixesHideCursor (ClientPtr client);
+int
+ SProcXFixesHideCursor(ClientPtr client);
 
-int 
-ProcXFixesShowCursor (ClientPtr client);
+int
+ ProcXFixesShowCursor(ClientPtr client);
 
-int 
-SProcXFixesShowCursor (ClientPtr client);
+int
+ SProcXFixesShowCursor(ClientPtr client);
 
 /* Version 5 */
 
 int
-ProcXFixesCreatePointerBarrier (ClientPtr client);
+ ProcXFixesCreatePointerBarrier(ClientPtr client);
 
 int
-SProcXFixesCreatePointerBarrier (ClientPtr client);
+ SProcXFixesCreatePointerBarrier(ClientPtr client);
 
 int
-ProcXFixesDestroyPointerBarrier (ClientPtr client);
+ ProcXFixesDestroyPointerBarrier(ClientPtr client);
 
 int
-SProcXFixesDestroyPointerBarrier (ClientPtr client);
+ SProcXFixesDestroyPointerBarrier(ClientPtr client);
 
 /* Xinerama */
-extern int (*PanoramiXSaveXFixesVector[XFixesNumberRequests])(ClientPtr);
-void PanoramiXFixesInit (void);
-void PanoramiXFixesReset (void);
+extern int (*PanoramiXSaveXFixesVector[XFixesNumberRequests]) (ClientPtr);
+void PanoramiXFixesInit(void);
+void PanoramiXFixesReset(void);
 
-#endif /* _XFIXESINT_H_ */
+#endif                          /* _XFIXESINT_H_ */