evdev 2.1 RC 1.

(cherry picked from commit 0089d931ac)

.gitignore

@@ -24,3 +24,4 @@ missing
 stamp-h1
 *.bz2
 *.gz
+*.pc

COPYING

@@ -1,12 +1,95 @@
-This is a stub file.  This package has not yet had its complete licensing
-information compiled.  Please see the individual source files for details on
-your rights to use and modify this software.
+Various copyright notices found in this driver:
 
-Please submit updated COPYING files to the Xorg bugzilla:
+Copyright © 2004-2008 Red Hat, Inc.
 
-https://bugs.freedesktop.org/enter_bug.cgi?product=xorg
+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, and that the name of Red Hat
+not be used in advertising or publicity pertaining to distribution
+of the software without specific, written prior permission.  Red
+Hat makes no representations about the suitability of this software
+for any purpose.  It is provided "as is" without express or implied
+warranty.
 
-All licensing questions regarding this software should be directed at the
-Xorg mailing list:
+THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
+
+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 copyright holders 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 copyright holders.
+
+Copyright © 2008 University of South Australia
+copyrights taken from xf86-input-mouse, partly valid for this driver.
+Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
+Copyright 1993 by David Dawes <dawes@xfree86.org>
+Copyright 2002 by SuSE Linux AG, Author: Egbert Eich
+Copyright 1994-2002 by The XFree86 Project, Inc.
+Copyright 2002 by Paul Elliott
+
+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, and that the name of the authors
+not be used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  The authors make no
+representations about the suitability of this software for any
+purpose.  It is provided "as is" without express or implied
+warranty.
+
+THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+Copyright 2005 Adam Jackson.
+
+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, sub
+license, 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
+ADAM JACKSON 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.
 
-http://lists.freedesktop.org/mailman/listinfo/xorg

Makefile.am

@@ -19,7 +19,10 @@
 #  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 AUTOMAKE_OPTIONS = foreign
-SUBDIRS = src man
+SUBDIRS = src man include
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = xorg-evdev.pc
 
 EXTRA_DIST = ChangeLog autogen.sh
 

configure.ac

@@ -22,7 +22,7 @@
 
 AC_PREREQ(2.57)
 AC_INIT([xf86-input-evdev],
-        2.0.5,
+        2.0.99.1,
         [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],
         xf86-input-evdev)
 
@@ -44,24 +44,6 @@ AC_PROG_CC
 
 AH_TOP([#include "xorg-server.h"])
 
-#AC_DEFINE(XFree86LOADER,1,[Stub define for loadable drivers])
-#
-#AC_ARG_ENABLE(XINPUT, AS_HELP_STRING([--enable-xinput],
-#              [Build XInput support (default: yes)]),
-#              [XINPUT=$enableval],[XINPUT=yes])
-#AM_CONDITIONAL(XINPUT, test "x$XINPUT" = "xyes")
-#if test "x$XINPUT" = "xyes" ; then
-#    AC_DEFINE(XINPUT,1,[Enable XInput support])
-#fi
-#
-#AC_ARG_ENABLE(XKB, AS_HELP_STRING([--enable-xkb],
-#              [Build XKB support (default: yes)]),
-#              [XKB=$enableval],[XKB=yes])
-#AM_CONDITIONAL(XKB, test "x$XKB" = "xyes")
-#if test "x$XKB" = "xyes" ; then
-#    AC_DEFINE(XKB,1,[Enable XKB support])
-#fi
-
 AC_ARG_WITH(xorg-module-dir,
             AC_HELP_STRING([--with-xorg-module-dir=DIR],
                            [Default xorg module directory [[default=$libdir/xorg/modules]]]),
@@ -71,12 +53,12 @@ inputdir=${moduledir}/input
 AC_SUBST(inputdir)
 
 # Checks for extensions
-XORG_DRIVER_CHECK_EXT(RANDR, randrproto)
 XORG_DRIVER_CHECK_EXT(XINPUT, inputproto)
 
 # Checks for pkg-config packages
 PKG_CHECK_MODULES(XORG, xorg-server xproto $REQUIRED_MODULES)
 sdkdir=$(pkg-config --variable=sdkdir xorg-server)
+AC_SUBST(sdkdir)
 
 CFLAGS="$CFLAGS $XORG_CFLAGS "' -I$(top_srcdir)/src'
 AC_SUBST([CFLAGS])
@@ -89,4 +71,8 @@ AC_HEADER_STDC
 XORG_MANPAGE_SECTIONS
 XORG_RELEASE_VERSION
 
-AC_OUTPUT([Makefile src/Makefile man/Makefile])
+AC_OUTPUT([Makefile
+           src/Makefile
+           man/Makefile
+           include/Makefile
+           xorg-evdev.pc])

include/Makefile.am

@@ -0,0 +1,2 @@
+EXTRA_DIST = evdev-properties.h
+sdk_HEADERS = evdev-properties.h

include/evdev-properties.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * 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, and that the name of Red Hat
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.  Red
+ * Hat makes no representations about the suitability of this software
+ * for any purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors:
+ *	Peter Hutterer (peter.hutterer@redhat.com)
+ */
+
+
+#ifndef _EVDEV_PROPERTIES_H_
+#define _EVDEV_PROPERTIES_H_
+
+/* Middle mouse button emulation */
+/* BOOL */
+#define EVDEV_PROP_MIDBUTTON "Evdev Middle Button Emulation"
+/* CARD16 */
+#define EVDEV_PROP_MIDBUTTON_TIMEOUT "Evdev Middle Button Timeout"
+
+/* Wheel emulation */
+/* BOOL */
+#define EVDEV_PROP_WHEEL "Evdev Wheel Emulation"
+/* CARD8, 4 values [x up, x down, y up, y down], 0 to disable a value*/
+#define EVDEV_PROP_WHEEL_AXES "Evdev Wheel Emulation Axes"
+/* CARD16 */
+#define EVDEV_PROP_WHEEL_INERTIA "Evdev Wheel Emulation Inertia"
+/* CARD16 */
+#define EVDEV_PROP_WHEEL_TIMEOUT "Evdev Wheel Emulation Timeout"
+/* CARD8, value range 0-32, 0 to disable a value */
+#define EVDEV_PROP_WHEEL_BUTTON "Evdev Wheel Emulation Button"
+
+/* Drag lock */
+/* CARD8, either 1 value or pairs, value range 0-32, 0 to disable a value*/
+#define EVDEV_PROP_DRAGLOCK "Evdev Drag Lock Buttons"
+
+/* Axis inversion */
+/* BOOL, 2 values [x, y], 1 inverts axis */
+#define EVDEV_PROP_INVERT_AXES "Evdev Axis Inversion"
+
+/* Reopen attempts. */
+/* CARD8 */
+#define EVDEV_PROP_REOPEN "Evdev Reopen Attempts"
+
+#endif

man/Makefile.am

@@ -1,5 +1,3 @@
-# $Id$
-#
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # 
 # Permission to use, copy, modify, distribute, and sell this software and its

man/evdev.man

@@ -9,7 +9,6 @@ evdev \- Generic Linux input driver
 .BI "  Identifier \*q" devname \*q
 .B  "  Driver \*qevdev\*q"
 .BI "  Option \*qDevice\*q   \*q" devpath \*q
-.BI "  Option \*qPath\*q     \*q" path \*q
 .BI "  Option \*qEmulate3Buttons\*q     \*q" True \*q
 .BI "  Option \*qEmulate3Timeout\*q     \*q" 50 \*q
 \ \ ...
@@ -47,30 +46,138 @@ are supported:
 .BI "Option \*qDevice\*q \*q" string \*q
 Specifies the device through which the device can be accessed.  This will 
 generally be of the form \*q/dev/input/eventX\*q, where X is some integer.
-The mapping from device node to hardware is system-dependent.  This option is
-mandatory unless \*qPath\*q is given, and there is no default setting.
-.TP 7
-.BI "Option \*qPath\*q \*q" string \*q
-Specifies the device through which the device can be accessed.  This will
-generally be of the form \*q/dev/input/by-path/xyz\*q, where xyz includes the
-name of the device. The mapping from device node to hardware is
-system-dependent. This option has precedence over the \*qDevice\*q option but
-one of \*qPath\*q or \*qDevice\*q must be given.
+The mapping from device node to hardware is system-dependent.
 .TP 7
 .BI "Option \*qEmulate3Buttons\*q \*q" boolean \*q
 Enable/disable the emulation of the third (middle) mouse button for mice
 which only have two physical buttons.  The third button is emulated by
 pressing both buttons simultaneously.  Default: on, until a middle mouse
-button event is registered.
+button event is registered. Property: "Evdev Middle Button Emulation".
 .TP 7
 .BI "Option \*qEmulate3Timeout\*q \*q" integer \*q
 Sets the timeout (in milliseconds) that the driver waits before deciding
 if two buttons where pressed "simultaneously" when 3 button emulation is
-enabled.  Default: 50.
+enabled.  Default: 50. Property: "Evdev Middle Button Timeout".
+.TP 7
+.BI "Option \*qButtonMapping\*q \*q" string \*q
+Sets the button mapping for this device. The mapping is a space-separated list
+of button mappings that correspond in order to the physical buttons on the
+device (i.e. the first number is the mapping for button 1, etc.). The default
+mapping is "1 2 3 ... 32". A mapping of 0 deactivates the button. Multiple
+buttons can have the same mapping.
+For example, a left-handed mouse with deactivated scroll-wheel would use a
+mapping of "3 2 1 0 0". Invalid mappings are ignored and the default mapping
+is used. Buttons not specified in the user's mapping use the default mapping.
+.TP 7
+.BI "Option \*qDragLockButtons\*q \*q" "L1 B2 L3 B4" \*q
+Sets \*qdrag lock buttons\*q that simulate holding a button down, so
+that low dexterity people do not have to hold a button down at the
+same time they move a mouse cursor. Button numbers occur in pairs,
+with the lock button number occurring first, followed by the button
+number that is the target of the lock button. Property: "Evdev
+Drag Lock Buttons".
+.TP 7
+.BI "Option \*qDragLockButtons\*q \*q" "M1" \*q
+Sets a \*qmaster drag lock button\*q that acts as a \*qMeta Key\*q
+indicating that the next button pressed is to be
+\*qdrag locked\*q. Property: "Evdev Drag Lock Buttons".
+.TP 7
+.BI "Option \*qEmulateWheel\*q \*q" boolean \*q
+Enable/disable "wheel" emulation.  Wheel emulation means emulating button
+press/release events when the mouse is moved while a specific real button
+is pressed.  Wheel button events (typically buttons 4 and 5) are
+usually used for scrolling.  Wheel emulation is useful for getting wheel-like
+behaviour with trackballs.  It can also be useful for mice with 4 or
+more buttons but no wheel.  See the description of the
+.BR EmulateWheelButton ,
+.BR EmulateWheelInertia ,
+.BR EmulateWheelTimeout ,
+.BR XAxisMapping ,
+and
+.B YAxisMapping
+options below.  Default: off. Property "Evdev Wheel Emulation".
+.TP 7
+.BI "Option \*qEmulateWheelButton\*q \*q" integer \*q
+Specifies which button must be held down to enable wheel emulation mode.
+While this button is down, X and/or Y pointer movement will generate button
+press/release events as specified for the
+.B XAxisMapping
+and
+.B YAxisMapping
+settings.  Default: 4. Property: "Evdev Wheel Emulation Button".
+.TP 7
+.BI "Option \*qEmulateWheelInertia\*q \*q" integer \*q
+Specifies how far (in pixels) the pointer must move to generate button
+press/release events in wheel emulation mode.  Default: 10. Property: "Evdev
+Wheel Emulation Inertia".
+.TP 7
+.BI "Option \*qEmulateWheelTimeout\*q \*q" integer \*q
+Specifies the time in milliseconds the
+.BR EmulateWheelButton
+must be pressed before wheel emulation is started. If the
+.BR EmulateWheelButton
+is released before this timeout, the original button press/release event
+is sent.  Default: 200. Property: "Evdev Wheel Emulation Timeout".
+.TP 7
+.BI "Option \*qXAxisMapping\*q \*q" "N1 N2" \*q
+Specifies which buttons are mapped to motion in the X direction in wheel
+emulation mode.  Button number
+.I N1
+is mapped to the negative X axis motion and button number
+.I N2
+is mapped to the positive X axis motion.  Default: no mapping. Property:
+"Evdev Wheel Emulation Axes".
+.TP 7
+.BI "Option \*qYAxisMapping\*q \*q" "N1 N2" \*q
+Specifies which buttons are mapped to motion in the Y direction in wheel
+emulation mode.  Button number
+.I N1
+is mapped to the negative Y axis motion and button number
+.I N2
+is mapped to the positive Y axis motion.  Default: "4 5". Property:
+"Evdev Wheel Emulation Axes".
 .TP 7
 .BI "Option \*qReopenAttempts\*q \*q" integer \*q
 Number of reopen attempts after a read error occurs on the device (e.g. after
 waking up from suspend). In between each attempt is a 100ms wait. Default: 10.
+.TP 7
+.BI "Option \*qInvertX\*q \*q" Bool \*q
+.TP 7
+.BI "Option \*qInvertY\*q \*q" Bool \*q
+Invert the given axis. Default: off. Property: "Evdev Axis Inversion".
+
+.SH SUPPORTED PROPERTIES
+The following properties are provided by the
+.B evdev
+driver.
+.TP 7
+.BI "Evdev Middle Button Emulation"
+1 boolean value (8 bit, 0 or 1).
+.TP 7
+.BI "Evdev Middle Button Timeout"
+1 16-bit positive value.
+.TP 7
+.BI "Evdev Wheel Emulation"
+1 boolean value (8 bit, 0 or 1).
+.TP 7
+.BI "Evdev Wheel Emulation Axes"
+4 8-bit values, order X up, X down, Y up, Y down. 0 disables a value.
+.TP 7
+.BI "Evdev Wheel Emulation Inertia"
+1 16-bit positive value.
+.TP 7
+.BI "Evdev Wheel Emulation Timeout"
+1 16-bit positive value.
+.TP 7
+.BI "Evdev Wheel Emulation Button"
+1 8-bit value, allowed range 0-32, 0 disables the button.
+.TP 7
+.BI "Evdev Drag Lock Buttons"
+8-bit. Either 1 value or pairs of values. Value range 0-32, 0 disables a
+value.
+.TP 7
+.BI "Evdev Axis Inversion"
+2 boolean values (8 bit, 0 or 1), order X, Y. 1 inverts the axis.
 
 .SH AUTHORS
 Kristian Høgsberg.

src/Makefile.am

@@ -28,6 +28,11 @@
 @DRIVER_NAME@_drv_la_LDFLAGS = -module -avoid-version
 @DRIVER_NAME@_drv_ladir = @inputdir@
 
+INCLUDES=-I$(top_srcdir)/include/
+
 @DRIVER_NAME@_drv_la_SOURCES = @DRIVER_NAME@.c \
                                @DRIVER_NAME@.h \
-                               emuMB.c
+                               emuMB.c \
+                               emuWheel.c \
+                               draglock.c
+

src/draglock.c

@@ -0,0 +1,318 @@
+/*
+ * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
+ * Copyright 1993 by David Dawes <dawes@xfree86.org>
+ * Copyright 2002 by SuSE Linux AG, Author: Egbert Eich
+ * Copyright 1994-2002 by The XFree86 Project, Inc.
+ * Copyright 2002 by Paul Elliott
+ * (Ported from xf86-input-mouse, above copyrights taken from there)
+ * Copyright © 2008 University of South Australia
+ * Copyright 2008 by Chris Salch
+ * Copyright 2008 Red Hat, Inc.
+ *
+ * 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, and that the name of the authors
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  The authors make no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+/* Draglock code */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <xf86.h>
+#include <xf86Xinput.h>
+#include <X11/Xatom.h>
+#include <exevents.h>
+
+#include <evdev-properties.h>
+#include "evdev.h"
+
+#ifdef HAVE_PROPERTIES
+static Atom prop_dlock     = 0; /* Drag lock buttons. */
+#endif
+
+void EvdevDragLockLockButton(InputInfoPtr pInfo, unsigned int button);
+
+
+/* Setup and configuration code */
+void
+EvdevDragLockPreInit(InputInfoPtr pInfo)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+    char *option_string = NULL;
+    int meta_button = 0;
+    int lock_button = 0;
+    char *next_num = NULL;
+    char *end_str = NULL;
+    BOOL pairs = FALSE;
+
+    option_string = xf86CheckStrOption(pInfo->options, "DragLockButtons",NULL);
+
+    if (!option_string)
+        return;
+
+    next_num = option_string;
+
+    /* Loop until we hit the end of our option string */
+    while (next_num != NULL) {
+        lock_button = 0;
+        meta_button = strtol(next_num, &end_str, 10);
+
+        /* check to see if we found anything */
+        if (next_num != end_str) {
+            /* setup for the next number */
+            next_num = end_str;
+        } else {
+            /* we have nothing more to parse, drop out of the loop */
+            next_num = NULL;
+        }
+
+        /* Check for a button to lock if we have a meta button */
+        if (meta_button != 0 && next_num != NULL ) {
+            lock_button = strtol(next_num, &end_str, 10);
+
+            /* check to see if we found anything */
+            if (next_num != end_str) {
+                /* setup for the next number */
+                next_num = end_str;
+            } else {
+                /* we have nothing more to parse, drop out of the loop */
+                next_num = NULL;
+            }
+        }
+
+        /* Ok, let the user know what we found on this look */
+        if (meta_button != 0) {
+            if (lock_button == 0) {
+                if (!pairs) {
+                    /* We only have a meta button */
+                    pEvdev->dragLock.meta = meta_button;
+
+                    xf86Msg(X_CONFIG, "%s: DragLockButtons : "
+                            "%i as meta\n",
+                            pInfo->name, meta_button);
+                } else {
+                    xf86Msg(X_ERROR, "%s: DragLockButtons : "
+                            "Incomplete pair specifying button pairs %s\n",
+                            pInfo->name, option_string);
+                }
+            } else {
+
+                /* Do bounds checking to make sure we don't crash */
+                if ((meta_button <= EVDEV_MAXBUTTONS) && (meta_button >= 0 ) &&
+                    (lock_button <= EVDEV_MAXBUTTONS) && (lock_button >= 0)) {
+
+                    xf86Msg(X_CONFIG, "%s: DragLockButtons : %i -> %i\n",
+                            pInfo->name, meta_button, lock_button);
+
+                    pEvdev->dragLock.lock_pair[meta_button - 1] = lock_button;
+                    pairs=TRUE;
+                } else {
+                    /* Let the user know something was wrong
+                       with this pair of buttons */
+                    xf86Msg(X_CONFIG, "%s: DragLockButtons : "
+                            "Invalid button pair %i -> %i\n",
+                            pInfo->name, meta_button, lock_button);
+                }
+            }
+        } else {
+            xf86Msg(X_ERROR, "%s: Found DragLockButtons "
+                    "with  invalid lock button string : '%s'\n",
+                    pInfo->name, option_string);
+
+            /* This should be the case anyhow, just make sure */
+            next_num = NULL;
+        }
+
+        /* Check for end of string, to avoid annoying error */
+        if (next_num != NULL && *next_num == '\0')
+            next_num = NULL;
+    }
+}
+
+/* Updates DragLock button state and firest button event messges */
+void
+EvdevDragLockLockButton(InputInfoPtr pInfo, unsigned int button)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+    BOOL state=0;
+
+    /* update button state */
+    state = pEvdev->dragLock.lock_state[button - 1] ? FALSE : TRUE;
+    pEvdev->dragLock.lock_state[button - 1] = state;
+
+    xf86PostButtonEvent(pInfo->dev, 0, button, state, 0, 0);
+}
+
+/* Filter button presses looking for either a meta button or the
+ * control of a button pair.
+ *
+ * @param button button number (1 for left, 3 for right)
+ * @param value TRUE if button press, FALSE if release
+ *
+ * @return TRUE if the event was swallowed here, FALSE otherwise.
+ */
+BOOL
+EvdevDragLockFilterEvent(InputInfoPtr pInfo, unsigned int button, int value)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+
+    if (button == 0)
+        return FALSE;
+
+    /* Do we have a single meta key or
+       several button pairings? */
+    if (pEvdev->dragLock.meta != 0) {
+
+        if (pEvdev->dragLock.meta == button) {
+
+            /* setup up for button lock */
+            if (value)
+                pEvdev->dragLock.meta_state = TRUE;
+
+            return TRUE;
+        } else if (pEvdev->dragLock.meta_state) { /* waiting to lock */
+
+            pEvdev->dragLock.meta_state = FALSE;
+
+            EvdevDragLockLockButton(pInfo, button);
+
+            return TRUE;
+        }
+    } else if (pEvdev->dragLock.lock_pair[button - 1] && value) {
+        /* A meta button in a meta/lock pair was pressed */
+        EvdevDragLockLockButton(pInfo, pEvdev->dragLock.lock_pair[button - 1]);
+        return TRUE;
+    }
+
+    /* Eat events for buttons that are locked */
+    if (pEvdev->dragLock.lock_state[button - 1])
+        return TRUE;
+
+    return FALSE;
+}
+
+#ifdef HAVE_PROPERTIES
+/**
+ * Set the drag lock property.
+ * If only one value is supplied, then this is used as the meta button.
+ * If more than one value is supplied, then each value is the drag lock button
+ * for the pair. 0 disables a pair.
+ * i.e. to set bt 3 to draglock button 1, supply 0,0,1
+ */
+int
+EvdevDragLockSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
+                         BOOL checkonly)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+
+    if (atom == prop_dlock)
+    {
+        int i;
+
+        if (val->format != 8 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        /* Don't allow changes while a lock is active */
+        if (pEvdev->dragLock.meta)
+        {
+            if (pEvdev->dragLock.meta_state)
+                return BadAccess;
+        } else
+        {
+            for (i = 0; i < EVDEV_MAXBUTTONS; i++)
+                if (pEvdev->dragLock.lock_state[i])
+                    return BadValue;
+        }
+
+        if (val->size == 1)
+        {
+            int meta = *((CARD8*)val->data);
+            if (meta > EVDEV_MAXBUTTONS)
+                return BadValue;
+
+            if (!checkonly)
+            {
+                pEvdev->dragLock.meta = meta;
+                memset(pEvdev->dragLock.lock_pair, 0, sizeof(pEvdev->dragLock.lock_pair));
+            }
+        } else
+        {
+            CARD8* vals = (CARD8*)val->data;
+
+            for (i = 0; i < val->size && i < EVDEV_MAXBUTTONS; i++)
+                if (vals[i] > EVDEV_MAXBUTTONS)
+                    return BadValue;
+
+            if (!checkonly)
+            {
+                pEvdev->dragLock.meta = 0;
+                memset(pEvdev->dragLock.lock_pair, 0, sizeof(pEvdev->dragLock.lock_pair));
+
+                for (i = 0; i < val->size && i < EVDEV_MAXBUTTONS; i++)
+                    pEvdev->dragLock.lock_pair[i] = vals[i];
+            }
+        }
+    }
+
+    return Success;
+}
+
+/**
+ * Initialise property for drag lock buttons setting.
+ */
+void
+EvdevDragLockInitProperty(DeviceIntPtr dev)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+
+    if (!dev->button) /* don't init prop for keyboards */
+        return;
+
+    prop_dlock = MakeAtom(EVDEV_PROP_DRAGLOCK, strlen(EVDEV_PROP_DRAGLOCK), TRUE);
+    if (pEvdev->dragLock.meta)
+    {
+        XIChangeDeviceProperty(dev, prop_dlock, XA_INTEGER, 8,
+                               PropModeReplace, 1, &pEvdev->dragLock.meta,
+                               FALSE);
+    } else {
+        int highest = 0;
+        int i;
+        CARD8 pair[EVDEV_MAXBUTTONS] = {0};
+
+        for (i = 0; i < EVDEV_MAXBUTTONS; i++)
+        {
+            if (pEvdev->dragLock.lock_pair[i])
+                highest = i;
+            pair[i] = pEvdev->dragLock.lock_pair[i];
+        }
+
+        XIChangeDeviceProperty(dev, prop_dlock, XA_INTEGER, 8, PropModeReplace,
+                               highest + 1, pair, FALSE);
+    }
+
+    XISetDevicePropertyDeletable(dev, prop_dlock, FALSE);
+
+    XIRegisterPropertyHandler(dev, EvdevDragLockSetProperty, NULL, NULL);
+}
+
+#endif

