Merge branch 'uli42-pr/update_xi' into arctica-3.6.x

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

1 files changed, 466 insertions, 636 deletions

diff --git a/nx-X11/programs/Xserver/Xi/exevents.c b/nx-X11/programs/Xserver/Xi/exevents.c
index 3b5a070b6..92b9f08ec 100644
--- a/nx-X11/programs/Xserver/Xi/exevents.c
+++ b/nx-X11/programs/Xserver/Xi/exevents.c
@@ -66,10 +66,10 @@ SOFTWARE.
 #include "region.h"
 #include "exevents.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
-#include "dixevents.h"			/* DeliverFocusedEvent */
-#include "dixgrabs.h"			/* CreateGrab() */
+#include "dixevents.h"	/* DeliverFocusedEvent */
+#include "dixgrabs.h"	/* CreateGrab() */
 
 #include "chgptr.h"
 
@@ -82,13 +82,11 @@ SOFTWARE.
 #define Motion_Filter(class) (DevicePointerMotionMask | \
 			      (class)->state | (class)->motionMask)
 
-static Bool		ShouldFreeInputMasks(
-				WindowPtr /* pWin */,
-				Bool /* ignoreSelectedEvents */
-				);
-static Bool		MakeInputMasks (
-				WindowPtr /* pWin */
-				);
+static Bool ShouldFreeInputMasks(WindowPtr /* pWin */ ,
+				 Bool	/* ignoreSelectedEvents */
+    );
+static Bool MakeInputMasks(WindowPtr	/* pWin */
+    );
 
 /**************************************************************************
  *
@@ -97,153 +95,137 @@ static Bool		MakeInputMasks (
  */
 
 void
-RegisterOtherDevice (device)
-    DeviceIntPtr device;
-    {
+RegisterOtherDevice(DeviceIntPtr device)
+{
     device->public.processInputProc = ProcessOtherEvent;
     device->public.realInputProc = ProcessOtherEvent;
     (device)->ActivateGrab = ActivateKeyboardGrab;
     (device)->DeactivateGrab = DeactivateKeyboardGrab;
-    }
+}
 
