1 files changed, 353 insertions, 393 deletions

diff --git a/nx-X11/programs/Xserver/Xi/extinit.c b/nx-X11/programs/Xserver/Xi/extinit.c
index d0052b1fb..a50552cfe 100644
--- a/nx-X11/programs/Xserver/Xi/extinit.c
+++ b/nx-X11/programs/Xserver/Xi/extinit.c
@@ -60,8 +60,8 @@ SOFTWARE.
 #include <nx-X11/X.h>
 #include <nx-X11/Xproto.h>
 #include "inputstr.h"
-#include "gcstruct.h"   		/* pointer for extnsionst.h*/
-#include "extnsionst.h"			/* extension entry   */
+#include "gcstruct.h"	/* pointer for extnsionst.h */
+#include "extnsionst.h"	/* extension entry   */
 #include <nx-X11/extensions/XI.h>
 #include <nx-X11/extensions/XIproto.h>
 
@@ -111,35 +111,37 @@ SOFTWARE.
 #include "ungrdevb.h"
 #include "ungrdevk.h"
 
-static Mask 	lastExtEventMask = 1;
-int  		ExtEventIndex;
-Mask		ExtValidMasks[EMASKSIZE];
-Mask		ExtExclusiveMasks[EMASKSIZE];
+static Mask lastExtEventMask = 1;
+int ExtEventIndex;
+Mask ExtValidMasks[EMASKSIZE];
+Mask ExtExclusiveMasks[EMASKSIZE];
 
-struct  dev_type
+struct dev_type
+{
+    Atom type;
+    char *name;
+} dev_type[] = {
     {
-    Atom	type;
-    char	*name;
-    }dev_type [] = {{0,XI_KEYBOARD},
-	    {0,XI_MOUSE},
-	    {0,XI_TABLET},
-	    {0,XI_TOUCHSCREEN},
-	    {0,XI_TOUCHPAD},
-	    {0,XI_BARCODE},
-	    {0,XI_BUTTONBOX},
-	    {0,XI_KNOB_BOX},
-	    {0,XI_ONE_KNOB},
-	    {0,XI_NINE_KNOB},
-	    {0,XI_TRACKBALL},
-	    {0,XI_QUADRATURE},
-	    {0,XI_ID_MODULE},
-	    {0,XI_SPACEBALL},
-	    {0,XI_DATAGLOVE},
-	    {0,XI_EYETRACKER},
-	    {0,XI_CURSORKEYS},
-	    {0,XI_FOOTMOUSE}};
-
-CARD8  event_base [numInputClasses];
+    0, XI_KEYBOARD}, {
+    0, XI_MOUSE}, {
+    0, XI_TABLET}, {
+    0, XI_TOUCHSCREEN}, {
+    0, XI_TOUCHPAD}, {
+    0, XI_BARCODE}, {
+    0, XI_BUTTONBOX}, {
+    0, XI_KNOB_BOX}, {
+    0, XI_ONE_KNOB}, {
+    0, XI_NINE_KNOB}, {
+    0, XI_TRACKBALL}, {
+    0, XI_QUADRATURE}, {
+    0, XI_ID_MODULE}, {
+    0, XI_SPACEBALL}, {
+    0, XI_DATAGLOVE}, {
+    0, XI_EYETRACKER}, {
+    0, XI_CURSORKEYS}, {
+0, XI_FOOTMOUSE}};
+
+CARD8 event_base[numInputClasses];
 XExtEventInfo EventInfo[32];
 
 /*****************************************************************
@@ -148,40 +150,40 @@ XExtEventInfo EventInfo[32];
  *
  */
 
-int 	IReqCode = 0;
-int	BadDevice = 0;
-int	BadEvent = 1;
-int	BadMode = 2;
-int	DeviceBusy = 3;
-int	BadClass = 4;
-
-Mask	DevicePointerMotionMask;
-Mask	DevicePointerMotionHintMask;
-Mask	DeviceFocusChangeMask;
-Mask	DeviceStateNotifyMask;
-Mask	ChangeDeviceNotifyMask;
-Mask	DeviceMappingNotifyMask;
-Mask	DeviceOwnerGrabButtonMask;
-Mask	DeviceButtonGrabMask;
-Mask	DeviceButtonMotionMask;
-
-int	DeviceValuator;
-int	DeviceKeyPress;
-int	DeviceKeyRelease;
-int	DeviceButtonPress;
-int	DeviceButtonRelease;
-int	DeviceMotionNotify;
-int	DeviceFocusIn;
-int	DeviceFocusOut;
-int	ProximityIn;
-int	ProximityOut;
-int	DeviceStateNotify;
-int	DeviceKeyStateNotify;
-int	DeviceButtonStateNotify;
-int	DeviceMappingNotify;
-int	ChangeDeviceNotify;
-
-int	RT_INPUTCLIENT;
+int IReqCode = 0;
+int BadDevice = 0;
+int BadEvent = 1;
+int BadMode = 2;
+int DeviceBusy = 3;
+int BadClass = 4;
+
+Mask DevicePointerMotionMask;
+Mask DevicePointerMotionHintMask;
+Mask DeviceFocusChangeMask;
+Mask DeviceStateNotifyMask;
+Mask ChangeDeviceNotifyMask;
+Mask DeviceMappingNotifyMask;
+Mask DeviceOwnerGrabButtonMask;
+Mask DeviceButtonGrabMask;
+Mask DeviceButtonMotionMask;
+
+int DeviceValuator;
+int DeviceKeyPress;
+int DeviceKeyRelease;
+int DeviceButtonPress;
+int DeviceButtonRelease;
+int DeviceMotionNotify;
+int DeviceFocusIn;
+int DeviceFocusOut;
+int ProximityIn;
+int ProximityOut;
+int DeviceStateNotify;
+int DeviceKeyStateNotify;
+int DeviceButtonStateNotify;
+int DeviceMappingNotify;
+int ChangeDeviceNotify;
+
+int RT_INPUTCLIENT;
 
 /*****************************************************************
  *
@@ -189,9 +191,9 @@ int	RT_INPUTCLIENT;
  *
  */
 