src/emuMB.c

@@ -11,11 +11,11 @@
  * 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, and that the name of Red Hat
- * not be used in advertising or publicity pertaining to distribution
- * of the software without specific, written prior permission.  Red
- * Hat makes no representations about the suitability of this software
- * for any purpose.  It is provided "as is" without express or implied
+ * appear in supporting documentation, and that the name of the authors
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  The authors make no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
  * warranty.
  *
  * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
@@ -34,8 +34,12 @@
 #include "config.h"
 #endif
 
+#include <X11/Xatom.h>
 #include <xf86.h>
+#include <xf86Xinput.h>
+#include <exevents.h>
 
+#include <evdev-properties.h>
 #include "evdev.h"
 
 enum {
@@ -44,6 +48,10 @@ enum {
     MBEMU_AUTO
 };
 
+#ifdef HAVE_PROPERTIES
+static Atom prop_mbemu     = 0; /* Middle button emulation on/off property */
+static Atom prop_mbtimeout = 0; /* Middle button timeout property */
+#endif
 /*
  * Lets create a simple finite-state machine for 3 button emulation:
  *
@@ -206,14 +214,14 @@ EvdevMBEmuTimer(InputInfoPtr pInfo)
 /**
  * Emulate a middle button on button press.
  *
- * @param code Evdev event code (BTN_LEFT or BTN_RIGHT)
+ * @param code button number (1 for left, 3 for right)
  * @param press TRUE if press, FALSE if release.
  *
  * @return TRUE if event was swallowed by middle mouse button emulation, FALSE
  * otherwise.
  */
 BOOL
-EvdevMBEmuFilterEvent(InputInfoPtr pInfo, int code, BOOL press)
+EvdevMBEmuFilterEvent(InputInfoPtr pInfo, int button, BOOL press)
 {
     EvdevPtr pEvdev = pInfo->private;
     int id;
@@ -224,14 +232,14 @@ EvdevMBEmuFilterEvent(InputInfoPtr pInfo, int code, BOOL press)
         return ret;
 
     /* don't care about other buttons */
-    if (code != BTN_LEFT && code != BTN_RIGHT)
+    if (button != 1 && button != 3)
         return ret;
 
     btstate = &pEvdev->emulateMB.buttonstate;
     if (press)
-        *btstate |= (code == BTN_LEFT) ? 0x1 : 0x2;
+        *btstate |= (button == 1) ? 0x1 : 0x2;
     else
-        *btstate &= (code == BTN_LEFT) ? ~0x1 : ~0x2;
+        *btstate &= (button == 1) ? ~0x1 : ~0x2;
 
     if ((id = stateTab[pEvdev->emulateMB.state][*btstate][0]) != 0)
     {
@@ -312,7 +320,6 @@ EvdevMBEmuPreInit(InputInfoPtr pInfo)
     RegisterBlockAndWakeupHandlers (EvdevMBEmuBlockHandler,
                                     EvdevMBEmuWakeupHandler,
                                     (pointer)pInfo);
-
 }
 
 void
@@ -332,3 +339,67 @@ EvdevMBEmuEnable(InputInfoPtr pInfo, BOOL enable)
     if (pEvdev->emulateMB.enabled == MBEMU_AUTO)
         pEvdev->emulateMB.enabled = enable;
 }
+
+
+#ifdef HAVE_PROPERTIES
+int
+EvdevMBEmuSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
+                      BOOL checkonly)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+
+    if (atom == prop_mbemu)
+    {
+        if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (!checkonly)
+            pEvdev->emulateMB.enabled = *((BOOL*)val->data);
+    } else if (atom == prop_mbtimeout)
+    {
+        if (val->format != 16 || val->size != 1 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (!checkonly)
+            pEvdev->emulateMB.timeout = *((INT16*)val->data);
+    }
+
+    return Success;
+}
+
+/**
+ * Initialise property for MB emulation on/off.
+ */
+void
+EvdevMBEmuInitProperty(DeviceIntPtr dev)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+    int          rc;
+
+    if (!dev->button) /* don't init prop for keyboards */
+        return;
+
+    prop_mbemu = MakeAtom(EVDEV_PROP_MIDBUTTON, strlen(EVDEV_PROP_MIDBUTTON), TRUE);
+    rc = XIChangeDeviceProperty(dev, prop_mbemu, XA_INTEGER, 8,
+                                PropModeReplace, 1,
+                                &pEvdev->emulateMB.enabled,
+                                FALSE);
+    if (rc != Success)
+        return;
+    XISetDevicePropertyDeletable(dev, prop_mbemu, FALSE);
+
+    prop_mbtimeout = MakeAtom(EVDEV_PROP_MIDBUTTON_TIMEOUT,
+                              strlen(EVDEV_PROP_MIDBUTTON_TIMEOUT),
+                              TRUE);
+    rc = XIChangeDeviceProperty(dev, prop_mbtimeout, XA_INTEGER, 16, PropModeReplace, 1,
+                                &pEvdev->emulateMB.timeout, FALSE);
+
+    if (rc != Success)
+        return;
+    XISetDevicePropertyDeletable(dev, prop_mbtimeout, FALSE);
+
+    XIRegisterPropertyHandler(dev, EvdevMBEmuSetProperty, NULL, NULL);
+}
+#endif

