Initial commit of Linux plugin

git-svn-id: file:///home/sven/projects/JOGL/git-svn/svn-server-sync/jinput/trunk@23 e343933a-64c8-49c5-92b1-88f2ce3e89e8

23 files changed, 4649 insertions, 0 deletions

diff --git a/plugins/linux/src/java/net/java/games/input/LinuxAxis.java b/plugins/linux/src/java/net/java/games/input/LinuxAxis.java
new file mode 100644
index 0000000..28cb9d9
--- /dev/null
+++ b/plugins/linux/src/java/net/java/games/input/LinuxAxis.java
@@ -0,0 +1,192 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+package net.java.games.input;
+
+import net.java.games.input.AbstractAxis;
+import net.java.games.input.LinuxDevice;
+
+/** Represents an Axis absolute or relative
+ *
+ * @author Jeremy Booth ([email protected])
+ */
+public class LinuxAxis extends AbstractAxis {
+    
+    /** The controller this axis is part of */
+    private LinuxDevice controller;
+    /** The native ID of this axis */
+    private int axisID;
+    /** The null zone, defaulted to 0 */
+    private float nullZone = 0.0f;
+    /** Is this axis analog */
+    private boolean isAnalog = true;
+    /** Are the values returned by getPollData normalised */
+    private boolean isNormalized = false;
+    /** Is this a relative axis */
+    private boolean isRelative = false;
+    /** Should we normalise the value before returning it in getPollData */
+    private boolean needsNormalising = false;
+    /** The minimum possible axis value (not always used) */    
+    private float minAxisValue;
+    /** The maximum possibe axis value (not always used */
+    private float maxAxisValue;
+    /** The current value of the axis */
+    private float value = 0.0f;
+
+    /**
+     * Creates a new instance of LinuxAxis
+     * @param controller The parent Controller
+     * @param axisID The native ID of this axis
+     * @param name The name of this axis
+     * @param id The Axis.Identifier of this axis
+     * @param deadzone The deadzone (null zone) of this axis
+     * @param isAnalog Is this axis analog
+     * @param isNormalized Is this axis normalised
+     * @param isRelative Is this axis relative
+     */
+    public LinuxAxis(LinuxDevice controller, int axisID, String name, Identifier id, float deadzone, boolean isAnalog, boolean isNormalized, boolean isRelative) {
+        super(name, id);
+        this.controller = controller;
+        this.axisID = axisID;
+        this.nullZone = deadzone;
+        this.isAnalog = isAnalog;
+        this.isNormalized = isNormalized;
+        this.isRelative = isRelative;
+        
+    }
+
+    /** Creates a new instance of LinuxAxis, it will auto normalise the data based on
+     * the minimum and maximum values provided
+     * @param controller The parent Controller
+     * @param axisID The native ID of this axis
+     * @param name The name of this axis
+     * @param id The Axis.Identifier of this axis
+     * @param deadzone The deadzone (null zone) of this axis
+     * @param isAnalog Is this axis analog
+     * @param isRelative Is this axis relative
+     * @param minAxisValue Minimum value that the native library will return for this axis
+     * @param maxAxisValue Maximum value that the native library will return for this axis
+     */
+    public LinuxAxis(LinuxDevice controller, int axisID, String name, Identifier id, float deadzone, boolean isAnalog, boolean isRelative, float minAxisValue, float maxAxisValue) {
+        super(name, id);
+        
+        this.controller = controller;
+        this.axisID = axisID;
+        this.nullZone = deadzone;
+        this.isAnalog = isAnalog;
+        this.isNormalized = false;
+        this.isRelative = isRelative;
+        this.needsNormalising = true;
+        this.minAxisValue = minAxisValue;
+        this.maxAxisValue = maxAxisValue;
+        
+    }
+    
+     /** Returns <code>true</code> if data returned from <code>poll</code>
+      * is relative to the last call, or <code>false</code> if data
+      * is absolute.
+      * @return Returns <code>true</code> if data returned from <code>poll</code>
+      * is relative to the last call, or <code>false</code> if data
+      * is absolute.
+      */
+    public boolean isRelative() {
+        return isRelative;
+    }
+    
+    /** Returns the suggested dead zone for this axis.  Dead zone is the
+     * amount polled data can vary before considered a significant change
+     * in value.  An application can safely ignore changes less than this
+     * value in the positive or negative direction.
+     * @return 0.0f by default, can be overridden
+     */
+    public float getDeadZone() {
+        return nullZone;
+    }
+    
+    /** Returns whether or not the axis is analog, or false if it is digital.
+     * @return false by default, can be overridden
+     */
+    public boolean isAnalog() {
+        return isAnalog;
+    }
+    
+    /** Returns the data from the last time the control has been polled.
+     * If this axis is a button, the value returned will be either 0.0f or 1.0f.
+     * If this axis is normalized, the value returned will be between -1.0f and
+     * 1.0f.
+     * @return 0.0f by default, can be overridden
+     */
+    public float getPollData() {  
+        if(isPolling()) {
+            updateValue();
+        }
+        return value;
+    }
+    
+    /** Update this axis data from the latest native poll value
+     */    
+    private void updateValue() {
+        if(isAnalog) {
+            float tempVal;
+            
+            if(isRelative) {
+                tempVal = (float)controller.getRelAxisValue(axisID);
+            } else {
+                tempVal = (float)controller.getAbsAxisValue(axisID);
+            }
+            if(needsNormalising) {
+                if(isRelative) {
+                    if(tempVal>1) {
+                        tempVal = 1;
+                    } else if(tempVal<-1) {
+                        tempVal = -1;
+                    }
+                    value = tempVal;
+                } else {
+                    //float center = (minAxisValue + maxAxisValue) / 2;
+                    //value = (tempVal - center) / center;
+                    float center = ((maxAxisValue - minAxisValue)/2);
+                    value = (((tempVal - minAxisValue) - center) / center);
+                    //System.out.println("tempVal: " + tempVal + " minAxisValue: " + minAxisValue + " maxAxisValue: " + maxAxisValue + " center: " + center + " value: " + value);
+                    //System.out.flush();
+                }
+            } else {
+                value = tempVal;
+            }
+        } else {
+            value = (float)controller.getButtonValue(axisID);
+        }
+    }
+    
+    /** Returns whether or not data polled from this axis is normalized
+     * between the values of -1.0f and 1.0f.
+     * @return true by default, can be overridden
+     */
+    public boolean isNormalized() {
+        return (isNormalized || needsNormalising);
+    }
+    
+}
diff --git a/plugins/linux/src/java/net/java/games/input/LinuxDevice.java b/plugins/linux/src/java/net/java/games/input/LinuxDevice.java
new file mode 100644
index 0000000..9ca6016
--- /dev/null
+++ b/plugins/linux/src/java/net/java/games/input/LinuxDevice.java
@@ -0,0 +1,956 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+package net.java.games.input;
+
+import net.java.games.input.AbstractController;
+import net.java.games.input.Axis;
+import net.java.games.input.Controller;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * Represents a device that is not a keyboard or mouse.
+ * @author Jeremy Booth ([email protected])
+ */
+public class LinuxDevice extends AbstractController {
+    
+    /** The name of the device
+     */    
+    private String name;
+    /** The native ID of the device
+     */    
+    private int nativeID;
+    /** The port type the device is attached to.
+     */    
+    private PortType portType;
+    /** List of buttons the device has
+     */    
+    private LinuxAxis[] buttons;
+    /** List of relative axes the device has
+     */    
+    private LinuxAxis[] relAxes;
+    /** List of absolute axes the device has
+     */    
+    private LinuxAxis[] absAxes;
+    /** List of coolie hats the device has
+     */    
+    private LinuxHat[] hats;
+    /** The id's of the coolie hat axes
+     */    
+    private int hatAxisIDs[] = new int[8];
+    /** The number of buttons the device has
+     */    
+    private int numButtons;
+    /** The number of relative axes the device has
+     */    
+    private int numRelAxes;
+    /** The number of absolute axes the device has
+     */    
+    private int numAbsAxes;
+    /** The number of coolie hats the device has
+     */    
+    private int numHats=0;
+    /** The native button values.
+     */    
+    private int[] buttonData;
+    /** The native relative axes values
+     */    
+    private int[] relAxesData;
+    /** The native absolute axis values
+     */    
+    private int[] absAxesData;
+    /** A guess at the device type.
+     */    
+    private Type typeGuess;
+    /** An array of the list of axes this device has
+     */    
+    private ArrayList axesArray = new ArrayList();
+    
+    /** Creates a new instance of LinuxDevice
+     * @param nativeID The native ID of this device
+     * @param name The name of this device
+     * @param numButtons The number of buttons the devices has
+     * @param numRelAxes The number of raltive axes this device has
+     * @param numAbsAxes The number of absolute axes this device has
+     */
+    public LinuxDevice(int nativeID, String name, int numButtons, int numRelAxes, int numAbsAxes) {
+        super(name);
+        
+        children = NO_CONTROLLERS;
+        rumblers = NO_RUMBLERS;
+
+        this.nativeID = nativeID;
+        
+        portType = LinuxNativeTypesMap.getPortType(getNativePortType(nativeID));
+        
+        for(int i=0;i<8;i++) {
+            hatAxisIDs[i] = -1;
+        }
+        
+        this.numButtons = numButtons;
+        this.numRelAxes = numRelAxes;
+        this.numAbsAxes = numAbsAxes;
+        this.numHats = 0;
+        
+        buttonData = new int[numButtons];
+        relAxesData = new int[numRelAxes];
+        absAxesData = new int[numAbsAxes];
+        
+        createButtons(numButtons);
+        createRelAxes(numRelAxes);
+        createAbsAxes(numAbsAxes);
+        createHats();
+        
+        /*ArrayList tempAxes = new ArrayList();
+        for(int i=0;i<numButtons;i++) {
+            Axis tempAxis = buttons[i];
+            if(tempAxis!=null) {
+                tempAxes.add(tempAxis);
+            }
+        }
+        for(int i=0;i<numRelAxes;i++) {
+            Axis tempAxis = relAxes[i];
+            if(tempAxis!=null) {
+                tempAxes.add(tempAxis);
+            }
+        }
+        for(int i=0;i<numAbsAxes;i++) {
+            Axis tempAxis = absAxes[i];
+            if(tempAxis!=null) {
+                tempAxes.add(tempAxis);
+            }
+        }
+        
+        axes = (Axis[]) tempAxes.toArray(axes);*/
+        for(int i=0;i<numAbsAxes;i++) {
+            if(absAxes[i]!=null) {
+                axesArray.add(absAxes[i]);
+            }
+        }
+        for(int i=0;i<numRelAxes;i++) {
+            if(relAxes[i]!=null) {
+                axesArray.add(relAxes[i]);
+            }
+        }
+        for(int i=0;i<numHats;i++) {
+            if(hats[i]!=null) {
+                axesArray.add(hats[i]);
+            }
+        }
+        for(int i=0;i<numButtons;i++) {
+            if(buttons[i]!=null) {
+                axesArray.add(buttons[i]);
+            }
+        }
+        axes = (Axis[]) axesArray.toArray(axes);
+        
+        guessType();
+    }
+    
+    /*public Axis[] getAxes(){
+        Axis retval[] = new Axis[0];
+        retval = (Axis []) axesArray.toArray(retval);
+        return retval;
+    }*/
+    
+    /**
+     * Returns the port type that this device is connected to.
+     * @return The port type
+     */    
+    public PortType getPortType() {
+        return portType;
+    }
+    
+    /** Create the buttons for the device
+     * @param numButtons The number of buttons the device has
+     */    
+    private void createButtons(int numButtons) {
+        
+        int supportedButtons[] = new int[numButtons];
+        getSupportedButtons(supportedButtons);
+        buttons = new LinuxAxis[numButtons];
+        for(int i=0;i<numButtons;i++) {
+            buttons[i] = createButton(i, supportedButtons[i]);
+            //axesArray.add(buttons[i]);
+        }
+    }
+    
+    /** Create the relative axes for the device
+     * @param numRelAxes The number of relative axes the device has
+     */    
+    private void createRelAxes(int numRelAxes) {
+        int supportedRelAxes[] = new int[numRelAxes];
+        getSupportedRelAxes(supportedRelAxes);
+        relAxes = new LinuxAxis[numRelAxes];
+        for(int i=0;i<numRelAxes;i++) {
+            relAxes[i] = createRelAxis(i, supportedRelAxes[i]);
+            //axesArray.add(relAxes[i]);
+        }
+    }
+
+    /** Create the absolute axes for the device
+     * @param numAbsAxes The number of absolute axes the device has
+     */    
+    private void createAbsAxes(int numAbsAxes) {
+        int supportedAbsAxes[] = new int[numAbsAxes];
+        getSupportedAbsAxes(supportedAbsAxes);
+        absAxes = new LinuxAxis[numAbsAxes];
+        for(int i=0;i<numAbsAxes;i++) {
+            // Nasy code here
+            // Hats underlinux are 2 axis, combine them
+            if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT0X) {
+                hatAxisIDs[0] = i;
+            } else if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT0Y) {
+                hatAxisIDs[1] = i;
+            } else if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT1X) {
+                hatAxisIDs[2] = i;
+            } else if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT1Y) {
+                hatAxisIDs[3] = i;
+            } else if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT2X) {
+                hatAxisIDs[4] = i;
+            } else if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT2Y) {
+                hatAxisIDs[5] = i;
+            } else if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT3X) {
+                hatAxisIDs[6] = i;
+            } else if(supportedAbsAxes[i] == NativeDefinitions.ABS_HAT3Y) {
+                hatAxisIDs[7] = i;
+            } else {
+                absAxes[i] = createAbsAxis(i, supportedAbsAxes[i]);
+                //axesArray.add(absAxes[i]);
+            }
+        }
+        
+    }
+    
+    /** Create the coolie hats for the device
+     */    
+    private void createHats() {
+        LinuxHat tempHats[] = new LinuxHat[4];
+        for(int i=0;i<4;i++) {
+            int x = i*2;
+            int y= x+1;
+            //Check we have at least one hat axis (can hats have just one axis?
+            if((hatAxisIDs[x]!=-1) || (hatAxisIDs[y]!=-1)) {
+                String hatName = "Hat " + i;
+                tempHats[numHats] = createHat(hatName, hatAxisIDs[x], hatAxisIDs[y]);
+                numHats++;
+            }
+        }
+        hats = new LinuxHat[numHats];
+        for(int i=0;i<numHats;i++) {
+            hats[i] = tempHats[i];
+            //axesArray.add(hats[i]);
+        }
+    }
+    
+    /*private void guessType() {
+        int joystickCharacteristic=0;
+        int gamepadCharacteristic=0;
+
+        int supportedButtons[] = new int[numButtons];
+        getSupportedButtons(supportedButtons);
+
+        for(int i=0;i<numButtons;i++) {
+            switch (supportedButtons[i]) {
+                case NativeDefinitions.BTN_TRIGGER : 
+                case NativeDefinitions.BTN_THUMB : 
+                case NativeDefinitions.BTN_THUMB2 : 
+                case NativeDefinitions.BTN_TOP : 
+                case NativeDefinitions.BTN_TOP2 : 
+                case NativeDefinitions.BTN_PINKIE : 
+                case NativeDefinitions.BTN_BASE : 
+                case NativeDefinitions.BTN_BASE2 : 
+                case NativeDefinitions.BTN_BASE3 : 
+                case NativeDefinitions.BTN_BASE4 : 
+                case NativeDefinitions.BTN_BASE5 : 
+                case NativeDefinitions.BTN_BASE6 : 
+                case NativeDefinitions.BTN_DEAD : 
+                    joystickCharacteristic++;
+                    break;
+                case NativeDefinitions.BTN_A : 
+                case NativeDefinitions.BTN_B : 
+                case NativeDefinitions.BTN_C : 
+                case NativeDefinitions.BTN_X : 
+                case NativeDefinitions.BTN_Y : 
+                case NativeDefinitions.BTN_Z : 
+                case NativeDefinitions.BTN_TL : 
+                case NativeDefinitions.BTN_TR : 
+                case NativeDefinitions.BTN_TL2 : 
+                case NativeDefinitions.BTN_TR2 : 
+                case NativeDefinitions.BTN_SELECT : 
+                case NativeDefinitions.BTN_MODE : 
+                case NativeDefinitions.BTN_THUMBL : 
+                case NativeDefinitions.BTN_THUMBR :
+                    gamepadCharacteristic++;
+                    break;
+                default:
+                    // no sweat, it's non of the above, erg                    
+            }
+        }
+        if(joystickCharacteristic > gamepadCharacteristic) {
+            typeGuess = Type.STICK;
+        } else {
+            typeGuess = Type.GAMEPAD;
+        }
+    }*/
+    
+    /** Take a guess at the device type.
+     */    
+    private void guessType() {
+        int joystickCharacteristic=0;
+        int digitiserCharacteristic=0;
+        int gamepadCharacteristic=0;
+        int miscCharacteristic=0;
+        int mouseCharacteristic=0;
+
+        int supportedButtons[] = new int[numButtons];
+        getSupportedButtons(supportedButtons);
+
+        for(int i=0;i<numButtons;i++) {
+            switch (supportedButtons[i]) {
+                case NativeDefinitions.BTN_TRIGGER : 
+                case NativeDefinitions.BTN_THUMB : 
+                case NativeDefinitions.BTN_THUMB2 : 
+                case NativeDefinitions.BTN_TOP : 
+                case NativeDefinitions.BTN_TOP2 : 
+                case NativeDefinitions.BTN_PINKIE : 
+                case NativeDefinitions.BTN_BASE : 
+                case NativeDefinitions.BTN_BASE2 : 
+                case NativeDefinitions.BTN_BASE3 : 
+                case NativeDefinitions.BTN_BASE4 : 
+                case NativeDefinitions.BTN_BASE5 : 
+                case NativeDefinitions.BTN_BASE6 : 
+                case NativeDefinitions.BTN_DEAD : 
+                    joystickCharacteristic++;
+                    break;
+                case NativeDefinitions.BTN_A : 
+                case NativeDefinitions.BTN_B : 
+                case NativeDefinitions.BTN_C : 
+                case NativeDefinitions.BTN_X : 
+                case NativeDefinitions.BTN_Y : 
+                case NativeDefinitions.BTN_Z : 
+                case NativeDefinitions.BTN_TL : 
+                case NativeDefinitions.BTN_TR : 
+                case NativeDefinitions.BTN_TL2 : 
+                case NativeDefinitions.BTN_TR2 : 
+                case NativeDefinitions.BTN_SELECT : 
+                case NativeDefinitions.BTN_MODE : 
+                case NativeDefinitions.BTN_THUMBL : 
+                case NativeDefinitions.BTN_THUMBR :
+                    gamepadCharacteristic++;
+                    break;
+                case NativeDefinitions.BTN_0 : 
+                case NativeDefinitions.BTN_1 : 
+                case NativeDefinitions.BTN_2 : 
+                case NativeDefinitions.BTN_3 : 
+                case NativeDefinitions.BTN_4 : 
+                case NativeDefinitions.BTN_5 : 
+                case NativeDefinitions.BTN_6 : 
+                case NativeDefinitions.BTN_7 : 
+                case NativeDefinitions.BTN_8 : 
+                case NativeDefinitions.BTN_9 : 
+                    miscCharacteristic++;
+                    break;
+                case NativeDefinitions.BTN_LEFT : 
+                case NativeDefinitions.BTN_RIGHT : 
+                case NativeDefinitions.BTN_MIDDLE : 
+                case NativeDefinitions.BTN_SIDE : 
+                case NativeDefinitions.BTN_EXTRA : 
+                case NativeDefinitions.BTN_FORWARD : 
+                case NativeDefinitions.BTN_BACK : 
+                    mouseCharacteristic++;
+                    break;
+                case NativeDefinitions.BTN_TOOL_PEN :
+                case NativeDefinitions.BTN_TOOL_RUBBER : 
+                case NativeDefinitions.BTN_TOOL_BRUSH : 
+                case NativeDefinitions.BTN_TOOL_PENCIL : 
+                case NativeDefinitions.BTN_TOOL_AIRBRUSH : 
+                case NativeDefinitions.BTN_TOOL_FINGER : 
+                case NativeDefinitions.BTN_TOOL_MOUSE : 
+                case NativeDefinitions.BTN_TOOL_LENS : 
+                case NativeDefinitions.BTN_TOUCH : 
+                case NativeDefinitions.BTN_STYLUS : 
+                case NativeDefinitions.BTN_STYLUS2 : 
+                    digitiserCharacteristic++;
+                    break;
+                default:
+                    // no sweat, it's non of the above, erg                    
+            }
+        }
+        if((joystickCharacteristic >= digitiserCharacteristic) && 
+           (joystickCharacteristic >= gamepadCharacteristic) &&
+           (joystickCharacteristic >= miscCharacteristic) &&
+           (joystickCharacteristic >= mouseCharacteristic)) {
+            typeGuess = Type.STICK;
+        } else if((gamepadCharacteristic >= digitiserCharacteristic) && 
+                  (gamepadCharacteristic >= joystickCharacteristic) &&
+                  (gamepadCharacteristic >= miscCharacteristic) &&
+                  (gamepadCharacteristic >= mouseCharacteristic)) {
+            typeGuess = Type.GAMEPAD;
+        } else if((digitiserCharacteristic >= gamepadCharacteristic) && 
+                  (digitiserCharacteristic >= joystickCharacteristic) &&
+                  (digitiserCharacteristic >= miscCharacteristic) &&
+                  (digitiserCharacteristic >= mouseCharacteristic)) {
+            typeGuess = Type.TRACKPAD;
+        } else if((miscCharacteristic >= gamepadCharacteristic) && 
+                  (miscCharacteristic >= joystickCharacteristic) &&
+                  (miscCharacteristic >= miscCharacteristic) &&
+                  (miscCharacteristic >= mouseCharacteristic)) {
+            // I'm not sure what one of these would be, but it has axis other 
+            // wise a LinuxKeyboard would have been constructed, so assume its
+            // some kind of stick;
+            typeGuess = Type.STICK;
+        } else if((mouseCharacteristic >= digitiserCharacteristic) && 
+                  (mouseCharacteristic >= joystickCharacteristic) &&
+                  (mouseCharacteristic >= miscCharacteristic) &&
+                  (mouseCharacteristic >= gamepadCharacteristic)) {
+            // We shouldn't ever get here, as a mouse should have constructed
+            // a LinuxMouse object, but you never know
+            typeGuess = Type.MOUSE;
+        }
+    }
+    
+    /** Create an button for the device
+     * @param buttonNumber The button number
+     * @param nativeButtonType The type of button
+     * @return The new button
+     */    
+    private LinuxAxis createButton(int buttonNumber, int nativeButtonType) {
+        Axis.Identifier id = LinuxNativeTypesMap.getButtonID(nativeButtonType);
+        String name = LinuxNativeTypesMap.getButtonName(nativeButtonType);
+        if(name == null) {
+            name = "Uknown button";
+            id = new ButtonID(name);
+        }
+        
+        return new LinuxAxis(this, buttonNumber, name, id, 0, false, true, false);
+    }
+    
+    /** Create a relative axis for the device
+     * @param axisNumber The native axis id
+     * @param nativeType The native type
+     * @return The new axis
+     */    
+    private LinuxAxis createRelAxis(int axisNumber, int nativeType) {
+        Axis.Identifier id = LinuxNativeTypesMap.getRelAxisID(nativeType);
+        String name = LinuxNativeTypesMap.getRelAxisName(nativeType);
+        
+        // This is done to be like the windows version
+        return new LinuxAxis(this, axisNumber, name, id, 0, true, true, 0, 0);
+        
+        //this is what should be done
+        // return new LinuxAxis(this, axisNumber, name, id, 0, true, false, true);
+    }
+    
+    /** Create an absolute axis for the device
+     * @param axisNumber The native axis number
+     * @param nativeType The native tpye
+     * @return The new axis
+     */    
+    private LinuxAxis createAbsAxis(int axisNumber, int nativeType) {
+        Axis.Identifier id = LinuxNativeTypesMap.getAbsAxisID(nativeType);
+        String name = LinuxNativeTypesMap.getAbsAxisName(nativeType);
+        
+        // Work around for a kernel level (I think) bug that incorrectly reports
+        // the third axis as a rudder not a throttle on analog (gameport) 3 axis
+        // 4 button sticks
+        if((getName().equals("Analog 3-axis 4-button joystick")) && (portType == Controller.PortType.GAME)) {
+            if((id == Axis.Identifier.RZ) && (name.equals("Rudder"))) {
+                id = Axis.Identifier.SLIDER;
+                name = "Throttle";
+            }
+        }
+        
+        return new LinuxAxis(this, axisNumber, name, id, getAbsAxisFuzz(axisNumber), true, false, getAbsAxisMinimum(axisNumber), getAbsAxisMaximum(axisNumber));
+        //return new LinuxAxis(this, axisNumber, name, id, getAbsAxisFuzz(axisNumber), true, false, false);
+    }
+    
+    /** Create a hat for the device
+     * @param name The name of the hat to create
+     * @param xAxisID The axis that is the hats X axis
+     * @param yAxisID The axis that is the hats Y axis
+     * @return The new hat
+     */    
+    private LinuxHat createHat(String name, int xAxisID, int yAxisID) {
+        return new LinuxHat(this, name, xAxisID, yAxisID);
+    }
+    
+    /** Polls axes for data.  Returns false if the controller is no longer valid.
+     * Polling reflects the current state of the device when polled.
+     * @return false if the controller is no longer valid.
+     */
+    public boolean poll() {
+        int retval = nativePoll(nativeID, buttonData, relAxesData, absAxesData);
+        if(retval>=0) return true;
+        return false;
+    }
+    
+    /**
+     * Retursn the value of a particular button or key
+     * @param buttonID The button/key to check
+     * @return The value fo the button/key
+     */    
+    public float getButtonValue(int buttonID) {
+        if(buttonData[buttonID]>0) return 1.0f;
+        return 0.0f;
+    }
+    
+    /**
+     * Returns the value of a particular absolute axis
+     * @param axisID The axis id
+     * @return The axis value
+     */    
+    public float getAbsAxisValue(int axisID) {
+        return (float) absAxesData[axisID];
+    }
+    
+    /**
+     * Returns the value of the requested relative axis.
+     * @param axisID The native axis ID.
+     * @return The value of the axis
+     */    
+    public float getRelAxisValue(int axisID) {
+        return (float) relAxesData[axisID];
+    }
+    
+    /**
+     * Gets the axis fuzz, used for nullzone information
+     * @param axisID The axis to get the fuzz for
+     * @return The axis fuzz.
+     */    
+    public float getAbsAxisFuzz(int axisID) {
+        return (float) getNativeAbsAxisFuzz(nativeID, axisID);
+    }
+    
+    /**
+     * Returns the maximum value for the requested axis
+     * @param axisID The native ID of the axis to check
+     * @return The maximum value
+     */    
+    public float getAbsAxisMaximum(int axisID) {
+        return (float) getNativeAbsAxisMaximum(nativeID, axisID);
+    }
+
+    /**
+     * The minimum value the requested axis can have
+     * @param axisID The native axis ID
+     * @return The minimum axis value
+     */    
+    public float getAbsAxisMinimum(int axisID) {
+        return (float) getNativeAbsAxisMinimum(nativeID, axisID);
+    }
+
+    /** Return the enumeration of supported button types for this device
+     * @param supportedButtons Array to populate
+     */    
+    private void getSupportedButtons(int supportedButtons[]) {
+        getNativeSupportedButtons(nativeID, supportedButtons);
+    }
+
+    /** Return the enumeration of supported absolute axis types for this device
+     * @param suportedAbsAxes The array to populate
+     */    
+    private void getSupportedAbsAxes(int suportedAbsAxes[]) {
+        getNativeSupportedAbsAxes(nativeID, suportedAbsAxes);
+    }
+
+    /** Return the enumeration of supported relative axis types for this device
+     * @param supportedRelAxes The array to populate
+     */    
+    private void getSupportedRelAxes(int supportedRelAxes[]) {
+        getNativeSupportedRelAxes(nativeID, supportedRelAxes);
+    }
+    
+    /** Native call to get the supported absolute axes for a device
+     * @param deviceID The native device number
+     * @param supportedAbsAxes aray to populate
+     */    
+    private native void getNativeSupportedAbsAxes(int deviceID, int supportedAbsAxes[]);
+    /** Native call to get the supported relative axes for a device
+     * @param deviceID The native device ID
+     * @param supportedRelAxes the array to populate
+     */    
+    private native void getNativeSupportedRelAxes(int deviceID, int supportedRelAxes[]);
+    /** Native call to get the supported buttons for a device
+     * @param deviceID The native device ID
+     * @param supportedButtons The array to populate
+     */    
+    private native void getNativeSupportedButtons(int deviceID, int supportedButtons[]);
+    /** Call to poll the device at the native library
+     * @param deviceID The native device ID
+     * @param buttonData Array to populate with button values
+     * @param relAxesData Array to populate with relative axes values
+     * @param absAxesData Array to populate with absolute axes values
+     * @return the number of events read
+     */    
+    private native int nativePoll(int deviceID, int buttonData[], int relAxesData[], int absAxesData[]);
+    /** Returns the fuzz of an axis fro mthe native lib
+     * @param deviceID The native device id
+     * @param axisID The native axis ID
+     * @return The fuzz
+     */    
+    private native int getNativeAbsAxisFuzz(int deviceID, int axisID);
+    /** Gets the maximum value for an absloute axis fr omthe native library
+     * @param deviceID The native device ID
+     * @param axisID The native axis ID
+     * @return The Max value
+     */    
+    private native int getNativeAbsAxisMaximum(int deviceID, int axisID);
+    /** Gets the minimum value for an absloute axis from the native library
+     * @param deviceID The native device ID
+     * @param axisID The native axis number
+     * @return The min value
+     */    
+    private native int getNativeAbsAxisMinimum(int deviceID, int axisID);
+    /** Gets the port type from the native lib
+     * @param deviceID The device to get the port type for
+     * @return The port type
+     */    
+    private native int getNativePortType(int deviceID);
+    
+    /**
+     * A device that represents a joystick coolie hat.
+     * @author Jeremy Booth ([email protected])
+     */
+    public static class LinuxHat extends AbstractAxis {
+        
+        /** The parent controller
+         */        
+        private LinuxDevice controller;
+        
+        /** The xAxis for this hat
+         */        
+        private int xAxisID;
+        
+        /** The y axis for this hat
+         */        
+        private int yAxisID;
+        
+        /** The last polled value of this hat
+         */        
+        private float value;
+        
+        /**
+         * Creates a new instance of LinuxHat, coolie hats under linux are reported as
+         * two independant axis, this class is responsible for combining the axis values
+         * and returning a value appropriate for a coolie hat.
+         * @param controller The parent controller
+         * @param name The name of this hat
+         * @param xAxisID The X axis native axis ID
+         * @param yAxisID The Y axis native axis ID
+         */
+        public LinuxHat(LinuxDevice controller, String name, int xAxisID, int yAxisID) {
+            super(name, Axis.Identifier.POV);
+            
+            this.controller = controller;
+            this.xAxisID = xAxisID;
+            this.yAxisID = yAxisID;
+            
+            //System.err.println("New hat: " + name + " created");
+            //System.err.flush();
+        }
+        
+        /** Returns <code>true</code> if data returned from <code>poll</code>
+         * is relative to the last call, or <code>false</code> if data
+         * is absolute.
+         * @return Returns <code>true</code> if data returned from <code>poll</code>
+         * is relative to the last call, or <code>false</code> if data
+         * is absolute.
+         */
+        public boolean isRelative() {
+            return false;
+        }
+        
+        /** Returns true if this axis is analog
+         * @return Always retursn true as coolie hats are analog under linux
+         */        
+        public boolean isAnalog() {
+            return false;
+        }
+        
+        /**
+         * Retursn true if this axis is normalised
+         * @return Always returns true as linux hats are normalised
+         */        
+        public boolean isNormalised() {
+            return true;
+        }
+        
+        /**
+         * Returns the current value of this axis
+         * @return The current axis value
+         */        
+        public float getPollData() {
+            //System.err.println("getPollData called, isPolling: " + isPolling());
+            //System.err.flush();
+            if(isPolling()) { updateData(); };
+            return value;
+        }
+        
+        /** Gets the data fro mthe native level and combines it to the hats value
+         */        
+        private void updateData() {
+            //System.err.println("updateData called");
+            //System.err.flush();
+            int newXAxisValue = (int)controller.getAbsAxisValue(xAxisID);
+            int newYAxisValue = (int)controller.getAbsAxisValue(yAxisID);
+            
+            //System.err.println("newXAxisValue: " + newXAxisValue + " newYAxisValue: " + newYAxisValue);
+            
+            if((newXAxisValue == 0) && (newYAxisValue == 0)) {
+                value = POV.OFF;
+            } else if((newXAxisValue == 32767) && (newYAxisValue == 32767)) {
+                value = POV.UP_RIGHT;
+            } else if((newXAxisValue == 32767) && (newYAxisValue == 0)) {
+                value = POV.RIGHT;
+            } else if((newXAxisValue == 32767) && (newYAxisValue == -32767)) {
+                value = POV.DOWN_RIGHT;
+            } else if((newXAxisValue == 0) && (newYAxisValue == -32767)) {
+                value = POV.DOWN;
+            } else if((newXAxisValue == -32767) && (newYAxisValue == -32767)) {
+                value = POV.DOWN_LEFT;
+            } else if((newXAxisValue == -32767) && (newYAxisValue == 0)) {
+                value = POV.LEFT;
+            } else if((newXAxisValue == -32767) && (newYAxisValue == 32767)) {
+                value = POV.UP_LEFT;
+            } else if((newXAxisValue == 0) && (newYAxisValue == 32767)) {
+                value = POV.UP;
+            }
+            
+            //System.err.println("new value: " + value);
+            //System.err.flush();
+        }
+        
+    }
+    
+    /** Some button ID's specific to linux devices
+     * @author Jeremy Booth ([email protected])
+     */    
+    public static class ButtonID extends Axis.Identifier {
+        
+        /** First device button
+         */        
+        public static final ButtonID BTN_0 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_0));
+        
+        /** Second device button
+         */        
+        public static final ButtonID BTN_1 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_1));
+        
+        /** Thrid device button
+         */        
+        public static final ButtonID BTN_2 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_2));
+        
+        /** Fourth device button
+         */        
+        public static final ButtonID BTN_3 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_3));
+        
+        /** Fifth device button
+         */        
+        public static final ButtonID BTN_4 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_4));
+        
+        /** Sixth device button
+         */        
+        public static final ButtonID BTN_5 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_5));
+        
+        /** Seventh device button
+         */        
+        public static final ButtonID BTN_6 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_6));
+        
+        /** Eighth (had to check that spelling on dictionary.com) device button
+         */        
+        public static final ButtonID BTN_7 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_7));
+        
+        /** Ninth device button
+         */        
+        public static final ButtonID BTN_8 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_8));
+        
+        /** 10th device button
+         */        
+        public static final ButtonID BTN_9 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_9));
+        
+        /** Joystick trigger button
+         */        
+        public static final ButtonID BTN_TRIGGER = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TRIGGER));
+        
+        /** Joystick thumb button
+         */        
+        public static final ButtonID BTN_THUMB = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_THUMB));
+        
+        /** Second joystick thumb button
+         */        
+        public static final ButtonID BTN_THUMB2 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_THUMB2));
+        
+        /** Joystick top button
+         */        
+        public static final ButtonID BTN_TOP = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOP));
+        
+        /** Second joystick top button
+         */        
+        public static final ButtonID BTN_TOP2 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOP2));
+        
+        /** The joystick button you play with with you little finger (Pinkie on *that* side
+         * of the pond :P)
+         */        
+        public static final ButtonID BTN_PINKIE = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_PINKIE));
+        
+        /** Joystick button on the base of the device
+         */        
+        public static final ButtonID BTN_BASE = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_BASE));
+        
+        /** Second joystick button on the base of the device
+         */        
+        public static final ButtonID BTN_BASE2 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_BASE2));
+        
+        /** Thrid joystick button on the base of the device
+         */        
+        public static final ButtonID BTN_BASE3 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_BASE3));
+        
+        /** Fourth joystick button on the base of the device
+         */        
+        public static final ButtonID BTN_BASE4 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_BASE4));
+        
+        /** Fifth joystick button on the base of the device
+         */        
+        public static final ButtonID BTN_BASE5 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_BASE5));
+        
+        /** Sixth joystick button on the base of the device
+         */        
+        public static final ButtonID BTN_BASE6 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_BASE6));
+        
+        /** erm, dunno, but it's in the defines so it might exist.
+         */        
+        public static final ButtonID BTN_DEAD = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_DEAD));
+        
+        /** 'A' button on a gamepad
+         */        
+        public static final ButtonID BTN_A = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_A));
+        
+        /** 'B' button on a gamepad
+         */        
+        public static final ButtonID BTN_B = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_B));
+        
+        /** 'C' button on a gamepad
+         */        
+        public static final ButtonID BTN_C = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_C));
+        
+        /** 'X' button on a gamepad
+         */        
+        public static final ButtonID BTN_X = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_X));
+        
+        /** 'Y' button on a gamepad
+         */        
+        public static final ButtonID BTN_Y = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_Y));
+        
+        /** 'Z' button on a gamepad
+         */        
+        public static final ButtonID BTN_Z = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_Z));
+        
+        /** Left thumb button on a gamepad
+         */        
+        public static final ButtonID BTN_TL = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TL));
+        
+        /** Right thumb button on a gamepad
+         */        
+        public static final ButtonID BTN_TR = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TR));
+        
+        /** Second left thumb button on a gamepad
+         */        
+        public static final ButtonID BTN_TL2 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TL2));
+        
+        /** Second right thumb button on a gamepad
+         */        
+        public static final ButtonID BTN_TR2 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TR2));
+        
+        /** 'Select' button on a gamepad
+         */        
+        public static final ButtonID BTN_SELECT = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_SELECT));
+        
+        /** 'Mode' button on a gamepad
+         */        
+        public static final ButtonID BTN_MODE = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_MODE));
+        
+        /** Another left thumb button on a gamepad (how many thumbs do you have??)
+         */        
+        public static final ButtonID BTN_THUMBL = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_THUMBL));
+        
+        /** Another right thumb button on a gamepad
+         */        
+        public static final ButtonID BTN_THUMBR = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_THUMBR));
+        
+        /** Digitiser pen tool button
+         */        
+        public static final ButtonID BTN_TOOL_PEN = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_PEN));
+        
+        /** Digitiser rubber (eraser) tool button
+         */        
+        public static final ButtonID BTN_TOOL_RUBBER = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_RUBBER));
+        
+        /** Digitiser brush tool button
+         */        
+        public static final ButtonID BTN_TOOL_BRUSH = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_BRUSH));
+        
+        /** Digitiser pencil tool button
+         */        
+        public static final ButtonID BTN_TOOL_PENCIL = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_PENCIL));
+        
+        /** Digitiser airbrush tool button
+         */        
+        public static final ButtonID BTN_TOOL_AIRBRUSH = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_AIRBRUSH));
+        
+        /** Digitiser finger tool button
+         */        
+        public static final ButtonID BTN_TOOL_FINGER = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_FINGER));
+        
+        /** Digitiser mouse tool button
+         */        
+        public static final ButtonID BTN_TOOL_MOUSE = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_MOUSE));
+        
+        /** Digitiser lens tool button
+         */        
+        public static final ButtonID BTN_TOOL_LENS = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOOL_LENS));
+        
+        /** Digitiser touch button
+         */        
+        public static final ButtonID BTN_TOUCH = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_TOUCH));
+        
+        /** Digitiser stylus button
+         */        
+        public static final ButtonID BTN_STYLUS = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_STYLUS));
+        
+        /** Second digitiser stylus button
+         */        
+        public static final ButtonID BTN_STYLUS2 = new ButtonID(LinuxNativeTypesMap.getButtonName(NativeDefinitions.BTN_STYLUS2));
+        
+        /** Create a new Button.Identidier with the passed name
+         * @param name The name for the new identifier
+         */        
+        private ButtonID(String name) {
+            super(name);
+        }
+        
+    }
+    
+}
diff --git a/plugins/linux/src/java/net/java/games/input/LinuxEnvironmentPlugin.java b/plugins/linux/src/java/net/java/games/input/LinuxEnvironmentPlugin.java
new file mode 100644
index 0000000..4e0fbe4
--- /dev/null
+++ b/plugins/linux/src/java/net/java/games/input/LinuxEnvironmentPlugin.java
@@ -0,0 +1,159 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+package net.java.games.input;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import net.java.games.input.Controller;
+import net.java.games.input.ControllerEnvironment;
+import net.java.games.util.plugins.Plugin;
+
+/** Environment plugin for linux
+ * @author Jeremy Booth ([email protected])
+ */
+public class LinuxEnvironmentPlugin extends ControllerEnvironment implements Plugin {
+    
+    static {
+        System.loadLibrary("jinput");
+    }
+
+    /** List of controllers
+     */    
+    private Controller[] controllers;
+    
+    /** Creates a new instance of LinuxEnvironmentPlugin */
+    public LinuxEnvironmentPlugin() {
+        LinuxNativeTypesMap.init();
+        init();
+        createControllers();
+    }
+    
+    /** Returns a list of all controllers available to this environment,
+     * or an empty array if there are no controllers in this environment.
+     * @return Returns a list of all controllers available to this environment,
+     * or an empty array if there are no controllers in this environment.
+     */
+    public Controller[] getControllers() {
+        return controllers;
+    }
+    
+    /** Create the controllers
+     */    
+    private void createControllers() {
+        int numDevices = getNumberOfDevices();
+        
+        controllers = new Controller[numDevices];
+        
+        for(int i=0;i<numDevices;i++) {
+            controllers[i] = createDevice(i);
+        }
+    }
+    
+    /** Create a particular device
+     * @param deviceNumber The device ID
+     * @return The new device
+     */    
+    private Controller createDevice(int deviceNumber) {
+        String name = getDeviceName(deviceNumber);
+        int numAbsAxes = getNumAbsAxes(deviceNumber);
+        int numRelAxes = getNumRelAxes(deviceNumber);
+        int numButtons = getNumButtons(deviceNumber);
+        Controller device = null;
+        
+        int mouseCharacteristic = 0;
+        int keyboardCharacteristic = 0;
+        int joystickCharacteristic = 0;
+        
+        // we are going to try and guess what type of controller it is now
+        if(name.toLowerCase().indexOf("mouse")>=0) {
+            mouseCharacteristic++;
+        }
+        if(name.toLowerCase().indexOf("keyboard")>=0) {
+            keyboardCharacteristic++;
+        }
+        if(name.toLowerCase().indexOf("joystick")>=0) {
+            joystickCharacteristic++;
+        }
+        
+        if(numRelAxes>=2) {
+            mouseCharacteristic++;
+        } else {
+            mouseCharacteristic--;
+        }
+        if(numAbsAxes>=2) {
+            joystickCharacteristic++;
+        } else {
+            joystickCharacteristic--;
+        }
+        if(numButtons>64) {
+            keyboardCharacteristic++;
+        } else {
+            keyboardCharacteristic--;
+        }
+        
+        if((mouseCharacteristic > keyboardCharacteristic) && (mouseCharacteristic > joystickCharacteristic)) {
+            device = new LinuxMouse(new LinuxDevice(deviceNumber, name, numButtons, numRelAxes, numAbsAxes));
+        } else if((keyboardCharacteristic > mouseCharacteristic) && (keyboardCharacteristic > joystickCharacteristic)) {
+            device = new LinuxKeyboard(deviceNumber, name, numButtons, numRelAxes, numAbsAxes);
+        } else if((joystickCharacteristic > keyboardCharacteristic) && (joystickCharacteristic > mouseCharacteristic)) {
+            device = new LinuxDevice(deviceNumber, name, numButtons, numRelAxes, numAbsAxes);
+        } else {
+            //Dunno what this is, but try it anyway
+            device = new LinuxDevice(deviceNumber, name, numButtons, numRelAxes, numAbsAxes);
+        }
+        return device;
+    }
+    
+    /** Get the name of a device from the native library
+     * @param deviceID The device id
+     * @return The devices name
+     */    
+    private native String getDeviceName(int deviceID);
+    /** Get the number of absolute axes for the requested device
+     * @param deviceID The device ID
+     * @return The number of abs axes
+     */    
+    private native int getNumAbsAxes(int deviceID);
+    /** Get the nmber or relative axes from the native library
+     * @param deviceID The native device ID
+     * @return The number of raltive axes for the device
+     */    
+    private native int getNumRelAxes(int deviceID);
+    /** Gets the number of buttons for the requested devce from the native library
+     * @param deviceID The device ID
+     * @return The number of buttons
+     */    
+    private native int getNumButtons(int deviceID);
+    /** Initialises the native library
+     * @return <0 if something went wrong
+     */    
+    private native int init();
+    /** Gets the number of devices the native library found
+     * @return Th number of devices
+     */    
+    private native int getNumberOfDevices();
+    
+}
diff --git a/plugins/linux/src/java/net/java/games/input/LinuxKeyboard.java b/plugins/linux/src/java/net/java/games/input/LinuxKeyboard.java
new file mode 100644
index 0000000..f03d81d
--- /dev/null
+++ b/plugins/linux/src/java/net/java/games/input/LinuxKeyboard.java
@@ -0,0 +1,232 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+package net.java.games.input;
+
+/** Class that represents a keyboard under linux
+ * @author Jeremy Booth ([email protected])
+ */
+public class LinuxKeyboard extends StandardKeyboard {
+    
+    /** Values for the keys
+     */    
+    private int keyData[];
+    /** Needed for the polling methods
+     */    
+    private int dummyRelAxesData[];
+    /** Needed for the polling methods
+     */    
+    private int dummyAbsAxesData[];
+    /** Map of native key numbers from jinput key id key indexes.
+     */    
+    private int keyMap[];
+    /** List of keys this keyboard supports
+     */    
+    private int supportedKeys[];
+    /** Number of keys this keyboard has
+     */    
+    private int numKeys;
+    /** Port type that this keyboard is connected to.
+     */    
+    private PortType portType;
+    /** The native device id
+     */    
+    private int nativeID;
+    
+    /** Creates a new instance of LinuxKeyboard
+     * @param nativeID Native device id
+     * @param name Name of this keybaord
+     * @param numButtons Number of keys
+     * @param numRelAxes Number of relative axes (you never know)
+     * @param numAbsAxes Number of absolute axes (you never know)
+     */
+    public LinuxKeyboard(int nativeID, String name, int numButtons, int numRelAxes, int numAbsAxes) {
+        super(name);
+        
+        children = NO_CONTROLLERS;
+        rumblers = NO_RUMBLERS;
+        
+        if((numRelAxes > 0) || (numAbsAxes > 0)) {
+            children = new Controller[1];
+            children[0] = new LinuxDevice(nativeID, name + " axis", 0, numRelAxes, numAbsAxes);
+        }
+
+        this.nativeID = nativeID;
+        
+        portType = LinuxNativeTypesMap.getPortType(getNativePortType(nativeID));
+        
+        dummyRelAxesData = new int[numRelAxes];
+        dummyAbsAxesData = new int[numAbsAxes];
+        
+        this.numKeys = numButtons;
+        keyData = new int[numButtons+1];
+        supportedKeys = new int[numButtons+1];
+        keyMap = new int[KeyID.LAST.getKeyIndex()];
+        
+        getSupportedButtons(supportedKeys);
+        supportedKeys[numKeys] = NativeDefinitions.KEY_UNKNOWN;
+        
+        setupKeyMap();
+        renameKeys();
+    }
+    
+    /** Returns whether or not the given key has been pressed since the last
+     * call to poll.  This is called from a key's getPollData method.
+     * @param key The key to check
+     * @return the value fo the key
+     */
+    protected boolean isKeyPressed(Key key) {
+        /*if(((Keyboard.KeyID) key.getIdentifier()).getKeyIndex() == StandardKeyboard.KeyID.ESCAPE.getKeyIndex()) {
+            System.out.println("Asked if key " + key + " was pressed");
+            System.out.println("key id " + key.getIdentifier());
+            System.out.println("keyIndex " + ((Keyboard.KeyID) key.getIdentifier()).getKeyIndex());
+            System.out.println("keyMap for index is " + keyMap[((Keyboard.KeyID) key.getIdentifier()).getKeyIndex()]);
+            System.out.println("name for supportedKeys index is " + LinuxNativeTypesMap.getButtonName(supportedKeys[keyMap[((Keyboard.KeyID) key.getIdentifier()).getKeyIndex()]]));
+            System.out.println("id for supportedKeys index is " + LinuxNativeTypesMap.getButtonID(supportedKeys[keyMap[((Keyboard.KeyID) key.getIdentifier()).getKeyIndex()]]));
+            System.out.flush();
+        }*/
+        if(keyData[keyMap[((Keyboard.KeyID) key.getIdentifier()).getKeyIndex()]] > 0) {
+            return true;
+        }
+        return false;
+    }
+    
+    /** Polls axes for data.  Returns false if the controller is no longer valid.
+     * Polling reflects the current state of the device when polled.
+     * @return False if this device is invalid.
+     */
+    public boolean poll() {
+        int retval = nativePoll(nativeID, keyData, dummyRelAxesData, dummyAbsAxesData);
+        if(retval>=0) return true;
+        return false;
+    }
+    
+    /** Goes through every key to initialise the key map
+     */    
+    private void setupKeyMap() {
+        for(int i=0;i<KeyID.LAST.getKeyIndex();i++) {
+            keyMap[i] = numKeys;
+        }
+        for(int i=0;i<numKeys;i++) {
+            int tempNativeID = supportedKeys[i];
+            Keyboard.KeyID tempKeyID = StandardKeyboard.KeyID.VOID;
+            try {
+                tempKeyID = (Keyboard.KeyID)LinuxNativeTypesMap.getButtonID(tempNativeID);                
+            } catch (ClassCastException e) {
+                System.out.println("LinuxNativeTypesMap.getButtonID() returned " + LinuxNativeTypesMap.getButtonID(tempNativeID).getClass().toString());
+            }            
+            if(tempKeyID.getKeyIndex() < keyMap.length) {
+                keyMap[tempKeyID.getKeyIndex()] = i;
+                //System.out.println("keyMap[" + (tempKeyID.getKeyIndex()) + "] (" + tempKeyID + ") set to index " + i + " (" + LinuxNativeTypesMap.getButtonName(supportedKeys[i]) + ")");
+            } else {
+                //System.out.println("Linux key " + LinuxNativeTypesMap.getButtonName(tempNativeID) + " isn't supported by jinput");
+            }
+        }
+    }
+    
+    /** Renames all the keys based on what information we have about them (number/name)
+     */    
+    private void renameKeys() {
+        Axis tempAxes[] = getAxes();
+        // Do this one by hand as it's a special case
+        //((AbstractAxis)tempAxes[0]).setName("Unknown");
+        for(int i=0;i<tempAxes.length;i++) {
+            Axis tempAxis = tempAxes[i];
+            int nativeKeyID = supportedKeys[keyMap[((Keyboard.KeyID) tempAxis.getIdentifier()).getKeyIndex()]];
+            //System.out.println("key " + tempAxis + " map: " + nativeKeyID);
+            if(nativeKeyID != NativeDefinitions.KEY_UNKNOWN) {
+                String tempName = LinuxNativeTypesMap.getButtonName(nativeKeyID);
+                ((AbstractAxis)tempAxis).setName(tempName);
+
+                /*System.out.println("axis id is " + (Keyboard.KeyID) tempAxis.getIdentifier());
+                System.out.println("keyMap[id] is " + keyMap[((Keyboard.KeyID) tempAxis.getIdentifier()).getKeyIndex()]);
+                System.out.println("nativeKeyID is: " + nativeKeyID);             
+                System.out.println("Set name of key " + ((Keyboard.KeyID) tempAxis.getIdentifier()).getKeyIndex() + " to " + tempName);*/
+            }
+        }
+    }
+    
+    /** Gets all the supported keys for this device
+     * @param supportedButtons The array if key types to populate
+     */    
+    private void getSupportedButtons(int supportedButtons[]) {
+        getNativeSupportedButtons(nativeID, supportedButtons);
+    }
+
+    /** Gets the supported key types for a particular native device
+     * @param deviceID The device ID
+     * @param supportedButtons The array to populate with teh supported key ids
+     */    
+    private native void getNativeSupportedButtons(int deviceID, int supportedButtons[]);
+    /** Calls the native library to poll the device
+     * @param deviceID The device ID
+     * @param buttonData Aray to populate with button values
+     * @param relAxesData Array to populate with relative axis values
+     * @param absAxesData Array to populate with absolute axes values
+     * @return <0 if soething went wrong
+     */    
+    private native int nativePoll(int deviceID, int buttonData[], int relAxesData[], int absAxesData[]);
+    /** Gets the port type from the native library for a particular keyboard
+     * @param deviceID The keybaord id
+     * @return native port ype
+     */    
+    private native int getNativePortType(int deviceID);
+
+    /** Linux specific key ID's
+     * @author Jeremy Booth ([email protected])
+     */    
+    public static class KeyID extends StandardKeyboard.KeyID {
+        
+        /** The Page up key id
+         */        
+        public static final KeyID PAGEUP = new KeyID(StandardKeyboard.KeyID.LAST.getKeyIndex()+1, "Page up");
+        /** Page down key id
+         */        
+        public static final KeyID PAGEDOWN = new KeyID(StandardKeyboard.KeyID.LAST.getKeyIndex()+1, "Page down");
+        /** The last defined key ID
+         */        
+        protected static final KeyID LAST = PAGEDOWN;
+        
+        /** The name of this key ID
+         */        
+        String name;
+        
+        /** Construct a new key ID from the passed arguments
+         * @param keyid The native ID of the key
+         * @param name The name fo the key
+         */        
+        public KeyID(int keyid, String name) {
+            super(keyid);
+            this.name = name;
+        }
+        
+        /** Returns a string representing this key ID
+         * @return String representing this key id
+         */        
+        public String toString() {
+            return super.toString() + " (" + name + ")";
+        }
+    }    
+}
diff --git a/plugins/linux/src/java/net/java/games/input/LinuxMouse.java b/plugins/linux/src/java/net/java/games/input/LinuxMouse.java
new file mode 100644
index 0000000..3336905
--- /dev/null
+++ b/plugins/linux/src/java/net/java/games/input/LinuxMouse.java
@@ -0,0 +1,168 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+package net.java.games.input;
+
+/**  Class that represents a mouse under linux.
+ *
+ * @author Jeremy Booth ([email protected])
+ */
+public class LinuxMouse extends Mouse {
+    
+    /** The parent linux device
+     */    
+    private LinuxDevice device;
+    
+    /** Creates a new instance of LinuxMouse
+     * @param device The parent device
+     */
+    public LinuxMouse(LinuxDevice device) {
+        super(device.getName());
+        
+        this.device = device;
+        Axis[] axes = device.getAxes();
+        Axis x = null;
+        Axis y = null;
+        Axis wheel = null;
+        Button left = null;
+        Button right = null;
+        Button middle = null;
+        Button side = null;
+        Button extra = null;
+        Button forward = null;
+        Button back = null;
+        
+        // start from the back, that way the first one is it
+        for(int i = (axes.length -1);i>=0;i--) {
+            Axis tempAxis = axes[i];
+            if(tempAxis.isRelative()) {
+                if(tempAxis.getIdentifier() == Axis.Identifier.X) {
+                    x = tempAxis;
+                } else if(tempAxis.getIdentifier() == Axis.Identifier.Y) {
+                    y = tempAxis;
+                } else if(tempAxis.getIdentifier() == Axis.Identifier.SLIDER) {
+                    wheel = tempAxis;
+                }
+            } else if(!(tempAxis.isAnalog())) {
+                if(tempAxis.getIdentifier() == Mouse.ButtonID.LEFT) {
+                    left = new LinuxMouseButton(tempAxis);
+                } else if(tempAxis.getIdentifier() == Mouse.ButtonID.RIGHT) {
+                    right = new LinuxMouseButton(tempAxis);
+                } else if(tempAxis.getIdentifier() == Mouse.ButtonID.MIDDLE) {
+                    middle = new LinuxMouseButton(tempAxis);
+                } else if(tempAxis.getIdentifier() == Mouse.ButtonID.SIDE) {
+                    side = new LinuxMouseButton(tempAxis);
+                } else if(tempAxis.getIdentifier() == Mouse.ButtonID.EXTRA) {
+                    extra = new LinuxMouseButton(tempAxis);
+                } else if(tempAxis.getIdentifier() == Mouse.ButtonID.FORWARD) {
+                    forward = new LinuxMouseButton(tempAxis);
+                } else if(tempAxis.getIdentifier() == Mouse.ButtonID.BACK) {
+                    back = new LinuxMouseButton(tempAxis);
+                }
+            }
+        }
+        ball = new LinuxMouseBall(x,y,wheel);
+        buttons = new LinuxMouseButtons(left, right, middle, side, extra, forward, back);
+        
+    }
+    
+    /** Polls axes for data.  Returns false if the controller is no longer valid.
+     * Polling reflects the current state of the device when polled.
+     * @return Returns false if the controller is no longer valid.
+     */
+    public boolean poll() {
+        return device.poll();
+    }
+    
+    /** Mouse ball under linux
+     */    
+    private class LinuxMouseBall extends Ball {
+        /** Constructs the new mouse ball
+         * @param x The x axis
+         * @param y The y axis
+         * @param wheel The mouse wheel axis
+         */        
+        public LinuxMouseBall(Axis x, Axis y, Axis wheel) {
+            super(LinuxMouse.this.getName() + " ball");
+            this.x = x;
+            this.y = y;
+            this.wheel = wheel;
+        }
+    }
+    
+    /** Mouse buttons under linux
+     */    
+    private class LinuxMouseButtons extends Buttons {
+        /** Creates the new mouse's buttons
+         * @param left Left mouse button
+         * @param right Right mouse button
+         * @param middle Middle mouse button
+         * @param side Side mouse button
+         * @param extra Extra mouse button
+         * @param forward Forward mouse button
+         * @param back Back mouse button
+         */        
+        public LinuxMouseButtons(Button left, Button right, Button middle, Button side, Button extra, Button forward, Button back) {
+            super(LinuxMouse.this.getName() + " buttons");
+            this.left = left;
+            this.right = right;
+            this.middle = middle;
+            this.side = side;
+            this.extra = extra;
+            this.forward = forward;
+            this.back = back;
+        }
+    }
+    
+    /** Linux specific mouse buttons
+     */    
+    private class LinuxMouseButton extends Mouse.Button {
+        /** The real Axis
+         */        
+        private Axis realAxis;
+        
+        /** Construct a linux mouse button fro mthe given axis
+         * @param axis The axis that holds the data
+         */        
+        public LinuxMouseButton(Axis axis) {
+            super(axis.getName(), (Mouse.ButtonID)axis.getIdentifier());
+            this.realAxis = axis;
+        }
+        
+        /** Returns true f this axis is relative
+         * @return Always returns false for a mouse button
+         */        
+        public boolean isRelative() {
+            return false;
+        }
+        
+        /** Returns the data for this mouse button
+         * @return Retursn this mouse buttons value
+         */        
+        public float getPollData(){
+            return realAxis.getPollData();
+        }
+    }
+}
diff --git a/plugins/linux/src/java/net/java/games/input/LinuxNativeTypesMap.java b/plugins/linux/src/java/net/java/games/input/LinuxNativeTypesMap.java
new file mode 100644
index 0000000..698c18f
--- /dev/null
+++ b/plugins/linux/src/java/net/java/games/input/LinuxNativeTypesMap.java
@@ -0,0 +1,792 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+package net.java.games.input;
+
+/**
+ * Mapping utility class between native type ints and string names or
+ * Key.Identifiers
+ * @author Jeremy Booth ([email protected])
+ */
+public class LinuxNativeTypesMap {
+    
+    /** Instance of they key map
+     */    
+    private static LinuxNativeTypesMap INSTANCE = new LinuxNativeTypesMap();
+    
+    /** Indexed array of key names
+     */    
+    private String keyNames[];
+    /** Inexed array of relative axes names
+     */    
+    private String relAxesNames[];
+    /** Indexed array of absolute axis names
+     */    
+    private String absAxesNames[];
+    /** Indexed array of relative axis ID's
+     */    
+    private Axis.Identifier relAxesIDs[];
+    /** Indexed array of absoulte axis ID's
+     */    
+    private Axis.Identifier absAxesIDs[];
+    /** Indexed array of button axis ID's
+     */    
+    private Axis.Identifier buttonIDs[];
+    
+    /** create an empty, uninitialsed map
+     */    
+    private LinuxNativeTypesMap() {
+        keyNames = new String[NativeDefinitions.KEY_MAX];
+    }
+    
+    /** Initialise the map, has to be done like this because the map references staic
+     * classes, as this would otherwise be done in a static class initialiser the whole
+     * thing blew up as the static classes this class references refer to this class
+     * this meant that the other classes could not be initialsed until this one was,
+     * but this class couldn't be loaded until the others were, all went horibly wrong
+     * and INSTANCE was null whilst initialising the class, ouch.
+     */    
+    public static void init() {
+        INSTANCE.reInit();
+    }
+        
+    /** Do the work.
+     */    
+    private void reInit() {
+        keyNames[NativeDefinitions.KEY_ESC] = "Escape";
+        keyNames[NativeDefinitions.KEY_1] = "1";
+        keyNames[NativeDefinitions.KEY_2] = "2";
+        keyNames[NativeDefinitions.KEY_3] = "3";
+        keyNames[NativeDefinitions.KEY_4] = "4";
+        keyNames[NativeDefinitions.KEY_5] = "5";
+        keyNames[NativeDefinitions.KEY_6] = "6";
+        keyNames[NativeDefinitions.KEY_7] = "7";
+        keyNames[NativeDefinitions.KEY_8] = "8";
+        keyNames[NativeDefinitions.KEY_9] = "9";
+        keyNames[NativeDefinitions.KEY_0] = "0";
+        keyNames[NativeDefinitions.KEY_MINUS] = "-";
+        keyNames[NativeDefinitions.KEY_EQUAL] = "=";
+        keyNames[NativeDefinitions.KEY_BACKSPACE] = "Backspace";
+        keyNames[NativeDefinitions.KEY_TAB] = "Tab";
+        keyNames[NativeDefinitions.KEY_Q] = "Q";
+        keyNames[NativeDefinitions.KEY_W] = "W";
+        keyNames[NativeDefinitions.KEY_E] = "E";
+        keyNames[NativeDefinitions.KEY_R] = "R";
+        keyNames[NativeDefinitions.KEY_T] = "T";
+        keyNames[NativeDefinitions.KEY_Y] = "Y";
+        keyNames[NativeDefinitions.KEY_U] = "U";
+        keyNames[NativeDefinitions.KEY_I] = "I";
+        keyNames[NativeDefinitions.KEY_O] = "O";
+        keyNames[NativeDefinitions.KEY_P] = "P";
+        keyNames[NativeDefinitions.KEY_LEFTBRACE] = "[";
+        keyNames[NativeDefinitions.KEY_RIGHTBRACE] = "]";
+        keyNames[NativeDefinitions.KEY_ENTER] = "Enter";
+        keyNames[NativeDefinitions.KEY_LEFTCTRL] = "LH Control";
+        keyNames[NativeDefinitions.KEY_A] = "A";
+        keyNames[NativeDefinitions.KEY_S] = "S";
+        keyNames[NativeDefinitions.KEY_D] = "D";
+        keyNames[NativeDefinitions.KEY_F] = "F";
+        keyNames[NativeDefinitions.KEY_G] = "G";
+        keyNames[NativeDefinitions.KEY_H] = "H";
+        keyNames[NativeDefinitions.KEY_J] = "J";
+        keyNames[NativeDefinitions.KEY_K] = "K";
+        keyNames[NativeDefinitions.KEY_L] = "L";
+        keyNames[NativeDefinitions.KEY_SEMICOLON] = ";";
+        keyNames[NativeDefinitions.KEY_APOSTROPHE] = "'";
+        keyNames[NativeDefinitions.KEY_GRAVE] = "`";
+        keyNames[NativeDefinitions.KEY_LEFTSHIFT] = "LH Shift";
+        keyNames[NativeDefinitions.KEY_BACKSLASH] = "\\";
+        keyNames[NativeDefinitions.KEY_Z] = "Z";
+        keyNames[NativeDefinitions.KEY_X] = "X";
+        keyNames[NativeDefinitions.KEY_C] = "C";
+        keyNames[NativeDefinitions.KEY_V] = "V";
+        keyNames[NativeDefinitions.KEY_B] = "B";
+        keyNames[NativeDefinitions.KEY_N] = "N";
+        keyNames[NativeDefinitions.KEY_M] = "M";
+        keyNames[NativeDefinitions.KEY_COMMA] = ",";
+        keyNames[NativeDefinitions.KEY_DOT] = ".";
+        keyNames[NativeDefinitions.KEY_SLASH] = "/";
+        keyNames[NativeDefinitions.KEY_RIGHTSHIFT] = "RH Shift";
+        keyNames[NativeDefinitions.KEY_KPASTERISK] = "*";
+        keyNames[NativeDefinitions.KEY_LEFTALT] = "LH Alt";
+        keyNames[NativeDefinitions.KEY_SPACE] = "Space";
+        keyNames[NativeDefinitions.KEY_CAPSLOCK] = "CapsLock";
+        keyNames[NativeDefinitions.KEY_F1] = "F1";
+        keyNames[NativeDefinitions.KEY_F2] = "F2";
+        keyNames[NativeDefinitions.KEY_F3] = "F3";
+        keyNames[NativeDefinitions.KEY_F4] = "F4";
+        keyNames[NativeDefinitions.KEY_F5] = "F5";
+        keyNames[NativeDefinitions.KEY_F6] = "F6";
+        keyNames[NativeDefinitions.KEY_F7] = "F7";
+        keyNames[NativeDefinitions.KEY_F8] = "F8";
+        keyNames[NativeDefinitions.KEY_F9] = "F9";
+        keyNames[NativeDefinitions.KEY_F10] = "F10";
+        keyNames[NativeDefinitions.KEY_NUMLOCK] = "NumLock";
+        keyNames[NativeDefinitions.KEY_SCROLLLOCK] = "ScrollLock";
+        keyNames[NativeDefinitions.KEY_KP7] = "KeyPad 7";
+        keyNames[NativeDefinitions.KEY_KP8] = "KeyPad 8";
+        keyNames[NativeDefinitions.KEY_KP9] = "Keypad 9";
+        keyNames[NativeDefinitions.KEY_KPMINUS] = "KeyPad Minus";
+        keyNames[NativeDefinitions.KEY_KP4] = "KeyPad 4";
+        keyNames[NativeDefinitions.KEY_KP5] = "KeyPad 5";
+        keyNames[NativeDefinitions.KEY_KP6] = "KeyPad 6";
+        keyNames[NativeDefinitions.KEY_KPPLUS] = "KeyPad Plus";
+        keyNames[NativeDefinitions.KEY_KP1] = "KeyPad 1";
+        keyNames[NativeDefinitions.KEY_KP2] = "KeyPad 2";
+        keyNames[NativeDefinitions.KEY_KP3] = "KeyPad 3";
+        keyNames[NativeDefinitions.KEY_KP0] = "KeyPad 0";
+        keyNames[NativeDefinitions.KEY_KPDOT] = "KeyPad decimal point";
+        keyNames[NativeDefinitions.KEY_103RD] = "Huh?";
+        keyNames[NativeDefinitions.KEY_F13] = "F13";
+        keyNames[NativeDefinitions.KEY_102ND] = "Beats me...";
+        keyNames[NativeDefinitions.KEY_F11] = "F11";
+        keyNames[NativeDefinitions.KEY_F12] = "F12";
+        keyNames[NativeDefinitions.KEY_F14] = "F14";
+        keyNames[NativeDefinitions.KEY_F15] = "F15";
+        keyNames[NativeDefinitions.KEY_F16] = "F16";
+        keyNames[NativeDefinitions.KEY_F17] = "F17";
+        keyNames[NativeDefinitions.KEY_F18] = "F18";
+        keyNames[NativeDefinitions.KEY_F19] = "F19";
+        keyNames[NativeDefinitions.KEY_F20] = "F20";
+        keyNames[NativeDefinitions.KEY_KPENTER] = "Keypad Enter";
+        keyNames[NativeDefinitions.KEY_RIGHTCTRL] = "RH Control";
+        keyNames[NativeDefinitions.KEY_KPSLASH] = "KeyPad Forward Slash";
+        keyNames[NativeDefinitions.KEY_SYSRQ] = "System Request";
+        keyNames[NativeDefinitions.KEY_RIGHTALT] = "RH Alternate";
+        keyNames[NativeDefinitions.KEY_LINEFEED] = "Line Feed";
+        keyNames[NativeDefinitions.KEY_HOME] = "Home";
+        keyNames[NativeDefinitions.KEY_UP] = "Up";
+        keyNames[NativeDefinitions.KEY_PAGEUP] = "Page Up";
+        keyNames[NativeDefinitions.KEY_LEFT] = "Left";
+        keyNames[NativeDefinitions.KEY_RIGHT] = "Right";
+        keyNames[NativeDefinitions.KEY_END] = "End";
+        keyNames[NativeDefinitions.KEY_DOWN] = "Down";
+        keyNames[NativeDefinitions.KEY_PAGEDOWN] = "Page Down";
+        keyNames[NativeDefinitions.KEY_INSERT] = "Insert";
+        keyNames[NativeDefinitions.KEY_DELETE] = "Delete";
+        keyNames[NativeDefinitions.KEY_MACRO] = "Macro";
+        keyNames[NativeDefinitions.KEY_MUTE] = "Mute";
+        keyNames[NativeDefinitions.KEY_VOLUMEDOWN] = "Volume Down";
+        keyNames[NativeDefinitions.KEY_VOLUMEUP] = "Volume Up";
+        keyNames[NativeDefinitions.KEY_POWER] = "Power";
+        keyNames[NativeDefinitions.KEY_KPEQUAL] = "KeyPad Equal";
+        keyNames[NativeDefinitions.KEY_KPPLUSMINUS] = "KeyPad +/-";
+        keyNames[NativeDefinitions.KEY_PAUSE] = "Pause";
+        keyNames[NativeDefinitions.KEY_F21] = "F21";
+        keyNames[NativeDefinitions.KEY_F22] = "F22";
+        keyNames[NativeDefinitions.KEY_F23] = "F23";
+        keyNames[NativeDefinitions.KEY_F24] = "F24";
+        keyNames[NativeDefinitions.KEY_KPCOMMA] = "KeyPad comma";
+        keyNames[NativeDefinitions.KEY_LEFTMETA] = "LH Meta";
+        keyNames[NativeDefinitions.KEY_RIGHTMETA] = "RH Meta";
+        keyNames[NativeDefinitions.KEY_COMPOSE] = "Compose";
+        keyNames[NativeDefinitions.KEY_STOP] = "Stop";
+        keyNames[NativeDefinitions.KEY_AGAIN] = "Again";
+        keyNames[NativeDefinitions.KEY_PROPS] = "Properties";
+        keyNames[NativeDefinitions.KEY_UNDO] = "Undo";
+        keyNames[NativeDefinitions.KEY_FRONT] = "Front";
+        keyNames[NativeDefinitions.KEY_COPY] = "Copy";
+        keyNames[NativeDefinitions.KEY_OPEN] = "Open";
+        keyNames[NativeDefinitions.KEY_PASTE] = "Paste";
+        keyNames[NativeDefinitions.KEY_FIND] = "Find";
+        keyNames[NativeDefinitions.KEY_CUT] = "Cut";
+        keyNames[NativeDefinitions.KEY_HELP] = "Help";
+        keyNames[NativeDefinitions.KEY_MENU] = "Menu";
+        keyNames[NativeDefinitions.KEY_CALC] = "Calculator";
+        keyNames[NativeDefinitions.KEY_SETUP] = "Setup";
+        keyNames[NativeDefinitions.KEY_SLEEP] = "Sleep";
+        keyNames[NativeDefinitions.KEY_WAKEUP] = "Wakeup";
+        keyNames[NativeDefinitions.KEY_FILE] = "File";
+        keyNames[NativeDefinitions.KEY_SENDFILE] = "Send File";
+        keyNames[NativeDefinitions.KEY_DELETEFILE] = "Delete File";
+        keyNames[NativeDefinitions.KEY_XFER] = "Transfer";
+        keyNames[NativeDefinitions.KEY_PROG1] = "Program 1";
+        keyNames[NativeDefinitions.KEY_PROG2] = "Program 2";
+        keyNames[NativeDefinitions.KEY_WWW] = "Web Browser";
+        keyNames[NativeDefinitions.KEY_MSDOS] = "DOS mode";
+        keyNames[NativeDefinitions.KEY_COFFEE] = "Coffee";
+        keyNames[NativeDefinitions.KEY_DIRECTION] = "Direction";
+        keyNames[NativeDefinitions.KEY_CYCLEWINDOWS] = "Window cycle";
+        keyNames[NativeDefinitions.KEY_MAIL] = "Mail";
+        keyNames[NativeDefinitions.KEY_BOOKMARKS] = "Book Marks";
+        keyNames[NativeDefinitions.KEY_COMPUTER] = "Computer";
+        keyNames[NativeDefinitions.KEY_BACK] = "Back";
+        keyNames[NativeDefinitions.KEY_FORWARD] = "Forward";
+        keyNames[NativeDefinitions.KEY_CLOSECD] = "Close CD";
+        keyNames[NativeDefinitions.KEY_EJECTCD] = "Eject CD";
+        keyNames[NativeDefinitions.KEY_EJECTCLOSECD] = "Eject / Close CD";
+        keyNames[NativeDefinitions.KEY_NEXTSONG] = "Next Song";
+        keyNames[NativeDefinitions.KEY_PLAYPAUSE] = "Play and Pause";
+        keyNames[NativeDefinitions.KEY_PREVIOUSSONG] = "Previous Song";
+        keyNames[NativeDefinitions.KEY_STOPCD] = "Stop CD";
+        keyNames[NativeDefinitions.KEY_RECORD] = "Record";
+        keyNames[NativeDefinitions.KEY_REWIND] = "Rewind";
+        keyNames[NativeDefinitions.KEY_PHONE] = "Phone";
+        keyNames[NativeDefinitions.KEY_ISO] = "ISO";
+        keyNames[NativeDefinitions.KEY_CONFIG] = "Config";
+        keyNames[NativeDefinitions.KEY_HOMEPAGE] = "Home";
+        keyNames[NativeDefinitions.KEY_REFRESH] = "Refresh";
+        keyNames[NativeDefinitions.KEY_EXIT] = "Exit";
+        keyNames[NativeDefinitions.KEY_MOVE] = "Move";
+        keyNames[NativeDefinitions.KEY_EDIT] = "Edit";
+        keyNames[NativeDefinitions.KEY_SCROLLUP] = "Scroll Up";
+        keyNames[NativeDefinitions.KEY_SCROLLDOWN] = "Scroll Down";
+        keyNames[NativeDefinitions.KEY_KPLEFTPAREN] = "KeyPad LH parenthesis";
+        keyNames[NativeDefinitions.KEY_KPRIGHTPAREN] = "KeyPad RH parenthesis";
+        keyNames[NativeDefinitions.KEY_INTL1] = "Intl 1";
+        keyNames[NativeDefinitions.KEY_INTL2] = "Intl 2";
+        keyNames[NativeDefinitions.KEY_INTL3] = "Intl 3";
+        keyNames[NativeDefinitions.KEY_INTL4] = "Intl 4";
+        keyNames[NativeDefinitions.KEY_INTL5] = "Intl 5";
+        keyNames[NativeDefinitions.KEY_INTL6] = "Intl 6";
+        keyNames[NativeDefinitions.KEY_INTL7] = "Intl 7";
+        keyNames[NativeDefinitions.KEY_INTL8] = "Intl 8";
+        keyNames[NativeDefinitions.KEY_INTL9] = "Intl 9";
+        keyNames[NativeDefinitions.KEY_LANG1] = "Language 1";
+        keyNames[NativeDefinitions.KEY_LANG2] = "Language 2";
+        keyNames[NativeDefinitions.KEY_LANG3] = "Language 3";
+        keyNames[NativeDefinitions.KEY_LANG4] = "Language 4";
+        keyNames[NativeDefinitions.KEY_LANG5] = "Language 5";
+        keyNames[NativeDefinitions.KEY_LANG6] = "Language 6";
+        keyNames[NativeDefinitions.KEY_LANG7] = "Language 7";
+        keyNames[NativeDefinitions.KEY_LANG8] = "Language 8";
+        keyNames[NativeDefinitions.KEY_LANG9] = "Language 9";
+        keyNames[NativeDefinitions.KEY_PLAYCD] = "Play CD";
+        keyNames[NativeDefinitions.KEY_PAUSECD] = "Pause CD";
+        keyNames[NativeDefinitions.KEY_PROG3] = "Program 3";
+        keyNames[NativeDefinitions.KEY_PROG4] = "Program 4";
+        keyNames[NativeDefinitions.KEY_SUSPEND] = "Suspend";
+        keyNames[NativeDefinitions.KEY_CLOSE] = "Close";
+        keyNames[NativeDefinitions.KEY_UNKNOWN] = "Specifically unknown";
+        keyNames[NativeDefinitions.KEY_BRIGHTNESSDOWN] = "Brightness Down";
+        keyNames[NativeDefinitions.KEY_BRIGHTNESSUP] = "Brightness Up";
+        keyNames[NativeDefinitions.BTN_0] = "Button 0";
+        keyNames[NativeDefinitions.BTN_1] = "Button 1";
+        keyNames[NativeDefinitions.BTN_2] = "Button 2";
+        keyNames[NativeDefinitions.BTN_3] = "Button 3";
+        keyNames[NativeDefinitions.BTN_4] = "Button 4";
+        keyNames[NativeDefinitions.BTN_5] = "Button 5";
+        keyNames[NativeDefinitions.BTN_6] = "Button 6";
+        keyNames[NativeDefinitions.BTN_7] = "Button 7";
+        keyNames[NativeDefinitions.BTN_8] = "Button 8";
+        keyNames[NativeDefinitions.BTN_9] = "Button 9";
+        keyNames[NativeDefinitions.BTN_LEFT] = "Left Button";
+        keyNames[NativeDefinitions.BTN_RIGHT] = "Right Button";
+        keyNames[NativeDefinitions.BTN_MIDDLE] = "Middle Button";
+        keyNames[NativeDefinitions.BTN_SIDE] = "Side Button";
+        keyNames[NativeDefinitions.BTN_EXTRA] = "Extra Button";
+        keyNames[NativeDefinitions.BTN_FORWARD] = "Forward Button";
+        keyNames[NativeDefinitions.BTN_BACK] = "Back Button";
+        keyNames[NativeDefinitions.BTN_TRIGGER] = "Trigger Button";
+        keyNames[NativeDefinitions.BTN_THUMB] = "Thumb Button";
+        keyNames[NativeDefinitions.BTN_THUMB2] = "Second Thumb Button";
+        keyNames[NativeDefinitions.BTN_TOP] = "Top Button";
+        keyNames[NativeDefinitions.BTN_TOP2] = "Second Top Button";
+        keyNames[NativeDefinitions.BTN_PINKIE] = "Pinkie Button";
+        keyNames[NativeDefinitions.BTN_BASE] = "Base Button";
+        keyNames[NativeDefinitions.BTN_BASE2] = "Second Base Button";
+        keyNames[NativeDefinitions.BTN_BASE3] = "Third Base Button";
+        keyNames[NativeDefinitions.BTN_BASE4] = "Fourth Base Button";
+        keyNames[NativeDefinitions.BTN_BASE5] = "Fifth Base Button";
+        keyNames[NativeDefinitions.BTN_BASE6] = "Sixth Base Button";
+        keyNames[NativeDefinitions.BTN_DEAD] = "Dead Button";
+        keyNames[NativeDefinitions.BTN_A] = "Button A";
+        keyNames[NativeDefinitions.BTN_B] = "Button B";
+        keyNames[NativeDefinitions.BTN_C] = "Button C";
+        keyNames[NativeDefinitions.BTN_X] = "Button X";
+        keyNames[NativeDefinitions.BTN_Y] = "Button Y";
+        keyNames[NativeDefinitions.BTN_Z] = "Button Z";
+        keyNames[NativeDefinitions.BTN_TL] = "Thumb Left Button";
+        keyNames[NativeDefinitions.BTN_TR] = "Thumb Right Button ";
+        keyNames[NativeDefinitions.BTN_TL2] = "Second Thumb Left Button";
+        keyNames[NativeDefinitions.BTN_TR2] = "Second Thumb Right Button ";
+        keyNames[NativeDefinitions.BTN_SELECT] = "Select Button";
+        keyNames[NativeDefinitions.BTN_MODE] = "Mode Button";
+        keyNames[NativeDefinitions.BTN_THUMBL] = "Another Left Thumb Button ";
+        keyNames[NativeDefinitions.BTN_THUMBR] = "Another Right Thumb Button ";
+        keyNames[NativeDefinitions.BTN_TOOL_PEN] = "Digitiser Pen Tool";
+        keyNames[NativeDefinitions.BTN_TOOL_RUBBER] = "Digitiser Rubber Tool";
+        keyNames[NativeDefinitions.BTN_TOOL_BRUSH] = "Digitiser Brush Tool";
+        keyNames[NativeDefinitions.BTN_TOOL_PENCIL] = "Digitiser Pencil Tool";
+        keyNames[NativeDefinitions.BTN_TOOL_AIRBRUSH] = "Digitiser Airbrush Tool";
+        keyNames[NativeDefinitions.BTN_TOOL_FINGER] = "Digitiser Finger Tool";
+        keyNames[NativeDefinitions.BTN_TOOL_MOUSE] = "Digitiser Mouse Tool";
+        keyNames[NativeDefinitions.BTN_TOOL_LENS] = "Digitiser Lens Tool";
+        keyNames[NativeDefinitions.BTN_TOUCH] = "Digitiser Touch Button ";
+        keyNames[NativeDefinitions.BTN_STYLUS] = "Digitiser Stylus Button ";
+        keyNames[NativeDefinitions.BTN_STYLUS2] = "Second Digitiser Stylus Button ";
+
+        buttonIDs = new Axis.Identifier[NativeDefinitions.KEY_MAX];
+        buttonIDs[NativeDefinitions.KEY_ESC] = StandardKeyboard.KeyID.ESCAPE;
+        buttonIDs[NativeDefinitions.KEY_1] = StandardKeyboard.KeyID._1;
+        buttonIDs[NativeDefinitions.KEY_2] = StandardKeyboard.KeyID._2;
+        buttonIDs[NativeDefinitions.KEY_3] = StandardKeyboard.KeyID._3;
+        buttonIDs[NativeDefinitions.KEY_4] = StandardKeyboard.KeyID._4;
+        buttonIDs[NativeDefinitions.KEY_5] = StandardKeyboard.KeyID._5;
+        buttonIDs[NativeDefinitions.KEY_6] = StandardKeyboard.KeyID._6;
+        buttonIDs[NativeDefinitions.KEY_7] = StandardKeyboard.KeyID._7;
+        buttonIDs[NativeDefinitions.KEY_8] = StandardKeyboard.KeyID._8;
+        buttonIDs[NativeDefinitions.KEY_9] = StandardKeyboard.KeyID._9;
+        buttonIDs[NativeDefinitions.KEY_0] = StandardKeyboard.KeyID._0;
+        buttonIDs[NativeDefinitions.KEY_MINUS] = StandardKeyboard.KeyID.MINUS;
+        buttonIDs[NativeDefinitions.KEY_EQUAL] = StandardKeyboard.KeyID.EQUALS;
+        buttonIDs[NativeDefinitions.KEY_BACKSPACE] = StandardKeyboard.KeyID.BACK;
+        buttonIDs[NativeDefinitions.KEY_TAB] = StandardKeyboard.KeyID.TAB;
+        buttonIDs[NativeDefinitions.KEY_Q] = StandardKeyboard.KeyID.Q;
+        buttonIDs[NativeDefinitions.KEY_W] = StandardKeyboard.KeyID.W;
+        buttonIDs[NativeDefinitions.KEY_E] = StandardKeyboard.KeyID.E;
+        buttonIDs[NativeDefinitions.KEY_R] = StandardKeyboard.KeyID.R;
+        buttonIDs[NativeDefinitions.KEY_T] = StandardKeyboard.KeyID.T;
+        buttonIDs[NativeDefinitions.KEY_Y] = StandardKeyboard.KeyID.Y;
+        buttonIDs[NativeDefinitions.KEY_U] = StandardKeyboard.KeyID.U;
+        buttonIDs[NativeDefinitions.KEY_I] = StandardKeyboard.KeyID.I;
+        buttonIDs[NativeDefinitions.KEY_O] = StandardKeyboard.KeyID.O;
+        buttonIDs[NativeDefinitions.KEY_P] = StandardKeyboard.KeyID.P;
+        buttonIDs[NativeDefinitions.KEY_LEFTBRACE] = StandardKeyboard.KeyID.LBRACKET;
+        buttonIDs[NativeDefinitions.KEY_RIGHTBRACE] = StandardKeyboard.KeyID.RBRACKET;
+        buttonIDs[NativeDefinitions.KEY_ENTER] = StandardKeyboard.KeyID.RETURN;
+        buttonIDs[NativeDefinitions.KEY_LEFTCTRL] = StandardKeyboard.KeyID.LCONTROL;
+        buttonIDs[NativeDefinitions.KEY_A] = StandardKeyboard.KeyID.A;
+        buttonIDs[NativeDefinitions.KEY_S] = StandardKeyboard.KeyID.S;
+        buttonIDs[NativeDefinitions.KEY_D] = StandardKeyboard.KeyID.D;
+        buttonIDs[NativeDefinitions.KEY_F] = StandardKeyboard.KeyID.F;
+        buttonIDs[NativeDefinitions.KEY_G] = StandardKeyboard.KeyID.G;
+        buttonIDs[NativeDefinitions.KEY_H] = StandardKeyboard.KeyID.H;
+        buttonIDs[NativeDefinitions.KEY_J] = StandardKeyboard.KeyID.J;
+        buttonIDs[NativeDefinitions.KEY_K] = StandardKeyboard.KeyID.K;
+        buttonIDs[NativeDefinitions.KEY_L] = StandardKeyboard.KeyID.L;
+        buttonIDs[NativeDefinitions.KEY_SEMICOLON] = StandardKeyboard.KeyID.SEMICOLON;
+        buttonIDs[NativeDefinitions.KEY_APOSTROPHE] = StandardKeyboard.KeyID.APOSTROPHE;
+        buttonIDs[NativeDefinitions.KEY_GRAVE] = StandardKeyboard.KeyID.GRAVE;
+        buttonIDs[NativeDefinitions.KEY_LEFTSHIFT] = StandardKeyboard.KeyID.LSHIFT;
+        buttonIDs[NativeDefinitions.KEY_BACKSLASH] = StandardKeyboard.KeyID.BACKSLASH;
+        buttonIDs[NativeDefinitions.KEY_Z] = StandardKeyboard.KeyID.Z;
+        buttonIDs[NativeDefinitions.KEY_X] = StandardKeyboard.KeyID.X;
+        buttonIDs[NativeDefinitions.KEY_C] = StandardKeyboard.KeyID.C;
+        buttonIDs[NativeDefinitions.KEY_V] = StandardKeyboard.KeyID.V;
+        buttonIDs[NativeDefinitions.KEY_B] = StandardKeyboard.KeyID.B;
+        buttonIDs[NativeDefinitions.KEY_N] = StandardKeyboard.KeyID.N;
+        buttonIDs[NativeDefinitions.KEY_M] = StandardKeyboard.KeyID.M;
+        buttonIDs[NativeDefinitions.KEY_COMMA] = StandardKeyboard.KeyID.COMMA;
+        buttonIDs[NativeDefinitions.KEY_DOT] = StandardKeyboard.KeyID.PERIOD;
+        buttonIDs[NativeDefinitions.KEY_SLASH] = StandardKeyboard.KeyID.SLASH;
+        buttonIDs[NativeDefinitions.KEY_RIGHTSHIFT] = StandardKeyboard.KeyID.RSHIFT;
+        buttonIDs[NativeDefinitions.KEY_KPASTERISK] = StandardKeyboard.KeyID.MULTIPLY;
+        buttonIDs[NativeDefinitions.KEY_LEFTALT] = StandardKeyboard.KeyID.LALT;
+        buttonIDs[NativeDefinitions.KEY_SPACE] = StandardKeyboard.KeyID.SPACE;
+        buttonIDs[NativeDefinitions.KEY_CAPSLOCK] = StandardKeyboard.KeyID.CAPITAL;
+        buttonIDs[NativeDefinitions.KEY_F1] = StandardKeyboard.KeyID.F1;
+        buttonIDs[NativeDefinitions.KEY_F2] = StandardKeyboard.KeyID.F2;
+        buttonIDs[NativeDefinitions.KEY_F3] = StandardKeyboard.KeyID.F3;
+        buttonIDs[NativeDefinitions.KEY_F4] = StandardKeyboard.KeyID.F4;
+        buttonIDs[NativeDefinitions.KEY_F5] = StandardKeyboard.KeyID.F5;
+        buttonIDs[NativeDefinitions.KEY_F6] = StandardKeyboard.KeyID.F6;
+        buttonIDs[NativeDefinitions.KEY_F7] = StandardKeyboard.KeyID.F7;
+        buttonIDs[NativeDefinitions.KEY_F8] = StandardKeyboard.KeyID.F8;
+        buttonIDs[NativeDefinitions.KEY_F9] = StandardKeyboard.KeyID.F9;
+        buttonIDs[NativeDefinitions.KEY_F10] = StandardKeyboard.KeyID.F10;
+        buttonIDs[NativeDefinitions.KEY_NUMLOCK] = StandardKeyboard.KeyID.NUMLOCK;
+        buttonIDs[NativeDefinitions.KEY_SCROLLLOCK] = StandardKeyboard.KeyID.SCROLL;
+        buttonIDs[NativeDefinitions.KEY_KP7] = StandardKeyboard.KeyID.NUMPAD7;
+        buttonIDs[NativeDefinitions.KEY_KP8] = StandardKeyboard.KeyID.NUMPAD8;
+        buttonIDs[NativeDefinitions.KEY_KP9] = StandardKeyboard.KeyID.NUMPAD9;
+        buttonIDs[NativeDefinitions.KEY_KPMINUS] = StandardKeyboard.KeyID.SUBTRACT;
+        buttonIDs[NativeDefinitions.KEY_KP4] = StandardKeyboard.KeyID.NUMPAD4;
+        buttonIDs[NativeDefinitions.KEY_KP5] = StandardKeyboard.KeyID.NUMPAD5;
+        buttonIDs[NativeDefinitions.KEY_KP6] = StandardKeyboard.KeyID.NUMPAD6;
+        buttonIDs[NativeDefinitions.KEY_KPPLUS] = StandardKeyboard.KeyID.ADD;
+        buttonIDs[NativeDefinitions.KEY_KP1] = StandardKeyboard.KeyID.NUMPAD1;
+        buttonIDs[NativeDefinitions.KEY_KP2] = StandardKeyboard.KeyID.NUMPAD2;
+        buttonIDs[NativeDefinitions.KEY_KP3] = StandardKeyboard.KeyID.NUMPAD3;
+        buttonIDs[NativeDefinitions.KEY_KP0] = StandardKeyboard.KeyID.NUMPAD0;
+        buttonIDs[NativeDefinitions.KEY_KPDOT] = StandardKeyboard.KeyID.DECIMAL;
+        buttonIDs[NativeDefinitions.KEY_103RD] = null;
+        buttonIDs[NativeDefinitions.KEY_F13] = StandardKeyboard.KeyID.F13;
+        buttonIDs[NativeDefinitions.KEY_102ND] = null;
+        buttonIDs[NativeDefinitions.KEY_F11] = StandardKeyboard.KeyID.F11;
+        buttonIDs[NativeDefinitions.KEY_F12] = StandardKeyboard.KeyID.F12;
+        buttonIDs[NativeDefinitions.KEY_F14] = StandardKeyboard.KeyID.F14;
+        buttonIDs[NativeDefinitions.KEY_F15] = StandardKeyboard.KeyID.F15;
+        buttonIDs[NativeDefinitions.KEY_F16] = null;
+        buttonIDs[NativeDefinitions.KEY_F17] = null;
+        buttonIDs[NativeDefinitions.KEY_F18] = null;
+        buttonIDs[NativeDefinitions.KEY_F19] = null;
+        buttonIDs[NativeDefinitions.KEY_F20] = null;
+        buttonIDs[NativeDefinitions.KEY_KPENTER] = StandardKeyboard.KeyID.NUMPADENTER;
+        buttonIDs[NativeDefinitions.KEY_RIGHTCTRL] = StandardKeyboard.KeyID.RCONTROL;
+        buttonIDs[NativeDefinitions.KEY_KPSLASH] = StandardKeyboard.KeyID.DIVIDE;
+        buttonIDs[NativeDefinitions.KEY_SYSRQ] = StandardKeyboard.KeyID.SYSRQ;
+        buttonIDs[NativeDefinitions.KEY_RIGHTALT] = StandardKeyboard.KeyID.RALT;
+        buttonIDs[NativeDefinitions.KEY_LINEFEED] = null;
+        buttonIDs[NativeDefinitions.KEY_HOME] = StandardKeyboard.KeyID.HOME;
+        buttonIDs[NativeDefinitions.KEY_UP] = StandardKeyboard.KeyID.UP;
+        buttonIDs[NativeDefinitions.KEY_PAGEUP] = LinuxKeyboard.KeyID.PAGEUP;
+        buttonIDs[NativeDefinitions.KEY_LEFT] = StandardKeyboard.KeyID.LEFT;
+        buttonIDs[NativeDefinitions.KEY_RIGHT] = StandardKeyboard.KeyID.RIGHT;
+        buttonIDs[NativeDefinitions.KEY_END] = StandardKeyboard.KeyID.END;
+        buttonIDs[NativeDefinitions.KEY_DOWN] = StandardKeyboard.KeyID.DOWN;
+        buttonIDs[NativeDefinitions.KEY_PAGEDOWN] = LinuxKeyboard.KeyID.PAGEDOWN;
+        buttonIDs[NativeDefinitions.KEY_INSERT] = StandardKeyboard.KeyID.INSERT;
+        buttonIDs[NativeDefinitions.KEY_DELETE] = StandardKeyboard.KeyID.DELETE;
+        buttonIDs[NativeDefinitions.KEY_PAUSE] = StandardKeyboard.KeyID.PAUSE;
+/*        buttonIDs[NativeDefinitions.KEY_MACRO] = "Macro";
+        buttonIDs[NativeDefinitions.KEY_MUTE] = "Mute";
+        buttonIDs[NativeDefinitions.KEY_VOLUMEDOWN] = "Volume Down";
+        buttonIDs[NativeDefinitions.KEY_VOLUMEUP] = "Volume Up";
+        buttonIDs[NativeDefinitions.KEY_POWER] = "Power";*/
+        buttonIDs[NativeDefinitions.KEY_KPEQUAL] = StandardKeyboard.KeyID.NUMPADEQUAL;
+        //buttonIDs[NativeDefinitions.KEY_KPPLUSMINUS] = "KeyPad +/-";
+/*        buttonIDs[NativeDefinitions.KEY_F21] = "F21";
+        buttonIDs[NativeDefinitions.KEY_F22] = "F22";
+        buttonIDs[NativeDefinitions.KEY_F23] = "F23";
+        buttonIDs[NativeDefinitions.KEY_F24] = "F24";
+        buttonIDs[NativeDefinitions.KEY_KPCOMMA] = "KeyPad comma";
+        buttonIDs[NativeDefinitions.KEY_LEFTMETA] = "LH Meta";
+        buttonIDs[NativeDefinitions.KEY_RIGHTMETA] = "RH Meta";
+        buttonIDs[NativeDefinitions.KEY_COMPOSE] = "Compose";
+        buttonIDs[NativeDefinitions.KEY_STOP] = "Stop";
+        buttonIDs[NativeDefinitions.KEY_AGAIN] = "Again";
+        buttonIDs[NativeDefinitions.KEY_PROPS] = "Properties";
+        buttonIDs[NativeDefinitions.KEY_UNDO] = "Undo";
+        buttonIDs[NativeDefinitions.KEY_FRONT] = "Front";
+        buttonIDs[NativeDefinitions.KEY_COPY] = "Copy";
+        buttonIDs[NativeDefinitions.KEY_OPEN] = "Open";
+        buttonIDs[NativeDefinitions.KEY_PASTE] = "Paste";
+        buttonIDs[NativeDefinitions.KEY_FIND] = "Find";
+        buttonIDs[NativeDefinitions.KEY_CUT] = "Cut";
+        buttonIDs[NativeDefinitions.KEY_HELP] = "Help";
+        buttonIDs[NativeDefinitions.KEY_MENU] = "Menu";
+        buttonIDs[NativeDefinitions.KEY_CALC] = "Calculator";
+        buttonIDs[NativeDefinitions.KEY_SETUP] = "Setup";*/
+        buttonIDs[NativeDefinitions.KEY_SLEEP] = StandardKeyboard.KeyID.SLEEP;
+        /*buttonIDs[NativeDefinitions.KEY_WAKEUP] = "Wakeup";
+        buttonIDs[NativeDefinitions.KEY_FILE] = "File";
+        buttonIDs[NativeDefinitions.KEY_SENDFILE] = "Send File";
+        buttonIDs[NativeDefinitions.KEY_DELETEFILE] = "Delete File";
+        buttonIDs[NativeDefinitions.KEY_XFER] = "Transfer";
+        buttonIDs[NativeDefinitions.KEY_PROG1] = "Program 1";
+        buttonIDs[NativeDefinitions.KEY_PROG2] = "Program 2";
+        buttonIDs[NativeDefinitions.KEY_WWW] = "Web Browser";
+        buttonIDs[NativeDefinitions.KEY_MSDOS] = "DOS mode";
+        buttonIDs[NativeDefinitions.KEY_COFFEE] = "Coffee";
+        buttonIDs[NativeDefinitions.KEY_DIRECTION] = "Direction";
+        buttonIDs[NativeDefinitions.KEY_CYCLEWINDOWS] = "Window cycle";
+        buttonIDs[NativeDefinitions.KEY_MAIL] = "Mail";
+        buttonIDs[NativeDefinitions.KEY_BOOKMARKS] = "Book Marks";
+        buttonIDs[NativeDefinitions.KEY_COMPUTER] = "Computer";
+        buttonIDs[NativeDefinitions.KEY_BACK] = "Back";
+        buttonIDs[NativeDefinitions.KEY_FORWARD] = "Forward";
+        buttonIDs[NativeDefinitions.KEY_CLOSECD] = "Close CD";
+        buttonIDs[NativeDefinitions.KEY_EJECTCD] = "Eject CD";
+        buttonIDs[NativeDefinitions.KEY_EJECTCLOSECD] = "Eject / Close CD";
+        buttonIDs[NativeDefinitions.KEY_NEXTSONG] = "Next Song";
+        buttonIDs[NativeDefinitions.KEY_PLAYPAUSE] = "Play and Pause";
+        buttonIDs[NativeDefinitions.KEY_PREVIOUSSONG] = "Previous Song";
+        buttonIDs[NativeDefinitions.KEY_STOPCD] = "Stop CD";
+        buttonIDs[NativeDefinitions.KEY_RECORD] = "Record";
+        buttonIDs[NativeDefinitions.KEY_REWIND] = "Rewind";
+        buttonIDs[NativeDefinitions.KEY_PHONE] = "Phone";
+        buttonIDs[NativeDefinitions.KEY_ISO] = "ISO";
+        buttonIDs[NativeDefinitions.KEY_CONFIG] = "Config";
+        buttonIDs[NativeDefinitions.KEY_HOMEPAGE] = "Home";
+        buttonIDs[NativeDefinitions.KEY_REFRESH] = "Refresh";
+        buttonIDs[NativeDefinitions.KEY_EXIT] = "Exit";
+        buttonIDs[NativeDefinitions.KEY_MOVE] = "Move";
+        buttonIDs[NativeDefinitions.KEY_EDIT] = "Edit";
+        buttonIDs[NativeDefinitions.KEY_SCROLLUP] = "Scroll Up";
+        buttonIDs[NativeDefinitions.KEY_SCROLLDOWN] = "Scroll Down";
+        buttonIDs[NativeDefinitions.KEY_KPLEFTPAREN] = "KeyPad LH parenthesis";
+        buttonIDs[NativeDefinitions.KEY_KPRIGHTPAREN] = "KeyPad RH parenthesis";
+        buttonIDs[NativeDefinitions.KEY_INTL1] = "Intl 1";
+        buttonIDs[NativeDefinitions.KEY_INTL2] = "Intl 2";
+        buttonIDs[NativeDefinitions.KEY_INTL3] = "Intl 3";
+        buttonIDs[NativeDefinitions.KEY_INTL4] = "Intl 4";
+        buttonIDs[NativeDefinitions.KEY_INTL5] = "Intl 5";
+        buttonIDs[NativeDefinitions.KEY_INTL6] = "Intl 6";
+        buttonIDs[NativeDefinitions.KEY_INTL7] = "Intl 7";
+        buttonIDs[NativeDefinitions.KEY_INTL8] = "Intl 8";
+        buttonIDs[NativeDefinitions.KEY_INTL9] = "Intl 9";
+        buttonIDs[NativeDefinitions.KEY_LANG1] = "Language 1";
+        buttonIDs[NativeDefinitions.KEY_LANG2] = "Language 2";
+        buttonIDs[NativeDefinitions.KEY_LANG3] = "Language 3";
+        buttonIDs[NativeDefinitions.KEY_LANG4] = "Language 4";
+        buttonIDs[NativeDefinitions.KEY_LANG5] = "Language 5";
+        buttonIDs[NativeDefinitions.KEY_LANG6] = "Language 6";
+        buttonIDs[NativeDefinitions.KEY_LANG7] = "Language 7";
+        buttonIDs[NativeDefinitions.KEY_LANG8] = "Language 8";
+        buttonIDs[NativeDefinitions.KEY_LANG9] = "Language 9";
+        buttonIDs[NativeDefinitions.KEY_PLAYCD] = "Play CD";
+        buttonIDs[NativeDefinitions.KEY_PAUSECD] = "Pause CD";
+        buttonIDs[NativeDefinitions.KEY_PROG3] = "Program 3";
+        buttonIDs[NativeDefinitions.KEY_PROG4] = "Program 4";
+        buttonIDs[NativeDefinitions.KEY_SUSPEND] = "Suspend";
+        buttonIDs[NativeDefinitions.KEY_CLOSE] = "Close";*/
+        buttonIDs[NativeDefinitions.KEY_UNKNOWN] = StandardKeyboard.KeyID.UNLABELED;
+        /*buttonIDs[NativeDefinitions.KEY_BRIGHTNESSDOWN] = "Brightness Down";
+        buttonIDs[NativeDefinitions.KEY_BRIGHTNESSUP] = "Brightness Up";*/
+        
+        //Msic keys
+        buttonIDs[NativeDefinitions.BTN_0] = LinuxDevice.ButtonID.BTN_0;
+        buttonIDs[NativeDefinitions.BTN_1] = LinuxDevice.ButtonID.BTN_1;
+        buttonIDs[NativeDefinitions.BTN_2] = LinuxDevice.ButtonID.BTN_2;
+        buttonIDs[NativeDefinitions.BTN_3] = LinuxDevice.ButtonID.BTN_3;
+        buttonIDs[NativeDefinitions.BTN_4] = LinuxDevice.ButtonID.BTN_4;
+        buttonIDs[NativeDefinitions.BTN_5] = LinuxDevice.ButtonID.BTN_5;
+        buttonIDs[NativeDefinitions.BTN_6] = LinuxDevice.ButtonID.BTN_6;
+        buttonIDs[NativeDefinitions.BTN_7] = LinuxDevice.ButtonID.BTN_7;
+        buttonIDs[NativeDefinitions.BTN_8] = LinuxDevice.ButtonID.BTN_8;
+        buttonIDs[NativeDefinitions.BTN_9] = LinuxDevice.ButtonID.BTN_9;
+        
+        // Mouse
+        buttonIDs[NativeDefinitions.BTN_LEFT] = Mouse.ButtonID.LEFT;
+        buttonIDs[NativeDefinitions.BTN_RIGHT] = Mouse.ButtonID.RIGHT;
+        buttonIDs[NativeDefinitions.BTN_MIDDLE] = Mouse.ButtonID.MIDDLE;
+        buttonIDs[NativeDefinitions.BTN_SIDE] = Mouse.ButtonID.SIDE;
+        buttonIDs[NativeDefinitions.BTN_EXTRA] = Mouse.ButtonID.EXTRA;
+        buttonIDs[NativeDefinitions.BTN_FORWARD] = Mouse.ButtonID.FORWARD;
+        buttonIDs[NativeDefinitions.BTN_BACK] = Mouse.ButtonID.BACK;
+        
+        // Joystick
+        buttonIDs[NativeDefinitions.BTN_TRIGGER] = LinuxDevice.ButtonID.BTN_TRIGGER;
+        buttonIDs[NativeDefinitions.BTN_THUMB] = LinuxDevice.ButtonID.BTN_THUMB;
+        buttonIDs[NativeDefinitions.BTN_THUMB2] = LinuxDevice.ButtonID.BTN_THUMB2;
+        buttonIDs[NativeDefinitions.BTN_TOP] = LinuxDevice.ButtonID.BTN_TOP;
+        buttonIDs[NativeDefinitions.BTN_TOP2] = LinuxDevice.ButtonID.BTN_TOP2;
+        buttonIDs[NativeDefinitions.BTN_PINKIE] = LinuxDevice.ButtonID.BTN_PINKIE;
+        buttonIDs[NativeDefinitions.BTN_BASE] = LinuxDevice.ButtonID.BTN_BASE;
+        buttonIDs[NativeDefinitions.BTN_BASE2] = LinuxDevice.ButtonID.BTN_BASE2;
+        buttonIDs[NativeDefinitions.BTN_BASE3] = LinuxDevice.ButtonID.BTN_BASE3;
+        buttonIDs[NativeDefinitions.BTN_BASE4] = LinuxDevice.ButtonID.BTN_BASE4;
+        buttonIDs[NativeDefinitions.BTN_BASE5] = LinuxDevice.ButtonID.BTN_BASE5;
+        buttonIDs[NativeDefinitions.BTN_BASE6] = LinuxDevice.ButtonID.BTN_BASE6;
+        buttonIDs[NativeDefinitions.BTN_DEAD] = LinuxDevice.ButtonID.BTN_DEAD;
+        
+        // Gamepad
+        buttonIDs[NativeDefinitions.BTN_A] = LinuxDevice.ButtonID.BTN_A;
+        buttonIDs[NativeDefinitions.BTN_B] = LinuxDevice.ButtonID.BTN_B;
+        buttonIDs[NativeDefinitions.BTN_C] = LinuxDevice.ButtonID.BTN_C;
+        buttonIDs[NativeDefinitions.BTN_X] = LinuxDevice.ButtonID.BTN_X;
+        buttonIDs[NativeDefinitions.BTN_Y] = LinuxDevice.ButtonID.BTN_Y;
+        buttonIDs[NativeDefinitions.BTN_Z] = LinuxDevice.ButtonID.BTN_Z;
+        buttonIDs[NativeDefinitions.BTN_TL] = LinuxDevice.ButtonID.BTN_TL;
+        buttonIDs[NativeDefinitions.BTN_TR] = LinuxDevice.ButtonID.BTN_TR;
+        buttonIDs[NativeDefinitions.BTN_TL2] = LinuxDevice.ButtonID.BTN_TL2;
+        buttonIDs[NativeDefinitions.BTN_TR2] = LinuxDevice.ButtonID.BTN_TR2;
+        buttonIDs[NativeDefinitions.BTN_SELECT] = LinuxDevice.ButtonID.BTN_SELECT;
+        buttonIDs[NativeDefinitions.BTN_MODE] = LinuxDevice.ButtonID.BTN_MODE;
+        buttonIDs[NativeDefinitions.BTN_THUMBL] = LinuxDevice.ButtonID.BTN_THUMBL;
+        buttonIDs[NativeDefinitions.BTN_THUMBR] = LinuxDevice.ButtonID.BTN_THUMBR;
+        
+        // Digitiser
+        buttonIDs[NativeDefinitions.BTN_TOOL_PEN] = LinuxDevice.ButtonID.BTN_TOOL_PEN;
+        buttonIDs[NativeDefinitions.BTN_TOOL_RUBBER] = LinuxDevice.ButtonID.BTN_TOOL_RUBBER;
+        buttonIDs[NativeDefinitions.BTN_TOOL_BRUSH] = LinuxDevice.ButtonID.BTN_TOOL_BRUSH;
+        buttonIDs[NativeDefinitions.BTN_TOOL_PENCIL] = LinuxDevice.ButtonID.BTN_TOOL_PENCIL;
+        buttonIDs[NativeDefinitions.BTN_TOOL_AIRBRUSH] = LinuxDevice.ButtonID.BTN_TOOL_AIRBRUSH;
+        buttonIDs[NativeDefinitions.BTN_TOOL_FINGER] = LinuxDevice.ButtonID.BTN_TOOL_FINGER;
+        buttonIDs[NativeDefinitions.BTN_TOOL_MOUSE] = LinuxDevice.ButtonID.BTN_TOOL_MOUSE;
+        buttonIDs[NativeDefinitions.BTN_TOOL_LENS] = LinuxDevice.ButtonID.BTN_TOOL_LENS;
+        buttonIDs[NativeDefinitions.BTN_TOUCH] = LinuxDevice.ButtonID.BTN_TOUCH;
+        buttonIDs[NativeDefinitions.BTN_STYLUS] = LinuxDevice.ButtonID.BTN_STYLUS;
+        buttonIDs[NativeDefinitions.BTN_STYLUS2] = LinuxDevice.ButtonID.BTN_STYLUS2;
+        
+        relAxesNames = new String[NativeDefinitions.REL_MAX];
+        relAxesNames[NativeDefinitions.REL_X] = "X axis";
+        relAxesNames[NativeDefinitions.REL_Y] = "Y axis";
+        relAxesNames[NativeDefinitions.REL_Z] = "Z axis";
+        relAxesNames[NativeDefinitions.REL_HWHEEL] ="Horizontal wheel";
+        relAxesNames[NativeDefinitions.REL_DIAL] = "Dial";
+        relAxesNames[NativeDefinitions.REL_WHEEL] = "Vertical wheel";
+        relAxesNames[NativeDefinitions.REL_MISC] = "Miscellaneous";
+        
+        relAxesIDs = new Axis.Identifier[NativeDefinitions.REL_MAX];
+        relAxesIDs[NativeDefinitions.REL_X] = Axis.Identifier.X;
+        relAxesIDs[NativeDefinitions.REL_Y] = Axis.Identifier.Y;
+        relAxesIDs[NativeDefinitions.REL_Z] = Axis.Identifier.Z;
+        relAxesIDs[NativeDefinitions.REL_WHEEL] = Axis.Identifier.SLIDER;
+        // There are guesses as I have no idea what they would be used for
+        relAxesIDs[NativeDefinitions.REL_HWHEEL] = Axis.Identifier.SLIDER;
+        relAxesIDs[NativeDefinitions.REL_DIAL] = Axis.Identifier.SLIDER;
+        relAxesIDs[NativeDefinitions.REL_MISC] = Axis.Identifier.SLIDER;
+        
+        absAxesNames = new String[NativeDefinitions.ABS_MAX];
+        absAxesNames[NativeDefinitions.ABS_X] = "X axis";
+        absAxesNames[NativeDefinitions.ABS_Y] = "Y axis";
+        absAxesNames[NativeDefinitions.ABS_Z] = "Z axis";        
+        absAxesNames[NativeDefinitions.ABS_RX] = "X rate axis";
+        absAxesNames[NativeDefinitions.ABS_RY] = "Y rate axis";
+        absAxesNames[NativeDefinitions.ABS_RZ] = "Z rate axis";
+        absAxesNames[NativeDefinitions.ABS_THROTTLE] = "Throttle";
+        absAxesNames[NativeDefinitions.ABS_RUDDER] = "Rudder";
+        absAxesNames[NativeDefinitions.ABS_WHEEL] = "Wheel";
+        absAxesNames[NativeDefinitions.ABS_GAS] = "Accelerator";
+        absAxesNames[NativeDefinitions.ABS_BRAKE] = "Brake";
+        // Hats are done this way as they are mapped from two axis down to one
+        absAxesNames[NativeDefinitions.ABS_HAT0X] = "Hat 1";
+        absAxesNames[NativeDefinitions.ABS_HAT0Y] = "Hat 1";
+        absAxesNames[NativeDefinitions.ABS_HAT1X] = "Hat 2";
+        absAxesNames[NativeDefinitions.ABS_HAT1Y] = "Hat 2";
+        absAxesNames[NativeDefinitions.ABS_HAT2X] = "Hat 3";
+        absAxesNames[NativeDefinitions.ABS_HAT2Y] = "Hat 3";
+        absAxesNames[NativeDefinitions.ABS_HAT3X] = "Hat 4";
+        absAxesNames[NativeDefinitions.ABS_HAT3Y] = "Hat 4";
+        absAxesNames[NativeDefinitions.ABS_PRESSURE] = "Pressure";
+        absAxesNames[NativeDefinitions.ABS_DISTANCE] = "Distance";
+        absAxesNames[NativeDefinitions.ABS_TILT_X] = "X axis tilt";
+        absAxesNames[NativeDefinitions.ABS_TILT_Y] = "Y axis tilt";
+        absAxesNames[NativeDefinitions.ABS_MISC] = "Miscellaneous";
+        
+        absAxesIDs = new Axis.Identifier[NativeDefinitions.ABS_MAX];
+        absAxesIDs[NativeDefinitions.ABS_X] = Axis.Identifier.X;
+        absAxesIDs[NativeDefinitions.ABS_Y] = Axis.Identifier.Y;
+        absAxesIDs[NativeDefinitions.ABS_Z] = Axis.Identifier.Z;
+        absAxesIDs[NativeDefinitions.ABS_RX] = Axis.Identifier.RX;
+        absAxesIDs[NativeDefinitions.ABS_RY] = Axis.Identifier.RY;
+        absAxesIDs[NativeDefinitions.ABS_RZ] = Axis.Identifier.RZ;
+        absAxesIDs[NativeDefinitions.ABS_THROTTLE] = Axis.Identifier.SLIDER;
+        absAxesIDs[NativeDefinitions.ABS_RUDDER] = Axis.Identifier.RZ;
+        absAxesIDs[NativeDefinitions.ABS_WHEEL] = Axis.Identifier.Y;
+        absAxesIDs[NativeDefinitions.ABS_GAS] = Axis.Identifier.SLIDER;
+        absAxesIDs[NativeDefinitions.ABS_BRAKE] = Axis.Identifier.SLIDER;
+        // Hats are done this way as they are mapped from two axis down to one
+        absAxesIDs[NativeDefinitions.ABS_HAT0X] = Axis.Identifier.POV;
+        absAxesIDs[NativeDefinitions.ABS_HAT0Y] = Axis.Identifier.POV;
+        absAxesIDs[NativeDefinitions.ABS_HAT1X] = Axis.Identifier.POV;
+        absAxesIDs[NativeDefinitions.ABS_HAT1Y] = Axis.Identifier.POV;
+        absAxesIDs[NativeDefinitions.ABS_HAT2X] = Axis.Identifier.POV;
+        absAxesIDs[NativeDefinitions.ABS_HAT2Y] = Axis.Identifier.POV;
+        absAxesIDs[NativeDefinitions.ABS_HAT3X] = Axis.Identifier.POV;
+        absAxesIDs[NativeDefinitions.ABS_HAT3Y] = Axis.Identifier.POV;
+        // erm, yeah
+        absAxesIDs[NativeDefinitions.ABS_PRESSURE] = null;
+        absAxesIDs[NativeDefinitions.ABS_DISTANCE] = null;
+        absAxesIDs[NativeDefinitions.ABS_TILT_X] = null;
+        absAxesIDs[NativeDefinitions.ABS_TILT_Y] = null;
+        absAxesIDs[NativeDefinitions.ABS_MISC] = null;
+        
+    }
+    
+    /** Return port type from a native port type int id
+     * @param nativeid The native port type
+     * @return The jinput port type
+     */    
+    public static Controller.PortType getPortType(int nativeid) {
+        // Have to do this one this way as there is no BUS_MAX
+        switch (nativeid) {
+            case NativeDefinitions.BUS_GAMEPORT :
+                return Controller.PortType.GAME;
+            case NativeDefinitions.BUS_I8042 :
+                return Controller.PortType.I8042;
+            case NativeDefinitions.BUS_PARPORT :
+                return Controller.PortType.PARALLEL;
+            case NativeDefinitions.BUS_RS232 :
+                return Controller.PortType.SERIAL;
+            case NativeDefinitions.BUS_USB :
+                return Controller.PortType.USB;
+            default:
+                return Controller.PortType.UNKNOWN;
+        }
+    }
+    
+    /** Returns the name of a native button
+     * @param nativeID The native button type id
+     * @return The button name
+     */    
+    public static String getButtonName(int nativeID) {
+        String retval = INSTANCE.keyNames[nativeID];
+        //if(retval == null){
+        //    retval = "Unknown button id";
+        //    INSTANCE.keyNames[nativeID] = retval;
+        //}
+        return retval;
+    }
+    
+    /** Retursn the name of the native relative axis
+     * @param nativeID The axis type ID
+     * @return The axis name
+     */    
+    public static String getRelAxisName(int nativeID) {
+        String retval = INSTANCE.relAxesNames[nativeID];
+        if(retval == null) {
+            retval = "Unknown relative axis id";
+            INSTANCE.relAxesNames[nativeID] = retval;
+        }
+        return retval;
+    }
+    
+    /** Retursn the name of the native absolute axis
+     * @param nativeID The native axis type ID
+     * @return The name of the axis
+     */    
+    public static String getAbsAxisName(int nativeID) {
+        String retval = INSTANCE.absAxesNames[nativeID];
+        if(retval == null) {
+            retval = "Unknown absolute axis id";
+            INSTANCE.absAxesNames[nativeID] = retval;
+        }
+        return retval;
+    }
+    
+    /** Gets the identifier for a relative axis
+     * @param nativeID The axis type ID
+     * @return The jinput id
+     */    
+    public static Axis.Identifier getRelAxisID(int nativeID) {
+        Axis.Identifier retval = INSTANCE.relAxesIDs[nativeID];
+        if(retval == null) {
+            retval = Axis.Identifier.SLIDER_VELOCITY;
+            INSTANCE.relAxesIDs[nativeID] = retval;
+        }
+        return retval;
+    }
+    
+    /** Gets the identifier for a absolute axis
+     * @param nativeID The native axis type id
+     * @return The jinput id
+     */    
+    public static Axis.Identifier getAbsAxisID(int nativeID) {
+        Axis.Identifier retval = INSTANCE.absAxesIDs[nativeID];
+        if(retval == null) {
+            retval = Axis.Identifier.SLIDER;
+            INSTANCE.absAxesIDs[nativeID] = retval;
+        }
+        return retval;
+    }
+    
+    /** Gets the identifier for a button
+     * @param nativeID The native button type id
+     * @return The jinput id
+     */    
+    public static Axis.Identifier getButtonID(int nativeID) {
+        Axis.Identifier retval = INSTANCE.buttonIDs[nativeID];
+        if(retval == null) {
+            //System.out.println("Creating new KeyID for nativeID " + nativeID);
+            retval = new LinuxKeyboard.KeyID(nativeID, getButtonName(nativeID));
+            INSTANCE.buttonIDs[nativeID] = retval;
+        }
+        return retval;
+    }
+    
+}
diff --git a/plugins/linux/src/java/net/java/games/input/NativeDefinitions.java b/plugins/linux/src/java/net/java/games/input/NativeDefinitions.java
new file mode 100644
index 0000000..12d3379
--- /dev/null
+++ b/plugins/linux/src/java/net/java/games/input/NativeDefinitions.java
@@ -0,0 +1,323 @@
+package net.java.games.input;
+
+
+/**
+ * This file is generated from /usr/include/linux/input.h please do not edit
+ */
+public class NativeDefinitions {
+    public static final int KEY_RESERVED = 0;
+    public static final int KEY_ESC = 1;
+    public static final int KEY_1 = 2;
+    public static final int KEY_2 = 3;
+    public static final int KEY_3 = 4;
+    public static final int KEY_4 = 5;
+    public static final int KEY_5 = 6;
+    public static final int KEY_6 = 7;
+    public static final int KEY_7 = 8;
+    public static final int KEY_8 = 9;
+    public static final int KEY_9 = 10;
+    public static final int KEY_0 = 11;
+    public static final int KEY_MINUS = 12;
+    public static final int KEY_EQUAL = 13;
+    public static final int KEY_BACKSPACE = 14;
+    public static final int KEY_TAB = 15;
+    public static final int KEY_Q = 16;
+    public static final int KEY_W = 17;
+    public static final int KEY_E = 18;
+    public static final int KEY_R = 19;
+    public static final int KEY_T = 20;
+    public static final int KEY_Y = 21;
+    public static final int KEY_U = 22;
+    public static final int KEY_I = 23;
+    public static final int KEY_O = 24;
+    public static final int KEY_P = 25;
+    public static final int KEY_LEFTBRACE = 26;
+    public static final int KEY_RIGHTBRACE = 27;
+    public static final int KEY_ENTER = 28;
+    public static final int KEY_LEFTCTRL = 29;
+    public static final int KEY_A = 30;
+    public static final int KEY_S = 31;
+    public static final int KEY_D = 32;
+    public static final int KEY_F = 33;
+    public static final int KEY_G = 34;
+    public static final int KEY_H = 35;
+    public static final int KEY_J = 36;
+    public static final int KEY_K = 37;
+    public static final int KEY_L = 38;
+    public static final int KEY_SEMICOLON = 39;
+    public static final int KEY_APOSTROPHE = 40;
+    public static final int KEY_GRAVE = 41;
+    public static final int KEY_LEFTSHIFT = 42;
+    public static final int KEY_BACKSLASH = 43;
+    public static final int KEY_Z = 44;
+    public static final int KEY_X = 45;
+    public static final int KEY_C = 46;
+    public static final int KEY_V = 47;
+    public static final int KEY_B = 48;
+    public static final int KEY_N = 49;
+    public static final int KEY_M = 50;
+    public static final int KEY_COMMA = 51;
+    public static final int KEY_DOT = 52;
+    public static final int KEY_SLASH = 53;
+    public static final int KEY_RIGHTSHIFT = 54;
+    public static final int KEY_KPASTERISK = 55;
+    public static final int KEY_LEFTALT = 56;
+    public static final int KEY_SPACE = 57;
+    public static final int KEY_CAPSLOCK = 58;
+    public static final int KEY_F1 = 59;
+    public static final int KEY_F2 = 60;
+    public static final int KEY_F3 = 61;
+    public static final int KEY_F4 = 62;
+    public static final int KEY_F5 = 63;
+    public static final int KEY_F6 = 64;
+    public static final int KEY_F7 = 65;
+    public static final int KEY_F8 = 66;
+    public static final int KEY_F9 = 67;
+    public static final int KEY_F10 = 68;
+    public static final int KEY_NUMLOCK = 69;
+    public static final int KEY_SCROLLLOCK = 70;
+    public static final int KEY_KP7 = 71;
+    public static final int KEY_KP8 = 72;
+    public static final int KEY_KP9 = 73;
+    public static final int KEY_KPMINUS = 74;
+    public static final int KEY_KP4 = 75;
+    public static final int KEY_KP5 = 76;
+    public static final int KEY_KP6 = 77;
+    public static final int KEY_KPPLUS = 78;
+    public static final int KEY_KP1 = 79;
+    public static final int KEY_KP2 = 80;
+    public static final int KEY_KP3 = 81;
+    public static final int KEY_KP0 = 82;
+    public static final int KEY_KPDOT = 83;
+    public static final int KEY_103RD = 84;
+    public static final int KEY_F13 = 85;
+    public static final int KEY_102ND = 86;
+    public static final int KEY_F11 = 87;
+    public static final int KEY_F12 = 88;
+    public static final int KEY_F14 = 89;
+    public static final int KEY_F15 = 90;
+    public static final int KEY_F16 = 91;
+    public static final int KEY_F17 = 92;
+    public static final int KEY_F18 = 93;
+    public static final int KEY_F19 = 94;
+    public static final int KEY_F20 = 95;
+    public static final int KEY_KPENTER = 96;
+    public static final int KEY_RIGHTCTRL = 97;
+    public static final int KEY_KPSLASH = 98;
+    public static final int KEY_SYSRQ = 99;
+    public static final int KEY_RIGHTALT = 100;
+    public static final int KEY_LINEFEED = 101;
+    public static final int KEY_HOME = 102;
+    public static final int KEY_UP = 103;
+    public static final int KEY_PAGEUP = 104;
+    public static final int KEY_LEFT = 105;
+    public static final int KEY_RIGHT = 106;
+    public static final int KEY_END = 107;
+    public static final int KEY_DOWN = 108;
+    public static final int KEY_PAGEDOWN = 109;
+    public static final int KEY_INSERT = 110;
+    public static final int KEY_DELETE = 111;
+    public static final int KEY_MACRO = 112;
+    public static final int KEY_MUTE = 113;
+    public static final int KEY_VOLUMEDOWN = 114;
+    public static final int KEY_VOLUMEUP = 115;
+    public static final int KEY_POWER = 116;
+    public static final int KEY_KPEQUAL = 117;
+    public static final int KEY_KPPLUSMINUS = 118;
+    public static final int KEY_PAUSE = 119;
+    public static final int KEY_F21 = 120;
+    public static final int KEY_F22 = 121;
+    public static final int KEY_F23 = 122;
+    public static final int KEY_F24 = 123;
+    public static final int KEY_KPCOMMA = 124;
+    public static final int KEY_LEFTMETA = 125;
+    public static final int KEY_RIGHTMETA = 126;
+    public static final int KEY_COMPOSE = 127;
+    public static final int KEY_STOP = 128;
+    public static final int KEY_AGAIN = 129;
+    public static final int KEY_PROPS = 130;
+    public static final int KEY_UNDO = 131;
+    public static final int KEY_FRONT = 132;
+    public static final int KEY_COPY = 133;
+    public static final int KEY_OPEN = 134;
+    public static final int KEY_PASTE = 135;
+    public static final int KEY_FIND = 136;
+    public static final int KEY_CUT = 137;
+    public static final int KEY_HELP = 138;
+    public static final int KEY_MENU = 139;
+    public static final int KEY_CALC = 140;
+    public static final int KEY_SETUP = 141;
+    public static final int KEY_SLEEP = 142;
+    public static final int KEY_WAKEUP = 143;
+    public static final int KEY_FILE = 144;
+    public static final int KEY_SENDFILE = 145;
+    public static final int KEY_DELETEFILE = 146;
+    public static final int KEY_XFER = 147;
+    public static final int KEY_PROG1 = 148;
+    public static final int KEY_PROG2 = 149;
+    public static final int KEY_WWW = 150;
+    public static final int KEY_MSDOS = 151;
+    public static final int KEY_COFFEE = 152;
+    public static final int KEY_DIRECTION = 153;
+    public static final int KEY_CYCLEWINDOWS = 154;
+    public static final int KEY_MAIL = 155;
+    public static final int KEY_BOOKMARKS = 156;
+    public static final int KEY_COMPUTER = 157;
+    public static final int KEY_BACK = 158;
+    public static final int KEY_FORWARD = 159;
+    public static final int KEY_CLOSECD = 160;
+    public static final int KEY_EJECTCD = 161;
+    public static final int KEY_EJECTCLOSECD = 162;
+    public static final int KEY_NEXTSONG = 163;
+    public static final int KEY_PLAYPAUSE = 164;
+    public static final int KEY_PREVIOUSSONG = 165;
+    public static final int KEY_STOPCD = 166;
+    public static final int KEY_RECORD = 167;
+    public static final int KEY_REWIND = 168;
+    public static final int KEY_PHONE = 169;
+    public static final int KEY_ISO = 170;
+    public static final int KEY_CONFIG = 171;
+    public static final int KEY_HOMEPAGE = 172;
+    public static final int KEY_REFRESH = 173;
+    public static final int KEY_EXIT = 174;
+    public static final int KEY_MOVE = 175;
+    public static final int KEY_EDIT = 176;
+    public static final int KEY_SCROLLUP = 177;
+    public static final int KEY_SCROLLDOWN = 178;
+    public static final int KEY_KPLEFTPAREN = 179;
+    public static final int KEY_KPRIGHTPAREN = 180;
+    public static final int KEY_INTL1 = 181;
+    public static final int KEY_INTL2 = 182;
+    public static final int KEY_INTL3 = 183;
+    public static final int KEY_INTL4 = 184;
+    public static final int KEY_INTL5 = 185;
+    public static final int KEY_INTL6 = 186;
+    public static final int KEY_INTL7 = 187;
+    public static final int KEY_INTL8 = 188;
+    public static final int KEY_INTL9 = 189;
+    public static final int KEY_LANG1 = 190;
+    public static final int KEY_LANG2 = 191;
+    public static final int KEY_LANG3 = 192;
+    public static final int KEY_LANG4 = 193;
+    public static final int KEY_LANG5 = 194;
+    public static final int KEY_LANG6 = 195;
+    public static final int KEY_LANG7 = 196;
+    public static final int KEY_LANG8 = 197;
+    public static final int KEY_LANG9 = 198;
+    public static final int KEY_PLAYCD = 200;
+    public static final int KEY_PAUSECD = 201;
+    public static final int KEY_PROG3 = 202;
+    public static final int KEY_PROG4 = 203;
+    public static final int KEY_SUSPEND = 205;
+    public static final int KEY_CLOSE = 206;
+    public static final int KEY_UNKNOWN = 220;
+    public static final int KEY_BRIGHTNESSDOWN = 224;
+    public static final int KEY_BRIGHTNESSUP = 225;
+    public static final int BTN_MISC = 0x100;
+    public static final int BTN_0 = 0x100;
+    public static final int BTN_1 = 0x101;
+    public static final int BTN_2 = 0x102;
+    public static final int BTN_3 = 0x103;
+    public static final int BTN_4 = 0x104;
+    public static final int BTN_5 = 0x105;
+    public static final int BTN_6 = 0x106;
+    public static final int BTN_7 = 0x107;
+    public static final int BTN_8 = 0x108;
+    public static final int BTN_9 = 0x109;
+    public static final int BTN_MOUSE = 0x110;
+    public static final int BTN_LEFT = 0x110;
+    public static final int BTN_RIGHT = 0x111;
+    public static final int BTN_MIDDLE = 0x112;
+    public static final int BTN_SIDE = 0x113;
+    public static final int BTN_EXTRA = 0x114;
+    public static final int BTN_FORWARD = 0x115;
+    public static final int BTN_BACK = 0x116;
+    public static final int BTN_JOYSTICK = 0x120;
+    public static final int BTN_TRIGGER = 0x120;
+    public static final int BTN_THUMB = 0x121;
+    public static final int BTN_THUMB2 = 0x122;
+    public static final int BTN_TOP = 0x123;
+    public static final int BTN_TOP2 = 0x124;
+    public static final int BTN_PINKIE = 0x125;
+    public static final int BTN_BASE = 0x126;
+    public static final int BTN_BASE2 = 0x127;
+    public static final int BTN_BASE3 = 0x128;
+    public static final int BTN_BASE4 = 0x129;
+    public static final int BTN_BASE5 = 0x12a;
+    public static final int BTN_BASE6 = 0x12b;
+    public static final int BTN_DEAD = 0x12f;
+    public static final int BTN_GAMEPAD = 0x130;
+    public static final int BTN_A = 0x130;
+    public static final int BTN_B = 0x131;
+    public static final int BTN_C = 0x132;
+    public static final int BTN_X = 0x133;
+    public static final int BTN_Y = 0x134;
+    public static final int BTN_Z = 0x135;
+    public static final int BTN_TL = 0x136;
+    public static final int BTN_TR = 0x137;
+    public static final int BTN_TL2 = 0x138;
+    public static final int BTN_TR2 = 0x139;
+    public static final int BTN_SELECT = 0x13a;
+    public static final int BTN_START = 0x13b;
+    public static final int BTN_MODE = 0x13c;
+    public static final int BTN_THUMBL = 0x13d;
+    public static final int BTN_THUMBR = 0x13e;
+    public static final int BTN_DIGI = 0x140;
+    public static final int BTN_TOOL_PEN = 0x140;
+    public static final int BTN_TOOL_RUBBER = 0x141;
+    public static final int BTN_TOOL_BRUSH = 0x142;
+    public static final int BTN_TOOL_PENCIL = 0x143;
+    public static final int BTN_TOOL_AIRBRUSH = 0x144;
+    public static final int BTN_TOOL_FINGER = 0x145;
+    public static final int BTN_TOOL_MOUSE = 0x146;
+    public static final int BTN_TOOL_LENS = 0x147;
+    public static final int BTN_TOUCH = 0x14a;
+    public static final int BTN_STYLUS = 0x14b;
+    public static final int BTN_STYLUS2 = 0x14c;
+    public static final int KEY_MAX = 0x1ff;
+    public static final int REL_X = 0x00;
+    public static final int REL_Y = 0x01;
+    public static final int REL_Z = 0x02;
+    public static final int REL_HWHEEL = 0x06;
+    public static final int REL_DIAL = 0x07;
+    public static final int REL_WHEEL = 0x08;
+    public static final int REL_MISC = 0x09;
+    public static final int REL_MAX = 0x0f;
+    public static final int ABS_X = 0x00;
+    public static final int ABS_Y = 0x01;
+    public static final int ABS_Z = 0x02;
+    public static final int ABS_RX = 0x03;
+    public static final int ABS_RY = 0x04;
+    public static final int ABS_RZ = 0x05;
+    public static final int ABS_THROTTLE = 0x06;
+    public static final int ABS_RUDDER = 0x07;
+    public static final int ABS_WHEEL = 0x08;
+    public static final int ABS_GAS = 0x09;
+    public static final int ABS_BRAKE = 0x0a;
+    public static final int ABS_HAT0X = 0x10;
+    public static final int ABS_HAT0Y = 0x11;
+    public static final int ABS_HAT1X = 0x12;
+    public static final int ABS_HAT1Y = 0x13;
+    public static final int ABS_HAT2X = 0x14;
+    public static final int ABS_HAT2Y = 0x15;
+    public static final int ABS_HAT3X = 0x16;
+    public static final int ABS_HAT3Y = 0x17;
+    public static final int ABS_PRESSURE = 0x18;
+    public static final int ABS_DISTANCE = 0x19;
+    public static final int ABS_TILT_X = 0x1a;
+    public static final int ABS_TILT_Y = 0x1b;
+    public static final int ABS_MISC = 0x1c;
+    public static final int ABS_MAX = 0x1f;
+    public static final int BUS_PCI = 0x01;
+    public static final int BUS_ISAPNP = 0x02;
+    public static final int BUS_USB = 0x03;
+    public static final int BUS_ISA = 0x10;
+    public static final int BUS_I8042 = 0x11;
+    public static final int BUS_XTKBD = 0x12;
+    public static final int BUS_RS232 = 0x13;
+    public static final int BUS_GAMEPORT = 0x14;
+    public static final int BUS_PARPORT = 0x15;
+    public static final int BUS_AMIGA = 0x16;
+    public static final int BUS_ADB = 0x17;
+    public static final int BUS_I2C = 0x18;
+}
diff --git a/plugins/linux/src/native/Device.h b/plugins/linux/src/native/Device.h
new file mode 100644
index 0000000..020df30
--- /dev/null
+++ b/plugins/linux/src/native/Device.h
@@ -0,0 +1,69 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#if !defined(eventInterface_Device_h)
+#define eventInterface_Device_h
+
+/**
+ * Simple abstract device class
+ *
+ * @author Jeremy Booth ([email protected])
+ */
+class Device {
+
+  private:
+
+  public:
+    /** Maximum name length for a device */
+    const static int MAX_NAME_LENGTH = 256;
+    /** Return the number of relative axes for this device */
+    virtual int getNumberRelAxes() = 0;
+    /** Return the number ofr absolute axes for this device */
+    virtual int getNumberAbsAxes() = 0;
+    /** Return the number of buttons for this device */
+    virtual int getNumberButtons() = 0;
+    /** Get the name of this device */
+    virtual const char *getName() = 0;
+    /** get teh bus type */
+    virtual int getBusType() = 0;
+    virtual int getVendorID() = 0;
+    virtual int getProductID() = 0;
+    virtual int getVersion() = 0;
+    /** Get the supported axes/button maps */
+    virtual void getSupportedRelAxes(int supportedAxis[]) = 0;
+    virtual void getSupportedAbsAxes(int supportedAxis[]) = 0;
+    virtual void getSupportedButtons(int supportedButtons[]) = 0;
+    /** poll it */
+    virtual int poll() = 0;
+    /** get the data */
+    virtual void getPolledData(int relAxesData[], int absAxesData[], int buttonData[]) = 0;
+    /** Get axis details */
+    virtual int getAbsAxisMinimum(int axisNumber) = 0;
+    virtual int getAbsAxisMaximum(int axisNumber) = 0;
+    virtual int getAbsAxisFuzz(int axisNumber) = 0;
+};
+
+#endif //eventInterface_Device_h
diff --git a/plugins/linux/src/native/EventDevice.cpp b/plugins/linux/src/native/EventDevice.cpp
new file mode 100644
index 0000000..de9b5a4
--- /dev/null
+++ b/plugins/linux/src/native/EventDevice.cpp
@@ -0,0 +1,364 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#include "eventInterfaceTypes.h"
+#include "EventDevice.h"
+#include <stdio.h>
+#include <linux/input.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <malloc.h>
+#include <errno.h>
+
+EventDevice::EventDevice(char *deviceFileName) {
+  char tempName[Device::MAX_NAME_LENGTH-1] = "Unknown";
+  int i;
+
+  fd = open(deviceFileName, O_RDWR | O_NONBLOCK);
+  if(fd<0) {
+    char errorMessage[512];
+    sprintf(errorMessage, "Error opening device %s\n", deviceFileName);
+    perror(errorMessage);
+  }
+
+  if(ioctl(fd, EVIOCGNAME(sizeof(tempName)), tempName) < 0) {
+    char errorMessage[512];
+    sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+    perror(errorMessage);
+  }
+
+  int namelength=strlen(tempName);
+  name = (char *)malloc(namelength+1);
+  strncpy(name,tempName, namelength+1);
+
+  uint8_t evtype_bitmask[EV_MAX/8 + 1];
+  memset(evtype_bitmask, 0, sizeof(evtype_bitmask));
+
+  if(ioctl(fd, EVIOCGBIT(0, EV_MAX), evtype_bitmask) < 0) {
+    char errorMessage[512];
+    sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+    perror(errorMessage);
+  }
+
+  struct input_devinfo deviceInfo;
+  if(ioctl(fd, EVIOCGID, &deviceInfo) < 0) {
+    char errorMessage[512];
+    sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+    perror(errorMessage);
+  }
+  
+  bustype = deviceInfo.bustype;
+  vendor = deviceInfo.vendor;
+  product = deviceInfo.product;
+  version = deviceInfo.version;
+
+  numButtons = -1;
+  numAbsAxes = -1;
+  numRelAxes = -1;
+
+  if(!(getBit(EV_KEY, evtype_bitmask))) {
+    numButtons = 0;
+  }
+  if(!(getBit(EV_REL, evtype_bitmask))) {
+    numRelAxes = 0;
+  }
+
+  if(!(getBit(EV_ABS, evtype_bitmask))) {
+    numAbsAxes = 0;
+  }
+
+  if(getBit(EV_FF, evtype_bitmask)) {
+    ffSupported = 1;
+  } else {
+    ffSupported = 0;
+  }
+
+  if(numButtons < 0) {
+    // This device supports keys, deal with it.
+    if(ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bitmask)), key_bitmask) < 0) {
+      char errorMessage[512];
+      sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+      perror(errorMessage);
+    }
+    for(i=0;i<KEY_MAX;i++) {
+      buttonLookup[i]=-1;
+    }
+    short tempSupportedButtons[KEY_MAX];
+    numButtons = 0;
+    for(i=0;i<KEY_MAX;i++) {
+      if(getBit(i,key_bitmask)) {
+        tempSupportedButtons[numButtons] = i;
+        numButtons++;
+      }
+    }
+    supportedButtons = (short *)malloc(numButtons * sizeof(short));
+    buttonData = (uint8_t *)malloc(numButtons * sizeof(uint8_t));
+    for(i=0;i<numButtons;i++) {
+      buttonData[i] = 0;
+      supportedButtons[i] = tempSupportedButtons[i];
+      buttonLookup[supportedButtons[i]] = i;
+    }
+  }
+  
+  if(numRelAxes < 0) {
+    // This device supports axes, deal with it.
+    if(ioctl(fd, EVIOCGBIT(EV_REL, sizeof(rel_bitmask)), rel_bitmask) < 0) {
+      char errorMessage[512];
+      sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+      perror(errorMessage);
+    }
+    for(i=0;i<REL_MAX;i++) {
+      relAxisLookup[i]=-1;
+    }
+    short tempSupportedAxes[REL_MAX];
+    numRelAxes=0;
+    for(i=0;i<REL_MAX;i++) {
+      if(getBit(i,rel_bitmask)) {
+        tempSupportedAxes[numRelAxes] = i;
+        numRelAxes++;
+      }
+    }
+    relAxesData = (int *)malloc(numRelAxes * sizeof(int));
+    supportedRelAxes = (short *)malloc(numRelAxes * sizeof(short));
+    for(i=0;i<numRelAxes;i++) {
+      relAxesData[i]=0;
+      supportedRelAxes[i] = tempSupportedAxes[i];
+      relAxisLookup[supportedRelAxes[i]] = i;
+    }
+  }
+
+
+  if(numAbsAxes < 0) {
+    if(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(abs_bitmask)), abs_bitmask) < 0) {
+      char errorMessage[512];
+      sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+      perror(errorMessage);
+    }
+    for(i=0;i<ABS_MAX;i++) {
+      absAxisLookup[i] = -1;
+    }
+    short tempSupportedAxes[ABS_MAX];
+    numAbsAxes=0;
+    for(i=0;i<ABS_MAX;i++) {
+      if(getBit(i,abs_bitmask)) {
+        tempSupportedAxes[numAbsAxes] = i;
+        numAbsAxes++;
+      }
+    }
+
+    absAxesData = (int *)malloc(numAbsAxes * sizeof(int));
+    supportedAbsAxes = (short *)malloc(numAbsAxes * sizeof(short));
+    for(i=0;i<numAbsAxes;i++) {
+      supportedAbsAxes[i] = tempSupportedAxes[i];
+      absAxisLookup[supportedAbsAxes[i]] = i;
+    }
+
+    abs_features = (struct input_absinfo *)malloc(numAbsAxes * sizeof(struct input_absinfo));
+    for(i=0;i<numAbsAxes;i++) {
+      if(ioctl(fd, EVIOCGABS(supportedAbsAxes[i]), &(abs_features[i]))) {
+        char errorMessage[512];
+        sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+        perror(errorMessage);
+      }
+      absAxesData[i] = abs_features[i].curr_value;
+    }
+  }
+
+  inited = 1;
+}
+
+int EventDevice::getNumberRelAxes(){
+  if(inited!=1) return -1;
+  return numRelAxes;
+}
+
+int EventDevice::getNumberAbsAxes(){
+  if(inited!=1) return -1;
+  return numAbsAxes;
+}
+
+int EventDevice::getNumberButtons(){
+  if(inited!=1) return -1;
+  return numButtons;
+}
+
+const char *EventDevice::getName(){ 
+  return name;
+}
+
+int EventDevice::getBusType(){
+  if(inited!=1) return -1;
+  return bustype;
+}
+
+int EventDevice::getVendorID(){
+  if(inited!=1) return -1;
+  return vendor;
+}
+
+int EventDevice::getProductID(){
+  if(inited!=1) return -1;
+  return product;
+}
+
+int EventDevice::getVersion(){
+  if(inited!=1) return -1;
+  return version;
+}
+
+void EventDevice::getSupportedRelAxes(int supportedAxis[]){
+  int i;
+
+  if(inited!=1) return;
+  for(i=0;i<numRelAxes; i++) {
+    (supportedAxis)[i] = supportedRelAxes[i];
+  }
+}
+
+void EventDevice::getSupportedAbsAxes(int supportedAxis[]){
+  int i;
+
+  if(inited!=1) return;
+  for(i=0;i<numAbsAxes; i++) {
+    (supportedAxis)[i] = supportedAbsAxes[i];
+  }
+}
+
+void EventDevice::getSupportedButtons(int supportedButtons[]){
+  int i;
+
+  if(inited!=1) return;
+  for(i=0;i<numButtons; i++) {
+    (supportedButtons)[i] = this->supportedButtons[i];
+  }
+}
+
+/**
+ * A return value of -1 means error, 0 means ok, but no change
+ * a return of >0 means the data for this device has changed
+ */
+int EventDevice::poll(){
+  size_t read_bytes;
+  struct input_event events[64];
+  int dataChanged=0;
+
+  if(inited!=1) return -1;
+
+  // first thing to do is reset all relative axis as mice never seem to do it
+  int i;
+  for(i=0;i<numRelAxes;i++){
+    if(relAxesData[i]!=0) {
+      dataChanged=1;
+      relAxesData[i]=0;
+    }
+  }
+
+  read_bytes = read(fd, events, sizeof(struct input_event) * 64);
+
+  if(read_bytes == 0) {
+    // no sweat, just return;
+    return 0;
+  }
+ 
+  if(read_bytes == -1) {
+    if(errno == EAGAIN) {
+      // No worries, we are in non blocking and noting is ready
+      return 0;
+    } else {
+      perror("Error reading events: ");
+      return -1;
+    }
+  }
+  
+  if (read_bytes < (int) sizeof(struct input_event)) {
+    perror("Error reading events: ");
+    return -1;
+  }
+
+  int numEventsRead = (int) (read_bytes / sizeof(struct input_event));
+  for(i=0;i<numEventsRead;i++) {
+    switch(events[i].type) {
+      case EV_KEY: {
+        dataChanged = 1;
+        int buttonIndex = buttonLookup[events[i].code];
+        buttonData[buttonIndex] = events[i].value;
+        //printf("button %d translates to button %d on this device\n", events[i].code, buttonIndex);
+        break; 
+      }
+      case EV_REL: {
+        dataChanged = 1;
+        int axisIndex = relAxisLookup[events[i].code];
+        relAxesData[axisIndex] += events[i].value;
+        //printf("rel axis %d translates to rel axis %d on this device\n", events[i].code, axisIndex);
+        break;
+      }
+      case EV_ABS: {
+        dataChanged = 1;
+        int axisIndex = absAxisLookup[events[i].code];
+        absAxesData[axisIndex] = events[i].value;
+        //printf("abs axis %d translates to abs axis %d on this device\n", events[i].code, axisIndex);
+        break;
+      }
+      case EV_RST:
+        // not sure what to do here, doing nothing seems to work :)
+        break;
+      case EV_LED:
+        // reveiced for things like numlock led change
+        break;
+      default:
+        fprintf(stderr, "Received event of type 0x%02X from %s, which I wasn't expecting, please report it to [email protected]\n", events[i].type, name);
+    }
+  }
+  return dataChanged;
+}
+
+void EventDevice::getPolledData(int relAxesData[], int absAxesData[], int buttonData[]){
+  int i;
+
+  if(inited!=1) return;
+  for(i=0;i<numRelAxes;i++) {
+    (relAxesData)[i] = this->relAxesData[i];
+  }
+  for(i=0;i<numAbsAxes;i++) {
+    (absAxesData)[i] = this->absAxesData[i];
+  }
+  for(i=0;i<numButtons;i++) {
+    (buttonData)[i] = this->buttonData[i];
+  }
+}
+
+int EventDevice::getAbsAxisMinimum(int axisNumber) {
+  return abs_features[axisNumber].min_value;
+}
+
+int EventDevice::getAbsAxisMaximum(int axisNumber) {
+  return abs_features[axisNumber].max_value;
+}
+
+int EventDevice::getAbsAxisFuzz(int axisNumber) {
+  return abs_features[axisNumber].fuzz;
+}
diff --git a/plugins/linux/src/native/EventDevice.h b/plugins/linux/src/native/EventDevice.h
new file mode 100644
index 0000000..1174a5f
--- /dev/null
+++ b/plugins/linux/src/native/EventDevice.h
@@ -0,0 +1,85 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#if !defined(eventInterface_eventDevice_h)
+#define eventInterface_eventDevice_h
+
+#include <stdint.h>
+#include <linux/input.h>
+#include "eventInterfaceTypes.h"
+#include "Device.h"
+
+class EventDevice : public Device {
+
+  private:
+    int fd;
+    int inited;
+    char *name;
+    int numButtons;
+    uint16_t bustype;
+    uint16_t vendor;
+    uint16_t product;
+    uint16_t version;
+    short *supportedRelAxes;
+    short *supportedAbsAxes;
+    short *supportedButtons;
+    int *relAxesData;
+    int *absAxesData;
+    uint8_t *buttonData;
+    int ffSupported;
+    int numRelAxes;
+    int numAbsAxes;
+    uint8_t evtype_bitmask[EV_MAX/8 + 1];
+    uint8_t key_bitmask[KEY_MAX/8 + 1];
+    uint8_t rel_bitmask[REL_MAX/8 + 1];
+    uint8_t abs_bitmask[ABS_MAX/8 + 1];
+    struct input_absinfo *abs_features;
+    int absAxisLookup[ABS_MAX];
+    int relAxisLookup[REL_MAX];
+    int buttonLookup[KEY_MAX];
+
+  public:
+    EventDevice(char *deviceFilename);
+    int getNumberRelAxes();
+    int getNumberAbsAxes();
+    int getNumberButtons();
+    const char *getName();
+    int getBusType();
+    int getVendorID();
+    int getProductID();
+    int getVersion();
+    void getSupportedRelAxes(int supportedAxis[]);
+    void getSupportedAbsAxes(int supportedAxis[]);
+    void getSupportedButtons(int supportedButtons[]);
+    int poll();
+    void getPolledData(int relAxesData[], int absAxesData[], int buttonData[]);
+    int getAbsAxisMinimum(int axisNumber);
+    int getAbsAxisMaximum(int axisNumber);
+    int getAbsAxisFuzz(int axisNumber);
+
+};
+
+#endif //eventInterface_eventDevice_h
diff --git a/plugins/linux/src/native/JoystickDevice.cpp b/plugins/linux/src/native/JoystickDevice.cpp
new file mode 100644
index 0000000..c20fc22
--- /dev/null
+++ b/plugins/linux/src/native/JoystickDevice.cpp
@@ -0,0 +1,178 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#include "eventInterfaceTypes.h"
+#include "JoystickDevice.h"
+#include <stdio.h>
+#include <linux/input.h>
+#include <linux/joystick.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <malloc.h>
+#include <errno.h>
+
+JoystickDevice::JoystickDevice(char *deviceFileName) {
+  char tempName[Device::MAX_NAME_LENGTH-1] = "Unknown";
+  int i;
+
+  fd = open(deviceFileName, O_RDWR | O_NONBLOCK);
+  /*if(fd<0) {
+    char errorMessage[512];
+    sprintf(errorMessage, "Error opening device %s\n", deviceFileName);
+    perror(errorMessage);
+  }*/
+
+  if(fd>0){
+    if(ioctl(fd, JSIOCGNAME(sizeof(tempName)), tempName) < 0) {
+      char errorMessage[512];
+      sprintf(errorMessage, "Error reading device %s\n", deviceFileName);
+      perror(errorMessage);
+    }
+
+    int namelength=strlen(tempName);
+    name = (char *)malloc(namelength+1);
+    strncpy(name,tempName, namelength+1);
+
+    char tempNumButtons;
+    char tempNumAxes;
+    ioctl (fd, JSIOCGBUTTONS, &tempNumButtons);
+    ioctl (fd, JSIOCGAXES, &tempNumAxes);
+
+    numButtons = tempNumButtons;
+    numAbsAxes = tempNumAxes;
+
+    //fprintf(stderr, "Got joystick %s with %d buttons and %d axes\n", tempName, numButtons, numAbsAxes);
+
+    //buttonData = (uint8_t *)malloc(numButtons * sizeof(uint8_t));
+    buttonData = new uint8_t[numButtons];
+    //absAxesData = (int *)malloc(numAbsAxes * sizeof(int));
+    absAxesData = new int[numAbsAxes];
+
+    inited = 1;
+  }
+}
+
+int JoystickDevice::isValidDevice() {
+  return inited; 
+}
+
+int JoystickDevice::getNumberRelAxes(){
+  if(inited!=1) return -1;
+  return 0;
+}
+
+int JoystickDevice::getNumberAbsAxes(){
+  if(inited!=1) return -1;
+  return numAbsAxes;
+}
+
+int JoystickDevice::getNumberButtons(){
+  if(inited!=1) return -1;
+  return numButtons;
+}
+
+const char *JoystickDevice::getName(){ 
+  return name;
+}
+
+int JoystickDevice::getBusType(){
+  if(inited!=1) return -1;
+  return 0;
+}
+
+int JoystickDevice::getVendorID(){
+  if(inited!=1) return -1;
+  return 0;
+}
+
+int JoystickDevice::getProductID(){
+  if(inited!=1) return -1;
+  return 0;
+}
+
+int JoystickDevice::getVersion(){
+  if(inited!=1) return -1;
+  return 0;
+}
+
+void JoystickDevice::getSupportedRelAxes(int supportedAxis[]){
+}
+
+void JoystickDevice::getSupportedAbsAxes(int supportedAxis[]){
+}
+
+void JoystickDevice::getSupportedButtons(int supportedButtons[]){
+}
+
+/**
+ * A return value of -1 means error, 0 means ok, but no change
+ * a return of >0 means the data for this device has changed
+ */
+int JoystickDevice::poll(){
+  struct js_event event;
+  int numEvents = 0;
+  while(read(fd, &event, sizeof event) > 0) {
+    numEvents++;
+    event.type &= ~JS_EVENT_INIT;
+    if(event.type == JS_EVENT_BUTTON) {
+      buttonData[event.number] = event.value;
+    } else if(event.type == JS_EVENT_AXIS) {
+      absAxesData[event.number] = event.value;
+    }
+
+  }
+  // EAGAIN is returned when the queue is empty
+  if(errno != EAGAIN) {
+    printf("Something went wrong getting an event\n");
+  }
+
+  return numEvents;
+}
+
+void JoystickDevice::getPolledData(int relAxesData[], int absAxesData[], int buttonData[]){
+  int i;
+
+  if(inited!=1) return;
+  for(i=0;i<numAbsAxes;i++) {
+    (absAxesData)[i] = this->absAxesData[i];
+  }
+  for(i=0;i<numButtons;i++) {
+    (buttonData)[i] = this->buttonData[i];
+  }
+}
+
+int JoystickDevice::getAbsAxisMinimum(int axisNumber) {
+  return -32767;
+}
+
+int JoystickDevice::getAbsAxisMaximum(int axisNumber) {
+  return 32767;
+}
+
+int JoystickDevice::getAbsAxisFuzz(int axisNumber) {
+  return 0;
+}
diff --git a/plugins/linux/src/native/JoystickDevice.h b/plugins/linux/src/native/JoystickDevice.h
new file mode 100644
index 0000000..642087d
--- /dev/null
+++ b/plugins/linux/src/native/JoystickDevice.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#ifndef JoystickDevice_h
+#define JoystickDevice_h
+
+#include <stdint.h>
+#include <linux/input.h>
+#include "eventInterfaceTypes.h"
+#include "Device.h"
+
+class JoystickDevice : public Device {
+
+  private:
+    int fd;
+    int inited;
+    char *name;
+    int numButtons;
+    int *absAxesData;
+    uint8_t *buttonData;
+    int numAbsAxes;
+
+  public:
+    JoystickDevice(char *deviceFilename);
+    int getNumberRelAxes();
+    int getNumberAbsAxes();
+    int getNumberButtons();
+    const char *getName();
+    int getBusType();
+    int getVendorID();
+    int getProductID();
+    int getVersion();
+    void getSupportedRelAxes(int supportedAxis[]);
+    void getSupportedAbsAxes(int supportedAxis[]);
+    void getSupportedButtons(int supportedButtons[]);
+    int poll();
+    void getPolledData(int relAxesData[], int absAxesData[], int buttonData[]);
+    int getAbsAxisMinimum(int axisNumber);
+    int getAbsAxisMaximum(int axisNumber);
+    int getAbsAxisFuzz(int axisNumber);
+    int isValidDevice();
+
+};
+
+#endif //eventInterface_eventDevice_h
diff --git a/plugins/linux/src/native/MixedDevice.cpp b/plugins/linux/src/native/MixedDevice.cpp
new file mode 100644
index 0000000..7f402ec
--- /dev/null
+++ b/plugins/linux/src/native/MixedDevice.cpp
@@ -0,0 +1,115 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#include "eventInterfaceTypes.h"
+#include "JoystickDevice.h"
+#include "MixedDevice.h"
+#include <stdio.h>
+#include <linux/input.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <malloc.h>
+#include <errno.h>
+
+MixedDevice::MixedDevice(JoystickDevice *jsDevice, EventDevice *evDevice) {
+
+  joystickDevice = jsDevice;
+  eventDevice = evDevice;
+}
+
+int MixedDevice::getNumberRelAxes(){
+  eventDevice->getNumberRelAxes();
+}
+
+int MixedDevice::getNumberAbsAxes(){
+  return eventDevice->getNumberAbsAxes();
+}
+
+int MixedDevice::getNumberButtons(){
+  return eventDevice->getNumberButtons();
+}
+
+const char *MixedDevice::getName(){ 
+  return eventDevice->getName();
+}
+
+int MixedDevice::getBusType(){
+  return eventDevice->getBusType();
+}
+
+int MixedDevice::getVendorID(){
+  return eventDevice->getVendorID();
+}
+
+int MixedDevice::getProductID(){
+  return eventDevice->getProductID();
+}
+
+int MixedDevice::getVersion(){
+  return eventDevice->getVersion();
+}
+
+void MixedDevice::getSupportedRelAxes(int supportedAxis[]){
+  return eventDevice->getSupportedRelAxes(supportedAxis);
+}
+
+void MixedDevice::getSupportedAbsAxes(int supportedAxis[]){
+  return eventDevice->getSupportedAbsAxes(supportedAxis);
+}
+
+void MixedDevice::getSupportedButtons(int supportedButtons[]){
+  return eventDevice->getSupportedButtons(supportedButtons);
+}
+
+/**
+ * A return value of -1 means error, 0 means ok, but no change
+ * a return of >0 means the data for this device has changed
+ */
+int MixedDevice::poll(){
+  eventDevice->poll();
+  return joystickDevice->poll();
+}
+
+void MixedDevice::getPolledData(int relAxesData[], int absAxesData[], int buttonData[]){
+  int i;
+
+  joystickDevice->getPolledData(new int[joystickDevice->getNumberRelAxes()], absAxesData, new int[joystickDevice->getNumberButtons()]);
+  eventDevice->getPolledData(relAxesData, new int[eventDevice->getNumberAbsAxes()], buttonData);
+
+}
+
+int MixedDevice::getAbsAxisMinimum(int axisNumber) {
+  return joystickDevice->getAbsAxisMinimum(axisNumber);
+}
+
+int MixedDevice::getAbsAxisMaximum(int axisNumber) {
+  return joystickDevice->getAbsAxisMaximum(axisNumber);
+}
+
+int MixedDevice::getAbsAxisFuzz(int axisNumber) {
+  return joystickDevice->getAbsAxisFuzz(axisNumber);
+}
diff --git a/plugins/linux/src/native/MixedDevice.h b/plugins/linux/src/native/MixedDevice.h
new file mode 100644
index 0000000..be468d6
--- /dev/null
+++ b/plugins/linux/src/native/MixedDevice.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#ifndef MixedDevice_h
+#define MixedDevice_h
+
+#include <stdint.h>
+#include <linux/input.h>
+#include "eventInterfaceTypes.h"
+#include "Device.h"
+#include "EventDevice.h"
+#include "JoystickDevice.h"
+#include "MixedDevice.h"
+
+class MixedDevice : public Device {
+
+  private:
+    JoystickDevice *joystickDevice;
+    EventDevice *eventDevice;
+
+  public:
+    MixedDevice(JoystickDevice *joystickDevice, EventDevice *eventDevice);
+    int getNumberRelAxes();
+    int getNumberAbsAxes();
+    int getNumberButtons();
+    const char *getName();
+    int getBusType();
+    int getVendorID();
+    int getProductID();
+    int getVersion();
+    void getSupportedRelAxes(int supportedAxis[]);
+    void getSupportedAbsAxes(int supportedAxis[]);
+    void getSupportedButtons(int supportedButtons[]);
+    void getSupportedRelAxes(short supportedAxis[]);
+    void getSupportedAbsAxes(short supportedAxis[]);
+    void getSupportedButtons(short supportedButtons[]);
+    int poll();
+    void getPolledData(int relAxesData[], int absAxesData[], int buttonData[]);
+    int getAbsAxisMinimum(int axisNumber);
+    int getAbsAxisMaximum(int axisNumber);
+    int getAbsAxisFuzz(int axisNumber);
+
+};
+
+#endif //eventInterface_eventDevice_h
diff --git a/plugins/linux/src/native/eventInterface.cpp b/plugins/linux/src/native/eventInterface.cpp
new file mode 100644
index 0000000..303c667
--- /dev/null
+++ b/plugins/linux/src/native/eventInterface.cpp
@@ -0,0 +1,131 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#include <sys/dir.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <linux/input.h>
+#include <string.h>
+#include <malloc.h>
+#include <unistd.h>
+#include "Device.h"
+#include "EventDevice.h"
+
+int evNumDevices;
+int eventInterfaceVersion;
+Device **evDeviceList;
+int evInited = 0;
+
+int evFileFilter(const struct direct *entry) {
+  if (strncmp(entry->d_name, "event", 5) == 0) {
+    return 1;
+  }
+    return 0;
+  }
+
+int evGetDeviceFiles(char ***filenames) {
+  struct direct **files;
+  int num_files, i;
+  char dirName[] = {"/dev/input"};
+
+  num_files = scandir(dirName, &files, &evFileFilter, alphasort);
+
+  *filenames = (char **)malloc(num_files * sizeof(char *));
+
+  for(i=0;i<num_files;i++) {
+    char *filename = files[i]->d_name;
+    char *fullFileName;
+
+    fullFileName = (char *)malloc((strlen(dirName) + 1 + strlen(filename) + 1));
+    sprintf(fullFileName, "%s/%s", dirName, filename);
+    (*filenames)[i] = fullFileName;
+  }
+
+  return num_files;
+}
+
+int evInit() {
+  int fd=-1;
+  int i;
+  char **deviceFileNames;
+  int numDeviceFiles;
+
+  numDeviceFiles = evGetDeviceFiles(&deviceFileNames);
+  if(numDeviceFiles<0) {
+    return -1;
+  }
+  
+  if ((fd = open(deviceFileNames[0], O_RDONLY)) <0) {
+    return -1;
+  }
+
+  if (ioctl(fd, EVIOCGVERSION, &eventInterfaceVersion)) {
+    close(fd);
+    return -1;
+  }
+
+  close(fd);
+
+  Device *tempDeviceList[numDeviceFiles];
+ 
+  evNumDevices = 0;
+  for(i=0;i<numDeviceFiles;i++) {
+    tempDeviceList[i] = new EventDevice(deviceFileNames[i]);
+    if(tempDeviceList[i]->getBusType()!=-1) {
+      evNumDevices++;
+    }
+  }
+
+  // Now we know for certain which devices are open, we can take notes
+  evDeviceList = (Device **)malloc(evNumDevices * sizeof(Device *));
+  for(i=0;i<evNumDevices;i++) {
+    evDeviceList[i] = tempDeviceList[i];
+  }
+
+  evInited=1;
+
+  return 0;
+}
+
+int evGetEventInterfaceVersionNumber() {
+  return eventInterfaceVersion;
+}
+
+int evGetNumberDevices() {
+  if(evInited) {
+    return evNumDevices;
+  }
+  return -1;
+}
+
+void evGetDevices(Device **theirDeviceList) {
+  int i;
+  for(i=0;i<evNumDevices;i++) {
+    theirDeviceList[i] = evDeviceList[i];
+  }
+}
diff --git a/plugins/linux/src/native/eventInterface.h b/plugins/linux/src/native/eventInterface.h
new file mode 100644
index 0000000..92e421c
--- /dev/null
+++ b/plugins/linux/src/native/eventInterface.h
@@ -0,0 +1,37 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#if !defined(eventInterface_h)
+#define eventInterface_h
+
+#include "Device.h"
+
+int evGetEventInterfaceVersionNumber();
+int evInit();
+int evGetNumberDevices();
+void evGetDevices(Device **deviceList);
+
+#endif //eventInterface_h
diff --git a/plugins/linux/src/native/eventInterfaceTypes.h b/plugins/linux/src/native/eventInterfaceTypes.h
new file mode 100644
index 0000000..2f1f936
--- /dev/null
+++ b/plugins/linux/src/native/eventInterfaceTypes.h
@@ -0,0 +1,24 @@
+#if !defined(eventInterfaceTypes_h)
+#define eventInterfaceTypes_h
+
+#include <linux/input.h>
+#include <stdint.h>
+
+#define getBit(bit, bitField) (bitField[bit/8] & (1 << (bit%8)))
+
+struct input_devinfo {
+        uint16_t bustype;
+        uint16_t vendor;
+        uint16_t product;
+        uint16_t version;
+};
+
+struct input_absinfo {
+  int curr_value;
+  int min_value;
+  int max_value;
+  int fuzz;
+  int flat;
+};
+
+#endif //eventInterfaceTypes_h
diff --git a/plugins/linux/src/native/jinput.cpp b/plugins/linux/src/native/jinput.cpp
new file mode 100644
index 0000000..e20feeb
--- /dev/null
+++ b/plugins/linux/src/native/jinput.cpp
@@ -0,0 +1,333 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <string.h>
+
+#include "net_java_games_input_LinuxDevice.h"
+#include "net_java_games_input_LinuxEnvironmentPlugin.h"
+#include "net_java_games_input_LinuxKeyboard.h"
+
+#include "Device.h"
+#include "EventDevice.h"
+#include "JoystickDevice.h"
+#include "MixedDevice.h"
+#include "eventInterface.h"
+#include "joystickInterface.h"
+
+Device **jinputDeviceList;
+int jinputNumDevices;
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    init
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_init
+  (JNIEnv *, jobject) {
+
+  if(evInit()!=0) {
+    fprintf(stderr, "Failed to init native jinput\n");
+    return -1;
+  }
+  if(jsInit()!=0) {
+    fprintf(stderr, "Failed to init native jinput\n");
+    return -1;
+  }
+
+  int numEventDevices = evGetNumberDevices();
+  EventDevice *eventDevices[numEventDevices];
+  
+  evGetDevices((Device **)eventDevices);
+
+  int numJoysticks = jsGetNumberDevices();
+  JoystickDevice *jsDevices[numJoysticks];
+  jsGetDevices((Device **)jsDevices);
+
+  
+  int i;
+  int j;
+  int joystickPtr = 0;
+  jinputDeviceList = (Device **)malloc(numEventDevices * sizeof(Device *));
+  for(i=0;i<numEventDevices;i++) {
+    EventDevice *eventDevice = eventDevices[i];
+    int deviceCountCache = jinputNumDevices;
+
+    for(j=joystickPtr;j<numJoysticks;j++) {
+      JoystickDevice *jsDevice = jsDevices[j];
+      if((jsDevice->getNumberButtons() == eventDevice->getNumberButtons()) && (jsDevice->getNumberAbsAxes() == (eventDevice->getNumberAbsAxes() + eventDevice->getNumberRelAxes()))) {
+        const char *jsName = jsDevice->getName();
+        const char *eventDeviceName = eventDevice->getName();
+
+        if(strcmp(jsName, eventDeviceName) == 0) {
+          // The current event device is the curre joystick device too
+          jinputDeviceList[jinputNumDevices] = new MixedDevice(jsDevice, eventDevice);
+          jinputNumDevices++;
+          joystickPtr = j;
+          j = numJoysticks;
+        }
+      }
+      /*if(jinputNumDevices == deviceCountCache) {
+        //fprintf(stderr, "event device \"%s\" doesn't match js \"%s\"\n", eventDevice->getName(), jsDevice->getName());
+        //fprintf(stderr, "event device has %d rel axes, %d abs axis and %d buttons\n", eventDevice->getNumberRelAxes(), eventDevice->getNumberAbsAxes(), eventDevice->getNumberButtons());
+        //fprintf(stderr, "js device has %d axes and %d buttons\n", jsDevice->getNumberAbsAxes(), jsDevice->getNumberButtons());
+      } else {
+        //fprintf(stderr, "event device %s did match js %s\n", eventDevice->getName(), jsDevice->getName());
+      } */
+  
+    }
+
+    if(jinputNumDevices == deviceCountCache) {
+      jinputDeviceList[jinputNumDevices] = eventDevice;
+      jinputNumDevices++;
+    }
+  }
+
+
+  return(0);
+
+}
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getDeviceName
+ * Signature: (I)Ljava/lang/String;
+ */
+
+JNIEXPORT jstring JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getDeviceName
+  (JNIEnv *env, jobject, jint deviceID) {
+  
+  return env->NewStringUTF(jinputDeviceList[deviceID]->getName());
+}
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumAbsAxes
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumAbsAxes
+  (JNIEnv *env, jobject, jint deviceID) {
+
+  return jinputDeviceList[deviceID]->getNumberAbsAxes();
+}
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumRelAxes
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumRelAxes
+  (JNIEnv *env, jobject, jint deviceID) {
+  
+  return jinputDeviceList[deviceID]->getNumberRelAxes();
+}
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumButtons
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumButtons
+  (JNIEnv *, jobject, jint deviceID) {
+
+  return jinputDeviceList[deviceID]->getNumberButtons();
+}
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumberOfDevices
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumberOfDevices
+  (JNIEnv *, jobject) {
+
+  return jinputNumDevices;
+}
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeSupportedAbsAxes
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxDevice_getNativeSupportedAbsAxes
+  (JNIEnv *env, jobject, jint deviceID, jintArray axesData) {
+
+  jint *axisReturns = env->GetIntArrayElements(axesData, 0);
+  
+  jinputDeviceList[deviceID]->getSupportedAbsAxes(axisReturns);
+
+  env->ReleaseIntArrayElements(axesData, axisReturns, 0);
+}
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeSupportedRelAxes
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxDevice_getNativeSupportedRelAxes
+  (JNIEnv *env, jobject, jint deviceID, jintArray axesData) {
+
+  jint *axisReturns = env->GetIntArrayElements(axesData, 0);
+  
+  jinputDeviceList[deviceID]->getSupportedRelAxes(axisReturns);
+
+  env->ReleaseIntArrayElements(axesData, axisReturns, 0);
+}
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeSupportedButtons
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxDevice_getNativeSupportedButtons
+  (JNIEnv *env, jobject, jint deviceID, jintArray buttonData) {
+
+  jint *buttonDataElements = env->GetIntArrayElements(buttonData, 0);
+  
+  jinputDeviceList[deviceID]->getSupportedButtons(buttonDataElements);
+
+  env->ReleaseIntArrayElements(buttonData, buttonDataElements, 0);
+}
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    nativePoll
+ * Signature: (I[I[I[I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_nativePoll
+  (JNIEnv *env, jobject, jint deviceID, jintArray buttons, jintArray relAxes, jintArray absAxes) {
+
+  jint *buttonElements = env->GetIntArrayElements(buttons, 0);
+  jint *relAxesElements = env->GetIntArrayElements(relAxes, 0);
+  jint *absAxesElements = env->GetIntArrayElements(absAxes, 0);
+
+  int retval = jinputDeviceList[deviceID]->poll();
+  jinputDeviceList[deviceID]->getPolledData(relAxesElements, absAxesElements, buttonElements);
+
+  env->ReleaseIntArrayElements(buttons, buttonElements, 0);
+  env->ReleaseIntArrayElements(relAxes, relAxesElements, 0);
+  env->ReleaseIntArrayElements(absAxes, absAxesElements, 0);
+
+  return retval;
+}
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeAbsAxisFuzz
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativeAbsAxisFuzz
+  (JNIEnv *, jobject, jint deviceID, jint axisID) {
+
+  return jinputDeviceList[deviceID]->getAbsAxisFuzz(axisID);
+}
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeAbsAxisMaximum
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativeAbsAxisMaximum
+  (JNIEnv *, jobject, jint deviceID, jint axisID) {
+
+  return jinputDeviceList[deviceID]->getAbsAxisMaximum(axisID);
+}
+
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeAbsAxisMinimum
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativeAbsAxisMinimum
+  (JNIEnv *, jobject, jint deviceID, jint axisID) {
+
+  return jinputDeviceList[deviceID]->getAbsAxisMinimum(axisID);
+}
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativePortType
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativePortType
+  (JNIEnv *, jobject, jint deviceID) {
+
+  jinputDeviceList[deviceID]->getBusType();
+}
+
+/* Inaccessible static: NO_RUMBLERS */
+/* Inaccessible static: _00024assertionsDisabled */
+/* Inaccessible static: class_00024net_00024java_00024games_00024input_00024Keyboard */
+/*
+ * Class:     net_java_games_input_LinuxKeyboard
+ * Method:    getNativeSupportedButtons
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxKeyboard_getNativeSupportedButtons
+  (JNIEnv *env, jobject, jint deviceID, jintArray buttons) {
+
+  jint *buttonDataElements = env->GetIntArrayElements(buttons, 0);
+  
+  jinputDeviceList[deviceID]->getSupportedButtons(buttonDataElements);
+
+  env->ReleaseIntArrayElements(buttons, buttonDataElements, 0);
+}
+
+/*
+ * Class:     net_java_games_input_LinuxKeyboard
+ * Method:    nativePoll
+ * Signature: (I[I[I[I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxKeyboard_nativePoll
+  (JNIEnv *env, jobject, jint deviceID, jintArray buttons, jintArray relAxes, jintArray absAxes) {
+
+  jint *buttonElements = env->GetIntArrayElements(buttons, 0);
+  jint *relAxesElements = env->GetIntArrayElements(relAxes, 0);
+  jint *absAxesElements = env->GetIntArrayElements(absAxes, 0);
+
+  int retval = jinputDeviceList[deviceID]->poll();
+  jinputDeviceList[deviceID]->getPolledData(relAxesElements, absAxesElements, buttonElements);
+
+  env->ReleaseIntArrayElements(buttons, buttonElements, 0);
+  env->ReleaseIntArrayElements(relAxes, relAxesElements, 0);
+  env->ReleaseIntArrayElements(absAxes, absAxesElements, 0);
+
+  return retval;
+}
+
+/*
+ * Class:     net_java_games_input_LinuxKeyboard
+ * Method:    getNativePortType
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxKeyboard_getNativePortType
+  (JNIEnv *, jobject, jint deviceID) {
+
+  jinputDeviceList[deviceID]->getBusType();
+}
diff --git a/plugins/linux/src/native/joystickInterface.cpp b/plugins/linux/src/native/joystickInterface.cpp
new file mode 100644
index 0000000..2bcc8bc
--- /dev/null
+++ b/plugins/linux/src/native/joystickInterface.cpp
@@ -0,0 +1,132 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#include <sys/dir.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <linux/joystick.h>
+#include <string.h>
+#include <malloc.h>
+#include <unistd.h>
+#include "Device.h"
+#include "JoystickDevice.h"
+
+int jsNumDevices;
+int joystickInterfaceVersion;
+Device **jsDeviceList;
+int jsInited = 0;
+
+int jsFileFilter(const struct direct *entry) {
+  if (strncmp(entry->d_name, "js", 2) == 0) {
+    return 1;
+  }
+    return 0;
+  }
+
+int jsGetDeviceFiles(char ***filenames) {
+  struct direct **files;
+  int num_files, i;
+  char dirName[] = {"/dev/input"};
+
+  num_files = scandir(dirName, &files, &jsFileFilter, alphasort);
+
+  *filenames = (char **)malloc(num_files * sizeof(char *));
+
+  for(i=0;i<num_files;i++) {
+    char *filename = files[i]->d_name;
+    char *fullFileName;
+
+    fullFileName = (char *)malloc((strlen(dirName) + 1 + strlen(filename) + 1));
+    sprintf(fullFileName, "%s/%s", dirName, filename);
+    (*filenames)[i] = fullFileName;
+  }
+
+  return num_files;
+}
+
+int jsInit() {
+  int fd=-1;
+  int i;
+  char **deviceFileNames;
+  int numDeviceFiles;
+
+  numDeviceFiles = jsGetDeviceFiles(&deviceFileNames);
+  if(numDeviceFiles<0) {
+    return -1;
+  }
+  
+  if ((fd = open(deviceFileNames[0], O_RDONLY)) <0) {
+    return -1;
+  }
+
+  if (ioctl(fd, JSIOCGVERSION, &joystickInterfaceVersion)) {
+    close(fd);
+    return -1;
+  }
+
+  close(fd);
+
+  Device *tempDeviceList[numDeviceFiles];
+ 
+  jsNumDevices = 0;
+  for(i=0;i<numDeviceFiles;i++) {
+    JoystickDevice *tempDevice = new JoystickDevice(deviceFileNames[i]); 
+    if(tempDevice->isValidDevice()==1) {
+      tempDeviceList[i] = tempDevice;
+      jsNumDevices++;
+    }
+  }
+
+  // Now we know for certain which devices are open, we can take notes
+  jsDeviceList = (Device **)malloc(jsNumDevices * sizeof(Device *));
+  for(i=0;i<jsNumDevices;i++) {
+    jsDeviceList[i] = tempDeviceList[i];
+  }
+
+  jsInited=1;
+
+  return 0;
+}
+
+int jsGetJoystickInterfaceVersionNumber() {
+  return joystickInterfaceVersion;
+}
+
+int jsGetNumberDevices() {
+  if(jsInited) {
+    return jsNumDevices;
+  }
+  return -1;
+}
+
+void jsGetDevices(Device **theirDeviceList) {
+  int i;
+  for(i=0;i<jsNumDevices;i++) {
+    theirDeviceList[i] = jsDeviceList[i];
+  }
+}
diff --git a/plugins/linux/src/native/joystickInterface.h b/plugins/linux/src/native/joystickInterface.h
new file mode 100644
index 0000000..01b8c58
--- /dev/null
+++ b/plugins/linux/src/native/joystickInterface.h
@@ -0,0 +1,37 @@
+/**
+ * Copyright (C) 2003 Jeremy Booth ([email protected])
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. Redistributions in binary 
+ * form must reproduce the above copyright notice, this list of conditions and 
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. 
+ * The name of the author may not be used to endorse or promote products derived
+ * from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+ */
+
+#if !defined(joystickInterface_h)
+#define joystickInterface_h
+
+#include "Device.h"
+
+int jsGetJoystickInterfaceVersionNumber();
+int jsInit();
+int jsGetNumberDevices();
+void jsGetDevices(Device **deviceList);
+
+#endif //joystickInterface_h
diff --git a/plugins/linux/src/native/net_java_games_input_LinuxDevice.h b/plugins/linux/src/native/net_java_games_input_LinuxDevice.h
new file mode 100644
index 0000000..50a4e8b
--- /dev/null
+++ b/plugins/linux/src/native/net_java_games_input_LinuxDevice.h
@@ -0,0 +1,80 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class net_java_games_input_LinuxDevice */
+
+#ifndef _Included_net_java_games_input_LinuxDevice
+#define _Included_net_java_games_input_LinuxDevice
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Inaccessible static: NO_AXES */
+/* Inaccessible static: NO_CONTROLLERS */
+/* Inaccessible static: NO_RUMBLERS */
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeSupportedAbsAxes
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxDevice_getNativeSupportedAbsAxes
+  (JNIEnv *, jobject, jint, jintArray);
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeSupportedRelAxes
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxDevice_getNativeSupportedRelAxes
+  (JNIEnv *, jobject, jint, jintArray);
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeSupportedButtons
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxDevice_getNativeSupportedButtons
+  (JNIEnv *, jobject, jint, jintArray);
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    nativePoll
+ * Signature: (I[I[I[I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_nativePoll
+  (JNIEnv *, jobject, jint, jintArray, jintArray, jintArray);
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeAbsAxisFuzz
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativeAbsAxisFuzz
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeAbsAxisMaximum
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativeAbsAxisMaximum
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativeAbsAxisMinimum
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativeAbsAxisMinimum
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     net_java_games_input_LinuxDevice
+ * Method:    getNativePortType
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxDevice_getNativePortType
+  (JNIEnv *, jobject, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/plugins/linux/src/native/net_java_games_input_LinuxEnvironmentPlugin.h b/plugins/linux/src/native/net_java_games_input_LinuxEnvironmentPlugin.h
new file mode 100644
index 0000000..6e68a97
--- /dev/null
+++ b/plugins/linux/src/native/net_java_games_input_LinuxEnvironmentPlugin.h
@@ -0,0 +1,64 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class net_java_games_input_LinuxEnvironmentPlugin */
+
+#ifndef _Included_net_java_games_input_LinuxEnvironmentPlugin
+#define _Included_net_java_games_input_LinuxEnvironmentPlugin
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Inaccessible static: _00024assertionsDisabled */
+/* Inaccessible static: defaultEnvironment */
+/* Inaccessible static: class_00024net_00024java_00024games_00024input_00024ControllerEnvironment */
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getDeviceName
+ * Signature: (I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getDeviceName
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumAbsAxes
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumAbsAxes
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumRelAxes
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumRelAxes
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumButtons
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumButtons
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    init
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_init
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     net_java_games_input_LinuxEnvironmentPlugin
+ * Method:    getNumberOfDevices
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxEnvironmentPlugin_getNumberOfDevices
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/plugins/linux/src/native/net_java_games_input_LinuxKeyboard.h b/plugins/linux/src/native/net_java_games_input_LinuxKeyboard.h
new file mode 100644
index 0000000..041f416
--- /dev/null
+++ b/plugins/linux/src/native/net_java_games_input_LinuxKeyboard.h
@@ -0,0 +1,42 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class net_java_games_input_LinuxKeyboard */
+
+#ifndef _Included_net_java_games_input_LinuxKeyboard
+#define _Included_net_java_games_input_LinuxKeyboard
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Inaccessible static: NO_AXES */
+/* Inaccessible static: NO_CONTROLLERS */
+/* Inaccessible static: NO_RUMBLERS */
+/* Inaccessible static: _00024assertionsDisabled */
+/* Inaccessible static: class_00024net_00024java_00024games_00024input_00024Keyboard */
+/*
+ * Class:     net_java_games_input_LinuxKeyboard
+ * Method:    getNativeSupportedButtons
+ * Signature: (I[I)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_LinuxKeyboard_getNativeSupportedButtons
+  (JNIEnv *, jobject, jint, jintArray);
+
+/*
+ * Class:     net_java_games_input_LinuxKeyboard
+ * Method:    nativePoll
+ * Signature: (I[I[I[I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxKeyboard_nativePoll
+  (JNIEnv *, jobject, jint, jintArray, jintArray, jintArray);
+
+/*
+ * Class:     net_java_games_input_LinuxKeyboard
+ * Method:    getNativePortType
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_net_java_games_input_LinuxKeyboard_getNativePortType
+  (JNIEnv *, jobject, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif