Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 309 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/hw/dmx/input/dmxeq.c b/nx-X11/programs/Xserver/hw/dmx/input/dmxeq.c
new file mode 100644
index 000000000..7a6bb11fc
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/dmx/input/dmxeq.c
@@ -0,0 +1,309 @@
+/* $XFree86$ */
+/*
+ * $Xorg: mieq.c,v 1.4 2001/02/09 02:05:20 xorgcvs Exp $
+ *
+ * Copyright 1990, 1998  The Open Group
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation.
+ *
+ * The above copyright notice and this permission notice 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
+ * OPEN GROUP 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.
+ *
+ * Except as contained in this notice, the name of The Open Group shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from The Open Group.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+/*
+ * dmxeq.c is derived from mi/mieq.c so that XInput events can be handled
+ *
+ * Modified by: Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ * Copyright 2002-2003 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * 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 on 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
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * 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.
+ */
+
+/** \file
+ * This file provides an event queue that knows about XInput events.
+ * All of the code is based on mi/mieq.c and was modified as little as
+ * possible to provide XInput event support (the copyright and some of
+ * the comments are from The Open Group, Keith Packard, MIT X
+ * Consortium).  (Another example of similar code is provided in
+ * hw/xfree86/common/xf86Xinput.c.) */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#define DMX_EQ_DEBUG 0
+
+#include "dmx.h"
+#include "dmxeq.h"
+#include "dmxinput.h"
+#include "dmxlog.h"
+#include "dmxdpms.h"
+
+#include "inputstr.h"
+#include "scrnintstr.h"         /* For screenInfo */
+
+#ifdef XINPUT
+#include <X11/extensions/XIproto.h>
+#define EXTENSION_PROC_ARGS void *
+#include "extinit.h"            /* For LookupDeviceIntRec */
+#endif
+
+#if DMX_EQ_DEBUG
+#define DMXDBG2(f,a,b)           dmxLog(dmxDebug,f,a,b)
+#define DMXDBG5(f,a,b,c,d,e)     dmxLog(dmxDebug,f,a,b,c,d,e)
+#else
+#define DMXDBG2(f,a,b)
+#define DMXDBG5(f,a,b,c,d,e)
+#endif
+
+/** The size of our queue.  (The queue provided by mi/mieq.c has a size
+ * of 256.) */
+#define QUEUE_SIZE  256
+
+/** Information about the event. */
+typedef struct _Event {
+    xEvent	   event;    /**< Event. */
+    ScreenPtr	   pScreen;  /**< Screen on which event occurred. */
+#ifdef XINPUT
+    deviceValuator valuator; /**< XInput device valuator information. */
+#endif
+} EventRec, *EventPtr;
+
+/** Event queue. */
+typedef struct _EventQueue {
+    HWEventQueueType head; /**< Queue head; must be long for SetInputCheck. */ 
+    HWEventQueueType tail; /**< Queue tail; must be long for SetInputCheck. */ 
+    CARD32           lastEventTime; /**< To avoid time running backwards. */
+    Bool	     lastMotion;    /**< True if last event was motion.  */
+    EventRec         events[QUEUE_SIZE]; /**< Static allocation for signals. */
+    DevicePtr	     pKbd, pPtr;    /**< Device pointers (to get funcs) */
+    ScreenPtr	     pEnqueueScreen;/**< Screen events are delivered to. */
+    ScreenPtr	     pDequeueScreen;/**< Screen events are dispatched to. */
+} EventQueueRec, *EventQueuePtr;
+
+static EventQueueRec dmxEventQueue;
+static Bool          dmxeqInitializedFlag = FALSE;
+
+Bool dmxeqInitialized(void)
+{
+    return dmxeqInitializedFlag;
+}
+
+Bool dmxeqInit(DevicePtr pKbd, DevicePtr pPtr)
+{
+    static unsigned long dmxGeneration = 0;
+    
+    if (dmxGeneration == serverGeneration && dmxeqInitializedFlag)
+        return FALSE;
+    dmxGeneration                = serverGeneration;
+    dmxeqInitializedFlag         = TRUE;
+    dmxEventQueue.head           = 0;
+    dmxEventQueue.tail           = 0;
+    dmxEventQueue.lastEventTime  = GetTimeInMillis();
+    dmxEventQueue.pKbd           = pKbd;
+    dmxEventQueue.pPtr           = pPtr;
+    dmxEventQueue.lastMotion     = FALSE;
+    dmxEventQueue.pEnqueueScreen = screenInfo.screens[0];
+    dmxEventQueue.pDequeueScreen = dmxEventQueue.pEnqueueScreen;
+    SetInputCheck(&dmxEventQueue.head, &dmxEventQueue.tail);
+    return TRUE;
+}
+
+/**
+ * This function adds an event to the end of the queue.  If the event is
+ * an XInput event, then the next event (the valuator event) is also
+ * stored in the queue.  If the new event has a time before the time of
+ * the last event currently on the queue, then the time is updated for
+ * the new event.
+ *
+ * Must be reentrant with ProcessInputEvents.  Assumption: dmxeqEnqueue
+ * will never be interrupted.  If this is called from both signal
+ * handlers and regular code, make sure the signal is suspended when
+ * called from regular code.
+ */
+
+void dmxeqEnqueue(xEvent *e)
+{
+    HWEventQueueType oldtail, newtail;
+    Bool             isMotion;
+
+    oldtail                               = dmxEventQueue.tail;
+    isMotion                              = e->u.u.type == MotionNotify;
+    if (isMotion
+        && dmxEventQueue.lastMotion
+        && oldtail != dmxEventQueue.head) {
+	if (oldtail == 0) oldtail = QUEUE_SIZE;
+	oldtail = oldtail - 1;
+    } else {
+    	newtail = oldtail + 1;
+    	if (newtail == QUEUE_SIZE) newtail = 0;
+    	/* Toss events which come in late */
+    	if (newtail == dmxEventQueue.head) return;
+	dmxEventQueue.tail = newtail;
+    }
+    DMXDBG2("dmxeqEnqueue %d %d\n", dmxEventQueue.head, dmxEventQueue.tail);
+    dmxEventQueue.lastMotion              = isMotion;
+    dmxEventQueue.events[oldtail].pScreen = dmxEventQueue.pEnqueueScreen;
+
+                                /* Store the event in the queue */
+    dmxEventQueue.events[oldtail].event   = *e;
+#ifdef XINPUT
+    {
+                                /* If this is an XInput event, store the
+                                 * valuator event, too */
+        deviceKeyButtonPointer *ev = (deviceKeyButtonPointer *)e;
+        if (e->u.u.type >= LASTEvent && (ev->deviceid & MORE_EVENTS))
+            dmxEventQueue.events[oldtail].valuator = *(deviceValuator *)(ev+1);
+    }
+#endif
+
+                                /* Make sure that event times don't go
+                                 * backwards - this is "unnecessary",
+                                 * but very useful */
+    if (e->u.keyButtonPointer.time < dmxEventQueue.lastEventTime
+        && dmxEventQueue.lastEventTime - e->u.keyButtonPointer.time < 10000) {
+	dmxEventQueue.events[oldtail].event.u.keyButtonPointer.time =
+	    dmxEventQueue.lastEventTime;
+    }
+}
+
+/** Make \a pScreen the new screen for enqueueing events.  If \a fromDIX
+ * is TRUE, also make \a pScreen the new screen for dequeuing events. */
+void dmxeqSwitchScreen(ScreenPtr pScreen, Bool fromDIX)
+{
+    dmxEventQueue.pEnqueueScreen = pScreen;
+    if (fromDIX) dmxEventQueue.pDequeueScreen = pScreen;
+}
+
+#ifdef XINPUT
+static void dmxeqProcessXInputEvent(xEvent *xe, EventRec *e)
+{
+    deviceKeyButtonPointer *ev     = (deviceKeyButtonPointer *)xe;
+    int                    id      = ev->deviceid & DEVICE_BITS;
+    DeviceIntPtr           pDevice = LookupDeviceIntRec(id);
+    
+    if (!pDevice) {
+        dmxLog(dmxError, "dmxeqProcessInputEvents: id %d not found\n", id);
+        return;
+    }
+
+    if (!pDevice->public.processInputProc) {
+        dmxLog(dmxError,
+               "dmxeqProcessInputEvents: no processInputProc for"
+               " device id %d (%s)\n", id, pDevice->name);
+        return;
+    }
+    
+    if (ev->deviceid & MORE_EVENTS) {
+        xe[1] = *(xEvent *)(&e->valuator);
+        pDevice->public.processInputProc(xe, pDevice, 2);
+    } else {
+        pDevice->public.processInputProc(xe, pDevice, 1);
+    }
+}
+#endif
+
+/**
+ * This function is called from #ProcessInputEvents() to remove events
+ * from the queue and process them.
+ */
+void dmxeqProcessInputEvents(void)
+{
+    EventRec	*e;
+    int		x, y;
+    xEvent	xe[2];
+
+    while (dmxEventQueue.head != dmxEventQueue.tail) {
+        dmxDPMSWakeup();        /* Handles screen saver and DPMS */
+	e = &dmxEventQueue.events[dmxEventQueue.head];
+        DMXDBG5("dmxeqProcessInputEvents: type=%d screen=%p,%p root=%d,%d\n",
+                e->event.u.u.type,
+                e->pScreen, dmxEventQueue.pDequeueScreen,
+                e->event.u.keyButtonPointer.rootX,
+                e->event.u.keyButtonPointer.rootY);
+	/*
+	 * Assumption - screen switching can only occur on core motion events
+	 */
+	if (e->event.u.u.type == MotionNotify
+            && e->pScreen != dmxEventQueue.pDequeueScreen) {
+	    dmxEventQueue.pDequeueScreen = e->pScreen;
+	    x = e->event.u.keyButtonPointer.rootX;
+	    y = e->event.u.keyButtonPointer.rootY;
+	    if (dmxEventQueue.head == QUEUE_SIZE - 1) dmxEventQueue.head = 0;
+	    else                                      ++dmxEventQueue.head;
+	    NewCurrentScreen(dmxEventQueue.pDequeueScreen, x, y);
+	} else {
+	    xe[0] = e->event;
+	    if (dmxEventQueue.head == QUEUE_SIZE - 1) dmxEventQueue.head = 0;
+	    else                                      ++dmxEventQueue.head;
+	    switch (xe[0].u.u.type) {
+	    case KeyPress:
+	    case KeyRelease:
+                if (!dmxEventQueue.pKbd) {
+                    dmxLog(dmxError, "dmxeqProcessInputEvents: No keyboard\n");
+                    return;
+                }
+                dmxEventQueue.pKbd
+                    ->processInputProc(xe,
+                                       (DeviceIntPtr)dmxEventQueue.pKbd, 1);
+	    	break;
+            default:
+#ifdef XINPUT
+                dmxeqProcessXInputEvent(xe, e);
+                break;
+#endif
+                /* ifndef XINPUT, fall through */
+            case ButtonPress:
+            case ButtonRelease:
+            case MotionNotify:
+                if (!dmxEventQueue.pPtr) {
+                    dmxLog(dmxError, "dmxeqProcessInputEvents: No mouse\n");
+                    return;
+                }
+                dmxEventQueue.pPtr
+                    ->processInputProc(xe,
+                                       (DeviceIntPtr)dmxEventQueue.pPtr, 1);
+	    	break;
+	    }
+	}
+    }
+}