-extern	XExtensionVersion	AllExtensionVersions[];
+extern XExtensionVersion AllExtensionVersions[];
 
-Mask	PropagateMask[MAX_DEVICES];
+Mask PropagateMask[MAX_DEVICES];
 
 /*****************************************************************
  *
@@ -203,7 +205,7 @@ static	XExtensionVersion	thisversion =
 					{XI_Present, 
 					 SERVER_XI_MAJOR_VERSION,
 					 SERVER_XI_MINOR_VERSION,
-					};
+};
 
 /**********************************************************************
  *
@@ -217,20 +219,19 @@ static	XExtensionVersion	thisversion =
  */
 
 void
-XInputExtensionInit()
+XInputExtensionInit(void)
 {
     ExtensionEntry *extEntry;
 
     extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,
-		   SProcIDispatch, IResetProc, StandardMinorOpcode);
-    if (extEntry)
-        {
+			    SProcIDispatch, IResetProc, StandardMinorOpcode);
+    if (extEntry) {
 	IReqCode = extEntry->base;
-	AllExtensionVersions[IReqCode-128] = thisversion;
-	MakeDeviceTypeAtoms ();
-	RT_INPUTCLIENT = CreateNewResourceType((DeleteType)InputClientGone);
-	FixExtensionEvents (extEntry);
-	ReplySwapVector[IReqCode] = (ReplySwapPtr)SReplyIDispatch;
+	AllExtensionVersions[IReqCode - 128] = thisversion;
+	MakeDeviceTypeAtoms();
+	RT_INPUTCLIENT = CreateNewResourceType((DeleteType) InputClientGone);
+	FixExtensionEvents(extEntry);
+	ReplySwapVector[IReqCode] = (ReplySwapPtr) SReplyIDispatch;
 	EventSwapVector[DeviceValuator] = SEventIDispatch;
 	EventSwapVector[DeviceKeyPress] = SEventIDispatch;
 	EventSwapVector[DeviceKeyRelease] = SEventIDispatch;
@@ -246,12 +247,10 @@ XInputExtensionInit()
 	EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
 	EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
 	EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
-	}
-    else 
-	{
+    } else {
 	FatalError("IExtensionInit: AddExtensions failed\n");
-	}
     }
+}
 
 /*************************************************************************
  *
@@ -261,86 +260,84 @@ XInputExtensionInit()
  */
 
 int
