shadowfacts/jinput-arm64
1
0
Fork 0
mirror of https://github.com/shadowfacts/jinput-arm64.git synced 2026-01-09 10:19:57 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Initial commit of Linux plugin

Browse source
This commit is contained in:
endolf 2003-07-31 19:34:46 +00:00
parent c4bc78af27
commit 1b4afd7352
23 changed files with 4649 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

192
plugins/linux/src/java/net/java/games/input/LinuxAxis.java Normal file
View file

@ -0,0 +1,192 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 (jeremy@newdawnsoftware.com)
*/
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);
}
}

956
plugins/linux/src/java/net/java/games/input/LinuxDevice.java Normal file
View file

@ -0,0 +1,956 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 (jeremy@newdawnsoftware.com)
*/
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 (jeremy@newdawnsoftware.com)
*/
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 (jeremy@computerbooth.com)
*/
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);
}
}
}

159
plugins/linux/src/java/net/java/games/input/LinuxEnvironmentPlugin.java Normal file
View file

@ -0,0 +1,159 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 (jeremy@newdawnsoftware.com)
*/
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();
}

232
plugins/linux/src/java/net/java/games/input/LinuxKeyboard.java Normal file
View file

@ -0,0 +1,232 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 (jeremy@newdawnsoftware.com)
*/
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 (jeremy@newdawnsoftware.com)
*/
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 + ")";
}
}
}

168
plugins/linux/src/java/net/java/games/input/LinuxMouse.java Normal file
View file

@ -0,0 +1,168 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 (jeremy@newdawnsoftware.com)
*/
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();
}
}
}

792
plugins/linux/src/java/net/java/games/input/LinuxNativeTypesMap.java Normal file
View file

@ -0,0 +1,792 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 (jeremy@newdawnsoftware.com)
*/
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;
}
}

323
plugins/linux/src/java/net/java/games/input/NativeDefinitions.java Normal file
View file

@ -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;
}

69
plugins/linux/src/native/Device.h Normal file
View file

@ -0,0 +1,69 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 (jeremy@newdawnsoftware.com)
*/
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

364
plugins/linux/src/native/EventDevice.cpp Normal file
View file

@ -0,0 +1,364 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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 jinput@computerbooth.com\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;
}

85
plugins/linux/src/native/EventDevice.h Normal file
View file

@ -0,0 +1,85 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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

178
plugins/linux/src/native/JoystickDevice.cpp Normal file
View file

@ -0,0 +1,178 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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;
}

68
plugins/linux/src/native/JoystickDevice.h Normal file
View file

@ -0,0 +1,68 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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

115
plugins/linux/src/native/MixedDevice.cpp Normal file
View file

@ -0,0 +1,115 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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);
}

68
plugins/linux/src/native/MixedDevice.h Normal file
View file

@ -0,0 +1,68 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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

131
plugins/linux/src/native/eventInterface.cpp Normal file
View file

@ -0,0 +1,131 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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];
}
}

37
plugins/linux/src/native/eventInterface.h Normal file
View file

@ -0,0 +1,37 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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

24
plugins/linux/src/native/eventInterfaceTypes.h Normal file
View file

@ -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

333
plugins/linux/src/native/jinput.cpp Normal file
View file

@ -0,0 +1,333 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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();
}

132
plugins/linux/src/native/joystickInterface.cpp Normal file
View file

@ -0,0 +1,132 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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];
}
}

37
plugins/linux/src/native/joystickInterface.h Normal file
View file

@ -0,0 +1,37 @@
/**
* Copyright (C) 2003 Jeremy Booth (jeremy@newdawnsoftware.com)
*
* 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

80
plugins/linux/src/native/net_java_games_input_LinuxDevice.h Normal file
View file

@ -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

64
plugins/linux/src/native/net_java_games_input_LinuxEnvironmentPlugin.h Normal file
View file

@ -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

42
plugins/linux/src/native/net_java_games_input_LinuxKeyboard.h Normal file
View file

@ -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