src/emuWheel.c

@@ -0,0 +1,466 @@
+/*
+* Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
+* Copyright 1993 by David Dawes <dawes@xfree86.org>
+* Copyright 2002 by SuSE Linux AG, Author: Egbert Eich
+* Copyright 1994-2002 by The XFree86 Project, Inc.
+* Copyright 2002 by Paul Elliott
+* (Ported from xf86-input-mouse, above copyrights taken from there)
+* Copyright 2008 by Chris Salch
+* Copyright © 2008 Red Hat, Inc.
+*
+* 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, and that the name of the authors
+* not be used in advertising or publicity pertaining to distribution of the
+* software without specific, written prior permission.  The authors make no
+* representations about the suitability of this software for any
+* purpose.  It is provided "as is" without express or implied
+* warranty.
+*
+* THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+* NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*
+*/
+
+/* Mouse wheel emulation code. */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <X11/Xatom.h>
+#include <xf86.h>
+#include <xf86Xinput.h>
+#include <exevents.h>
+
+#include <evdev-properties.h>
+#include "evdev.h"
+
+#define WHEEL_NOT_CONFIGURED 0
+
+#ifdef HAVE_PROPERTIES
+static Atom prop_wheel_emu      = 0;
+static Atom prop_wheel_axismap  = 0;
+static Atom prop_wheel_inertia  = 0;
+static Atom prop_wheel_timeout  = 0;
+static Atom prop_wheel_button   = 0;
+#endif
+
+/* Local Funciton Prototypes */
+static BOOL EvdevWheelEmuHandleButtonMap(InputInfoPtr pInfo, WheelAxisPtr pAxis, char *axis_name);
+static void EvdevWheelEmuInertia(InputInfoPtr pInfo, WheelAxisPtr axis, int value);
+
+/* Filter mouse button events */
+BOOL
+EvdevWheelEmuFilterButton(InputInfoPtr pInfo, unsigned int button, int value)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+    int ms;
+
+    /* Has wheel emulation been configured to be enabled? */
+    if (!pEvdev->emulateWheel.enabled)
+	return FALSE;
+
+    /* Check for EmulateWheelButton */
+    if (pEvdev->emulateWheel.button == button) {
+	pEvdev->emulateWheel.button_state = value;
+
+        if (value)
+            /* Start the timer when the button is pressed */
+            pEvdev->emulateWheel.expires = pEvdev->emulateWheel.timeout +
+                                           GetTimeInMillis();
+        else {
+            ms = pEvdev->emulateWheel.expires - GetTimeInMillis();
+            if (ms > 0) {
+                /*
+                 * If the button is released early enough emit the button
+                 * press/release events
+                 */
+                xf86PostButtonEvent(pInfo->dev, 0, button, 1, 0, 0);
+                xf86PostButtonEvent(pInfo->dev, 0, button, 0, 0, 0);
+            }
+        }
+
+	return TRUE;
+    }
+
+    /* Don't care about this event */
+    return FALSE;
+}
+
+/* Filter mouse wheel events */
+BOOL
+EvdevWheelEmuFilterMotion(InputInfoPtr pInfo, struct input_event *pEv)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+    WheelAxisPtr pAxis = NULL;
+    int value = pEv->value;
+    int ms;
+
+    /* Has wheel emulation been configured to be enabled? */
+    if (!pEvdev->emulateWheel.enabled)
+	return FALSE;
+
+    /* Handle our motion events if the emuWheel button is pressed*/
+    if (pEvdev->emulateWheel.button_state) {
+        /* Just return if the timeout hasn't expired yet */
+        ms = pEvdev->emulateWheel.expires - GetTimeInMillis();
+        if (ms > 0)
+            return TRUE;
+
+	/* We don't want to intercept real mouse wheel events */
+	switch(pEv->code) {
+	case REL_X:
+	    pAxis = &(pEvdev->emulateWheel.X);
+	    break;
+
+	case REL_Y:
+	    pAxis = &(pEvdev->emulateWheel.Y);
+	    break;
+
+	default:
+	    break;
+	}
+
+	/* If we found REL_X or REL_Y, emulate a mouse wheel */
+	if (pAxis)
+	    EvdevWheelEmuInertia(pInfo, pAxis, value);
+
+	/* Eat motion events while emulateWheel button pressed. */
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+/* Simulate inertia for our emulated mouse wheel */
+static void
+EvdevWheelEmuInertia(InputInfoPtr pInfo, WheelAxisPtr axis, int value)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+    int button;
+    int inertia;
+
+    /* if this axis has not been configured, just eat the motion */
+    if (!axis->up_button)
+	return;
+
+    axis->traveled_distance += value;
+
+    if (axis->traveled_distance < 0) {
+	button = axis->up_button;
+	inertia = -pEvdev->emulateWheel.inertia;
+    } else {
+	button = axis->down_button;
+	inertia = pEvdev->emulateWheel.inertia;
+    }
+
+    /* Produce button press events for wheel motion */
+    while(abs(axis->traveled_distance) > pEvdev->emulateWheel.inertia) {
+
+	axis->traveled_distance -= inertia;
+	xf86PostButtonEvent(pInfo->dev, 0, button, 1, 0, 0);
+	xf86PostButtonEvent(pInfo->dev, 0, button, 0, 0, 0);
+    }
+}
+
+/* Handle button mapping here to avoid code duplication,
+returns true if a button mapping was found. */
+static BOOL
+EvdevWheelEmuHandleButtonMap(InputInfoPtr pInfo, WheelAxisPtr pAxis, char* axis_name)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+    char *option_string;
+
+    pAxis->up_button = WHEEL_NOT_CONFIGURED;
+
+    /* Check to see if there is configuration for this axis */
+    option_string = xf86SetStrOption(pInfo->options, axis_name, NULL);
+    if (option_string) {
+	int up_button = 0;
+	int down_button = 0;
+	char *msg = NULL;
+
+	if ((sscanf(option_string, "%d %d", &up_button, &down_button) == 2) &&
+	    ((up_button > 0) && (up_button <= EVDEV_MAXBUTTONS)) &&
+	    ((down_button > 0) && (down_button <= EVDEV_MAXBUTTONS))) {
+
+	    /* Use xstrdup to allocate a string for us */
+	    msg = xstrdup("buttons XX and YY");
+
+	    if (msg)
+		sprintf(msg, "buttons %d and %d", up_button, down_button);
+
+	    pAxis->up_button = up_button;
+	    pAxis->down_button = down_button;
+
+	    /* Update the number of buttons if needed */
+	    if (up_button > pEvdev->buttons) pEvdev->buttons = up_button;
+	    if (down_button > pEvdev->buttons) pEvdev->buttons = down_button;
+
+	} else {
+	    xf86Msg(X_WARNING, "%s: Invalid %s value:\"%s\"\n",
+		    pInfo->name, axis_name, option_string);
+
+	}
+
+	/* Clean up and log what happened */
+	if (msg) {
+	    xf86Msg(X_CONFIG, "%s: %s: %s\n",pInfo->name, axis_name, msg);
+	    xfree(msg);
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+/* Setup the basic configuration options used by mouse wheel emulation */
+void
+EvdevWheelEmuPreInit(InputInfoPtr pInfo)
+{
+    EvdevPtr pEvdev = (EvdevPtr)pInfo->private;
+    char val[4];
+    int wheelButton;
+    int inertia;
+    int timeout;
+
+    val[0] = 0;
+    val[1] = 0;
+
+    if (xf86SetBoolOption(pInfo->options, "EmulateWheel", FALSE)) {
+	pEvdev->emulateWheel.enabled = TRUE;
+    } else
+        pEvdev->emulateWheel.enabled = FALSE;
+
+    wheelButton = xf86SetIntOption(pInfo->options, "EmulateWheelButton", 4);
+
+    if ((wheelButton < 0) || (wheelButton > EVDEV_MAXBUTTONS)) {
+        xf86Msg(X_WARNING, "%s: Invalid EmulateWheelButton value: %d\n",
+                pInfo->name, wheelButton);
+        xf86Msg(X_WARNING, "%s: Wheel emulation disabled.\n", pInfo->name);
+
+        pEvdev->emulateWheel.enabled = FALSE;
+    }
+
+    pEvdev->emulateWheel.button = wheelButton;
+
+    inertia = xf86SetIntOption(pInfo->options, "EmulateWheelInertia", 10);
+
+    if (inertia <= 0) {
+        xf86Msg(X_WARNING, "%s: Invalid EmulateWheelInertia value: %d\n",
+                pInfo->name, inertia);
+        xf86Msg(X_WARNING, "%s: Using built-in inertia value.\n",
+                pInfo->name);
+
+        inertia = 10;
+    }
+
+    pEvdev->emulateWheel.inertia = inertia;
+
+    timeout = xf86SetIntOption(pInfo->options, "EmulateWheelTimeout", 200);
+
+    if (timeout < 0) {
+        xf86Msg(X_WARNING, "%s: Invalid EmulateWheelTimeout value: %d\n",
+                pInfo->name, timeout);
+        xf86Msg(X_WARNING, "%s: Using built-in timeout value.\n",
+                pInfo->name);
+
+        timeout = 200;
+    }
+
+    pEvdev->emulateWheel.timeout = timeout;
+
+    /* Configure the Y axis or default it */
+    if (!EvdevWheelEmuHandleButtonMap(pInfo, &(pEvdev->emulateWheel.Y),
+                "YAxisMapping")) {
+        /* Default the Y axis to sane values */
+        pEvdev->emulateWheel.Y.up_button = 4;
+        pEvdev->emulateWheel.Y.down_button = 5;
+
+        /* Simpler to check just the largest value in this case */
+        /* XXX: we should post this to the server */
+        if (5 > pEvdev->buttons)
+            pEvdev->buttons = 5;
+
+        /* Display default Configuration */
+        xf86Msg(X_CONFIG, "%s: YAxisMapping: buttons %d and %d\n",
+                pInfo->name, pEvdev->emulateWheel.Y.up_button,
+                pEvdev->emulateWheel.Y.down_button);
+    }
+
+
+    /* This axis should default to an unconfigured state as most people
+       are not going to expect a Horizontal wheel. */
+    EvdevWheelEmuHandleButtonMap(pInfo, &(pEvdev->emulateWheel.X),
+            "XAxisMapping");
+
+    /* Used by the inertia code */
+    pEvdev->emulateWheel.X.traveled_distance = 0;
+    pEvdev->emulateWheel.Y.traveled_distance = 0;
+
+    xf86Msg(X_CONFIG, "%s: EmulateWheelButton: %d, "
+            "EmulateWheelInertia: %d, "
+            "EmulateWheelTimeout: %d\n",
+            pInfo->name, pEvdev->emulateWheel.button, inertia, timeout);
+}
+
+#ifdef HAVE_PROPERTIES
+int
+EvdevWheelEmuSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
+                         BOOL checkonly)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+
+    if (atom == prop_wheel_emu)
+    {
+        if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (!checkonly)
+        {
+            pEvdev->emulateWheel.enabled = *((BOOL*)val->data);
+            /* Don't enable with zero inertia, otherwise we may get stuck in an
+             * infinite loop */
+            if (pEvdev->emulateWheel.inertia <= 0)
+            {
+                pEvdev->emulateWheel.inertia = 10;
+                /* We may get here before the property is actually enabled */
+                if (prop_wheel_inertia)
+                    XIChangeDeviceProperty(dev, prop_wheel_inertia, XA_INTEGER,
+                            16, PropModeReplace, 1,
+                            &pEvdev->emulateWheel.inertia, TRUE);
+            }
+
+            /* Don't enable with negative timeout */
+            if (pEvdev->emulateWheel.timeout < 0)
+            {
+                pEvdev->emulateWheel.timeout = 200;
+                XIChangeDeviceProperty(dev, prop_wheel_timeout, XA_INTEGER, 16,
+                        PropModeReplace, 1,
+                        &pEvdev->emulateWheel.timeout, TRUE);
+            }
+        }
+    }
+    else if (atom == prop_wheel_button)
+    {
+        int bt = *((CARD8*)val->data);
+
+        if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (bt < 0 || bt >= EVDEV_MAXBUTTONS)
+            return BadValue;
+
+        if (!checkonly)
+            pEvdev->emulateWheel.button = bt;
+    } else if (atom == prop_wheel_axismap)
+    {
+        if (val->format != 8 || val->size != 4 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (!checkonly)
+        {
+            pEvdev->emulateWheel.X.up_button = *((CARD8*)val->data);
+            pEvdev->emulateWheel.X.down_button = *(((CARD8*)val->data) + 1);
+            pEvdev->emulateWheel.Y.up_button = *(((CARD8*)val->data) + 2);
+            pEvdev->emulateWheel.Y.down_button = *(((CARD8*)val->data) + 3);
+        }
+    } else if (atom == prop_wheel_inertia)
+    {
+        int inertia = *((CARD16*)val->data);
+
+        if (val->format != 16 || val->size != 1 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (inertia < 0)
+            return BadValue;
+
+        if (!checkonly)
+            pEvdev->emulateWheel.inertia = inertia;
+    } else if (atom == prop_wheel_timeout)
+    {
+        int timeout = *((CARD16*)val->data);
+
+        if (val->format != 16 || val->size != 1 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (timeout < 0)
+            return BadValue;
+
+        if (!checkonly)
+            pEvdev->emulateWheel.timeout = timeout;
+    }
+    return Success;
+}
+
+void
+EvdevWheelEmuInitProperty(DeviceIntPtr dev)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+    int          rc     = TRUE;
+    char         vals[4];
+
+    if (!dev->button) /* don't init prop for keyboards */
+        return;
+
+    prop_wheel_emu = MakeAtom(EVDEV_PROP_WHEEL, strlen(EVDEV_PROP_WHEEL), TRUE);
+    rc = XIChangeDeviceProperty(dev, prop_wheel_emu, XA_INTEGER, 8,
+                                PropModeReplace, 1,
+                                &pEvdev->emulateWheel.enabled, FALSE);
+    if (rc != Success)
+        return;
+
+    XISetDevicePropertyDeletable(dev, prop_wheel_emu, FALSE);
+
+    vals[0] = pEvdev->emulateWheel.X.up_button;
+    vals[1] = pEvdev->emulateWheel.X.down_button;
+    vals[2] = pEvdev->emulateWheel.Y.up_button;
+    vals[3] = pEvdev->emulateWheel.Y.down_button;
+
+    prop_wheel_axismap = MakeAtom(EVDEV_PROP_WHEEL_AXES, strlen(EVDEV_PROP_WHEEL_AXES), TRUE);
+    rc = XIChangeDeviceProperty(dev, prop_wheel_axismap, XA_INTEGER, 8,
+                                PropModeReplace, 4, vals, FALSE);
+
+    if (rc != Success)
+        return;
+
+    XISetDevicePropertyDeletable(dev, prop_wheel_axismap, FALSE);
+
+    prop_wheel_inertia = MakeAtom(EVDEV_PROP_WHEEL_INERTIA, strlen(EVDEV_PROP_WHEEL_INERTIA), TRUE);
+    rc = XIChangeDeviceProperty(dev, prop_wheel_inertia, XA_INTEGER, 16,
+                                PropModeReplace, 1,
+                                &pEvdev->emulateWheel.inertia, FALSE);
+    if (rc != Success)
+        return;
+
+    XISetDevicePropertyDeletable(dev, prop_wheel_inertia, FALSE);
+
+    prop_wheel_timeout = MakeAtom(EVDEV_PROP_WHEEL_TIMEOUT, strlen(EVDEV_PROP_WHEEL_TIMEOUT), TRUE);
+    rc = XIChangeDeviceProperty(dev, prop_wheel_timeout, XA_INTEGER, 16,
+                                PropModeReplace, 1,
+                                &pEvdev->emulateWheel.timeout, FALSE);
+    if (rc != Success)
+        return;
+
+    XISetDevicePropertyDeletable(dev, prop_wheel_timeout, FALSE);
+
+    prop_wheel_button = MakeAtom(EVDEV_PROP_WHEEL_BUTTON, strlen(EVDEV_PROP_WHEEL_BUTTON), TRUE);
+    rc = XIChangeDeviceProperty(dev, prop_wheel_button, XA_INTEGER, 8,
+                                PropModeReplace, 1,
+                                &pEvdev->emulateWheel.button, FALSE);
+    if (rc != Success)
+        return;
+
+    XISetDevicePropertyDeletable(dev, prop_wheel_button, FALSE);
+
+    XIRegisterPropertyHandler(dev, EvdevWheelEmuSetProperty, NULL, NULL);
+}
+#endif

src/evdev.c

@@ -23,6 +23,7 @@
  * Authors:
  *	Kristian Høgsberg (krh@redhat.com)
  *	Adam Jackson (ajax@redhat.com)
+ *	Peter Hutterer (peter.hutterer@redhat.com)
  */
 
 #ifdef HAVE_CONFIG_H
@@ -30,26 +31,26 @@
 #endif
 
 #include <X11/keysym.h>
-#include <X11/XF86keysym.h>
-#include <X11/extensions/XIproto.h>
 
 #include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
 
-#include <misc.h>
 #include <xf86.h>
-#include <xf86str.h>
-#include <xf86_OSproc.h>
 #include <xf86Xinput.h>
 #include <exevents.h>
-#include <mipointer.h>
 #include <xorgVersion.h>
+#ifdef XKB
+#include <xkbsrv.h>
+#endif
 
 #include "evdev.h"
 
-#include <xf86Module.h>
+#ifdef HAVE_PROPERTIES
+#include <X11/Xatom.h>
+#include <evdev-properties.h>
+#endif
 
-#include <errno.h>
-#include <fcntl.h>
 
 /* 2.4 compatibility */
 #ifndef EVIOCGRAB
@@ -89,16 +90,24 @@
 #define MODEFLAG	8
 #define COMPOSEFLAG	16
 
-
 static const char *evdevDefaults[] = {
-    "XkbRules",     "base",
+    "XkbRules",     "evdev",
     "XkbModel",     "evdev",
     "XkbLayout",    "us",
     NULL
 };
 
 static int EvdevOn(DeviceIntPtr);
-static int EvdevCacheCompare(InputInfoPtr pInfo, Bool compare);
+static int EvdevCacheCompare(InputInfoPtr pInfo, BOOL compare);
+
+#ifdef HAVE_PROPERTIES
+static void EvdevInitProperty(DeviceIntPtr dev);
+static int EvdevSetProperty(DeviceIntPtr dev, Atom atom,
+                            XIPropertyValuePtr val, BOOL checkonly);
+static Atom prop_invert = 0;
+static Atom prop_reopen = 0;
+#endif
+
 
 static void
 SetXkbOption(InputInfoPtr pInfo, char *name, char **option)
@@ -176,12 +185,10 @@ EvdevReopenTimer(OsTimerPtr timer, CARD32 time, pointer arg)
 
     if (pInfo->fd != -1)
     {
-        pEvdev->reopen_left = 0;
-
         if (EvdevCacheCompare(pInfo, TRUE) == Success)
         {
             xf86Msg(X_INFO, "%s: Device reopened after %d attempts.\n", pInfo->name,
-                    pEvdev->reopen_attempts - pEvdev->reopen_left);
+                    pEvdev->reopen_attempts - pEvdev->reopen_left + 1);
             EvdevOn(pInfo->dev);
         } else
         {
@@ -191,6 +198,7 @@ EvdevReopenTimer(OsTimerPtr timer, CARD32 time, pointer arg)
             close(pInfo->fd);
             pInfo->fd = -1;
         }
+        pEvdev->reopen_left = 0;
         return 0;
     }
 
@@ -214,6 +222,7 @@ EvdevReadInput(InputInfoPtr pInfo)
     int len, value;
     int dx, dy;
     unsigned int abs;
+    unsigned int button;
     EvdevPtr pEvdev = pInfo->private;
 
     dx = 0;
@@ -238,11 +247,16 @@ EvdevReadInput(InputInfoPtr pInfo)
             break;
         }
 