-/*ARGSUSED*/
-void
-ProcessOtherEvent (xE, other, count)
-    xEventPtr xE;
-    register DeviceIntPtr other;
-    int count;
-    {
-    register BYTE   	*kptr;
-    register int    	i;
-    register CARD16 	modifiers;
-    register CARD16 	mask;
-    GrabPtr         	grab = other->grab;
-    Bool            	deactivateDeviceGrab = FALSE;
-    int             	key = 0, bit = 0, rootX, rootY;
-    ButtonClassPtr	b = other->button;
-    KeyClassPtr		k = other->key;
-    ValuatorClassPtr	v = other->valuator;
-    deviceValuator	*xV = (deviceValuator *) xE;
+ /*ARGSUSED*/ void
+ProcessOtherEvent(xEventPtr xE, register DeviceIntPtr other, int count)
+{
+    register BYTE *kptr;
+    register int i;
+    register CARD16 modifiers;
+    register CARD16 mask;
+    GrabPtr grab = other->grab;
+    Bool deactivateDeviceGrab = FALSE;
+    int key = 0, bit = 0, rootX, rootY;
+    ButtonClassPtr b = other->button;
+    KeyClassPtr k = other->key;
+    ValuatorClassPtr v = other->valuator;
+    deviceValuator *xV = (deviceValuator *) xE;
 
     if (xE->u.u.type != DeviceValuator) {
-        GetSpritePosition(&rootX, &rootY);
-        xE->u.keyButtonPointer.rootX = rootX;
-        xE->u.keyButtonPointer.rootY = rootY;
-        key = xE->u.u.detail;
-        NoticeEventTime(xE);
-        xE->u.keyButtonPointer.state = inputInfo.keyboard->key->state | 
-		    inputInfo.pointer->button->state;
-        bit = 1 << (key & 7);
+	GetSpritePosition(&rootX, &rootY);
+	xE->u.keyButtonPointer.rootX = rootX;
+	xE->u.keyButtonPointer.rootY = rootY;
+	key = xE->u.u.detail;
+	NoticeEventTime(xE);
+	xE->u.keyButtonPointer.state = inputInfo.keyboard->key->state |
+	    inputInfo.pointer->button->state;
+	bit = 1 << (key & 7);
     }
-    if (DeviceEventCallback)
-    {
+    if (DeviceEventCallback) {
 	DeviceEventInfoRec eventinfo;
+
 	eventinfo.events = (xEventPtr) xE;
 	eventinfo.count = count;
-	CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
+	CallCallbacks(&DeviceEventCallback, (void *) & eventinfo);
     }
-    for (i=1; i<count; i++)
-	if ((++xV)->type == DeviceValuator)
-	    {
+    for (i = 1; i < count; i++)
+	if ((++xV)->type == DeviceValuator) {
 	    int first = xV->first_valuator;
 	    int *axisvals;
 
-	    if (xV->num_valuators && (!v || (xV->num_valuators && (first + xV->num_valuators > v->numAxes))))
-		FatalError("Bad valuators reported for device %s\n",other->name);
+	    if (xV->num_valuators
+		&& (!v
+		    || (xV->num_valuators
+			&& (first + xV->num_valuators > v->numAxes))))
+		FatalError("Bad valuators reported for device %s\n",
+			   other->name);
 	    xV->device_state = 0;
 	    if (k)
 		xV->device_state |= k->state;
 	    if (b)
-	        xV->device_state |= b->state;
-	    if (v && v->axisVal)
-		{
-	        axisvals = v->axisVal;
-	        switch (xV->num_valuators) {
-		    case 6:
-		        *(axisvals+first+5) = xV->valuator5;
-		    case 5:
-		        *(axisvals+first+4) = xV->valuator4;
-		    case 4:
-		        *(axisvals+first+3) = xV->valuator3;
-		    case 3:
-		        *(axisvals+first+2) = xV->valuator2;
-		    case 2:
-		        *(axisvals+first+1) = xV->valuator1;
-		    case 1:
-		        *(axisvals+first) = xV->valuator0;
-		    case 0:
-		    default:
-		        break;
-		    }
+		xV->device_state |= b->state;
+	    if (v && v->axisVal) {
+		axisvals = v->axisVal;
+		switch (xV->num_valuators) {
+		case 6:
+		    *(axisvals + first + 5) = xV->valuator5;
+		case 5:
+		    *(axisvals + first + 4) = xV->valuator4;
+		case 4:
+		    *(axisvals + first + 3) = xV->valuator3;
+		case 3:
+		    *(axisvals + first + 2) = xV->valuator2;
+		case 2:
+		    *(axisvals + first + 1) = xV->valuator1;
+		case 1:
+		    *(axisvals + first) = xV->valuator0;
+		case 0:
+		default:
+		    break;
 		}
 	    }
-    
-    if (xE->u.u.type == DeviceKeyPress)
-	{
+	}
+
+    if (xE->u.u.type == DeviceKeyPress) {
 	modifiers = k->modifierMap[key];
-        kptr = &k->down[key >> 3];
-	if (*kptr & bit) /* allow ddx to generate multiple downs */
-	    {   
-	    if (!modifiers)
-		{
+	kptr = &k->down[key >> 3];
+	if (*kptr & bit) {	/* allow ddx to generate multiple downs */
+	    if (!modifiers) {
 		xE->u.u.type = DeviceKeyRelease;
 		ProcessOtherEvent(xE, other, count);
 		xE->u.u.type = DeviceKeyPress;
 		/* release can have side effects, don't fall through */
 		ProcessOtherEvent(xE, other, count);
-		}
-	    return;
 	    }
+	    return;
+	}
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
 	*kptr |= bit;
 	k->prev_state = k->state;
-	for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
-	    {
-	    if (mask & modifiers) 
-	        {
+	for (i = 0, mask = 1; modifiers; i++, mask <<= 1) {
+	    if (mask & modifiers) {
 		/* This key affects modifier "i" */
 		k->modifierKeyCount[i]++;
 		k->state |= mask;
 		modifiers &= ~mask;
-		}
 	    }
-	if (!grab && CheckDeviceGrabs(other, xE, 0, count))
-	    {
+	}
+	if (!grab && CheckDeviceGrabs(other, xE, 0, count)) {
 	    other->activatingKey = key;
 	    return;
-	    }
 	}
-    else if (xE->u.u.type == DeviceKeyRelease)
-	{
-        kptr = &k->down[key >> 3];
-	if (!(*kptr & bit)) /* guard against duplicates */
+    } else if (xE->u.u.type == DeviceKeyRelease) {
+	kptr = &k->down[key >> 3];
+	if (!(*kptr & bit))	/* guard against duplicates */
 	    return;
 	modifiers = k->modifierMap[key];
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
 	*kptr &= ~bit;
 	k->prev_state = k->state;
-	for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
-	    {
-	    if (mask & modifiers) 
-	        {
+	for (i = 0, mask = 1; modifiers; i++, mask <<= 1) {
+	    if (mask & modifiers) {
 		/* This key affects modifier "i" */
-		if (--k->modifierKeyCount[i] <= 0) 
-		    {
+		if (--k->modifierKeyCount[i] <= 0) {
 		    k->modifierKeyCount[i] = 0;
 		    k->state &= ~mask;
-		    }
-		modifiers &= ~mask;
 		}
+		modifiers &= ~mask;
 	    }
+	}
 
 	if (other->fromPassiveGrab && (key == other->activatingKey))
 	    deactivateDeviceGrab = TRUE;
-	}
-    else if (xE->u.u.type == DeviceButtonPress)
-	{
-        kptr = &b->down[key >> 3];
+    } else if (xE->u.u.type == DeviceButtonPress) {
+	kptr = &b->down[key >> 3];
 	*kptr |= bit;
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
@@ -251,33 +233,30 @@ ProcessOtherEvent (xE, other, count)
 	b->motionMask = DeviceButtonMotionMask;
 	xE->u.u.detail = b->map[key];
 	if (xE->u.u.detail == 0)
-	     return;
+	    return;
 	if (xE->u.u.detail <= 5)
 	    b->state |= (Button1Mask >> 1) << xE->u.u.detail;
-	SetMaskForEvent(Motion_Filter(b),DeviceMotionNotify);
+	SetMaskForEvent(Motion_Filter(b), DeviceMotionNotify);
 	if (!grab)
 	    if (CheckDeviceGrabs(other, xE, 0, count))
 		return;
 
-	}
-    else if (xE->u.u.type == DeviceButtonRelease)
-	{
-        kptr = &b->down[key >> 3];
+    } else if (xE->u.u.type == DeviceButtonRelease) {
+	kptr = &b->down[key >> 3];
 	*kptr &= ~bit;
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
 	if (!--b->buttonsDown)
-		b->motionMask = 0;
+	    b->motionMask = 0;
 	xE->u.u.detail = b->map[key];
 	if (xE->u.u.detail == 0)
 	    return;
 	if (xE->u.u.detail <= 5)
 	    b->state &= ~((Button1Mask >> 1) << xE->u.u.detail);
-	SetMaskForEvent(Motion_Filter(b),DeviceMotionNotify);
+	SetMaskForEvent(Motion_Filter(b), DeviceMotionNotify);
 	if (!b->state && other->fromPassiveGrab)
 	    deactivateDeviceGrab = TRUE;
-	}
-    else if (xE->u.u.type == ProximityIn)
+    } else if (xE->u.u.type == ProximityIn)
 	other->valuator->mode &= ~OutOfProximity;
     else if (xE->u.u.type == ProximityOut)
 	other->valuator->mode |= OutOfProximity;
@@ -291,15 +270,15 @@ ProcessOtherEvent (xE, other, count)
 			    other, count);
 
     if (deactivateDeviceGrab == TRUE)
-        (*other->DeactivateGrab)(other);
-    }
+	(*other->DeactivateGrab) (other);
+}
 
 int
-InitProximityClassDeviceStruct( DeviceIntPtr dev)
+InitProximityClassDeviceStruct(DeviceIntPtr dev)
 {
     register ProximityClassPtr proxc;
 
-    proxc = (ProximityClassPtr)malloc(sizeof(ProximityClassRec));
+    proxc = (ProximityClassPtr) malloc(sizeof(ProximityClassRec));
     if (!proxc)
 	return FALSE;
     dev->proximity = proxc;
@@ -307,13 +286,8 @@ InitProximityClassDeviceStruct( DeviceIntPtr dev)
 }
 
 void
-InitValuatorAxisStruct(	DeviceIntPtr dev,
-						int axnum,
-						int minval,
-						int maxval,
-						int resolution,
-						int min_res,
-						int max_res )
+InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
+		       int resolution, int min_res, int max_res)
 {
     register AxisInfoPtr ax = dev->valuator->axes + axnum;
 
@@ -325,13 +299,8 @@ InitValuatorAxisStruct(	DeviceIntPtr dev,
 }
 
 static void
-FixDeviceStateNotify (
-    DeviceIntPtr dev,
-    deviceStateNotify *ev,
-    KeyClassPtr k,
-    ButtonClassPtr b,
-    ValuatorClassPtr v,
-    int first)
+FixDeviceStateNotify(DeviceIntPtr dev, deviceStateNotify * ev, KeyClassPtr k,
+		     ButtonClassPtr b, ValuatorClassPtr v, int first)
 {
     ev->type = DeviceStateNotify;
     ev->deviceid = dev->id;
@@ -344,37 +313,33 @@ FixDeviceStateNotify (
     if (b) {
 	ev->classes_reported |= (1 << ButtonClass);
 	ev->num_buttons = b->numButtons;
-	memmove((char *) &ev->buttons[0], (char *) b->down, 4);
-	}
-    else if (k) {
+	memmove((char *)&ev->buttons[0], (char *)b->down, 4);
+    } else if (k) {
 	ev->classes_reported |= (1 << KeyClass);
 	ev->num_keys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
-	memmove((char *) &ev->keys[0], (char *) k->down, 4);
-	}
+	memmove((char *)&ev->keys[0], (char *)k->down, 4);
+    }
     if (v) {
 	int nval = v->numAxes - first;
+
 	ev->classes_reported |= (1 << ValuatorClass);
 	ev->classes_reported |= (dev->valuator->mode << ModeBitsShift);
 	ev->num_valuators = nval < 3 ? nval : 3;
-	switch (ev->num_valuators) 
-	    {
-	    case 3:
-		ev->valuator2 = v->axisVal[first+2];
-	    case 2:
-		ev->valuator1 = v->axisVal[first+1];
-	    case 1:
-		ev->valuator0 = v->axisVal[first];
+	switch (ev->num_valuators) {
+	case 3:
+	    ev->valuator2 = v->axisVal[first + 2];
+	case 2:
+	    ev->valuator1 = v->axisVal[first + 1];
+	case 1:
+	    ev->valuator0 = v->axisVal[first];
 	    break;
-	    }
 	}
     }
+}
 
 static void
-FixDeviceValuator (
-    DeviceIntPtr dev,
-    deviceValuator *ev,
-    ValuatorClassPtr v,
-    int first)
+FixDeviceValuator(DeviceIntPtr dev, deviceValuator * ev, ValuatorClassPtr v,
+		  int first)
 {
     int nval = v->numAxes - first;
 
@@ -383,24 +348,22 @@ FixDeviceValuator (
     ev->num_valuators = nval < 3 ? nval : 3;
     ev->first_valuator = first;
     switch (ev->num_valuators) {
-	case 3:
-	    ev->valuator2 = v->axisVal[first+2];
-	case 2:
-	    ev->valuator1 = v->axisVal[first+1];
-	case 1:
-	    ev->valuator0 = v->axisVal[first];
+    case 3:
+	ev->valuator2 = v->axisVal[first + 2];
+    case 2:
+	ev->valuator1 = v->axisVal[first + 1];
+    case 1:
+	ev->valuator0 = v->axisVal[first];
 	break;
-	}
-    first += ev->num_valuators;
     }
+    first += ev->num_valuators;
+}
 
 void
-DeviceFocusEvent(dev, type, mode, detail, pWin)
-    DeviceIntPtr dev;
-    int type, mode, detail;
-    register WindowPtr pWin;
-    {
-    deviceFocus	event;
+DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
+		 register WindowPtr pWin)
+{
+    deviceFocus event;
 
     if (type == FocusIn)
 	type = DeviceFocusIn;
@@ -414,29 +377,29 @@ DeviceFocusEvent(dev, type, mode, detail, pWin)
     event.window = pWin->drawable.id;
     event.time = currentTime.milliseconds;
 
-    (void) DeliverEventsToWindow(pWin, (xEvent *)&event, 1,
-    	DeviceFocusChangeMask, NullGrab, dev->id);
+    (void)DeliverEventsToWindow(pWin, (xEvent *) & event, 1,
+				DeviceFocusChangeMask, NullGrab, dev->id);
 
-    if ((type == DeviceFocusIn) && 
+    if ((type == DeviceFocusIn) &&
 	(wOtherInputMasks(pWin)) &&
 	(wOtherInputMasks(pWin)->inputEvents[dev->id] & DeviceStateNotifyMask))
-        {
-	int 			evcount = 1;
-	deviceStateNotify 	*ev, *sev;
-	deviceKeyStateNotify 	*kev;
+    {
+	int evcount = 1;
+	deviceStateNotify *ev, *sev;
+	deviceKeyStateNotify *kev;
 	deviceButtonStateNotify *bev;
 
 	KeyClassPtr k;
 	ButtonClassPtr b;
 	ValuatorClassPtr v;
-	int nval=0, nkeys=0, nbuttons=0, first=0;
+	int nval = 0, nkeys = 0, nbuttons = 0, first = 0;
 
-	if ((b=dev->button) != NULL) {
+	if ((b = dev->button) != NULL) {
 	    nbuttons = b->numButtons;
 	    if (nbuttons > 32)
 		evcount++;
 	}
-	if ((k=dev->key) != NULL) {
+	if ((k = dev->key) != NULL) {
 	    nkeys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
 	    if (nkeys > 32)
 		evcount++;
@@ -444,7 +407,7 @@ DeviceFocusEvent(dev, type, mode, detail, pWin)
 		evcount++;
 	    }
 	}
-	if ((v=dev->valuator) != NULL) {
+	if ((v = dev->valuator) != NULL) {
 	    nval = v->numAxes;
 
 	    if (nval > 3)
@@ -458,103 +421,89 @@ DeviceFocusEvent(dev, type, mode, detail, pWin)
 	}
 
 	sev = ev = (deviceStateNotify *) malloc(evcount * sizeof(xEvent));
-	FixDeviceStateNotify (dev, ev, NULL, NULL, NULL, first);
+	FixDeviceStateNotify(dev, ev, NULL, NULL, NULL, first);
 
 	if (b != NULL) {
-	    FixDeviceStateNotify (dev, ev++, NULL, b, v, first);
+	    FixDeviceStateNotify(dev, ev++, NULL, b, v, first);
 	    first += 3;
 	    nval -= 3;
 	    if (nbuttons > 32) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		bev = (deviceButtonStateNotify *) ev++; 
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		bev = (deviceButtonStateNotify *) ev++;
 		bev->type = DeviceButtonStateNotify;
 		bev->deviceid = dev->id;
-		memmove((char *) &bev->buttons[0], (char *) &b->down[4], 28);
+		memmove((char *)&bev->buttons[0], (char *)&b->down[4], 28);
 	    }
 	    if (nval > 0) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator(dev, (deviceValuator *) ev++, v, first);
 		first += 3;
 		nval -= 3;
 	    }
 	}
 
 	if (k != NULL) {
-	    FixDeviceStateNotify (dev, ev++, k, NULL, v, first);
+	    FixDeviceStateNotify(dev, ev++, k, NULL, v, first);
 	    first += 3;
 	    nval -= 3;
 	    if (nkeys > 32) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		kev = (deviceKeyStateNotify *) ev++; 
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		kev = (deviceKeyStateNotify *) ev++;
 		kev->type = DeviceKeyStateNotify;
 		kev->deviceid = dev->id;
-		memmove((char *) &kev->keys[0], (char *) &k->down[4], 28);
+		memmove((char *)&kev->keys[0], (char *)&k->down[4], 28);
 	    }
 	    if (nval > 0) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator(dev, (deviceValuator *) ev++, v, first);
 		first += 3;
 		nval -= 3;
 	    }
 	}
 
 	while (nval > 0) {
-	    FixDeviceStateNotify (dev, ev++, NULL, NULL, v, first);
+	    FixDeviceStateNotify(dev, ev++, NULL, NULL, v, first);
 	    first += 3;
 	    nval -= 3;
 	    if (nval > 0) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator(dev, (deviceValuator *) ev++, v, first);
 		first += 3;
 		nval -= 3;
 	    }
 	}
 
-	(void) DeliverEventsToWindow(pWin, (xEvent *)sev, evcount,
-	    DeviceStateNotifyMask, NullGrab, dev->id);
-	free (sev);
-        }
+	(void)DeliverEventsToWindow(pWin, (xEvent *) sev, evcount,
+				    DeviceStateNotifyMask, NullGrab, dev->id);
+	free(sev);
     }
+}
 
 int
-GrabButton(
-    ClientPtr client,
-    DeviceIntPtr dev,
-    BYTE this_device_mode,
-    BYTE other_devices_mode,
-    CARD16 modifiers,
-    DeviceIntPtr modifier_device,
-    CARD8 button,
-    Window grabWindow,
-    BOOL ownerEvents,
-    Cursor rcursor,
-    Window rconfineTo,
-    Mask eventMask)
+GrabButton(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
+	   BYTE other_devices_mode, CARD16 modifiers,
+	   DeviceIntPtr modifier_device, CARD8 button, Window grabWindow,
+	   BOOL ownerEvents, Cursor rcursor, Window rconfineTo, Mask eventMask)
 {
     WindowPtr pWin, confineTo;
     CursorPtr cursor;
     GrabPtr grab;
 
     if ((this_device_mode != GrabModeSync) &&
-	(this_device_mode != GrabModeAsync))
-    {
+	(this_device_mode != GrabModeAsync)) {
 	client->errorValue = this_device_mode;
-        return BadValue;
+	return BadValue;
     }
     if ((other_devices_mode != GrabModeSync) &&
-	(other_devices_mode != GrabModeAsync))
-    {
+	(other_devices_mode != GrabModeAsync)) {
 	client->errorValue = other_devices_mode;
-        return BadValue;
+	return BadValue;
     }
-    if ((modifiers != AnyModifier) &&
-	(modifiers & ~AllModifiersMask))
-    {
+    if ((modifiers != AnyModifier) && (modifiers & ~AllModifiersMask)) {
 	client->errorValue = modifiers;
 	return BadValue;
     }
-    if ((ownerEvents != xFalse) && (ownerEvents != xTrue))
-    {
+    if ((ownerEvents != xFalse) && (ownerEvents != xTrue)) {
 	client->errorValue = ownerEvents;
 	return BadValue;
     }
@@ -563,324 +512,266 @@ GrabButton(
 	return BadWindow;
     if (rconfineTo == None)
 	confineTo = NullWindow;
-    else
-    {
+    else {
 	confineTo = LookupWindow(rconfineTo, client);
 	if (!confineTo)
 	    return BadWindow;
     }
     if (rcursor == None)
 	cursor = NullCursor;
-    else
-    {
-	cursor = (CursorPtr)LookupIDByType(rcursor, RT_CURSOR);
-	if (!cursor)
-	{
+    else {
+	cursor = (CursorPtr) LookupIDByType(rcursor, RT_CURSOR);
+	if (!cursor) {
 	    client->errorValue = rcursor;
 	    return BadCursor;
 	}
     }
 
     grab = CreateGrab(client->index, dev, pWin, eventMask,
-	(Bool)ownerEvents, (Bool) this_device_mode, (Bool)other_devices_mode,
-	modifier_device, modifiers, DeviceButtonPress, button, confineTo, 
-	cursor);
+		      (Bool) ownerEvents, (Bool) this_device_mode,
+		      (Bool) other_devices_mode, modifier_device, modifiers,
+		      DeviceButtonPress, button, confineTo, cursor);
     if (!grab)
 	return BadAlloc;
     return AddPassiveGrabToList(grab);
-    }
+}
 
 int
-GrabKey(
-    ClientPtr client,
-    DeviceIntPtr dev,
-    BYTE this_device_mode,
-    BYTE other_devices_mode,
-    CARD16 modifiers,
-    DeviceIntPtr modifier_device,
-    CARD8 key,
-    Window grabWindow,
-    BOOL ownerEvents,
-    Mask mask)
+GrabKey(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
+	BYTE other_devices_mode, CARD16 modifiers,
+	DeviceIntPtr modifier_device, CARD8 key, Window grabWindow,
+	BOOL ownerEvents, Mask mask)
 {
     WindowPtr pWin;
     GrabPtr grab;
     KeyClassPtr k = dev->key;
 
-    if (k==NULL)
+    if (k == NULL)
 	return BadMatch;
     if ((other_devices_mode != GrabModeSync) &&
-	(other_devices_mode != GrabModeAsync))
-    {
+	(other_devices_mode != GrabModeAsync)) {
 	client->errorValue = other_devices_mode;
-        return BadValue;
+	return BadValue;
     }
     if ((this_device_mode != GrabModeSync) &&
-	(this_device_mode != GrabModeAsync))
-    {
+	(this_device_mode != GrabModeAsync)) {
 	client->errorValue = this_device_mode;
-        return BadValue;
+	return BadValue;
     }
-    if (((key > k->curKeySyms.maxKeyCode) || 
-	 (key < k->curKeySyms.minKeyCode))
-	&& (key != AnyKey))
-    {
+    if (((key > k->curKeySyms.maxKeyCode) || (key < k->curKeySyms.minKeyCode))
+	&& (key != AnyKey)) {
 	client->errorValue = key;
-        return BadValue;
+	return BadValue;
     }
-    if ((modifiers != AnyModifier) &&
-	(modifiers & ~AllModifiersMask))
-    {
+    if ((modifiers != AnyModifier) && (modifiers & ~AllModifiersMask)) {
 	client->errorValue = modifiers;
 	return BadValue;
     }
-    if ((ownerEvents != xTrue) && (ownerEvents != xFalse))
-    {
+    if ((ownerEvents != xTrue) && (ownerEvents != xFalse)) {
 	client->errorValue = ownerEvents;
-        return BadValue;
+	return BadValue;
     }
     pWin = LookupWindow(grabWindow, client);
     if (!pWin)
 	return BadWindow;
 
-    grab = CreateGrab(client->index, dev, pWin, 
-	mask, ownerEvents, this_device_mode, other_devices_mode, 
-	modifier_device, modifiers, DeviceKeyPress, key, NullWindow, 
-	NullCursor);
+    grab = CreateGrab(client->index, dev, pWin,
+		      mask, ownerEvents, this_device_mode, other_devices_mode,
+		      modifier_device, modifiers, DeviceKeyPress, key,
+		      NullWindow, NullCursor);
     if (!grab)
 	return BadAlloc;
     return AddPassiveGrabToList(grab);
-    }
+}
 
 int
-SelectForWindow(dev, pWin, client, mask, exclusivemasks, validmasks)
-	DeviceIntPtr dev;
-	WindowPtr pWin;
-	ClientPtr client;
-	Mask mask;
-	Mask exclusivemasks;
-	Mask validmasks;
+SelectForWindow(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client,
+		Mask mask, Mask exclusivemasks, Mask validmasks)
 {
     int mskidx = dev->id;
     int i, ret;
     Mask check;
     InputClientsPtr others;
 
-    if (mask & ~validmasks)
-    {
+    if (mask & ~validmasks) {
 	client->errorValue = mask;
 	return BadValue;
     }
     check = (mask & exclusivemasks);
-    if (wOtherInputMasks(pWin))
-	{
-	if (check & wOtherInputMasks(pWin)->inputEvents[mskidx])
-	    {			       /* It is illegal for two different
-				          clients to select on any of the
-				          events for maskcheck. However,
-				          it is OK, for some client to
-				          continue selecting on one of those
-				          events.  */
-	    for (others = wOtherInputMasks(pWin)->inputClients; others; 
-		others = others->next)
-	        {
-	        if (!SameClient(others, client) && (check & 
-		    others->mask[mskidx]))
+    if (wOtherInputMasks(pWin)) {
+	if (check & wOtherInputMasks(pWin)->inputEvents[mskidx]) {	/* It is illegal for two different
+									 * clients to select on any of the
+									 * events for maskcheck. However,
+									 * it is OK, for some client to
+									 * continue selecting on one of those
+									 * events.  */
+	    for (others = wOtherInputMasks(pWin)->inputClients; others;
+		 others = others->next) {
+		if (!SameClient(others, client) && (check &
+						    others->mask[mskidx]))
 		    return BadAccess;
-	        }
-            }
-	for (others = wOtherInputMasks(pWin)->inputClients; others; 
-		others = others->next)
-	    {
-	    if (SameClient(others, client))
-	        {
+	    }
+	}
+	for (others = wOtherInputMasks(pWin)->inputClients; others;
+	     others = others->next) {
+	    if (SameClient(others, client)) {
 		check = others->mask[mskidx];
 		others->mask[mskidx] = mask;
-		if (mask == 0)
-		    {
-		    for (i=0; i<EMASKSIZE; i++)
+		if (mask == 0) {
+		    for (i = 0; i < EMASKSIZE; i++)
 			if (i != mskidx && others->mask[i] != 0)
 			    break;
-		    if (i == EMASKSIZE)
-			{
+		    if (i == EMASKSIZE) {
 			RecalculateDeviceDeliverableEvents(pWin);
 			if (ShouldFreeInputMasks(pWin, FALSE))
 			    FreeResource(others->resource, RT_NONE);
-		        return Success;
-			}
+			return Success;
 		    }
+		}
 		goto maskSet;
-	        }
 	    }
 	}
+    }
     check = 0;
-    if ((ret = AddExtensionClient (pWin, client, mask, mskidx)) != Success)
+    if ((ret = AddExtensionClient(pWin, client, mask, mskidx)) != Success)
 	return ret;
-maskSet: 
+  maskSet:
     if (dev->valuator)
 	if ((dev->valuator->motionHintWindow == pWin) &&
 	    (mask & DevicePointerMotionHintMask) &&
-	    !(check & DevicePointerMotionHintMask) &&
-	    !dev->grab)
+	    !(check & DevicePointerMotionHintMask) && !dev->grab)
 	    dev->valuator->motionHintWindow = NullWindow;
     RecalculateDeviceDeliverableEvents(pWin);
     return Success;
 }
 
-int 
-AddExtensionClient (pWin, client, mask, mskidx)
-    WindowPtr pWin;
-    ClientPtr client;
-    Mask mask;
-    int mskidx;
-    {
+int
+AddExtensionClient(WindowPtr pWin, ClientPtr client, Mask mask, int mskidx)
+{
     InputClientsPtr others;
 
-    if (!pWin->optional && !MakeWindowOptional (pWin))
+    if (!pWin->optional && !MakeWindowOptional(pWin))
 	return BadAlloc;
     others = (InputClients *) malloc(sizeof(InputClients));
     if (!others)
 	return BadAlloc;
-    if (!pWin->optional->inputMasks && !MakeInputMasks (pWin))
+    if (!pWin->optional->inputMasks && !MakeInputMasks(pWin))
 	return BadAlloc;
-    bzero((char *) &others->mask[0], sizeof(Mask)*EMASKSIZE);
+    bzero((char *)&others->mask[0], sizeof(Mask) * EMASKSIZE);
     others->mask[mskidx] = mask;
     others->resource = FakeClientID(client->index);
     others->next = pWin->optional->inputMasks->inputClients;
     pWin->optional->inputMasks->inputClients = others;
-    if (!AddResource(others->resource, RT_INPUTCLIENT, (void *)pWin))
+    if (!AddResource(others->resource, RT_INPUTCLIENT, (void *) pWin))
 	return BadAlloc;
     return Success;
-    }
+}
 
 static Bool
-MakeInputMasks (pWin)
-    WindowPtr	pWin;
-    {
+MakeInputMasks(WindowPtr pWin)
+{
     struct _OtherInputMasks *imasks;
 
-    imasks = (struct _OtherInputMasks *) 
-	malloc (sizeof (struct _OtherInputMasks));
+    imasks = (struct _OtherInputMasks *)
+	malloc(sizeof(struct _OtherInputMasks));
     if (!imasks)
 	return FALSE;
-    bzero((char *) imasks, sizeof (struct _OtherInputMasks));
+    bzero((char *)imasks, sizeof(struct _OtherInputMasks));
     pWin->optional->inputMasks = imasks;
     return TRUE;
-    }
+}
 
 void
-RecalculateDeviceDeliverableEvents(pWin)
-    WindowPtr pWin;
-    {
+RecalculateDeviceDeliverableEvents(WindowPtr pWin)
+{
     register InputClientsPtr others;
-    struct _OtherInputMasks *inputMasks;   /* default: NULL */
+    struct _OtherInputMasks *inputMasks;	/* default: NULL */
     register WindowPtr pChild, tmp;
     int i;
 
     pChild = pWin;
-    while (1)
-	{
-	if ((inputMasks = wOtherInputMasks(pChild)) != 0)
-	    {
-	    for (others = inputMasks->inputClients; others; 
-		others = others->next)
-		{
-		for (i=0; i<EMASKSIZE; i++)
+    while (1) {
+	if ((inputMasks = wOtherInputMasks(pChild)) != 0) {
+	    for (others = inputMasks->inputClients; others;
+		 others = others->next) {
+		for (i = 0; i < EMASKSIZE; i++)
 		    inputMasks->inputEvents[i] |= others->mask[i];
-		}
-	    for (i=0; i<EMASKSIZE; i++)
+	    }
+	    for (i = 0; i < EMASKSIZE; i++)
 		inputMasks->deliverableEvents[i] = inputMasks->inputEvents[i];
-	    for (tmp = pChild->parent; tmp; tmp=tmp->parent)
+	    for (tmp = pChild->parent; tmp; tmp = tmp->parent)
 		if (wOtherInputMasks(tmp))
-		    for (i=0; i<EMASKSIZE; i++)
+		    for (i = 0; i < EMASKSIZE; i++)
 			inputMasks->deliverableEvents[i] |=
-			(wOtherInputMasks(tmp)->deliverableEvents[i] 
-			& ~inputMasks->dontPropagateMask[i] & PropagateMask[i]);
-	    }
-	if (pChild->firstChild)
-	    {
+			    (wOtherInputMasks(tmp)->deliverableEvents[i]
+			     & ~inputMasks->
+			     dontPropagateMask[i] & PropagateMask[i]);
+	}
+	if (pChild->firstChild) {
 	    pChild = pChild->firstChild;
 	    continue;
-	    }
+	}
 	while (!pChild->nextSib && (pChild != pWin))
 	    pChild = pChild->parent;
 	if (pChild == pWin)
 	    break;
 	pChild = pChild->nextSib;
-	}
     }
+}
 
 int
-InputClientGone(pWin, id)
-    register WindowPtr pWin;
-    XID   id;
-    {
+InputClientGone(register WindowPtr pWin, XID id)
+{
     register InputClientsPtr other, prev;
+
     if (!wOtherInputMasks(pWin))
-	return(Success);
+	return (Success);
     prev = 0;
-    for (other = wOtherInputMasks(pWin)->inputClients; other; 
-	other = other->next)
-	{
-	if (other->resource == id)
-	    {
-	    if (prev)
-		{
+    for (other = wOtherInputMasks(pWin)->inputClients; other;
+	 other = other->next) {
+	if (other->resource == id) {
+	    if (prev) {
 		prev->next = other->next;
 		free(other);
-		}
-	    else if (!(other->next))
-		{
-	        if (ShouldFreeInputMasks(pWin, TRUE))
-		    {
+	    } else if (!(other->next)) {
+		if (ShouldFreeInputMasks(pWin, TRUE)) {
 		    wOtherInputMasks(pWin)->inputClients = other->next;
 		    free(wOtherInputMasks(pWin));
 		    pWin->optional->inputMasks = (OtherInputMasks *) NULL;
-		    CheckWindowOptionalNeed (pWin);
+		    CheckWindowOptionalNeed(pWin);
 		    free(other);
-		    }
-		else
-		    {
+		} else {
 		    other->resource = FakeClientID(0);
-		    if (!AddResource(other->resource, RT_INPUTCLIENT, 
-			(void *)pWin))
+		    if (!AddResource(other->resource, RT_INPUTCLIENT,
+				     (void *) pWin))
 			return BadAlloc;
-		    }
 		}
-	    else
-		{
+	    } else {
 		wOtherInputMasks(pWin)->inputClients = other->next;
 		free(other);
-		}
-	    RecalculateDeviceDeliverableEvents(pWin);
-	    return(Success);
 	    }
+	    RecalculateDeviceDeliverableEvents(pWin);
+	    return (Success);
+	}
 	prev = other;
-        }
+    }
     FatalError("client not on device event list");
     /*NOTREACHED*/
-    }
+}
 
 int
-SendEvent (client, d, dest, propagate, ev, mask, count)
-    ClientPtr		client;
-    DeviceIntPtr	d;
-    Window		dest;
-    Bool		propagate;
-    xEvent		*ev;
-    Mask		mask;
-    int			count;
-    {
+SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
+	  xEvent * ev, Mask mask, int count)
+{
     WindowPtr pWin;
-    WindowPtr effectiveFocus = NullWindow; /* only set if dest==InputFocus */
-    WindowPtr spriteWin=GetSpriteWindow();
+    WindowPtr effectiveFocus = NullWindow;	/* only set if dest==InputFocus */
+    WindowPtr spriteWin = GetSpriteWindow();
 
     if (dest == PointerWindow)
 	pWin = spriteWin;
-    else if (dest == InputFocus)
-    {
+    else if (dest == InputFocus) {
 	WindowPtr inputFocus;
-	
+
 	if (!d->focus)
 	    inputFocus = spriteWin;
 	else
@@ -893,33 +784,27 @@ SendEvent (client, d, dest, propagate, ev, mask, count)
 	    return Success;
 
 	/* If the input focus is PointerRootWin, send the event to where
-	the pointer is if possible, then perhaps propogate up to root. */
-   	if (inputFocus == PointerRootWin)
+	 * the pointer is if possible, then perhaps propogate up to root. */
+	if (inputFocus == PointerRootWin)
 	    inputFocus = GetCurrentRootWindow();
 
-	if (IsParent(inputFocus, spriteWin))
-	{
+	if (IsParent(inputFocus, spriteWin)) {
 	    effectiveFocus = inputFocus;
 	    pWin = spriteWin;
-	}
-	else
+	} else
 	    effectiveFocus = pWin = inputFocus;
-    }
-    else
+    } else
 	pWin = LookupWindow(dest, client);
     if (!pWin)
 	return BadWindow;
-    if ((propagate != xFalse) && (propagate != xTrue))
-    {
+    if ((propagate != xFalse) && (propagate != xTrue)) {
 	client->errorValue = propagate;
 	return BadValue;
     }
     ev->u.u.type |= 0x80;
-    if (propagate)
-    {
-	for (;pWin; pWin = pWin->parent)
-	{
-	    if (DeliverEventsToWindow( pWin, ev, count, mask, NullGrab, d->id))
+    if (propagate) {
+	for (; pWin; pWin = pWin->parent) {
+	    if (DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, d->id))
 		return Success;
 	    if (pWin == effectiveFocus)
 		return Success;
@@ -928,158 +813,140 @@ SendEvent (client, d, dest, propagate, ev, mask, count)
 	    if (!mask)
 		break;
 	}
-    }
-    else
-	(void)(DeliverEventsToWindow( pWin, ev, count, mask, NullGrab, d->id));
+    } else
+	(void)(DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, d->id));
     return Success;
-    }
+}
 
 int
-SetButtonMapping (client, dev, nElts, map)
-    ClientPtr client;
-    DeviceIntPtr dev;
-    int nElts;
-    BYTE *map;
-    {
+SetButtonMapping(ClientPtr client, DeviceIntPtr dev, int nElts, BYTE * map)
+{
     register int i;
     ButtonClassPtr b = dev->button;
 
     if (b == NULL)
 	return BadMatch;
 
-    if (nElts != b->numButtons)
-    {
+    if (nElts != b->numButtons) {
 	client->errorValue = nElts;
 	return BadValue;
     }
     if (BadDeviceMap(&map[0], nElts, 1, 255, &client->errorValue))
 	return BadValue;
-    for (i=0; i < nElts; i++)
-	if ((b->map[i + 1] != map[i]) &&
-		BitIsOn(b->down, i + 1))
-    	    return MappingBusy;
+    for (i = 0; i < nElts; i++)
+	if ((b->map[i + 1] != map[i]) && BitIsOn(b->down, i + 1))
+	    return MappingBusy;
     for (i = 0; i < nElts; i++)
 	b->map[i + 1] = map[i];
     return Success;
-    }
+}
 
-int 
-SetModifierMapping(client, dev, len, rlen, numKeyPerModifier, inputMap, k)
-    ClientPtr client;
-    DeviceIntPtr dev;
-    int len;
-    int rlen;
-    int numKeyPerModifier;
-    KeyCode *inputMap;
-    KeyClassPtr *k;
+int
+SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
+		   int numKeyPerModifier, KeyCode * inputMap, KeyClassPtr * k)
 {
     KeyCode *map = NULL;
     int inputMapLen;
     register int i;
-    
+
     *k = dev->key;
     if (*k == NULL)
 	return BadMatch;
-    if (len != ((numKeyPerModifier<<1) + rlen))
+    if (len != ((numKeyPerModifier << 1) + rlen))
 	return BadLength;
 
-    inputMapLen = 8*numKeyPerModifier;
+    inputMapLen = 8 * numKeyPerModifier;
 
     /*
-     *	Now enforce the restriction that "all of the non-zero keycodes must be
-     *	in the range specified by min-keycode and max-keycode in the
-     *	connection setup (else a Value error)"
+     *  Now enforce the restriction that "all of the non-zero keycodes must be
+     *  in the range specified by min-keycode and max-keycode in the
+     *  connection setup (else a Value error)"
      */
     i = inputMapLen;
     while (i--) {
 	if (inputMap[i]
 	    && (inputMap[i] < (*k)->curKeySyms.minKeyCode
 		|| inputMap[i] > (*k)->curKeySyms.maxKeyCode)) {
-		client->errorValue = inputMap[i];
-		return -1; /* BadValue collides with MappingFailed */
-		}
+	    client->errorValue = inputMap[i];
+	    return -1;	/* BadValue collides with MappingFailed */
+	}
     }
 
     /*
-     *	Now enforce the restriction that none of the old or new
-     *	modifier keys may be down while we change the mapping,  and
-     *	that the DDX layer likes the choice.
+     *  Now enforce the restriction that none of the old or new
+     *  modifier keys may be down while we change the mapping,  and
+     *  that the DDX layer likes the choice.
      */
-    if (!AllModifierKeysAreUp (dev, (*k)->modifierKeyMap, 
-	(int)(*k)->maxKeysPerModifier, inputMap, (int)numKeyPerModifier)
-	    ||
-	!AllModifierKeysAreUp(dev, inputMap, (int)numKeyPerModifier,
-	      (*k)->modifierKeyMap, (int)(*k)->maxKeysPerModifier)) {
+    if (!AllModifierKeysAreUp(dev, (*k)->modifierKeyMap,
+			      (int)(*k)->maxKeysPerModifier, inputMap,
+			      (int)numKeyPerModifier)
+	|| !AllModifierKeysAreUp(dev, inputMap, (int)numKeyPerModifier,
+				 (*k)->modifierKeyMap,
+				 (int)(*k)->maxKeysPerModifier)) {
 	return MappingBusy;
     } else {
 	for (i = 0; i < inputMapLen; i++) {
-	    if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr)dev)) {
+	    if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr) dev)) {
 		return MappingFailed;
 	    }
 	}
     }
 
     /*
-     *	Now build the keyboard's modifier bitmap from the
-     *	list of keycodes.
+     *  Now build the keyboard's modifier bitmap from the
+     *  list of keycodes.
      */
     if (inputMapLen) {
-	map = (KeyCode *)malloc(inputMapLen);
-        if (!map)
-            return BadAlloc;
+	map = (KeyCode *) malloc(inputMapLen);
+	if (!map)
+	    return BadAlloc;
     }
     if ((*k)->modifierKeyMap)
-        free((*k)->modifierKeyMap);
+	free((*k)->modifierKeyMap);
     if (inputMapLen) {
-        (*k)->modifierKeyMap = map;
-        memmove((char *)(*k)->modifierKeyMap, (char *)inputMap, inputMapLen);
+	(*k)->modifierKeyMap = map;
+	memmove((char *)(*k)->modifierKeyMap, (char *)inputMap, inputMapLen);
     } else
 	(*k)->modifierKeyMap = NULL;
 
     (*k)->maxKeysPerModifier = numKeyPerModifier;
     for (i = 0; i < MAP_LENGTH; i++)
-        (*k)->modifierMap[i] = 0;
-    for (i = 0; i < inputMapLen; i++) if (inputMap[i]) {
-        (*k)->modifierMap[inputMap[i]]
-          |= (1<<(i/ (*k)->maxKeysPerModifier));
-    }
+	(*k)->modifierMap[i] = 0;
+    for (i = 0; i < inputMapLen; i++)
+	if (inputMap[i]) {
+	    (*k)->modifierMap[inputMap[i]]
+		|= (1 << (i / (*k)->maxKeysPerModifier));
+	}
 
-    return(MappingSuccess);
-    }
+    return (MappingSuccess);
+}
 
 void
-SendDeviceMappingNotify(
-    CARD8 request,
-    KeyCode firstKeyCode,
-    CARD8 count,
-    DeviceIntPtr dev)
+SendDeviceMappingNotify(CARD8 request,
+			KeyCode firstKeyCode, CARD8 count, DeviceIntPtr dev)
 {
     xEvent event;
-    deviceMappingNotify         *ev = (deviceMappingNotify *) &event;
+    deviceMappingNotify *ev = (deviceMappingNotify *) & event;
 
     ev->type = DeviceMappingNotify;
     ev->request = request;
     ev->deviceid = dev->id;
     ev->time = currentTime.milliseconds;
-    if (request == MappingKeyboard)
-	{
+    if (request == MappingKeyboard) {
 	ev->firstKeyCode = firstKeyCode;
 	ev->count = count;
-	}
-
-    SendEventToAllWindows (dev, DeviceMappingNotifyMask, (xEvent *)ev, 1);
     }
 
+    SendEventToAllWindows(dev, DeviceMappingNotifyMask, (xEvent *) ev, 1);
+}
+
 int
-ChangeKeyMapping(
-    ClientPtr 	client,
-    DeviceIntPtr dev,
-    unsigned 	len,
-    int 	type,
-    KeyCode 	firstKeyCode,
-    CARD8 	keyCodes,
-    CARD8 	keySymsPerKeyCode,
-    KeySym	*map)
+ChangeKeyMapping(ClientPtr client,
+		 DeviceIntPtr dev,
+		 unsigned len,
+		 int type,
+		 KeyCode firstKeyCode,
+		 CARD8 keyCodes, CARD8 keySymsPerKeyCode, KeySym * map)
 {
     KeySymsRec keysyms;
     KeyClassPtr k = dev->key;
@@ -1088,18 +955,16 @@ ChangeKeyMapping(
 	return (BadMatch);
 
     if (len != (keyCodes * keySymsPerKeyCode))
-            return BadLength;
+	return BadLength;
 
     if ((firstKeyCode < k->curKeySyms.minKeyCode) ||
-	(firstKeyCode + keyCodes - 1 > k->curKeySyms.maxKeyCode))
-    {
-	    client->errorValue = firstKeyCode;
-	    return BadValue;
+	(firstKeyCode + keyCodes - 1 > k->curKeySyms.maxKeyCode)) {
+	client->errorValue = firstKeyCode;
+	return BadValue;
     }
-    if (keySymsPerKeyCode == 0)
-    {
-	    client->errorValue = 0;
-            return BadValue;
+    if (keySymsPerKeyCode == 0) {
+	client->errorValue = 0;
+	return BadValue;
     }
     keysyms.minKeyCode = firstKeyCode;
     keysyms.maxKeyCode = firstKeyCode + keyCodes - 1;
@@ -1107,195 +972,169 @@ ChangeKeyMapping(
     keysyms.map = map;
     if (!SetKeySymsMap(&k->curKeySyms, &keysyms))
 	return BadAlloc;
-    SendDeviceMappingNotify(MappingKeyboard, firstKeyCode, keyCodes,
-	dev);
+    SendDeviceMappingNotify(MappingKeyboard, firstKeyCode, keyCodes, dev);
     return client->noClientException;
-    }
+}
 
 void
-DeleteWindowFromAnyExtEvents(pWin, freeResources)
-    WindowPtr		pWin;
-    Bool		freeResources;
-    {
-    int			i;
-    DeviceIntPtr	dev;
-    InputClientsPtr	ic;
+DeleteWindowFromAnyExtEvents(WindowPtr pWin, Bool freeResources)
+{
+    int i;
+    DeviceIntPtr dev;
+    InputClientsPtr ic;
     struct _OtherInputMasks *inputMasks;
 
-    for (dev=inputInfo.devices; dev; dev=dev->next)
-	{
-	if (dev == inputInfo.pointer ||
-	    dev == inputInfo.keyboard)
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+	if (dev == inputInfo.pointer || dev == inputInfo.keyboard)
 	    continue;
 	DeleteDeviceFromAnyExtEvents(pWin, dev);
-	}
+    }
 
-    for (dev=inputInfo.off_devices; dev; dev=dev->next)
+    for (dev = inputInfo.off_devices; dev; dev = dev->next)
 	DeleteDeviceFromAnyExtEvents(pWin, dev);
 
     if (freeResources)
-	while ((inputMasks = wOtherInputMasks(pWin)) != 0)
-	    {
+	while ((inputMasks = wOtherInputMasks(pWin)) != 0) {
 	    ic = inputMasks->inputClients;
-	    for (i=0; i<EMASKSIZE; i++)
+	    for (i = 0; i < EMASKSIZE; i++)
 		inputMasks->dontPropagateMask[i] = 0;
 	    FreeResource(ic->resource, RT_NONE);
-	    }
-    }
+	}
+}
 
 void
-DeleteDeviceFromAnyExtEvents(pWin, dev)
-    WindowPtr		pWin;
-    DeviceIntPtr	dev;
-    {
-    WindowPtr		parent;
+DeleteDeviceFromAnyExtEvents(WindowPtr pWin, DeviceIntPtr dev)
+{
+    WindowPtr parent;
 
     /* Deactivate any grabs performed on this window, before making
-	any input focus changes.
-        Deactivating a device grab should cause focus events. */
+     * any input focus changes.
+     * Deactivating a device grab should cause focus events. */
 
     if (dev->grab && (dev->grab->window == pWin))
-	(*dev->DeactivateGrab)(dev);
+	(*dev->DeactivateGrab) (dev);
 
     /* If the focus window is a root window (ie. has no parent) 
-	then don't delete the focus from it. */
-    
-    if (dev->focus && (pWin==dev->focus->win) && (pWin->parent != NullWindow))
-	{
+     * then don't delete the focus from it. */
+
+    if (dev->focus && (pWin == dev->focus->win) && (pWin->parent != NullWindow)) {
 	int focusEventMode = NotifyNormal;
 
- 	/* If a grab is in progress, then alter the mode of focus events. */
+	/* If a grab is in progress, then alter the mode of focus events. */
 
 	if (dev->grab)
 	    focusEventMode = NotifyWhileGrabbed;
 
-	switch (dev->focus->revert)
-	    {
-	    case RevertToNone:
+	switch (dev->focus->revert) {
+	case RevertToNone:
+	    DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
+	    dev->focus->win = NoneWin;
+	    dev->focus->traceGood = 0;
+	    break;
+	case RevertToParent:
+	    parent = pWin;
+	    do {
+		parent = parent->parent;
+		dev->focus->traceGood--;
+	    }
+	    while (!parent->realized);
+	    DoFocusEvents(dev, pWin, parent, focusEventMode);
+	    dev->focus->win = parent;
+	    dev->focus->revert = RevertToNone;
+	    break;
+	case RevertToPointerRoot:
+	    DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
+	    dev->focus->win = PointerRootWin;
+	    dev->focus->traceGood = 0;
+	    break;
+	case RevertToFollowKeyboard:
+	    if (inputInfo.keyboard->focus->win) {
+		DoFocusEvents(dev, pWin, inputInfo.keyboard->focus->win,
+			      focusEventMode);
+		dev->focus->win = FollowKeyboardWin;
+		dev->focus->traceGood = 0;
+	    } else {
 		DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
 		dev->focus->win = NoneWin;
 		dev->focus->traceGood = 0;
-		break;
-	    case RevertToParent:
-		parent = pWin;
-		do
-		    {
-		    parent = parent->parent;
-		    dev->focus->traceGood--;
-		    } while (!parent->realized);
-		DoFocusEvents(dev, pWin, parent, focusEventMode);
-		dev->focus->win = parent;
-		dev->focus->revert = RevertToNone;
-		break;
-	    case RevertToPointerRoot:
-		DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
-		dev->focus->win = PointerRootWin;
-		dev->focus->traceGood = 0;
-		break;
-	    case RevertToFollowKeyboard:
-		if (inputInfo.keyboard->focus->win) {
-		    DoFocusEvents(dev, pWin, inputInfo.keyboard->focus->win,
-				  focusEventMode);
-		    dev->focus->win = FollowKeyboardWin;
-		    dev->focus->traceGood = 0;
-		} else {
-		    DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
-		    dev->focus->win = NoneWin;
-		    dev->focus->traceGood = 0;
-		}
-		break;
 	    }
+	    break;
 	}
+    }
 
     if (dev->valuator)
 	if (dev->valuator->motionHintWindow == pWin)
 	    dev->valuator->motionHintWindow = NullWindow;
-    }
+}
 
 int
-MaybeSendDeviceMotionNotifyHint (pEvents, mask)
-    deviceKeyButtonPointer *pEvents;
-    Mask mask;
-    {
+MaybeSendDeviceMotionNotifyHint(deviceKeyButtonPointer * pEvents, Mask mask)
+{
     DeviceIntPtr dev;
 
-    dev = LookupDeviceIntRec (pEvents->deviceid & DEVICE_BITS);
-    if (pEvents->type == DeviceMotionNotify)
-	{
-	if (mask & DevicePointerMotionHintMask)
-	    {
-	    if (WID(dev->valuator->motionHintWindow) == pEvents->event)
-		{
-		return 1; /* don't send, but pretend we did */
-		}
-	    pEvents->detail = NotifyHint;
+    dev = LookupDeviceIntRec(pEvents->deviceid & DEVICE_BITS);
+    if (pEvents->type == DeviceMotionNotify) {
+	if (mask & DevicePointerMotionHintMask) {
+	    if (WID(dev->valuator->motionHintWindow) == pEvents->event) {
+		return 1;	/* don't send, but pretend we did */
 	    }
-	 else
-	    {
+	    pEvents->detail = NotifyHint;
+	} else {
 	    pEvents->detail = NotifyNormal;
-	    }
 	}
-    return (0);
     }
+    return (0);
+}
 
 void
-CheckDeviceGrabAndHintWindow (pWin, type, xE, grab, client, deliveryMask)
-    WindowPtr pWin;
-    int type;
-    deviceKeyButtonPointer *xE;
-    GrabPtr grab;
-    ClientPtr client;
-    Mask deliveryMask;
-    {
+CheckDeviceGrabAndHintWindow(WindowPtr pWin, int type,
+			     deviceKeyButtonPointer * xE, GrabPtr grab,
+			     ClientPtr client, Mask deliveryMask)
+{
     DeviceIntPtr dev;
 
-    dev = LookupDeviceIntRec (xE->deviceid & DEVICE_BITS);
+    dev = LookupDeviceIntRec(xE->deviceid & DEVICE_BITS);
     if (type == DeviceMotionNotify)
 	dev->valuator->motionHintWindow = pWin;
-    else if ((type == DeviceButtonPress) && (!grab) && 
-	(deliveryMask & DeviceButtonGrabMask))
-        {
+    else if ((type == DeviceButtonPress) && (!grab) &&
+	     (deliveryMask & DeviceButtonGrabMask)) {
 	GrabRec tempGrab;
 
 	tempGrab.device = dev;
 	tempGrab.resource = client->clientAsMask;
 	tempGrab.window = pWin;
-	tempGrab.ownerEvents = (deliveryMask & DeviceOwnerGrabButtonMask) ? TRUE : FALSE;
+	tempGrab.ownerEvents =
+	    (deliveryMask & DeviceOwnerGrabButtonMask) ? TRUE : FALSE;
 	tempGrab.eventMask = deliveryMask;
 	tempGrab.keyboardMode = GrabModeAsync;
 	tempGrab.pointerMode = GrabModeAsync;
 	tempGrab.confineTo = NullWindow;
 	tempGrab.cursor = NullCursor;
-	(*dev->ActivateGrab)(dev, &tempGrab, currentTime, TRUE);
-        }
+	(*dev->ActivateGrab) (dev, &tempGrab, currentTime, TRUE);
     }
+}
 
 Mask
-DeviceEventMaskForClient(dev, pWin, client)
-    DeviceIntPtr	dev;
-    WindowPtr		pWin;
-    ClientPtr		client;
-    {
+DeviceEventMaskForClient(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
+{
     register InputClientsPtr other;
 
     if (!wOtherInputMasks(pWin))
 	return 0;
-    for (other = wOtherInputMasks(pWin)->inputClients; other; 
-	other = other->next)
-	{
+    for (other = wOtherInputMasks(pWin)->inputClients; other;
+	 other = other->next) {
 	if (SameClient(other, client))
 	    return other->mask[dev->id];
-	}
-    return 0;
     }
+    return 0;
+}
 
 void
-MaybeStopDeviceHint(dev, client)
-    register DeviceIntPtr dev;
-    ClientPtr client;
+MaybeStopDeviceHint(register DeviceIntPtr dev, ClientPtr client)
 {
     WindowPtr pWin;
     GrabPtr grab = dev->grab;
+
     pWin = dev->valuator->motionHintWindow;
 
     if ((grab && SameClient(grab, client) &&
@@ -1310,54 +1149,45 @@ MaybeStopDeviceHint(dev, client)
 }
 
 int
-DeviceEventSuppressForWindow(pWin, client, mask, maskndx)
-	WindowPtr pWin;
-	ClientPtr client;
-	Mask mask;
-	int maskndx;
-    {
-    struct _OtherInputMasks *inputMasks = wOtherInputMasks (pWin);
+DeviceEventSuppressForWindow(WindowPtr pWin, ClientPtr client, Mask mask,
+			     int maskndx)
+{
+    struct _OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
 
-    if (mask & ~PropagateMask[maskndx])
-	{
+    if (mask & ~PropagateMask[maskndx]) {
 	client->errorValue = mask;
 	return BadValue;
-	}
+    }
 
-    if (mask == 0) 
-	{
+    if (mask == 0) {
 	if (inputMasks)
 	    inputMasks->dontPropagateMask[maskndx] = mask;
-	} 
-    else 
-	{
+    } else {
 	if (!inputMasks)
-	    AddExtensionClient (pWin, client, 0, 0);
+	    AddExtensionClient(pWin, client, 0, 0);
 	inputMasks = wOtherInputMasks(pWin);
 	inputMasks->dontPropagateMask[maskndx] = mask;
-	}
+    }
     RecalculateDeviceDeliverableEvents(pWin);
     if (ShouldFreeInputMasks(pWin, FALSE))
-        FreeResource(inputMasks->inputClients->resource, RT_NONE);
+	FreeResource(inputMasks->inputClients->resource, RT_NONE);
     return Success;
-    }
+}
 
 static Bool
-ShouldFreeInputMasks (pWin, ignoreSelectedEvents)
-    WindowPtr pWin;
-    Bool ignoreSelectedEvents;
-    {
+ShouldFreeInputMasks(WindowPtr pWin, Bool ignoreSelectedEvents)
+{
     int i;
     Mask allInputEventMasks = 0;
-    struct _OtherInputMasks *inputMasks = wOtherInputMasks (pWin);
+    struct _OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
 
-    for (i=0; i<EMASKSIZE; i++)
+    for (i = 0; i < EMASKSIZE; i++)
 	allInputEventMasks |= inputMasks->dontPropagateMask[i];
     if (!ignoreSelectedEvents)
-	for (i=0; i<EMASKSIZE; i++)
+	for (i = 0; i < EMASKSIZE; i++)
 	    allInputEventMasks |= inputMasks->inputEvents[i];
     if (allInputEventMasks == 0)
 	return TRUE;
     else
 	return FALSE;
-    }
+}