summaryrefslogtreecommitdiffstats
path: root/plugins/linux/src
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/linux/src')
-rw-r--r--plugins/linux/src/java/net/java/games/input/LinuxAxis.java192
-rw-r--r--plugins/linux/src/java/net/java/games/input/LinuxDevice.java956
-rw-r--r--plugins/linux/src/java/net/java/games/input/LinuxEnvironmentPlugin.java159
-rw-r--r--plugins/linux/src/java/net/java/games/input/LinuxKeyboard.java232
-rw-r--r--plugins/linux/src/java/net/java/games/input/LinuxMouse.java168
-rw-r--r--plugins/linux/src/java/net/java/games/input/LinuxNativeTypesMap.java792
-rw-r--r--plugins/linux/src/java/net/java/games/input/NativeDefinitions.java323
-rw-r--r--plugins/linux/src/native/Device.h69
-rw-r--r--plugins/linux/src/native/EventDevice.cpp364
-rw-r--r--plugins/linux/src/native/EventDevice.h85
-rw-r--r--plugins/linux/src/native/JoystickDevice.cpp178
-rw-r--r--plugins/linux/src/native/JoystickDevice.h68
-rw-r--r--plugins/linux/src/native/MixedDevice.cpp115
-rw-r--r--plugins/linux/src/native/MixedDevice.h68
-rw-r--r--plugins/linux/src/native/eventInterface.cpp131
-rw-r--r--plugins/linux/src/native/eventInterface.h37
-rw-r--r--plugins/linux/src/native/eventInterfaceTypes.h24
-rw-r--r--plugins/linux/src/native/jinput.cpp333
-rw-r--r--plugins/linux/src/native/joystickInterface.cpp132
-rw-r--r--plugins/linux/src/native/joystickInterface.h37
-rw-r--r--plugins/linux/src/native/net_java_games_input_LinuxDevice.h80
-rw-r--r--plugins/linux/src/native/net_java_games_input_LinuxEnvironmentPlugin.h64
-rw-r--r--plugins/linux/src/native/net_java_games_input_LinuxKeyboard.h42
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