+
         /* Get the signed value, earlier kernels had this as unsigned */
         value = ev.value;
 
         switch (ev.type) {
 	case EV_REL:
+	    /* Handle mouse wheel emulation */
+	    if (EvdevWheelEmuFilterMotion(pInfo, &ev))
+		break;
+
             switch (ev.code) {
             case REL_X:
                 dx += value;
@@ -255,7 +269,7 @@ EvdevReadInput(InputInfoPtr pInfo)
             case REL_WHEEL:
                 if (value > 0)
                     PostButtonClicks(pInfo, wheel_up_button, value);
-                if (value < 0)
+                else if (value < 0)
                     PostButtonClicks(pInfo, wheel_down_button, -value);
                 break;
 
@@ -263,7 +277,7 @@ EvdevReadInput(InputInfoPtr pInfo)
             case REL_HWHEEL:
                 if (value > 0)
                     PostButtonClicks(pInfo, wheel_right_button, value);
-                if (value < 0)
+                else if (value < 0)
                     PostButtonClicks(pInfo, wheel_left_button, -value);
                 break;
             }
@@ -289,53 +303,35 @@ EvdevReadInput(InputInfoPtr pInfo)
 		    break;
 
             switch (ev.code) {
-	    /* swap here, pretend we're an X-conformant device. */
-            case BTN_LEFT:
-                if (!EvdevMBEmuFilterEvent(pInfo, ev.code, value))
-                    xf86PostButtonEvent(pInfo->dev, 0, 1, value, 0, 0);
-                break;
-            case BTN_RIGHT:
-                if (!EvdevMBEmuFilterEvent(pInfo, ev.code, value))
-                    xf86PostButtonEvent(pInfo->dev, 0, 3, value, 0, 0);
-                break;
-            case BTN_MIDDLE:
-                EvdevMBEmuEnable(pInfo, FALSE);
-                xf86PostButtonEvent(pInfo->dev, 0, 2, value, 0, 0);
-                break;
-
-            case BTN_SIDE:
-            case BTN_EXTRA:
-            case BTN_FORWARD:
-            case BTN_BACK:
-            case BTN_TASK:
-                xf86PostButtonEvent(pInfo->dev, 0, ev.code - BTN_LEFT + 5,
-                                    value, 0, 0);
-                break;
-
 	    case BTN_TOUCH:
- 	    case BTN_TOOL_PEN:
- 	    case BTN_TOOL_RUBBER:
- 	    case BTN_TOOL_BRUSH:
- 	    case BTN_TOOL_PENCIL:
- 	    case BTN_TOOL_AIRBRUSH:
- 	    case BTN_TOOL_FINGER:
- 	    case BTN_TOOL_MOUSE:
- 	    case BTN_TOOL_LENS:
+	    case BTN_TOOL_PEN:
+	    case BTN_TOOL_RUBBER:
+	    case BTN_TOOL_BRUSH:
+	    case BTN_TOOL_PENCIL:
+	    case BTN_TOOL_AIRBRUSH:
+	    case BTN_TOOL_FINGER:
+	    case BTN_TOOL_MOUSE:
+	    case BTN_TOOL_LENS:
 		pEvdev->tool = value ? ev.code : 0;
 		break;
 
             default:
-		if (ev.code > BTN_TASK && ev.code < KEY_OK) {
-		    /* Some fancy mice with a lot of buttons generate
-		     * button events between BTN_TASK and BTN_JOYSTICK */
-		    if (ev.code < BTN_JOYSTICK)
-			xf86PostButtonEvent(pInfo->dev, 0,
-			                    ev.code - BTN_LEFT + 5,
-			                    value, 0, 0);
-		    break;
-		}
+		button = EvdevUtilButtonEventToButtonNumber(ev.code);
 
-                PostKbdEvent(pInfo, &ev, value);
+		/* Handle drag lock */
+		if (EvdevDragLockFilterEvent(pInfo, button, value))
+		    break;
+
+		if (EvdevWheelEmuFilterButton(pInfo, button, value))
+		   break;
+
+		if (EvdevMBEmuFilterEvent(pInfo, button, value))
+		   break;
+
+		if (button)
+		    xf86PostButtonEvent(pInfo->dev, 0, button, value, 0, 0);
+		else
+		    PostKbdEvent(pInfo, &ev, value);
 		break;
             }
             break;
@@ -360,8 +356,13 @@ EvdevReadInput(InputInfoPtr pInfo)
 	}
     }
 