-ProcIDispatch (client)
-    register ClientPtr client;
+ProcIDispatch(register ClientPtr client)
 {
     REQUEST(xReq);
     if (stuff->data == X_GetExtensionVersion)
-	return(ProcXGetExtensionVersion(client));
+	return (ProcXGetExtensionVersion(client));
     if (stuff->data == X_ListInputDevices)
-	return(ProcXListInputDevices(client));
+	return (ProcXListInputDevices(client));
     else if (stuff->data == X_OpenDevice)
-        return(ProcXOpenDevice(client));
+	return (ProcXOpenDevice(client));
     else if (stuff->data == X_CloseDevice)
-        return(ProcXCloseDevice(client));
+	return (ProcXCloseDevice(client));
     else if (stuff->data == X_SetDeviceMode)
-	return(ProcXSetDeviceMode(client));
+	return (ProcXSetDeviceMode(client));
     else if (stuff->data == X_SelectExtensionEvent)
-	return(ProcXSelectExtensionEvent(client));
+	return (ProcXSelectExtensionEvent(client));
     else if (stuff->data == X_GetSelectedExtensionEvents)
-        return(ProcXGetSelectedExtensionEvents(client));
+	return (ProcXGetSelectedExtensionEvents(client));
     else if (stuff->data == X_ChangeDeviceDontPropagateList)
-        return(ProcXChangeDeviceDontPropagateList(client));
+	return (ProcXChangeDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceDontPropagateList)
-        return(ProcXGetDeviceDontPropagateList(client));
+	return (ProcXGetDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceMotionEvents)
-	return(ProcXGetDeviceMotionEvents(client));
+	return (ProcXGetDeviceMotionEvents(client));
     else if (stuff->data == X_ChangeKeyboardDevice)
-	return(ProcXChangeKeyboardDevice(client));
+	return (ProcXChangeKeyboardDevice(client));
     else if (stuff->data == X_ChangePointerDevice)
-	return(ProcXChangePointerDevice(client));
+	return (ProcXChangePointerDevice(client));
     else if (stuff->data == X_GrabDevice)
-	return(ProcXGrabDevice(client));
+	return (ProcXGrabDevice(client));
     else if (stuff->data == X_UngrabDevice)
-	return(ProcXUngrabDevice(client));
+	return (ProcXUngrabDevice(client));
     else if (stuff->data == X_GrabDeviceKey)
-	return(ProcXGrabDeviceKey(client));
+	return (ProcXGrabDeviceKey(client));
     else if (stuff->data == X_UngrabDeviceKey)
-	return(ProcXUngrabDeviceKey(client));
+	return (ProcXUngrabDeviceKey(client));
     else if (stuff->data == X_GrabDeviceButton)
-	return(ProcXGrabDeviceButton(client));
+	return (ProcXGrabDeviceButton(client));
     else if (stuff->data == X_UngrabDeviceButton)
-	return(ProcXUngrabDeviceButton(client));
+	return (ProcXUngrabDeviceButton(client));
     else if (stuff->data == X_AllowDeviceEvents)
-        return(ProcXAllowDeviceEvents(client));
+	return (ProcXAllowDeviceEvents(client));
     else if (stuff->data == X_GetDeviceFocus)
-	return(ProcXGetDeviceFocus(client));
+	return (ProcXGetDeviceFocus(client));
     else if (stuff->data == X_SetDeviceFocus)
-	return(ProcXSetDeviceFocus(client));
+	return (ProcXSetDeviceFocus(client));
     else if (stuff->data == X_GetFeedbackControl)
-	return(ProcXGetFeedbackControl(client));
+	return (ProcXGetFeedbackControl(client));
     else if (stuff->data == X_ChangeFeedbackControl)
-	return(ProcXChangeFeedbackControl(client));
+	return (ProcXChangeFeedbackControl(client));
     else if (stuff->data == X_GetDeviceKeyMapping)
-        return(ProcXGetDeviceKeyMapping(client));
+	return (ProcXGetDeviceKeyMapping(client));
     else if (stuff->data == X_ChangeDeviceKeyMapping)
-        return(ProcXChangeDeviceKeyMapping(client));
+	return (ProcXChangeDeviceKeyMapping(client));
     else if (stuff->data == X_GetDeviceModifierMapping)
-        return(ProcXGetDeviceModifierMapping(client));
+	return (ProcXGetDeviceModifierMapping(client));
     else if (stuff->data == X_SetDeviceModifierMapping)
-        return(ProcXSetDeviceModifierMapping(client));
+	return (ProcXSetDeviceModifierMapping(client));
     else if (stuff->data == X_GetDeviceButtonMapping)
-        return(ProcXGetDeviceButtonMapping(client));
+	return (ProcXGetDeviceButtonMapping(client));
     else if (stuff->data == X_SetDeviceButtonMapping)
-        return(ProcXSetDeviceButtonMapping(client));
+	return (ProcXSetDeviceButtonMapping(client));
     else if (stuff->data == X_QueryDeviceState)
-        return(ProcXQueryDeviceState(client));
+	return (ProcXQueryDeviceState(client));
     else if (stuff->data == X_SendExtensionEvent)
-        return(ProcXSendExtensionEvent(client));
+	return (ProcXSendExtensionEvent(client));
     else if (stuff->data == X_DeviceBell)
-        return(ProcXDeviceBell(client));
+	return (ProcXDeviceBell(client));
     else if (stuff->data == X_SetDeviceValuators)
-        return(ProcXSetDeviceValuators(client));
+	return (ProcXSetDeviceValuators(client));
     else if (stuff->data == X_GetDeviceControl)
-        return(ProcXGetDeviceControl(client));
+	return (ProcXGetDeviceControl(client));
     else if (stuff->data == X_ChangeDeviceControl)
-        return(ProcXChangeDeviceControl(client));
-    else
-        {
+	return (ProcXChangeDeviceControl(client));
+    else {
 	SendErrorToClient(client, IReqCode, stuff->data, 0, BadRequest);
-        }
-    return(BadRequest);
     }
+    return (BadRequest);
+}
 
 /*******************************************************************************
  *
@@ -352,86 +349,84 @@ ProcIDispatch (client)
  */
 
 int
