Merge remote-tracking branch 'whot/for-keith'

Xext/xtest.c

@@ -52,6 +52,7 @@
 #include "mipointer.h"
 #include "xserver-properties.h"
 #include "exevents.h"
+#include "eventstr.h"
 #include "inpututils.h"
 
 #include "modinit.h"
@@ -61,7 +62,7 @@ extern int DeviceValuator;
 /* XTest events are sent during request processing and may be interruped by
  * a SIGIO. We need a separate event list to avoid events overwriting each
  * other's memory */
-static EventListPtr xtest_evlist;
+static InternalEvent* xtest_evlist;
 
 /**
  * xtestpointer
@@ -428,7 +429,7 @@ ProcXTestFakeInput(ClientPtr client)
     }
 
     for (i = 0; i < nevents; i++)
-        mieqProcessDeviceEvent(dev, (InternalEvent*)(xtest_evlist+i)->event, NULL);
+        mieqProcessDeviceEvent(dev, &xtest_evlist[i], NULL);
 
     if (need_ptr_update)
         miPointerUpdateSprite(dev);

Xi/exevents.c

@@ -77,6 +77,7 @@ SOFTWARE.
 #include "xiquerydevice.h" /* For List*Info */
 #include "eventconvert.h"
 #include "eventstr.h"
+#include "inpututils.h"
 
 #include <X11/extensions/XKBproto.h>
 #include "xkbsrv.h"
@@ -920,7 +921,7 @@ ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
     DeviceIntPtr mouse = NULL, kbd = NULL;
     DeviceEvent *event = &ev->device_event;
 
-    CHECKEVENT(ev);
+    verify_internal_event(ev);
 
     if (ev->any.type == ET_RawKeyPress ||
         ev->any.type == ET_RawKeyRelease ||
@@ -1188,75 +1189,8 @@ FixDeviceValuator(DeviceIntPtr dev, deviceValuator * ev, ValuatorClassPtr v,
     first += ev->num_valuators;
 }
 
-void
+static void
-DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
+DeliverStateNotifyEvent(DeviceIntPtr dev, WindowPtr win)
-		 WindowPtr pWin)
-{
-    deviceFocus event;
-    xXIFocusInEvent *xi2event;
-    DeviceIntPtr mouse;
-    int btlen, len, i;
-
-    mouse = IsFloating(dev) ? dev : GetMaster(dev, MASTER_POINTER);
-
-    /* XI 2 event */
-    btlen = (mouse->button) ? bits_to_bytes(mouse->button->numButtons) : 0;
-    btlen = bytes_to_int32(btlen);
-    len = sizeof(xXIFocusInEvent) + btlen * 4;
-
-    xi2event = calloc(1, len);
-    xi2event->type         = GenericEvent;
-    xi2event->extension    = IReqCode;
-    xi2event->evtype       = type;
-    xi2event->length       = bytes_to_int32(len - sizeof(xEvent));
-    xi2event->buttons_len  = btlen;
-    xi2event->detail       = detail;
-    xi2event->time         = currentTime.milliseconds;
-    xi2event->deviceid     = dev->id;
-    xi2event->sourceid     = dev->id; /* a device doesn't change focus by itself */
-    xi2event->mode         = mode;
-    xi2event->root_x       = FP1616(mouse->spriteInfo->sprite->hot.x, 0);
-    xi2event->root_y       = FP1616(mouse->spriteInfo->sprite->hot.y, 0);
-
-    for (i = 0; mouse && mouse->button && i < mouse->button->numButtons; i++)
-        if (BitIsOn(mouse->button->down, i))
-            SetBit(&xi2event[1], i);
-
-    if (dev->key)
-    {
-        xi2event->mods.base_mods = dev->key->xkbInfo->state.base_mods;
-        xi2event->mods.latched_mods = dev->key->xkbInfo->state.latched_mods;
-        xi2event->mods.locked_mods = dev->key->xkbInfo->state.locked_mods;
-        xi2event->mods.effective_mods = dev->key->xkbInfo->state.mods;
-
-        xi2event->group.base_group = dev->key->xkbInfo->state.base_group;
-        xi2event->group.latched_group = dev->key->xkbInfo->state.latched_group;
-        xi2event->group.locked_group = dev->key->xkbInfo->state.locked_group;
-        xi2event->group.effective_group = dev->key->xkbInfo->state.group;
-    }
-
-    FixUpEventFromWindow(dev->spriteInfo->sprite, (xEvent*)xi2event, pWin,
-                         None, FALSE);
-
-    DeliverEventsToWindow(dev, pWin, (xEvent*)xi2event, 1,
-                          GetEventFilter(dev, (xEvent*)xi2event), NullGrab);
-
-    free(xi2event);
-
-    /* XI 1.x event */
-    event.deviceid = dev->id;
-    event.mode = mode;
-    event.type = (type == XI_FocusIn) ? DeviceFocusIn : DeviceFocusOut;
-    event.detail = detail;
-    event.window = pWin->drawable.id;
-    event.time = currentTime.milliseconds;
-
-    DeliverEventsToWindow(dev, pWin, (xEvent *) & event, 1,
-				DeviceFocusChangeMask, NullGrab);
-
-    if ((event.type == DeviceFocusIn) &&
-	(wOtherInputMasks(pWin)) &&
-	(wOtherInputMasks(pWin)->inputEvents[dev->id] & DeviceStateNotifyMask))
 {
     int evcount = 1;
     deviceStateNotify *ev, *sev;
@@ -1268,6 +1202,10 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
     ValuatorClassPtr v;
     int nval = 0, nkeys = 0, nbuttons = 0, first = 0;
 
+    if (!(wOtherInputMasks(win)) ||
+        !(wOtherInputMasks(win)->inputEvents[dev->id] & DeviceStateNotifyMask))
+        return;
+
     if ((b = dev->button) != NULL) {
         nbuttons = b->numButtons;
         if (nbuttons > 32)
@@ -1348,10 +1286,79 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
         }
     }
 
-	DeliverEventsToWindow(dev, pWin, (xEvent *) sev, evcount,
+    DeliverEventsToWindow(dev, win, (xEvent *) sev, evcount,
                           DeviceStateNotifyMask, NullGrab);
     free(sev);
 }
+
+void
+DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
+		 WindowPtr pWin)
+{
+    deviceFocus event;
+    xXIFocusInEvent *xi2event;
+    DeviceIntPtr mouse;
+    int btlen, len, i;
+
+    mouse = IsFloating(dev) ? dev : GetMaster(dev, MASTER_POINTER);
+
+    /* XI 2 event */
+    btlen = (mouse->button) ? bits_to_bytes(mouse->button->numButtons) : 0;
+    btlen = bytes_to_int32(btlen);
+    len = sizeof(xXIFocusInEvent) + btlen * 4;
+
+    xi2event = calloc(1, len);
+    xi2event->type         = GenericEvent;
+    xi2event->extension    = IReqCode;
+    xi2event->evtype       = type;
+    xi2event->length       = bytes_to_int32(len - sizeof(xEvent));
+    xi2event->buttons_len  = btlen;
+    xi2event->detail       = detail;
+    xi2event->time         = currentTime.milliseconds;
+    xi2event->deviceid     = dev->id;
+    xi2event->sourceid     = dev->id; /* a device doesn't change focus by itself */
+    xi2event->mode         = mode;
+    xi2event->root_x       = FP1616(mouse->spriteInfo->sprite->hot.x, 0);
+    xi2event->root_y       = FP1616(mouse->spriteInfo->sprite->hot.y, 0);
+
+    for (i = 0; mouse && mouse->button && i < mouse->button->numButtons; i++)
+        if (BitIsOn(mouse->button->down, i))
+            SetBit(&xi2event[1], i);
+
+    if (dev->key)
+    {
+        xi2event->mods.base_mods = dev->key->xkbInfo->state.base_mods;
+        xi2event->mods.latched_mods = dev->key->xkbInfo->state.latched_mods;
+        xi2event->mods.locked_mods = dev->key->xkbInfo->state.locked_mods;
+        xi2event->mods.effective_mods = dev->key->xkbInfo->state.mods;
+
+        xi2event->group.base_group = dev->key->xkbInfo->state.base_group;
+        xi2event->group.latched_group = dev->key->xkbInfo->state.latched_group;
+        xi2event->group.locked_group = dev->key->xkbInfo->state.locked_group;
+        xi2event->group.effective_group = dev->key->xkbInfo->state.group;
+    }
+
+    FixUpEventFromWindow(dev->spriteInfo->sprite, (xEvent*)xi2event, pWin,
+                         None, FALSE);
+
+    DeliverEventsToWindow(dev, pWin, (xEvent*)xi2event, 1,
+                          GetEventFilter(dev, (xEvent*)xi2event), NullGrab);
+
+    free(xi2event);
+
+    /* XI 1.x event */
+    event.deviceid = dev->id;
+    event.mode = mode;
+    event.type = (type == XI_FocusIn) ? DeviceFocusIn : DeviceFocusOut;
+    event.detail = detail;
+    event.window = pWin->drawable.id;
+    event.time = currentTime.milliseconds;
+
+    DeliverEventsToWindow(dev, pWin, (xEvent *) & event, 1,
+				DeviceFocusChangeMask, NullGrab);
+
+    if (event.type == DeviceFocusIn)
+        DeliverStateNotifyEvent(dev, pWin);
 }
 
 int

Xi/xichangehierarchy.c

@@ -355,6 +355,7 @@ detach_slave(ClientPtr client, xXIDetachSlaveInfo *c, int flags[MAXDEVICES])
         goto unwind;
     }
 
+    ReleaseButtonsAndKeys(dev);
     AttachDevice(client, dev, NULL);
     flags[dev->id] |= XISlaveDetached;
 
@@ -406,6 +407,7 @@ attach_slave(ClientPtr client, xXIAttachSlaveInfo *c,
         goto unwind;
     }
 
+    ReleaseButtonsAndKeys(dev);
     AttachDevice(client, dev, newmaster);
     flags[dev->id] |= XISlaveAttached;
 

Xi/xiqueryversion.c

@@ -58,7 +58,6 @@ ProcXIQueryVersion(ClientPtr client)
     xXIQueryVersionReply rep;
     XIClientPtr pXIClient;
     int major, minor;
-    unsigned int sversion, cversion;
 
     REQUEST(xXIQueryVersionReq);
     REQUEST_SIZE_MATCH(xXIQueryVersionReq);
@@ -72,10 +71,8 @@ ProcXIQueryVersion(ClientPtr client)
 
     pXIClient = dixLookupPrivate(&client->devPrivates, XIClientPrivateKey);
 
-    sversion = XIVersion.major_version * 1000 + XIVersion.minor_version;
+    if (version_compare(XIVersion.major_version, XIVersion.minor_version,
-    cversion = stuff->major_version * 1000 + stuff->minor_version;
+                        stuff->major_version, stuff->minor_version) > 0)
-
-    if (sversion > cversion)
     {
         major = stuff->major_version;
         minor = stuff->minor_version;

dix/devices.c

@@ -2365,10 +2365,10 @@ RecalculateMasterButtons(DeviceIntPtr slave)
  * Generate release events for all keys/button currently down on this
  * device.
  */
-static void
+void
 ReleaseButtonsAndKeys(DeviceIntPtr dev)
 {
-    EventListPtr        eventlist = InitEventList(GetMaximumEventsNum());
+    InternalEvent*      eventlist = InitEventList(GetMaximumEventsNum());
     ButtonClassPtr      b = dev->button;
     KeyClassPtr         k = dev->key;
     int                 i, j, nevents;
@@ -2383,7 +2383,7 @@ ReleaseButtonsAndKeys(DeviceIntPtr dev)
         {
             nevents = GetPointerEvents(eventlist, dev, ButtonRelease, i, 0, NULL);
             for (j = 0; j < nevents; j++)
-                mieqProcessDeviceEvent(dev, (InternalEvent*)(eventlist+j)->event, NULL);
+                mieqProcessDeviceEvent(dev, &eventlist[j], NULL);
         }
     }
 
@@ -2394,7 +2394,7 @@ ReleaseButtonsAndKeys(DeviceIntPtr dev)
         {
             nevents = GetKeyboardEvents(eventlist, dev, KeyRelease, i, NULL);
             for (j = 0; j < nevents; j++)
-                mieqProcessDeviceEvent(dev, (InternalEvent*)(eventlist+j)->event, NULL);
+                mieqProcessDeviceEvent(dev, &eventlist[j], NULL);
         }
     }
 
@@ -2434,8 +2434,6 @@ AttachDevice(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr master)
         free(dev->spriteInfo->sprite);
     }
 
-    ReleaseButtonsAndKeys(dev);
-
     oldmaster = GetMaster(dev, MASTER_ATTACHED);
     dev->master = master;
 

dix/eventconvert.c

@@ -156,7 +156,7 @@ EventToCore(InternalEvent *event, xEvent **core_out, int *count_out)
         case ET_RawButtonRelease:
         case ET_RawMotion:
             ret = BadMatch;
-            goto out;
+            break;
         default:
             /* XXX: */
             ErrorF("[dix] EventToCore: Not implemented yet \n");

dix/events.c

@@ -176,12 +176,23 @@ typedef const char *string;
 #define AllEventMasks (LastEventMask|(LastEventMask-1))
 
 