-    if (dx != 0 || dy != 0)
+    if (dx != 0 || dy != 0) {
+        if (pEvdev->invert_x)
+            dx *= -1;
+        if (pEvdev->invert_y)
+            dy *= -1;
         xf86PostMotionEvent(pInfo->dev, FALSE, 0, 2, dx, dy);
+    }
 
     /*
      * Some devices only generate valid abs coords when BTN_DIGI is
@@ -373,8 +374,15 @@ EvdevReadInput(InputInfoPtr pInfo)
      * just works.
      */
     if (abs && pEvdev->tool) {
-	xf86PostMotionEvent(pInfo->dev, TRUE, 0, 2,
-			    pEvdev->abs_x, pEvdev->abs_y);
+        int abs_x, abs_y;
+        abs_x = pEvdev->abs_x;
+        abs_y = pEvdev->abs_y;
+        if (pEvdev->invert_x)
+            abs_x = pEvdev->max_x - abs_x;
+        if (pEvdev->invert_y)
+            abs_y = pEvdev->max_y - abs_y;
+
+	xf86PostMotionEvent(pInfo->dev, TRUE, 0, 2, abs_x, abs_y);
     }
 }
 
@@ -679,7 +687,7 @@ EvdevAddKeyClass(DeviceIntPtr device)
 
     static struct { KeySym keysym; CARD8 mask; } modifiers[] = {
         { XK_Shift_L,		ShiftMask },
-        { XK_Shift_R, 		ShiftMask },
+        { XK_Shift_R,		ShiftMask },
         { XK_Control_L,		ControlMask },
         { XK_Control_R,		ControlMask },
         { XK_Caps_Lock,		LockMask },
@@ -692,11 +700,6 @@ EvdevAddKeyClass(DeviceIntPtr device)
         { XK_Mode_switch,	AltLangMask }
     };
 
-    /* TODO:
-     * Ctrl-Alt-Backspace and other Ctrl-Alt-stuff should work
-     * Get keyboard repeat under control (right now caps lock repeats!)
-     */
-
     pInfo = device->public.devicePrivate;
     pEvdev = pInfo->private;
 