-SProcIDispatch(client)
-    register ClientPtr client;
+SProcIDispatch(register ClientPtr client)
 {
     REQUEST(xReq);
     if (stuff->data == X_GetExtensionVersion)
-	return(SProcXGetExtensionVersion(client));
+	return (SProcXGetExtensionVersion(client));
     if (stuff->data == X_ListInputDevices)
-	return(SProcXListInputDevices(client));
+	return (SProcXListInputDevices(client));
     else if (stuff->data == X_OpenDevice)
-        return(SProcXOpenDevice(client));
+	return (SProcXOpenDevice(client));
     else if (stuff->data == X_CloseDevice)
-        return(SProcXCloseDevice(client));
+	return (SProcXCloseDevice(client));
     else if (stuff->data == X_SetDeviceMode)
-	return(SProcXSetDeviceMode(client));
+	return (SProcXSetDeviceMode(client));
     else if (stuff->data == X_SelectExtensionEvent)
-	return(SProcXSelectExtensionEvent(client));
+	return (SProcXSelectExtensionEvent(client));
     else if (stuff->data == X_GetSelectedExtensionEvents)
-        return(SProcXGetSelectedExtensionEvents(client));
+	return (SProcXGetSelectedExtensionEvents(client));
     else if (stuff->data == X_ChangeDeviceDontPropagateList)
-        return(SProcXChangeDeviceDontPropagateList(client));
+	return (SProcXChangeDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceDontPropagateList)
-        return(SProcXGetDeviceDontPropagateList(client));
+	return (SProcXGetDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceMotionEvents)
-	return(SProcXGetDeviceMotionEvents(client));
+	return (SProcXGetDeviceMotionEvents(client));
     else if (stuff->data == X_ChangeKeyboardDevice)
-	return(SProcXChangeKeyboardDevice(client));
+	return (SProcXChangeKeyboardDevice(client));
     else if (stuff->data == X_ChangePointerDevice)
-	return(SProcXChangePointerDevice(client));
+	return (SProcXChangePointerDevice(client));
     else if (stuff->data == X_GrabDevice)
-	return(SProcXGrabDevice(client));
+	return (SProcXGrabDevice(client));
     else if (stuff->data == X_UngrabDevice)
-	return(SProcXUngrabDevice(client));
+	return (SProcXUngrabDevice(client));
     else if (stuff->data == X_GrabDeviceKey)
-	return(SProcXGrabDeviceKey(client));
+	return (SProcXGrabDeviceKey(client));
     else if (stuff->data == X_UngrabDeviceKey)
-	return(SProcXUngrabDeviceKey(client));
+	return (SProcXUngrabDeviceKey(client));
     else if (stuff->data == X_GrabDeviceButton)
-	return(SProcXGrabDeviceButton(client));
+	return (SProcXGrabDeviceButton(client));
     else if (stuff->data == X_UngrabDeviceButton)
-	return(SProcXUngrabDeviceButton(client));
+	return (SProcXUngrabDeviceButton(client));
     else if (stuff->data == X_AllowDeviceEvents)
-        return(SProcXAllowDeviceEvents(client));
+	return (SProcXAllowDeviceEvents(client));
     else if (stuff->data == X_GetDeviceFocus)
-	return(SProcXGetDeviceFocus(client));
+	return (SProcXGetDeviceFocus(client));
     else if (stuff->data == X_SetDeviceFocus)
-	return(SProcXSetDeviceFocus(client));
+	return (SProcXSetDeviceFocus(client));
     else if (stuff->data == X_GetFeedbackControl)
-	return(SProcXGetFeedbackControl(client));
+	return (SProcXGetFeedbackControl(client));
     else if (stuff->data == X_ChangeFeedbackControl)
-	return(SProcXChangeFeedbackControl(client));
+	return (SProcXChangeFeedbackControl(client));
     else if (stuff->data == X_GetDeviceKeyMapping)
-        return(SProcXGetDeviceKeyMapping(client));
+	return (SProcXGetDeviceKeyMapping(client));
     else if (stuff->data == X_ChangeDeviceKeyMapping)
-        return(SProcXChangeDeviceKeyMapping(client));
+	return (SProcXChangeDeviceKeyMapping(client));
     else if (stuff->data == X_GetDeviceModifierMapping)
-        return(SProcXGetDeviceModifierMapping(client));
+	return (SProcXGetDeviceModifierMapping(client));
     else if (stuff->data == X_SetDeviceModifierMapping)
-        return(SProcXSetDeviceModifierMapping(client));
+	return (SProcXSetDeviceModifierMapping(client));
     else if (stuff->data == X_GetDeviceButtonMapping)
-        return(SProcXGetDeviceButtonMapping(client));
+	return (SProcXGetDeviceButtonMapping(client));
     else if (stuff->data == X_SetDeviceButtonMapping)
-        return(SProcXSetDeviceButtonMapping(client));
+	return (SProcXSetDeviceButtonMapping(client));
     else if (stuff->data == X_QueryDeviceState)
-        return(SProcXQueryDeviceState(client));
+	return (SProcXQueryDeviceState(client));
     else if (stuff->data == X_SendExtensionEvent)
-        return(SProcXSendExtensionEvent(client));
+	return (SProcXSendExtensionEvent(client));
     else if (stuff->data == X_DeviceBell)
-        return(SProcXDeviceBell(client));
+	return (SProcXDeviceBell(client));
     else if (stuff->data == X_SetDeviceValuators)
-        return(SProcXSetDeviceValuators(client));
+	return (SProcXSetDeviceValuators(client));
     else if (stuff->data == X_GetDeviceControl)
-        return(SProcXGetDeviceControl(client));
+	return (SProcXGetDeviceControl(client));
     else if (stuff->data == X_ChangeDeviceControl)
-        return(SProcXChangeDeviceControl(client));
-    else
-        {
+	return (SProcXChangeDeviceControl(client));
+    else {
 	SendErrorToClient(client, IReqCode, stuff->data, 0, BadRequest);
-        }
-    return(BadRequest);
     }
+    return (BadRequest);
+}
 
 /**********************************************************************
  *
@@ -446,58 +441,69 @@ SProcIDispatch(client)
 	SRepX##code (client, len, (x##code##Reply *) rep)
 
 void
-SReplyIDispatch (client, len, rep)
-    ClientPtr		client;
-    int			len;
-    xGrabDeviceReply	*rep;		/* All we look at is the type field */
-{					/* This is common to all replies    */
+SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
+					/* All we look at is the type field */
+{	/* This is common to all replies    */
     if (rep->RepType == X_GetExtensionVersion)
-	SRepXGetExtensionVersion (client, len, (xGetExtensionVersionReply *)rep);
+	SRepXGetExtensionVersion(client, len,
+				 (xGetExtensionVersionReply *) rep);
     else if (rep->RepType == X_ListInputDevices)
-	SRepXListInputDevices (client, len, (xListInputDevicesReply *)rep);
+	SRepXListInputDevices(client, len, (xListInputDevicesReply *) rep);
     else if (rep->RepType == X_OpenDevice)
-	SRepXOpenDevice (client, len, (xOpenDeviceReply *)rep);
+	SRepXOpenDevice(client, len, (xOpenDeviceReply *) rep);
     else if (rep->RepType == X_SetDeviceMode)
-	SRepXSetDeviceMode (client, len, (xSetDeviceModeReply *) rep);
+	SRepXSetDeviceMode(client, len, (xSetDeviceModeReply *) rep);
     else if (rep->RepType == X_GetSelectedExtensionEvents)
-	SRepXGetSelectedExtensionEvents (client, len, (xGetSelectedExtensionEventsReply *) rep);
+	SRepXGetSelectedExtensionEvents(client, len,
+					(xGetSelectedExtensionEventsReply *)
+					rep);
     else if (rep->RepType == X_GetDeviceDontPropagateList)
-	SRepXGetDeviceDontPropagateList (client, len, (xGetDeviceDontPropagateListReply *)rep);
+	SRepXGetDeviceDontPropagateList(client, len,
+					(xGetDeviceDontPropagateListReply *)
+					rep);
     else if (rep->RepType == X_GetDeviceMotionEvents)
-	SRepXGetDeviceMotionEvents (client, len, (xGetDeviceMotionEventsReply *) rep);
+	SRepXGetDeviceMotionEvents(client, len,
+				   (xGetDeviceMotionEventsReply *) rep);
     else if (rep->RepType == X_ChangeKeyboardDevice)
-	SRepXChangeKeyboardDevice (client, len, (xChangeKeyboardDeviceReply *) rep);
+	SRepXChangeKeyboardDevice(client, len,
+				  (xChangeKeyboardDeviceReply *) rep);
     else if (rep->RepType == X_ChangePointerDevice)
-	SRepXChangePointerDevice (client, len, (xChangePointerDeviceReply *)rep);
+	SRepXChangePointerDevice(client, len,
+				 (xChangePointerDeviceReply *) rep);
     else if (rep->RepType == X_GrabDevice)
-	SRepXGrabDevice (client, len, (xGrabDeviceReply *)rep);
+	SRepXGrabDevice(client, len, (xGrabDeviceReply *) rep);
     else if (rep->RepType == X_GetDeviceFocus)
-	SRepXGetDeviceFocus (client, len, (xGetDeviceFocusReply *)rep);
+	SRepXGetDeviceFocus(client, len, (xGetDeviceFocusReply *) rep);
     else if (rep->RepType == X_GetFeedbackControl)
-	SRepXGetFeedbackControl (client, len, (xGetFeedbackControlReply *)rep);
+	SRepXGetFeedbackControl(client, len, (xGetFeedbackControlReply *) rep);
     else if (rep->RepType == X_GetDeviceKeyMapping)
-	SRepXGetDeviceKeyMapping (client, len, (xGetDeviceKeyMappingReply *)rep);
+	SRepXGetDeviceKeyMapping(client, len,
+				 (xGetDeviceKeyMappingReply *) rep);
     else if (rep->RepType == X_GetDeviceModifierMapping)
-	SRepXGetDeviceModifierMapping (client, len, (xGetDeviceModifierMappingReply *)rep);
+	SRepXGetDeviceModifierMapping(client, len,
+				      (xGetDeviceModifierMappingReply *) rep);
     else if (rep->RepType == X_SetDeviceModifierMapping)
-	SRepXSetDeviceModifierMapping (client, len, (xSetDeviceModifierMappingReply *)rep);
+	SRepXSetDeviceModifierMapping(client, len,
+				      (xSetDeviceModifierMappingReply *) rep);
     else if (rep->RepType == X_GetDeviceButtonMapping)
-	SRepXGetDeviceButtonMapping (client, len, (xGetDeviceButtonMappingReply *)rep);
+	SRepXGetDeviceButtonMapping(client, len,
+				    (xGetDeviceButtonMappingReply *) rep);
     else if (rep->RepType == X_SetDeviceButtonMapping)
-	SRepXSetDeviceButtonMapping (client, len, (xSetDeviceButtonMappingReply *)rep);
+	SRepXSetDeviceButtonMapping(client, len,
+				    (xSetDeviceButtonMappingReply *) rep);
     else if (rep->RepType == X_QueryDeviceState)
-	SRepXQueryDeviceState (client, len, (xQueryDeviceStateReply *)rep);
+	SRepXQueryDeviceState(client, len, (xQueryDeviceStateReply *) rep);
     else if (rep->RepType == X_SetDeviceValuators)
-	SRepXSetDeviceValuators (client, len, (xSetDeviceValuatorsReply *)rep);
+	SRepXSetDeviceValuators(client, len, (xSetDeviceValuatorsReply *) rep);
     else if (rep->RepType == X_GetDeviceControl)
-	SRepXGetDeviceControl (client, len, (xGetDeviceControlReply *)rep);
+	SRepXGetDeviceControl(client, len, (xGetDeviceControlReply *) rep);
     else if (rep->RepType == X_ChangeDeviceControl)
-	SRepXChangeDeviceControl (client, len, (xChangeDeviceControlReply *)rep);
-    else
-	{
-	    FatalError("XINPUT confused sending swapped reply");
-	}
+	SRepXChangeDeviceControl(client, len,
+				 (xChangeDeviceControlReply *) rep);
+    else {
+	FatalError("XINPUT confused sending swapped reply");
     }
+}
 
 /*****************************************************************************
  *
@@ -508,68 +514,51 @@ SReplyIDispatch (client, len, rep)
 #define DO_SWAP(func,type) func ((type *)from, (type *)to)
 
 void
-SEventIDispatch (from, to)
-    xEvent	*from;
-    xEvent	*to;
+SEventIDispatch(xEvent * from, xEvent * to)
 {
-    int		type = from->u.u.type & 0177;
+    int type = from->u.u.type & 0177;
 
     if (type == DeviceValuator)
 	DO_SWAP(SEventDeviceValuator, deviceValuator);
-    else if (type == DeviceKeyPress)
-	{
-        SKeyButtonPtrEvent (from, to);
+    else if (type == DeviceKeyPress) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceKeyRelease)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceKeyRelease) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceButtonPress)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceButtonPress) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceButtonRelease)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceButtonRelease) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceMotionNotify)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceMotionNotify) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceFocusIn)
-        DO_SWAP(SEventFocus, deviceFocus);
+    } else if (type == DeviceFocusIn)
+	DO_SWAP(SEventFocus, deviceFocus);
     else if (type == DeviceFocusOut)
-        DO_SWAP(SEventFocus, deviceFocus);
-    else if (type == ProximityIn)
-	{
-        SKeyButtonPtrEvent (from, to);
+	DO_SWAP(SEventFocus, deviceFocus);
+    else if (type == ProximityIn) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == ProximityOut)
-	{ 
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == ProximityOut) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceStateNotify)
-        DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
+    } else if (type == DeviceStateNotify)
+	DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
     else if (type == DeviceKeyStateNotify)
-        DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
+	DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
     else if (type == DeviceButtonStateNotify)
-        DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
+	DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
     else if (type == DeviceMappingNotify)
-        DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
+	DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
     else if (type == ChangeDeviceNotify)
-        DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
-    else
-	{
+	DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
+    else {
 	FatalError("XInputExtension: Impossible event!\n");
-	}
     }
+}
 
 /************************************************************************
  *
@@ -578,11 +567,9 @@ SEventIDispatch (from, to)
  */
 
 void
-SEventDeviceValuator (from, to)
-    deviceValuator	*from;
-    deviceValuator	*to;
-    {
-    register int	i;
+SEventDeviceValuator(deviceValuator * from, deviceValuator * to)
+{
+    register int i;
     INT32 *ip B32;
 
     *to = *from;
@@ -591,76 +578,65 @@ SEventDeviceValuator (from, to)
     ip = &to->valuator0;
     for (i=0; i<6; i++)
 	{
-        swapl((ip+i));	/* macro - braces are required	    */
-	}
+	swapl((ip + i));	/* macro - braces are required      */
     }
+}
 
 void
-SEventFocus (from, to)
-    deviceFocus	*from;
-    deviceFocus	*to;
+SEventFocus(deviceFocus * from, deviceFocus * to)
 {
     *to = *from;
     swaps(&to->sequenceNumber);
     swapl(&to->time);
     swapl(&to->window);
-    }
+}
 
 void