-#define CORE_EVENT(event) \
+/* @return the core event type or 0 if the event is not a core event */
-    (!((event)->u.u.type & EXTENSION_EVENT_BASE) && \
+static inline int
-      (event)->u.u.type != GenericEvent)
+core_get_type(const xEvent *event)
-#define XI2_EVENT(event) \
+{
-    (((event)->u.u.type == GenericEvent) && \
+    int type = event->u.u.type;
-    ((xGenericEvent*)(event))->extension == IReqCode)
+
+    return ((type & EXTENSION_EVENT_BASE) || type == GenericEvent) ? 0 : type;
+}
+
+/* @return the XI2 event type or 0 if the event is not a XI2 event */
+static inline int
+xi2_get_type(const xEvent *event)
+{
+    xGenericEvent* e = (xGenericEvent*)event;
+
+    return (e->type != GenericEvent || e->extension != IReqCode) ? 0 : e->evtype;
+}
 
 /**
  * Used to indicate a implicit passive grab created by a ButtonPress event.
@@ -345,8 +356,8 @@ extern int DeviceMotionNotify;
 /**
  * Event masks for each event type.
  *
- * One set of filters for each device, but only the first layer
+ * One set of filters for each device, initialized by memcpy of
- * is initialized. The rest is memcpy'd in InitEvents.
+ * default_filter in InitEvents.
  *
  * Filters are used whether a given event may be delivered to a client,
  * usually in the form of if (window-event-mask & filter); then deliver event.
@@ -355,7 +366,9 @@ extern int DeviceMotionNotify;
  * time a button is pressed, the filter is modified to also contain the
  * matching ButtonXMotion mask.
  */
-static Mask filters[MAXDEVICES][128] = {
+static Mask filters[MAXDEVICES][128];
+
+static const Mask default_filter[128] =
 {
 	NoSuchEvent,		       /* 0 */
 	NoSuchEvent,		       /* 1 */
@@ -392,7 +405,7 @@ static Mask filters[MAXDEVICES][128] = {
 	ColormapChangeMask,	       /* ColormapNotify */
 	CantBeFiltered,		       /* ClientMessage */
 	CantBeFiltered		       /* MappingNotify */
-}};
+};
 
 /**
  * For the given event, return the matching event filter. This filter may then
@@ -412,10 +425,12 @@ static Mask filters[MAXDEVICES][128] = {
 Mask
 GetEventFilter(DeviceIntPtr dev, xEvent *event)
 {
+    int evtype = 0;
+
     if (event->u.u.type != GenericEvent)
         return filters[dev ? dev->id : 0][event->u.u.type];
-    else if (XI2_EVENT(event))
+    else if ((evtype = xi2_get_type(event)))
-        return (1 << (((xXIDeviceEvent*)event)->evtype % 8));
+        return (1 << (evtype % 8));
     ErrorF("[dix] Unknown device type %d. No filter\n", event->u.u.type);
     return 0;
 }
@@ -430,7 +445,7 @@ GetWindowXI2Mask(DeviceIntPtr dev, WindowPtr win, xEvent* ev)
     int filter;
     int evtype;
 
-    if (!inputMasks || !XI2_EVENT(ev))
+    if (!inputMasks || xi2_get_type(ev) == 0)
         return 0;
 
     evtype = ((xGenericEvent*)ev)->evtype;
@@ -444,14 +459,16 @@ GetWindowXI2Mask(DeviceIntPtr dev, WindowPtr win, xEvent* ev)
 Mask
 GetEventMask(DeviceIntPtr dev, xEvent *event, InputClients* other)
 {
+    int evtype;
+
     /* XI2 filters are only ever 8 bit, so let's return a 8 bit mask */
-    if (XI2_EVENT(event))
+    if ((evtype = xi2_get_type(event)))
     {
-        int byte = ((xGenericEvent*)event)->evtype / 8;
+        int byte = evtype / 8;
         return (other->xi2mask[dev->id][byte] |
                 other->xi2mask[XIAllDevices][byte] |
                 (IsMaster(dev)? other->xi2mask[XIAllMasterDevices][byte] : 0));
-    } else if (CORE_EVENT(event))
+    } else if (core_get_type(event) != 0)
         return other->mask[XIAllDevices];
     else
         return other->mask[dev->id];
@@ -1937,6 +1954,159 @@ TryClientEvents (ClientPtr client, DeviceIntPtr dev, xEvent *pEvents,
     return 1;
 }
 
+static BOOL
+ActivateImplicitGrab(DeviceIntPtr dev, ClientPtr client, WindowPtr win,
+                     xEvent *event, Mask deliveryMask)
+{
+    GrabRec tempGrab;
+    OtherInputMasks *inputMasks;
+    CARD8 type = event->u.u.type;
+    GrabType grabtype;
+
+    if (type == ButtonPress)
+        grabtype = GRABTYPE_CORE;
+    else if (type == DeviceButtonPress)
+        grabtype = GRABTYPE_XI;
+    else if ((type = xi2_get_type(event)) == XI_ButtonPress)
+        grabtype = GRABTYPE_XI2;
+    else
+        return FALSE;
+
+    memset(&tempGrab, 0, sizeof(GrabRec));
+    tempGrab.next = NULL;
+    tempGrab.device = dev;
+    tempGrab.resource = client->clientAsMask;
+    tempGrab.window = win;
+    tempGrab.ownerEvents = (deliveryMask & OwnerGrabButtonMask) ? TRUE : FALSE;
+    tempGrab.eventMask = deliveryMask;
+    tempGrab.keyboardMode = GrabModeAsync;
+    tempGrab.pointerMode = GrabModeAsync;
+    tempGrab.confineTo = NullWindow;
+    tempGrab.cursor = NullCursor;
+    tempGrab.type = type;
+    tempGrab.grabtype = grabtype;
+
+    /* get the XI and XI2 device mask */
+    inputMasks = wOtherInputMasks(win);
+    tempGrab.deviceMask = (inputMasks) ? inputMasks->inputEvents[dev->id]: 0;
+
+    if (inputMasks)
+        memcpy(tempGrab.xi2mask, inputMasks->xi2mask,
+               sizeof(tempGrab.xi2mask));
+
+    (*dev->deviceGrab.ActivateGrab)(dev, &tempGrab,
+                                    currentTime, TRUE | ImplicitGrabMask);
+    return TRUE;
+}
+
+enum EventDeliveryState {
+    EVENT_DELIVERED,     /**< Event has been delivered to a client  */
+    EVENT_NOT_DELIVERED, /**< Event was not delivered to any client */
+    EVENT_SKIP,          /**< Event can be discarded by the caller  */
+    EVENT_REJECTED,      /**< Event was rejected for delivery to the client */
+};
+
+/**
+ * Attempt event delivery to the client owning the window.
+ */
+static enum EventDeliveryState
+DeliverToWindowOwner(DeviceIntPtr dev, WindowPtr win,
+                     xEvent *events, int count, Mask filter,
+                     GrabPtr grab)
+{
+    /* if nobody ever wants to see this event, skip some work */
+    if (filter != CantBeFiltered &&
+            !((wOtherEventMasks(win)|win->eventMask) & filter))
+        return EVENT_SKIP;
+
+    if (IsInterferingGrab(wClient(win), dev, events))
+        return EVENT_SKIP;
+
+    if (!XaceHook(XACE_RECEIVE_ACCESS, wClient(win), win, events, count))
+    {
+        int attempt = TryClientEvents(wClient(win), dev, events,
+                                      count, win->eventMask,
+                                      filter, grab);
+        if (attempt > 0)
+            return EVENT_DELIVERED;
+        if (attempt < 0)
+            return EVENT_REJECTED;
+    }
+
+    return EVENT_NOT_DELIVERED;
+}
+
+/**
+ * Deliver events to clients registered on the window.
+ *
+ * @param client_return On successful delivery, set to the recipient.
+ * @param mask_return On successful delivery, set to the recipient's event
+ * mask for this event.
+ */
+static enum EventDeliveryState
+DeliverEventToClients(DeviceIntPtr dev, WindowPtr win, xEvent *events,
+                      int count, Mask filter, GrabPtr grab,
+                      ClientPtr *client_return, Mask *mask_return)
+{
+    int attempt;
+    enum EventDeliveryState rc = EVENT_SKIP;
+    InputClients *other;
+
+    if (core_get_type(events) != 0)
+        other = (InputClients *)wOtherClients(win);
+    else if (xi2_get_type(events) != 0)
+    {
+        OtherInputMasks *inputMasks = wOtherInputMasks(win);
+        /* Has any client selected for the event? */
+        if (!GetWindowXI2Mask(dev, win, events))
+            goto out;
+        other = inputMasks->inputClients;
+    } else {
+        OtherInputMasks *inputMasks = wOtherInputMasks(win);
+        /* Has any client selected for the event? */
+        if (!inputMasks ||
+            !(inputMasks->inputEvents[dev->id] & filter))
+            goto out;
+
+        other = inputMasks->inputClients;
+    }
+
+    rc = EVENT_NOT_DELIVERED;
+
+    for (; other; other = other->next)
+    {
+        Mask mask;
+        ClientPtr client = rClient(other);
+
+        if (IsInterferingGrab(client, dev, events))
+            continue;
+
+        mask = GetEventMask(dev, events, other);
+
+        if (XaceHook(XACE_RECEIVE_ACCESS, client, win,
+                    events, count))
+            /* do nothing */;
+        else if ( (attempt = TryClientEvents(client, dev,
+                        events, count,
+                        mask, filter, grab)) )
+        {
+            if (attempt > 0)
+            {
+                rc = EVENT_DELIVERED;
+                *client_return = client;
+                *mask_return = mask;
+                /* Success overrides non-success, so if we've been
+                 * successful on one client, return that */
+            } else if (rc == EVENT_NOT_DELIVERED)
+                rc = EVENT_REJECTED;
+        }
+    }
+
+out:
+    return rc;
+}
+
+
 /**
  * Deliver events to a window. At this point, we do not yet know if the event
  * actually needs to be delivered. May activate a grab if the event is a
@@ -1955,152 +2125,84 @@ TryClientEvents (ClientPtr client, DeviceIntPtr dev, xEvent *pEvents,
  * @param filter Mask based on event type.
  * @param grab Possible grab on the device that caused the event.
  *
- * @return Number of events delivered to various clients.
+ * @return a positive number if at least one successful delivery has been
+ * made, 0 if no events were delivered, or a negative number if the event
+ * has not been delivered _and_ rejected by at least one client.
  */
 int
 DeliverEventsToWindow(DeviceIntPtr pDev, WindowPtr pWin, xEvent
         *pEvents, int count, Mask filter, GrabPtr grab)
 {
     int deliveries = 0, nondeliveries = 0;
-    int attempt;
-    InputClients *other;
     ClientPtr client = NullClient;
     Mask deliveryMask = 0; /* If a grab occurs due to a button press, then
 		              this mask is the mask of the grab. */
     int type = pEvents->u.u.type;
 
-
     /* Deliver to window owner */
-    if ((filter == CantBeFiltered) || CORE_EVENT(pEvents))
+    if ((filter == CantBeFiltered) || core_get_type(pEvents) != 0)
     {
-	/* if nobody ever wants to see this event, skip some work */
+        enum EventDeliveryState rc;
-	if (filter != CantBeFiltered &&
-	    !((wOtherEventMasks(pWin)|pWin->eventMask) & filter))
-	    return 0;
 
-        if (IsInterferingGrab(wClient(pWin), pDev, pEvents))
+        rc = DeliverToWindowOwner(pDev, pWin, pEvents, count, filter, grab);
-                return 0;
 
-	if (XaceHook(XACE_RECEIVE_ACCESS, wClient(pWin), pWin, pEvents, count))
+        switch(rc)
-	    /* do nothing */;
-        else if ( (attempt = TryClientEvents(wClient(pWin), pDev, pEvents,
-                                             count, pWin->eventMask,
-                                             filter, grab)) )
-	{
-	    if (attempt > 0)
         {
+            case EVENT_SKIP:
+                return 0;
+            case EVENT_REJECTED:
+                nondeliveries--;
+                break;
+            case EVENT_DELIVERED:
+                /* We delivered to the owner, with our event mask */
                 deliveries++;
                 client = wClient(pWin);
                 deliveryMask = pWin->eventMask;
-	    } else
+                break;
-		nondeliveries--;
+            case EVENT_NOT_DELIVERED:
+                break;
         }
     }
 
     /* CantBeFiltered means only window owner gets the event */
     if (filter != CantBeFiltered)
     {
-        if (CORE_EVENT(pEvents))
+        enum EventDeliveryState rc;
-            other = (InputClients *)wOtherClients(pWin);
+
-        else if (XI2_EVENT(pEvents))
+        rc = DeliverEventToClients(pDev, pWin, pEvents, count, filter, grab,
+                                   &client, &deliveryMask);
+
+        switch(rc)
         {
-            OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
+            case EVENT_SKIP:
-            /* Has any client selected for the event? */
-            if (!GetWindowXI2Mask(pDev, pWin, pEvents))
                 return 0;
-            other = inputMasks->inputClients;
+            case EVENT_REJECTED:
-        } else {
-            OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
-            /* Has any client selected for the event? */
-            if (!inputMasks ||
-                !(inputMasks->inputEvents[pDev->id] & filter))
-                return 0;
-
-            other = inputMasks->inputClients;
-        }
-
-        for (; other; other = other->next)
-        {
-            Mask mask;
-            if (IsInterferingGrab(rClient(other), pDev, pEvents))
-                continue;
-
-            mask = GetEventMask(pDev, pEvents, other);
-
-            if (XaceHook(XACE_RECEIVE_ACCESS, rClient(other), pWin,
-                        pEvents, count))
-                /* do nothing */;
-            else if ( (attempt = TryClientEvents(rClient(other), pDev,
-                            pEvents, count,
-                            mask, filter, grab)) )
-            {
-                if (attempt > 0)
-                {
-                    deliveries++;
-                    client = rClient(other);
-                    deliveryMask = mask;
-                } else
                 nondeliveries--;
+                break;
+            case EVENT_DELIVERED:
+                deliveries++;
+                break;
+            case EVENT_NOT_DELIVERED:
+                break;
         }
     }
-    }
+
+    if (deliveries)
+    {
         /*
          * Note that since core events are delivered first, an implicit grab may
          * be activated on a core grab, stopping the XI events.
          */
-    if ((type == DeviceButtonPress || type == ButtonPress ||
+        if (!grab && ActivateImplicitGrab(pDev, client, pWin, pEvents, deliveryMask))
-        ((XI2_EVENT(pEvents) && ((xGenericEvent*)pEvents)->evtype == XI_ButtonPress)))
+            /* grab activated */;
-            && deliveries
+        else if ((type == MotionNotify))
-            && (!grab))
-    {
-	GrabRec tempGrab;
-        OtherInputMasks *inputMasks;
-
-        memset(&tempGrab, 0, sizeof(GrabRec));
-        tempGrab.next = NULL;
-	tempGrab.device = pDev;
-	tempGrab.resource = client->clientAsMask;
-	tempGrab.window = pWin;
-	tempGrab.ownerEvents = (deliveryMask & OwnerGrabButtonMask) ? TRUE : FALSE;
-	tempGrab.eventMask = deliveryMask;
-	tempGrab.keyboardMode = GrabModeAsync;
-	tempGrab.pointerMode = GrabModeAsync;
-	tempGrab.confineTo = NullWindow;
-	tempGrab.cursor = NullCursor;
-        tempGrab.type = type;
-        if (type == ButtonPress)
-            tempGrab.grabtype = GRABTYPE_CORE;
-        else if (type == DeviceButtonPress)
-            tempGrab.grabtype = GRABTYPE_XI;
-        else
-        {
-            tempGrab.type = ((xGenericEvent*)pEvents)->evtype;
-            tempGrab.grabtype = GRABTYPE_XI2;
-        }
-
-        /* get the XI and XI2 device mask */
-        inputMasks = wOtherInputMasks(pWin);
-        tempGrab.deviceMask = (inputMasks) ? inputMasks->inputEvents[pDev->id]: 0;
-
-        if (inputMasks)
-            memcpy(tempGrab.xi2mask, inputMasks->xi2mask,
-                    sizeof(tempGrab.xi2mask));
-
-	(*pDev->deviceGrab.ActivateGrab)(pDev, &tempGrab,
-                                        currentTime, TRUE | ImplicitGrabMask);
-    }
-    else if ((type == MotionNotify) && deliveries)
             pDev->valuator->motionHintWindow = pWin;
-    else
+        else if (type == DeviceMotionNotify || type == DeviceButtonPress)
-    {
-	if ((type == DeviceMotionNotify || type == DeviceButtonPress) &&
-	    deliveries)
                 CheckDeviceGrabAndHintWindow (pWin, type,
                                               (deviceKeyButtonPointer*) pEvents,
                                               grab, client, deliveryMask);
-    }
-    if (deliveries)
 	return deliveries;
+    }
     return nondeliveries;
 }
 