@@ -728,12 +731,12 @@ EvdevAddKeyClass(DeviceIntPtr device)
 #ifdef XKB
     else
     {
+	/* sorry, no rules change allowed for you */
+	xf86ReplaceStrOption(pInfo->options, "xkb_rules", "evdev");
         SetXkbOption(pInfo, "xkb_rules", &pEvdev->xkb_rules);
-	if (!pEvdev->xkb_rules)
-	    SetXkbOption(pInfo, "XkbRules", &pEvdev->xkb_rules);
-	/* sorry, no model change allowed for you */
-	xf86ReplaceStrOption(pInfo->options, "xkb_model", "evdev");
         SetXkbOption(pInfo, "xkb_model", &pEvdev->xkb_model);
+	if (!pEvdev->xkb_model)
+	    SetXkbOption(pInfo, "XkbModel", &pEvdev->xkb_rules);
         SetXkbOption(pInfo, "xkb_layout", &pEvdev->xkb_layout);
 	if (!pEvdev->xkb_layout)
 	    SetXkbOption(pInfo, "XkbLayout", &pEvdev->xkb_layout);
@@ -848,22 +851,71 @@ EvdevAddRelClass(DeviceIntPtr device)
 static int
 EvdevAddButtonClass(DeviceIntPtr device)
 {
-    CARD8 map[32];
     InputInfoPtr pInfo;
-    int i;
+    EvdevPtr pEvdev;
 
     pInfo = device->public.devicePrivate;
+    pEvdev = pInfo->private;
 
     /* FIXME: count number of actual buttons */
-    for (i = 0; i < ArrayLength(map); i++)
-        map[i] = i;
-
-    if (!InitButtonClassDeviceStruct(device, ArrayLength(map), map))
+    if (!InitButtonClassDeviceStruct(device, ArrayLength(pEvdev->btnmap),
+                                     pEvdev->btnmap))
         return !Success;
 
     return Success;
 }
 
+/**
+ * Init the button mapping for the device. By default, this is a 1:1 mapping,
+ * i.e. Button 1 maps to Button 1, Button 2 to 2, etc.
+ *
+ * If a mapping has been specified, the mapping is the default, with the
+ * user-defined ones overwriting the defaults.
+ * i.e. a user-defined mapping of "3 2 1" results in a mapping of 3 2 1 4 5 6 ...
+ *
+ * Invalid button mappings revert to the default.
+ *
+ * Note that index 0 is unused, button 0 does not exist.
+ * This mapping is initialised for all devices, but only applied if the device
+ * has buttons (in EvdevAddButtonClass).
+ */
+static void
+EvdevInitButtonMapping(InputInfoPtr pInfo)
+{
+    int         i, nbuttons     = 1;
+    char       *mapping         = NULL;
+    EvdevPtr    pEvdev          = pInfo->private;
+
+    /* Check for user-defined button mapping */
+    if ((mapping = xf86CheckStrOption(pInfo->options, "ButtonMapping", NULL)))
+    {
+        char    *s  = " ";
+        int     btn = 0;
+
+        xf86Msg(X_CONFIG, "%s: ButtonMapping '%s'\n", pInfo->name, mapping);
+        while (s && *s != '\0' && nbuttons < EVDEV_MAXBUTTONS)
+        {
+            btn = strtol(mapping, &s, 10);
+
+            if (s == mapping || btn < 0 || btn > EVDEV_MAXBUTTONS)
+            {
+                xf86Msg(X_ERROR,
+                        "%s: ... Invalid button mapping. Using defaults\n",
+                        pInfo->name);
+                nbuttons = 1; /* ensure defaults start at 1 */
+                break;
+            }
+
+            pEvdev->btnmap[nbuttons++] = btn;
+            mapping = s;
+        }
+    }
+
+    for (i = nbuttons; i < ArrayLength(pEvdev->btnmap); i++)
+        pEvdev->btnmap[i] = i;
+
+}
+
 static int
 EvdevInit(DeviceIntPtr device)
 {
@@ -893,6 +945,17 @@ EvdevInit(DeviceIntPtr device)
     else if (pEvdev->flags & EVDEV_ABSOLUTE_EVENTS)
         EvdevAddAbsClass(device);
 
+#ifdef HAVE_PROPERTIES
+    /* We drop the return value, the only time we ever want the handlers to
+     * unregister is when the device dies. In which case we don't have to
+     * unregister anyway */
+    XIRegisterPropertyHandler(device, EvdevSetProperty, NULL, NULL);
+    EvdevInitProperty(device);
+    EvdevMBEmuInitProperty(device);
+    EvdevWheelEmuInitProperty(device);
+    EvdevDragLockInitProperty(device);
+#endif
+
     return Success;
 }
 
@@ -933,11 +996,6 @@ EvdevOn(DeviceIntPtr device)
     } else
     {
         xf86AddEnabledDevice(pInfo);
-        if ((pEvdev->flags & EVDEV_BUTTON_EVENTS) &&
-            !(pEvdev->flags & EVDEV_INITIALIZED))
-        {
-            EvdevMBEmuPreInit(pInfo);
-        }
         pEvdev->flags |= EVDEV_INITIALIZED;
         device->public.on = TRUE;
     }
@@ -970,6 +1028,8 @@ EvdevProc(DeviceIntPtr device, int what)
                 xf86Msg(X_WARNING, "%s: Release failed (%s)\n", pInfo->name,
                         strerror(errno));
             xf86RemoveEnabledDevice(pInfo);
+            close(pInfo->fd);
+            pInfo->fd = -1;
         }
         if (pEvdev->flags & EVDEV_INITIALIZED)
             EvdevMBEmuFinalize(pInfo);
@@ -984,37 +1044,16 @@ EvdevProc(DeviceIntPtr device, int what)
 
     case DEVICE_CLOSE:
 	xf86Msg(X_INFO, "%s: Close\n", pInfo->name);
-        if (pInfo->fd != -1)
+        if (pInfo->fd != -1) {
             close(pInfo->fd);
+            pInfo->fd = -1;
+        }
 	break;
     }
 
     return Success;
 }
 
-static Bool
-EvdevConvert(InputInfoPtr pInfo, int first, int num, int v0, int v1, int v2,
-	     int v3, int v4, int v5, int *x, int *y)
-{
-    EvdevPtr pEvdev = pInfo->private;
-    int screenWidth = screenInfo.screens[pEvdev->screen]->width;
-    int screenHeight = screenInfo.screens[pEvdev->screen]->height;
-
-    if (first != 0 || num != 2)
-	return FALSE;
-
-    /* on absolute touchpads, don't warp on initial touch */
-    if (pEvdev->flags & EVDEV_TOUCHPAD) {
-	*x = v0;
-	*y = v0;
-	return TRUE;
-    }
-
-    *x = (v0 - pEvdev->min_x) * screenWidth / (pEvdev->max_x - pEvdev->min_x);
-    *y = (v1 - pEvdev->min_y) * screenHeight / (pEvdev->max_y - pEvdev->min_y);
-
-    return TRUE;
-}
 /**
  * Get as much information as we can from the fd and cache it.
  * If compare is True, then the information retrieved will be compared to the
@@ -1024,7 +1063,7 @@ EvdevConvert(InputInfoPtr pInfo, int first, int num, int v0, int v1, int v2,
  * @return Success if the information was cached, or !Success otherwise.
  */
 static int
-EvdevCacheCompare(InputInfoPtr pInfo, Bool compare)
+EvdevCacheCompare(InputInfoPtr pInfo, BOOL compare)
 {
     EvdevPtr pEvdev = pInfo->private;
     int i;
@@ -1124,6 +1163,7 @@ EvdevCacheCompare(InputInfoPtr pInfo, Bool compare)
 
 error:
     return !Success;
+
 }
 
 static int
@@ -1132,7 +1172,7 @@ EvdevProbe(InputInfoPtr pInfo)
     long key_bitmask[NBITS(KEY_MAX)];
     long rel_bitmask[NBITS(REL_MAX)];
     long abs_bitmask[NBITS(ABS_MAX)];
-    int i, has_axes, has_buttons, has_keys;
+    int i, has_axes, has_keys, num_buttons;
     EvdevPtr pEvdev = pInfo->private;
 
     if (ioctl(pInfo->fd, EVIOCGRAB, (void *)1)) {
@@ -1147,7 +1187,7 @@ EvdevProbe(InputInfoPtr pInfo)
         ioctl(pInfo->fd, EVIOCGRAB, (void *)0);
     }
 