-SDeviceStateNotifyEvent (from, to)
-    deviceStateNotify	*from;
-    deviceStateNotify	*to;
+SDeviceStateNotifyEvent(deviceStateNotify * from, deviceStateNotify * to)
 {
-    register int	i;
+    register int i;
     INT32 *ip B32;
 
     *to = *from;
     swaps(&to->sequenceNumber);
     swapl(&to->time);
     ip = &to->valuator0;
-    for (i=0; i<3; i++)
-	{
-        swapl((ip+i));	/* macro - braces are required	    */
-	}
+    for (i = 0; i < 3; i++) {
+	swapl((ip + i));	/* macro - braces are required      */
     }
+}
 
 void
-SDeviceKeyStateNotifyEvent (from, to)
-    deviceKeyStateNotify	*from;
-    deviceKeyStateNotify	*to;
+SDeviceKeyStateNotifyEvent(deviceKeyStateNotify * from,
+			   deviceKeyStateNotify * to)
 {
     *to = *from;
     swaps(&to->sequenceNumber);
-    }
+}
 
 void
-SDeviceButtonStateNotifyEvent (from, to)
-    deviceButtonStateNotify	*from;
-    deviceButtonStateNotify	*to;
+SDeviceButtonStateNotifyEvent(deviceButtonStateNotify * from,
+			      deviceButtonStateNotify * to)
 {
     *to = *from;
     swaps(&to->sequenceNumber);
-    }
+}
 
 void
