Always add second input device for keys only

Having one device for both mouse and keyboard events breaks with MPX and custom keymaps, because the keymap is
copied to the core pointer instead of the core keyboard.

Easiest fix for that is to have two separate input devices. One single instance of the driver will now create
a second input device that has only keyboard capabilities. It shares all the config with the master and will
be removed when the master device is removed.

The creation of this second device is a little hack-ish. I hope things are done right.

6 files changed, 202 insertions, 24 deletions

diff --git a/src/jstk.c b/src/jstk.c
index b7a3ae2..35ced34 100644
--- a/src/jstk.c
+++ b/src/jstk.c
@@ -33,6 +33,7 @@
 #include <xf86.h>
 #include <xf86Xinput.h>
 #include <exevents.h>		/* Needed for InitValuator/Proximity stuff */
+#include <xf86Opt.h>
 
 #include <math.h>
 #include <xf86Module.h>
@@ -167,7 +168,7 @@ jstkReadProc(LocalDevicePtr local)
             switch (priv->button[number].mapping) {
             case MAPPING_BUTTON:
                 if (priv->mouse_enabled == TRUE) {
-                    xf86PostButtonEvent(local->dev, 0, 
+                    xf86PostButtonEvent(local->dev, 0,
                         priv->button[number].buttonnumber,
                         priv->button[number].pressed, 0, 0);
                 }
@@ -185,7 +186,7 @@ jstkReadProc(LocalDevicePtr local)
 
             case MAPPING_KEY:
                 if (priv->keys_enabled == TRUE)
-                    jstkGenerateKeys(local->dev, 
+                    jstkGenerateKeys(priv->keyboard_device, 
                                      priv->button[number].keys, 
                                      priv->button[number].pressed);
                 break;
@@ -281,13 +282,13 @@ jstkReadProc(LocalDevicePtr local)
                 if (priv->axis[number].type == TYPE_ACCELERATED) {
                     if ((priv->axis[number].value > 0) != 
                         (priv->axis[number].oldvalue > 0))
-                        jstkGenerateKeys(local->dev, 
+                        jstkGenerateKeys(priv->keyboard_device, 
                                          priv->axis[number].keys_high,
                                          (priv->axis[number].value > 0) ? 1:0);
 
                     if ((priv->axis[number].value < 0) != 
                         (priv->axis[number].oldvalue < 0))
-                        jstkGenerateKeys(local->dev,
+                        jstkGenerateKeys(priv->keyboard_device,
                                          priv->axis[number].keys_low,
                                          (priv->axis[number].value < 0) ? 1:0);
                 } else if (priv->axis[number].type == TYPE_BYVALUE) {
@@ -335,13 +336,7 @@ jstkDeviceControlProc(DeviceIntPtr       pJstk,
                 ErrorF("unable to allocate Button class device\n");
                 return !Success;
             }
-            if (InitFocusClassDeviceStruct(pJstk) == FALSE) {
-                ErrorF("unable to init Focus class device\n");
-                return !Success;
-            }
         }
-        jstkInitKeys(pJstk, priv);
-
         m = 2;
         for (i=0; i<MAXAXES; i++) 
             if (priv->axis[i].type != TYPE_NONE)
@@ -385,6 +380,18 @@ jstkDeviceControlProc(DeviceIntPtr       pJstk,
             /* allocate the motion history buffer if needed */
             xf86MotionHistoryAllocate(local);
         }
+
+
+        if (priv->keyboard_device != NULL)
+        {
+            DBG(2, ErrorF("Activating keyboard device\n"));
+            xf86ActivateDevice(priv->keyboard_device);
+            priv->keyboard_device->dev->inited = 
+                (priv->keyboard_device->device_control(priv->keyboard_device->dev, DEVICE_INIT) == Success);
+            xf86EnableDevice(priv->keyboard_device->dev);
+            DBG(2, ErrorF("Keyboard device activated\n"));
+        }
+
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 3
 	jstkInitProperties(pJstk, priv);
 #endif
@@ -433,6 +440,17 @@ jstkDeviceControlProc(DeviceIntPtr       pJstk,
 
 
 
+
+_X_EXPORT InputDriverRec JOYSTICK_KEYBOARD = {
+    1,
+    "joystick_keyboard",
+    NULL,
+    jstkKeyboardPreInit,
+    jstkKeyboardUnInit,
+    NULL,
+    0
+};
+
 /*
  ***************************************************************************
  *
@@ -461,7 +479,6 @@ jstkCorePreInit(InputDriverPtr drv, IDevPtr dev, int flags)
 
     local->name   = dev->identifier;
     local->flags  = XI86_POINTER_CAPABLE;
-    local->flags |= XI86_KEYBOARD_CAPABLE;
     local->flags |= XI86_SEND_DRAG_EVENTS;
     local->device_control = jstkDeviceControlProc;
     local->read_input = jstkReadProc;
@@ -486,6 +503,7 @@ jstkCorePreInit(InputDriverPtr drv, IDevPtr dev, int flags)
     priv->keys_enabled = TRUE;
     priv->amplify = 1.0f;
     priv->buttonmap.size = 0;
+    priv->keyboard_device = NULL;
     priv->keymap.size = 1;
     memset(priv->keymap.map, NoSymbol, sizeof(priv->keymap.map));
     priv->repeat_delay = 0;
@@ -627,6 +645,11 @@ jstkCorePreInit(InputDriverPtr drv, IDevPtr dev, int flags)
     /* return the LocalDevice */
     local->flags |= XI86_CONFIGURED;
 
+    priv->keyboard_device = jstkKeyboardPreInit(&JOYSTICK_KEYBOARD, dev, flags);
+    if (priv->keyboard_device) {
+        priv->keyboard_device->private = priv;
+    }
+
     return (local);
 
 SetupProc_fail:
@@ -657,7 +680,11 @@ jstkCoreUnInit(InputDriverPtr    drv,
 {
     JoystickDevPtr device = (JoystickDevPtr) local->private;
 
-    jstkDeviceControlProc(local->dev, DEVICE_OFF);
+    if (device->keyboard_device != NULL)
+    {
+        xf86DisableDevice(device->keyboard_device->dev, TRUE);
+        device->keyboard_device = NULL;
+    }
 
     xfree (device);
     local->private = NULL;
@@ -695,6 +722,7 @@ jstkDriverPlug(pointer  module,
                int      *errmin)
 {
     xf86AddInputDriver(&JOYSTICK, module, 0);
+    xf86AddInputDriver(&JOYSTICK_KEYBOARD, module, 0);
     return module;
 }
 
diff --git a/src/jstk.h b/src/jstk.h
index 7ea7fb3..fb600ff 100644
--- a/src/jstk.h
+++ b/src/jstk.h
@@ -24,6 +24,8 @@
 #ifndef __JSTK_H_INCLUDED__
 #define __JSTK_H_INCLUDED__
 
+#include <xf86Xinput.h>
+
 
 #define MAXBUTTONS 32
 #define MAXAXES 32
@@ -111,6 +113,7 @@ typedef struct _JoystickDevRec {
     jstkReadDataProc read_proc; /* Callback for reading data from the backend */
     void         *devicedata; /* Extra platform device dependend data */
     char         *device;     /* Name of the device */
+    LocalDevicePtr keyboard_device; /* Slave device for keyboard events */
 
     OsTimerPtr   timer;       /* Timer for axis movement */
     Bool         timerrunning;
diff --git a/src/jstk_axis.c b/src/jstk_axis.c
index f9e2fce..57eacef 100644
--- a/src/jstk_axis.c
+++ b/src/jstk_axis.c
@@ -34,6 +34,7 @@
 
 #include "jstk.h"
 #include "jstk_axis.h"
+#include "jstk_key.h"
 
 
 /***********************************************************************
@@ -136,13 +137,13 @@ jstkAxisTimer(OsTimerPtr        timer,
                 num = abs((int)axis->subpixel);
                 if ((int)axis->subpixel < 0) {
                     for (i=0; i<num; i++) {
-                        jstkGenerateKeys(device, axis->keys_low, 1);
-                        jstkGenerateKeys(device, axis->keys_low, 0);
+                        jstkGenerateKeys(priv->keyboard_device, axis->keys_low, 1);
+                        jstkGenerateKeys(priv->keyboard_device, axis->keys_low, 0);
                     }
                 } else {
                     for (i=0; i<num; i++) {
-                        jstkGenerateKeys(device, axis->keys_high, 1);
-                        jstkGenerateKeys(device, axis->keys_high, 0);
+                        jstkGenerateKeys(priv->keyboard_device, axis->keys_high, 1);
+                        jstkGenerateKeys(priv->keyboard_device, axis->keys_high, 0);
                     }
                 }
                 break;
diff --git a/src/jstk_axis.h b/src/jstk_axis.h
index 4b91aae..e759f39 100644
--- a/src/jstk_axis.h
+++ b/src/jstk_axis.h
@@ -27,6 +27,5 @@
 void jstkStartAxisTimer(LocalDevicePtr device, int number);
 void jstkStartButtonAxisTimer(LocalDevicePtr device, int number);
 void jstkHandleAbsoluteAxis(LocalDevicePtr device, int number);
-void jstkGenerateKeys(DeviceIntPtr device, KEYSCANCODES keys, char pressed);
 
 #endif
diff --git a/src/jstk_key.c b/src/jstk_key.c
index c154fbc..ba7c4c9 100644
--- a/src/jstk_key.c
+++ b/src/jstk_key.c
@@ -52,9 +52,16 @@ jstkKbdCtrl(DeviceIntPtr device, KeybdCtrl *ctrl)
 {
 }
 
-
-
-int
+/*
+ ***************************************************************************
+ *
+ * jstkInitKeys --
+ *
+ * Sets up the keymap, modmap and the keyboard device structs
+ *
+ ***************************************************************************
+ */
+static int
 jstkInitKeys(DeviceIntPtr pJstk, JoystickDevPtr priv)
 {
     KeySymsRec keySyms;
@@ -82,7 +89,7 @@ jstkInitKeys(DeviceIntPtr pJstk, JoystickDevPtr priv)
                    priv->keymap.size));
     for (i = 0; i < priv->keymap.size; i++)
     {
-	DBG(6, xf86Msg(X_CONFIG, "Keymap [%d]: 0x%08X\n", MIN_KEYCODE+i,priv->keymap.map[i]));
+	DBG(6, xf86Msg(X_CONFIG, "Keymap [%d]: 0x%08X\n", MIN_KEYCODE+i,(unsigned int)priv->keymap.map[i]));
     }
 
     memset(modMap, 0, sizeof(modMap));
@@ -137,11 +144,13 @@ jstkInitKeys(DeviceIntPtr pJstk, JoystickDevPtr priv)
  ***************************************************************************
  */
 void
-jstkGenerateKeys(DeviceIntPtr device, KEYSCANCODES keys, char pressed)
+jstkGenerateKeys(LocalDevicePtr device, KEYSCANCODES keys, char pressed)
 {
     int i;
     unsigned int k;
 
+    if (device == NULL)
+        return;
     for (i=0;i<MAXKEYSPERBUTTON;i++) {
         if (pressed != 0) 
             k = keys[i];
@@ -151,9 +160,145 @@ jstkGenerateKeys(DeviceIntPtr device, KEYSCANCODES keys, char pressed)
             k = k + MIN_KEYCODE;
             DBG(2, ErrorF("Generating key %s event with keycode %d\n", 
                 (pressed)?"press":"release", k));
-            xf86PostKeyboardEvent(device, k, pressed);
+            xf86PostKeyboardEvent(device->dev, k, pressed);
+        }
+    }
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * jstkKeyboardDeviceControlProc --
+ *
+ * Handles the initialization, etc. of the keyboard device
+ *
+ ***************************************************************************
+ */
+static Bool
+jstkKeyboardDeviceControlProc(DeviceIntPtr       dev,
+                              int                what)
+{
+    JoystickDevPtr priv  = (JoystickDevPtr)XI_PRIVATE(dev);
+    if (!priv) {
+        DBG(2, ErrorF("jstkKeyboardDeviceControlProc: priv == NULL\n"));
+        return !Success;
+    }
+    switch (what) {
+    case DEVICE_INIT:
+        DBG(2, ErrorF("jstkKeyboardDeviceControlProc what=DEVICE_INIT\n"));
+        if (InitFocusClassDeviceStruct(dev) == FALSE) {
+            ErrorF("unable to init Focus class device\n");
+            return !Success;
         }
+        if (jstkInitKeys(dev, priv) != Success)
+            return !Success;
+        break;
+    case DEVICE_ON:
+        DBG(2, ErrorF("jstkKeyboardDeviceControlProc what=DEVICE_ON\n"));
+        dev->public.on = TRUE;
+        break;
+    case DEVICE_OFF:
+        DBG(2, ErrorF("jstkKeyboardDeviceControlProc what=DEVICE_OFF\n"));
+        dev->public.on = FALSE;
+        break;
+    case DEVICE_CLOSE:
+        DBG(2, ErrorF("jstkKeyboardDeviceControlProc what=DEVICE_CLOSE\n"));
+        dev->public.on = FALSE;
+        break;
     }
+
+    return Success;
 }
 
 
+/*
+ ***************************************************************************
+ *
+ * jstkKeyboardPreInit --
+ *
+ * Called manually to create a keyboard device for the joystick
+ *
+ ***************************************************************************
+ */
+InputInfoPtr
+jstkKeyboardPreInit(InputDriverPtr drv, IDevPtr _dev, int flags)
+{
+    LocalDevicePtr local = NULL;
+    IDevPtr dev = NULL;
+    char name[512] = {0};
+
+    local = xf86AllocateInput(drv, 0);
+    if (!local) {
+        goto SetupProc_fail;
+    }
+
+    dev = xcalloc(sizeof(IDevRec), 1);
+    strcpy(name, _dev->identifier);
+    strcat(name, " (keys)");
+    dev->identifier = xstrdup(name);
+    dev->driver = xstrdup(_dev->driver);
+    dev->commonOptions = xf86optionListDup(_dev->commonOptions);
+    dev->extraOptions = xf86optionListDup(_dev->extraOptions);
+
+    local->name   = dev->identifier;
+    local->flags  = XI86_KEYBOARD_CAPABLE;
+    local->device_control = jstkKeyboardDeviceControlProc;
+    local->read_input = NULL;
+    local->close_proc = NULL;
+    local->control_proc = NULL;
+    local->switch_mode = NULL;
+    local->conversion_proc = NULL;
+    local->fd = -1;
+    local->dev = NULL;
+    local->private = NULL;
+    local->type_name = XI_KEYBOARD;
+    local->history_size = 0;
+    local->always_core_feedback = 0;
+    local->conf_idev = dev;
+
+    xf86CollectInputOptions(local, NULL, NULL);
+    xf86OptionListReport(local->options);
+    xf86ProcessCommonOptions(local, local->options);
+
+
+    /* return the LocalDevice */
+    local->flags |= XI86_CONFIGURED;
+
+    return (local);
+
+SetupProc_fail:
+    if (local)
+        local->private = NULL;
+    if (dev) {
+        if (dev->identifier) xfree(dev->identifier);
+        if (dev->driver) xfree(dev->driver);
+        xfree(dev);
+    }
+    return NULL;
+}
+
+
+/*
+ ***************************************************************************
+ *
+ * jstkKeyboardUnInit --
+ *
+ * Called when the keyboard slave device gets removed
+ *
+ ***************************************************************************
+ */
+void
+jstkKeyboardUnInit(InputDriverPtr    drv,
+                   LocalDevicePtr    local,
+                   int               flags)
+{
+    JoystickDevPtr device = (JoystickDevPtr) local->private;
+    DBG(2, ErrorF("jstkKeyboardUnInit.\n"));
+
+    device->keyboard_device = NULL;
+    local->private = NULL;
+
+    xf86DeleteInput(local, 0);
+}
+
diff --git a/src/jstk_key.h b/src/jstk_key.h
index df19f65..1791c35 100644
--- a/src/jstk_key.h
+++ b/src/jstk_key.h
@@ -25,7 +25,9 @@
 #ifndef __JSTK_KEY_H_INCLUDED__
 #define __JSTK_KEY_H_INCLUDED__
 
-int jstkInitKeys(DeviceIntPtr pJstk, JoystickDevPtr priv);
+void jstkGenerateKeys(LocalDevicePtr device, KEYSCANCODES keys, char pressed);
 
+InputInfoPtr jstkKeyboardPreInit(InputDriverPtr drv, IDevPtr dev, int flags);
+void jstkKeyboardUnInit(InputDriverPtr drv, LocalDevicePtr local, int flags);
 
 #endif