-    if (ioctl(pInfo->fd, 
+    if (ioctl(pInfo->fd,
               EVIOCGBIT(EV_REL, sizeof(rel_bitmask)), rel_bitmask) < 0) {
         xf86Msg(X_ERROR, "ioctl EVIOCGBIT failed: %s\n", strerror(errno));
         return 1;
@@ -1166,15 +1206,15 @@ EvdevProbe(InputInfoPtr pInfo)
     }
 
     has_axes = FALSE;
-    has_buttons = FALSE;
     has_keys = FALSE;
+    num_buttons = 0;
 
     if (TestBit(REL_X, rel_bitmask) && TestBit(REL_Y, rel_bitmask)) {
         xf86Msg(X_INFO, "%s: Found x and y relative axes\n", pInfo->name);
 	pEvdev->flags |= EVDEV_RELATIVE_EVENTS;
 	has_axes = TRUE;
     }
-      
+
     if (TestBit(ABS_X, abs_bitmask) && TestBit(ABS_Y, abs_bitmask)) {
         xf86Msg(X_INFO, "%s: Found x and y absolute axes\n", pInfo->name);
 	pEvdev->flags |= EVDEV_ABSOLUTE_EVENTS;
@@ -1186,10 +1226,19 @@ EvdevProbe(InputInfoPtr pInfo)
 	has_axes = TRUE;
     }
 
-    if (TestBit(BTN_LEFT, key_bitmask)) {
-        xf86Msg(X_INFO, "%s: Found mouse buttons\n", pInfo->name);
-	pEvdev->flags |= EVDEV_BUTTON_EVENTS;
-	has_buttons = TRUE;
+    /* count all buttons */
+    for (i = BTN_MISC; i < BTN_JOYSTICK; i++)
+    {
+        if (TestBit(i, key_bitmask))
+            num_buttons++;
+    }
+
+    if (num_buttons)
+    {
+        pEvdev->flags |= EVDEV_BUTTON_EVENTS;
+        pEvdev->buttons = num_buttons;
+        xf86Msg(X_INFO, "%s: Found %d mouse buttons\n", pInfo->name,
+                num_buttons);
     }
 
     for (i = 0; i < BTN_MISC; i++)
@@ -1202,9 +1251,9 @@ EvdevProbe(InputInfoPtr pInfo)
 	has_keys = TRUE;
     }
 
-    if (has_axes && has_buttons) {
+    if (has_axes && num_buttons) {
         xf86Msg(X_INFO, "%s: Configuring as mouse\n", pInfo->name);
-	pInfo->flags |= XI86_POINTER_CAPABLE | XI86_SEND_DRAG_EVENTS | 
+	pInfo->flags |= XI86_POINTER_CAPABLE | XI86_SEND_DRAG_EVENTS |
 	    XI86_CONFIGURED;
 	pInfo->type_name = XI_MOUSE;
     }
@@ -1229,11 +1278,11 @@ EvdevProbe(InputInfoPtr pInfo)
     return 0;
 }
 
+
 static InputInfoPtr
 EvdevPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
 {
     InputInfoPtr pInfo;
-    MessageType deviceFrom = X_CONFIG;
     const char *device;
     EvdevPtr pEvdev;
 
@@ -1250,7 +1299,7 @@ EvdevPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
     pInfo->control_proc = NULL;
     pInfo->close_proc = NULL;
     pInfo->switch_mode = NULL;
-    pInfo->conversion_proc = EvdevConvert;
+    pInfo->conversion_proc = NULL;
     pInfo->reverse_conversion_proc = NULL;
     pInfo->dev = NULL;
     pInfo->private_flags = 0;
@@ -1263,18 +1312,15 @@ EvdevPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
     pInfo->private = pEvdev;
 
     xf86CollectInputOptions(pInfo, evdevDefaults, NULL);
-    xf86ProcessCommonOptions(pInfo, pInfo->options); 
+    xf86ProcessCommonOptions(pInfo, pInfo->options);
 
-    pEvdev->screen = xf86SetIntOption(pInfo->options, "ScreenNumber", 0);
     /*
      * We initialize pEvdev->tool to 1 so that device that doesn't use
      * proximity will still report events.
      */
     pEvdev->tool = 1;
 
-    device = xf86CheckStrOption(dev->commonOptions, "Path", NULL);
-    if (!device)
-	device = xf86CheckStrOption(dev->commonOptions, "Device", NULL);
+    device = xf86CheckStrOption(dev->commonOptions, "Device", NULL);
     if (!device) {
         xf86Msg(X_ERROR, "%s: No device specified.\n", pInfo->name);
 	xf86DeleteInput(pInfo, 0);
@@ -1283,7 +1329,7 @@ EvdevPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
 
     pEvdev->device = device;
 
-    xf86Msg(deviceFrom, "%s: Device: \"%s\"\n", pInfo->name, device);
+    xf86Msg(X_CONFIG, "%s: Device: \"%s\"\n", pInfo->name, device);
     do {
         pInfo->fd = open(device, O_RDWR, 0);
     } while (pInfo->fd < 0 && errno == EINTR);
@@ -1295,9 +1341,12 @@ EvdevPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
     }
 
     pEvdev->reopen_attempts = xf86SetIntOption(pInfo->options, "ReopenAttempts", 10);
+    pEvdev->invert_x = xf86SetBoolOption(pInfo->options, "InvertX", FALSE);
+    pEvdev->invert_y = xf86SetBoolOption(pInfo->options, "InvertY", FALSE);
 
-    pEvdev->noXkb = noXkbExtension;
-    /* parse the XKB options during kbd setup */
+    pEvdev->noXkb = noXkbExtension; /* parse the XKB options during kbd setup */
+
+    EvdevInitButtonMapping(pInfo);
 
     if (EvdevProbe(pInfo)) {
 	close(pInfo->fd);
@@ -1307,6 +1356,13 @@ EvdevPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
 
     EvdevCacheCompare(pInfo, FALSE); /* cache device data */
 
+    if (pEvdev->flags & EVDEV_BUTTON_EVENTS)
+    {
+        EvdevMBEmuPreInit(pInfo);
+        EvdevWheelEmuPreInit(pInfo);
+        EvdevDragLockPreInit(pInfo);
+    }
+
     return pInfo;
 }
 
@@ -1355,3 +1411,117 @@ _X_EXPORT XF86ModuleData evdevModuleData =
     EvdevPlug,
     EvdevUnplug
 };
+
+
+/* Return an index value for a given button event code
+ * returns 0 on non-button event.
+ */
+unsigned int
+EvdevUtilButtonEventToButtonNumber(int code)
+{
+    unsigned int button = 0;
+
+    switch(code) {
+    case BTN_LEFT:
+	button = 1;
+	break;
+
+    case BTN_RIGHT:
+	button = 3;
+	break;
+
+    case BTN_MIDDLE:
+	button = 2;
+	break;
+
+    case BTN_SIDE:
+    case BTN_EXTRA:
+    case BTN_FORWARD:
+    case BTN_BACK:
+    case BTN_TASK:
+	button = (code - BTN_LEFT + 5);
+	break;
+
+    default:
+	if ((code > BTN_TASK) && (code < KEY_OK)) {
+	    if (code < BTN_JOYSTICK)
+		button = (code - BTN_LEFT + 5);
+	}
+    }
+
+    if (button > EVDEV_MAXBUTTONS)
+	return 0;
+
+    return button;
+}
+
+#ifdef HAVE_PROPERTIES
+static void
+EvdevInitProperty(DeviceIntPtr dev)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+    int          rc;
+    BOOL         invert[2];
+    char         reopen;
+
+
+    if (pEvdev->flags & (EVDEV_RELATIVE_EVENTS | EVDEV_ABSOLUTE_EVENTS))
+    {
+        invert[0] = pEvdev->invert_x;
+        invert[1] = pEvdev->invert_y;
+
+        prop_invert = MakeAtom(EVDEV_PROP_INVERT_AXES, strlen(EVDEV_PROP_INVERT_AXES), TRUE);
+
+        rc = XIChangeDeviceProperty(dev, prop_invert, XA_INTEGER, 8,
+                PropModeReplace, 2,
+                invert, FALSE);
+        if (rc != Success)
+            return;
+
+        XISetDevicePropertyDeletable(dev, prop_invert, FALSE);
+    }
+
+    prop_reopen = MakeAtom(EVDEV_PROP_REOPEN, strlen(EVDEV_PROP_REOPEN),
+            TRUE);
+
+    reopen = pEvdev->reopen_attempts;
+    rc = XIChangeDeviceProperty(dev, prop_reopen, XA_INTEGER, 8,
+                                PropModeReplace, 1, &reopen, FALSE);
+    if (rc != Success)
+        return;
+
+    XISetDevicePropertyDeletable(dev, prop_reopen, FALSE);
+}
+
+static int
+EvdevSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
+                 BOOL checkonly)
+{
+    InputInfoPtr pInfo  = dev->public.devicePrivate;
+    EvdevPtr     pEvdev = pInfo->private;
+
+    if (atom == prop_invert)
+    {
+        BOOL* data;
+        if (val->format != 8 || val->size != 2 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (!checkonly)
+        {
+            data = (BOOL*)val->data;
+            pEvdev->invert_x = data[0];
+            pEvdev->invert_y = data[1];
+        }
+    } else if (atom == prop_reopen)
+    {
+        if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER)
+            return BadMatch;
+
+        if (!checkonly)
+            pEvdev->reopen_attempts = *((CARD8*)val->data);
+    }
+
+    return Success;
+}
+#endif

src/evdev.h

@@ -35,14 +35,26 @@
 #include <xf86Xinput.h>
 #include <xf86_OSproc.h>
 
-#if defined(XKB)
-/* XXX VERY WRONG.  this is a client side header. */
-#include <X11/extensions/XKBstr.h>
+#ifdef XKB
+#include <xkbstr.h>
+#endif
+
+#define EVDEV_MAXBUTTONS 32
+
+#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 3
+#define HAVE_PROPERTIES 1
 #endif
 
 #define LONG_BITS (sizeof(long) * 8)
 #define NBITS(x) (((x) + LONG_BITS - 1) / LONG_BITS)
 
+/* axis specific data for wheel emulation */
+typedef struct {
+    int up_button;
+    int down_button;
+    int traveled_distance;
+} WheelAxis, *WheelAxisPtr;
+
 typedef struct {
     const char *device;
     int kernel24;
@@ -51,6 +63,9 @@ typedef struct {
     int abs_x, abs_y, old_x, old_y;
     int flags;
     int tool;
+    int buttons;            /* number of buttons */
+    BOOL invert_x;
+    BOOL invert_y;
 
     /* XKB stuff has to be per-device rather than per-driver */
     int noXkb;
@@ -71,6 +86,25 @@ typedef struct {
         Time                expires;     /* time of expiry */
         Time                timeout;
     } emulateMB;
+    struct {
+	int                 meta;           /* meta key to lock any button */
+	BOOL                meta_state;     /* meta_button state */
+	unsigned int        lock_pair[EVDEV_MAXBUTTONS];  /* specify a meta/lock pair */
+	BOOL                lock_state[EVDEV_MAXBUTTONS]; /* state of any locked buttons */
+    } dragLock;
+    struct {
+        BOOL                enabled;
+        int                 button;
+        int                 button_state;
+        int                 inertia;
+        WheelAxis           X;
+        WheelAxis           Y;
+        Time                expires;     /* time of expiry */
+        Time                timeout;
+    } emulateWheel;
+
+    unsigned char btnmap[32];           /* config-file specified button mapping */
+
     int reopen_attempts; /* max attempts to re-open after read failure */
     int reopen_left;     /* number of attempts left to re-open the device */
     OsTimerPtr reopen_timer;
@@ -85,6 +119,8 @@ typedef struct {
     struct input_absinfo absinfo[ABS_MAX];
 } EvdevRec, *EvdevPtr;
 
+unsigned int EvdevUtilButtonEventToButtonNumber(int code);
+
 /* Middle Button emulation */
 int  EvdevMBEmuTimer(InputInfoPtr);
 BOOL EvdevMBEmuFilterEvent(InputInfoPtr, int, BOOL);
@@ -94,4 +130,18 @@ void EvdevMBEmuPreInit(InputInfoPtr);
 void EvdevMBEmuFinalize(InputInfoPtr);
 void EvdevMBEmuEnable(InputInfoPtr, BOOL);
 
+/* Mouse Wheel emulation */
+void EvdevWheelEmuPreInit(InputInfoPtr pInfo);
+BOOL EvdevWheelEmuFilterButton(InputInfoPtr pInfo, unsigned int button, int value);
+BOOL EvdevWheelEmuFilterMotion(InputInfoPtr pInfo, struct input_event *pEv);
+
+/* Draglock code */
+void EvdevDragLockPreInit(InputInfoPtr pInfo);
+BOOL EvdevDragLockFilterEvent(InputInfoPtr pInfo, unsigned int button, int value);
+
+#ifdef HAVE_PROPERTIES
+void EvdevMBEmuInitProperty(DeviceIntPtr);
+void EvdevWheelEmuInitProperty(DeviceIntPtr);
+void EvdevDragLockInitProperty(DeviceIntPtr);
+#endif
 #endif

xorg-evdev.pc.in

@@ -0,0 +1,6 @@
+sdkdir=@sdkdir@
+
+Name: xorg-evdev
+Description: X.Org evdev input driver.
+Version: @PACKAGE_VERSION@
+Cflags: -I${sdkdir}