-SChangeDeviceNotifyEvent (from, to)
-    changeDeviceNotify	*from;
-    changeDeviceNotify	*to;
+SChangeDeviceNotifyEvent(changeDeviceNotify * from, changeDeviceNotify * to)
 {
     *to = *from;
     swaps(&to->sequenceNumber);
     swapl(&to->time);
-    }
+}
 
 void
-SDeviceMappingNotifyEvent (from, to)
-    deviceMappingNotify	*from;
-    deviceMappingNotify	*to;
+SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
 {
     *to = *from;
     swaps(&to->sequenceNumber);
     swapl(&to->time);
-    }
+}
 
 /************************************************************************
  *
@@ -669,25 +645,24 @@ SDeviceMappingNotifyEvent (from, to)
  */
 
 void
-FixExtensionEvents (extEntry)
-    ExtensionEntry 	*extEntry;
+FixExtensionEvents(ExtensionEntry * extEntry)
 {
-    Mask		mask;
-
-    DeviceValuator  	    = extEntry->eventBase;
-    DeviceKeyPress   	    = DeviceValuator + 1;
-    DeviceKeyRelease 	    = DeviceKeyPress + 1;
-    DeviceButtonPress       = DeviceKeyRelease + 1;
-    DeviceButtonRelease     = DeviceButtonPress + 1;
-    DeviceMotionNotify      = DeviceButtonRelease + 1;
-    DeviceFocusIn  	    = DeviceMotionNotify + 1;
-    DeviceFocusOut	    = DeviceFocusIn + 1;
-    ProximityIn  	    = DeviceFocusOut + 1;
-    ProximityOut  	    = ProximityIn + 1;
-    DeviceStateNotify  	    = ProximityOut + 1;
-    DeviceMappingNotify     = DeviceStateNotify + 1;
-    ChangeDeviceNotify      = DeviceMappingNotify + 1;
-    DeviceKeyStateNotify    = ChangeDeviceNotify + 1;
+    Mask mask;
+
+    DeviceValuator = extEntry->eventBase;
+    DeviceKeyPress = DeviceValuator + 1;
+    DeviceKeyRelease = DeviceKeyPress + 1;
+    DeviceButtonPress = DeviceKeyRelease + 1;
+    DeviceButtonRelease = DeviceButtonPress + 1;
+    DeviceMotionNotify = DeviceButtonRelease + 1;
+    DeviceFocusIn = DeviceMotionNotify + 1;
+    DeviceFocusOut = DeviceFocusIn + 1;
+    ProximityIn = DeviceFocusOut + 1;
+    ProximityOut = ProximityIn + 1;
+    DeviceStateNotify = ProximityOut + 1;
+    DeviceMappingNotify = DeviceStateNotify + 1;
+    ChangeDeviceNotify = DeviceMappingNotify + 1;
+    DeviceKeyStateNotify = ChangeDeviceNotify + 1;
     DeviceButtonStateNotify = DeviceKeyStateNotify + 1;
 
     event_base[KeyClass] = DeviceKeyPress;
@@ -703,66 +678,66 @@ FixExtensionEvents (extEntry)
     DeviceBusy += extEntry->errorBase;
     BadClass += extEntry->errorBase;
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceKeyPress);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceKeyPress);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceKeyRelease);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceKeyRelease);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceButtonPress);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceButtonPress);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceButtonRelease);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceButtonRelease);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, ProximityIn);
-    SetMaskForExtEvent (mask, ProximityOut);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, ProximityIn);
+    SetMaskForExtEvent(mask, ProximityOut);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
+    mask = GetNextExtEventMask();
     DeviceStateNotifyMask = mask;
