summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/XAllowDv.c25
-rw-r--r--src/XChgDCtl.c100
-rw-r--r--src/XChgFCtl.c114
-rw-r--r--src/XChgKMap.c28
-rw-r--r--src/XChgKbd.c25
-rw-r--r--src/XChgPnt.c29
-rw-r--r--src/XChgProp.c33
-rw-r--r--src/XCloseDev.c21
-rw-r--r--src/XDevBell.c25
-rw-r--r--src/XExtInt.c971
-rw-r--r--src/XExtToWire.c753
-rw-r--r--src/XFreeLst.c13
-rw-r--r--src/XGMotion.c88
-rw-r--r--src/XGetBMap.c36
-rw-r--r--src/XGetDCtl.c146
-rw-r--r--src/XGetFCtl.c337
-rw-r--r--src/XGetKMap.c36
-rw-r--r--src/XGetMMap.c37
-rw-r--r--src/XGetProp.c74
-rw-r--r--src/XGetVers.c54
-rw-r--r--src/XGrDvBut.c42
-rw-r--r--src/XGrDvKey.c47
-rw-r--r--src/XGrabDev.c44
-rw-r--r--src/XGtFocus.c19
-rw-r--r--src/XGtSelect.c91
-rw-r--r--src/XIint.h14
-rw-r--r--src/XListDev.c265
-rw-r--r--src/XOpenDev.c59
-rw-r--r--src/XQueryDv.c212
-rw-r--r--src/XSelect.c32
-rw-r--r--src/XSetBMap.c28
-rw-r--r--src/XSetDVal.c37
-rw-r--r--src/XSetMMap.c31
-rw-r--r--src/XSetMode.c27
-rw-r--r--src/XSndExEv.c66
-rw-r--r--src/XStFocus.c26
-rw-r--r--src/XUngrDev.c16
-rw-r--r--src/XUngrDvB.c20
-rw-r--r--src/XUngrDvK.c22
39 files changed, 1992 insertions, 2051 deletions
diff --git a/src/XAllowDv.c b/src/XAllowDv.c
index d745046..94a27ca 100644
--- a/src/XAllowDv.c
+++ b/src/XAllowDv.c
@@ -61,20 +61,20 @@ SOFTWARE.
#include "XIint.h"
int
-XAllowDeviceEvents (dpy, dev, event_mode, time)
- register Display *dpy;
- XDevice *dev;
- int event_mode;
- Time time;
- {
- xAllowDeviceEventsReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XAllowDeviceEvents(dpy, dev, event_mode, time)
+ register Display *dpy;
+ XDevice *dev;
+ int event_mode;
+ Time time;
+{
+ xAllowDeviceEventsReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(AllowDeviceEvents,req);
+ GetReq(AllowDeviceEvents, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_AllowDeviceEvents;
req->deviceid = dev->device_id;
@@ -84,5 +84,4 @@ XAllowDeviceEvents (dpy, dev, event_mode, time)
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
-
+}
diff --git a/src/XChgDCtl.c b/src/XChgDCtl.c
index b1fd7a1..be5d941 100644
--- a/src/XChgDCtl.c
+++ b/src/XChgDCtl.c
@@ -62,69 +62,65 @@ SOFTWARE.
#include "XIint.h"
int
-XChangeDeviceControl (dpy, dev, control, d)
- register Display *dpy;
- XDevice *dev;
- int control;
- XDeviceControl *d;
- {
+XChangeDeviceControl(dpy, dev, control, d)
+ register Display *dpy;
+ XDevice *dev;
+ int control;
+ XDeviceControl *d;
+{
int length;
- xChangeDeviceControlReq *req;
- xChangeDeviceControlReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ xChangeDeviceControlReq *req;
+ xChangeDeviceControlReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Add_XChangeDeviceControl) == -1)
return (NoSuchExtension);
- GetReq(ChangeDeviceControl,req);
+ GetReq(ChangeDeviceControl, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ChangeDeviceControl;
req->deviceid = dev->device_id;
req->control = control;
- switch (control)
- {
- case DEVICE_RESOLUTION:
- {
- XDeviceResolutionControl *R;
- xDeviceResolutionCtl r;
-
- R = (XDeviceResolutionControl *) d;
- r.control = DEVICE_RESOLUTION;
- r.length = sizeof (xDeviceResolutionCtl) +
- R->num_valuators * sizeof(int);
- r.first_valuator = R->first_valuator;
- r.num_valuators = R->num_valuators;
- req->length += ((unsigned)(r.length + 3) >> 2);
- length = sizeof (xDeviceResolutionCtl);
- Data (dpy, (char *) &r, length);
- length = r.num_valuators * sizeof(int);
- Data (dpy, (char *) R->resolutions, length);
- if (! _XReply (dpy, (xReply *) &rep, 0, xTrue))
- {
- UnlockDisplay(dpy);
- SyncHandle();
- return (NoSuchExtension);
- }
- else
- return (rep.status);
- }
- default:
- {
- xDeviceCtl u;
-
- u.control = d->control;
- u.length = d->length - sizeof (int);
- length = ((unsigned)(u.length + 3) >> 2);
- req->length += length;
- length <<= 2;
- Data (dpy, (char *) &u, length);
- }
- }
+ switch (control) {
+ case DEVICE_RESOLUTION:
+ {
+ XDeviceResolutionControl *R;
+ xDeviceResolutionCtl r;
+
+ R = (XDeviceResolutionControl *) d;
+ r.control = DEVICE_RESOLUTION;
+ r.length = sizeof(xDeviceResolutionCtl) +
+ R->num_valuators * sizeof(int);
+ r.first_valuator = R->first_valuator;
+ r.num_valuators = R->num_valuators;
+ req->length += ((unsigned)(r.length + 3) >> 2);
+ length = sizeof(xDeviceResolutionCtl);
+ Data(dpy, (char *)&r, length);
+ length = r.num_valuators * sizeof(int);
+ Data(dpy, (char *)R->resolutions, length);
+ if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return (NoSuchExtension);
+ } else
+ return (rep.status);
+ }
+ default:
+ {
+ xDeviceCtl u;
+
+ u.control = d->control;
+ u.length = d->length - sizeof(int);
+ length = ((unsigned)(u.length + 3) >> 2);
+ req->length += length;
+ length <<= 2;
+ Data(dpy, (char *)&u, length);
+ }
+ }
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
-
+}
diff --git a/src/XChgFCtl.c b/src/XChgFCtl.c
index 8f4c009..32c7b24 100644
--- a/src/XChgFCtl.c
+++ b/src/XChgFCtl.c
@@ -62,35 +62,34 @@ SOFTWARE.
#include "XIint.h"
int
-XChangeFeedbackControl (dpy, dev, mask, f)
- register Display *dpy;
- XDevice *dev;
- unsigned long mask;
- XFeedbackControl *f;
- {
+XChangeFeedbackControl(dpy, dev, mask, f)
+ register Display *dpy;
+ XDevice *dev;
+ unsigned long mask;
+ XFeedbackControl *f;
+{
int length;
- xChangeFeedbackControlReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ xChangeFeedbackControlReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(ChangeFeedbackControl,req);
+ GetReq(ChangeFeedbackControl, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ChangeFeedbackControl;
req->deviceid = dev->device_id;
req->mask = mask;
req->feedbackid = f->class;
- if (f->class == KbdFeedbackClass)
- {
- XKbdFeedbackControl *K;
- xKbdFeedbackCtl k;
+ if (f->class == KbdFeedbackClass) {
+ XKbdFeedbackControl *K;
+ xKbdFeedbackCtl k;
K = (XKbdFeedbackControl *) f;
k.class = KbdFeedbackClass;
- k.length = sizeof (xKbdFeedbackCtl);
+ k.length = sizeof(xKbdFeedbackCtl);
k.id = K->id;
k.click = K->click;
k.percent = K->percent;
@@ -103,16 +102,14 @@ XChangeFeedbackControl (dpy, dev, mask, f)
length = ((unsigned)(k.length + 3) >> 2);
req->length += length;
length <<= 2;
- Data (dpy, (char *) &k, length);
- }
- else if (f->class == PtrFeedbackClass)
- {
- XPtrFeedbackControl *P;
- xPtrFeedbackCtl p;
+ Data(dpy, (char *)&k, length);
+ } else if (f->class == PtrFeedbackClass) {
+ XPtrFeedbackControl *P;
+ xPtrFeedbackCtl p;
P = (XPtrFeedbackControl *) f;
p.class = PtrFeedbackClass;
- p.length = sizeof (xPtrFeedbackCtl);
+ p.length = sizeof(xPtrFeedbackCtl);
p.id = P->id;
p.num = P->accelNum;
p.denom = P->accelDenom;
@@ -120,48 +117,42 @@ XChangeFeedbackControl (dpy, dev, mask, f)
length = ((unsigned)(p.length + 3) >> 2);
req->length += length;
length <<= 2;
- Data (dpy, (char *) &p, length);
- }
- else if (f->class == IntegerFeedbackClass)
- {
- XIntegerFeedbackControl *I;
- xIntegerFeedbackCtl i;
+ Data(dpy, (char *)&p, length);
+ } else if (f->class == IntegerFeedbackClass) {
+ XIntegerFeedbackControl *I;
+ xIntegerFeedbackCtl i;
I = (XIntegerFeedbackControl *) f;
i.class = IntegerFeedbackClass;
- i.length = sizeof (xIntegerFeedbackCtl);
+ i.length = sizeof(xIntegerFeedbackCtl);
i.id = I->id;
i.int_to_display = I->int_to_display;
length = ((unsigned)(i.length + 3) >> 2);
req->length += length;
length <<= 2;
- Data (dpy, (char *) &i, length);
- }
- else if (f->class == StringFeedbackClass)
- {
- XStringFeedbackControl *S;
- xStringFeedbackCtl s;
+ Data(dpy, (char *)&i, length);
+ } else if (f->class == StringFeedbackClass) {
+ XStringFeedbackControl *S;
+ xStringFeedbackCtl s;
S = (XStringFeedbackControl *) f;
s.class = StringFeedbackClass;
- s.length = sizeof (xStringFeedbackCtl) +
- (S->num_keysyms * sizeof (KeySym));
+ s.length = sizeof(xStringFeedbackCtl) +
+ (S->num_keysyms * sizeof(KeySym));
s.id = S->id;
s.num_keysyms = S->num_keysyms;
req->length += ((unsigned)(s.length + 3) >> 2);
- length = sizeof (xStringFeedbackCtl);
- Data (dpy, (char *) &s, length);
- length = (s.num_keysyms * sizeof (KeySym));
- Data (dpy, (char *) S->syms_to_display, length);
- }
- else if (f->class == BellFeedbackClass)
- {
- XBellFeedbackControl *B;
- xBellFeedbackCtl b;
+ length = sizeof(xStringFeedbackCtl);
+ Data(dpy, (char *)&s, length);
+ length = (s.num_keysyms * sizeof(KeySym));
+ Data(dpy, (char *)S->syms_to_display, length);
+ } else if (f->class == BellFeedbackClass) {
+ XBellFeedbackControl *B;
+ xBellFeedbackCtl b;
B = (XBellFeedbackControl *) f;
b.class = BellFeedbackClass;
- b.length = sizeof (xBellFeedbackCtl);
+ b.length = sizeof(xBellFeedbackCtl);
b.id = B->id;
b.percent = B->percent;
b.pitch = B->pitch;
@@ -169,39 +160,34 @@ XChangeFeedbackControl (dpy, dev, mask, f)
length = ((unsigned)(b.length + 3) >> 2);
req->length += length;
length <<= 2;
- Data (dpy, (char *) &b, length);
- }
- else if (f->class == LedFeedbackClass)
- {
- XLedFeedbackControl *L;
- xLedFeedbackCtl l;
+ Data(dpy, (char *)&b, length);
+ } else if (f->class == LedFeedbackClass) {
+ XLedFeedbackControl *L;
+ xLedFeedbackCtl l;
L = (XLedFeedbackControl *) f;
l.class = LedFeedbackClass;
- l.length = sizeof (xLedFeedbackCtl);
+ l.length = sizeof(xLedFeedbackCtl);
l.id = L->id;
l.led_mask = L->led_mask;
l.led_values = L->led_values;
length = ((unsigned)(l.length + 3) >> 2);
req->length += length;
length <<= 2;
- Data (dpy, (char *) &l, length);
- }
- else
- {
- xFeedbackCtl u;
+ Data(dpy, (char *)&l, length);
+ } else {
+ xFeedbackCtl u;
u.class = f->class;
- u.length = f->length - sizeof (int);
+ u.length = f->length - sizeof(int);
u.id = f->id;
length = ((unsigned)(u.length + 3) >> 2);
req->length += length;
length <<= 2;
- Data (dpy, (char *) &u, length);
- }
+ Data(dpy, (char *)&u, length);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
-
+}
diff --git a/src/XChgKMap.c b/src/XChgKMap.c
index 8ad77ca..d0a334f 100644
--- a/src/XChgKMap.c
+++ b/src/XChgKMap.c
@@ -61,23 +61,23 @@ SOFTWARE.
#include "XIint.h"
int
-XChangeDeviceKeyMapping (dpy, dev, first, syms_per_code, keysyms, count)
- register Display *dpy;
- XDevice *dev;
- int first;
- int syms_per_code;
- KeySym *keysyms;
- int count;
- {
+XChangeDeviceKeyMapping(dpy, dev, first, syms_per_code, keysyms, count)
+ register Display *dpy;
+ XDevice *dev;
+ int first;
+ int syms_per_code;
+ KeySym *keysyms;
+ int count;
+{
register long nbytes;
xChangeDeviceKeyMappingReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(ChangeDeviceKeyMapping,req);
+ GetReq(ChangeDeviceKeyMapping, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ChangeDeviceKeyMapping;
req->deviceid = dev->device_id;
@@ -85,10 +85,10 @@ XChangeDeviceKeyMapping (dpy, dev, first, syms_per_code, keysyms, count)
req->keyCodes = count;
req->keySymsPerKeyCode = syms_per_code;
req->length += count * syms_per_code;
- nbytes = syms_per_code * count * sizeof (CARD32);
- Data (dpy, (char *)keysyms, nbytes);
+ nbytes = syms_per_code * count * sizeof(CARD32);
+ Data(dpy, (char *)keysyms, nbytes);
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XChgKbd.c b/src/XChgKbd.c
index b3e2c06..feba239 100644
--- a/src/XChgKbd.c
+++ b/src/XChgKbd.c
@@ -61,28 +61,27 @@ SOFTWARE.
#include "XIint.h"
int
-XChangeKeyboardDevice (dpy, dev)
- register Display *dpy;
- XDevice *dev;
- {
- xChangeKeyboardDeviceReq *req;
- xChangeKeyboardDeviceReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XChangeKeyboardDevice(dpy, dev)
+ register Display *dpy;
+ XDevice *dev;
+{
+ xChangeKeyboardDeviceReq *req;
+ xChangeKeyboardDeviceReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(ChangeKeyboardDevice,req);
+ GetReq(ChangeKeyboardDevice, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ChangeKeyboardDevice;
req->deviceid = dev->device_id;
rep.status = Success;
- (void) _XReply (dpy, (xReply *) &rep, 0, xTrue);
+ (void)_XReply(dpy, (xReply *) & rep, 0, xTrue);
UnlockDisplay(dpy);
SyncHandle();
return (rep.status);
- }
-
+}
diff --git a/src/XChgPnt.c b/src/XChgPnt.c
index c7248fd..9e0a617 100644
--- a/src/XChgPnt.c
+++ b/src/XChgPnt.c
@@ -61,21 +61,21 @@ SOFTWARE.
#include "XIint.h"
int
-XChangePointerDevice (dpy, dev, xaxis, yaxis)
- register Display *dpy;
- XDevice *dev;
- int xaxis;
- int yaxis;
- {
- xChangePointerDeviceReq *req;
- xChangePointerDeviceReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XChangePointerDevice(dpy, dev, xaxis, yaxis)
+ register Display *dpy;
+ XDevice *dev;
+ int xaxis;
+ int yaxis;
+{
+ xChangePointerDeviceReq *req;
+ xChangePointerDeviceReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(ChangePointerDevice,req);
+ GetReq(ChangePointerDevice, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ChangePointerDevice;
req->deviceid = dev->device_id;
@@ -83,10 +83,9 @@ XChangePointerDevice (dpy, dev, xaxis, yaxis)
req->yaxis = yaxis;
rep.status = Success;
- (void) _XReply (dpy, (xReply *) &rep, 0, xTrue);
+ (void)_XReply(dpy, (xReply *) & rep, 0, xTrue);
UnlockDisplay(dpy);
SyncHandle();
return (rep.status);
- }
-
+}
diff --git a/src/XChgProp.c b/src/XChgProp.c
index 3fa68cf..6939cb3 100644
--- a/src/XChgProp.c
+++ b/src/XChgProp.c
@@ -62,21 +62,21 @@ SOFTWARE.
#include "XIint.h"
int
-XChangeDeviceDontPropagateList (dpy, window, count, events, mode)
- register Display *dpy;
- Window window;
- int count;
- XEventClass *events;
- int mode;
- {
- xChangeDeviceDontPropagateListReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XChangeDeviceDontPropagateList(dpy, window, count, events, mode)
+ register Display *dpy;
+ Window window;
+ int count;
+ XEventClass *events;
+ int mode;
+{
+ xChangeDeviceDontPropagateListReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(ChangeDeviceDontPropagateList,req);
+ GetReq(ChangeDeviceDontPropagateList, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ChangeDeviceDontPropagateList;
req->window = window;
@@ -85,14 +85,13 @@ XChangeDeviceDontPropagateList (dpy, window, count, events, mode)
req->length += count;
/* note: Data is a macro that uses its arguments multiple
- times, so "nvalues" is changed in a separate assignment
- statement */
+ * times, so "nvalues" is changed in a separate assignment
+ * statement */
count <<= 2;
- Data32 (dpy, (long *) events, count);
+ Data32(dpy, (long *)events, count);
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
-
+}
diff --git a/src/XCloseDev.c b/src/XCloseDev.c
index 170843b..71e792a 100644
--- a/src/XCloseDev.c
+++ b/src/XCloseDev.c
@@ -62,24 +62,23 @@ SOFTWARE.
int
XCloseDevice(dpy, dev)
- register Display *dpy;
- register XDevice *dev;
- {
- xCloseDeviceReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ register Display *dpy;
+ register XDevice *dev;
+{
+ xCloseDeviceReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(CloseDevice,req);
+ GetReq(CloseDevice, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_CloseDevice;
req->deviceid = dev->device_id;
- XFree ((char *)dev);
- UnlockDisplay (dpy);
+ XFree((char *)dev);
+ UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
-
+}
diff --git a/src/XDevBell.c b/src/XDevBell.c
index 2b7669f..276a1b8 100644
--- a/src/XDevBell.c
+++ b/src/XDevBell.c
@@ -61,20 +61,20 @@ SOFTWARE.
#include "XIint.h"
int
-XDeviceBell (dpy, dev, feedbackclass, feedbackid, percent)
- register Display *dpy;
- XDevice *dev;
- XID feedbackclass, feedbackid;
- int percent;
- {
- xDeviceBellReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XDeviceBell(dpy, dev, feedbackclass, feedbackid, percent)
+ register Display *dpy;
+ XDevice *dev;
+ XID feedbackclass, feedbackid;
+ int percent;
+{
+ xDeviceBellReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Add_XDeviceBell) == -1)
return (NoSuchExtension);
- GetReq(DeviceBell,req);
+ GetReq(DeviceBell, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_DeviceBell;
req->deviceid = dev->device_id;
@@ -85,5 +85,4 @@ XDeviceBell (dpy, dev, feedbackclass, feedbackid, percent)
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
-
+}
diff --git a/src/XExtInt.c b/src/XExtInt.c
index 9e569df..811c0c3 100644
--- a/src/XExtInt.c
+++ b/src/XExtInt.c
@@ -66,63 +66,64 @@ SOFTWARE.
#define ENQUEUE_EVENT True
#define DONT_ENQUEUE False
-static XExtensionInfo *xinput_info;
-static /* const */ char *xinput_extension_name = INAME;
-static int XInputClose();
-static char *XInputError();
+static XExtensionInfo *xinput_info;
+static /* const */ char *xinput_extension_name = INAME;
+static int XInputClose();
+static char *XInputError();
static Bool XInputWireToEvent();
-Status _XiEventToWire();
-static /* const */ XEvent emptyevent;
+Status _XiEventToWire();
+static /* const */ XEvent emptyevent;
typedef struct _XInputData
- {
- XEvent data;
- XExtensionVersion *vers;
- } XInputData;
+{
+ XEvent data;
+ XExtensionVersion *vers;
+} XInputData;
#define XInputCheckExtension(dpy,i,val) \
XextCheckExtension (dpy, i, xinput_extension_name, val)
static /* const */ XExtensionHooks xinput_extension_hooks = {
- NULL, /* create_gc */
- NULL, /* copy_gc */
- NULL, /* flush_gc */
- NULL, /* free_gc */
- NULL, /* create_font */
- NULL, /* free_font */
- XInputClose, /* close_display */
- XInputWireToEvent, /* wire_to_event */
- _XiEventToWire, /* event_to_wire */
- NULL, /* error */
- XInputError, /* error_string */
+ NULL, /* create_gc */
+ NULL, /* copy_gc */
+ NULL, /* flush_gc */
+ NULL, /* free_gc */
+ NULL, /* create_font */
+ NULL, /* free_font */
+ XInputClose, /* close_display */
+ XInputWireToEvent, /* wire_to_event */
+ _XiEventToWire, /* event_to_wire */
+ NULL, /* error */
+ XInputError, /* error_string */
};
static char *XInputErrorList[] = {
- "BadDevice, invalid or uninitialized input device", /* BadDevice */
- "BadEvent, invalid event type", /* BadEvent */
- "BadMode, invalid mode parameter", /* BadMode */
- "DeviceBusy, device is busy", /* DeviceBusy */
- "BadClass, invalid event class", /* BadClass */
+ "BadDevice, invalid or uninitialized input device", /* BadDevice */
+ "BadEvent, invalid event type", /* BadEvent */
+ "BadMode, invalid mode parameter", /* BadMode */
+ "DeviceBusy, device is busy", /* DeviceBusy */
+ "BadClass, invalid event class", /* BadClass */
};
-XEXT_GENERATE_FIND_DISPLAY (XInput_find_display, xinput_info,
- xinput_extension_name, &xinput_extension_hooks, IEVENTS, NULL)
+XEXT_GENERATE_FIND_DISPLAY(XInput_find_display, xinput_info,
+ xinput_extension_name, &xinput_extension_hooks,
+ IEVENTS, NULL)
-static XEXT_GENERATE_ERROR_STRING (XInputError, xinput_extension_name,
- IERRORS, XInputErrorList)
+ static XEXT_GENERATE_ERROR_STRING(XInputError, xinput_extension_name,
+ IERRORS, XInputErrorList)
/*******************************************************************
*
* Input extension versions.
*
*/
-
-static XExtensionVersion versions[] = {{XI_Absent,0,0},
- {XI_Present, XI_Initial_Release_Major, XI_Initial_Release_Minor},
- {XI_Present, XI_Add_XDeviceBell_Major, XI_Add_XDeviceBell_Minor},
- {XI_Present, XI_Add_XSetDeviceValuators_Major,
- XI_Add_XSetDeviceValuators_Minor},
- {XI_Present, XI_Add_XChangeDeviceControl_Major,
- XI_Add_XChangeDeviceControl_Minor}};
+ static XExtensionVersion versions[] = { {XI_Absent, 0, 0},
+ {XI_Present, XI_Initial_Release_Major, XI_Initial_Release_Minor},
+ {XI_Present, XI_Add_XDeviceBell_Major, XI_Add_XDeviceBell_Minor},
+ {XI_Present, XI_Add_XSetDeviceValuators_Major,
+ XI_Add_XSetDeviceValuators_Minor},
+ {XI_Present, XI_Add_XChangeDeviceControl_Major,
+ XI_Add_XChangeDeviceControl_Minor}
+ };
/***********************************************************************
*
@@ -130,45 +131,55 @@ static XExtensionVersion versions[] = {{XI_Absent,0,0},
*
*/
-void _xibaddevice (dpy, error)
+void
+_xibaddevice(dpy, error)
Display *dpy;
int *error;
- {
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
*error = info->codes->first_error + XI_BadDevice;
- }
+}
-void _xibadclass (dpy, error)
+void
+_xibadclass(dpy, error)
Display *dpy;
int *error;
- {
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
*error = info->codes->first_error + XI_BadClass;
- }
+}
-void _xibadevent (dpy, error)
+void
+_xibadevent(dpy, error)
Display *dpy;
int *error;
- {
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
*error = info->codes->first_error + XI_BadEvent;
- }
+}
-void _xibadmode (dpy, error)
+void
+_xibadmode(dpy, error)
Display *dpy;
int *error;
- {
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
*error = info->codes->first_error + XI_BadMode;
- }
+}
-void _xidevicebusy (dpy, error)
+void
+_xidevicebusy(dpy, error)
Display *dpy;
int *error;
- {
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
*error = info->codes->first_error + XI_DeviceBusy;
- }
+}
/***********************************************************************
*
@@ -179,39 +190,35 @@ void _xidevicebusy (dpy, error)
int
_XiCheckExtInit(dpy, version_index)
- register Display *dpy;
- register int version_index;
- {
- XExtensionVersion *ext;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ register Display *dpy;
+ register int version_index;
+{
+ XExtensionVersion *ext;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- XInputCheckExtension (dpy, info, -1);
+ XInputCheckExtension(dpy, info, -1);
- if (info->data == NULL)
- {
- info->data = (XPointer) Xmalloc (sizeof (XInputData));
- if (!info->data)
- {
- UnlockDisplay(dpy);
+ if (info->data == NULL) {
+ info->data = (XPointer) Xmalloc(sizeof(XInputData));
+ if (!info->data) {
+ UnlockDisplay(dpy);
return (-1);
- }
- ((XInputData *) info->data)->vers =
- _XiGetExtensionVersion (dpy, "XInputExtension");
}
+ ((XInputData *) info->data)->vers =
+ _XiGetExtensionVersion(dpy, "XInputExtension");
+ }
- if (versions[version_index].major_version > Dont_Check)
- {
+ if (versions[version_index].major_version > Dont_Check) {
ext = ((XInputData *) info->data)->vers;
if ((ext->major_version < versions[version_index].major_version) ||
((ext->major_version == versions[version_index].major_version) &&
- (ext->minor_version < versions[version_index].minor_version)))
- {
- UnlockDisplay(dpy);
+ (ext->minor_version < versions[version_index].minor_version))) {
+ UnlockDisplay(dpy);
return (-1);
- }
}
- return (0);
}
+ return (0);
+}
/***********************************************************************
*
@@ -220,28 +227,27 @@ _XiCheckExtInit(dpy, version_index)
*/
static int
-XInputClose (dpy, codes)
+XInputClose(dpy, codes)
Display *dpy;
XExtCodes *codes;
- {
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- if(info->data != NULL) {
+ if (info->data != NULL) {
XFree((char *)((XInputData *) info->data)->vers);
XFree((char *)info->data);
}
- return XextRemoveDisplay (xinput_info, dpy);
- }
-
+ return XextRemoveDisplay(xinput_info, dpy);
+}
static int
-Ones(mask)
+Ones(mask)
Mask mask;
{
register Mask y;
- y = (mask >> 1) &033333333333;
- y = mask - y - ((y >>1) & 033333333333);
+ y = (mask >> 1) & 033333333333;
+ y = mask - y - ((y >> 1) & 033333333333);
return (((y + (y >> 3)) & 030707070707) % 077);
}
@@ -253,411 +259,416 @@ Ones(mask)
*/
static Bool
-XInputWireToEvent (dpy, re, event)
- Display *dpy;
- XEvent *re;
- xEvent *event;
- {
- unsigned int type, reltype;
- unsigned int i,j;
- XExtDisplayInfo *info = XInput_find_display (dpy);
- XEvent *save = (XEvent *) info->data;
+XInputWireToEvent(dpy, re, event)
+ Display *dpy;
+ XEvent *re;
+ xEvent *event;
+{
+ unsigned int type, reltype;
+ unsigned int i, j;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+ XEvent *save = (XEvent *) info->data;
type = event->u.u.type & 0x7f;
reltype = (type - info->codes->first_event);
-
-
- if (reltype != XI_DeviceValuator &&
+ if (reltype != XI_DeviceValuator &&
reltype != XI_DeviceKeystateNotify &&
- reltype != XI_DeviceButtonstateNotify)
- {
+ reltype != XI_DeviceButtonstateNotify) {
*save = emptyevent;
- save->type = type;
- ((XAnyEvent *)save)->serial = _XSetLastRequestRead(dpy,
- (xGenericReply *)event);
- ((XAnyEvent *)save)->send_event = ((event->u.u.type & 0x80) != 0);
- ((XAnyEvent *)save)->display = dpy;
+ save->type = type;
+ ((XAnyEvent *) save)->serial = _XSetLastRequestRead(dpy,
+ (xGenericReply *)
+ event);
+ ((XAnyEvent *) save)->send_event = ((event->u.u.type & 0x80) != 0);
+ ((XAnyEvent *) save)->display = dpy;
+ }
+
+ switch (reltype) {
+ case XI_DeviceMotionNotify:
+ {
+ register XDeviceMotionEvent *ev = (XDeviceMotionEvent *) save;
+ deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
+
+ ev->root = ev2->root;
+ ev->window = ev2->event;
+ ev->subwindow = ev2->child;
+ ev->time = ev2->time;
+ ev->x_root = ev2->root_x;
+ ev->y_root = ev2->root_y;
+ ev->x = ev2->event_x;
+ ev->y = ev2->event_y;
+ ev->state = ev2->state;
+ ev->same_screen = ev2->same_screen;
+ ev->is_hint = ev2->detail;
+ ev->deviceid = ev2->deviceid & DEVICE_BITS;
+ return (DONT_ENQUEUE);
+ }
+ break;
+ case XI_DeviceKeyPress:
+ case XI_DeviceKeyRelease:
+ {
+ register XDeviceKeyEvent *ev = (XDeviceKeyEvent *) save;
+ deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
+
+ ev->root = ev2->root;
+ ev->window = ev2->event;
+ ev->subwindow = ev2->child;
+ ev->time = ev2->time;
+ ev->x_root = ev2->root_x;
+ ev->y_root = ev2->root_y;
+ ev->x = ev2->event_x;
+ ev->y = ev2->event_y;
+ ev->state = ev2->state;
+ ev->same_screen = ev2->same_screen;
+ ev->keycode = ev2->detail;
+ ev->deviceid = ev2->deviceid & DEVICE_BITS;
+ if (ev2->deviceid & MORE_EVENTS)
+ return (DONT_ENQUEUE);
+ else {
+ *re = *save;
+ return (ENQUEUE_EVENT);
}
-
- switch (reltype)
- {
- case XI_DeviceMotionNotify:
- {
- register XDeviceMotionEvent *ev = (XDeviceMotionEvent*) save;
- deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
-
- ev->root = ev2->root;
- ev->window = ev2->event;
- ev->subwindow = ev2->child;
- ev->time = ev2->time;
- ev->x_root = ev2->root_x;
- ev->y_root = ev2->root_y;
- ev->x = ev2->event_x;
- ev->y = ev2->event_y;
- ev->state = ev2->state;
- ev->same_screen = ev2->same_screen;
- ev->is_hint = ev2->detail;
- ev->deviceid = ev2->deviceid & DEVICE_BITS;
- return (DONT_ENQUEUE);
- }
- break;
- case XI_DeviceKeyPress:
- case XI_DeviceKeyRelease:
- {
- register XDeviceKeyEvent *ev = (XDeviceKeyEvent*) save;
- deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
-
- ev->root = ev2->root;
- ev->window = ev2->event;
- ev->subwindow = ev2->child;
- ev->time = ev2->time;
- ev->x_root = ev2->root_x;
- ev->y_root = ev2->root_y;
- ev->x = ev2->event_x;
- ev->y = ev2->event_y;
- ev->state = ev2->state;
- ev->same_screen = ev2->same_screen;
- ev->keycode = ev2->detail;
- ev->deviceid = ev2->deviceid & DEVICE_BITS;
- if (ev2->deviceid & MORE_EVENTS)
- return (DONT_ENQUEUE);
- else
- {
- *re = *save;
- return (ENQUEUE_EVENT);
- }
- }
- break;
- case XI_DeviceButtonPress:
- case XI_DeviceButtonRelease:
- {
- register XDeviceButtonEvent *ev = (XDeviceButtonEvent*) save;
- deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
-
- ev->root = ev2->root;
- ev->window = ev2->event;
- ev->subwindow = ev2->child;
- ev->time = ev2->time;
- ev->x_root = ev2->root_x;
- ev->y_root = ev2->root_y;
- ev->x = ev2->event_x;
- ev->y = ev2->event_y;
- ev->state = ev2->state;
- ev->same_screen = ev2->same_screen;
- ev->button = ev2->detail;
- ev->deviceid = ev2->deviceid & DEVICE_BITS;
- if (ev2->deviceid & MORE_EVENTS)
- return (DONT_ENQUEUE);
- else
- {
- *re = *save;
- return (ENQUEUE_EVENT);
- }
- }
- break;
- case XI_ProximityIn:
- case XI_ProximityOut:
- {
- register XProximityNotifyEvent *ev =
- (XProximityNotifyEvent *) save;
- deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
-
- ev->root = ev2->root;
- ev->window = ev2->event;
- ev->subwindow = ev2->child;
- ev->time = ev2->time;
- ev->x_root = ev2->root_x;
- ev->y_root = ev2->root_y;
- ev->x = ev2->event_x;
- ev->y = ev2->event_y;
- ev->state = ev2->state;
- ev->same_screen = ev2->same_screen;
- ev->deviceid = ev2->deviceid & DEVICE_BITS;
- if (ev2->deviceid & MORE_EVENTS)
- return (DONT_ENQUEUE);
- else
- {
- *re = *save;
- return (ENQUEUE_EVENT);
- }
- }
- break;
- case XI_DeviceValuator:
- {
- deviceValuator *xev = (deviceValuator *) event;
- int save_type = save->type - info->codes->first_event;
-
- if (save_type == XI_DeviceKeyPress ||
- save_type == XI_DeviceKeyRelease)
- {
- XDeviceKeyEvent *kev = (XDeviceKeyEvent*) save;
- kev->device_state = xev->device_state;
- kev->axes_count = xev->num_valuators;
- kev->first_axis = xev->first_valuator;
- i = xev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: kev->axis_data[5] = xev->valuator5;
- case 5: kev->axis_data[4] = xev->valuator4;
- case 4: kev->axis_data[3] = xev->valuator3;
- case 3: kev->axis_data[2] = xev->valuator2;
- case 2: kev->axis_data[1] = xev->valuator1;
- case 1: kev->axis_data[0] = xev->valuator0;
- }
- }
- else if (save_type == XI_DeviceButtonPress ||
- save_type == XI_DeviceButtonRelease)
- {
- XDeviceButtonEvent *bev = (XDeviceButtonEvent*) save;
- bev->device_state = xev->device_state;
- bev->axes_count = xev->num_valuators;
- bev->first_axis = xev->first_valuator;
- i = xev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: bev->axis_data[5] = xev->valuator5;
- case 5: bev->axis_data[4] = xev->valuator4;
- case 4: bev->axis_data[3] = xev->valuator3;
- case 3: bev->axis_data[2] = xev->valuator2;
- case 2: bev->axis_data[1] = xev->valuator1;
- case 1: bev->axis_data[0] = xev->valuator0;
- }
- }
- else if (save_type == XI_DeviceMotionNotify)
- {
- XDeviceMotionEvent *mev = (XDeviceMotionEvent*) save;
- mev->device_state = xev->device_state;
- mev->axes_count = xev->num_valuators;
- mev->first_axis = xev->first_valuator;
- i = xev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: mev->axis_data[5] = xev->valuator5;
- case 5: mev->axis_data[4] = xev->valuator4;
- case 4: mev->axis_data[3] = xev->valuator3;
- case 3: mev->axis_data[2] = xev->valuator2;
- case 2: mev->axis_data[1] = xev->valuator1;
- case 1: mev->axis_data[0] = xev->valuator0;
- }
- }
- else if (save_type == XI_ProximityIn ||
- save_type == XI_ProximityOut)
- {
- XProximityNotifyEvent *pev =
- (XProximityNotifyEvent*) save;
- pev->device_state = xev->device_state;
- pev->axes_count = xev->num_valuators;
- pev->first_axis = xev->first_valuator;
- i = xev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: pev->axis_data[5] = xev->valuator5;
- case 5: pev->axis_data[4] = xev->valuator4;
- case 4: pev->axis_data[3] = xev->valuator3;
- case 3: pev->axis_data[2] = xev->valuator2;
- case 2: pev->axis_data[1] = xev->valuator1;
- case 1: pev->axis_data[0] = xev->valuator0;
- }
- }
- else if (save_type == XI_DeviceStateNotify)
- {
- XDeviceStateNotifyEvent *sev =
- (XDeviceStateNotifyEvent*) save;
- XInputClass *any = (XInputClass *) &sev->data[0];
- XValuatorStatus *v;
-
- for (i=0; i<sev->num_classes; i++)
- if (any->class != ValuatorClass)
- any = (XInputClass *) ((char *) any + any->length);
- v = (XValuatorStatus *) any;
- i = v->num_valuators;
- j = xev->num_valuators;
- if (j > 3) j = 3;
- switch (j)
- {
- case 3: v->valuators[i + 2] = xev->valuator2;
- case 2: v->valuators[i + 1] = xev->valuator1;
- case 1: v->valuators[i + 0] = xev->valuator0;
- }
- v->num_valuators += j;
-
- }
+ }
+ break;
+ case XI_DeviceButtonPress:
+ case XI_DeviceButtonRelease:
+ {
+ register XDeviceButtonEvent *ev = (XDeviceButtonEvent *) save;
+ deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
+
+ ev->root = ev2->root;
+ ev->window = ev2->event;
+ ev->subwindow = ev2->child;
+ ev->time = ev2->time;
+ ev->x_root = ev2->root_x;
+ ev->y_root = ev2->root_y;
+ ev->x = ev2->event_x;
+ ev->y = ev2->event_y;
+ ev->state = ev2->state;
+ ev->same_screen = ev2->same_screen;
+ ev->button = ev2->detail;
+ ev->deviceid = ev2->deviceid & DEVICE_BITS;
+ if (ev2->deviceid & MORE_EVENTS)
+ return (DONT_ENQUEUE);
+ else {
*re = *save;
return (ENQUEUE_EVENT);
+ }
+ }
+ break;
+ case XI_ProximityIn:
+ case XI_ProximityOut:
+ {
+ register XProximityNotifyEvent *ev = (XProximityNotifyEvent *) save;
+ deviceKeyButtonPointer *ev2 = (deviceKeyButtonPointer *) event;
+
+ ev->root = ev2->root;
+ ev->window = ev2->event;
+ ev->subwindow = ev2->child;
+ ev->time = ev2->time;
+ ev->x_root = ev2->root_x;
+ ev->y_root = ev2->root_y;
+ ev->x = ev2->event_x;
+ ev->y = ev2->event_y;
+ ev->state = ev2->state;
+ ev->same_screen = ev2->same_screen;
+ ev->deviceid = ev2->deviceid & DEVICE_BITS;
+ if (ev2->deviceid & MORE_EVENTS)
+ return (DONT_ENQUEUE);
+ else {
+ *re = *save;
+ return (ENQUEUE_EVENT);
+ }
+ }
+ break;
+ case XI_DeviceValuator:
+ {
+ deviceValuator *xev = (deviceValuator *) event;
+ int save_type = save->type - info->codes->first_event;
+
+ if (save_type == XI_DeviceKeyPress || save_type == XI_DeviceKeyRelease) {
+ XDeviceKeyEvent *kev = (XDeviceKeyEvent *) save;
+
+ kev->device_state = xev->device_state;
+ kev->axes_count = xev->num_valuators;
+ kev->first_axis = xev->first_valuator;
+ i = xev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ kev->axis_data[5] = xev->valuator5;
+ case 5:
+ kev->axis_data[4] = xev->valuator4;
+ case 4:
+ kev->axis_data[3] = xev->valuator3;
+ case 3:
+ kev->axis_data[2] = xev->valuator2;
+ case 2:
+ kev->axis_data[1] = xev->valuator1;
+ case 1:
+ kev->axis_data[0] = xev->valuator0;
}
- break;
- case XI_DeviceFocusIn:
- case XI_DeviceFocusOut:
- {
- register XDeviceFocusChangeEvent *ev =
- (XDeviceFocusChangeEvent *) re;
- deviceFocus *fev = (deviceFocus *) event;
-
- *ev = *((XDeviceFocusChangeEvent *) save);
- ev->window = fev->window;
- ev->time = fev->time;
- ev->mode = fev->mode;
- ev->detail = fev->detail;
- ev->deviceid = fev->deviceid & DEVICE_BITS;
- return (ENQUEUE_EVENT);
- }
- break;
- case XI_DeviceStateNotify:
- {
- XDeviceStateNotifyEvent *stev =
- (XDeviceStateNotifyEvent *) save;
- deviceStateNotify *sev = (deviceStateNotify *) event;
- char *data;
-
- stev->window = None;
- stev->deviceid = sev->deviceid & DEVICE_BITS;
- stev->time = sev->time;
- stev->num_classes = Ones ((Mask)sev->classes_reported & InputClassBits);
- data = (char *) &stev->data[0];
- if (sev->classes_reported & (1 << KeyClass))
- {
- register XKeyStatus *kstev = (XKeyStatus *) data;
- kstev->class = KeyClass;
- kstev->length = sizeof (XKeyStatus);
- kstev->num_keys = sev->num_keys;
- memcpy ((char *) &kstev->keys[0], (char *) &sev->keys[0], 4);
- data += sizeof (XKeyStatus);
- }
- if (sev->classes_reported & (1 << ButtonClass))
- {
- register XButtonStatus *bev = (XButtonStatus *) data;
- bev->class = ButtonClass;
- bev->length = sizeof (XButtonStatus);
- bev->num_buttons = sev->num_buttons;
- memcpy ((char *) bev->buttons, (char *) sev->buttons, 4);
- data += sizeof (XButtonStatus);
- }
- if (sev->classes_reported & (1 << ValuatorClass))
- {
- register XValuatorStatus *vev = (XValuatorStatus *) data;
- vev->class = ValuatorClass;
- vev->length = sizeof (XValuatorStatus);
- vev->num_valuators = sev->num_valuators;
- vev->mode = sev->classes_reported >> ModeBitsShift;
- j = sev->num_valuators;
- if (j > 3) j = 3;
- switch (j)
- {
- case 3: vev->valuators[2] = sev->valuator2;
- case 2: vev->valuators[1] = sev->valuator1;
- case 1: vev->valuators[0] = sev->valuator0;
- }
- data += sizeof (XValuatorStatus);
- }
- if (sev->deviceid & MORE_EVENTS)
- return (DONT_ENQUEUE);
- else
- {
- *re = *save;
- stev = (XDeviceStateNotifyEvent *) re;
- return (ENQUEUE_EVENT);
- }
+ } else if (save_type == XI_DeviceButtonPress ||
+ save_type == XI_DeviceButtonRelease) {
+ XDeviceButtonEvent *bev = (XDeviceButtonEvent *) save;
+
+ bev->device_state = xev->device_state;
+ bev->axes_count = xev->num_valuators;
+ bev->first_axis = xev->first_valuator;
+ i = xev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ bev->axis_data[5] = xev->valuator5;
+ case 5:
+ bev->axis_data[4] = xev->valuator4;
+ case 4:
+ bev->axis_data[3] = xev->valuator3;
+ case 3:
+ bev->axis_data[2] = xev->valuator2;
+ case 2:
+ bev->axis_data[1] = xev->valuator1;
+ case 1:
+ bev->axis_data[0] = xev->valuator0;
}
- break;
- case XI_DeviceKeystateNotify:
- {
- int i;
- XInputClass *anyclass;
- register XKeyStatus *kv;
- deviceKeyStateNotify *ksev = (deviceKeyStateNotify *) event;
- XDeviceStateNotifyEvent *kstev =
- (XDeviceStateNotifyEvent *) save;
-
- anyclass = (XInputClass *) &kstev->data[0];
- for (i=0; i<kstev->num_classes; i++)
- if (anyclass->class == KeyClass)
- break;
- else
- anyclass = (XInputClass *) ((char *) anyclass +
- anyclass->length);
-
- kv = (XKeyStatus *) anyclass;
- kv->num_keys = 256;
- memcpy ((char *) &kv->keys[4], (char *) ksev->keys, 28);
- if (ksev->deviceid & MORE_EVENTS)
- return (DONT_ENQUEUE);
- else
- {
- *re = *save;
- kstev = (XDeviceStateNotifyEvent *) re;
- return (ENQUEUE_EVENT);
- }
+ } else if (save_type == XI_DeviceMotionNotify) {
+ XDeviceMotionEvent *mev = (XDeviceMotionEvent *) save;
+
+ mev->device_state = xev->device_state;
+ mev->axes_count = xev->num_valuators;
+ mev->first_axis = xev->first_valuator;
+ i = xev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ mev->axis_data[5] = xev->valuator5;
+ case 5:
+ mev->axis_data[4] = xev->valuator4;
+ case 4:
+ mev->axis_data[3] = xev->valuator3;
+ case 3:
+ mev->axis_data[2] = xev->valuator2;
+ case 2:
+ mev->axis_data[1] = xev->valuator1;
+ case 1:
+ mev->axis_data[0] = xev->valuator0;
}
- break;
- case XI_DeviceButtonstateNotify:
- {
- int i;
- XInputClass *anyclass;
- register XButtonStatus *bv;
- deviceButtonStateNotify *bsev = (deviceButtonStateNotify *) event;
- XDeviceStateNotifyEvent *bstev =
- (XDeviceStateNotifyEvent *) save;
-
-
- anyclass = (XInputClass *) &bstev->data[0];
- for (i=0; i<bstev->num_classes; i++)
- if (anyclass->class == ButtonClass)
- break;
- else
- anyclass = (XInputClass *) ((char *) anyclass +
- anyclass->length);
-
- bv = (XButtonStatus *) anyclass;
- bv->num_buttons = 256;
- memcpy ((char *) &bv->buttons[4], (char *) bsev->buttons, 28);
- if (bsev->deviceid & MORE_EVENTS)
- return (DONT_ENQUEUE);
- else
- {
- *re = *save;
- bstev = (XDeviceStateNotifyEvent *) re;
- return (ENQUEUE_EVENT);
- }
+ } else if (save_type == XI_ProximityIn || save_type == XI_ProximityOut) {
+ XProximityNotifyEvent *pev = (XProximityNotifyEvent *) save;
+
+ pev->device_state = xev->device_state;
+ pev->axes_count = xev->num_valuators;
+ pev->first_axis = xev->first_valuator;
+ i = xev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ pev->axis_data[5] = xev->valuator5;
+ case 5:
+ pev->axis_data[4] = xev->valuator4;
+ case 4:
+ pev->axis_data[3] = xev->valuator3;
+ case 3:
+ pev->axis_data[2] = xev->valuator2;
+ case 2:
+ pev->axis_data[1] = xev->valuator1;
+ case 1:
+ pev->axis_data[0] = xev->valuator0;
}
- break;
- case XI_DeviceMappingNotify:
- {
- register XDeviceMappingEvent *ev = (XDeviceMappingEvent *) re;
- deviceMappingNotify *ev2 = (deviceMappingNotify *) event;
-
- *ev = *((XDeviceMappingEvent *) save);
- ev->window = 0;
- ev->first_keycode = ev2->firstKeyCode;
- ev->request = ev2->request;
- ev->count = ev2->count;
- ev->time = ev2->time;
- ev->deviceid = ev2->deviceid & DEVICE_BITS;
- return (ENQUEUE_EVENT);
+ } else if (save_type == XI_DeviceStateNotify) {
+ XDeviceStateNotifyEvent *sev = (XDeviceStateNotifyEvent *) save;
+ XInputClass *any = (XInputClass *) & sev->data[0];
+ XValuatorStatus *v;
+
+ for (i = 0; i < sev->num_classes; i++)
+ if (any->class != ValuatorClass)
+ any = (XInputClass *) ((char *)any + any->length);
+ v = (XValuatorStatus *) any;
+ i = v->num_valuators;
+ j = xev->num_valuators;
+ if (j > 3)
+ j = 3;
+ switch (j) {
+ case 3:
+ v->valuators[i + 2] = xev->valuator2;
+ case 2:
+ v->valuators[i + 1] = xev->valuator1;
+ case 1:
+ v->valuators[i + 0] = xev->valuator0;
}
- break;
- case XI_ChangeDeviceNotify:
- {
- register XChangeDeviceNotifyEvent *ev =
- (XChangeDeviceNotifyEvent *) re;
- changeDeviceNotify *ev2 = (changeDeviceNotify *) event;
-
- *ev = *((XChangeDeviceNotifyEvent *) save);
- ev->window = 0;
- ev->request = ev2->request;
- ev->time = ev2->time;
- ev->deviceid = ev2->deviceid & DEVICE_BITS;
- return (ENQUEUE_EVENT);
+ v->num_valuators += j;
+
+ }
+ *re = *save;
+ return (ENQUEUE_EVENT);
+ }
+ break;
+ case XI_DeviceFocusIn:
+ case XI_DeviceFocusOut:
+ {
+ register XDeviceFocusChangeEvent *ev = (XDeviceFocusChangeEvent *) re;
+ deviceFocus *fev = (deviceFocus *) event;
+
+ *ev = *((XDeviceFocusChangeEvent *) save);
+ ev->window = fev->window;
+ ev->time = fev->time;
+ ev->mode = fev->mode;
+ ev->detail = fev->detail;
+ ev->deviceid = fev->deviceid & DEVICE_BITS;
+ return (ENQUEUE_EVENT);
+ }
+ break;
+ case XI_DeviceStateNotify:
+ {
+ XDeviceStateNotifyEvent *stev = (XDeviceStateNotifyEvent *) save;
+ deviceStateNotify *sev = (deviceStateNotify *) event;
+ char *data;
+
+ stev->window = None;
+ stev->deviceid = sev->deviceid & DEVICE_BITS;
+ stev->time = sev->time;
+ stev->num_classes = Ones((Mask) sev->classes_reported & InputClassBits);
+ data = (char *)&stev->data[0];
+ if (sev->classes_reported & (1 << KeyClass)) {
+ register XKeyStatus *kstev = (XKeyStatus *) data;
+
+ kstev->class = KeyClass;
+ kstev->length = sizeof(XKeyStatus);
+ kstev->num_keys = sev->num_keys;
+ memcpy((char *)&kstev->keys[0], (char *)&sev->keys[0], 4);
+ data += sizeof(XKeyStatus);
+ }
+ if (sev->classes_reported & (1 << ButtonClass)) {
+ register XButtonStatus *bev = (XButtonStatus *) data;
+
+ bev->class = ButtonClass;
+ bev->length = sizeof(XButtonStatus);
+ bev->num_buttons = sev->num_buttons;
+ memcpy((char *)bev->buttons, (char *)sev->buttons, 4);
+ data += sizeof(XButtonStatus);
+ }
+ if (sev->classes_reported & (1 << ValuatorClass)) {
+ register XValuatorStatus *vev = (XValuatorStatus *) data;
+
+ vev->class = ValuatorClass;
+ vev->length = sizeof(XValuatorStatus);
+ vev->num_valuators = sev->num_valuators;
+ vev->mode = sev->classes_reported >> ModeBitsShift;
+ j = sev->num_valuators;
+ if (j > 3)
+ j = 3;
+ switch (j) {
+ case 3:
+ vev->valuators[2] = sev->valuator2;
+ case 2:
+ vev->valuators[1] = sev->valuator1;
+ case 1:
+ vev->valuators[0] = sev->valuator0;
}
- break;
- default:
- printf ("XInputWireToEvent: UNKNOWN WIRE EVENT! type=%d\n",type);
- break;
+ data += sizeof(XValuatorStatus);
+ }
+ if (sev->deviceid & MORE_EVENTS)
+ return (DONT_ENQUEUE);
+ else {
+ *re = *save;
+ stev = (XDeviceStateNotifyEvent *) re;
+ return (ENQUEUE_EVENT);
+ }
+ }
+ break;
+ case XI_DeviceKeystateNotify:
+ {
+ int i;
+ XInputClass *anyclass;
+ register XKeyStatus *kv;
+ deviceKeyStateNotify *ksev = (deviceKeyStateNotify *) event;
+ XDeviceStateNotifyEvent *kstev = (XDeviceStateNotifyEvent *) save;
+
+ anyclass = (XInputClass *) & kstev->data[0];
+ for (i = 0; i < kstev->num_classes; i++)
+ if (anyclass->class == KeyClass)
+ break;
+ else
+ anyclass = (XInputClass *) ((char *)anyclass +
+ anyclass->length);
+
+ kv = (XKeyStatus *) anyclass;
+ kv->num_keys = 256;
+ memcpy((char *)&kv->keys[4], (char *)ksev->keys, 28);
+ if (ksev->deviceid & MORE_EVENTS)
+ return (DONT_ENQUEUE);
+ else {
+ *re = *save;
+ kstev = (XDeviceStateNotifyEvent *) re;
+ return (ENQUEUE_EVENT);
+ }
+ }
+ break;
+ case XI_DeviceButtonstateNotify:
+ {
+ int i;
+ XInputClass *anyclass;
+ register XButtonStatus *bv;
+ deviceButtonStateNotify *bsev = (deviceButtonStateNotify *) event;
+ XDeviceStateNotifyEvent *bstev = (XDeviceStateNotifyEvent *) save;
+
+ anyclass = (XInputClass *) & bstev->data[0];
+ for (i = 0; i < bstev->num_classes; i++)
+ if (anyclass->class == ButtonClass)
+ break;
+ else
+ anyclass = (XInputClass *) ((char *)anyclass +
+ anyclass->length);
+
+ bv = (XButtonStatus *) anyclass;
+ bv->num_buttons = 256;
+ memcpy((char *)&bv->buttons[4], (char *)bsev->buttons, 28);
+ if (bsev->deviceid & MORE_EVENTS)
+ return (DONT_ENQUEUE);
+ else {
+ *re = *save;
+ bstev = (XDeviceStateNotifyEvent *) re;
+ return (ENQUEUE_EVENT);
}
+ }
+ break;
+ case XI_DeviceMappingNotify:
+ {
+ register XDeviceMappingEvent *ev = (XDeviceMappingEvent *) re;
+ deviceMappingNotify *ev2 = (deviceMappingNotify *) event;
+
+ *ev = *((XDeviceMappingEvent *) save);
+ ev->window = 0;
+ ev->first_keycode = ev2->firstKeyCode;
+ ev->request = ev2->request;
+ ev->count = ev2->count;
+ ev->time = ev2->time;
+ ev->deviceid = ev2->deviceid & DEVICE_BITS;
+ return (ENQUEUE_EVENT);
+ }
+ break;
+ case XI_ChangeDeviceNotify:
+ {
+ register XChangeDeviceNotifyEvent *ev = (XChangeDeviceNotifyEvent *) re;
+ changeDeviceNotify *ev2 = (changeDeviceNotify *) event;
+
+ *ev = *((XChangeDeviceNotifyEvent *) save);
+ ev->window = 0;
+ ev->request = ev2->request;
+ ev->time = ev2->time;
+ ev->deviceid = ev2->deviceid & DEVICE_BITS;
+ return (ENQUEUE_EVENT);
+ }
+ break;
+ default:
+ printf("XInputWireToEvent: UNKNOWN WIRE EVENT! type=%d\n", type);
+ break;
+ }
return (DONT_ENQUEUE);
- }
+}
diff --git a/src/XExtToWire.c b/src/XExtToWire.c
index 30f0140..213da32 100644
--- a/src/XExtToWire.c
+++ b/src/XExtToWire.c
@@ -67,386 +67,395 @@ _XiEventToWire(dpy, re, event, count)
register XEvent *re; /* pointer to client event */
register xEvent **event; /* wire protocol event */
register int *count;
- {
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ XExtDisplayInfo *info = XInput_find_display(dpy);
int i;
- switch ((re->type & 0x7f) - info->codes->first_event)
- {
- case XI_DeviceKeyPress:
- case XI_DeviceKeyRelease:
- {
- register XDeviceKeyEvent *ev = (XDeviceKeyEvent*) re;
- register deviceKeyButtonPointer *kev;
- register deviceValuator *vev;
-
- *count = 2;
- kev = (deviceKeyButtonPointer *) Xmalloc (*count * sizeof (xEvent));
- if (!kev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) kev;
-
- kev->type = ev->type;
- kev->root = ev->root;
- kev->event = ev->window;
- kev->child = ev->subwindow;
- kev->time = ev->time;
- kev->event_x = ev->x ;
- kev->event_y = ev->y ;
- kev->root_x = ev->x_root;
- kev->root_y = ev->y_root;
- kev->state = ev->state;
- kev->same_screen = ev->same_screen;
- kev->detail = ev->keycode;
- kev->deviceid = ev->deviceid | MORE_EVENTS;
-
- vev = (deviceValuator *) ++kev;
- vev->type = info->codes->first_event + XI_DeviceValuator;
- vev->deviceid = ev->deviceid;
- vev->device_state = ev->device_state;
- vev->first_valuator = ev->first_axis;
- vev->num_valuators = ev->axes_count;
- i = vev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: vev->valuator5 = ev->axis_data[5];
- case 5: vev->valuator4 = ev->axis_data[4];
- case 4: vev->valuator3 = ev->axis_data[3];
- case 3: vev->valuator2 = ev->axis_data[2];
- case 2: vev->valuator1 = ev->axis_data[1];
- case 1: vev->valuator0 = ev->axis_data[0];
- }
- break;
- }
- case XI_ProximityIn:
- case XI_ProximityOut:
- {
- register XProximityNotifyEvent *ev =
- (XProximityNotifyEvent *) re;
- register deviceKeyButtonPointer *pev;
- register deviceValuator *vev;
-
- *count = 2;
- pev = (deviceKeyButtonPointer *) Xmalloc (*count * sizeof (xEvent));
- if (!pev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) pev;
-
- pev->type = ev->type;
- pev->root = ev->root;
- pev->event = ev->window;
- pev->child = ev->subwindow;
- pev->time = ev->time;
- pev->event_x = ev->x ;
- pev->event_y = ev->y ;
- pev->root_x = ev->x_root;
- pev->root_y = ev->y_root;
- pev->state = ev->state;
- pev->same_screen = ev->same_screen;
- pev->deviceid = ev->deviceid | MORE_EVENTS;
-
- vev = (deviceValuator *) ++pev;
- vev->type = info->codes->first_event + XI_DeviceValuator;
- vev->deviceid = ev->deviceid;
- vev->device_state = ev->device_state;
- vev->first_valuator = ev->first_axis;
- vev->num_valuators = ev->axes_count;
-
- i = vev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: vev->valuator5 = ev->axis_data[5];
- case 5: vev->valuator4 = ev->axis_data[4];
- case 4: vev->valuator3 = ev->axis_data[3];
- case 3: vev->valuator2 = ev->axis_data[2];
- case 2: vev->valuator1 = ev->axis_data[1];
- case 1: vev->valuator0 = ev->axis_data[0];
- }
- break;
+ switch ((re->type & 0x7f) - info->codes->first_event) {
+ case XI_DeviceKeyPress:
+ case XI_DeviceKeyRelease:
+ {
+ register XDeviceKeyEvent *ev = (XDeviceKeyEvent *) re;
+ register deviceKeyButtonPointer *kev;
+ register deviceValuator *vev;
+
+ *count = 2;
+ kev = (deviceKeyButtonPointer *) Xmalloc(*count * sizeof(xEvent));
+ if (!kev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) kev;
+
+ kev->type = ev->type;
+ kev->root = ev->root;
+ kev->event = ev->window;
+ kev->child = ev->subwindow;
+ kev->time = ev->time;
+ kev->event_x = ev->x;
+ kev->event_y = ev->y;
+ kev->root_x = ev->x_root;
+ kev->root_y = ev->y_root;
+ kev->state = ev->state;
+ kev->same_screen = ev->same_screen;
+ kev->detail = ev->keycode;
+ kev->deviceid = ev->deviceid | MORE_EVENTS;
+
+ vev = (deviceValuator *)++ kev;
+ vev->type = info->codes->first_event + XI_DeviceValuator;
+ vev->deviceid = ev->deviceid;
+ vev->device_state = ev->device_state;
+ vev->first_valuator = ev->first_axis;
+ vev->num_valuators = ev->axes_count;
+ i = vev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ vev->valuator5 = ev->axis_data[5];
+ case 5:
+ vev->valuator4 = ev->axis_data[4];
+ case 4:
+ vev->valuator3 = ev->axis_data[3];
+ case 3:
+ vev->valuator2 = ev->axis_data[2];
+ case 2:
+ vev->valuator1 = ev->axis_data[1];
+ case 1:
+ vev->valuator0 = ev->axis_data[0];
+ }
+ break;
+ }
+ case XI_ProximityIn:
+ case XI_ProximityOut:
+ {
+ register XProximityNotifyEvent *ev = (XProximityNotifyEvent *) re;
+ register deviceKeyButtonPointer *pev;
+ register deviceValuator *vev;
+
+ *count = 2;
+ pev = (deviceKeyButtonPointer *) Xmalloc(*count * sizeof(xEvent));
+ if (!pev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) pev;
+
+ pev->type = ev->type;
+ pev->root = ev->root;
+ pev->event = ev->window;
+ pev->child = ev->subwindow;
+ pev->time = ev->time;
+ pev->event_x = ev->x;
+ pev->event_y = ev->y;
+ pev->root_x = ev->x_root;
+ pev->root_y = ev->y_root;
+ pev->state = ev->state;
+ pev->same_screen = ev->same_screen;
+ pev->deviceid = ev->deviceid | MORE_EVENTS;
+
+ vev = (deviceValuator *)++ pev;
+ vev->type = info->codes->first_event + XI_DeviceValuator;
+ vev->deviceid = ev->deviceid;
+ vev->device_state = ev->device_state;
+ vev->first_valuator = ev->first_axis;
+ vev->num_valuators = ev->axes_count;
+
+ i = vev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ vev->valuator5 = ev->axis_data[5];
+ case 5:
+ vev->valuator4 = ev->axis_data[4];
+ case 4:
+ vev->valuator3 = ev->axis_data[3];
+ case 3:
+ vev->valuator2 = ev->axis_data[2];
+ case 2:
+ vev->valuator1 = ev->axis_data[1];
+ case 1:
+ vev->valuator0 = ev->axis_data[0];
+ }
+ break;
+ }
+ case XI_DeviceButtonPress:
+ case XI_DeviceButtonRelease:
+ {
+ register XDeviceButtonEvent *ev = (XDeviceButtonEvent *) re;
+ register deviceKeyButtonPointer *bev;
+ register deviceValuator *vev;
+
+ *count = 2;
+ bev = (deviceKeyButtonPointer *) Xmalloc(*count * sizeof(xEvent));
+ if (!bev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) bev;
+
+ bev->type = ev->type;
+ bev->root = ev->root;
+ bev->event = ev->window;
+ bev->child = ev->subwindow;
+ bev->time = ev->time;
+ bev->event_x = ev->x;
+ bev->event_y = ev->y;
+ bev->root_x = ev->x_root;
+ bev->root_y = ev->y_root;
+ bev->state = ev->state;
+ bev->same_screen = ev->same_screen;
+ bev->detail = ev->button;
+ bev->deviceid = ev->deviceid | MORE_EVENTS;
+
+ vev = (deviceValuator *)++ bev;
+ vev->type = info->codes->first_event + XI_DeviceValuator;
+ vev->deviceid = ev->deviceid;
+ vev->device_state = ev->device_state;
+ vev->first_valuator = ev->first_axis;
+ vev->num_valuators = ev->axes_count;
+
+ i = vev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ vev->valuator5 = ev->axis_data[5];
+ case 5:
+ vev->valuator4 = ev->axis_data[4];
+ case 4:
+ vev->valuator3 = ev->axis_data[3];
+ case 3:
+ vev->valuator2 = ev->axis_data[2];
+ case 2:
+ vev->valuator1 = ev->axis_data[1];
+ case 1:
+ vev->valuator0 = ev->axis_data[0];
+ }
+ break;
+ }
+ case XI_DeviceMotionNotify:
+ {
+ register XDeviceMotionEvent *ev = (XDeviceMotionEvent *) re;
+ register deviceKeyButtonPointer *mev;
+ register deviceValuator *vev;
+
+ *count = 2;
+ mev = (deviceKeyButtonPointer *) Xmalloc(*count * sizeof(xEvent));
+ if (!mev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) mev;
+
+ mev->type = ev->type;
+ mev->root = ev->root;
+ mev->event = ev->window;
+ mev->child = ev->subwindow;
+ mev->time = ev->time;
+ mev->event_x = ev->x;
+ mev->event_y = ev->y;
+ mev->root_x = ev->x_root;
+ mev->root_y = ev->y_root;
+ mev->state = ev->state;
+ mev->same_screen = ev->same_screen;
+ mev->detail = ev->is_hint;
+ mev->deviceid = ev->deviceid | MORE_EVENTS;
+
+ vev = (deviceValuator *)++ mev;
+ vev->type = info->codes->first_event + XI_DeviceValuator;
+ vev->deviceid = ev->deviceid;
+ vev->device_state = ev->device_state;
+ vev->first_valuator = ev->first_axis;
+ vev->num_valuators = ev->axes_count;
+
+ i = vev->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ vev->valuator5 = ev->axis_data[5];
+ case 5:
+ vev->valuator4 = ev->axis_data[4];
+ case 4:
+ vev->valuator3 = ev->axis_data[3];
+ case 3:
+ vev->valuator2 = ev->axis_data[2];
+ case 2:
+ vev->valuator1 = ev->axis_data[1];
+ case 1:
+ vev->valuator0 = ev->axis_data[0];
+ }
+ break;
+ }
+ case XI_DeviceFocusIn:
+ case XI_DeviceFocusOut:
+ {
+ register XDeviceFocusChangeEvent *ev = (XDeviceFocusChangeEvent *) re;
+ register deviceFocus *fev;
+
+ *count = 1;
+ fev = (deviceFocus *) Xmalloc(*count * sizeof(xEvent));
+ if (!fev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) fev;
+
+ fev->type = ev->type;
+ fev->window = ev->window;
+ fev->mode = ev->mode;
+ fev->detail = ev->detail;
+ fev->time = ev->time;
+ fev->deviceid = ev->deviceid;
+ break;
+ }
+ case XI_DeviceMappingNotify:
+ {
+ register XDeviceMappingEvent *ev = (XDeviceMappingEvent *) re;
+ register deviceMappingNotify *mev;
+
+ *count = 1;
+ mev = (deviceMappingNotify *) Xmalloc(*count * sizeof(xEvent));
+ if (!mev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) mev;
+
+ mev->type = ev->type;
+ mev->firstKeyCode = ev->first_keycode;
+ mev->request = ev->request;
+ mev->count = ev->count;
+ mev->time = ev->time;
+ mev->deviceid = ev->deviceid;
+ break;
+ }
+ case XI_DeviceStateNotify:
+ {
+ register XDeviceStateNotifyEvent *ev = (XDeviceStateNotifyEvent *) re;
+ register deviceStateNotify *sev;
+ register xEvent *tev;
+ XInputClass *any = (XInputClass *) & ev->data[0];
+ unsigned char *sav_id;
+
+ *count = 1;
+
+ for (i = 0; i < ev->num_classes; i++) {
+ if (any->class == KeyClass) {
+ XKeyStatus *k = (XKeyStatus *) any;
+
+ if (k->num_keys > 32)
+ (*count)++;
+ } else if (any->class == ButtonClass) {
+ XButtonStatus *b = (XButtonStatus *) any;
+
+ if (b->num_buttons > 32)
+ (*count)++;
+ } else if (any->class == ValuatorClass) {
+ XValuatorStatus *v = (XValuatorStatus *) any;
+
+ if (v->num_valuators > 3)
+ (*count)++;
}
- case XI_DeviceButtonPress:
- case XI_DeviceButtonRelease:
- {
- register XDeviceButtonEvent *ev =
- (XDeviceButtonEvent *) re;
- register deviceKeyButtonPointer *bev;
- register deviceValuator *vev;
-
- *count = 2;
- bev = (deviceKeyButtonPointer *) Xmalloc (*count * sizeof (xEvent));
- if (!bev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) bev;
-
- bev->type = ev->type;
- bev->root = ev->root;
- bev->event = ev->window;
- bev->child = ev->subwindow;
- bev->time = ev->time;
- bev->event_x = ev->x ;
- bev->event_y = ev->y ;
- bev->root_x = ev->x_root;
- bev->root_y = ev->y_root;
- bev->state = ev->state;
- bev->same_screen = ev->same_screen;
- bev->detail = ev->button;
- bev->deviceid = ev->deviceid | MORE_EVENTS;
-
- vev = (deviceValuator *) ++bev;
- vev->type = info->codes->first_event + XI_DeviceValuator;
- vev->deviceid = ev->deviceid;
- vev->device_state = ev->device_state;
- vev->first_valuator = ev->first_axis;
- vev->num_valuators = ev->axes_count;
-
- i = vev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: vev->valuator5 = ev->axis_data[5];
- case 5: vev->valuator4 = ev->axis_data[4];
- case 4: vev->valuator3 = ev->axis_data[3];
- case 3: vev->valuator2 = ev->axis_data[2];
- case 2: vev->valuator1 = ev->axis_data[1];
- case 1: vev->valuator0 = ev->axis_data[0];
+ any = (XInputClass *) ((char *)any + any->length);
+ }
+
+ sev = (deviceStateNotify *) Xmalloc(*count * sizeof(xEvent));
+ if (!sev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) sev;
+ tev = (xEvent *) (sev + 1);
+
+ sev->type = ev->type;
+ sev->deviceid = ev->deviceid;
+ sav_id = &(sev->deviceid);
+ sev->time = ev->time;
+ sev->classes_reported = 0;
+
+ any = (XInputClass *) & ev->data[0];
+ for (i = 0; i < ev->num_classes; i++) {
+ if (any->class == KeyClass) {
+ XKeyStatus *k = (XKeyStatus *) any;
+ register deviceKeyStateNotify *kev;
+
+ sev->classes_reported |= (1 << KeyClass);
+ sev->num_keys = k->num_keys;
+ memcpy((char *)(sev->keys), (char *)(k->keys), 4);
+ if (k->num_keys > 32) {
+ kev = (deviceKeyStateNotify *) tev++;
+ kev->type = info->codes->first_event +
+ XI_DeviceKeystateNotify;
+ kev->deviceid = ev->deviceid;
+ *sav_id |= MORE_EVENTS;
+ sav_id = &(kev->deviceid);
+ memcpy((char *)(kev->keys), (char *)(&k->keys[4]), 28);
}
- break;
- }
- case XI_DeviceMotionNotify:
- {
- register XDeviceMotionEvent *ev =
- (XDeviceMotionEvent *)re;
- register deviceKeyButtonPointer *mev;
- register deviceValuator *vev;
-
- *count = 2;
- mev = (deviceKeyButtonPointer *) Xmalloc (*count * sizeof (xEvent));
- if (!mev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) mev;
-
- mev->type = ev->type;
- mev->root = ev->root;
- mev->event = ev->window;
- mev->child = ev->subwindow;
- mev->time = ev->time;
- mev->event_x = ev->x ;
- mev->event_y = ev->y ;
- mev->root_x = ev->x_root;
- mev->root_y = ev->y_root;
- mev->state = ev->state;
- mev->same_screen = ev->same_screen;
- mev->detail = ev->is_hint;
- mev->deviceid = ev->deviceid | MORE_EVENTS;
-
- vev = (deviceValuator *) ++mev;
- vev->type = info->codes->first_event + XI_DeviceValuator;
- vev->deviceid = ev->deviceid;
- vev->device_state = ev->device_state;
- vev->first_valuator = ev->first_axis;
- vev->num_valuators = ev->axes_count;
-
- i = vev->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: vev->valuator5 = ev->axis_data[5];
- case 5: vev->valuator4 = ev->axis_data[4];
- case 4: vev->valuator3 = ev->axis_data[3];
- case 3: vev->valuator2 = ev->axis_data[2];
- case 2: vev->valuator1 = ev->axis_data[1];
- case 1: vev->valuator0 = ev->axis_data[0];
+ } else if (any->class == ButtonClass) {
+ XButtonStatus *b = (XButtonStatus *) any;
+ register deviceButtonStateNotify *bev;
+
+ sev->classes_reported |= (1 << ButtonClass);
+ sev->num_buttons = b->num_buttons;
+ memcpy((char *)(sev->buttons), (char *)(b->buttons), 4);
+ if (b->num_buttons > 32) {
+ bev = (deviceButtonStateNotify *) tev++;
+ bev->type = info->codes->first_event +
+ XI_DeviceButtonstateNotify;
+ bev->deviceid = ev->deviceid;
+ *sav_id |= MORE_EVENTS;
+ sav_id = &(bev->deviceid);
+ memcpy((char *)(bev->buttons), (char *)(&b->buttons[4]),
+ 28);
}
- break;
- }
- case XI_DeviceFocusIn:
- case XI_DeviceFocusOut:
- {
- register XDeviceFocusChangeEvent *ev =
- (XDeviceFocusChangeEvent *) re;
- register deviceFocus *fev;
-
- *count = 1;
- fev = (deviceFocus *) Xmalloc (*count * sizeof (xEvent));
- if (!fev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) fev;
-
- fev->type = ev->type;
- fev->window = ev->window;
- fev->mode = ev->mode;
- fev->detail = ev->detail;
- fev->time = ev->time;
- fev->deviceid = ev->deviceid;
- break;
- }
- case XI_DeviceMappingNotify:
- {
- register XDeviceMappingEvent *ev = (XDeviceMappingEvent *) re;
- register deviceMappingNotify *mev;
-
- *count = 1;
- mev = (deviceMappingNotify *) Xmalloc (*count * sizeof (xEvent));
- if (!mev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) mev;
-
- mev->type = ev->type;
- mev->firstKeyCode = ev->first_keycode;
- mev->request = ev->request;
- mev->count = ev->count;
- mev->time = ev->time;
- mev->deviceid = ev->deviceid;
- break;
- }
- case XI_DeviceStateNotify:
- {
- register XDeviceStateNotifyEvent *ev =
- (XDeviceStateNotifyEvent *) re;
- register deviceStateNotify *sev;
- register xEvent *tev;
- XInputClass *any = (XInputClass *) &ev->data[0];
- unsigned char *sav_id;
- *count = 1;
-
- for (i=0; i<ev->num_classes; i++)
- {
- if (any->class == KeyClass)
- {
- XKeyStatus *k = (XKeyStatus *) any;
- if (k->num_keys > 32)
- (*count)++;
- }
- else if (any->class == ButtonClass)
- {
- XButtonStatus *b = (XButtonStatus *) any;
- if (b->num_buttons > 32)
- (*count)++;
- }
- else if (any->class == ValuatorClass)
- {
- XValuatorStatus *v = (XValuatorStatus *) any;
- if (v->num_valuators > 3)
- (*count)++;
- }
- any = (XInputClass *) ((char *) any + any->length);
+ } else if (any->class == ValuatorClass) {
+ XValuatorStatus *val = (XValuatorStatus *) any;
+ register deviceValuator *vev;
+
+ sev->classes_reported |= (1 << ValuatorClass);
+ sev->num_valuators = val->num_valuators < 3 ?
+ val->num_valuators : 3;
+ switch (sev->num_valuators) {
+ case 3:
+ sev->valuator2 = val->valuators[2];
+ case 2:
+ sev->valuator1 = val->valuators[1];
+ case 1:
+ sev->valuator0 = val->valuators[0];
}
-
- sev = (deviceStateNotify *) Xmalloc (*count * sizeof (xEvent));
- if (!sev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) sev;
- tev = (xEvent *) (sev+1);
-
- sev->type = ev->type;
- sev->deviceid = ev->deviceid;
- sav_id = &(sev->deviceid);
- sev->time = ev->time;
- sev->classes_reported = 0;
-
- any = (XInputClass *) &ev->data[0];
- for (i=0; i<ev->num_classes; i++)
- {
- if (any->class == KeyClass)
- {
- XKeyStatus *k = (XKeyStatus *) any;
- register deviceKeyStateNotify *kev;
-
- sev->classes_reported |= (1 << KeyClass);
- sev->num_keys = k->num_keys;
- memcpy ((char *) (sev->keys), (char *) (k->keys), 4);
- if (k->num_keys > 32)
- {
- kev = (deviceKeyStateNotify *) tev++;
- kev->type = info->codes->first_event +
- XI_DeviceKeystateNotify;
- kev->deviceid = ev->deviceid;
- *sav_id |= MORE_EVENTS;
- sav_id = &(kev->deviceid);
- memcpy ((char *) (kev->keys), (char *) (&k->keys[4]),
- 28);
- }
- }
- else if (any->class == ButtonClass)
- {
- XButtonStatus *b = (XButtonStatus *) any;
- register deviceButtonStateNotify *bev;
-
- sev->classes_reported |= (1 << ButtonClass);
- sev->num_buttons = b->num_buttons;
- memcpy ((char *) (sev->buttons), (char *) (b->buttons), 4);
- if (b->num_buttons > 32)
- {
- bev = (deviceButtonStateNotify *) tev++;
- bev->type = info->codes->first_event +
- XI_DeviceButtonstateNotify;
- bev->deviceid = ev->deviceid;
- *sav_id |= MORE_EVENTS;
- sav_id = &(bev->deviceid);
- memcpy ((char *)(bev->buttons), (char *)(&b->buttons[4]),
- 28);
- }
- }
- else if (any->class == ValuatorClass)
- {
- XValuatorStatus *val = (XValuatorStatus *) any;
- register deviceValuator *vev;
-
- sev->classes_reported |= (1 << ValuatorClass);
- sev->num_valuators = val->num_valuators < 3 ?
- val->num_valuators : 3;
- switch (sev->num_valuators)
- {
- case 3: sev->valuator2 = val->valuators[2];
- case 2: sev->valuator1 = val->valuators[1];
- case 1: sev->valuator0 = val->valuators[0];
- }
- if (val->num_valuators > 3)
- {
- vev = (deviceValuator *) tev++;
- vev->type = info->codes->first_event +
- XI_DeviceValuator;
- vev->deviceid = ev->deviceid;
- vev->first_valuator = 3;
- vev->num_valuators = val->num_valuators - 3;
- *sav_id |= MORE_EVENTS;
- sav_id = &(vev->deviceid);
- i = val->num_valuators;
- if (i > 6) i = 6;
- switch (i)
- {
- case 6: vev->valuator2 = val->valuators[5];
- case 5: vev->valuator1 = val->valuators[4];
- case 4: vev->valuator0 = val->valuators[3];
- }
- }
+ if (val->num_valuators > 3) {
+ vev = (deviceValuator *) tev++;
+ vev->type = info->codes->first_event + XI_DeviceValuator;
+ vev->deviceid = ev->deviceid;
+ vev->first_valuator = 3;
+ vev->num_valuators = val->num_valuators - 3;
+ *sav_id |= MORE_EVENTS;
+ sav_id = &(vev->deviceid);
+ i = val->num_valuators;
+ if (i > 6)
+ i = 6;
+ switch (i) {
+ case 6:
+ vev->valuator2 = val->valuators[5];
+ case 5:
+ vev->valuator1 = val->valuators[4];
+ case 4:
+ vev->valuator0 = val->valuators[3];
}
- any = (XInputClass *) ((char *) any + any->length);
}
- break;
}
- case XI_ChangeDeviceNotify:
- {
- register XChangeDeviceNotifyEvent *ev =
- (XChangeDeviceNotifyEvent *) re;
- register changeDeviceNotify *cev;
-
- *count = 1;
- cev = (changeDeviceNotify *) Xmalloc (*count * sizeof (xEvent));
- if (!cev)
- return(_XUnknownNativeEvent(dpy, re, *event));
- *event = (xEvent *) cev;
-
- cev->type = ev->type;
- cev->request = ev->request;
- cev->time = ev->time;
- cev->deviceid = ev->deviceid;
- break;
- }
- default:
- return(_XUnknownNativeEvent(dpy, re, *event));
+ any = (XInputClass *) ((char *)any + any->length);
}
- return(1);
+ break;
+ }
+ case XI_ChangeDeviceNotify:
+ {
+ register XChangeDeviceNotifyEvent *ev = (XChangeDeviceNotifyEvent *) re;
+ register changeDeviceNotify *cev;
+
+ *count = 1;
+ cev = (changeDeviceNotify *) Xmalloc(*count * sizeof(xEvent));
+ if (!cev)
+ return (_XUnknownNativeEvent(dpy, re, *event));
+ *event = (xEvent *) cev;
+
+ cev->type = ev->type;
+ cev->request = ev->request;
+ cev->time = ev->time;
+ cev->deviceid = ev->deviceid;
+ break;
+ }
+ default:
+ return (_XUnknownNativeEvent(dpy, re, *event));
}
+ return (1);
+}
diff --git a/src/XFreeLst.c b/src/XFreeLst.c
index 3966f3f..1805c30 100644
--- a/src/XFreeLst.c
+++ b/src/XFreeLst.c
@@ -62,12 +62,11 @@ SOFTWARE.
*
*/
-XFreeDeviceList (list)
+XFreeDeviceList(list)
XDeviceList *list;
- {
- if (list != NULL)
- {
- XFree ((list->name) - sizeof(XDeviceList));
- XFree ((XDeviceList *) list);
- }
+{
+ if (list != NULL) {
+ XFree((list->name) - sizeof(XDeviceList));
+ XFree((XDeviceList *) list);
}
+}
diff --git a/src/XGMotion.c b/src/XGMotion.c
index 4ce41bf..077bd88 100644
--- a/src/XGMotion.c
+++ b/src/XGMotion.c
@@ -61,82 +61,86 @@ SOFTWARE.
#include "XIint.h"
XDeviceTimeCoord
-*XGetDeviceMotionEvents (dpy, dev, start, stop, nEvents, mode, axis_count)
- register Display *dpy;
- XDevice *dev;
- Time start;
- Time stop;
- int *nEvents;
- int *mode;
- int *axis_count;
- {
- xGetDeviceMotionEventsReq *req;
- xGetDeviceMotionEventsReply rep;
+ * XGetDeviceMotionEvents(dpy, dev, start, stop, nEvents, mode, axis_count)
+ register Display *
+ dpy;
+ XDevice *
+ dev;
+ Time
+ start;
+ Time
+ stop;
+ int *
+ nEvents;
+ int *
+ mode;
+ int *
+ axis_count;
+{
+ xGetDeviceMotionEventsReq *req;
+ xGetDeviceMotionEventsReply rep;
XDeviceTimeCoord *tc;
int *data, *bufp, *readp, *savp;
long size, size2;
- int i, j;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ int i, j;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((XDeviceTimeCoord *) NoSuchExtension);
- GetReq(GetDeviceMotionEvents,req);
+ GetReq(GetDeviceMotionEvents, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetDeviceMotionEvents;
req->start = start;
req->stop = stop;
req->deviceid = dev->device_id;
- if (!_XReply (dpy, (xReply *)&rep, 0, xFalse)) {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
- SyncHandle();
+ SyncHandle();
*nEvents = 0;
return (NULL);
- }
+ }
*mode = rep.mode;
*axis_count = rep.axes;
*nEvents = rep.nEvents;
- if (!rep.nEvents)
- {
+ if (!rep.nEvents) {
UnlockDisplay(dpy);
- SyncHandle();
+ SyncHandle();
return (NULL);
- }
+ }
size = rep.length << 2;
- size2 = rep.nEvents *
- (sizeof (XDeviceTimeCoord) + (rep.axes * sizeof (int)));
- savp = readp = (int *) Xmalloc (size);
- bufp = (int *) Xmalloc (size2);
- if (!bufp || !savp)
- {
+ size2 = rep.nEvents * (sizeof(XDeviceTimeCoord) + (rep.axes * sizeof(int)));
+ savp = readp = (int *)Xmalloc(size);
+ bufp = (int *)Xmalloc(size2);
+ if (!bufp || !savp) {
*nEvents = 0;
- _XEatData (dpy, (unsigned long) size);
+ _XEatData(dpy, (unsigned long)size);
UnlockDisplay(dpy);
SyncHandle();
return (NULL);
- }
- _XRead (dpy, (char *) readp, size);
+ }
+ _XRead(dpy, (char *)readp, size);
tc = (XDeviceTimeCoord *) bufp;
- data = (int *) (tc + rep.nEvents);
- for (i=0; i<*nEvents; i++,tc++)
- {
+ data = (int *)(tc + rep.nEvents);
+ for (i = 0; i < *nEvents; i++, tc++) {
tc->time = *readp++;
tc->data = data;
- for (j=0; j<*axis_count; j++)
+ for (j = 0; j < *axis_count; j++)
*data++ = *readp++;
- }
- XFree ((char *)savp);
+ }
+ XFree((char *)savp);
UnlockDisplay(dpy);
SyncHandle();
return ((XDeviceTimeCoord *) bufp);
- }
+}
-void XFreeDeviceMotionEvents (events)
+void
+XFreeDeviceMotionEvents(events)
XDeviceTimeCoord *events;
- {
- XFree ((char *)events);
- }
+{
+ XFree((char *)events);
+}
diff --git a/src/XGetBMap.c b/src/XGetBMap.c
index 1c1658f..1eaaa23 100644
--- a/src/XGetBMap.c
+++ b/src/XGetBMap.c
@@ -60,22 +60,22 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-#ifdef MIN /* some systems define this in <sys/param.h> */
+#ifdef MIN /* some systems define this in <sys/param.h> */
#undef MIN
#endif
#define MIN(a, b) ((a) < (b) ? (a) : (b))
int
-XGetDeviceButtonMapping (dpy, device, map, nmap)
- register Display *dpy;
- XDevice *device;
- unsigned char map[];
- unsigned int nmap;
- {
- int status = 0;
- unsigned char mapping[256]; /* known fixed size */
+XGetDeviceButtonMapping(dpy, device, map, nmap)
+ register Display *dpy;
+ XDevice *device;
+ unsigned char map[];
+ unsigned int nmap;
+{
+ int status = 0;
+ unsigned char mapping[256]; /* known fixed size */
long nbytes;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
register xGetDeviceButtonMappingReq *req;
xGetDeviceButtonMappingReply rep;
@@ -89,20 +89,18 @@ XGetDeviceButtonMapping (dpy, device, map, nmap)
req->ReqType = X_GetDeviceButtonMapping;
req->deviceid = device->device_id;
- status = _XReply (dpy, (xReply *)&rep, 0, xFalse);
- if (status == 1)
- {
+ status = _XReply(dpy, (xReply *) & rep, 0, xFalse);
+ if (status == 1) {
nbytes = (long)rep.length << 2;
- _XRead (dpy, (char *)mapping, nbytes);
+ _XRead(dpy, (char *)mapping, nbytes);
/* don't return more data than the user asked for. */
- if (rep.nElts)
- memcpy ((char *) map, (char *) mapping, MIN((int)rep.nElts, nmap));
+ if (rep.nElts)
+ memcpy((char *)map, (char *)mapping, MIN((int)rep.nElts, nmap));
status = rep.nElts;
- }
- else
+ } else
status = 0;
UnlockDisplay(dpy);
SyncHandle();
return (status);
- }
+}
diff --git a/src/XGetDCtl.c b/src/XGetDCtl.c
index 66b3525..9862dcc 100644
--- a/src/XGetDCtl.c
+++ b/src/XGetDCtl.c
@@ -61,113 +61,111 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-XDeviceControl
-*XGetDeviceControl (dpy, dev, control)
- register Display *dpy;
- XDevice *dev;
- int control;
- {
- int size = 0;
- int nbytes, i;
+XDeviceControl * XGetDeviceControl(dpy, dev, control)
+ register Display *
+ dpy;
+ XDevice *
+ dev;
+ int
+ control;
+{
+ int size = 0;
+ int nbytes, i;
XDeviceControl *Device = NULL;
XDeviceControl *Sav = NULL;
xDeviceState *d = NULL;
xDeviceState *sav = NULL;
xGetDeviceControlReq *req;
xGetDeviceControlReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Add_XChangeDeviceControl) == -1)
return ((XDeviceControl *) NoSuchExtension);
- GetReq(GetDeviceControl,req);
+ GetReq(GetDeviceControl, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetDeviceControl;
req->deviceid = dev->device_id;
req->control = control;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (XDeviceControl *) NULL;
- }
- if (rep.length > 0)
- {
+ }
+ if (rep.length > 0) {
nbytes = (long)rep.length << 2;
- d = (xDeviceState *) Xmalloc((unsigned) nbytes);
- if (!d)
- {
- _XEatData (dpy, (unsigned long) nbytes);
+ d = (xDeviceState *) Xmalloc((unsigned)nbytes);
+ if (!d) {
+ _XEatData(dpy, (unsigned long)nbytes);
UnlockDisplay(dpy);
SyncHandle();
return (XDeviceControl *) NULL;
- }
+ }
sav = d;
- _XRead (dpy, (char *) d, nbytes);
-
- switch (d->control)
- {
- case DEVICE_RESOLUTION:
- {
- xDeviceResolutionState *r;
-
- r = (xDeviceResolutionState *) d;
- size += sizeof (XDeviceResolutionState) +
- (3 * sizeof(int) * r->num_valuators);
- break;
- }
- default:
- size += d->length;
- break;
- }
-
- Device = (XDeviceControl *) Xmalloc((unsigned) size);
- if (!Device)
- {
+ _XRead(dpy, (char *)d, nbytes);
+
+ switch (d->control) {
+ case DEVICE_RESOLUTION:
+ {
+ xDeviceResolutionState *r;
+
+ r = (xDeviceResolutionState *) d;
+ size += sizeof(XDeviceResolutionState) +
+ (3 * sizeof(int) * r->num_valuators);
+ break;
+ }
+ default:
+ size += d->length;
+ break;
+ }
+
+ Device = (XDeviceControl *) Xmalloc((unsigned)size);
+ if (!Device) {
UnlockDisplay(dpy);
SyncHandle();
return (XDeviceControl *) NULL;
- }
+ }
Sav = Device;
d = sav;
- switch (control)
- {
- case DEVICE_RESOLUTION:
- {
- int *iptr, *iptr2;
- xDeviceResolutionState *r;
- XDeviceResolutionState *R;
- r = (xDeviceResolutionState *) d;
- R = (XDeviceResolutionState *) Device;
-
- R->control = DEVICE_RESOLUTION;
- R->length = sizeof (XDeviceResolutionState);
- R->num_valuators = r->num_valuators;
- iptr = (int *) (R+1);
- iptr2 = (int *) (r+1);
- R->resolutions = iptr;
- R->min_resolutions = iptr + R->num_valuators;
- R->max_resolutions = iptr + (2 * R->num_valuators);
- for (i=0; i < (3 * R->num_valuators); i++)
- *iptr++ = *iptr2++;
- break;
- }
- default:
- break;
- }
- XFree (sav);
+ switch (control) {
+ case DEVICE_RESOLUTION:
+ {
+ int *iptr, *iptr2;
+ xDeviceResolutionState *r;
+ XDeviceResolutionState *R;
+
+ r = (xDeviceResolutionState *) d;
+ R = (XDeviceResolutionState *) Device;
+
+ R->control = DEVICE_RESOLUTION;
+ R->length = sizeof(XDeviceResolutionState);
+ R->num_valuators = r->num_valuators;
+ iptr = (int *)(R + 1);
+ iptr2 = (int *)(r + 1);
+ R->resolutions = iptr;
+ R->min_resolutions = iptr + R->num_valuators;
+ R->max_resolutions = iptr + (2 * R->num_valuators);
+ for (i = 0; i < (3 * R->num_valuators); i++)
+ *iptr++ = *iptr2++;
+ break;
}
+ default:
+ break;
+ }
+ XFree(sav);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (Sav);
- }
+}
-void XFreeDeviceControl (control)
+void
+XFreeDeviceControl(control)
XDeviceControl *control;
- {
- XFree (control);
- }
+{
+ XFree(control);
+}
diff --git a/src/XGetFCtl.c b/src/XGetFCtl.c
index e34c7ce..1e90633 100644
--- a/src/XGetFCtl.c
+++ b/src/XGetFCtl.c
@@ -61,213 +61,214 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-XFeedbackState
-*XGetFeedbackControl (dpy, dev, num_feedbacks)
- register Display *dpy;
- XDevice *dev;
- int *num_feedbacks;
- {
- int size = 0;
- int nbytes, i;
+XFeedbackState * XGetFeedbackControl(dpy, dev, num_feedbacks)
+ register Display *
+ dpy;
+ XDevice *
+ dev;
+ int *
+ num_feedbacks;
+{
+ int size = 0;
+ int nbytes, i;
XFeedbackState *Feedback = NULL;
XFeedbackState *Sav = NULL;
xFeedbackState *f = NULL;
xFeedbackState *sav = NULL;
xGetFeedbackControlReq *req;
xGetFeedbackControlReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((XFeedbackState *) NoSuchExtension);
- GetReq(GetFeedbackControl,req);
+ GetReq(GetFeedbackControl, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetFeedbackControl;
req->deviceid = dev->device_id;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (XFeedbackState *) NULL;
- }
- if (rep.length > 0)
- {
+ }
+ if (rep.length > 0) {
*num_feedbacks = rep.num_feedbacks;
nbytes = (long)rep.length << 2;
- f = (xFeedbackState *) Xmalloc((unsigned) nbytes);
- if (!f)
- {
- _XEatData (dpy, (unsigned long) nbytes);
+ f = (xFeedbackState *) Xmalloc((unsigned)nbytes);
+ if (!f) {
+ _XEatData(dpy, (unsigned long)nbytes);
UnlockDisplay(dpy);
SyncHandle();
return (XFeedbackState *) NULL;
- }
+ }
sav = f;
- _XRead (dpy, (char *) f, nbytes);
+ _XRead(dpy, (char *)f, nbytes);
- for (i=0; i<*num_feedbacks; i++)
+ for (i = 0; i < *num_feedbacks; i++) {
+ switch (f->class) {
+ case KbdFeedbackClass:
+ size += sizeof(XKbdFeedbackState);
+ break;
+ case PtrFeedbackClass:
+ size += sizeof(XPtrFeedbackState);
+ break;
+ case IntegerFeedbackClass:
+ size += sizeof(XIntegerFeedbackState);
+ break;
+ case StringFeedbackClass:
{
- switch (f->class)
- {
- case KbdFeedbackClass:
- size += sizeof (XKbdFeedbackState);
- break;
- case PtrFeedbackClass:
- size += sizeof (XPtrFeedbackState);
- break;
- case IntegerFeedbackClass:
- size += sizeof (XIntegerFeedbackState);
- break;
- case StringFeedbackClass:
- {
- xStringFeedbackState *strf = (xStringFeedbackState *) f;
-
- size += sizeof (XStringFeedbackState) +
- (strf->num_syms_supported * sizeof (KeySym));
- }
- break;
- case LedFeedbackClass:
- size += sizeof (XLedFeedbackState);
- break;
- case BellFeedbackClass:
- size += sizeof (XBellFeedbackState);
- break;
- default:
- size += f->length;
- break;
- }
- f = (xFeedbackState *) ((char *) f + f->length);
+ xStringFeedbackState *strf = (xStringFeedbackState *) f;
+
+ size += sizeof(XStringFeedbackState) +
+ (strf->num_syms_supported * sizeof(KeySym));
+ }
+ break;
+ case LedFeedbackClass:
+ size += sizeof(XLedFeedbackState);
+ break;
+ case BellFeedbackClass:
+ size += sizeof(XBellFeedbackState);
+ break;
+ default:
+ size += f->length;
+ break;
}
+ f = (xFeedbackState *) ((char *)f + f->length);
+ }
- Feedback = (XFeedbackState *) Xmalloc((unsigned) size);
- if (!Feedback)
- {
+ Feedback = (XFeedbackState *) Xmalloc((unsigned)size);
+ if (!Feedback) {
UnlockDisplay(dpy);
SyncHandle();
return (XFeedbackState *) NULL;
- }
+ }
Sav = Feedback;
f = sav;
- for (i=0; i<*num_feedbacks; i++)
+ for (i = 0; i < *num_feedbacks; i++) {
+ switch (f->class) {
+ case KbdFeedbackClass:
{
- switch (f->class)
- {
- case KbdFeedbackClass:
- {
- xKbdFeedbackState *k;
- XKbdFeedbackState *K;
- k = (xKbdFeedbackState *) f;
- K = (XKbdFeedbackState *) Feedback;
-
- K->class = k->class;
- K->length = sizeof (XKbdFeedbackState);
- K->id = k->id;
- K->click = k->click;
- K->percent = k->percent;
- K->pitch = k->pitch;
- K->duration = k->duration;
- K->led_mask = k->led_mask;
- K->global_auto_repeat = k->global_auto_repeat;
- memcpy ((char *) &K->auto_repeats[0],
- (char *) &k->auto_repeats[0], 32);
- break;
- }
- case PtrFeedbackClass:
- {
- xPtrFeedbackState *p;
- XPtrFeedbackState *P;
- p = (xPtrFeedbackState *) f;
- P = (XPtrFeedbackState *) Feedback;
-
- P->class = p->class;
- P->length = sizeof (XPtrFeedbackState);
- P->id = p->id;
- P->accelNum = p->accelNum;
- P->accelDenom = p->accelDenom;
- P->threshold = p->threshold;
- break;
- }
- case IntegerFeedbackClass:
- {
- xIntegerFeedbackState *i;
- XIntegerFeedbackState *I;
- i = (xIntegerFeedbackState *) f;
- I = (XIntegerFeedbackState *) Feedback;
-
- I->class = i->class;
- I->length = sizeof (XIntegerFeedbackState);
- I->id = i->id;
- I->resolution = i->resolution;
- I->minVal = i->min_value;
- I->maxVal = i->max_value;
- break;
- }
- case StringFeedbackClass:
- {
- xStringFeedbackState *s;
- XStringFeedbackState *S;
- s = (xStringFeedbackState *) f;
- S = (XStringFeedbackState *) Feedback;
-
- S->class = s->class;
- S->length = sizeof (XStringFeedbackState) +
- (s->num_syms_supported * sizeof (KeySym));
- S->id = s->id;
- S->max_symbols = s->max_symbols;
- S->num_syms_supported = s->num_syms_supported;
- S->syms_supported = (KeySym *) (S+1);
- memcpy ((char *) S->syms_supported, (char *) (s+1),
- (S->num_syms_supported * sizeof (KeySym)));
- break;
- }
- case LedFeedbackClass:
- {
- xLedFeedbackState *l;
- XLedFeedbackState *L;
- l = (xLedFeedbackState *) f;
- L = (XLedFeedbackState *) Feedback;
-
- L->class = l->class;
- L->length = sizeof (XLedFeedbackState);
- L->id = l->id;
- L->led_values = l->led_values;
- L->led_mask = l->led_mask;
- break;
- }
- case BellFeedbackClass:
- {
- xBellFeedbackState *b;
- XBellFeedbackState *B;
- b = (xBellFeedbackState *) f;
- B = (XBellFeedbackState *) Feedback;
-
- B->class = b->class;
- B->length = sizeof (XBellFeedbackState);
- B->id = b->id;
- B->percent = b->percent;
- B->pitch = b->pitch;
- B->duration = b->duration;
- break;
- }
- default:
- break;
- }
- f = (xFeedbackState *) ((char *) f + f->length);
- Feedback = (XFeedbackState *) ((char *) Feedback+Feedback->length);
+ xKbdFeedbackState *k;
+ XKbdFeedbackState *K;
+
+ k = (xKbdFeedbackState *) f;
+ K = (XKbdFeedbackState *) Feedback;
+
+ K->class = k->class;
+ K->length = sizeof(XKbdFeedbackState);
+ K->id = k->id;
+ K->click = k->click;
+ K->percent = k->percent;
+ K->pitch = k->pitch;
+ K->duration = k->duration;
+ K->led_mask = k->led_mask;
+ K->global_auto_repeat = k->global_auto_repeat;
+ memcpy((char *)&K->auto_repeats[0],
+ (char *)&k->auto_repeats[0], 32);
+ break;
}
- XFree ((char *)sav);
+ case PtrFeedbackClass:
+ {
+ xPtrFeedbackState *p;
+ XPtrFeedbackState *P;
+
+ p = (xPtrFeedbackState *) f;
+ P = (XPtrFeedbackState *) Feedback;
+
+ P->class = p->class;
+ P->length = sizeof(XPtrFeedbackState);
+ P->id = p->id;
+ P->accelNum = p->accelNum;
+ P->accelDenom = p->accelDenom;
+ P->threshold = p->threshold;
+ break;
+ }
+ case IntegerFeedbackClass:
+ {
+ xIntegerFeedbackState *i;
+ XIntegerFeedbackState *I;
+
+ i = (xIntegerFeedbackState *) f;
+ I = (XIntegerFeedbackState *) Feedback;
+
+ I->class = i->class;
+ I->length = sizeof(XIntegerFeedbackState);
+ I->id = i->id;
+ I->resolution = i->resolution;
+ I->minVal = i->min_value;
+ I->maxVal = i->max_value;
+ break;
+ }
+ case StringFeedbackClass:
+ {
+ xStringFeedbackState *s;
+ XStringFeedbackState *S;
+
+ s = (xStringFeedbackState *) f;
+ S = (XStringFeedbackState *) Feedback;
+
+ S->class = s->class;
+ S->length = sizeof(XStringFeedbackState) +
+ (s->num_syms_supported * sizeof(KeySym));
+ S->id = s->id;
+ S->max_symbols = s->max_symbols;
+ S->num_syms_supported = s->num_syms_supported;
+ S->syms_supported = (KeySym *) (S + 1);
+ memcpy((char *)S->syms_supported, (char *)(s + 1),
+ (S->num_syms_supported * sizeof(KeySym)));
+ break;
+ }
+ case LedFeedbackClass:
+ {
+ xLedFeedbackState *l;
+ XLedFeedbackState *L;
+
+ l = (xLedFeedbackState *) f;
+ L = (XLedFeedbackState *) Feedback;
+
+ L->class = l->class;
+ L->length = sizeof(XLedFeedbackState);
+ L->id = l->id;
+ L->led_values = l->led_values;
+ L->led_mask = l->led_mask;
+ break;
+ }
+ case BellFeedbackClass:
+ {
+ xBellFeedbackState *b;
+ XBellFeedbackState *B;
+
+ b = (xBellFeedbackState *) f;
+ B = (XBellFeedbackState *) Feedback;
+
+ B->class = b->class;
+ B->length = sizeof(XBellFeedbackState);
+ B->id = b->id;
+ B->percent = b->percent;
+ B->pitch = b->pitch;
+ B->duration = b->duration;
+ break;
+ }
+ default:
+ break;
+ }
+ f = (xFeedbackState *) ((char *)f + f->length);
+ Feedback = (XFeedbackState *) ((char *)Feedback + Feedback->length);
}
+ XFree((char *)sav);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (Sav);
- }
+}
-void XFreeFeedbackList (list)
+void
+XFreeFeedbackList(list)
XFeedbackState *list;
- {
- XFree ((char *)list);
- }
+{
+ XFree((char *)list);
+}
diff --git a/src/XGetKMap.c b/src/XGetKMap.c
index c794006..59f6f93 100644
--- a/src/XGetKMap.c
+++ b/src/XGetKMap.c
@@ -61,51 +61,47 @@ SOFTWARE.
#include "XIint.h"
KeySym *
-XGetDeviceKeyMapping (
- register Display *dpy,
- XDevice *dev,
+XGetDeviceKeyMapping(register Display * dpy, XDevice * dev,
#if NeedWidePrototypes
- unsigned int first,
+ unsigned int first,
#else
- KeyCode first,
+ KeyCode first,
#endif
- int keycount,
- int *syms_per_code)
- {
+ int keycount, int *syms_per_code)
+{
long nbytes;
register KeySym *mapping = NULL;
xGetDeviceKeyMappingReq *req;
xGetDeviceKeyMappingReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((KeySym *) NoSuchExtension);
- GetReq(GetDeviceKeyMapping,req);
+ GetReq(GetDeviceKeyMapping, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetDeviceKeyMapping;
req->deviceid = dev->device_id;
req->firstKeyCode = first;
req->count = keycount;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (KeySym *) NULL;
- }
+ }
if (rep.length > 0) {
- *syms_per_code = rep.keySymsPerKeyCode;
+ *syms_per_code = rep.keySymsPerKeyCode;
nbytes = (long)rep.length << 2;
- mapping = (KeySym *) Xmalloc((unsigned) nbytes);
+ mapping = (KeySym *) Xmalloc((unsigned)nbytes);
if (mapping)
- _XRead (dpy, (char *)mapping, nbytes);
+ _XRead(dpy, (char *)mapping, nbytes);
else
- _XEatData (dpy, (unsigned long) nbytes);
- }
+ _XEatData(dpy, (unsigned long)nbytes);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (mapping);
- }
+}
diff --git a/src/XGetMMap.c b/src/XGetMMap.c
index 04e89d8..b952a2f 100644
--- a/src/XGetMMap.c
+++ b/src/XGetMMap.c
@@ -60,45 +60,44 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-XModifierKeymap
-*XGetDeviceModifierMapping (dpy, dev)
- register Display *dpy;
- XDevice *dev;
- {
+XModifierKeymap * XGetDeviceModifierMapping(dpy, dev)
+ register Display *
+ dpy;
+ XDevice *
+ dev;
+{
unsigned long nbytes;
XModifierKeymap *res;
xGetDeviceModifierMappingReq *req;
xGetDeviceModifierMappingReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((XModifierKeymap *) NoSuchExtension);
- GetReq(GetDeviceModifierMapping,req);
+ GetReq(GetDeviceModifierMapping, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetDeviceModifierMapping;
req->deviceid = dev->device_id;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (XModifierKeymap *) NULL;
- }
+ }
nbytes = (unsigned long)rep.length << 2;
- res = (XModifierKeymap *) Xmalloc(sizeof (XModifierKeymap));
- if (res)
- {
- res->modifiermap = (KeyCode *) Xmalloc (nbytes);
+ res = (XModifierKeymap *) Xmalloc(sizeof(XModifierKeymap));
+ if (res) {
+ res->modifiermap = (KeyCode *) Xmalloc(nbytes);
if (res->modifiermap)
- _XReadPad(dpy, (char *) res->modifiermap, nbytes);
+ _XReadPad(dpy, (char *)res->modifiermap, nbytes);
else
- _XEatData (dpy, (unsigned long) nbytes);
+ _XEatData(dpy, (unsigned long)nbytes);
res->max_keypermod = rep.numKeyPerModifier;
- }
+ }
UnlockDisplay(dpy);
SyncHandle();
return (res);
- }
+}
diff --git a/src/XGetProp.c b/src/XGetProp.c
index ed5a2d1..59b8b87 100644
--- a/src/XGetProp.c
+++ b/src/XGetProp.c
@@ -61,60 +61,56 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-XEventClass
-*XGetDeviceDontPropagateList (dpy, window, count)
- register Display *dpy;
- Window window;
- int *count;
- {
- XEventClass *list = NULL;
- int rlen;
- xGetDeviceDontPropagateListReq *req;
- xGetDeviceDontPropagateListReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XEventClass * XGetDeviceDontPropagateList(dpy, window, count)
+ register Display *
+ dpy;
+ Window
+ window;
+ int *
+ count;
+{
+ XEventClass *list = NULL;
+ int rlen;
+ xGetDeviceDontPropagateListReq *req;
+ xGetDeviceDontPropagateListReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((XEventClass *) NoSuchExtension);
- GetReq(GetDeviceDontPropagateList,req);
+ GetReq(GetDeviceDontPropagateList, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetDeviceDontPropagateList;
req->window = window;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (XEventClass *) NULL;
- }
+ }
*count = rep.count;
- if (*count)
- {
+ if (*count) {
rlen = rep.length << 2;
- list = (XEventClass *) Xmalloc (rep.length * sizeof(XEventClass));
- if (list)
- {
- int i;
- CARD32 ec;
-
- /* read and assign each XEventClass separately because
- * the library representation may not be the same size
- * as the wire representation (64 bit machines)
- */
- for (i = 0; i < rep.length; i++)
- {
- _XRead (dpy, (char *)(&ec), sizeof(CARD32));
- list[i] = (XEventClass)ec;
- }
+ list = (XEventClass *) Xmalloc(rep.length * sizeof(XEventClass));
+ if (list) {
+ int i;
+ CARD32 ec;
+
+ /* read and assign each XEventClass separately because
+ * the library representation may not be the same size
+ * as the wire representation (64 bit machines)
+ */
+ for (i = 0; i < rep.length; i++) {
+ _XRead(dpy, (char *)(&ec), sizeof(CARD32));
+ list[i] = (XEventClass) ec;
}
- else
- _XEatData (dpy, (unsigned long) rlen);
- }
+ } else
+ _XEatData(dpy, (unsigned long)rlen);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (list);
- }
-
+}
diff --git a/src/XGetVers.c b/src/XGetVers.c
index 3180837..1f4fd7a 100644
--- a/src/XGetVers.c
+++ b/src/XGetVers.c
@@ -61,55 +61,47 @@ SOFTWARE.
#include "XIint.h"
XExtensionVersion *
-XGetExtensionVersion (
- register Display *dpy,
- _Xconst char *name)
- {
- XExtensionVersion *ext;
-
- LockDisplay (dpy);
- ext = _XiGetExtensionVersion (dpy, name);
+XGetExtensionVersion(register Display * dpy, _Xconst char *name)
+{
+ XExtensionVersion *ext;
+
+ LockDisplay(dpy);
+ ext = _XiGetExtensionVersion(dpy, name);
if (ext != (XExtensionVersion *) NoSuchExtension) {
- UnlockDisplay (dpy);
+ UnlockDisplay(dpy);
SyncHandle();
}
return (ext);
- }
+}
XExtensionVersion *
-_XiGetExtensionVersion (
- register Display *dpy,
- _Xconst char *name)
- {
- xGetExtensionVersionReq *req;
- xGetExtensionVersionReply rep;
- XExtensionVersion *ext;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+_XiGetExtensionVersion(register Display * dpy, _Xconst char *name)
+{
+ xGetExtensionVersionReq *req;
+ xGetExtensionVersionReply rep;
+ XExtensionVersion *ext;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
if (_XiCheckExtInit(dpy, Dont_Check) == -1)
return ((XExtensionVersion *) NoSuchExtension);
- GetReq(GetExtensionVersion,req);
+ GetReq(GetExtensionVersion, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetExtensionVersion;
req->nbytes = name ? strlen(name) : 0;
- req->length += (unsigned)(req->nbytes+3)>>2;
+ req->length += (unsigned)(req->nbytes + 3) >> 2;
_XSend(dpy, name, (long)req->nbytes);
- if (! _XReply (dpy, (xReply *) &rep, 0, xTrue))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) {
return (XExtensionVersion *) NULL;
- }
- ext = (XExtensionVersion *) Xmalloc (sizeof (XExtensionVersion));
- if (ext)
- {
+ }
+ ext = (XExtensionVersion *) Xmalloc(sizeof(XExtensionVersion));
+ if (ext) {
ext->present = rep.present;
- if (ext->present)
- {
+ if (ext->present) {
ext->major_version = rep.major_version;
ext->minor_version = rep.minor_version;
- }
}
- return (ext);
}
-
+ return (ext);
+}
diff --git a/src/XGrDvBut.c b/src/XGrDvBut.c
index 48381f8..fbc26ba 100644
--- a/src/XGrDvBut.c
+++ b/src/XGrDvBut.c
@@ -61,25 +61,25 @@ SOFTWARE.
#include "XIint.h"
int
-XGrabDeviceButton (dpy, dev, button, modifiers, modifier_device,
- grab_window, owner_events, event_count, event_list, this_device_mode,
- other_devices_mode)
- register Display *dpy;
- XDevice *dev;
- unsigned int button; /* CARD8 */
- unsigned int modifiers; /* CARD16 */
- XDevice *modifier_device;
- Window grab_window;
- Bool owner_events;
- unsigned int event_count;
- XEventClass *event_list;
- int this_device_mode;
- int other_devices_mode;
- {
+XGrabDeviceButton(dpy, dev, button, modifiers, modifier_device,
+ grab_window, owner_events, event_count, event_list,
+ this_device_mode, other_devices_mode)
+ register Display *dpy;
+ XDevice *dev;
+ unsigned int button; /* CARD8 */
+ unsigned int modifiers; /* CARD16 */
+ XDevice *modifier_device;
+ Window grab_window;
+ Bool owner_events;
+ unsigned int event_count;
+ XEventClass *event_list;
+ int this_device_mode;
+ int other_devices_mode;
+{
register xGrabDeviceButtonReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
@@ -102,13 +102,13 @@ XGrabDeviceButton (dpy, dev, button, modifiers, modifier_device,
req->length += event_count;
/* note: Data is a macro that uses its arguments multiple
- times, so "nvalues" is changed in a separate assignment
- statement */
+ * times, so "nvalues" is changed in a separate assignment
+ * statement */
event_count <<= 2;
- Data32 (dpy, (long *) event_list, event_count);
+ Data32(dpy, (long *)event_list, event_count);
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XGrDvKey.c b/src/XGrDvKey.c
index 94e9ba4..6731e2c 100644
--- a/src/XGrDvKey.c
+++ b/src/XGrDvKey.c
@@ -61,25 +61,25 @@ SOFTWARE.
#include "XIint.h"
int
-XGrabDeviceKey (dpy, dev, key, modifiers, modifier_device,
- grab_window, owner_events, event_count, event_list, this_device_mode,
- other_devices_mode)
- register Display *dpy;
- XDevice *dev;
- unsigned int key; /* CARD8 */
- unsigned int modifiers; /* CARD16 */
- XDevice *modifier_device;
- Window grab_window;
- Bool owner_events;
- unsigned int event_count;
- XEventClass *event_list;
- int this_device_mode;
- int other_devices_mode;
- {
+XGrabDeviceKey(dpy, dev, key, modifiers, modifier_device,
+ grab_window, owner_events, event_count, event_list,
+ this_device_mode, other_devices_mode)
+ register Display *dpy;
+ XDevice *dev;
+ unsigned int key; /* CARD8 */
+ unsigned int modifiers; /* CARD16 */
+ XDevice *modifier_device;
+ Window grab_window;
+ Bool owner_events;
+ unsigned int event_count;
+ XEventClass *event_list;
+ int this_device_mode;
+ int other_devices_mode;
+{
register xGrabDeviceKeyReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
@@ -102,16 +102,15 @@ XGrabDeviceKey (dpy, dev, key, modifiers, modifier_device,
req->length += event_count;
/* note: Data is a macro that uses its arguments multiple
- times, so "nvalues" is changed in a separate assignment
- statement */
+ * times, so "nvalues" is changed in a separate assignment
+ * statement */
- if (event_count)
- {
+ if (event_count) {
event_count <<= 2;
- Data32 (dpy, (long *) event_list, event_count);
- }
+ Data32(dpy, (long *)event_list, event_count);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XGrabDev.c b/src/XGrabDev.c
index f49a6bd..536e369 100644
--- a/src/XGrabDev.c
+++ b/src/XGrabDev.c
@@ -60,31 +60,31 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-int
-XGrabDevice (dpy, dev, grab_window, ownerEvents, event_count, event_list,
- this_device_mode, other_devices_mode, time)
- register Display *dpy;
- XDevice *dev;
- Window grab_window;
- Bool ownerEvents;
- int event_count;
- XEventClass *event_list;
- int this_device_mode;
- int other_devices_mode;
- Time time;
- {
+int
+XGrabDevice(dpy, dev, grab_window, ownerEvents, event_count, event_list,
+ this_device_mode, other_devices_mode, time)
+ register Display *dpy;
+ XDevice *dev;
+ Window grab_window;
+ Bool ownerEvents;
+ int event_count;
+ XEventClass *event_list;
+ int this_device_mode;
+ int other_devices_mode;
+ Time time;
+{
xGrabDeviceReply rep;
register xGrabDeviceReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(GrabDevice,req);
+ GetReq(GrabDevice, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GrabDevice;
-
+
req->deviceid = dev->device_id;
req->grabWindow = grab_window;
req->ownerEvents = ownerEvents;
@@ -95,15 +95,15 @@ XGrabDevice (dpy, dev, grab_window, ownerEvents, event_count, event_list,
req->length += event_count;
/* note: Data is a macro that uses its arguments multiple
- times, so "nvalues" is changed in a separate assignment
- statement */
+ * times, so "nvalues" is changed in a separate assignment
+ * statement */
event_count <<= 2;
- Data32 (dpy, (long *) event_list, event_count);
+ Data32(dpy, (long *)event_list, event_count);
- if (_XReply (dpy, (xReply *) &rep, 0, xTrue) == 0)
+ if (_XReply(dpy, (xReply *) & rep, 0, xTrue) == 0)
rep.status = GrabSuccess;
UnlockDisplay(dpy);
SyncHandle();
return (rep.status);
- }
+}
diff --git a/src/XGtFocus.c b/src/XGtFocus.c
index 29e8de7..08cebd9 100644
--- a/src/XGtFocus.c
+++ b/src/XGtFocus.c
@@ -61,32 +61,31 @@ SOFTWARE.
#include "XIint.h"
int
-XGetDeviceFocus (dpy, dev, focus, revert_to, time)
+XGetDeviceFocus(dpy, dev, focus, revert_to, time)
register Display *dpy;
XDevice *dev;
Window *focus;
int *revert_to;
Time *time;
- {
- xGetDeviceFocusReq *req;
- xGetDeviceFocusReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ xGetDeviceFocusReq *req;
+ xGetDeviceFocusReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(GetDeviceFocus,req);
+ GetReq(GetDeviceFocus, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetDeviceFocus;
req->deviceid = dev->device_id;
- (void) _XReply (dpy, (xReply *) &rep, 0, xTrue);
+ (void)_XReply(dpy, (xReply *) & rep, 0, xTrue);
*focus = rep.focus;
*revert_to = rep.revertTo;
*time = rep.time;
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
-
+}
diff --git a/src/XGtSelect.c b/src/XGtSelect.c
index 9663653..0f63caf 100644
--- a/src/XGtSelect.c
+++ b/src/XGtSelect.c
@@ -61,86 +61,79 @@ SOFTWARE.
#include "XIint.h"
int
-XGetSelectedExtensionEvents (dpy, w, this_client_count, this_client_list,
- all_clients_count, all_clients_list)
- register Display *dpy;
- Window w;
- int *this_client_count;
- XEventClass **this_client_list;
- int *all_clients_count;
- XEventClass **all_clients_list;
- {
- int tlen, alen;
- register xGetSelectedExtensionEventsReq *req;
+XGetSelectedExtensionEvents(dpy, w, this_client_count, this_client_list,
+ all_clients_count, all_clients_list)
+ register Display *dpy;
+ Window w;
+ int *this_client_count;
+ XEventClass **this_client_list;
+ int *all_clients_count;
+ XEventClass **all_clients_list;
+{
+ int tlen, alen;
+ register xGetSelectedExtensionEventsReq *req;
xGetSelectedExtensionEventsReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(GetSelectedExtensionEvents,req);
+ GetReq(GetSelectedExtensionEvents, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetSelectedExtensionEvents;
req->window = w;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return Success;
- }
+ }
*this_client_count = rep.this_client_count;
*all_clients_count = rep.all_clients_count;
- if (rep.length)
- {
+ if (rep.length) {
int i;
CARD32 ec;
+
tlen = (*this_client_count) * sizeof(CARD32);
alen = (rep.length << 2) - tlen;
- if (tlen)
- {
- *this_client_list = (XEventClass *) Xmalloc (
- *this_client_count * sizeof(XEventClass));
- if (!*this_client_list)
- {
- _XEatData (dpy, (unsigned long) tlen+alen);
+ if (tlen) {
+ *this_client_list =
+ (XEventClass *) Xmalloc(*this_client_count *
+ sizeof(XEventClass));
+ if (!*this_client_list) {
+ _XEatData(dpy, (unsigned long)tlen + alen);
return (Success);
- }
- for (i = 0; i < *this_client_count; i++)
- {
- _XRead (dpy, (char *)(&ec), sizeof(CARD32));
- (*this_client_list)[i] = (XEventClass)ec;
- }
}
- else
+ for (i = 0; i < *this_client_count; i++) {
+ _XRead(dpy, (char *)(&ec), sizeof(CARD32));
+ (*this_client_list)[i] = (XEventClass) ec;
+ }
+ } else
*this_client_list = (XEventClass *) NULL;
- if (alen)
- {
- *all_clients_list = (XEventClass *) Xmalloc (
- *all_clients_count * sizeof(XEventClass));
- if (!*all_clients_list)
- {
+ if (alen) {
+ *all_clients_list =
+ (XEventClass *) Xmalloc(*all_clients_count *
+ sizeof(XEventClass));
+ if (!*all_clients_list) {
Xfree((char *)*this_client_list);
*this_client_list = NULL;
- _XEatData (dpy, (unsigned long) alen);
+ _XEatData(dpy, (unsigned long)alen);
return (Success);
- }
- for (i = 0; i < *all_clients_count; i++)
- {
- _XRead (dpy, (char *)(&ec), sizeof(CARD32));
- (*all_clients_list)[i] = (XEventClass)ec;
- }
}
- else
+ for (i = 0; i < *all_clients_count; i++) {
+ _XRead(dpy, (char *)(&ec), sizeof(CARD32));
+ (*all_clients_list)[i] = (XEventClass) ec;
+ }
+ } else
*all_clients_list = (XEventClass *) NULL;
- }
+ }
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XIint.h b/src/XIint.h
index fdca57d..ba965a6 100644
--- a/src/XIint.h
+++ b/src/XIint.h
@@ -8,18 +8,10 @@
#ifndef _XIINT_H_
#define _XIINT_H_
-extern XExtDisplayInfo * XInput_find_display(
- Display*
-);
+extern XExtDisplayInfo *XInput_find_display(Display *);
-extern int _XiCheckExtInit(
- Display*,
- int
-);
+extern int _XiCheckExtInit(Display *, int);
-extern XExtensionVersion * _XiGetExtensionVersion(
- Display*,
- _Xconst char*
-);
+extern XExtensionVersion *_XiGetExtensionVersion(Display *, _Xconst char *);
#endif
diff --git a/src/XListDev.c b/src/XListDev.c
index 279bede..e834e6a 100644
--- a/src/XListDev.c
+++ b/src/XListDev.c
@@ -63,185 +63,174 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-XDeviceInfo
-*XListInputDevices(dpy, ndevices)
- register Display *dpy;
- int *ndevices;
- {
- int size;
- xListInputDevicesReq *req;
- xListInputDevicesReply rep;
- xDeviceInfo *list, *slist = NULL;
- XDeviceInfo *sclist = NULL;
- XDeviceInfo *clist = NULL;
- xAnyClassPtr any, sav_any;
- XAnyClassPtr Any;
- char *nptr, *Nptr;
- register int i,j,k;
- register long rlen;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XDeviceInfo * XListInputDevices(dpy, ndevices)
+ register Display *
+ dpy;
+ int *
+ ndevices;
+{
+ int size;
+ xListInputDevicesReq *req;
+ xListInputDevicesReply rep;
+ xDeviceInfo *list, *slist = NULL;
+ XDeviceInfo *sclist = NULL;
+ XDeviceInfo *clist = NULL;
+ xAnyClassPtr any, sav_any;
+ XAnyClassPtr Any;
+ char *nptr, *Nptr;
+ register int i, j, k;
+ register long rlen;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((XDeviceInfo *) NULL);
- GetReq(ListInputDevices,req);
+ GetReq(ListInputDevices, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ListInputDevices;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (XDeviceInfo *) NULL;
- }
+ }
- if ((*ndevices = rep.ndevices)) /* at least 1 input device */
- {
- size = *ndevices * sizeof (XDeviceInfo);
- rlen = rep.length << 2; /* multiply length by 4 */
- list = (xDeviceInfo *) Xmalloc (rlen);
+ if ((*ndevices = rep.ndevices)) { /* at least 1 input device */
+ size = *ndevices * sizeof(XDeviceInfo);
+ rlen = rep.length << 2; /* multiply length by 4 */
+ list = (xDeviceInfo *) Xmalloc(rlen);
slist = list;
- if (!slist)
- {
- _XEatData (dpy, (unsigned long) rlen);
+ if (!slist) {
+ _XEatData(dpy, (unsigned long)rlen);
UnlockDisplay(dpy);
SyncHandle();
return (XDeviceInfo *) NULL;
- }
- _XRead (dpy, (char *)list, rlen);
+ }
+ _XRead(dpy, (char *)list, rlen);
- any = (xAnyClassPtr) ((char *) list +
- (*ndevices * sizeof(xDeviceInfo)));
+ any = (xAnyClassPtr) ((char *)list + (*ndevices * sizeof(xDeviceInfo)));
sav_any = any;
- for (i=0; i<*ndevices; i++, list++)
- {
- for (j=0; j<(int)list->num_classes; j++)
+ for (i = 0; i < *ndevices; i++, list++) {
+ for (j = 0; j < (int)list->num_classes; j++) {
+ switch (any->class) {
+ case KeyClass:
+ size += sizeof(XKeyInfo);
+ break;
+ case ButtonClass:
+ size += sizeof(XButtonInfo);
+ break;
+ case ValuatorClass:
{
- switch (any->class)
- {
- case KeyClass:
- size += sizeof (XKeyInfo);
- break;
- case ButtonClass:
- size += sizeof (XButtonInfo);
- break;
- case ValuatorClass:
- {
- xValuatorInfoPtr v;
- v = (xValuatorInfoPtr) any;
- size += sizeof (XValuatorInfo) +
- (v->num_axes * sizeof (XAxisInfo));
- break;
- }
- default:
- break;
- }
- any = (xAnyClassPtr) ((char *) any + any->length);
+ xValuatorInfoPtr v;
+
+ v = (xValuatorInfoPtr) any;
+ size += sizeof(XValuatorInfo) +
+ (v->num_axes * sizeof(XAxisInfo));
+ break;
+ }
+ default:
+ break;
}
+ any = (xAnyClassPtr) ((char *)any + any->length);
}
+ }
- for (i=0, nptr = (char *) any; i<*ndevices; i++)
- {
- size += *nptr +1;
+ for (i = 0, nptr = (char *)any; i < *ndevices; i++) {
+ size += *nptr + 1;
nptr += (*nptr + 1);
- }
+ }
- clist = (XDeviceInfoPtr) Xmalloc (size);
- if (!clist)
- {
- XFree ((char *)slist);
+ clist = (XDeviceInfoPtr) Xmalloc(size);
+ if (!clist) {
+ XFree((char *)slist);
UnlockDisplay(dpy);
SyncHandle();
return (XDeviceInfo *) NULL;
- }
+ }
sclist = clist;
- Any = (XAnyClassPtr) ((char *) clist +
- (*ndevices * sizeof (XDeviceInfo)));
+ Any = (XAnyClassPtr) ((char *)clist +
+ (*ndevices * sizeof(XDeviceInfo)));
list = slist;
any = sav_any;
- for (i=0; i<*ndevices; i++, list++, clist++)
- {
- clist->type = list->type;
+ for (i = 0; i < *ndevices; i++, list++, clist++) {
+ clist->type = list->type;
clist->id = list->id;
clist->use = list->use;
clist->num_classes = list->num_classes;
clist->inputclassinfo = Any;
- for (j=0; j<(int)list->num_classes; j++)
+ for (j = 0; j < (int)list->num_classes; j++) {
+ switch (any->class) {
+ case KeyClass:
+ {
+ XKeyInfoPtr K = (XKeyInfoPtr) Any;
+ xKeyInfoPtr k = (xKeyInfoPtr) any;
+
+ K->class = KeyClass;
+ K->length = sizeof(XKeyInfo);
+ K->min_keycode = k->min_keycode;
+ K->max_keycode = k->max_keycode;
+ K->num_keys = k->num_keys;
+ break;
+ }
+ case ButtonClass:
{
- switch (any->class)
- {
- case KeyClass:
- {
- XKeyInfoPtr K = (XKeyInfoPtr) Any;
- xKeyInfoPtr k = (xKeyInfoPtr) any;
- K->class = KeyClass;
- K->length = sizeof (XKeyInfo);
- K->min_keycode = k->min_keycode;
- K->max_keycode = k->max_keycode;
- K->num_keys = k->num_keys;
- break;
- }
- case ButtonClass:
- {
- XButtonInfoPtr B = (XButtonInfoPtr) Any;
- xButtonInfoPtr b = (xButtonInfoPtr) any;
- B->class = ButtonClass;
- B->length = sizeof (XButtonInfo);
- B->num_buttons = b->num_buttons;
- break;
- }
- case ValuatorClass:
- {
- XValuatorInfoPtr V = (XValuatorInfoPtr) Any;
- xValuatorInfoPtr v = (xValuatorInfoPtr) any;
- XAxisInfoPtr A;
- xAxisInfoPtr a;
+ XButtonInfoPtr B = (XButtonInfoPtr) Any;
+ xButtonInfoPtr b = (xButtonInfoPtr) any;
- V->class = ValuatorClass;
- V->length = sizeof (XValuatorInfo) +
- (v->num_axes * sizeof (XAxisInfo));
- V->num_axes = v->num_axes;
- V->motion_buffer = v->motion_buffer_size;
- V->mode = v->mode;
- A = (XAxisInfoPtr) ((char *) V + sizeof(XValuatorInfo));
- V->axes = A;
- a = (xAxisInfoPtr) ((char *) any +
- sizeof (xValuatorInfo));
- for (k=0; k<(int)v->num_axes; k++,a++,A++)
- {
- A->min_value = a->min_value;
- A->max_value = a->max_value;
- A->resolution = a->resolution;
- }
- break;
- }
- default:
- break;
+ B->class = ButtonClass;
+ B->length = sizeof(XButtonInfo);
+ B->num_buttons = b->num_buttons;
+ break;
+ }
+ case ValuatorClass:
+ {
+ XValuatorInfoPtr V = (XValuatorInfoPtr) Any;
+ xValuatorInfoPtr v = (xValuatorInfoPtr) any;
+ XAxisInfoPtr A;
+ xAxisInfoPtr a;
+
+ V->class = ValuatorClass;
+ V->length = sizeof(XValuatorInfo) +
+ (v->num_axes * sizeof(XAxisInfo));
+ V->num_axes = v->num_axes;
+ V->motion_buffer = v->motion_buffer_size;
+ V->mode = v->mode;
+ A = (XAxisInfoPtr) ((char *)V + sizeof(XValuatorInfo));
+ V->axes = A;
+ a = (xAxisInfoPtr) ((char *)any + sizeof(xValuatorInfo));
+ for (k = 0; k < (int)v->num_axes; k++, a++, A++) {
+ A->min_value = a->min_value;
+ A->max_value = a->max_value;
+ A->resolution = a->resolution;
}
- any = (xAnyClassPtr) ((char *) any + any->length);
- Any = (XAnyClassPtr) ((char *) Any + Any->length);
+ break;
}
+ default:
+ break;
+ }
+ any = (xAnyClassPtr) ((char *)any + any->length);
+ Any = (XAnyClassPtr) ((char *)Any + Any->length);
}
+ }
clist = sclist;
- nptr = (char *) any;
- Nptr = (char *) Any;
- for (i=0; i<*ndevices; i++,clist++)
- {
- clist->name = (char *) Nptr;
- memcpy (Nptr, nptr+1, *nptr);
+ nptr = (char *)any;
+ Nptr = (char *)Any;
+ for (i = 0; i < *ndevices; i++, clist++) {
+ clist->name = (char *)Nptr;
+ memcpy(Nptr, nptr + 1, *nptr);
Nptr += (*nptr);
*Nptr++ = '\0';
nptr += (*nptr + 1);
- }
}
+ }
- XFree ((char *)slist);
+ XFree((char *)slist);
UnlockDisplay(dpy);
SyncHandle();
return (sclist);
- }
+}
/***********************************************************************
*
@@ -249,11 +238,11 @@ XDeviceInfo
*
*/
-void XFreeDeviceList (list)
+void
+XFreeDeviceList(list)
XDeviceInfo *list;
- {
- if (list != NULL)
- {
- XFree ((char *) list);
- }
+{
+ if (list != NULL) {
+ XFree((char *)list);
}
+}
diff --git a/src/XOpenDev.c b/src/XOpenDev.c
index 7930a9a..c98204d 100644
--- a/src/XOpenDev.c
+++ b/src/XOpenDev.c
@@ -60,54 +60,51 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-XDevice
-*XOpenDevice(dpy, id)
- register Display *dpy;
- register XID id;
- {
- register long rlen; /* raw length */
- xOpenDeviceReq *req;
- xOpenDeviceReply rep;
- XDevice *dev;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XDevice * XOpenDevice(dpy, id)
+ register Display *
+ dpy;
+ register XID
+ id;
+{
+ register long rlen; /* raw length */
+ xOpenDeviceReq *req;
+ xOpenDeviceReply rep;
+ XDevice *dev;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((XDevice *) NoSuchExtension);
- GetReq(OpenDevice,req);
+ GetReq(OpenDevice, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_OpenDevice;
req->deviceid = id;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (XDevice *) NULL;
- }
+ }
rlen = rep.length << 2;
- dev = (XDevice *) Xmalloc (sizeof(XDevice) + rep.num_classes *
- sizeof (XInputClassInfo));
- if (dev)
- {
- int dlen; /* data length */
+ dev = (XDevice *) Xmalloc(sizeof(XDevice) + rep.num_classes *
+ sizeof(XInputClassInfo));
+ if (dev) {
+ int dlen; /* data length */
dev->device_id = req->deviceid;
dev->num_classes = rep.num_classes;
- dev->classes = (XInputClassInfo *) ((char *) dev + sizeof (XDevice));
+ dev->classes = (XInputClassInfo *) ((char *)dev + sizeof(XDevice));
dlen = rep.num_classes * sizeof(xInputClassInfo);
- _XRead (dpy, (char *)dev->classes, dlen);
+ _XRead(dpy, (char *)dev->classes, dlen);
/* could be padding that we still need to eat (yummy!) */
- if(rlen - dlen > 0)
- _XEatData (dpy, (unsigned long) rlen - dlen);
- }
- else
- _XEatData (dpy, (unsigned long) rlen);
+ if (rlen - dlen > 0)
+ _XEatData(dpy, (unsigned long)rlen - dlen);
+ } else
+ _XEatData(dpy, (unsigned long)rlen);
- UnlockDisplay (dpy);
+ UnlockDisplay(dpy);
SyncHandle();
return (dev);
- }
-
+}
diff --git a/src/XQueryDv.c b/src/XQueryDv.c
index 1450c15..94d0f9a 100644
--- a/src/XQueryDv.c
+++ b/src/XQueryDv.c
@@ -60,139 +60,135 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-XDeviceState
-*XQueryDeviceState (dpy, dev)
- register Display *dpy;
- XDevice *dev;
- {
- int i,j;
- int rlen;
- int size = 0;
- xQueryDeviceStateReq *req;
- xQueryDeviceStateReply rep;
- XDeviceState *state = NULL;
- XInputClass *any, *Any;
- char *data;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XDeviceState * XQueryDeviceState(dpy, dev)
+ register Display *
+ dpy;
+ XDevice *
+ dev;
+{
+ int i, j;
+ int rlen;
+ int size = 0;
+ xQueryDeviceStateReq *req;
+ xQueryDeviceStateReply rep;
+ XDeviceState *state = NULL;
+ XInputClass *any, *Any;
+ char *data;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return ((XDeviceState *) NoSuchExtension);
- GetReq(QueryDeviceState,req);
+ GetReq(QueryDeviceState, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_QueryDeviceState;
req->deviceid = dev->device_id;
- if (! _XReply (dpy, (xReply *) &rep, 0, xFalse))
- {
+ if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
return (XDeviceState *) NULL;
- }
+ }
rlen = rep.length << 2;
- if (rlen > 0)
- {
- data = Xmalloc (rlen);
- if (!data)
- {
- _XEatData (dpy, (unsigned long) rlen);
- UnlockDisplay(dpy);
- SyncHandle();
- return ((XDeviceState *) NULL);
- }
- _XRead (dpy, data, rlen);
-
- for (i=0, any=(XInputClass *) data; i<(int)rep.num_classes; i++)
+ if (rlen > 0) {
+ data = Xmalloc(rlen);
+ if (!data) {
+ _XEatData(dpy, (unsigned long)rlen);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return ((XDeviceState *) NULL);
+ }
+ _XRead(dpy, data, rlen);
+
+ for (i = 0, any = (XInputClass *) data; i < (int)rep.num_classes; i++) {
+ switch (any->class) {
+ case KeyClass:
+ size += sizeof(XKeyState);
+ break;
+ case ButtonClass:
+ size += sizeof(XButtonState);
+ break;
+ case ValuatorClass:
{
- switch (any->class)
- {
- case KeyClass:
- size += sizeof (XKeyState);
- break;
- case ButtonClass:
- size += sizeof (XButtonState);
- break;
- case ValuatorClass:
- {
- xValuatorState *v = (xValuatorState *) any;
- size += (sizeof (XValuatorState) +
- (v->num_valuators * sizeof(int)));
- }
- break;
- }
- any = (XInputClass *) ((char *) any + any->length);
+ xValuatorState *v = (xValuatorState *) any;
+ size += (sizeof(XValuatorState) +
+ (v->num_valuators * sizeof(int)));
}
- state = (XDeviceState *) Xmalloc (size + sizeof(XDeviceState));
- if (!state)
- {
- UnlockDisplay(dpy);
- SyncHandle();
- return ((XDeviceState *) NULL);
+ break;
}
+ any = (XInputClass *) ((char *)any + any->length);
+ }
+ state = (XDeviceState *) Xmalloc(size + sizeof(XDeviceState));
+ if (!state) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return ((XDeviceState *) NULL);
+ }
state->device_id = dev->device_id;
state->num_classes = rep.num_classes;
state->data = (XInputClass *) (state + 1);
- Any = state->data;
- for (i=0, any=(XInputClass *) data; i<(int)rep.num_classes; i++)
+ Any = state->data;
+ for (i = 0, any = (XInputClass *) data; i < (int)rep.num_classes; i++) {
+ switch (any->class) {
+ case KeyClass:
{
- switch (any->class)
- {
- case KeyClass:
- {
- xKeyState *k = (xKeyState *) any;
- XKeyState *K = (XKeyState *) Any;
- K->class = k->class;
- K->length = sizeof (XKeyState);
- K->num_keys = k->num_keys;
- memcpy ((char *) &K->keys[0], (char *) &k->keys[0], 32);
- Any = (XInputClass *) (K+1);
- }
- break;
- case ButtonClass:
- {
- xButtonState *b = (xButtonState *) any;
- XButtonState *B = (XButtonState *) Any;
- B->class = b->class;
- B->length = sizeof (XButtonState);
- B->num_buttons = b->num_buttons;
- memcpy ((char *) &B->buttons[0], (char *) &b->buttons[0],
- 32);
- Any = (XInputClass *) (B+1);
- }
- break;
- case ValuatorClass:
- {
- xValuatorState *v = (xValuatorState *) any;
- XValuatorState *V = (XValuatorState *) Any;
- CARD32 *valuators = (CARD32 *) (v+1);
- V->class = v->class;
- V->length = sizeof (XValuatorState);
- V->num_valuators = v->num_valuators;
- V->mode = v->mode;
- Any = (XInputClass *) (V+1);
- V->valuators = (int *) Any;
- for (j=0; j<(int)V->num_valuators; j++)
- *(V->valuators + j) = *valuators++;
- Any = (XInputClass *)((char *) Any +
- V->num_valuators * sizeof (int));
- }
- break;
- }
- any = (XInputClass *) ((char *) any + any->length);
+ xKeyState *k = (xKeyState *) any;
+ XKeyState *K = (XKeyState *) Any;
+
+ K->class = k->class;
+ K->length = sizeof(XKeyState);
+ K->num_keys = k->num_keys;
+ memcpy((char *)&K->keys[0], (char *)&k->keys[0], 32);
+ Any = (XInputClass *) (K + 1);
}
- Xfree(data);
+ break;
+ case ButtonClass:
+ {
+ xButtonState *b = (xButtonState *) any;
+ XButtonState *B = (XButtonState *) Any;
+
+ B->class = b->class;
+ B->length = sizeof(XButtonState);
+ B->num_buttons = b->num_buttons;
+ memcpy((char *)&B->buttons[0], (char *)&b->buttons[0], 32);
+ Any = (XInputClass *) (B + 1);
+ }
+ break;
+ case ValuatorClass:
+ {
+ xValuatorState *v = (xValuatorState *) any;
+ XValuatorState *V = (XValuatorState *) Any;
+ CARD32 *valuators = (CARD32 *) (v + 1);
+
+ V->class = v->class;
+ V->length = sizeof(XValuatorState);
+ V->num_valuators = v->num_valuators;
+ V->mode = v->mode;
+ Any = (XInputClass *) (V + 1);
+ V->valuators = (int *)Any;
+ for (j = 0; j < (int)V->num_valuators; j++)
+ *(V->valuators + j) = *valuators++;
+ Any = (XInputClass *) ((char *)Any +
+ V->num_valuators * sizeof(int));
+ }
+ break;
+ }
+ any = (XInputClass *) ((char *)any + any->length);
}
+ Xfree(data);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (state);
- }
+}
-void XFreeDeviceState (list)
+void
+XFreeDeviceState(list)
XDeviceState *list;
- {
- XFree ((char *)list);
- }
+{
+ XFree((char *)list);
+}
diff --git a/src/XSelect.c b/src/XSelect.c
index c0a8dc8..b23829a 100644
--- a/src/XSelect.c
+++ b/src/XSelect.c
@@ -61,19 +61,19 @@ SOFTWARE.
#include "XIint.h"
int
-XSelectExtensionEvent (dpy, w, event_list, count)
- register Display *dpy;
- Window w;
- XEventClass *event_list;
- int count;
- {
- register xSelectExtensionEventReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
- if (_XiCheckExtInit(dpy,XInput_Initial_Release) == -1)
+XSelectExtensionEvent(dpy, w, event_list, count)
+ register Display *dpy;
+ Window w;
+ XEventClass *event_list;
+ int count;
+{
+ register xSelectExtensionEventReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
+ if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(SelectExtensionEvent,req);
+ GetReq(SelectExtensionEvent, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_SelectExtensionEvent;
@@ -82,13 +82,13 @@ XSelectExtensionEvent (dpy, w, event_list, count)
req->length += count;
/* note: Data is a macro that uses its arguments multiple
- times, so "nvalues" is changed in a separate assignment
- statement */
+ * times, so "nvalues" is changed in a separate assignment
+ * statement */
count <<= 2;
- Data32 (dpy, (long *) event_list, count);
+ Data32(dpy, (long *)event_list, count);
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XSetBMap.c b/src/XSetBMap.c
index 716d8c5..bdfe501 100644
--- a/src/XSetBMap.c
+++ b/src/XSetBMap.c
@@ -63,31 +63,31 @@ SOFTWARE.
/* returns either DeviceMappingSuccess or DeviceMappingBusy */
-int
-XSetDeviceButtonMapping (dpy, device, map, nmap)
- register Display *dpy;
- XDevice *device;
- unsigned char map[];
- int nmap;
- {
+int
+XSetDeviceButtonMapping(dpy, device, map, nmap)
+ register Display *dpy;
+ XDevice *device;
+ unsigned char map[];
+ int nmap;
+{
register xSetDeviceButtonMappingReq *req;
xSetDeviceButtonMappingReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ XExtDisplayInfo *info = XInput_find_display(dpy);
LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq (SetDeviceButtonMapping, req);
+ GetReq(SetDeviceButtonMapping, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_SetDeviceButtonMapping;
req->map_length = nmap;
- req->length += (nmap + 3)>>2;
+ req->length += (nmap + 3) >> 2;
req->deviceid = device->device_id;
- Data (dpy, (char *)map, (long) nmap); /* note that map is char[] */
- if (_XReply (dpy, (xReply *)&rep, 0, xFalse) == 0) /* suppress error */
+ Data(dpy, (char *)map, (long)nmap); /* note that map is char[] */
+ if (_XReply(dpy, (xReply *) & rep, 0, xFalse) == 0) /* suppress error */
rep.status = MappingSuccess;
UnlockDisplay(dpy);
SyncHandle();
- return ((int) rep.status);
- }
+ return ((int)rep.status);
+}
diff --git a/src/XSetDVal.c b/src/XSetDVal.c
index 3cee1a9..6b382f1 100644
--- a/src/XSetDVal.c
+++ b/src/XSetDVal.c
@@ -62,22 +62,22 @@ SOFTWARE.
#include "XIint.h"
int
-XSetDeviceValuators (dpy, dev, valuators, first_valuator, num_valuators)
- register Display *dpy;
- XDevice *dev;
- int *valuators;
- int first_valuator;
- int num_valuators;
- {
- xSetDeviceValuatorsReq *req;
- xSetDeviceValuatorsReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XSetDeviceValuators(dpy, dev, valuators, first_valuator, num_valuators)
+ register Display *dpy;
+ XDevice *dev;
+ int *valuators;
+ int first_valuator;
+ int num_valuators;
+{
+ xSetDeviceValuatorsReq *req;
+ xSetDeviceValuatorsReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Add_XSetDeviceValuators) == -1)
return (NoSuchExtension);
- GetReq(SetDeviceValuators,req);
+ GetReq(SetDeviceValuators, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_SetDeviceValuators;
req->deviceid = dev->device_id;
@@ -86,15 +86,14 @@ XSetDeviceValuators (dpy, dev, valuators, first_valuator, num_valuators)
req->length += num_valuators;
/* note: Data is a macro that uses its arguments multiple
- times, so "nvalues" is changed in a separate assignment
- statement */
+ * times, so "nvalues" is changed in a separate assignment
+ * statement */
num_valuators <<= 2;
- Data (dpy, (char *) valuators, num_valuators);
+ Data(dpy, (char *)valuators, num_valuators);
- (void) _XReply (dpy, (xReply *) &rep, 0, xTrue);
+ (void)_XReply(dpy, (xReply *) & rep, 0, xTrue);
UnlockDisplay(dpy);
SyncHandle();
return (rep.status);
- }
-
+}
diff --git a/src/XSetMMap.c b/src/XSetMMap.c
index d31197c..b0838f6 100644
--- a/src/XSetMMap.c
+++ b/src/XSetMMap.c
@@ -60,18 +60,18 @@ SOFTWARE.
#include <X11/extensions/extutil.h>
#include "XIint.h"
-int
-XSetDeviceModifierMapping (dpy, dev, modmap)
- register Display *dpy;
- XDevice *dev;
- XModifierKeymap *modmap;
- {
- int mapSize = modmap->max_keypermod << 3; /* 8 modifiers */
- xSetDeviceModifierMappingReq *req;
- xSetDeviceModifierMappingReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+int
+XSetDeviceModifierMapping(dpy, dev, modmap)
+ register Display *dpy;
+ XDevice *dev;
+ XModifierKeymap *modmap;
+{
+ int mapSize = modmap->max_keypermod << 3; /* 8 modifiers */
+ xSetDeviceModifierMappingReq *req;
+ xSetDeviceModifierMappingReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
@@ -82,10 +82,11 @@ XSetDeviceModifierMapping (dpy, dev, modmap)
req->numKeyPerModifier = modmap->max_keypermod;
memcpy((char *)&req[1], modmap->modifiermap, mapSize);
- (void) _XReply(dpy, (xReply *) &rep,
- (sizeof(xSetDeviceModifierMappingReply) - sizeof(xReply)) >> 2, xTrue);
+ (void)_XReply(dpy, (xReply *) & rep,
+ (sizeof(xSetDeviceModifierMappingReply) -
+ sizeof(xReply)) >> 2, xTrue);
UnlockDisplay(dpy);
SyncHandle();
return (rep.success);
- }
+}
diff --git a/src/XSetMode.c b/src/XSetMode.c
index 5f62fb1..278c4ff 100644
--- a/src/XSetMode.c
+++ b/src/XSetMode.c
@@ -61,28 +61,27 @@ SOFTWARE.
#include "XIint.h"
int
-XSetDeviceMode (dpy, dev, mode)
- register Display *dpy;
- XDevice *dev;
- int mode;
- {
- xSetDeviceModeReq *req;
- xSetDeviceModeReply rep;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XSetDeviceMode(dpy, dev, mode)
+ register Display *dpy;
+ XDevice *dev;
+ int mode;
+{
+ xSetDeviceModeReq *req;
+ xSetDeviceModeReply rep;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(SetDeviceMode,req);
+ GetReq(SetDeviceMode, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_SetDeviceMode;
req->deviceid = dev->device_id;
req->mode = mode;
- (void) _XReply (dpy, (xReply *) &rep, 0, xTrue);
+ (void)_XReply(dpy, (xReply *) & rep, 0, xTrue);
UnlockDisplay(dpy);
SyncHandle();
return (rep.status);
- }
-
+}
diff --git a/src/XSndExEv.c b/src/XSndExEv.c
index 28b654b..6d65745 100644
--- a/src/XSndExEv.c
+++ b/src/XSndExEv.c
@@ -63,61 +63,59 @@ SOFTWARE.
extern Status _XiEventToWire();
Status
-XSendExtensionEvent (dpy, dev, dest, prop, count, list, event)
- register Display *dpy;
- XDevice *dev;
- Window dest;
- Bool prop;
- int count;
- XEventClass *list;
- XEvent *event;
- {
- int num_events;
- int ev_size;
- xSendExtensionEventReq *req;
- xEvent *ev;
- register Status (**fp)();
- Status status;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
+XSendExtensionEvent(dpy, dev, dest, prop, count, list, event)
+ register Display *dpy;
+ XDevice *dev;
+ Window dest;
+ Bool prop;
+ int count;
+ XEventClass *list;
+ XEvent *event;
+{
+ int num_events;
+ int ev_size;
+ xSendExtensionEventReq *req;
+ xEvent *ev;
+ register Status(**fp) ();
+ Status status;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
/* call through display to find proper conversion routine */
fp = &dpy->wire_vec[event->type & 0177];
- if (*fp == NULL)
+ if (*fp == NULL)
*fp = _XiEventToWire;
- status = (**fp)(dpy, event, &ev, &num_events);
+ status = (**fp) (dpy, event, &ev, &num_events);
- if (status)
- {
- GetReq(SendExtensionEvent,req);
- req->reqType = info->codes->major_opcode;
+ if (status) {
+ GetReq(SendExtensionEvent, req);
+ req->reqType = info->codes->major_opcode;
req->ReqType = X_SendExtensionEvent;
req->deviceid = dev->device_id;
req->destination = dest;
req->propagate = prop;
req->count = count;
req->num_events = num_events;
- ev_size = num_events * sizeof (xEvent);
+ ev_size = num_events * sizeof(xEvent);
req->length += (count + (ev_size >> 2));
/* note: Data is a macro that uses its arguments multiple
- times, so "count" is changed in a separate assignment
- statement. Any extra events must be sent before the event
- list, in order to ensure quad alignment. */
+ * times, so "count" is changed in a separate assignment
+ * statement. Any extra events must be sent before the event
+ * list, in order to ensure quad alignment. */
- Data (dpy, (char *) ev, ev_size);
+ Data(dpy, (char *)ev, ev_size);
count <<= 2;
- Data32 (dpy, (long *) list, count);
- XFree ((char *)ev);
- }
+ Data32(dpy, (long *)list, count);
+ XFree((char *)ev);
+ }
UnlockDisplay(dpy);
SyncHandle();
return (status);
- }
-
+}
diff --git a/src/XStFocus.c b/src/XStFocus.c
index fc61896..08578c8 100644
--- a/src/XStFocus.c
+++ b/src/XStFocus.c
@@ -62,18 +62,18 @@ SOFTWARE.
int
XSetDeviceFocus(dpy, dev, focus, revert_to, time)
- register Display *dpy;
- XDevice *dev;
- Window focus;
- int revert_to;
- Time time;
- {
- xSetDeviceFocusReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
-
- LockDisplay (dpy);
-
- GetReq(SetDeviceFocus,req);
+ register Display *dpy;
+ XDevice *dev;
+ Window focus;
+ int revert_to;
+ Time time;
+{
+ xSetDeviceFocusReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
+
+ LockDisplay(dpy);
+
+ GetReq(SetDeviceFocus, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_SetDeviceFocus;
req->device = dev->device_id;
@@ -84,4 +84,4 @@ XSetDeviceFocus(dpy, dev, focus, revert_to, time)
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XUngrDev.c b/src/XUngrDev.c
index e3aec36..ecc8887 100644
--- a/src/XUngrDev.c
+++ b/src/XUngrDev.c
@@ -61,26 +61,26 @@ SOFTWARE.
#include "XIint.h"
int
-XUngrabDevice (dpy, dev, time)
+XUngrabDevice(dpy, dev, time)
register Display *dpy;
XDevice *dev;
Time time;
- {
- register xUngrabDeviceReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+{
+ register xUngrabDeviceReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
- LockDisplay (dpy);
+ LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
return (NoSuchExtension);
- GetReq(UngrabDevice,req);
+ GetReq(UngrabDevice, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_UngrabDevice;
-
+
req->deviceid = dev->device_id;
req->time = time;
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XUngrDvB.c b/src/XUngrDvB.c
index 7e96665..07f2c3f 100644
--- a/src/XUngrDvB.c
+++ b/src/XUngrDvB.c
@@ -62,15 +62,15 @@ SOFTWARE.
int
XUngrabDeviceButton(dpy, dev, button, modifiers, modifier_dev, grab_window)
- register Display *dpy;
- XDevice *dev;
- unsigned int button; /* CARD8 */
- unsigned int modifiers; /* CARD16 */
- XDevice *modifier_dev;
- Window grab_window;
- {
- register xUngrabDeviceButtonReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+ register Display *dpy;
+ XDevice *dev;
+ unsigned int button; /* CARD8 */
+ unsigned int modifiers; /* CARD16 */
+ XDevice *modifier_dev;
+ Window grab_window;
+{
+ register xUngrabDeviceButtonReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
@@ -90,4 +90,4 @@ XUngrabDeviceButton(dpy, dev, button, modifiers, modifier_dev, grab_window)
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}
diff --git a/src/XUngrDvK.c b/src/XUngrDvK.c
index 26a5841..e9e4cdf 100644
--- a/src/XUngrDvK.c
+++ b/src/XUngrDvK.c
@@ -61,16 +61,16 @@ SOFTWARE.
#include "XIint.h"
int
-XUngrabDeviceKey (dpy, dev, key, modifiers, modifier_dev, grab_window)
- register Display *dpy;
- XDevice *dev;
- unsigned int key; /* CARD8 */
- unsigned int modifiers; /* CARD16 */
- XDevice *modifier_dev;
- Window grab_window;
- {
- register xUngrabDeviceKeyReq *req;
- XExtDisplayInfo *info = XInput_find_display (dpy);
+XUngrabDeviceKey(dpy, dev, key, modifiers, modifier_dev, grab_window)
+ register Display *dpy;
+ XDevice *dev;
+ unsigned int key; /* CARD8 */
+ unsigned int modifiers; /* CARD16 */
+ XDevice *modifier_dev;
+ Window grab_window;
+{
+ register xUngrabDeviceKeyReq *req;
+ XExtDisplayInfo *info = XInput_find_display(dpy);
LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release) == -1)
@@ -90,4 +90,4 @@ XUngrabDeviceKey (dpy, dev, key, modifiers, modifier_dev, grab_window)
UnlockDisplay(dpy);
SyncHandle();
return (Success);
- }
+}