1 files changed, 30 insertions, 30 deletions

diff --git a/mi/mieq.c b/mi/mieq.c
index a05c9eb1b..cb940e403 100644
--- a/mi/mieq.c
+++ b/mi/mieq.c
@@ -77,12 +77,13 @@ typedef struct _EventQueue {
     int              lastMotion;         /* device ID if last event motion? */
     EventRec         events[QUEUE_SIZE]; /* static allocation for signals */
     mieqHandler      handlers[128];      /* custom event handler */
 } EventQueueRec, *EventQueuePtr;
 
 static EventQueueRec miEventQueue;
+static EventListPtr masterEvents; /* for use in mieqProcessInputEvents */
 
 Bool
 mieqInit(void)
 {
     int i;
 
@@ -95,12 +96,23 @@ mieqInit(void)
     {
         EventListPtr evlist = InitEventList(1 + MAX_VALUATOR_EVENTS);
         if (!evlist)
             FatalError("Could not allocate event queue.\n");
         miEventQueue.events[i].events = evlist;
     }
+
+    /* XXX: mE is just 1 event long, if we have Motion + Valuator they are
+     * squashed into the first event to make passing it into the event
+     * processing handlers easier. This should be fixed when the processing
+     * handlers switch to EventListPtr instead of xEvent */
+    masterEvents = InitEventList(1);
+    if (!masterEvents)
+        FatalError("Could not allocated MD event queue.\n");
+    SetMinimumEventSize(masterEvents, 1,
+                        (1 + MAX_VALUATOR_EVENTS) * sizeof(xEvent));
+
     SetInputCheck(&miEventQueue.head, &miEventQueue.tail);
     return TRUE;
 }
 
 /* Ensure all events in the EQ are at least size bytes. */
 void
@@ -272,47 +284,39 @@ ChangeDeviceID(DeviceIntPtr dev, xEvent* event)
  * @param original The event as it came from the EQ
  * @param master The event after being copied
  * @param count Number of events in original.
  */
 void
 CopyGetMasterEvent(DeviceIntPtr mdev, xEvent* original,
-                   xEvent** master, int count)
+                   EventListPtr master, int count)
 {
-    if (count > 1) {
-        *master = xcalloc(count, sizeof(xEvent));
-        if (!*master)
-            FatalError("[mi] No memory left for master event.\n");
-        while(count--)
-        {
-            memcpy(&(*master)[count], &original[count], sizeof(xEvent));
-            ChangeDeviceID(mdev, &(*master)[count]);
-        }
-    } else
-    {
-        int len = sizeof(xEvent);
-        if (original->u.u.type == GenericEvent)
-            len += GEV(original)->length * 4;
-        *master = xalloc(len);
-        if (!*master)
-            FatalError("[mi] No memory left for master event.\n");
-        memcpy(*master, original, len);
-        ChangeDeviceID(mdev, *master);
-    }
+    int len = count * sizeof(xEvent);
+
+    /* Assumption: GenericEvents always have count 1 */
+
+    if (GEV(original)->type == GenericEvent)
+        len += GEV(original)->length * 4;
+
+    if (master->evlen < len)
+        SetMinimumEventSize(master, 1, len);
+
+    memcpy(master->event, original, len);
+    while (count--)
+        ChangeDeviceID(mdev, &master->event[count]);
 }
 
 /* Call this from ProcessInputEvents(). */
 void
 mieqProcessInputEvents(void)
 {
     mieqHandler handler;
     EventRec *e = NULL;
     int x = 0, y = 0;
     int type, nevents, evlen, i;
     ScreenPtr screen;
-    xEvent *event,
-           *master_event = NULL;
+    xEvent *event;
     DeviceIntPtr dev = NULL,
                  master = NULL;
 
     while (miEventQueue.head != miEventQueue.tail) {
         e = &miEventQueue.events[miEventQueue.head];
 
@@ -355,37 +359,33 @@ mieqProcessInputEvents(void)
             x = event->u.keyButtonPointer.rootX;
             y = event->u.keyButtonPointer.rootY;
             NewCurrentScreen (dev, DequeueScreen(dev), x, y);
         }
         else {
             if (master)
-                CopyGetMasterEvent(master, event,
-                                   &master_event, nevents);
-            else
-                master_event = NULL;
+                CopyGetMasterEvent(master, event, masterEvents, nevents);
 
             /* If someone's registered a custom event handler, let them
              * steal it. */
             if (handler)
             {
                 handler(DequeueScreen(dev)->myNum, event, dev, nevents);
                 if (master)
                     handler(DequeueScreen(master)->myNum,
-                            master_event, master, nevents);
+                            masterEvents->event, master, nevents);
             } else
             {
                 /* process slave first, then master */
                 dev->public.processInputProc(event, dev, nevents);
 
                 if (master)
-                    master->public.processInputProc(master_event, master,
+                    master->public.processInputProc(masterEvents->event, master,
                                                     nevents);
             }
 
             xfree(event);
-            xfree(master_event);
         }
 
         /* Update the sprite now. Next event may be from different device. */
         if (type == DeviceMotionNotify && (master || dev->isMaster))
             miPointerUpdateSprite(dev);
     }