-    SetMaskForExtEvent (mask, DeviceStateNotify);
+    SetMaskForExtEvent(mask, DeviceStateNotify);
 
-    mask = GetNextExtEventMask ();
+    mask = GetNextExtEventMask();
     DevicePointerMotionMask = mask;
-    SetMaskForExtEvent (mask, DeviceMotionNotify);
-    AllowPropagateSuppress (mask);
+    SetMaskForExtEvent(mask, DeviceMotionNotify);
+    AllowPropagateSuppress(mask);
 
     DevicePointerMotionHintMask = GetNextExtEventMask();
-    SetEventInfo (DevicePointerMotionHintMask, _devicePointerMotionHint);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton1Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton2Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton3Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton4Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton5Motion);
+    SetEventInfo(DevicePointerMotionHintMask, _devicePointerMotionHint);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton1Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton2Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton3Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton4Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton5Motion);
     DeviceButtonMotionMask = GetNextExtEventMask();
-    SetEventInfo (DeviceButtonMotionMask, _deviceButtonMotion);
+    SetEventInfo(DeviceButtonMotionMask, _deviceButtonMotion);
 
-    DeviceFocusChangeMask = GetNextExtEventMask ();
-    SetMaskForExtEvent (DeviceFocusChangeMask, DeviceFocusIn);
-    SetMaskForExtEvent (DeviceFocusChangeMask, DeviceFocusOut);
+    DeviceFocusChangeMask = GetNextExtEventMask();
+    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusIn);
+    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusOut);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceMappingNotify);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceMappingNotify);
     DeviceMappingNotifyMask = mask;
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, ChangeDeviceNotify);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, ChangeDeviceNotify);
     ChangeDeviceNotifyMask = mask;
 
     DeviceButtonGrabMask = GetNextExtEventMask();
-    SetEventInfo (DeviceButtonGrabMask, _deviceButtonGrab);
-    SetExclusiveAccess (DeviceButtonGrabMask);
+    SetEventInfo(DeviceButtonGrabMask, _deviceButtonGrab);
+    SetExclusiveAccess(DeviceButtonGrabMask);
 
     DeviceOwnerGrabButtonMask = GetNextExtEventMask();
-    SetEventInfo (DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
-    SetEventInfo (0, _noExtensionEvent);
-    }
+    SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
+    SetEventInfo(0, _noExtensionEvent);
+}
 
 /************************************************************************
  *
@@ -772,19 +747,18 @@ FixExtensionEvents (extEntry)
  */
 
 void
-RestoreExtensionEvents ()
+RestoreExtensionEvents(void)
 {
-    int	i;
+    int i;
 
     IReqCode = 0;
 
-    for (i=0; i<ExtEventIndex-1; i++)
-	{
+    for (i = 0; i < ExtEventIndex - 1; i++) {
 	if ((EventInfo[i].type >= LASTEvent) && (EventInfo[i].type < 128))
-	    SetMaskForEvent(0,EventInfo[i].type);
-        EventInfo[i].mask = 0;
-        EventInfo[i].type = 0;
-	}
+	    SetMaskForEvent(0, EventInfo[i].type);
+	EventInfo[i].mask = 0;
+	EventInfo[i].type = 0;
+    }
     ExtEventIndex = 0;
     lastExtEventMask = 1;
     DeviceValuator = 0;
@@ -809,7 +783,7 @@ RestoreExtensionEvents ()
     DeviceBusy = 3;
     BadClass = 4;
 
-    }
+}
 
 /***********************************************************************
  *
@@ -820,9 +794,8 @@ RestoreExtensionEvents ()
  */
 
 void