@@ -2180,7 +2282,7 @@ MaybeDeliverEventsToClient(WindowPtr pWin, xEvent *pEvents,
 
 static Window FindChildForEvent(SpritePtr pSprite, WindowPtr event)
 {
-    WindowPtr w = pSprite->spriteTrace[pSprite->spriteTraceGood-1];
+    WindowPtr w = DeepestSpriteWin(pSprite);
     Window child = None;
 
     /* If the search ends up past the root should the child field be
@@ -2224,22 +2326,29 @@ FixUpEventFromWindow(
     Window child,
     Bool calcChild)
 {
+    int evtype;
+
     if (calcChild)
         child = FindChildForEvent(pSprite, pWin);
 
-    if (XI2_EVENT(xE))
+    if ((evtype = xi2_get_type(xE)))
     {
         xXIDeviceEvent* event = (xXIDeviceEvent*)xE;
 
-        if (event->evtype == XI_RawKeyPress ||
+        switch (evtype)
-            event->evtype == XI_RawKeyRelease ||
+        {
-            event->evtype == XI_RawButtonPress ||
+            case XI_RawKeyPress:
-            event->evtype == XI_RawButtonRelease ||
+            case XI_RawKeyRelease:
-            event->evtype == XI_RawMotion ||
+            case XI_RawButtonPress:
-            event->evtype == XI_DeviceChanged ||
+            case XI_RawButtonRelease:
-            event->evtype == XI_HierarchyChanged ||
+            case XI_RawMotion:
-            event->evtype == XI_PropertyEvent)
+            case XI_DeviceChanged:
+            case XI_HierarchyChanged:
+            case XI_PropertyEvent:
                 return;
+            default:
+                break;
+        }
 
         event->root = RootWindow(pSprite)->drawable.id;
         event->event = pWin->drawable.id;
@@ -2375,7 +2484,7 @@ DeliverDeviceEvents(WindowPtr pWin, InternalEvent *event, GrabPtr grab,
     xEvent *xE = NULL, *core = NULL;
     int rc, mask, count = 0;
 
-    CHECKEVENT(event);
+    verify_internal_event(event);
 
     while (pWin)
     {
@@ -2623,7 +2732,7 @@ XYToWindow(SpritePtr pSprite, int x, int y)
 	else
 	    pWin = pWin->nextSib;
     }
-    return pSprite->spriteTrace[pSprite->spriteTraceGood-1];
+    return DeepestSpriteWin(pSprite);
 }
 
 /**
@@ -2661,7 +2770,8 @@ ActivateFocusInGrab(DeviceIntPtr dev, WindowPtr old, WindowPtr win)
     event.deviceid = dev->id;
     event.sourceid = dev->id;
     event.detail.button = 0;
-    rc = (CheckPassiveGrabsOnWindow(win, dev, &event, FALSE, TRUE) != NULL);
+    rc = (CheckPassiveGrabsOnWindow(win, dev, (InternalEvent *) &event, FALSE,
+                                    TRUE) != NULL);
     if (rc)
         DoEnterLeaveEvents(dev, dev->id, old, win, XINotifyPassiveUngrab);
     return rc;
@@ -2698,7 +2808,8 @@ ActivateEnterGrab(DeviceIntPtr dev, WindowPtr old, WindowPtr win)
     event.deviceid = dev->id;
     event.sourceid = dev->id;
     event.detail.button = 0;
-    rc = (CheckPassiveGrabsOnWindow(win, dev, &event, FALSE, TRUE) != NULL);
+    rc = (CheckPassiveGrabsOnWindow(win, dev, (InternalEvent *) &event, FALSE,
+                                    TRUE) != NULL);
     if (rc)
         DoEnterLeaveEvents(dev, dev->id, old, win, XINotifyPassiveGrab);
     return rc;
@@ -2721,7 +2832,7 @@ CheckMotion(DeviceEvent *ev, DeviceIntPtr pDev)
     WindowPtr prevSpriteWin, newSpriteWin;
     SpritePtr pSprite = pDev->spriteInfo->sprite;
 
-    CHECKEVENT(ev);
+    verify_internal_event(ev);
 
     prevSpriteWin = pSprite->win;
 
@@ -3385,7 +3496,7 @@ GrabPtr
 CheckPassiveGrabsOnWindow(
     WindowPtr pWin,
     DeviceIntPtr device,
-    DeviceEvent *event,
+    InternalEvent *event,
     BOOL checkCore,
     BOOL activate)
 {
@@ -3402,9 +3513,22 @@ CheckPassiveGrabsOnWindow(
 	return NULL;
     /* Fill out the grab details, but leave the type for later before
      * comparing */
+    switch (event->any.type)
+    {
+        case ET_KeyPress:
+        case ET_KeyRelease:
+            tempGrab.detail.exact = event->device_event.detail.key;
+            break;
+        case ET_ButtonPress:
+        case ET_ButtonRelease:
+            tempGrab.detail.exact = event->device_event.detail.button;
+            break;
+        default:
+            tempGrab.detail.exact = 0;
+            break;
+    }
     tempGrab.window = pWin;
     tempGrab.device = device;
-    tempGrab.detail.exact = event->detail.key;
     tempGrab.detail.pMask = NULL;
     tempGrab.modifiersDetail.pMask = NULL;
     tempGrab.next = NULL;
@@ -3412,6 +3536,8 @@ CheckPassiveGrabsOnWindow(
     {
 	DeviceIntPtr	gdev;
 	XkbSrvInfoPtr	xkbi = NULL;
+	xEvent *xE = NULL;
+        int count, rc;
 
 	gdev= grab->modifierDevice;
         if (grab->grabtype == GRABTYPE_CORE)
@@ -3437,16 +3563,15 @@ CheckPassiveGrabsOnWindow(
         tempGrab.modifiersDetail.exact = xkbi ? xkbi->state.grab_mods : 0;
 
         /* Check for XI2 and XI grabs first */
-        tempGrab.type = GetXI2Type((InternalEvent*)event);
+        tempGrab.type = GetXI2Type(event);
         tempGrab.grabtype = GRABTYPE_XI2;
         if (GrabMatchesSecond(&tempGrab, grab, FALSE))
             match = XI2_MATCH;
 
-        tempGrab.detail.exact = event->detail.key;
         if (!match)
         {
             tempGrab.grabtype = GRABTYPE_XI;
-            if ((tempGrab.type = GetXIType((InternalEvent*)event)) &&
+            if ((tempGrab.type = GetXIType(event)) &&
                 (GrabMatchesSecond(&tempGrab, grab, FALSE)))
                 match = XI_MATCH;
         }
@@ -3455,20 +3580,16 @@ CheckPassiveGrabsOnWindow(
         if (!match && checkCore)
         {
             tempGrab.grabtype = GRABTYPE_CORE;
-            if ((tempGrab.type = GetCoreType((InternalEvent*)event)) &&
+            if ((tempGrab.type = GetCoreType(event)) &&
                 (GrabMatchesSecond(&tempGrab, grab, TRUE)))
                 match = CORE_MATCH;
         }
 
-        if (match && (!grab->confineTo ||
+        if (!match || (grab->confineTo &&
-	     (grab->confineTo->realized &&
+                       (!grab->confineTo->realized ||
-				BorderSizeNotEmpty(device, grab->confineTo))))
+                        !BorderSizeNotEmpty(device, grab->confineTo))))
-	{
+            continue;
-            int rc, count = 0;
-            xEvent *xE = NULL;
 
-            event->corestate &= 0x1f00;
-            event->corestate |= tempGrab.modifiersDetail.exact & (~0x1f00);
         grabinfo = &device->deviceGrab;
         /* In some cases a passive core grab may exist, but the client
          * already has a core grab on some other device. In this case we
@@ -3513,37 +3634,54 @@ CheckPassiveGrabsOnWindow(
         }
 
         if (!activate)
+        {
             return grab;
+        }
+        else if (!GetXIType(event) && !GetCoreType(event))
+        {
+            ErrorF("Event type %d in CheckPassiveGrabsOnWindow is neither"
+                   " XI 1.x nor core\n", event->any.type);
+            return NULL;
+        }
+
+        /* The only consumers of corestate are Xi 1.x and core events, which
+         * are guaranteed to come from DeviceEvents. */
+        if (match & (XI_MATCH | CORE_MATCH))
+        {
+            event->device_event.corestate &= 0x1f00;
+            event->device_event.corestate |= tempGrab.modifiersDetail.exact &
+                                              (~0x1f00);
+        }
 
         if (match & CORE_MATCH)
         {
-                rc = EventToCore((InternalEvent*)event, &xE, &count);
+            rc = EventToCore(event, &xE, &count);
             if (rc != Success)
             {
                 if (rc != BadMatch)
                     ErrorF("[dix] %s: core conversion failed in CPGFW "
-                                "(%d, %d).\n", device->name, event->type, rc);
+                            "(%d, %d).\n", device->name, event->any.type, rc);
                 continue;
             }
         } else if (match & XI2_MATCH)
         {
-                rc = EventToXI2((InternalEvent*)event, &xE);
+            rc = EventToXI2(event, &xE);
             if (rc != Success)
             {
                 if (rc != BadMatch)
                     ErrorF("[dix] %s: XI2 conversion failed in CPGFW "
-                                "(%d, %d).\n", device->name, event->type, rc);
+                            "(%d, %d).\n", device->name, event->any.type, rc);
                 continue;
             }
             count = 1;
         } else
         {
-                rc = EventToXI((InternalEvent*)event, &xE, &count);
+            rc = EventToXI(event, &xE, &count);
             if (rc != Success)
             {
                 if (rc != BadMatch)
                     ErrorF("[dix] %s: XI conversion failed in CPGFW "
-                                "(%d, %d).\n", device->name, event->type, rc);
+                            "(%d, %d).\n", device->name, event->any.type, rc);
                 continue;
             }
         }
@@ -3563,15 +3701,14 @@ CheckPassiveGrabsOnWindow(
         if (grabinfo->sync.state == FROZEN_NO_EVENT)
         {
             if (!grabinfo->sync.event)
-                    grabinfo->sync.event = calloc(1, sizeof(InternalEvent));
+                grabinfo->sync.event = calloc(1, sizeof(DeviceEvent));
-                *grabinfo->sync.event = *event;
+            *grabinfo->sync.event = event->device_event;
             grabinfo->sync.state = FROZEN_WITH_EVENT;
         }
 
         free(xE);
         return grab;
     }
-    }
     return NULL;
 #undef CORE_MATCH
 #undef XI_MATCH
@@ -3639,7 +3776,8 @@ CheckDeviceGrabs(DeviceIntPtr device, DeviceEvent *event, WindowPtr ancestor)
 	for (; i < focus->traceGood; i++)
 	{
 	    pWin = focus->trace[i];
-	    if (CheckPassiveGrabsOnWindow(pWin, device, event, sendCore, TRUE))
+	    if (CheckPassiveGrabsOnWindow(pWin, device, (InternalEvent *) event,
+                                          sendCore, TRUE))
 	    {
 		ret = TRUE;
 		goto out;
@@ -3655,7 +3793,8 @@ CheckDeviceGrabs(DeviceIntPtr device, DeviceEvent *event, WindowPtr ancestor)
     for (; i < device->spriteInfo->sprite->spriteTraceGood; i++)
     {
 	pWin = device->spriteInfo->sprite->spriteTrace[i];
-	if (CheckPassiveGrabsOnWindow(pWin, device, event, sendCore, TRUE))
+	if (CheckPassiveGrabsOnWindow(pWin, device, (InternalEvent *) event,
+	                              sendCore, TRUE))
 	{
 	    ret = TRUE;
 	    goto out;
@@ -3766,8 +3905,10 @@ unwind:
  * grab. If not, TryClientEvents() is used.
  *
  * @param deactivateGrab True if the device's grab should be deactivated.
+ *
+ * @return The number of events delivered.
  */
-void
+int
 DeliverGrabbedEvent(InternalEvent *event, DeviceIntPtr thisDev,
                     Bool deactivateGrab)
 {
@@ -3935,6 +4076,8 @@ DeliverGrabbedEvent(InternalEvent *event, DeviceIntPtr thisDev,
     free(core);
     free(xi);
     free(xi2);
+
+    return deliveries;
 }
 
 /* This function is used to set the key pressed or key released state -
@@ -4977,12 +5120,9 @@ InitEvents(void)
     inputInfo.off_devices = (DeviceIntPtr)NULL;
     inputInfo.keyboard = (DeviceIntPtr)NULL;
     inputInfo.pointer = (DeviceIntPtr)NULL;
-    /* The mask for pointer motion events may have changed in the last server
+    for (i = 0; i < MAXDEVICES; i++)
-     * generation. See comment above definition of filters. */
-    filters[0][PointerMotionMask] = MotionNotify;
-    for (i = 1; i < MAXDEVICES; i++)
     {
-        memcpy(&filters[i], filters[0], sizeof(filters[0]));
+        memcpy(&filters[i], default_filter, sizeof(default_filter));
     }
 
     syncEvents.replayDev = (DeviceIntPtr)NULL;
@@ -5006,8 +5146,7 @@ InitEvents(void)
 	DontPropagateRefCnts[i] = 0;
     }
 
-    InputEventListLen = GetMaximumEventsNum();
+    InputEventList = InitEventList(GetMaximumEventsNum());
-    InputEventList = InitEventList(InputEventListLen);
     if (!InputEventList)
         FatalError("[dix] Failed to allocate input event list.\n");
 }
@@ -5015,8 +5154,7 @@ InitEvents(void)
 void
 CloseDownEvents(void)
 {
-    FreeEventList(InputEventList, InputEventListLen);
+    FreeEventList(InputEventList, GetMaximumEventsNum());
-    InputEventListLen = 0;
     InputEventList = NULL;
 }
 

dix/getevents.c

@@ -47,6 +47,7 @@
 #include "eventstr.h"
 #include "eventconvert.h"
 #include "inpututils.h"
+#include "mi.h"
 
 #include <X11/extensions/XKBproto.h>
 #include "xkbsrv.h"
@@ -67,19 +68,12 @@
 /* Number of motion history events to store. */
 #define MOTION_HISTORY_SIZE 256
 
-/* InputEventList is the container list for all input events generated by the
+/**
- * DDX. The DDX is expected to call GetEventList() and then pass the list into
+ * InputEventList is the storage for input events generated by
- * Get{Pointer|Keyboard}Events.
+ * QueuePointerEvents, QueueKeyboardEvents, and QueueProximityEvents.
+ * This list is allocated on startup by the DIX.
  */
-EventListPtr InputEventList = NULL;
+InternalEvent* InputEventList = NULL;
-int InputEventListLen = 0;
-
-int
-GetEventList(EventListPtr* list)
-{
-    *list = InputEventList;
-    return InputEventListLen;
-}
 
 /**
  * Pick some arbitrary size for Xi motion history.
@@ -223,7 +217,7 @@ set_valuators(DeviceIntPtr dev, DeviceEvent* event, ValuatorMask *mask)
 }
 
 void
-CreateClassesChangedEvent(EventList* event,
+CreateClassesChangedEvent(InternalEvent* event,
                           DeviceIntPtr master,
                           DeviceIntPtr slave,
                           int type)
@@ -232,7 +226,7 @@ CreateClassesChangedEvent(EventList* event,
     DeviceChangedEvent *dce;
     CARD32 ms = GetTimeInMillis();
 
-    dce = (DeviceChangedEvent*)event->event;
+    dce = &event->changed_event;
     memset(dce, 0, sizeof(DeviceChangedEvent));
     dce->deviceid = slave->id;
     dce->masterid = master->id;
@@ -676,15 +670,15 @@ clipValuators(DeviceIntPtr pDev, ValuatorMask *mask)
  * is done in the event processing).
  * Pull in the coordinates from the MD if necessary.
  *
- * @param events Pointer to a pre-allocated event list.
+ * @param events Pointer to a pre-allocated event array.
  * @param dev The slave device that generated an event.
  * @param type Either DEVCHANGE_POINTER_EVENT and/or DEVCHANGE_KEYBOARD_EVENT
  * @param num_events The current number of events, returns the number of
  *        events if a DCCE was generated.
  * @return The updated @events pointer.
  */
-EventListPtr
+InternalEvent*
-UpdateFromMaster(EventListPtr events, DeviceIntPtr dev, int type, int *num_events)
+UpdateFromMaster(InternalEvent* events, DeviceIntPtr dev, int type, int *num_events)
 {
     DeviceIntPtr master;
 
@@ -924,16 +918,49 @@ updateHistory(DeviceIntPtr dev, ValuatorMask *mask, CARD32 ms)
     }
 }
 
+static void
+queueEventList(DeviceIntPtr device, InternalEvent *events, int nevents)
+{
+    int i;
+    for (i = 0; i < nevents; i++)
+        mieqEnqueue(device, &events[i]);
+}
+
+/**
+ * Generate internal events representing this keyboard event and enqueue
+ * them on the event queue.
+ *
+ * This function is not reentrant. Disable signals before calling.
+ *
+ * FIXME: flags for relative/abs motion?
+ *
+ * @param device The device to generate the event for
+ * @param type Event type, one of KeyPress or KeyRelease
+ * @param keycode Key code of the pressed/released key
+ * @param mask Valuator mask for valuators present for this event.
+ *
+ */
+void
+QueueKeyboardEvents(DeviceIntPtr device, int type,
+                    int keycode, const ValuatorMask *mask)
+{
+    int nevents;
+
+    nevents = GetKeyboardEvents(InputEventList, device, type, keycode, mask);
+    queueEventList(device, InputEventList, nevents);
+}
+
 /**
  * Returns a set of InternalEvents for KeyPress/KeyRelease, optionally
  * also with valuator events.
  *
- * events is not NULL-terminated; the return value is the number of events.
+ * The DDX is responsible for allocating the event list in the first
- * The DDX is responsible for allocating the event structure in the first
+ * place via InitEventList(), and for freeing it.
- * place via GetMaximumEventsNum(), and for freeing it.
+ *
+ * @return the number of events written into events.
  */
 int
-GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type,
+GetKeyboardEvents(InternalEvent *events, DeviceIntPtr pDev, int type,
                   int key_code, const ValuatorMask *mask_in) {
     int num_events = 0;
     CARD32 ms = 0;
@@ -966,7 +993,7 @@ GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type,
 
     ms = GetTimeInMillis();
 
-    raw = (RawDeviceEvent*)events->event;
+    raw = &events->raw_event;
     events++;
     num_events++;
 
@@ -979,7 +1006,7 @@ GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type,
 
     set_raw_valuators(raw, &mask, raw->valuators.data);
 
-    event = (DeviceEvent*) events->event;
+    event = &events->device_event;
     init_event(pDev, event, ms);
     event->detail.key = key_code;
 
@@ -1000,37 +1027,16 @@ GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type,
 }
 
 /**
- * Initialize an event list and fill with 32 byte sized events.
+ * Initialize an event array large enough for num_events arrays.
  * This event list is to be passed into GetPointerEvents() and
  * GetKeyboardEvents().
  *
  * @param num_events Number of elements in list.
  */
-EventListPtr
+InternalEvent*
 InitEventList(int num_events)
 {
-    EventListPtr events;
+    InternalEvent *events = calloc(num_events, sizeof(InternalEvent));
-    int i;
-
-    events = (EventListPtr)calloc(num_events, sizeof(EventList));
-    if (!events)
-        return NULL;
-
-    for (i = 0; i < num_events; i++)
-    {
-        events[i].evlen = sizeof(InternalEvent);
-        events[i].event = calloc(1, sizeof(InternalEvent));
-        if (!events[i].event)
-        {
-            /* rollback */
-            while(i--)
-                free(events[i].event);
-            free(events);
-            events = NULL;
-            break;
-        }
-    }
-
     return events;
 }
 
@@ -1041,41 +1047,50 @@ InitEventList(int num_events)
  * @param num_events Number of elements in list.
  */
 void
-FreeEventList(EventListPtr list, int num_events)
+FreeEventList(InternalEvent *list, int num_events)
 {
-    if (!list)
-        return;
-    while(num_events--)
-        free(list[num_events].event);
     free(list);
 }
 
 static void
-transformAbsolute(DeviceIntPtr dev, ValuatorMask *mask)
+transformAbsolute(DeviceIntPtr dev, ValuatorMask *mask, int *x, int *y)
 {
-    struct pixman_f_vector p;
+    struct pixman_f_vector p = {.v = {*x, *y, 1}};
-
-    /* p' = M * p in homogeneous coordinates */
-    p.v[0] = (valuator_mask_isset(mask, 0) ? valuator_mask_get(mask, 0) :
-              dev->last.valuators[0]);
-    p.v[1] = (valuator_mask_isset(mask, 1) ? valuator_mask_get(mask, 1) :
-              dev->last.valuators[1]);
-    p.v[2] = 1.0;
 
     pixman_f_transform_point(&dev->transform, &p);
 
-    if (lround(p.v[0]) != dev->last.valuators[0])
+    *x = lround(p.v[0]);
-        valuator_mask_set(mask, 0, lround(p.v[0]));
+    *y = lround(p.v[1]);
-    if (lround(p.v[1]) != dev->last.valuators[1])
-        valuator_mask_set(mask, 1, lround(p.v[1]));
 }
 
 /**
- * Generate a series of InternalEvents (filled into the EventList)
+ * Generate internal events representing this pointer event and enqueue them
- * representing pointer motion, or button presses.
+ * on the event queue.
  *
- * events is not NULL-terminated; the return value is the number of events.
+ * This function is not reentrant. Disable signals before calling.
- * The DDX is responsible for allocating the event structure in the first
+ *
+ * @param device The device to generate the event for
+ * @param type Event type, one of ButtonPress, ButtonRelease, MotionNotify
+ * @param buttons Button number of the buttons modified. Must be 0 for
+ * MotionNotify
+ * @param flags Event modification flags
+ * @param mask Valuator mask for valuators present for this event.
+ */
+void
+QueuePointerEvents(DeviceIntPtr device, int type,
+                   int buttons, int flags, const ValuatorMask *mask)
+{
+    int nevents;
+
+    nevents = GetPointerEvents(InputEventList, device, type, buttons, flags, mask);
+    queueEventList(device, InputEventList, nevents);
+}
+
+/**
+ * Generate a series of InternalEvents representing pointer motion, or
+ * button presses.
+ *
+ * The DDX is responsible for allocating the events in the first
  * place via InitEventList() and GetMaximumEventsNum(), and for freeing it.
  *
  * In the generated events rootX/Y will be in absolute screen coords and
@@ -1085,9 +1100,11 @@ transformAbsolute(DeviceIntPtr dev, ValuatorMask *mask)
  * last.valuators[x] of the master device is in absolute screen coords.
  *
  * master->last.valuators[x] for x > 2 is undefined.
+ *
+ * @return the number of events written into events.
  */
 int
-GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
+GetPointerEvents(InternalEvent *events, DeviceIntPtr pDev, int type, int buttons,
                  int flags, const ValuatorMask *mask_in) {
     int num_events = 1;
     CARD32 ms;
@@ -1125,7 +1142,7 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
 
     events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT, &num_events);
 
-    raw = (RawDeviceEvent*)events->event;
+    raw = &events->raw_event;
     events++;
     num_events++;
 
@@ -1158,7 +1175,16 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
             }
         }
 
-        transformAbsolute(pDev, &mask);
+        x = (valuator_mask_isset(&mask, 0) ? valuator_mask_get(&mask, 0) :
+             pDev->last.valuators[0]);
+        y = (valuator_mask_isset(&mask, 1) ? valuator_mask_get(&mask, 1) :
+             pDev->last.valuators[1]);
+        transformAbsolute(pDev, &mask, &x, &y);
+        if (valuator_mask_isset(&mask, 0))
+            valuator_mask_set(&mask, 0, x);
+        if (valuator_mask_isset(&mask, 1))
+            valuator_mask_set(&mask, 1, y);
+
         moveAbsolute(pDev, &x, &y, &mask);
     } else {
         if (flags & POINTER_ACCELERATE) {
@@ -1185,7 +1211,7 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
 
     clipValuators(pDev, &mask);
 
-    event = (DeviceEvent*) events->event;
+    event = &events->device_event;
     init_event(pDev, event, ms);
 
     if (type == MotionNotify) {
@@ -1214,17 +1240,39 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
     return num_events;
 }
 
+/**
+ * Generate internal events representing this proximity event and enqueue
+ * them on the event queue.
+ *
+ * This function is not reentrant. Disable signals before calling.
+ *
+ * @param device The device to generate the event for
+ * @param type Event type, one of ProximityIn or ProximityOut
+ * @param keycode Key code of the pressed/released key
+ * @param mask Valuator mask for valuators present for this event.
+ *
+ */
+void
+QueueProximityEvents(DeviceIntPtr device, int type,
+                     const ValuatorMask *mask)
+{
+    int nevents;
+
+    nevents = GetProximityEvents(InputEventList, device, type, mask);
+    queueEventList(device, InputEventList, nevents);
+}
 
 /**
  * Generate ProximityIn/ProximityOut InternalEvents, accompanied by
  * valuators.
  *
- * events is not NULL-terminated; the return value is the number of events.
+ * The DDX is responsible for allocating the events in the first place via
- * The DDX is responsible for allocating the event structure in the first
+ * InitEventList(), and for freeing it.
- * place via GetMaximumEventsNum(), and for freeing it.
+ *
+ * @return the number of events written into events.
  */
 int
-GetProximityEvents(EventList *events, DeviceIntPtr pDev, int type, const ValuatorMask *mask_in)
+GetProximityEvents(InternalEvent *events, DeviceIntPtr pDev, int type, const ValuatorMask *mask_in)
 {
     int num_events = 1, i;
     DeviceEvent *event;
@@ -1256,7 +1304,7 @@ GetProximityEvents(EventList *events, DeviceIntPtr pDev, int type, const Valuato
 
     events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT, &num_events);
 
-    event = (DeviceEvent *) events->event;
+    event = &events->device_event;
     init_event(pDev, event, GetTimeInMillis());
     event->type = (type == ProximityIn) ? ET_ProximityIn : ET_ProximityOut;
 

dix/inpututils.c

@@ -36,6 +36,7 @@
 #include "xkbsrv.h"
 #include "xkbstr.h"
 #include "inpututils.h"
+#include "eventstr.h"
 
 /* Check if a button map change is okay with the device.
  * Returns -1 for BadValue, as it collides with MappingBusy. */
@@ -556,3 +557,30 @@ CountBits(const uint8_t *mask, int len)
 
     return ret;
 }
+
+/**
+ * Verifies sanity of the event. If the event is not an internal event,
+ * memdumps the first 32 bytes of event to the log, a backtrace, then kill
+ * the server.
+ */
+void verify_internal_event(const InternalEvent *ev)
+{
+    if (ev && ev->any.header != ET_Internal)
+    {
+        int i;
+        unsigned char *data = (unsigned char*)ev;
+
+        ErrorF("dix: invalid event type %d\n", ev->any.header);
+
+        for (i = 0; i < sizeof(xEvent); i++, data++)
+        {
+            ErrorF("%02hx ", *data);
+
+            if ((i % 8) == 7)
+                ErrorF("\n");
+        }
+
+        xorg_backtrace();
+        FatalError("Wrong event type %d. Aborting server\n", ev->any.header);
+    }
+}

hw/dmx/input/dmxevents.c

@@ -176,19 +176,15 @@ static void enqueueMotion(DevicePtr pDev, int x, int y)
 {
     GETDMXLOCALFROMPDEV;
     DeviceIntPtr p = dmxLocal->pDevice;
-    int i, nevents, valuators[3];
+    int valuators[3];
-    EventListPtr events;
     int detail = 0;  /* XXX should this be mask of pressed buttons? */
     ValuatorMask mask;
     valuators[0] = x;
     valuators[1] = y;
 
     valuator_mask_set_range(&mask, 0, 2, valuators);
-    GetEventList(&events);
+    QueuePointerEvents(p, MotionNotify, detail,
-    nevents = GetPointerEvents(events, p, MotionNotify, detail,
                        POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
-    for (i = 0; i < nevents; i++)
-       mieqEnqueue(p, (InternalEvent*)(events + i)->event);
     return;
 }
 
@@ -291,10 +287,7 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
     deviceValuator         *xv     = (deviceValuator *)xev+1;
     int                    thisX   = 0;
     int                    thisY   = 0;
-    int                    i;
     int                    count;
-    EventListPtr           events;
-    int                    nevents;
     ValuatorMask           mask;
 
     memset(xE, 0, sizeof(xE));
@@ -348,6 +341,7 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
             }
             count              = 2;
     } else {
+        int i;
         for (i = 0, count = 0; i < axesCount; i += 6) {
             xev->time          = GetTimeInMillis();
             xev->type          = DeviceMotionNotify;
@@ -375,11 +369,8 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
     if (block)
         dmxSigioBlock();
     valuator_mask_set_range(&mask, firstAxis, axesCount, v);
-    GetEventList(&events);
+    QueuePointerEvents(pDevice, MotionNotify, 0,
-    nevents = GetPointerEvents(events, pDevice, MotionNotify, 0,
                        POINTER_ABSOLUTE, &mask);
-    for (i = 0; i < nevents; i++)
-        mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
 
     if (block)
         dmxSigioUnblock();
@@ -394,8 +385,6 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
     XDeviceMotionEvent     *me     = (XDeviceMotionEvent *)e;
     DeviceIntPtr           pDevice = dmxLocal->pDevice;
     int                    valuators[MAX_VALUATORS];
-    EventListPtr           events;
-    int                    nevents, i;
     ValuatorMask           mask;
 
     if (!e)
@@ -452,12 +441,7 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
         valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
         if (block)
             dmxSigioBlock();
-        GetEventList(&events);
+        QueueKeyboardEvents(pDevice, event, ke->keycode, &mask);
-        nevents = GetKeyboardEvents(events, pDevice, event,
-                                    ke->keycode, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
         if (block)
             dmxSigioUnblock();
         break;
@@ -467,12 +451,8 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
         valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
         if (block)
             dmxSigioBlock();
-        GetEventList(&events);
+        QueuePointerEvents(pDevice, event, ke->keycode,
-        nevents = GetPointerEvents(events, pDevice, event, ke->keycode,
                            POINTER_ABSOLUTE, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
         if (block)
             dmxSigioUnblock();
         break;
@@ -482,11 +462,7 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
         valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
         if (block)
             dmxSigioBlock();
-        GetEventList(&events);
+        QueueProximityEvents(pDevice, event, &mask);
-        nevents = GetProximityEvents(events, pDevice, event, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
         if (block)
             dmxSigioUnblock();
         break;
@@ -667,8 +643,7 @@ void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
     GETDMXINPUTFROMPDEV;
     xEvent xE;
     DeviceIntPtr p = dmxLocal->pDevice;
-    int i, nevents, valuators[3];
+    int valuators[3];
-    EventListPtr events;
     ValuatorMask mask;
 
     DMXDBG2("dmxEnqueue: Enqueuing type=%d detail=0x%0x\n", type, detail);
@@ -683,34 +658,25 @@ void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
         if (dmxLocal->sendsCore && dmxLocal != dmxLocalCoreKeyboard)
             xE.u.u.detail = dmxFixup(pDev, detail, keySym);
 
-        GetEventList(&events);
         /*ErrorF("KEY %d  sym %d\n", detail, (int) keySym);*/
-        nevents = GetKeyboardEvents(events, p, type, detail, NULL);
+        QueueKeyboardEvents(p, type, detail, NULL);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
         return;
 
     case ButtonPress:
     case ButtonRelease:
         detail = dmxGetButtonMapping(dmxLocal, detail);
         valuator_mask_zero(&mask);
-        GetEventList(&events);
+        QueuePointerEvents(p, type, detail,
-        nevents = GetPointerEvents(events, p, type, detail,
                            POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
         return;
 
     case MotionNotify:
-        GetEventList(&events);
         valuators[0] = e->xmotion.x;
         valuators[1] = e->xmotion.y;
         valuators[2] = e->xmotion.state; /* FIXME: WTF?? */
         valuator_mask_set_range(&mask, 0, 3, valuators);
-        nevents = GetPointerEvents(events, p, type, detail, 
+        QueuePointerEvents(p, type, detail,
                            POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
         return;
 
     case EnterNotify:

hw/kdrive/src/kinput.c

@@ -66,8 +66,6 @@ static struct KdConfigDevice *kdConfigPointers    = NULL;
 static KdKeyboardDriver *kdKeyboardDrivers = NULL;
 static KdPointerDriver  *kdPointerDrivers  = NULL;
 
-static EventListPtr     kdEvents = NULL;
-
 static Bool		kdInputEnabled;
 static Bool		kdOffScreen;
 static unsigned long	kdOffScreenTime;
@@ -1793,7 +1791,7 @@ void
 KdReleaseAllKeys (void)
 {
 #if 0
-    int	key, nEvents, i;
+    int	key;
     KdKeyboardInfo *ki;
 
     KdBlockSigio ();
@@ -1803,10 +1801,7 @@ KdReleaseAllKeys (void)
              key++) {
             if (key_is_down(ki->dixdev, key, KEY_POSTED | KEY_PROCESSED)) {
                 KdHandleKeyboardEvent(ki, KeyRelease, key);
-                GetEventList(&kdEvents);
+                QueueGetKeyboardEvents(ki->dixdev, KeyRelease, key, NULL);
-                nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, KeyRelease, key, NULL);
-                for (i = 0; i < nEvents; i++)
-                    KdQueueEvent (ki->dixdev, (kdEvents + i)->event);
             }
         }
     }
@@ -1842,7 +1837,7 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,
     unsigned char key_code;
     KeyClassPtr	keyc = NULL;
     KeybdCtrl *ctrl = NULL;
-    int type, nEvents, i;
+    int type;
 
     if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed || !ki->dixdev->key)
 	return;
@@ -1862,11 +1857,7 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,
 	else
 	    type = KeyPress;
 
-        GetEventList(&kdEvents);
+        QueueKeyboardEvents(ki->dixdev, type, key_code, NULL);
-
-        nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, type, key_code, NULL);
-        for (i = 0; i < nEvents; i++)
-            KdQueueEvent(ki->dixdev, (InternalEvent *)((kdEvents + i)->event));
     }
     else {
         ErrorF("driver %s wanted to post scancode %d outside of [%d, %d]!\n",
@@ -1965,7 +1956,6 @@ void
 _KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
                         int b, int absrel, Bool force)
 {
-    int nEvents = 0, i = 0;
     int valuators[3] = { x, y, z };
     ValuatorMask mask;
 
@@ -1975,10 +1965,7 @@ _KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
 
     valuator_mask_set_range(&mask, 0, 3, valuators);
 
-    GetEventList(&kdEvents);
+    QueuePointerEvents(pi->dixdev, type, b, absrel, &mask);
-    nEvents = GetPointerEvents(kdEvents, pi->dixdev, type, b, absrel, &mask);
-    for (i = 0; i < nEvents; i++)
-        KdQueueEvent(pi->dixdev, (InternalEvent *)((kdEvents + i)->event));
 }
 
 void

hw/xfree86/common/xf86Events.c

@@ -376,7 +376,7 @@ static void
 xf86ReleaseKeys(DeviceIntPtr pDev)
 {
     KeyClassPtr keyc;
-    int i, j, nevents, sigstate;
+    int i, sigstate;
 
     if (!pDev || !pDev->key)
         return;
@@ -399,9 +399,7 @@ xf86ReleaseKeys(DeviceIntPtr pDev)
          i++) {
         if (key_is_down(pDev, i, KEY_POSTED)) {
             sigstate = xf86BlockSIGIO ();
-            nevents = GetKeyboardEvents(xf86Events, pDev, KeyRelease, i, NULL);
+            QueueKeyboardEvents(pDev, KeyRelease, i, NULL);
-            for (j = 0; j < nevents; j++)
-                mieqEnqueue(pDev, (InternalEvent*)(xf86Events + j)->event);
             xf86UnblockSIGIO(sigstate);
         }
     }

hw/xfree86/common/xf86Init.c

@@ -806,8 +806,6 @@ InitInput(int argc, char **argv)
 
     mieqInit();
 
-    GetEventList(&xf86Events);
-
     /* Initialize all configured input devices */
     for (pDev = xf86ConfigLayout.inputs; pDev && *pDev; pDev++) {
         /* Replace obsolete keyboard driver with kbd */

hw/xfree86/common/xf86Priv.h

@@ -148,9 +148,6 @@ extern _X_EXPORT int xf86SetVerbosity(int verb);
 extern _X_EXPORT int xf86SetLogVerbosity(int verb);
 extern _X_EXPORT Bool xf86CallDriverProbe( struct _DriverRec * drv, Bool detect_only );
 
-/* xf86Xinput.c */
-extern _X_EXPORT EventList *xf86Events;
-
 #endif /* _NO_XF86_PROTOTYPES */
 
 

hw/xfree86/common/xf86Xinput.c

@@ -99,8 +99,6 @@
 		return;								\
 	}
 
-EventListPtr xf86Events = NULL;
-
 static int
 xf86InputDevicePostInit(DeviceIntPtr dev);
 
@@ -329,8 +327,8 @@ xf86ActivateDevice(InputInfoPtr pInfo)
     dev->config_info = xf86SetStrOption(pInfo->options, "config_info", NULL);
 
     if (serverGeneration == 1)
-        xf86Msg(X_INFO, "XINPUT: Adding extended input device \"%s\" (type: %s)\n",
+        xf86Msg(X_INFO, "XINPUT: Adding extended input device \"%s\" (type: %s, id %d)\n",
-                pInfo->name, pInfo->type_name);
+                pInfo->name, pInfo->type_name, dev->id);
 
     return dev;
 }
@@ -1012,7 +1010,6 @@ xf86PostMotionEventM(DeviceIntPtr	device,
                      int		is_absolute,
                      const ValuatorMask	*mask)
 {
-    int i = 0, nevents = 0;
     int flags = 0;
 
     if (valuator_mask_num_valuators(mask) > 0)
@@ -1050,11 +1047,7 @@ xf86PostMotionEventM(DeviceIntPtr	device,
         }
 #endif
 
-    nevents = GetPointerEvents(xf86Events, device, MotionNotify, 0, flags, mask);
+    QueuePointerEvents(device, MotionNotify, 0, flags, mask);
-
-    for (i = 0; i < nevents; i++) {
-        mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));
-    }
 }
 
 void
@@ -1099,13 +1092,7 @@ xf86PostProximityEventM(DeviceIntPtr	device,
                         int		is_in,
                         const ValuatorMask *mask)
 {
-    int i, nevents;
+    QueueProximityEvents(device, is_in ? ProximityIn : ProximityOut, mask);
-
-    nevents = GetProximityEvents(xf86Events, device,
-                                 is_in ? ProximityIn : ProximityOut, mask);
-    for (i = 0; i < nevents; i++)
-        mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));
-
 }
 
 void
@@ -1157,7 +1144,6 @@ xf86PostButtonEventM(DeviceIntPtr	device,
                      int		is_down,
                      const ValuatorMask	*mask)
 {
-    int i = 0, nevents = 0;
     int flags = 0;
 
     if (valuator_mask_num_valuators(mask) > 0)
@@ -1177,13 +1163,9 @@ xf86PostButtonEventM(DeviceIntPtr	device,
     }
 #endif
 
-    nevents = GetPointerEvents(xf86Events, device,
+    QueuePointerEvents(device,
                        is_down ? ButtonPress : ButtonRelease, button,
                        flags, mask);
-
-    for (i = 0; i < nevents; i++)
-        mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));
-
 }
 
 void
@@ -1235,8 +1217,6 @@ xf86PostKeyEventM(DeviceIntPtr	device,
                   int		is_absolute,
                   const ValuatorMask *mask)
 {
-    int i = 0, nevents = 0;
-
 #if XFreeXDGA
     DeviceIntPtr pointer;
 
@@ -1250,12 +1230,9 @@ xf86PostKeyEventM(DeviceIntPtr	device,
     }
 #endif
 
-    nevents = GetKeyboardEvents(xf86Events, device,
+    QueueKeyboardEvents(device,
                         is_down ? KeyPress : KeyRelease,
                         key_code, mask);
-
-    for (i = 0; i < nevents; i++)
-        mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));
 }
 
 void

hw/xnest/Events.c

@@ -43,8 +43,6 @@ is" without express or implied warranty.
 
 CARD32 lastEventTime = 0;
 
-extern EventList *xnestEvents;
-
 void
 ProcessInputEvents(void)
 {
@@ -104,23 +102,17 @@ xnestCollectExposures(void)
 void
 xnestQueueKeyEvent(int type, unsigned int keycode)
 {
-  int i, n;
-
-  GetEventList(&xnestEvents);
   lastEventTime = GetTimeInMillis();
-  n = GetKeyboardEvents(xnestEvents, xnestKeyboardDevice, type, keycode, NULL);
+  QueueKeyboardEvents(xnestKeyboardDevice, type, keycode, NULL);
-  for (i = 0; i < n; i++)
-    mieqEnqueue(xnestKeyboardDevice, (InternalEvent*)(xnestEvents + i)->event);
 }
 
 void
 xnestCollectEvents(void)
 {
   XEvent X;
-  int i, n, valuators[2];
+  int valuators[2];
   ValuatorMask mask;
   ScreenPtr pScreen;
-  GetEventList(&xnestEvents);
 
   while (XCheckIfEvent(xnestDisplay, &X, xnestNotExposurePredicate, NULL)) {
     switch (X.type) {
@@ -138,20 +130,16 @@ xnestCollectEvents(void)
       valuator_mask_set_range(&mask, 0, 0, NULL);
       xnestUpdateModifierState(X.xkey.state);
       lastEventTime = GetTimeInMillis();
-      n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonPress,
+      QueuePointerEvents(xnestPointerDevice, ButtonPress,
                          X.xbutton.button, POINTER_RELATIVE, &mask);
-      for (i = 0; i < n; i++)
-        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
       break;
       
     case ButtonRelease:
       valuator_mask_set_range(&mask, 0, 0, NULL);
       xnestUpdateModifierState(X.xkey.state);
       lastEventTime = GetTimeInMillis();
-      n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonRelease,
+      QueuePointerEvents(xnestPointerDevice, ButtonRelease,
                          X.xbutton.button, POINTER_RELATIVE, &mask);
-      for (i = 0; i < n; i++)
-        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
       break;
       
     case MotionNotify:
@@ -159,10 +147,8 @@ xnestCollectEvents(void)
       valuators[1] = X.xmotion.y;
       valuator_mask_set_range(&mask, 0, 2, valuators);
       lastEventTime = GetTimeInMillis();
-      n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,
+      QueuePointerEvents(xnestPointerDevice, MotionNotify,
                          0, POINTER_ABSOLUTE, &mask);
-      for (i = 0; i < n; i++)
-        mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
       break;
       
     case FocusIn:
@@ -193,10 +179,8 @@ xnestCollectEvents(void)
           valuators[1] = X.xcrossing.y;
           valuator_mask_set_range(&mask, 0, 2, valuators);
           lastEventTime = GetTimeInMillis();
-          n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,
+          QueuePointerEvents(xnestPointerDevice, MotionNotify,
                              0, POINTER_ABSOLUTE, &mask);
-          for (i = 0; i < n; i++)
-            mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
 	  xnestDirectInstallColormaps(pScreen);
 	}
       }

hw/xnest/Init.c

@@ -45,8 +45,6 @@ is" without express or implied warranty.
 
 Bool xnestDoFullGeneration = True;
 
-EventList *xnestEvents = NULL;
-
 void
 InitOutput(ScreenInfo *screenInfo, int argc, char *argv[])
 {
@@ -100,8 +98,6 @@ InitInput(int argc, char *argv[])
   if (rc != Success)
       FatalError("Failed to init Xnest default devices.\n");
 
-  GetEventList(&xnestEvents);
-
   mieqInit();
 
   AddEnabledDevice(XConnectionNumber(xnestDisplay));

hw/xquartz/darwinEvents.c

@@ -88,7 +88,7 @@ static pthread_mutex_t fd_add_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t fd_add_ready_cond = PTHREAD_COND_INITIALIZER;
 static pthread_t fd_add_tid = NULL;
 
-static EventListPtr darwinEvents = NULL;
+static InternalEvent* darwinEvents = NULL;
 
 static pthread_mutex_t mieq_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t mieq_ready_cond = PTHREAD_COND_INITIALIZER;
@@ -433,7 +433,6 @@ static void DarwinPrepareValuators(DeviceIntPtr pDev, int *valuators, ScreenPtr
 void DarwinSendPointerEvents(DeviceIntPtr pDev, int ev_type, int ev_button, float pointer_x, float pointer_y, 
 			     float pressure, float tilt_x, float tilt_y) {
 	static int darwinFakeMouseButtonDown = 0;
-	int i, num_events;
     ScreenPtr screen;
     int valuators[5];
 	
@@ -486,15 +485,12 @@ void DarwinSendPointerEvents(DeviceIntPtr pDev, int ev_type, int ev_button, floa
     darwinEvents_lock(); {
         ValuatorMask mask;
         valuator_mask_set_range(&mask, 0, (pDev == darwinPointer) ? 2 : 5, valuators);
-        num_events = GetPointerEvents(darwinEvents, pDev, ev_type, ev_button, 
+        QueuePointerEvents(pDev, ev_type, ev_button, POINTER_ABSOLUTE, &mask);
-                                      POINTER_ABSOLUTE, &mask);
+        DarwinPokeEQ();
-        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
-        if(num_events > 0) DarwinPokeEQ();
     } darwinEvents_unlock();
 }
 
 void DarwinSendKeyboardEvents(int ev_type, int keycode) {
-	int i, num_events;
 
 	if(!darwinEvents) {
 		DEBUG_LOG("DarwinSendKeyboardEvents called before darwinEvents was initialized\n");
@@ -502,15 +498,13 @@ void DarwinSendKeyboardEvents(int ev_type, int keycode) {
 	}
 
     darwinEvents_lock(); {
-        num_events = GetKeyboardEvents(darwinEvents, darwinKeyboard, ev_type, keycode + MIN_KEYCODE, NULL);
+        QueueKeyboardEvents(darwinKeyboard, ev_type, keycode + MIN_KEYCODE, NULL);
-        for(i=0; i<num_events; i++) mieqEnqueue(darwinKeyboard, (InternalEvent*)darwinEvents[i].event);
+        DarwinPokeEQ();
-        if(num_events > 0) DarwinPokeEQ();
     } darwinEvents_unlock();
 }
 
 void DarwinSendProximityEvents(DeviceIntPtr pDev, int ev_type, float pointer_x, float pointer_y,  
                                float pressure, float tilt_x, float tilt_y) {
-    int i, num_events;
     ScreenPtr screen;
     int valuators[5];
 
@@ -531,9 +525,8 @@ void DarwinSendProximityEvents(DeviceIntPtr pDev, int ev_type, float pointer_x,
     darwinEvents_lock(); {
         ValuatorMask mask;
         valuator_mask_set_range(&mask, 0, 5, valuators);
-        num_events = GetProximityEvents(darwinEvents, pDev, ev_type, &mask);
+        QueueProximityEvents(pDev, ev_type, &mask);
-        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
+        DarwinPokeEQ();
-        if(num_events > 0) DarwinPokeEQ();
     } darwinEvents_unlock();
 }
 

hw/xwin/winkeybd.c

@@ -472,8 +472,7 @@ winKeybdReleaseKeys (void)
 void
 winSendKeyEvent (DWORD dwKey, Bool fDown)
 {
-  EventListPtr events;
+  InternalEvent* events;
-  int i, nevents;
 
   /*
    * When alt-tabing between screens we can get phantom key up messages
@@ -484,11 +483,7 @@ winSendKeyEvent (DWORD dwKey, Bool fDown)
   /* Update the keyState map */
   g_winKeyState[dwKey] = fDown;
 
-  GetEventList(&events);
+  QueueKeyboardEvents(g_pwinKeyboard, fDown ? KeyPress : KeyRelease, dwKey + MIN_KEYCODE, NULL);
-  nevents = GetKeyboardEvents(events, g_pwinKeyboard, fDown ? KeyPress : KeyRelease, dwKey + MIN_KEYCODE, NULL);
-
-  for (i = 0; i < nevents; i++)
-    mieqEnqueue(g_pwinKeyboard, (InternalEvent*)events[i].event);
 
   winDebug("winSendKeyEvent: dwKey: %d, fDown: %d, nEvents %d\n",
            dwKey, fDown, nevents);

hw/xwin/winmouse.c

@@ -234,21 +234,15 @@ winMouseWheel (ScreenPtr pScreen, int iDeltaZ)
 void
 winMouseButtonsSendEvent (int iEventType, int iButton)
 {
-  EventListPtr events;
-  int i, nevents;
   ValuatorMask mask;
 
   if (g_winMouseButtonMap)
     iButton = g_winMouseButtonMap[iButton];
 
   valuator_mask_zero(&mask);
-  GetEventList(&events);
+  QueuePointerEvents(g_pwinPointer, iEventType, iButton,
-  nevents = GetPointerEvents(events, g_pwinPointer, iEventType, iButton,
 		     POINTER_RELATIVE, &mask);
 
-  for (i = 0; i < nevents; i++)
-    mieqEnqueue(g_pwinPointer, (InternalEvent*)events[i].event);
-
 #if CYGDEBUG
   ErrorF("winMouseButtonsSendEvent: iEventType: %d, iButton: %d, nEvents %d\n",
           iEventType, iButton, nevents);
@@ -367,20 +361,15 @@ winMouseButtonsHandle (ScreenPtr pScreen,
  */
 void winEnqueueMotion(int x, int y)
 {
-  int i, nevents;
   int valuators[2];
   ValuatorMask mask;
-  EventListPtr events;
 
   miPointerSetPosition(g_pwinPointer, POINTER_RELATIVE, &x, &y);
   valuators[0] = x;
   valuators[1] = y;
 
   valuator_mask_set_range(&mask, 0, 2, valuators);
-  GetEventList(&events);
+  QueuePointerEvents(g_pwinPointer, MotionNotify, 0,
-  nevents = GetPointerEvents(events, g_pwinPointer, MotionNotify, 0,
 		     POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
 
-  for (i = 0; i < nevents; i++)
-    mieqEnqueue(g_pwinPointer, (InternalEvent*)events[i].event);
 }

include/dix.h

@@ -375,7 +375,7 @@ extern void ReleaseActiveGrabs(
 extern GrabPtr CheckPassiveGrabsOnWindow(
     WindowPtr /* pWin */,
     DeviceIntPtr /* device */,
-    DeviceEvent * /* event */,
+    InternalEvent * /* event */,
     BOOL /* checkCore */,
     BOOL /* activate */);
 
@@ -415,7 +415,7 @@ extern void DeliverFocusedEvent(
     InternalEvent* /* event */,
     WindowPtr /* window */);
 
-extern void DeliverGrabbedEvent(
+extern int DeliverGrabbedEvent(
     InternalEvent* /* event */,
     DeviceIntPtr /* thisDev */,
     Bool /* deactivateGrab */);

include/eventstr.h

@@ -68,10 +68,6 @@ enum EventType {
     ET_Internal = 0xFF /* First byte */
 };
 
-#define CHECKEVENT(ev) if (ev && ((InternalEvent*)(ev))->any.header != 0xFF) \
-                          FatalError("Wrong event type %d.\n", \
-                                     ((InternalEvent*)(ev))->any.header);
-
 /**
  * Used for ALL input device events internal in the server until
  * copied into the matching protocol event.

include/input.h

@@ -109,19 +109,8 @@ typedef union _GrabMask GrabMask;
 
 typedef struct _ValuatorMask ValuatorMask;
 
-typedef struct _EventList {
-    xEvent* event;
-    int evlen; /* length of allocated memory for event in bytes.  This is not
-                  the actual length of the event. The event's actual length is
-                  32 for standard events or 32 +
-                  ((xGenericEvent*)event)->length * 4 for GenericEvents.
-                  For events in the EQ, the length is
-                  ((InternalEvent*)event)->u.any.length */
-} EventList, *EventListPtr;
-
 /* The DIX stores incoming input events in this list */
-extern EventListPtr InputEventList;
+extern InternalEvent* InputEventList;
-extern int InputEventListLen;
 
 typedef int (*DeviceProc)(
     DeviceIntPtr /*device*/,
@@ -439,22 +428,28 @@ extern _X_EXPORT void CloseInput(void);
 
 extern _X_EXPORT int GetMaximumEventsNum(void);
 
-extern _X_EXPORT int GetEventList(EventListPtr* list);
+extern _X_EXPORT InternalEvent *InitEventList(int num_events);
-extern _X_EXPORT EventListPtr InitEventList(int num_events);
+extern _X_EXPORT void FreeEventList(InternalEvent *list, int num_events);
-extern _X_EXPORT void FreeEventList(EventListPtr list, int num_events);
 
-extern void CreateClassesChangedEvent(EventListPtr event,
+extern void CreateClassesChangedEvent(InternalEvent *event,
                                       DeviceIntPtr master,
                                       DeviceIntPtr slave,
                                       int type);
-extern EventListPtr UpdateFromMaster(
+extern InternalEvent * UpdateFromMaster(
-    EventListPtr events,
+    InternalEvent *events,
     DeviceIntPtr pDev,
     int type,
     int *num_events);
 
 extern _X_EXPORT int GetPointerEvents(
-    EventListPtr events,
+    InternalEvent *events,
+    DeviceIntPtr pDev,
+    int type,
+    int buttons,
+    int flags,
+    const ValuatorMask *mask);
+
+extern _X_EXPORT void QueuePointerEvents(
     DeviceIntPtr pDev,
     int type,
     int buttons,
@@ -462,14 +457,25 @@ extern _X_EXPORT int GetPointerEvents(
     const ValuatorMask *mask);
 
 extern _X_EXPORT int GetKeyboardEvents(
-    EventListPtr events,
+    InternalEvent *events,
+    DeviceIntPtr pDev,
+    int type,
+    int key_code,
+    const ValuatorMask *mask);
+
+extern _X_EXPORT void QueueKeyboardEvents(
     DeviceIntPtr pDev,
     int type,
     int key_code,
     const ValuatorMask *mask);
 
 extern int GetProximityEvents(
-    EventListPtr events,
+    InternalEvent *events,
+    DeviceIntPtr pDev,
+    int type,
+    const ValuatorMask *mask);
+
+extern void QueueProximityEvents(
     DeviceIntPtr pDev,
     int type,
     const ValuatorMask *mask);
@@ -495,6 +501,8 @@ extern _X_EXPORT int GetMotionHistory(
     ScreenPtr pScreen,
     BOOL core);
 
+extern void ReleaseButtonsAndKeys(DeviceIntPtr dev);
+
 extern int AttachDevice(ClientPtr client,
                         DeviceIntPtr slave,
                         DeviceIntPtr master);

include/inputstr.h

@@ -591,4 +591,14 @@ typedef struct _EventSyncInfo {
 
 extern EventSyncInfoRec syncEvents;
 
+/**
+ * Given a sprite, returns the window at the bottom of the trace (i.e. the
+ * furthest window from the root).
+ */
+static inline WindowPtr DeepestSpriteWin(SpritePtr sprite)
+{
+    assert(sprite->spriteTraceGood > 0);
+    return sprite->spriteTrace[sprite->spriteTraceGood - 1];
+}
+
 #endif /* INPUTSTRUCT_H */

include/inpututils.h

@@ -37,4 +37,6 @@ struct _ValuatorMask {
     int         valuators[MAX_VALUATORS]; /* valuator data */
 };
 
+extern void verify_internal_event(const InternalEvent *ev);
+
 #endif

include/misc.h

@@ -223,6 +223,24 @@ pad_to_int32(const int bytes) {
 extern char**
 xstrtokenize(const char *str, const char* separators);
 
+/**
+ * Compare the two version numbers comprising of major.minor.
+ *
+ * @return A value less than 0 if a is less than b, 0 if a is equal to b,
+ * or a value greater than 0
+ */
+static inline int
+version_compare(uint16_t a_major, uint16_t a_minor,
+                uint16_t b_major, uint16_t b_minor)
+{
+    int a, b;
+
+    a = a_major << 16 | a_minor;
+    b = b_major << 16 | b_minor;
+
+    return (a - b);
+}
+
 /* some macros to help swap requests, replies, and events */
 
 #define LengthRestB(stuff) \

mi/mieq.c

@@ -64,7 +64,7 @@ in this Software without prior written authorization from The Open Group.
 #define DequeueScreen(dev) dev->spriteInfo->sprite->pDequeueScreen
 
 typedef struct _Event {
-    EventListPtr    events;
+    InternalEvent*  events;
     ScreenPtr	    pScreen;
     DeviceIntPtr    pDev; /* device this event _originated_ from */
 } EventRec, *EventPtr;
@@ -111,7 +111,7 @@ mieqInit(void)
     for (i = 0; i < QUEUE_SIZE; i++)
     {
 	if (miEventQueue.events[i].events == NULL) {
-	    EventListPtr evlist = InitEventList(1);
+	    InternalEvent* evlist = InitEventList(1);
 	    if (!evlist)
 		FatalError("Could not allocate event queue.\n");
 	    miEventQueue.events[i].events = evlist;
@@ -146,7 +146,7 @@ void
 mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
 {
     unsigned int           oldtail = miEventQueue.tail;
-    EventListPtr           evt;
+    InternalEvent*         evt;
     int                    isMotion = 0;
     int                    evlen;
     Time                   time;
@@ -156,7 +156,7 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
     pthread_mutex_lock(&miEventQueueMutex);
 #endif
 
-    CHECKEVENT(e);
+    verify_internal_event(e);
 
     /* avoid merging events from different devices */
     if (e->any.type == ET_Motion)
@@ -188,21 +188,7 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
 
     evlen = e->any.length;
     evt = miEventQueue.events[oldtail].events;
-    if (evt->evlen < evlen)
+    memcpy(evt, e, evlen);
-    {
-        evt->evlen = evlen;
-        evt->event = realloc(evt->event, evt->evlen);
-        if (!evt->event)
-        {
-            ErrorF("[mi] Running out of memory. Tossing event.\n");
-#ifdef XQUARTZ
-            pthread_mutex_unlock(&miEventQueueMutex);
-#endif
-            return;
-        }
-    }
-
-    memcpy(evt->event, e, evlen);
 
     time = e->any.time;
     /* Make sure that event times don't go backwards - this
@@ -211,7 +197,7 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
         miEventQueue.lastEventTime - time < 10000)
         e->any.time = miEventQueue.lastEventTime;
 
-    miEventQueue.lastEventTime = ((InternalEvent*)evt->event)->any.time;
+    miEventQueue.lastEventTime = evt->any.time;
     miEventQueue.events[oldtail].pScreen = pDev ? EnqueueScreen(pDev) : NULL;
     miEventQueue.events[oldtail].pDev = pDev;
 
@@ -292,8 +278,8 @@ static void
 FixUpEventForMaster(DeviceIntPtr mdev, DeviceIntPtr sdev,
                     InternalEvent* original, InternalEvent *master)
 {
-    CHECKEVENT(original);
+    verify_internal_event(original);
-    CHECKEVENT(master);
+    verify_internal_event(master);
     /* Ensure chained button mappings, i.e. that the detail field is the
      * value of the mapped button on the SD, not the physical button */
     if (original->any.type == ET_ButtonPress ||
@@ -323,7 +309,7 @@ CopyGetMasterEvent(DeviceIntPtr sdev,
     int type = original->any.type;
     int mtype; /* which master type? */
 
-    CHECKEVENT(original);
+    verify_internal_event(original);
 
     /* ET_XQuartz has sdev == NULL */
     if (!sdev || IsMaster(sdev) || IsFloating(sdev))
@@ -376,7 +362,7 @@ mieqProcessDeviceEvent(DeviceIntPtr dev,
     DeviceIntPtr master;
     InternalEvent mevent; /* master event */
 
-    CHECKEVENT(event);
+    verify_internal_event(event);
 
     /* Custom event handler */
     handler = miEventQueue.handlers[event->any.type];
@@ -431,10 +417,8 @@ void
 mieqProcessInputEvents(void)
 {
     EventRec *e = NULL;
-    int evlen;
     ScreenPtr screen;
-    static InternalEvent *event = NULL;
+    static InternalEvent event;
-    static size_t event_size = 0;
     DeviceIntPtr dev = NULL,
                  master = NULL;
 
@@ -445,20 +429,7 @@ mieqProcessInputEvents(void)
     while (miEventQueue.head != miEventQueue.tail) {
         e = &miEventQueue.events[miEventQueue.head];
 
-        evlen   = e->events->evlen;
+        event = *e->events;
-        if(evlen > event_size)
-          {
-            event = realloc(event, evlen);
-            event_size = evlen;
-          }
-
-
-        if (!event)
-            FatalError("[mi] No memory left for event processing.\n");
-
-        memcpy(event, e->events->event, evlen);
-
-
         dev     = e->pDev;
         screen  = e->pScreen;
 
@@ -480,10 +451,10 @@ mieqProcessInputEvents(void)
             DPMSSet(serverClient, DPMSModeOn);
 #endif
 
-        mieqProcessDeviceEvent(dev, event, screen);
+        mieqProcessDeviceEvent(dev, &event, screen);
 
         /* Update the sprite now. Next event may be from different device. */
-        if (event->any.type == ET_Motion && master)
+        if (event.any.type == ET_Motion && master)
             miPointerUpdateSprite(dev);
 
 #ifdef XQUARTZ

mi/mipointer.c

@@ -63,6 +63,7 @@ in this Software without prior written authorization from The Open Group.
 # include   "dixstruct.h"
 # include   "inputstr.h"
 # include   "inpututils.h"
+# include   "eventstr.h"
 
 DevPrivateKeyRec miPointerScreenKeyRec;
 
@@ -99,7 +100,7 @@ static void miPointerDeviceCleanup(DeviceIntPtr pDev,
                                    ScreenPtr pScreen);
 static void miPointerMoveNoEvent (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y);
 
-static EventList* events; /* for WarpPointer MotionNotifies */
+static InternalEvent* events; /* for WarpPointer MotionNotifies */
 
 Bool
 miPointerInitialize (ScreenPtr                  pScreen,
@@ -689,7 +690,7 @@ miPointerMove (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
     darwinEvents_lock();
 #endif
     for (i = 0; i < nevents; i++)
-        mieqEnqueue(pDev, (InternalEvent*)events[i].event);
+        mieqEnqueue(pDev, &events[i]);
 #ifdef XQUARTZ
     darwinEvents_unlock();
 #endif

randr/rrdispatch.c

@@ -28,8 +28,8 @@ RRClientKnowsRates (ClientPtr	pClient)
 {
     rrClientPriv(pClient);
 
-    return (pRRClient->major_version > 1 ||
+    return version_compare(pRRClient->major_version, pRRClient->minor_version,
-	    (pRRClient->major_version == 1 && pRRClient->minor_version >= 1));
+                           1, 1) >= 0;
 }
 
 static int
@@ -47,8 +47,8 @@ ProcRRQueryVersion (ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    if ((stuff->majorVersion * 1000 + stuff->minorVersion) <
+    if (version_compare(stuff->majorVersion, stuff->minorVersion,
-        (SERVER_RANDR_MAJOR_VERSION * 1000 + SERVER_RANDR_MINOR_VERSION))
+                        SERVER_RANDR_MAJOR_VERSION, SERVER_RANDR_MINOR_VERSION) < 0)
     {
 	rep.majorVersion = stuff->majorVersion;
 	rep.minorVersion = stuff->minorVersion;

test/Makefile.am

@@ -1,7 +1,7 @@
 if ENABLE_UNIT_TESTS
 if HAVE_LD_WRAP
 SUBDIRS= . xi2
-noinst_PROGRAMS = xkb input xtest list
+noinst_PROGRAMS = xkb input xtest list misc
 check_LTLIBRARIES = libxservertest.la
 
 TESTS=$(noinst_PROGRAMS)
@@ -18,6 +18,7 @@ xkb_LDADD=$(TEST_LDADD)
 input_LDADD=$(TEST_LDADD)
 xtest_LDADD=$(TEST_LDADD)
 list_LDADD=$(TEST_LDADD)
+misc_LDADD=$(TEST_LDADD)
 
 libxservertest_la_LIBADD = \
             $(XSERVER_LIBS) \

test/misc.c

@@ -0,0 +1,62 @@
+/**
+ * Copyright © 2011 Red Hat, Inc.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a
+ *  copy of this software and associated documentation files (the "Software"),
+ *  to deal in the Software without restriction, including without limitation
+ *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ *  and/or sell copies of the Software, and to permit persons to whom the
+ *  Software is furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice (including the next
+ *  paragraph) shall be included in all copies or substantial portions of the
+ *  Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <stdint.h>
+#include "misc.h"
+
+static void dix_version_compare(void)
+{
+    int rc;
+
+    rc = version_compare(0, 0, 1, 0);
+    assert(rc < 0);
+    rc = version_compare(1, 0, 0, 0);
+    assert(rc > 0);
+    rc = version_compare(0, 0, 0, 0);
+    assert(rc == 0);
+    rc = version_compare(1, 0, 1, 0);
+    assert(rc == 0);
+    rc = version_compare(1, 0, 0, 9);
+    assert(rc > 0);
+    rc = version_compare(0, 9, 1, 0);
+    assert(rc < 0);
+    rc = version_compare(1, 0, 1, 9);
+    assert(rc < 0);
+    rc = version_compare(1, 9, 1, 0);
+    assert(rc > 0);
+    rc = version_compare(2, 0, 1, 9);
+    assert(rc > 0);
+    rc = version_compare(1, 9, 2, 0);
+    assert(rc < 0);
+}
+
+int main(int argc, char** argv)
+{
+    dix_version_compare();
+
+    return 0;
+}

xfixes/xfixes.c

@@ -72,17 +72,17 @@ ProcXFixesQueryVersion(ClientPtr client)
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
-    if (stuff->majorVersion < SERVER_XFIXES_MAJOR_VERSION) {
+
+    if (version_compare(stuff->majorVersion, stuff->minorVersion,
+                        SERVER_XFIXES_MAJOR_VERSION, SERVER_XFIXES_MAJOR_VERSION) < 0)
+    {
 	rep.majorVersion = stuff->majorVersion;
 	rep.minorVersion = stuff->minorVersion;
     } else {
 	rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
-	if (stuff->majorVersion == SERVER_XFIXES_MAJOR_VERSION &&
-	    stuff->minorVersion < SERVER_XFIXES_MINOR_VERSION)
-	    rep.minorVersion = stuff->minorVersion;
-	else
         rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;
     }
+
     pXFixesClient->major_version = rep.majorVersion;
     pXFixesClient->minor_version = rep.minorVersion;
     if (client->swapped) {

xkb/xkb.c

@@ -5586,6 +5586,7 @@ ProcXkbGetKbdByName(ClientPtr client)
 {
     DeviceIntPtr 		dev;
     DeviceIntPtr                tmpd;
+    DeviceIntPtr                master;
     xkbGetKbdByNameReply 	rep = {0};
     xkbGetMapReply		mrep = {0};
     xkbGetCompatMapReply	crep = {0};
@@ -5611,6 +5612,7 @@ ProcXkbGetKbdByName(ClientPtr client)
 	return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, access_mode);
+    master = GetMaster(dev, MASTER_KEYBOARD);
 
     xkb = dev->key->xkbInfo->desc;
     status= Success;
@@ -5869,8 +5871,26 @@ ProcXkbGetKbdByName(ClientPtr client)
 	}
 	xkb->ctrls->num_groups= nTG;
 
+	nkn.deviceID= nkn.oldDeviceID= dev->id;
+	nkn.minKeyCode= new->min_key_code;
+	nkn.maxKeyCode= new->max_key_code;
+	nkn.oldMinKeyCode= xkb->min_key_code;
+	nkn.oldMaxKeyCode= xkb->max_key_code;
+	nkn.requestMajor= XkbReqCode;
+	nkn.requestMinor= X_kbGetKbdByName;
+	nkn.changed= XkbNKN_KeycodesMask;
+	if (geom_changed)
+	    nkn.changed|= XkbNKN_GeometryMask;
+	XkbSendNewKeyboardNotify(dev,&nkn);
+
+        /* Update the map and LED info on the device itself, as well as
+         * any slaves if it's an MD, or its MD if it's an SD and was the
+         * last device used on that MD. */
         for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
-            if ((tmpd == dev) || (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
+            if (tmpd != dev && GetMaster(tmpd, MASTER_KEYBOARD) != dev &&
+                (tmpd != master || dev != master->lastSlave))
+                continue;
+
             if (tmpd != dev)
                 XkbCopyDeviceKeymap(tmpd, dev);
 
@@ -5887,27 +5907,6 @@ ProcXkbGetKbdByName(ClientPtr client)
             }
         }
     }
-
-	nkn.deviceID= nkn.oldDeviceID= dev->id;
-	nkn.minKeyCode= new->min_key_code;
-	nkn.maxKeyCode= new->max_key_code;
-	nkn.oldMinKeyCode= xkb->min_key_code;
-	nkn.oldMaxKeyCode= xkb->max_key_code;
-	nkn.requestMajor= XkbReqCode;
-	nkn.requestMinor= X_kbGetKbdByName;
-	nkn.changed= XkbNKN_KeycodesMask;
-	if (geom_changed)
-	    nkn.changed|= XkbNKN_GeometryMask;
-	XkbSendNewKeyboardNotify(dev,&nkn);
-
-	if (!IsMaster(dev)) {
-	    DeviceIntPtr master = GetMaster(dev, MASTER_KEYBOARD);
-	    if (master && master->lastSlave == dev) {
-		XkbCopyDeviceKeymap(master, dev);
-		XkbSendNewKeyboardNotify(dev,&nkn);
-	    }
-	}
-    }
     if ((new!=NULL)&&(new!=xkb)) {
 	XkbFreeKeyboard(new,XkbAllComponentsMask,TRUE);
 	new= NULL;

xkb/xkbActions.c

@@ -1351,7 +1351,7 @@ static void
 InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, ValuatorMask *mask)
 {
     ScreenPtr           pScreen;
-    EventListPtr        events;
+    InternalEvent*      events;
     int                 nevents, i;
     DeviceIntPtr        ptr, mpointer, lastSlave = NULL;
     Bool                saveWait;
@@ -1377,7 +1377,7 @@ InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, Valuat
     OsReleaseSignals();
 
     for (i = 0; i < nevents; i++)
-        mieqProcessDeviceEvent(ptr, (InternalEvent*)events[i].event, NULL);
+        mieqProcessDeviceEvent(ptr, &events[i], NULL);
 
     FreeEventList(events, GetMaximumEventsNum());
 

xkb/xkbEvents.c

@@ -88,11 +88,15 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
         if (!clients[i] || clients[i]->clientState != ClientStateRunning)
             continue;
 
-        /* Ignore clients which will have already received this.
+        /* XKB allows clients to restrict the MappingNotify events sent to
-         * Inconsistent with themselves, but consistent with previous
+         * them.  This was broken for three years.  Sorry. */
-         * behaviour.*/
+        if (xkb_event == XkbMapNotify &&
-        if (xkb_event == XkbMapNotify && (clients[i]->mapNotifyMask & changed))
+            (clients[i]->xkbClientFlags & _XkbClientInitialized) &&
+            !(clients[i]->mapNotifyMask & changed))
             continue;
+        /* Emulate previous server behaviour: any client which has activated
+         * XKB will not receive core events emulated from a NewKeyboardNotify
+         * at all. */
         if (xkb_event == XkbNewKeyboardNotify &&
             (clients[i]->xkbClientFlags & _XkbClientInitialized))
             continue;
@@ -164,9 +168,6 @@ XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
         if (!(clients[i]->newKeyboardNotifyMask & changed))
             continue;
 
-        if (!XIShouldNotify(clients[i], kbd))
-            continue;
-
         pNKN->sequenceNumber = clients[i]->sequence;
         pNKN->time = time;
         pNKN->changed = changed;
@@ -232,8 +233,7 @@ register CARD16	changed,bState;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->stateNotifyMask&changed) &&
+	    (interest->stateNotifyMask&changed)) {
-            XIShouldNotify(interest->client,kbd)) {
 	    pSN->sequenceNumber = interest->client->sequence;
 	    pSN->time = time;
 	    pSN->changed = changed;
@@ -280,9 +280,6 @@ XkbSendMapNotify(DeviceIntPtr kbd, xkbMapNotify *pMN)
         if (!(clients[i]->mapNotifyMask & changed))
             continue;
 
-        if (!XIShouldNotify(clients[i], kbd))
-            continue;
-
         pMN->time = time;
         pMN->sequenceNumber = clients[i]->sequence;
         pMN->changed = changed;
@@ -401,8 +398,7 @@ Time 		 	time = 0;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->ctrlsNotifyMask&changedControls) &&
+	    (interest->ctrlsNotifyMask&changedControls)) {
-            XIShouldNotify(interest->client, kbd)) {
 	    if (!initialized) {
 		pCN->type = XkbEventCode + XkbEventBase;
 		pCN->xkbType = XkbControlsNotify;
@@ -450,7 +446,6 @@ CARD32		state,changed;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-            XIShouldNotify(interest->client, kbd) &&
 	    (((xkbType==XkbIndicatorStateNotify)&&
 				(interest->iStateNotifyMask&changed))||
 	     ((xkbType==XkbIndicatorMapNotify)&&
@@ -534,8 +529,7 @@ XID		winID = 0;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->bellNotifyMask) &&
+	    (interest->bellNotifyMask)) {
-            XIShouldNotify(interest->client,kbd)) {
 	    if (!initialized) {
 		time = GetTimeInMillis();
 		bn.type = XkbEventCode + XkbEventBase;
@@ -589,8 +583,7 @@ CARD16		sk_delay,db_delay;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->accessXNotifyMask&(1<<pEv->detail)) &&
+	    (interest->accessXNotifyMask&(1<<pEv->detail))) {
-            XIShouldNotify(interest->client, kbd)) {
 	    if (!initialized) {
 		pEv->type = XkbEventCode + XkbEventBase;
 		pEv->xkbType = XkbAccessXNotify;
@@ -637,8 +630,7 @@ CARD32		changedIndicators;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->namesNotifyMask&pEv->changed) &&
+	    (interest->namesNotifyMask&pEv->changed)) {
-            XIShouldNotify(interest->client, kbd)) {
 	    if (!initialized) {
 		pEv->type = XkbEventCode + XkbEventBase;
 		pEv->xkbType = XkbNamesNotify;
@@ -683,8 +675,7 @@ CARD16		firstSI = 0, nSI = 0, nTotalSI = 0;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->compatNotifyMask) &&
+	    (interest->compatNotifyMask)) {
-            XIShouldNotify(interest->client, kbd)) {
 	    if (!initialized) {
 		pEv->type = XkbEventCode + XkbEventBase;
 		pEv->xkbType = XkbCompatMapNotify;
@@ -736,8 +727,7 @@ Time 		 time = 0;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->actionMessageMask) &&
+	    (interest->actionMessageMask)) {
-            XIShouldNotify(interest->client, kbd)) {
 	    if (!initialized) {
 		pEv->type = XkbEventCode + XkbEventBase;
 		pEv->xkbType = XkbActionMessage;
@@ -783,8 +773,7 @@ CARD16		 reason;
 	if ((!interest->client->clientGone) &&
 	    (interest->client->requestVector != InitialVector) &&
 	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->extDevNotifyMask&reason) &&
+	    (interest->extDevNotifyMask&reason)) {
-            XIShouldNotify(interest->client, dev)) {
 	    if (!initialized) {
 		pEv->type = XkbEventCode + XkbEventBase;
 		pEv->xkbType = XkbExtensionDeviceNotify;