-IResetProc(unused)
-    ExtensionEntry *unused;
-    {
+IResetProc(ExtensionEntry * unused)
+{
 
     ReplySwapVector[IReqCode] = ReplyNotSwappd;
     EventSwapVector[DeviceValuator] = NotImplemented;
@@ -840,8 +813,8 @@ IResetProc(unused)
     EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
     EventSwapVector[DeviceMappingNotify] = NotImplemented;
     EventSwapVector[ChangeDeviceNotify] = NotImplemented;
-    RestoreExtensionEvents ();
-    }
+    RestoreExtensionEvents();
+}
 
 /***********************************************************************
  *
@@ -849,16 +822,13 @@ IResetProc(unused)
  *
  */
 
-void
-AssignTypeAndName (dev, type, name)
-    DeviceIntPtr dev;
-    Atom type;
-    char *name;
+ void
+AssignTypeAndName(DeviceIntPtr dev, Atom type, char *name)
 {
     dev->type = type;
-    dev->name = (char *) malloc(strlen(name)+1);
-    strcpy (dev->name, name);
-    }
+    dev->name = (char *)malloc(strlen(name) + 1);
+    strcpy(dev->name, name);
+}
 
 /***********************************************************************
  *
@@ -867,14 +837,14 @@ AssignTypeAndName (dev, type, name)
  */
 
 void
-MakeDeviceTypeAtoms ()
-    {
+MakeDeviceTypeAtoms(void)
+{
     int i;
 
-    for (i=0; i<NUMTYPES; i++)
-	dev_type[i].type = 
-		MakeAtom (dev_type[i].name, strlen(dev_type[i].name), 1);
-    }
+    for (i = 0; i < NUMTYPES; i++)
+	dev_type[i].type =
+	    MakeAtom(dev_type[i].name, strlen(dev_type[i].name), 1);
+}
 
 /**************************************************************************
  *
@@ -884,22 +854,19 @@ MakeDeviceTypeAtoms ()
  */
 
 DeviceIntPtr
-LookupDeviceIntRec (
-    CARD8 id)
+LookupDeviceIntRec(CARD8 id)
 {
     DeviceIntPtr dev;
 
-    for (dev=inputInfo.devices; dev; dev=dev->next)
-	{
-	if (dev->id == id)
-	    {
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+	if (dev->id == id) {
 	    if (id == inputInfo.pointer->id || id == inputInfo.keyboard->id)
 		return (NULL);
 	    return (dev);
-	    }
 	}
-    return (NULL);
     }
+    return (NULL);
+}
 
 /**************************************************************************
  *
@@ -910,14 +877,13 @@ LookupDeviceIntRec (
  */
 
 void
-SetExclusiveAccess (mask)
-    Mask mask;
-    {
+SetExclusiveAccess(Mask mask)
+{
     int i;
 
-    for (i=0; i<MAX_DEVICES; i++)
+    for (i = 0; i < MAX_DEVICES; i++)
 	ExtExclusiveMasks[i] |= mask;
-    }
+}
 
 /**************************************************************************
  *
@@ -927,14 +893,13 @@ SetExclusiveAccess (mask)
  */
 
 void
-AllowPropagateSuppress (mask)
-    Mask mask;
-    {
+AllowPropagateSuppress(Mask mask)
+{
     int i;
 
-    for (i=0; i<MAX_DEVICES; i++)
+    for (i = 0; i < MAX_DEVICES; i++)
 	PropagateMask[i] |= mask;
-    }
+}
 
 /**************************************************************************
  *
@@ -942,22 +907,21 @@ AllowPropagateSuppress (mask)
  *
  */
 
-Mask 
-GetNextExtEventMask ()
-    {
+Mask
+GetNextExtEventMask(void)
+{
     int i;
     Mask mask = lastExtEventMask;
 
-    if (lastExtEventMask == 0)
-	{
+    if (lastExtEventMask == 0) {
 	FatalError("GetNextExtEventMask: no more events are available.");
-	}
+    }
     lastExtEventMask <<= 1;
 
-    for (i=0; i<MAX_DEVICES; i++)
+    for (i = 0; i < MAX_DEVICES; i++)
 	ExtValidMasks[i] |= mask;
     return mask;
-    }
+}
 
 /**************************************************************************
  *
@@ -966,18 +930,16 @@ GetNextExtEventMask ()
  */
 
 void
-SetMaskForExtEvent(mask, event)
-    Mask mask;
-    int event;
-    {
+SetMaskForExtEvent(Mask mask, int event)
+{
 
     EventInfo[ExtEventIndex].mask = mask;
     EventInfo[ExtEventIndex++].type = event;
 
     if ((event < LASTEvent) || (event >= 128))
 	FatalError("MaskForExtensionEvent: bogus event number");
-    SetMaskForEvent(mask,event);
-    }
+    SetMaskForEvent(mask, event);
+}
 
 /**************************************************************************
  *
@@ -993,10 +955,8 @@ SetMaskForExtEvent(mask, event)
  */
 
 void
-SetEventInfo(mask, constant)
-    Mask mask;
-    int constant;
-    {
+SetEventInfo(Mask mask, int constant)
+{
     EventInfo[ExtEventIndex].mask = mask;
     EventInfo[ExtEventIndex++].type = constant;
-    }
+}