shadowfacts/jinput-arm64
1
0
Fork 0
mirror of https://github.com/shadowfacts/jinput-arm64.git synced 2026-04-21 06:14:11 +00:00
Code Issues Projects Releases Packages Wiki Activity

This commit was manufactured by cvs2svn to create tag 'Tested'.

Browse source
This commit is contained in:
no author 2004-04-21 16:19:43 +00:00
parent 307a1d5ff3
commit b226eec1c8
42 changed files with 0 additions and 8500 deletions
Download patch file Download diff file Expand all files Collapse all files

46
plugins/DX8/README.txt
View file

@ -1,46 +0,0 @@
This file modified last on 06/06/2003 by Jeff Kesselman
This is the source tree for the core input API.
Directory Organization:
The root contains a master ANT build.xml.
After a successful build you will have the following sub directories:
-- apidocs Where the javadocs get built to
-- lib Where dependant libraries are kept.
-- bin Where the plugin dll and jar files ar built to.
-- src The source files.
Build instructions:
To clean: ant clean
To build: ant all (or just ant)
To build docs: ant javadoc
To test:
This build will install the plug-in into the coreAPI's test
directories.
Use the tests in the coreAPI build.xml to test.
Release Info:
Initial Release: This release contains an implementation of the input
API designed by Mike Martak of Sun and Thomas (?) of Sony CEA for
the WIn32 platform. All the code in src/input is cross platform. The
Win32 code is segregated to the DirectX plugin (src/DXplugin) which
depends on DirectInput from DX7 (or later).
05/09/2003: A number of bugs and problems with the DXPlugin are fixed in this
release. This release also brings the code up to date using the DI8
interface. This thus is the first release that requries Peter Puck's
DX8 bindings to compile with MinGW.
05/09/2003 (second update):
This version adds a new standard value type to the API.
Axis.POV holds standard definitions for values for POV (hat) switches
-- Axis.POV.CENTER and Axis.POV.OFF are synonmous and are
the center position.
-- Axis.POV.UP, Axis.POV.DOWN, Axis.POV.LEFT and Axis.POV.RIGHT
should be self explainatory.
Any hat that claims to be "normalized" will return these values. (It is
recommended that all hats be normalized by the systemn specific plugins.)

103
plugins/DX8/build.xml
View file

@ -1,103 +0,0 @@
<?xml version="1.0"?>
<!-- Written to assume that classpath is rooted in the current directory. -->
<!-- So this should be OK if you make this script in the root of a filesystem. -->
<!-- If not, you may prefer to adjust the basedir, or move some directories around. -->
<!-- The idea is that both Ant and NetBeans have to know what the package root is -->
<!-- for the classes in your application. -->
<project name="Direct Input Plugin" basedir="." default="all">
<!-- Don't worry if you don't know the Ant syntax completely or need help on some tasks! -->
<!-- The standard Ant documentation is bundled. See Help | Help Sets | Ant 1.4.1 Manual. -->
<target name="init">
<!-- You can set up any variables you want used throughout the script here. -->
<property name="hello" value="world"/>
<mkdir dir="classes"/>
<mkdir dir="bin"/>
<!-- To use e.g. Jikes, uncomment this line. -->
<!-- (Or make the same change in Tools | Options | Ant Settings | Properties.) -->
<!-- <property name="build.compiler" value="jikes"/> -->
<!-- You might like to set up some overridable paths, etc.: -->
<!-- <property name="mylib" value="../lib/mylib.jar"/> -->
</target>
<target name="compile" depends="init">
<!-- Both srcdir and destdir should be package roots. -->
<!-- They could be different of course; in that case NetBeans can also be set -->
<!-- up to compile to a different filesystem in the same way; see Compiler Types: -->
<javac srcdir="src/java" destdir="classes" debug="true" deprecation="true" source="1.4">
<!-- To add something to the classpath: -->
<classpath>
<pathelement location="lib/jinput.jar"/>
<pathelement location="lib/jutils.jar"/>
</classpath>
<!-- To exclude some files: -->
<!--
<exclude name="com/foo/SomeFile.java"/>
<exclude name="com/foo/somepackage/"/>
-->
</javac>
<exec dir="." executable="g++" os="Windows 2000, Windows XP, Windows 98">
<arg line=" -D_STRICT_ANSI -D_JNI_IMPLEMENTATION_"/>
<arg line=" -I'${java.home}/../include' -I'${java.home}/../include/win32' -Ic:/dx9/include"/>
<arg line=" -o bin/dxinput.dll src/native/input.cpp -Wl,--export-all-symbols"/>
<arg line=" -shared -Wl,--kill-at -ldxguid -ldinput -ldinput8"/>
</exec>
<copy file="bin/dxinput.dll" todir="../../coreAPI/src/tests/controller" />
</target>
<target name="jar" depends="init,compile">
<!-- To make a standalone app: -->
<!-- 1. Create a myapp.mf manifest somewhere. -->
<!-- 2. Put in it: -->
<!-- Manifest-Version: 1.0 -->
<!-- Main-Class: com.foo.Main -->
<!-- 3. Pass to <jar>: manifest="myapp.mf" -->
<jar jarfile="bin/dxinput.jar" compress="true" basedir="classes">
<exclude name="**/*.java"/>
<exclude name="**/*.form"/>
<exclude name="dxinput.mf"/>
<exclude name="dxinput.jar"/>
<exclude name="apidoc"/>
</jar>
<copy file="bin/dxinput.jar" todir="../../coreAPI/src/tests/controller" />
</target>
<target name="all" depends="compile,jar" description="Build everything.">
<echo message="Application built. Hello ${hello}!"/>
</target>
<target name="test" depends="init,all" description="Try running it.">
<echo message="Test by running test on the build.xml for input"/>
</target>
<target name="javadoc" depends="init" description="Javadoc for my API.">
<mkdir dir="apidocs"/>
<javadoc packagenames="net.*"
destdir="apidocs"
additionalparam="-source 1.4">
<sourcepath>
<pathelement location="src/java"/>
</sourcepath>
<classpath>
<pathelement location="lib/jinput.jar"/>
<pathelement location="lib/jutils.jar"/>
</classpath>
</javadoc>
</target>
<target name="clean" depends="init" description="Clean all build products.">
<delete>
<fileset dir="classes">
<include name="**/*.class"/>
</fileset>
</delete>
<delete file="bin/dxinput.jar" failonerror="no"/>
<delete file="bin/dxinput.dll" failonerror="no"/>
<delete file="../../coreAPI/src/tests/controller/dxinput.jar" failonerror="no" />
<delete file="../../coreAPI/src/test/controller/dxinput.dll" failonerror="no"/>
<delete dir="../../docs/input/win32/apidoc" failonerror="no"/>
</target>
</project>

219
plugins/DX8/src/java/net/java/games/input/DirectInputAxis.java
View file

@ -1,219 +0,0 @@
/*
* %W% %E%
*
* Copyright 2002 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
/*****************************************************************************
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materails provided with the distribution.
*
* Neither the name Sun Microsystems, Inc. or the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for us in
* the design, construction, operation or maintenance of any nuclear facility
*
*****************************************************************************/
package net.java.games.input;
import net.java.games.input.AbstractAxis;
import net.java.games.input.Axis;
/**
*
* @author martak
* @version
*/
class DirectInputAxis extends AbstractAxis {
/**
* DIDFT_ constants and macros defined in dinput.h
*/
private static final int DIDFT_ALL = 0x00000000;
private static final int DIDFT_RELAXIS = 0x00000001;
private static final int DIDFT_ABSAXIS = 0x00000002;
private static final int DIDFT_AXIS = 0x00000003;
private static final int DIDFT_PSHBUTTON = 0x00000004;
private static final int DIDFT_TGLBUTTON = 0x00000008;
private static final int DIDFT_BUTTON = 0x0000000C;
private static final int DIDFT_POV = 0x00000010;
private static final int DIDFT_COLLECTION = 0x00000040;
private static final int DIDFT_NODATA = 0x00000080;
private static final int DIDFT_ANYINSTANCE = 0x00FFFF00;
private static final int DIDFT_INSTANCEMASK = DIDFT_ANYINSTANCE;
private static final int DIDFT_FFACTUATOR = 0x01000000;
private static final int DIDFT_FFEFFECTTRIGGER = 0x02000000;
private static final int DIDFT_OUTPUT = 0x10000000;
private static final int DIDFT_NOCOLLECTION = 0x00FFFF00;
private static int DIDFT_MAKEINSTANCE(int n) {
return ((n&0xffff) << 8);
}
private static int DIDFT_GETTYPE(int n) {
return (n&0xFF);
}
private static int DIDFT_GETINSTANCE(int n) {
return ((n >> 8)&0xffff);
}
private static int DIDFT_ENUMCOLLECTION(int n) {
return ((n&0xFFFF) << 8);
}
private DirectInputDevice device;
/**
* DIJOYSTATE structure defined in dinput.h:
*
* <pre>
* typedef struct DIJOYSTATE {
* LONG lX;
* LONG lY;
* LONG lZ;
* LONG lRx;
* LONG lRy;
* LONG lRz;
* LONG rglSlider[2];
* DWORD rgdwPOV[4];
* BYTE rgbButtons[32];
* } DIJOYSTATE, *LPDIJOYSTATE;
*
* 80 bytes total
* </pre>
*/
private int offset;
private int type;
private int instance;
private int bitmask = 0xffffffff;
private int bitshift = 0;
private DirectInputAxis(DirectInputDevice device, Axis.Identifier id,
int didft, String name) {
super(name, id);
this.device = device;
this.type = DIDFT_GETTYPE(didft);
this.instance = DIDFT_GETINSTANCE(didft);
if (id == Axis.Identifier.X) {
offset = 0;
} else if (id == Axis.Identifier.Y) {
offset = 1;
} else if (id == Axis.Identifier.Z) {
offset = 2;
} else if (id == Axis.Identifier.RX) {
offset = 3;
} else if (id == Axis.Identifier.RY) {
offset = 4;
} else if (id == Axis.Identifier.RZ) {
offset = 5;
} else if (id == Axis.Identifier.SLIDER) {
//System.out.println("Slider on "+name+" instance = "+instance);
offset = 6 + (instance>>2);
} else if (id == Axis.Identifier.POV) {
//System.out.println("POV on "+name+" instance = "+instance);
offset = 8 + instance;
} else if (id == Axis.Identifier.BUTTON) {
//System.out.println("Button on "+name+" instance = "+instance);
offset = 12 + (instance/4);
bitshift = (instance%4)*8;
bitmask=0xff;
}
}
/** 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 A float between -1.0 and 1.0
*/
public float getPollData() {
int data = ((device.data[offset] >> bitshift)&bitmask);
if ((type&DIDFT_BUTTON) != 0 ) {
return (float)((data&0x80)>>7);
} else if ((type&DIDFT_AXIS)!=0){ // all axes are set for -32768 to 32738
return ((float)data)/32768;
} else if ((type&DIDFT_POV)!=0) {
if (data == -1) {
return Axis.POV.OFF;
} else if (data == 0.0) {
return Axis.POV.UP;
} else if (data == 4500) {
return Axis.POV.UP_RIGHT;
} else if (data == 9000) {
return Axis.POV.RIGHT;
} else if (data == 13500) {
return Axis.POV.DOWN_RIGHT;
} else if (data == 18000) {
return Axis.POV.DOWN;
} else if (data == 22500) {
return Axis.POV.DOWN_LEFT;
} else if (data == 27000) {
return Axis.POV.LEFT;
} else if (data == 31500) {
return Axis.POV.UP_LEFT;
} else {
System.err.print("Unexpected value for DX8 HAT: "+data);
return Axis.POV.OFF;
}
} else { // return raw value
return (float)data;
}
}
/** 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 true if data has chnaged since last poll, else false
*/
public boolean isRelative() {
return (type & DIDFT_RELAXIS) != 0;
}
/** Returns whether or not the axis is analog, or false if it is digital.
* @return true if analog, false if digital
*/
public boolean isAnalog() {
return (type & DIDFT_AXIS) != 0;
}
/** Returns whether or not data polled from this axis is normalized
* between the values of -1.0f and 1.0f.
* @return true if data is normalized, false if not.
*/
public boolean isNormalized() {
return (type & (DIDFT_BUTTON|DIDFT_AXIS|DIDFT_POV)) != 0;
}
/** Creates a new DirectInputAxis (factory method).
* This is a function used internally during set up
* @return The new DirectInputAxis object.
* @param device The device to attach this axis to.
*
* @param didft The identifier for the axis as provided by DX8.
* @param name A name to give the new axis.
* @param id The identifier for the device
*/
public static DirectInputAxis createAxis(DirectInputDevice device,
Axis.Identifier id, int didft, String name) {
return new DirectInputAxis(device, id, didft, name);
}
}

227
plugins/DX8/src/java/net/java/games/input/DirectInputDevice.java
View file

@ -1,227 +0,0 @@
/*
* %W% %E%
*
* Copyright 2002 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
/*****************************************************************************
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materails provided with the distribution.
*
* Neither the name Sun Microsystems, Inc. or the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for us in
* the design, construction, operation or maintenance of any nuclear facility
*
*****************************************************************************/
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;
/**
*
* @author martak
* @version
*/
class DirectInputDevice extends AbstractController {
/**
* DIDEVTYPE_ constants from dinput.h header file
** JPK NOTE: This changed in DI8. In general this
* is fragile anda way shoudl be found to tie these mroe directly
* to the header files.
*/
/* Mike's <=DX7 types
private static final int DIDEVTYPEJOYSTICK_UNKNOWN = 1;
private static final int DIDEVTYPEJOYSTICK_TRADITIONAL = 2;
private static final int DIDEVTYPEJOYSTICK_FLIGHTSTICK = 3;
private static final int DIDEVTYPEJOYSTICK_GAMEPAD = 4;
private static final int DIDEVTYPEJOYSTICK_RUDDER = 5;
private static final int DIDEVTYPEJOYSTICK_WHEEL = 6;
private static final int DIDEVTYPEJOYSTICK_HEADTRACKER = 7;
*/
/**
* Pointer to the IDirectInputDevice for this device
*/
private long lpDevice;
/**
* Type of device
*/
private Type type;
/**
* Do we need to poll data?
*/
private boolean polled = true;
/**
* Data when polling, as per the DIJOYSTATE structure in dinput.h;
* @see DirectInputAxis for a breakdown of this structure
*/
int[] data = new int[32];
/** Array list of rumblers */
private ArrayList rumblerList = new ArrayList();
/**
* Private constructor
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param subtype The subtype of device, as defined in the DIDEVTYPE
* constants above
* @param productName The product name for the device
* @param instanceName The name of the device
*/
private DirectInputDevice(long lpDevice, int subtype, String productName,
String instanceName,boolean polled) {
super(productName + " " + instanceName);
this.lpDevice = lpDevice;
this.polled = polled;
System.out.println("Creating "+productName+" polling = "+polled);
switch(subtype) {
/*
case DIDEVTYPEJOYSTICK_GAMEPAD:
type = Type.GAMEPAD; break;
case DIDEVTYPEJOYSTICK_RUDDER:
type = Type.RUDDER; break;
case DIDEVTYPEJOYSTICK_WHEEL:
type = Type.WHEEL; break;
case DIDEVTYPEJOYSTICK_HEADTRACKER:
type = Type.HEADTRACKER; break;
case DIDEVTYPEJOYSTICK_TRADITIONAL: // fall through
case DIDEVTYPEJOYSTICK_FLIGHTSTICK: // fall through
*/
default:
type = Type.STICK; break;
}
axes = initDirectInputAxes();
}
/**
* Used instead of overriding initAxes because it needs the
* pointer to the IDirectInputDevice
*/
private Axis[] initDirectInputAxes() {
ArrayList list = new ArrayList();
enumObjects(lpDevice, list);
Axis[] ret = new Axis[list.size()];
Iterator it = list.iterator();
int i = 0;
while (it.hasNext()) {
ret[i] = (Axis)it.next();
i++;
}
return ret;
}
/**
* Callback called by enumObjects to add a new axis into the list
* @param list This in which to add the new axis
* @param id The identifier for the axis, based on GUID
* @param didft The combination of DIDFT_ flags that make up the type and
* instance number of the axis.
* @param name The name to call the axis.
*/
private void addAxis(ArrayList list, Axis.Identifier id, int didft,
String name) {
list.add(DirectInputAxis.createAxis(this, id, didft, name));
}
/**
* Callback called by enumDevice to add a rumbler
*
* @param effect the natie effect id
* @param axisID The axis ID
*/
private void addRumbler(long effect, Axis.Identifier axisID, String axisName) {
rumblerList.add(new DirectInputRumbler(this, effect, axisID, axisName));
}
/** Polls axes for data. Returns false if the controller is no longer valid.
* Polling reflects the current state of the device when polled, and is
* unbuffered.
* @return False if the co troller is no longer valid, else true.
*/
public boolean poll() {
return pollNative(lpDevice, data, polled);
}
/** Returns the type of Controller.
* @return The type of the controller.
*/
public Type getType() {
return type;
}
/** Returns the zero-based port number for this Controller.
* @return The port number.
*/
public int getPortNumber() {
// REMIND : We may be able to parse this from the name string
return 0;
}
/**
* Returns the rumbler array
*/
public Rumbler[] getRumblers() {
return (Rumbler[]) rumblerList.toArray(new Rumbler[0]);
}
/**
* Polls the device; native method. The data from the poll is stored in
* the data array.
*/
private native boolean pollNative(long lpDevice, int[] data,
boolean polled);
/**
* Enumerates the axes on the device
*/
private native boolean enumObjects(long lpDevice, ArrayList list);
/** Creates a new DirectInputDevice (factory method)
* This is a function used internally during set up
* @param polled Whether this device's driver should actually be
* polled during a call to Poll or whether it is an
* interrupt driven device that should ignore poll
* requests.
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param subtype The subtype of device, as defined in the DIDEVTYPE
* constants above
* @param productName The product name for the device
* @param instanceName The name of the device
* @return The new DirectInputDevice object
*/
public static DirectInputDevice createDevice(long lpDevice, int subtype,
String productName, String instanceName, boolean polled) {
return new DirectInputDevice(lpDevice, subtype, productName,
instanceName,polled);
}
} // class DirectInputDevice

186
plugins/DX8/src/java/net/java/games/input/DirectInputEnvironmentPlugin.java
View file

@ -1,186 +0,0 @@
/*
* %W% %E%
*
* Copyright 2002 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
/*****************************************************************************
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materails provided with the distribution.
*
* Neither the name Sun Microsystems, Inc. or the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for us in
* the design, construction, operation or maintenance of any nuclear facility
*
*****************************************************************************/
package net.java.games.input;
import java.security.AccessController;
import java.util.ArrayList;
import java.util.Iterator;
import net.java.games.input.Controller;
import net.java.games.input.ControllerEnvironment;
//import sun.security.action.LoadLibraryAction;
import net.java.games.util.plugins.Plugin;
/** DirectInput implementation of controller environment
* @author martak
* @version 1.0
*/
public class DirectInputEnvironmentPlugin extends ControllerEnvironment
implements Plugin
{
static {
/** Mikes old code, causes it to be laoded by wrong loader
java.security.AccessController.doPrivileged(
new LoadLibraryAction("jinput"));
*/
System.loadLibrary("dxinput");
}
/**
* DIDEVTYPE_ constants from dinput.h header file
* JPK NOTE: changed in DX8 so had to be changed. This is
* fragile, we should find a way to set them from
* the C side sowe can stay up to date with header
*/
/** DX7 and earlier
private static final int DIDEVTYPE_DEVICE = 1;
private static final int DIDEVTYPE_MOUSE = 2;
private static final int DIDEVTYPE_KEYBOARD = 3;
private static final int DIDEVTYPE_JOYSTICK = 4;
private static final int DIDEVTYPE_HID = 0x00010000;
private static int GET_DIDEVICE_TYPE(int dwDevType) {
return (int)((byte)dwDevType);
}
private static int GET_DIDEVICE_SUBTYPE(int dwDevType) {
return (int)((byte)((((short)dwDevType) >> 8) & 0xFF));
}
**/
/* DX8 and 9 */
private static final int DI8DEVTYPE_DEVICE = 0x11;
private static final int DI8DEVTYPE_MOUSE = 0x12;
private static final int DI8DEVTYPE_KEYBOARD = 0x13;
private static final int DI8DEVTYPE_JOYSTICK = 0x14;
private static final int DI8DEVTYPE_GAMEPAD = 0x15;
private static final int DI8DEVTYPE_DRIVING = 0x16;
private static final int DI8DEVTYPE_FLIGHT = 0x17;
private static final int DI8DEVTYPE_1STPERSON = 0x18;
private static final int DI8DEVTYPE_DEVICECTRL = 0x19;
private static final int DI8DEVTYPE_SCREENPOINTER = 0x1A;
private static final int DI8DEVTYPE_REMOTE = 0x1B;
private static final int DI8DEVTYPE_SUPPLEMENTAL = 0x1C;
private static int GET_DIDEVICE_TYPE(int dwDevType) {
return (dwDevType&0xFF);
}
private static int GET_DIDEVICE_SUBTYPE(int dwDevType) {
return (int)((byte)((((short)dwDevType) >> 8) & 0xFF));
}
// Pointer to DirectInput instance
private long lpDirectInput;
// Permanent array of controllers
private Controller[] controllers;
/** Creates new DirectInputEnvironment */
public DirectInputEnvironmentPlugin() {
lpDirectInput = directInputCreate();
enumControllers();
}
/** Returns a list of all controllers available to this environment,
* or an empty array if there are no controllers in this environment.
* @return An array of controllers that may be empty.
*/
public Controller[] getControllers() {
return controllers;
}
private void enumControllers() {
// If direct input fails, create an empty array
if (lpDirectInput == 0) {
controllers = new Controller[] {};
return;
}
// Create temporary controller array
ArrayList tempDevices = new ArrayList();
// Eumerate devices
enumDevices(lpDirectInput, tempDevices);
// Set up permanent controller array
controllers = new Controller[tempDevices.size()];
Iterator it = tempDevices.iterator();
int i = 0;
while (it.hasNext()) {
controllers[i] = (Controller)it.next();
i++;
}
}
/**
* Creates a new device, adding it to the list supplied.
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param type The type of device to create, as defined by the constants
* in dinput.h (see DI8DEVTYPE constants above).
* @param productName The product name for the device
* @param instanceName The name of the device
*/
private void addDevice(ArrayList list, long lpDevice,
int type, String productName, String instanceName, boolean polled) {
Controller c;
int category = GET_DIDEVICE_TYPE(type);
int subtype = GET_DIDEVICE_SUBTYPE(type);
//System.out.println("Category = "+category);
if (category == DI8DEVTYPE_MOUSE) {
c = DirectInputMouse.createMouse(lpDevice, subtype, productName,
instanceName);
} else if (category == DI8DEVTYPE_KEYBOARD) {
c = DirectInputKeyboard.createKeyboard(lpDevice, subtype,
productName, instanceName);
} else {
// commented out the assert as we have already got devices that are
// gamepad type, but wr are still going to create them as
// DirectInputDevices
//assert category == DI8DEVTYPE_JOYSTICK;
c = DirectInputDevice.createDevice(lpDevice, subtype, productName,
instanceName,polled);
}
if (c != null) {
list.add(c);
}
}
/**
* Returns the direct input instance, or 0 if failed to initialize
*/
private native long directInputCreate();
/**
* Enumerates all devices, calling createDevice for each one
*/
private native boolean enumDevices(long lpDirectInput, ArrayList list);
} // class DirectInputEnvironment

208
plugins/DX8/src/java/net/java/games/input/DirectInputKeyboard.java
View file

@ -1,208 +0,0 @@
/*
* %W% %E%
*
* Copyright 2002 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
/*****************************************************************************
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materails provided with the distribution.
*
* Neither the name Sun Microsystems, Inc. or the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for us in
* the design, construction, operation or maintenance of any nuclear facility
*
*****************************************************************************/
package net.java.games.input;
import net.java.games.input.AbstractAxis;
import net.java.games.input.Axis;
import net.java.games.input.StandardKeyboard;
/**
* DirectInput keyboard implementation.
* @author martak
* @version
*/
class DirectInputKeyboard extends StandardKeyboard {
/**
* DIDEVTYPE_ constants from dinput.h header file
*/
private static final int DIDEVTYPEKEYBOARD_UNKNOWN = 0;
private static final int DIDEVTYPEKEYBOARD_PCXT = 1;
private static final int DIDEVTYPEKEYBOARD_OLIVETTI = 2;
private static final int DIDEVTYPEKEYBOARD_PCAT = 3;
private static final int DIDEVTYPEKEYBOARD_PCENH = 4;
private static final int DIDEVTYPEKEYBOARD_NOKIA1050 = 5;
private static final int DIDEVTYPEKEYBOARD_NOKIA9140 = 6;
private static final int DIDEVTYPEKEYBOARD_NEC98 = 7;
private static final int DIDEVTYPEKEYBOARD_NEC98LAPTOP = 8;
private static final int DIDEVTYPEKEYBOARD_NEC98106 = 9;
private static final int DIDEVTYPEKEYBOARD_JAPAN106 = 10;
private static final int DIDEVTYPEKEYBOARD_JAPANAX = 11;
private static final int DIDEVTYPEKEYBOARD_J3100 = 12;
/**
* Key index crosstable; maps indices into the data array to virtual keys
* in the key array in StandardKeyboard.
* For example, the key F11 is at index 84 in the array of keys in
* StandardKeyboard, yet it is data element 87 (0x57) in our data array.
* <p>
* To access the data element of a particular key (F11), we use the
* crosstable as follows:
* <p><code>
* KeyID f11 = StandardKey.KeyID.F11;
* int keyIndex = f11.getKeyIndex(); // returns 84
* int crossIndex = CROSSTABLE[keyIndex]; // returns 0x57 (87)
* </code>
* To find a key given the data element index (87), we do a simple search
* through the crosstable starting at that index (index 87/0x57 = 0x65) and
* looking backwards until we find our key itself, or a lower number
* (meaning the key was not found). We can only take advantage of this
* algorithm only because on Windows, our crosstable is in increasing order.
*/
private final static int[] CROSSTABLE = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, // _9
0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, // Y
0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, // D
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, // BACKSLASH
0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, // RSHIFT
0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, // F7
0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, // NUMPAD5
0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x57, 0x58, 0x64, 0x65, // F14
0x66, 0x70, 0x79, 0x7B, 0x7D, 0x8D, 0x90, 0x91, 0x92, 0x93, 0x94, // KANJI
0x95, 0x96, 0x97, 0x9C, 0x9D, 0xB3, 0xB5, 0xB7, 0xB8, 0xC5, 0xC7, // HOME
0xC8, 0xC9, 0xCB, 0xCD, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xDB, 0xDC, // RWIN
0xDD, 0xDE, 0xDF // SLEEP
};
/**
* Pointer to the IDirectInputDevice for this device
*/
private long lpDevice;
/**
* Subtype of keyboard, defined by DIDEVTYPE constants
*/
private int subtype;
/**
* Polling key data
*/
private byte[] keyData = new byte[256];
/**
* Private constructor
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param subtype The subtype of keyboard, as defined in the DIDEVTYPE
* constants above
* @param productName The product name for the device
* @param instanceName The name of the device
*/
private DirectInputKeyboard(long lpDevice, int subtype, String productName,
String instanceName) {
super(productName + " (" + instanceName + ")");
this.lpDevice = lpDevice;
this.subtype = subtype;
}
/**
* Callback to rename a given key by index, name
* @param index the index in the data array
* @param name the name of the key
*/
private void renameKey(int index, String name) {
int keyIndex = index;
if (keyIndex > CROSSTABLE.length) {
keyIndex = CROSSTABLE.length - 1;
}
for (; CROSSTABLE[keyIndex] > index; keyIndex--)
;
if (CROSSTABLE[keyIndex] == index) {
Axis[] axes = getAxes();
AbstractAxis key = (AbstractAxis)axes[index];
if (name != null && name.length() > 0) {
//System.out.println("Renaming key " + key.getName() +
// " to " + name + " index=" +
// index + " keyIndex=" + keyIndex + " CROSSTAB=" +
// CROSSTABLE[keyIndex]);
key.setName(name);
}
} else {
//System.out.println("Key not found " + name + " index=" + index +
// " keyIndex=" + keyIndex + " CROSSTAB=" +
// CROSSTABLE[keyIndex]);
}
}
/** 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 KB is no longer valid, true otherwise.
*/
public boolean poll() {
return pollNative(lpDevice, keyData);
}
/** Returns whether or not the given key has been pressed since the last
* call to poll.
* @param key The key whose state to check.
* @return true if this key has changed state since last read of its state, false otherwise.
*/
protected boolean isKeyPressed(Key key) {
KeyID id = (KeyID)key.getIdentifier();
int keyIndex = id.getKeyIndex();
int crossIndex = CROSSTABLE[keyIndex];
return ((keyData[crossIndex] & 0x80) != 0);
}
/**
* Polls the device; native method
*/
private native boolean pollNative(long lpDevice, byte[] keyData);
/**
* Renames the keys with the name provided by DirectInput
*/
private native boolean renameKeys(long lpDevice);
/** Creates a new DirectInputKeyboard (factory method)
* This is a function used internally during set up.
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param subtype The subtype of keyboard, as defined in the DIDEVTYPE
* constants above
* @param productName The product name for the keyboard
* @param instanceName The name of the keyboard
* @return The new DirectInputKeyboard object.
*/
public static DirectInputKeyboard createKeyboard(long lpDevice,
int subtype, String productName, String instanceName) {
DirectInputKeyboard ret = new DirectInputKeyboard(lpDevice, subtype,
productName, instanceName);
ret.renameKeys(lpDevice);
return ret;
}
} // class DirectInputKeyboard

352
plugins/DX8/src/java/net/java/games/input/DirectInputMouse.java
View file

@ -1,352 +0,0 @@
/*
* %W% %E%
*
* Copyright 2002 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
/*****************************************************************************
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materails provided with the distribution.
*
* Neither the name Sun Microsystems, Inc. or the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for us in
* the design, construction, operation or maintenance of any nuclear facility
*
*****************************************************************************/
package net.java.games.input;
import net.java.games.input.AbstractAxis;
import net.java.games.input.Axis;
import net.java.games.input.Mouse;
/**
* DirectInput mouse implementation.
* @author martak
* @version
*/
class DirectInputMouse extends Mouse {
/**
* DIDEVTYPE_ constants from dinput.h header file
*/
private static final int DIDEVTYPEMOUSE_UNKNOWN = 1;
private static final int DIDEVTYPEMOUSE_TRADITIONAL = 2;
private static final int DIDEVTYPEMOUSE_FINGERSTICK = 3;
private static final int DIDEVTYPEMOUSE_TOUCHPAD = 4;
private static final int DIDEVTYPEMOUSE_TRACKBALL = 5;
/**
* Pointer to the IDirectInputDevice for this device
*/
private long lpDevice;
/**
* Type of mouse
*/
private Type type;
/**
* Mouse data
*/
private byte[] mouseData = new byte[20];
/**
* Private constructor
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param subtype The subtype of mouse, as defined in the DIDEVTYPE
* constants above
* @param productName The product name for the device
* @param instanceName The name of the device
*/
private DirectInputMouse(long lpDevice, int subtype, String productName,
String instanceName) {
super(productName + " " + instanceName);
this.lpDevice = lpDevice;
buttons = new ButtonsImpl();
ball = new BallImpl();
switch(subtype) {
case DIDEVTYPEMOUSE_FINGERSTICK:
type = Type.FINGERSTICK; break;
case DIDEVTYPEMOUSE_TOUCHPAD:
type = Type.TRACKPAD; break;
case DIDEVTYPEMOUSE_TRACKBALL:
type = Type.TRACKBALL; break;
case DIDEVTYPEMOUSE_TRADITIONAL: // fall through
case DIDEVTYPEMOUSE_UNKNOWN: // fall through
default:
type = Type.MOUSE; break;
}
renameAxes(lpDevice);
}
/**
* Callback to rename a given axis by type, name
*/
private void renameAxis(Axis.Identifier id, String name) {
AbstractAxis axis;
if (id instanceof ButtonID) {
axis = (AbstractAxis)getButtons().getAxis(id);
} else {
axis = (AbstractAxis)getBall().getAxis(id);
}
axis.setName(name);
//System.out.println("Renaming " + name);
}
/** 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 mosue is no lonegr valid, true otherwise.
*/
public boolean poll() {
return pollNative(lpDevice, mouseData);
}
/** Returns the type of the Controller.
* @return The device type of the controller (logically this
* shoudl be some form of "mouse" .)
*/
public Type getType() {
return type;
}
/** Creates a new DirectInputMouse (factory method)
* This is a function used internally during set up.
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param subtype The subtype of mouse, as defined in the DIDEVTYPE
* constants above
* @param productName The product name for the keyboard
* @param instanceName The name of the keyboard
* @return The new DirectInputMouse object.
*/
public static DirectInputMouse createMouse(long lpDevice, int subtype,
String productName, String instanceName) {
return new DirectInputMouse(lpDevice, subtype, productName,
instanceName);
}
/**
* Implementation class representing the mouse ball
*/
class BallImpl extends Ball {
private int numAxes;
/**
* Public constructor
*/
public BallImpl() {
super(DirectInputMouse.this.getName() + " ball");
numAxes = getNumAxes(lpDevice);
x = new BallAxis(Axis.Identifier.X);
y = new BallAxis(Axis.Identifier.Y);
if(numAxes > 2) {
wheel = new BallAxis(Axis.Identifier.SLIDER);
}
}
} // class DirectInputMouse.BallImpl
/**
* Implementation class representing the mouse buttons
*/
class ButtonsImpl extends Buttons {
private int numButtons;
/**
* Public constructor
*/
public ButtonsImpl() {
super(DirectInputMouse.this.getName() + " buttons");
numButtons = getNumButtons(lpDevice);
left = new ButtonImpl(ButtonID.LEFT);
right = new ButtonImpl(ButtonID.RIGHT);
if(numButtons>2) {
middle = new ButtonImpl(ButtonID.MIDDLE);
}
if(numButtons>3) {
side = new ButtonImpl(ButtonID.SIDE);
}
if(numButtons>4) {
extra = new ButtonImpl(ButtonID.EXTRA);
}
if(numButtons>5) {
forward = new ButtonImpl(ButtonID.FORWARD);
}
if(numButtons>6) {
back = new ButtonImpl(ButtonID.BACK);
}
}
} // class DirectInputMouse.ButtonsImpl
/**
* Polls the device; native method
*/
private native boolean pollNative(long lpDevice, byte[] mouseData);
/**
* Renames the axes with the name provided by DirectInput
*/
private native boolean renameAxes(long lpDevice);
// another Endolf special
/**
* Gets the number of buttons the mouse supports
*/
private native int getNumButtons(long lpDevice);
/**
* Gets the number of axes the mouse supports
*/
private native int getNumAxes(long lpDevice);
/**
* Mouse button axis implementation
*/
class ButtonImpl extends Button {
/**
* Index into the mouseData array
*/
private final int index;
/** Public constructor
* @param id An ID of a button to create an obejct to represent.
*
*/
public ButtonImpl(ButtonID id) {
super(id.getName(), id);
if (id == ButtonID.LEFT) {
index = 12;
} else if (id == ButtonID.RIGHT) {
index = 13;
} else if (id == ButtonID.MIDDLE) {
index = 14;
} else if (id == ButtonID.SIDE) {
index = 15;
} else if (id == ButtonID.EXTRA) {
index = 16;
} else if (id == ButtonID.FORWARD) {
index = 17;
} else if (id == ButtonID.BACK) {
index = 18;
} else {
throw new RuntimeException("Unknown button");
}
}
/** 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 state of controller. (Note: DX8 mice actually
* queue state so what is returned is the next state,
* not necessarily the most current one.)
*/
public float getPollData() {
// Mouse button
byte data = mouseData[index];
if ((data & 0x80) != 0) {
return 1.0f;
} else {
return 0.0f;
}
}
/** 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 true if data is relative, otherwise false.
*/
public boolean isRelative() {
return false;
}
} // class DirectInputMouse.ButtonImpl
/**
* Mouse ball axis implementation
*/
class BallAxis extends AbstractAxis {
/**
* Starting index into the mouseData array
*/
private final int index;
/** Public constructor
* @param id An ID for a mouse axis to create an object to represent.
*/
public BallAxis(Identifier id) {
super(id.getName(), id);
if (id == Identifier.X) {
index = 0;
} else if (id == Identifier.Y) {
index = 4;
} else if (id == Identifier.SLIDER) {
index = 8;
} else {
throw new RuntimeException("Unknown mouse axis");
}
}
// Endolf changed this comment, we *are* a mouse axis if we are in here,
// and mouse axes no longer are normalised at all
/** Returns the data from the last time the control has been polled.
*
* @return data The total mouse axis change since the last poll
*/
public float getPollData() {
int data = ((int)mouseData[index+3] << 24) |
((int)mouseData[index + 2] << 16) |
((int)mouseData[index + 1] << 8) |
((int)mouseData[index]);
return (float)data;
}
/** 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 true if relative, otherwise false.
*/
public boolean isRelative() {
return true;
}
/** Returns whether or not the axis is analog, or false if it is digital.
* @return true if analog, false if digital
*/
public boolean isAnalog() {
return true;
}
/** Returns whether or not data polled from this axis is normalized between the values of -1.0f and 1.0f.
*
* @return true if normalized, otherwise false.
*/
public boolean isNormalized() {
return false;
}
} // class DirectInputMouse.MouseBallAxis
} // class DirectInputMouse

101
plugins/DX8/src/java/net/java/games/input/DirectInputRumbler.java
View file

@ -1,101 +0,0 @@
/**
* 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;
/**
* Implementation of the Rumbler interface for direct x
*
* @author Endolf
*/
public class DirectInputRumbler implements Rumbler {
/** The parent device */
private DirectInputDevice device;
/** The native effect */
private long effect;
/** The identifier of the axis we are attached too */
private Axis.Identifier axisID;
/** The name of the axis this rumbler is attached too */
private String axisName;
/**
* Creates a new instance of DirectInputRumbler
*
* @param device The parent device
* @param effect The native effect
* @param axisID The id of the axis this rumbler is attached too
* @param axisName The name of the axis this rumbler is attached too
*/
public DirectInputRumbler(DirectInputDevice device, long effect, Axis.Identifier axisID, String axisName) {
this.device = device;
this.effect = effect;
this.axisID = axisID;
this.axisName = axisName;
}
/**
* Gets the identifier of the axis this rumbler is attached too
*
* @return The axis id
*/
public Axis.Identifier getAxisIdentifier() {
return axisID;
}
/**
* Gets the name of the axis this rumbler is attached too
*
* @return The axis name
*/
public String getAxisName() {
return axisName;
}
/**
* Rumbles this rumbler at the given intensity.
* This will start or stop the effect if necesary.
* The intensity is in the range of -1 to 1 and will be clipped if values
* outside that range are provided.
*
* @param intensity The intensity
*/
public void rumble(float intensity) {
if(intensity>1f) {
intensity = 1.0f;
} else if(intensity<-1f) {
intensity = -1.0f;
}
setRumble(effect, intensity);
}
/**
* Performs the native call(s) to run the effect
*
* @param effect The native effect
* @param intensity The intensity of the rumble
*/
private native void setRumble(long effect, float intensity);
}

1114
plugins/DX8/src/native/input.cpp
View file

File diff suppressed because it is too large Load diff

81
plugins/OSX/build.xml
View file

@ -1,81 +0,0 @@
<?xml version="1.0" ?>
<project basedir="." default="all" name="OSX Plugin">
<description>OSX JInput Plugin</description>
<property name="src" location="src" />
<property name="build" location="classes" />
<property name="dist" location="dist" />
<property name="plugins" location="plugins" />
<target name="init">
<mkdir dir="classes"/>
<mkdir dir="dist"/>
</target>
<target depends="init" name="compile">
<javac debug="true" deprecation="true" destdir="${build}" source="1.4" srcdir="src/java">
<classpath>
<pathelement location="../../coreAPI/bin/jinput.jar"/>
<pathelement location="../../coreAPI/lib/jutils.jar"/>
</classpath>
</javac>
</target>
<target depends="init,compile" name="jar">
<jar jarfile="${dist}/HIDWrapper.jar" compress="true" basedir="${build}">
<exclude name="**/*.java"/>
<exclude name="HIDWrapper.jar"/>
<exclude name="apidoc"/>
</jar>
<copy file="${dist}/HIDWrapper.jar" todir="../../coreAPI/src/tests/controller" />
</target>
<target depends="compileNativeJinputLib,jar" description="Build everything." name="all">
<echo message="Native OSX JInput library built!"/>
</target>
<target name="javadoc" depends="init" description="Javadoc for OS X plugin for JInput.">
<mkdir dir="apidocs"/>
<javadoc packagenames="net.java.games.input.*"
destdir="apidocs"
additionalparam="-source 1.4"
link="../../../coreAPI/apidocs">
<sourcepath>
<pathelement location="src/java"/>
</sourcepath>
<classpath>
<pathelement location="../../coreAPI/bin/jinput.jar"/>
<pathelement location="../../coreAPI/lib/jutils.jar"/>
</classpath>
</javadoc>
</target>
<target description="Clean all build products." name="clean">
<delete failonerror="no">
<fileset dir="${build}">
<include name="**/*.class"/>
</fileset>
</delete>
<delete file="${dist}/HIDWrapper.jar" failonerror="no"/>
<delete file="${dist}/libjinput.jnilib" failonerror="no"/>
<delete file="../../coreAPI/src/tests/controller/HIDWrapper.jar" failonerror="no" />
<delete file="../../coreAPI/src/tests/controller/libjinput.jnilib" failonerror="no"/>
<delete file="apidoc" failonerror="no"/>
</target>
<target depends="init,compile" name="createJNIHeaders">
<javah destdir="src/native">
<classpath>
<pathelement path="${build}"/>
<pathelement location="../../coreAPI/classes"/>
</classpath>
<class name="net.java.games.input.OSXEnvironmentPlugin"/>
</javah>
</target>
<target name="compileNativeJinputLib" depends="init,createJNIHeaders" >
<ant dir="src/native" target="compileNativeJinputLib"/>
<copy file="src/native/libjinput.jnilib" todir="${dist}" />
<copy file="${dist}/libjinput.jnilib" todir="../../coreAPI/src/tests/controller" />
</target>
</project>

13
plugins/OSX/src/java/net/java/games/input/InputController.java
View file

@ -1,13 +0,0 @@
package net.java.games.input;
/**
* Created by IntelliJ IDEA.
* User: gpierce
* Date: Aug 2, 2003
* Time: 2:57:15 PM
* To change this template use Options | File Templates.
*/
public interface InputController
{
public void addControllerElement( InputControllerElement element );
}

195
plugins/OSX/src/java/net/java/games/input/InputControllerElement.java
View file

@ -1,195 +0,0 @@
package net.java.games.input;
/**
* Created by IntelliJ IDEA.
* User: gpierce
* Date: Aug 2, 2003
* Time: 2:59:26 PM
* To change this template use Options | File Templates.
*/
public class InputControllerElement
{
private long hidCookie;
private int elementType;
private int usagePage;
private int usage;
private int rawMin;
private int rawMax;
private int scaledMin;
private int scaledMax;
private int dataBitSize;
private boolean isRelative;
private boolean isWrapping;
private boolean isNonLinear;
private boolean hasPreferredState;
private boolean hasNullState;
public InputControllerElement()
{
}
public InputControllerElement(long hidCookie, int elementType, int usage, int usagePage,
int rawMin, int rawMax, int scaledMin, int scaledMax,
int dataBitSize, boolean isRelative, boolean isWrapping,
boolean isNonLinear, boolean hasPreferredState, boolean hasNullState )
{
this.hidCookie = hidCookie;
this.elementType = elementType;
this.usage = usage;
this.usagePage = usagePage;
this.rawMin = rawMin;
this.rawMax = rawMax;
this.scaledMin = scaledMin;
this.scaledMax = scaledMax;
this.dataBitSize = dataBitSize;
this.isRelative = isRelative;
this.isWrapping = isWrapping;
this.isNonLinear = isNonLinear;
this.hasPreferredState = hasPreferredState;
this.hasNullState = hasNullState;
}
public long getHidCookie()
{
return hidCookie;
}
public void setHidCookie(long hidCookie)
{
this.hidCookie = hidCookie;
}
public int getElementType()
{
return elementType;
}
public void setElementType(int elementType)
{
this.elementType = elementType;
}
public int getUsagePage()
{
return usagePage;
}
public void setUsagePage(int usagePage)
{
this.usagePage = usagePage;
}
public int getUsage()
{
return usage;
}
public void setUsage(int usage)
{
this.usage = usage;
}
public int getRawMin()
{
return rawMin;
}
public void setRawMin(int rawMin)
{
this.rawMin = rawMin;
}
public int getRawMax()
{
return rawMax;
}
public void setRawMax(int rawMax)
{
this.rawMax = rawMax;
}
public int getScaledMin()
{
return scaledMin;
}
public void setScaledMin(int scaledMin)
{
this.scaledMin = scaledMin;
}
public int getScaledMax()
{
return scaledMax;
}
public void setScaledMax(int scaledMax)
{
this.scaledMax = scaledMax;
}
public int getDataBitSize()
{
return dataBitSize;
}
public void setDataBitSize(int dataBitSize)
{
this.dataBitSize = dataBitSize;
}
public boolean isRelative()
{
return isRelative;
}
public void setRelative(boolean relative)
{
isRelative = relative;
}
public boolean isWrapping()
{
return isWrapping;
}
public void setWrapping(boolean wrapping)
{
isWrapping = wrapping;
}
public boolean isNonLinear()
{
return isNonLinear;
}
public void setNonLinear(boolean nonLinear)
{
isNonLinear = nonLinear;
}
public boolean isHasPreferredState()
{
return hasPreferredState;
}
public void setHasPreferredState(boolean hasPreferredState)
{
this.hasPreferredState = hasPreferredState;
}
public boolean isHasNullState()
{
return hasNullState;
}
public void setHasNullState(boolean hasNullState)
{
this.hasNullState = hasNullState;
}
}

484
plugins/OSX/src/java/net/java/games/input/OSXEnvironmentPlugin.java
View file

@ -1,484 +0,0 @@
/*
* %W% %E%
*
* Copyright 2002 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
/*****************************************************************************
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materails provided with the distribution.
*
* Neither the name Sun Microsystems, Inc. or the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for us in
* the design, construction, operation or maintenance of any nuclear facility
*
*****************************************************************************/
package net.java.games.input;
import java.security.AccessController;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.HashMap;
import net.java.games.input.Controller;
import net.java.games.input.ControllerEnvironment;
import net.java.games.util.plugins.Plugin;
/** OSX HIDManager implementation of controller environment
* @author gregorypierce
* @version 1.0
*/
public class OSXEnvironmentPlugin extends ControllerEnvironment implements Plugin
{
public static final int HID_DEVICE_MOUSE = 0x02;
public static final int HID_DEVICE_JOYSTICK = 0x04;
public static final int HID_DEVICE_GAMEPAD = 0x05;
public static final int HID_DEVICE_KEYBOARD = 0x06;
public static final int HID_USAGE_POINTER = 0x01;
public static final int HID_USAGE_XAXIS = 0x30;
public static final int HID_USAGE_YAXIS = 0x31;
public static final int HID_USAGE_ZAXIS = 0x32;
public static final int HID_USAGE_XAXIS_ROTATION = 0x33;
public static final int HID_USAGE_YAXIS_ROTATION = 0x34;
public static final int HID_USAGE_ZAXIS_ROTATION = 0x35;
public static final int HID_USAGE_SLIDER = 0x36;
public static final int HID_USAGE_DIAL = 0x37;
public static final int HID_USAGE_WHEEL = 0x38;
public static final int HID_USAGE_HAT = 0x39;
public static final int HID_USAGE_DPAD_UP = 0x90;
public static final int HID_USAGE_DPAD_DOWN = 0x91;
public static final int HID_USAGE_DPAD_LEFT = 0x92;
public static final int HID_USAGE_DPAD_RIGHT = 0x93;
public static final int HID_USAGE_KEYBOARD_ERRORROLLOVER = 0x01; /* ErrorRollOver */
public static final int HID_USAGE_KEYBOARD_POSTFAIL = 0x02; /* POSTFail */
public static final int HID_USAGE_KEYBOARD_ERRORUNDEFINED = 0x03; /* ErrorUndefined */
public static final int HID_USAGE_KEYBOARD_A = 0x04; /* a or A */
public static final int HID_USAGE_KEYBOARD_B = 0x05; /* b or B */
public static final int HID_USAGE_KEYBOARD_C = 0x06; /* c or C */
public static final int HID_USAGE_KEYBOARD_D = 0x07; /* d or D */
public static final int HID_USAGE_KEYBOARD_E = 0x08; /* e or E */
public static final int HID_USAGE_KEYBOARD_F = 0x09; /* f or F */
public static final int HID_USAGE_KEYBOARD_G = 0x0A; /* g or G */
public static final int HID_USAGE_KEYBOARD_H = 0x0B; /* h or H */
public static final int HID_USAGE_KEYBOARD_I = 0x0C; /* i or I */
public static final int HID_USAGE_KEYBOARD_J = 0x0D; /* j or J */
public static final int HID_USAGE_KEYBOARD_K = 0x0E; /* k or K */
public static final int HID_USAGE_KEYBOARD_L = 0x0F; /* l or L */
public static final int HID_USAGE_KEYBOARD_M = 0x10; /* m or M */
public static final int HID_USAGE_KEYBOARD_N = 0x11; /* n or N */
public static final int HID_USAGE_KEYBOARD_O = 0x12; /* o or O */
public static final int HID_USAGE_KEYBOARD_P = 0x13; /* p or P */
public static final int HID_USAGE_KEYBOARD_Q = 0x14; /* q or Q */
public static final int HID_USAGE_KEYBOARD_R = 0x15; /* r or R */
public static final int HID_USAGE_KEYBOARD_S = 0x16; /* s or S */
public static final int HID_USAGE_KEYBOARD_T = 0x17; /* t or T */
public static final int HID_USAGE_KEYBOARD_U = 0x18; /* u or U */
public static final int HID_USAGE_KEYBOARD_V = 0x19; /* v or V */
public static final int HID_USAGE_KEYBOARD_W = 0x1A; /* w or W */
public static final int HID_USAGE_KEYBOARD_X = 0x1B; /* x or X */
public static final int HID_USAGE_KEYBOARD_Y = 0x1C; /* y or Y */
public static final int HID_USAGE_KEYBOARD_Z = 0x1D; /* z or Z */
public static final int HID_USAGE_KEYBOARD_1 = 0x1E; /* 1 or ! */
public static final int HID_USAGE_KEYBOARD_2 = 0x1F; /* 2 or @ */
public static final int HID_USAGE_KEYBOARD_3 = 0x20; /* 3 or # */
public static final int HID_USAGE_KEYBOARD_4 = 0x21; /* 4 or $ */
public static final int HID_USAGE_KEYBOARD_5 = 0x22; /* 5 or % */
public static final int HID_USAGE_KEYBOARD_6 = 0x23; /* 6 or ^ */
public static final int HID_USAGE_KEYBOARD_7 = 0x24; /* 7 or & */
public static final int HID_USAGE_KEYBOARD_8 = 0x25; /* 8 or * */
public static final int HID_USAGE_KEYBOARD_9 = 0x26; /* 9 or ( */
public static final int HID_USAGE_KEYBOARD_0 = 0x27; /* 0 or ) */
public static final int HID_USAGE_KEYBOARD_ENTER = 0x28; /* Return (Enter) */
public static final int HID_USAGE_KEYBOARD_ESCAPE = 0x29; /* Escape */
public static final int HID_USAGE_KEYBOARD_BACKSPACE = 0x2A; /* Delete (Backspace) */
public static final int HID_USAGE_KEYBOARD_TAB = 0x2B; /* Tab */
public static final int HID_USAGE_KEYBOARD_SPACEBAR = 0x2C; /* Spacebar */
public static final int HID_USAGE_KEYBOARD_HYPHEN = 0x2D; /* - or _ */
public static final int HID_USAGE_KEYBOARD_EQUALSIGN = 0x2E; /* = or + */
public static final int HID_USAGE_KEYBOARD_OPENBRACKET = 0x2F; /* [ or { */
public static final int HID_USAGE_KEYBOARD_CLOSEBRACKET = 0x30; /* ] or } */
public static final int HID_USAGE_KEYBOARD_BACKSLASH = 0x31; /* \ or | */
public static final int HID_USAGE_KEYBOARD_NONUSPOUNT = 0x32; /* Non-US # or _ */
public static final int HID_USAGE_KEYBOARD_SEMICOLON = 0x33; /* ; or : */
public static final int HID_USAGE_KEYBOARD_QUOTE = 0x34; /* ' or " */
public static final int HID_USAGE_KEYBOARD_TILDE = 0x35; /* Grave Accent and Tilde */
public static final int HID_USAGE_KEYBOARD_COMMA = 0x36; /* , or < */
public static final int HID_USAGE_KEYBOARD_PERIOD = 0x37; /* . or > */
public static final int HID_USAGE_KEYBOARD_SLASH = 0x38; /* / or ? */
public static final int HID_USAGE_KEYBOARD_CAPSLOCK = 0x39; /* Caps Lock */
public static final int HID_USAGE_KEYBOARD_F1 = 0x3A; /* F1 */
public static final int HID_USAGE_KEYBOARD_F2 = 0x3B; /* F2 */
public static final int HID_USAGE_KEYBOARD_F3 = 0x3C; /* F3 */
public static final int HID_USAGE_KEYBOARD_F4 = 0x3D; /* F4 */
public static final int HID_USAGE_KEYBOARD_F5 = 0x3E; /* F5 */
public static final int HID_USAGE_KEYBOARD_F6 = 0x3F; /* F6 */
public static final int HID_USAGE_KEYBOARD_F7 = 0x40; /* F7 */
public static final int HID_USAGE_KEYBOARD_F8 = 0x41; /* F8 */
public static final int HID_USAGE_KEYBOARD_F9 = 0x42; /* F9 */
public static final int HID_USAGE_KEYBOARD_F10 = 0x43; /* F10 */
public static final int HID_USAGE_KEYBOARD_F11 = 0x44; /* F11 */
public static final int HID_USAGE_KEYBOARD_F12 = 0x45; /* F12 */
public static final int HID_USAGE_KEYBOARD_PRINTSCREEN = 0x46; /* Print Screen */
public static final int HID_USAGE_KEYBOARD_SCROLLLOCK = 0x47; /* Scroll Lock */
public static final int HID_USAGE_KEYBOARD_PAUSE = 0x48; /* Pause */
public static final int HID_USAGE_KEYBOARD_INSERT = 0x49; /* Insert */
public static final int HID_USAGE_KEYBOARD_HOME = 0x4A; /* Home */
public static final int HID_USAGE_KEYBOARD_PAGEUP = 0x4B; /* Page Up */
public static final int HID_USAGE_KEYBOARD_DELETE = 0x4C; /* Delete Forward */
public static final int HID_USAGE_KEYBOARD_END = 0x4D; /* End */
public static final int HID_USAGE_KEYBOARD_PAGEDOWN = 0x4E; /* Page Down */
public static final int HID_USAGE_KEYBOARD_RIGHTARROW = 0x4F; /* Right Arrow */
public static final int HID_USAGE_KEYBOARD_LEFTARROW = 0x50; /* Left Arrow */
public static final int HID_USAGE_KEYBOARD_DOWNARROW = 0x51; /* Down Arrow */
public static final int HID_USAGE_KEYBOARD_UPARROW = 0x52; /* Up Arrow */
public static final int HID_USAGE_KEYPAD_NUMLOCK = 0x53; /* Keypad NumLock or Clear */
public static final int HID_USAGE_KEYPAD_SLASH = 0x54; /* Keypad / */
public static final int HID_USAGE_KEYPAD_ASTERICK = 0x55; /* Keypad * */
public static final int HID_USAGE_KEYPAD_HYPHEN = 0x56; /* Keypad - */
public static final int HID_USAGE_KEYPAD_PLUS = 0x57; /* Keypad + */
public static final int HID_USAGE_KEYPAD_ENTER = 0x58; /* Keypad Enter */
public static final int HID_USAGE_KEYPAD_1 = 0x59; /* Keypad 1 or End */
public static final int HID_USAGE_KEYPAD_2 = 0x5A; /* Keypad 2 or Down Arrow */
public static final int HID_USAGE_KEYPAD_3 = 0x5B; /* Keypad 3 or Page Down */
public static final int HID_USAGE_KEYPAD_4 = 0x5C; /* Keypad 4 or Left Arrow */
public static final int HID_USAGE_KEYPAD_5 = 0x5D; /* Keypad 5 */
public static final int HID_USAGE_KEYPAD_6 = 0x5E; /* Keypad 6 or Right Arrow */
public static final int HID_USAGE_KEYPAD_7 = 0x5F; /* Keypad 7 or Home */
public static final int HID_USAGE_KEYPAD_8 = 0x60; /* Keypad 8 or Up Arrow */
public static final int HID_USAGE_KEYPAD_9 = 0x61; /* Keypad 9 or Page Up */
public static final int HID_USAGE_KEYPAD_0 = 0x62; /* Keypad 0 or Insert */
public static final int HID_USAGE_KEYPAD_PERIOD = 0x63; /* Keypad . or Delete */
public static final int HID_USAGE_KEYBOARD_NONUSBACKSLASH = 0x64; /* Non-US \ or | */
public static final int HID_USAGE_KEYBOARD_APPLICATION = 0x65; /* Application */
public static final int HID_USAGE_KEYBOARD_POWER = 0x66; /* Power */
public static final int HID_USAGE_KEYPAD_EQUALSIGN = 0x67; /* Keypad = */
public static final int HID_USAGE_KEYBOARD_F13 = 0x68; /* F13 */
public static final int HID_USAGE_KEYBOARD_F14 = 0x69; /* F14 */
public static final int HID_USAGE_KEYBOARD_F15 = 0x6A; /* F15 */
public static final int HID_USAGE_KEYBOARD_F16 = 0x6B; /* F16 */
public static final int HID_USAGE_KEYBOARD_F17 = 0x6C; /* F17 */
public static final int HID_USAGE_KEYBOARD_F18 = 0x6D; /* F18 */
public static final int HID_USAGE_KEYBOARD_F19 = 0x6E; /* F19 */
public static final int HID_USAGE_KEYBOARD_F20 = 0x6F; /* F20 */
public static final int HID_USAGE_KEYBOARD_F21 = 0x70; /* F21 */
public static final int HID_USAGE_KEYBOARD_F22 = 0x71; /* F22 */
public static final int HID_USAGE_KEYBOARD_F23 = 0x72; /* F23 */
public static final int HID_USAGE_KEYBOARD_F24 = 0x73; /* F24 */
public static final int HID_USAGE_KEYBOARD_EXECUTE = 0x74; /* Execute */
public static final int HID_USAGE_KEYBOARD_HELP = 0x75; /* Help */
public static final int HID_USAGE_KEYBOARD_MENU = 0x76; /* Menu */
public static final int HID_USAGE_KEYBOARD_SELECT = 0x77; /* Select */
public static final int HID_USAGE_KEYBOARD_STOP = 0x78; /* Stop */
public static final int HID_USAGE_KEYBOARD_AGAIN = 0x79; /* Again */
public static final int HID_USAGE_KEYBOARD_UNDO = 0x7A; /* Undo */
public static final int HID_USAGE_KEYBOARD_CUT = 0x7B; /* Cut */
public static final int HID_USAGE_KEYBOARD_COPY = 0x7C; /* Copy */
public static final int HID_USAGE_KEYBOARD_PASTE = 0x7D; /* Paste */
public static final int HID_USAGE_KEYBOARD_FIND = 0x7E; /* Find */
public static final int HID_USAGE_KEYBOARD_MUTE = 0x7F; /* Mute */
public static final int HID_USAGE_KEYBOARD_VOLUMEUP = 0x80; /* Volume Up */
public static final int HID_USAGE_KEYBOARD_VOLUMEDOWN = 0x81; /* Volume Down */
public static final int HID_USAGE_KEYBOARD_LOCKINGCAPSLOCK = 0x82; /* Locking Caps Lock */
public static final int HID_USAGE_KEYBOARD_LOCKINGNUMLOCK = 0x83; /* Locking Num Lock */
public static final int HID_USAGE_KEYBOARD_LOCKINGSCROLLLOCK = 0x84; /* Locking Scroll Lock */
public static final int HID_USAGE_KEYPAD_COMMA = 0x85; /* Keypad Comma */
public static final int HID_USAGE_KEYPAD_EQUALSSIGNAS400 = 0x86; /* Keypad Equal Sign for AS/400 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL1 = 0x87; /* International1 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL2 = 0x88; /* International2 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL3 = 0x89; /* International3 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL4 = 0x8A; /* International4 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL5 = 0x8B; /* International5 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL6 = 0x8C; /* International6 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL7 = 0x8D; /* International7 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL8 = 0x8E; /* International8 */
public static final int HID_USAGE_KEYBOARD_INTERNATIONAL9 = 0x8F; /* International9 */
public static final int HID_USAGE_KEYBOARD_LANG1 = 0x90; /* LANG1 */
public static final int HID_USAGE_KEYBOARD_LANG2 = 0x91; /* LANG2 */
public static final int HID_USAGE_KEYBOARD_LANG3 = 0x92; /* LANG3 */
public static final int HID_USAGE_KEYBOARD_LANG4 = 0x93; /* LANG4 */
public static final int HID_USAGE_KEYBOARD_LANG5 = 0x94; /* LANG5 */
public static final int HID_USAGE_KEYBOARD_LANG6 = 0x95; /* LANG6 */
public static final int HID_USAGE_KEYBOARD_LANG7 = 0x96; /* LANG7 */
public static final int HID_USAGE_KEYBOARD_LANG8 = 0x97; /* LANG8 */
public static final int HID_USAGE_KEYBOARD_LANG9 = 0x98; /* LANG9 */
public static final int HID_USAGE_KEYBOARD_ALTERNATEERASE = 0x99; /* AlternateErase */
public static final int HID_USAGE_KEYBOARD_SYSREQORATTENTION = 0x9A; /* SysReq/Attention */
public static final int HID_USAGE_KEYBOARD_CANCEL = 0x9B; /* Cancel */
public static final int HID_USAGE_KEYBOARD_CLEAR = 0x9C; /* Clear */
public static final int HID_USAGE_KEYBOARD_PRIOR = 0x9D; /* Prior */
public static final int HID_USAGE_KEYBOARD_RETURN = 0x9E; /* Return */
public static final int HID_USAGE_KEYBOARD_SEPARATOR = 0x9F; /* Separator */
public static final int HID_USAGE_KEYBOARD_OUT = 0xA0; /* Out */
public static final int HID_USAGE_KEYBOARD_OPER = 0xA1; /* Oper */
public static final int HID_USAGE_KEYBOARD_CLEARORAGAIN = 0xA2; /* Clear/Again */
public static final int HID_USAGE_KEYBOARD_CRSELORPROPS = 0xA3; /* CrSel/Props */
public static final int HID_USAGE_KEYBOARD_EXSEL = 0xA4; /* ExSel */
/* 0xA5-0xDF Reserved */
public static final int HID_USAGE_KEYBOARD_LEFTCONTROL = 0xE0; /* Left Control */
public static final int HID_USAGE_KEYBOARD_LEFTSHIFT = 0xE1; /* Left Shift */
public static final int HID_USAGE_KEYBOARD_LEFTALT = 0xE2; /* Left Alt */
public static final int HID_USAGE_KEYBOARD_LEFTGUI = 0xE3; /* Left GUI */
public static final int HID_USAGE_KEYBOARD_RIGHTCONTROL = 0xE4; /* Right Control */
public static final int HID_USAGE_KEYBOARD_RIGHTSHIFT = 0xE5; /* Right Shift */
public static final int HID_USAGE_KEYBOARD_RIGHTALT = 0xE6; /* Right Alt */
public static final int HID_USAGE_KEYBOARD_RIGHTGUI = 0xE7; /* Right GUI */
/* 0xE8-0xFFFF Reserved */
public static final int HID_USAGE_KEYBOARD__RESERVED = 0xFFFF;
public static final int HID_USAGEPAGE_UNDEFINED = 0x00;
public static final int HID_USAGEPAGE_GENERICDESKTOP = 0x01;
public static final int HID_USAGEPAGE_SIMULATION = 0x02;
public static final int HID_USAGEPAGE_VR = 0x03;
public static final int HID_USAGEPAGE_SPORT = 0x04;
public static final int HID_USAGEPAGE_GAME = 0x05;
public static final int HID_USAGEPAGE_KEYBOARD = 0x07; /* USB Device Class Definition for Human Interface Devices (HID). Note: the usage type for all key codes is Selector (Sel). */
public static final int HID_USAGEPAGE_LED = 0x08;
public static final int HID_USAGEPAGE_BUTTON = 0x09;
public static final int HID_USAGEPAGE_ORDINAL = 0x0A;
public static final int HID_USAGEPAGE_TELEPHONY = 0x0B;
public static final int HID_USAGEPAGE_CONSUMER = 0x0C;
public static final int HID_USAGEPAGE_DIGITIZER = 0x0D;
public static final int HID_USAGEPAGE_PID = 0x0F; /* USB Physical Interface Device definitions for force feedback and related devices. */
public static final int HID_USAGEPAGE_UNICODE = 0x10;
public static final int HID_USAGEPAGE_ALPHANUMERIC_DISPLAY = 0x14;
public static final int HID_USAGEPAGE_POWERDEVICE = 0x84; /* Power Device Page */
public static final int HID_USAGEPAGE_BATTERY_SYSTEM = 0x85; /* Battery System Page */
public static final int HID_USAGEPAGE_BARCODE_SCANNER = 0x8C; /* (Point of Sale) USB Device Class Definition for Bar Code Scanner Devices */
public static final int HID_USAGEPAGE_SCALE = 0x8D; /* (Point of Sale) USB Device Class Definition for Scale Devices */
public static final int HID_USAGEPAGE_CAMERA_CONTROL = 0x90; /* USB Device Class Definition for Image Class Devices */
public static final int HID_USAGEPAGE_ARCADE = 0x91; /* OAAF Definitions for arcade and coinop related Devices */
public static final int HID_USAGEPAGE_VENDOR_DEFINED_START = 0xFF00;
public static final int HID_ELEMENTTYPE_INPUT_MISC = 1;
public static final int HID_ELEMENTTYPE_INPUT_BUTTON = 2;
public static final int HID_ELEMENTTYPE_INPUT_AXIS = 3;
public static final int HID_ELEMENTTYPE_INPUT_SCANCODES = 4;
public static final int HID_ELEMENTTYPE_OUTPUT = 129;
public static final int HID_ELEMENTTYPE_FEATURE = 257;
public static final int HID_ELEMENTTYPE_COLLECTION = 513;
static
{
System.loadLibrary("jinput");
}
public native void hidCreate();
public native void hidDispose();
public native void enumDevices();
/**
* Opens an input device and returns the address of the input queue for that device
*/
public native long openDevice( long lpDevice, int queueDepth );
public native void closeDevice( long lpDevice, long lpQueue );
/**
* Polls a device and returns the element top most on the input queue. The elements that
* are returned are only those that have had their hidCookies registered with registerDeviceElement.
* @param lpQueue
* @return
*/
public native int pollDevice( long lpQueue );
public native int pollElement( long lpDevice, long hidCookie );
public native void registerDeviceElement( long lpQueue, long hidCookie );
public native void deregisterDeviceElement( long lpQueue, long hidCookie );
private HashMap devices = new HashMap();
public OSXEnvironmentPlugin()
{
System.out.println("net.java.games.input.OSXEnvironmentPlugin instance created");
System.out.println("Creating HID engine");
hidCreate();
System.out.println("Enumerating devices");
enumDevices();
}
public void finalize()
{
System.out.println("Disposing HID engine");
hidDispose();
}
public Controller[] getControllers()
{
return (Controller[])(devices.values().toArray( new Controller[0]));
}
public Controller createController( long lpDevice, String productName, int usage )
{
switch (usage)
{
case (HID_DEVICE_MOUSE):
System.out.println("Found mouse [" + productName + "] device address [" + lpDevice + "]");
return new OSXMouse( this, lpDevice, productName );
case (HID_DEVICE_JOYSTICK):
System.out.println("Found joystick [" + productName + "] device address [" + lpDevice + "]");
return new OSXJoystick( this, lpDevice, productName );
case (HID_DEVICE_GAMEPAD):
System.out.println("Found gamepad [" + productName + "] device address [" + lpDevice + "]");
return new OSXGamepad( this, lpDevice, productName );
case (HID_DEVICE_KEYBOARD):
System.out.println("Found keyboard [" + productName + "] device address [" + lpDevice + "]");
return new OSXKeyboard( this, lpDevice, productName );
default:
System.out.println("Found device of unknown or unsupported type. Usage[" + usage + "], ProductName[" + productName + "] - ignoring");
return null;
}
}
/**
* Add a controller to the device list
* @param lpDevice
* @param productName
* @param usage
*/
private void addController( long lpDevice, String productName, int usage )
{
Controller controller = null;
controller = createController( lpDevice, productName, usage );
if ( controller != null )
{
devices.put( new Long(lpDevice), controller );
}
}
/**
* Adds an InputControllerElement to a device. This method is invoked from native code.
* @param lpDevice
* @param elementCookie
* @param elementType
* @param usage
* @param usagePage
* @param rawMin
* @param rawMax
* @param scaledMin
* @param scaledMax
* @param dataBitSize
* @param isRelative
* @param isWrapping
* @param isNonLinear
* @param hasPreferredState
* @param hasNullState
*/
private void addControllerElement( long lpDevice,
long elementCookie,
int elementType,
int usage,
int usagePage,
int rawMin,
int rawMax,
int scaledMin,
int scaledMax,
int dataBitSize,
boolean isRelative,
boolean isWrapping,
boolean isNonLinear,
boolean hasPreferredState,
boolean hasNullState)
{
InputControllerElement element = new InputControllerElement( elementCookie, elementType, usage, usagePage,
rawMin, rawMax, scaledMin, scaledMax,
dataBitSize, isRelative, isWrapping, isNonLinear,
hasPreferredState, hasNullState );
InputController inputController = (InputController)devices.get( new Long( lpDevice) );
if ( inputController != null )
{
inputController.addControllerElement( element );
}
}
public void testDevice( long lpDevice )
{
System.out.println("Opening device ");
long lpQueue = openDevice( lpDevice, 32 );
for ( int i = 0; i < 50; i++ )
{
try
{
pollDevice( lpQueue );
Thread.sleep(10);
}
catch( Exception e )
{
System.out.println("Interrupted" + e );
}
}
System.out.println("Closing device");
closeDevice( lpDevice, lpQueue );
}
public static void main (String args[])
{
System.out.println("Started net.java.games.input.OSXEnvironmentPlugin");
OSXEnvironmentPlugin newjni = new OSXEnvironmentPlugin();
//newjni.hidCreate();
//newjni.enumDevices();
Controller[] controllers = newjni.getControllers();
for ( int i = 0; i < controllers.length; i++ )
{
System.out.println("Controller [" + controllers[i].getName() +"] enumerated...");
}
//newjni.hidDispose();
System.out.println("Done");
}
}

82
plugins/OSX/src/java/net/java/games/input/OSXGamepad.java
View file

@ -1,82 +0,0 @@
package net.java.games.input;
/**
* Created by IntelliJ IDEA.
* User: gpierce
* Date: Aug 2, 2003
* Time: 3:59:09 PM
* To change this template use Options | File Templates.
*/
public class OSXGamepad extends AbstractController implements InputController
{
private OSXEnvironmentPlugin plugin;
private long lpDevice;
private long lpQueue;
public OSXGamepad( OSXEnvironmentPlugin plugin, long lpDevice, String productName )
{
super( productName );
this.plugin = plugin;
this.lpDevice = lpDevice;
openDevice();
}
public boolean poll()
{
plugin.pollDevice( lpQueue );
return true;
}
public void openDevice()
{
this.lpQueue = plugin.openDevice( this.lpDevice, 32 );
}
public void closeDevice()
{
plugin.closeDevice( this.lpDevice, this.lpQueue );
}
public void pollDevice()
{
plugin.pollDevice( this.lpQueue );
}
public void addControllerElement(InputControllerElement element)
{
switch ( element.getElementType() )
{
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_MISC:
System.out.println("*Adding misc component");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_BUTTON:
System.out.println("*Adding button");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_AXIS:
System.out.println("*Adding axis");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_SCANCODES:
System.out.println("*Adding scancode");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_OUTPUT:
System.out.println("*Adding forcefeedback");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_FEATURE:
System.out.println("*Adding feature");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_COLLECTION:
System.out.println("*Adding collection");
break;
}
}
}

83
plugins/OSX/src/java/net/java/games/input/OSXJoystick.java
View file

@ -1,83 +0,0 @@
package net.java.games.input;
/**
* Created by IntelliJ IDEA.
* User: gpierce
* Date: Aug 2, 2003
* Time: 3:58:45 PM
* To change this template use Options | File Templates.
*/
public class OSXJoystick extends AbstractController implements InputController
{
private OSXEnvironmentPlugin plugin;
private long lpDevice;
private long lpQueue;
public OSXJoystick( OSXEnvironmentPlugin plugin, long lpDevice, String productName )
{
super( productName );
this.plugin = plugin;
this.lpDevice = lpDevice;
openDevice();
}
public boolean poll()
{
plugin.pollDevice( lpQueue );
return true;
}
public void openDevice()
{
this.lpQueue = plugin.openDevice( this.lpDevice, 32 );
}
public void closeDevice()
{
plugin.closeDevice( this.lpDevice, this.lpQueue );
}
public void pollDevice()
{
plugin.pollDevice( this.lpQueue );
}
public void addControllerElement(InputControllerElement element)
{
switch ( element.getElementType() )
{
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_MISC:
System.out.println("*Adding misc component");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_BUTTON:
System.out.println("*Adding button");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_AXIS:
System.out.println("*Adding axis");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_SCANCODES:
System.out.println("*Adding scancode");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_OUTPUT:
System.out.println("*Adding forcefeedback");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_FEATURE:
System.out.println("*Adding feature");
break;
case OSXEnvironmentPlugin.HID_ELEMENTTYPE_COLLECTION:
System.out.println("*Adding collection");
break;
}
}
}

253
plugins/OSX/src/java/net/java/games/input/OSXKeyboard.java
View file

@ -1,253 +0,0 @@
package net.java.games.input;
import java.util.HashMap;
/**
* Created by IntelliJ IDEA.
* User: gpierce
* Date: Aug 2, 2003
* Time: 3:57:58 PM
* To change this template use Options | File Templates.
*/
public class OSXKeyboard extends StandardKeyboard implements InputController
{
private final static int[] CROSSTABLE = {
0x00, // VOID
0x29, // ESCAPE
0x1E, // _1
0x1F, // _2
0x20, // _3
0x21, // _4
0x22, // _5
0x23, // _6
0x24, // _7
0x25, // _8
0x26, // _9
0x27, // _0
0x2D, // MINUS
0x2E, // EQUALS
0x2A, // BACK
0x2B, // TAB
0x14, // Q
0x1A, // W
0x08, // E
0x15, // R
0x17, // T
0x1C, // Y
0x18, // U
0x0C, // I
0x12, // O
0x13, // P
0x2F, // [
0x30, // ]
0x28, // RETURN
0xE0, // LEFT CONTROL
0x04, // A
0x16, // S
0x07, // D
0x09, // F
0x0A, // G
0x0B, // H
0x0D, // J
0x0E, // K
0x0F, // L
0x33, // ;
0x34, // '
0x35, // ~
0xE1, // /
0x31, // BACKSLASH (\)
0x1D, // Z
0x1B, // X
0x06, // C
0x19, // V
0x05, // B
0x11, // N
0x10, // M
0x36, // ,
0x37, // .
0x38, // SLASH (/)
0xE5, // RSHIFT
0x55, // MULT (*)
0xE2, // LEFT ALT
0x2C, // SPACE
0x39, // CAPSLOCK
0x3A, // F1
0x3B, // F2
0x3C, // F3
0x3D, // F4
0x3E, // F5
0x3F, // F6
0x40, // F7
0x41, // F8
0x42, // F9
0x43, // F10
0x53, // NUMLOCK
0x47, // SCROLLLOCK
0x5F, // NUMPAD7
0x60, // NUMPAD8
0x61, // NUMPAD9
0x56, // SUBTRACT (KEYPAD -)
0x5C, // NUMPAD4
0x5D, // NUMPAD5
0x5E, // NUMPAD6
0x57, // ADD (KEYPAD +)
0x59, // NUMPAD1
0x5A, // NUMPAD2
0x5B, // NUMPAD3
0x62, // NUMPAD0
0x63, // DECIMAL (KEYPAD .)
0x44, // F11
0x45, // F12
0x68, // F13
0x69, // F14
0x6A, // F15
0x87, // KANA
0x88, // CONVERT
0x89, // NONCONVERT
0x8A, // YEN
0x67, // NUMPAD=
0x8B, // CIRCUMFLEX
0x8C, // AT
0x8D, // COLON
0x9F, // UNDERLINE
0x8E, // KANJI
0x78, // STOP
0x8F, // AX
0x90, // UNLABELED
0x58, // NUMPAD ENTER
0xE4, // RIGHT CONTROL
0x85, // NUMPAD COMMA
0x54, // DIVIDE ( NUMPAD /)
0x9A, // SYSREQ
0xE6, // RIGHT ALT
0x48, // PAUSE
0x4A, // HOME
0x52, // UP
0x9D, // PRIOR
0x50, // LEFT
0x4F, // RIGHT
0x4D, // END
0x51, // DOWN
0xA2, // NEXT
0x49, // INSERT
0x4C, // DELETE
0xE3, // LEFT WIN
0xE7, // RIGHT WIN
0x65, // APPS
0x66, // POWER
0x66 // SLEEP
};
private OSXEnvironmentPlugin plugin;
private long lpDevice;
private long lpQueue;
private HashMap keys = new HashMap();
private static int[] COOKIETABLE = new int[CROSSTABLE.length ];
public OSXKeyboard( OSXEnvironmentPlugin plugin, long lpDevice, String productName )
{
super( productName );
this.plugin = plugin;
this.lpDevice = lpDevice;
openDevice();
}
public void openDevice()
{
this.lpQueue = plugin.openDevice( this.lpDevice, 256 );
}
public void closeDevice()
{
plugin.closeDevice( this.lpDevice, this.lpQueue );
}
public void addControllerElement(InputControllerElement element)
{
System.out.println("Adding keyboard elements usage page[" + element.getUsagePage() + "] usage [" + element.getUsage() + "] type [" + element.getElementType() + "]" );
switch( element.getUsagePage() )
{
case OSXEnvironmentPlugin.HID_USAGEPAGE_KEYBOARD:
System.out.println("Found keyboard element");
if ( element.getElementType() == OSXEnvironmentPlugin.HID_ELEMENTTYPE_INPUT_BUTTON )
{
// register this key with the queue system as all buttons are retrieved from the
// input controllers queue
//
System.out.println("Registering button-key (usage page [" + element.getUsagePage() + "], usage[" + element.getUsage() + "], elementType [" + element.getElementType() + "], hidCookie [" + element.getHidCookie() + "])");
if ( keys.get( new Long( element.getUsage() )) == null )
{
plugin.registerDeviceElement( lpQueue, element.getHidCookie() );
keys.put( new Long( element.getUsage() ), element );
System.out.println("Registered key [" + element.getHidCookie() + "]");
}
else
{
System.out.println("Ignoring key [" + element.getHidCookie() + "] already enumerated.");
}
}
else
{
System.out.println("Ignoring non-button-key (usage page [" + element.getUsagePage() + "], usage[" + element.getUsage() + "], elementType [" + element.getElementType() + "], hidCookie [" + element.getHidCookie() + "])");
}
break;
default:
}
}
public boolean poll()
{
plugin.pollDevice( lpQueue );
return true;
}
/** Returns whether or not the given key has been pressed since the last
* call to poll.
* @param key The key whose state to check.
* @return true if this key has changed state since last read of its state, false otherwise.
*/
protected boolean isKeyPressed(Keyboard.Key key)
{
KeyID id = (KeyID)key.getIdentifier();
int keyIndex = id.getKeyIndex();
// get that key code out of the crosstable and find the proper InputControllerElement/button for that key
//
//TODO: Optimize this - put the usages in another array the same size as the crosstable so the hidCookies
// can be retrieved directly without the Long creation
int usage = CROSSTABLE[keyIndex];
InputControllerElement element = (InputControllerElement) keys.get( new Long(usage) );
if ( element != null )
{
int value = plugin.pollElement( lpDevice, element.getHidCookie() );
System.out.println("Key Poll result [" + value + "]");
if ( value == 1 )
{
return true;
}
else
{
return false;
}
}
return false;
}
}

251
plugins/OSX/src/java/net/java/games/input/OSXMouse.java
View file

@ -1,251 +0,0 @@
package net.java.games.input;
/**
* Created by IntelliJ IDEA.
* User: gpierce
* Date: Aug 2, 2003
* Time: 3:57:00 PM
* To change this template use Options | File Templates.
*/
public class OSXMouse extends Mouse implements InputController
{
private OSXEnvironmentPlugin plugin;
private long lpDevice;
private long lpQueue;
private int buttonCount = 0;
public OSXMouse( OSXEnvironmentPlugin plugin, long lpDevice, String productName )
{
super( productName );
this.plugin = plugin;
this.lpDevice = lpDevice;
openDevice();
buttons = new ButtonsImpl();
ball = new BallImpl();
}
public void openDevice()
{
this.lpQueue = plugin.openDevice( this.lpDevice, 32 );
}
public void closeDevice()
{
plugin.closeDevice( this.lpDevice, this.lpQueue );
}
public boolean poll()
{
plugin.pollDevice( this.lpQueue );
return true;
}
public void addControllerElement(InputControllerElement element)
{
switch ( element.getUsagePage() )
{
case OSXEnvironmentPlugin.HID_USAGEPAGE_BUTTON:
buttonCount ++;
System.out.println("Adding button [" + buttonCount + "]");
((ButtonsImpl)buttons).addButton(element);
break;
case OSXEnvironmentPlugin.HID_USAGEPAGE_GENERICDESKTOP:
switch( element.getUsage() )
{
case OSXEnvironmentPlugin.HID_USAGE_POINTER:
System.out.println("Adding pointer - this will contain axis");
break;
case OSXEnvironmentPlugin.HID_USAGE_XAXIS:
((BallImpl)ball).addXAxis(element);
System.out.println("Adding X Axis") ;
break;
case OSXEnvironmentPlugin.HID_USAGE_YAXIS:
((BallImpl)ball).addYAxis(element);
System.out.println("Adding Y Axis");
break;
case OSXEnvironmentPlugin.HID_USAGE_WHEEL:
((BallImpl)ball).addWheelAxis(element);
System.out.println("Adding wheel");
break;
default:
}
break;
default:
}
}
/**
* Implementation class representing the mouse ball
*/
class BallImpl extends Ball
{
/**
* Public constructor
*/
public BallImpl()
{
super(OSXMouse.this.getName() + " ball");
}
public void addXAxis( InputControllerElement element )
{
x = new BallAxis( Axis.Identifier.X, element );
}
public void addYAxis( InputControllerElement element )
{
y = new BallAxis( Axis.Identifier.Y, element );
}
public void addWheelAxis( InputControllerElement element )
{
wheel = new BallAxis( Axis.Identifier.SLIDER, element );
}
}
/**
* Implementation class representing the mouse buttons
*/
class ButtonsImpl extends Buttons
{
/**
* Public constructor
*/
public ButtonsImpl()
{
super(OSXMouse.this.getName() + " buttons");
}
public void addButton( InputControllerElement element )
{
if ( left == null )
{
left = new ButtonImpl( ButtonID.LEFT, element );
}
else if ( right == null )
{
right = new ButtonImpl( ButtonID.RIGHT, element );
}
else if ( middle == null )
{
middle = new ButtonImpl( ButtonID.MIDDLE, element );
}
}
}
/**
* Mouse button axis implementation
*/
class ButtonImpl extends Button
{
private long hidCookie;
private boolean isRelative;
/** Public constructor
* @param id An ID of a button to create an obejct to represent.
*
*/
public ButtonImpl(ButtonID id, InputControllerElement element)
{
super(id.getName(), id);
this.hidCookie = element.getHidCookie();
this.isRelative = element.isRelative();
}
/** 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 state of controller. (Note: DX8 mice actually
* queue state so what is returned is the next state,
* not necessarily the most current one.)
*/
public float getPollData()
{
return (float) plugin.pollElement( lpDevice, hidCookie );
}
/** 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 true if data is relative, otherwise false.
*/
public boolean isRelative()
{
return isRelative;
}
}
/**
* Mouse ball axis implementation
*/
class BallAxis extends AbstractAxis
{
private long hidCookie;
private boolean isRelative;
/** Public constructor
* @param id An ID for a mouse axis to create an object to represent.
*/
public BallAxis(Identifier id, InputControllerElement element)
{
super(id.getName(), id);
this.hidCookie = element.getHidCookie();
this.isRelative = element.isRelative();
}
/** 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 data. (Note that mice queue state in DX8 so what
* is returned is the next stae in the queue, not
* necessarily the most current one.)
*/
public float getPollData()
{
return (float) plugin.pollElement( lpDevice, hidCookie );
}
/** 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 true if relative, otherwise false.
*/
public boolean isRelative()
{
return isRelative;
}
/** Returns whether or not the axis is analog, or false if it is digital.
* @return true if analog, false if digital
*/
public boolean isAnalog()
{
return true;
}
}
}

23
plugins/OSX/src/native/build.xml
View file

@ -1,23 +0,0 @@
<?xml version="1.0" ?>
<project name="OS X Plugin, Native code" basedir="." default="compileNativeJinputLib">
<description>OSX JInput Native Plugin</description>
<property name="src" location="src" />
<property name="build" location="classes" />
<property name="dist" location="../../dist" />
<property name="plugins" location="plugins" />
<target name="init">
<mkdir dir="build"/>
</target>
<target name="compileNativeJinputLib" depends="init">
<exec dir="." executable="cc" os="Mac OS X">
<arg line="-c -I${java.home}/include jinputjnilib.c"/>
</exec>
<exec dir="." executable="cc" os="Mac OS X">
<arg line="-bundle -o libjinput.jnilib jinputjnilib.o -framework JavaVM -framework CoreFoundation -framework IOKit "/>
</exec>
</target>
</project>

839
plugins/OSX/src/native/jinputjnilib.c
View file

@ -1,839 +0,0 @@
/*
* %W% %E%
*
* Copyright 2002 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
/*****************************************************************************
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materails provided with the distribution.
*
* Neither the name Sun Microsystems, Inc. or the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for us in
* the design, construction, operation or maintenance of any nuclear facility
*
*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/errno.h>
#include <sysexits.h>
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOCFPlugIn.h>
#include <IOKit/hid/IOHIDLib.h>
#include <IOKit/hid/IOHIDKeys.h>
#include <CoreFoundation/CoreFoundation.h>
#include <Carbon/Carbon.h>
#include "net_java_games_input_OSXEnvironmentPlugin.h"
Boolean init( JNIEnv * env );
void createMasterPort();
void disposeMasterPort();
void createHIDDevice(io_object_t hidDevice, IOHIDDeviceInterface ***hidDeviceInterface);
IOReturn openDevice(IOHIDDeviceInterface ***hidDeviceInterface);
IOReturn closeDevice(IOHIDDeviceInterface ***hidDeviceInterface);
Boolean showDictionaryElement (CFDictionaryRef dictionary, CFStringRef key);
void showProperty(const void * key, const void * value);
void displayCFProperty(CFStringRef object, CFTypeRef value);
void CFObjectShow( CFTypeRef value );
void CFObjectSend( CFTypeRef value );
jclass CLASS_JNIWrapper = NULL;
jmethodID MID_AddController = NULL;
jmethodID MID_AddControllerElement = NULL;
mach_port_t masterPort = NULL;
io_iterator_t hidObjectIterator;
long elementCookie;
long elementType;
long usage;
long usagePage;
long min;
long max;
long scaledMin;
long scaledMax;
long size;
jboolean isRelative;
jboolean isWrapping;
jboolean isNonLinear;
JNIEnv * lpEnv;
jlong lpDevice;
jobject lpObj;
jboolean completeElement = JNI_FALSE;
Boolean showDictionaryElement (CFDictionaryRef dictionary, CFStringRef key)
{
CFTypeRef value = CFDictionaryGetValue (dictionary, key);
if (value)
{
const char * c = CFStringGetCStringPtr (key, CFStringGetSystemEncoding ());
if (c)
{
printf ("%s", c);
}
else
{
CFIndex bufferSize = CFStringGetLength (key) + 1;
char * buffer = (char *)malloc (bufferSize);
if (buffer)
{
if (CFStringGetCString (key, buffer, bufferSize, CFStringGetSystemEncoding ()))
printf ("%s", buffer);
free(buffer);
}
}
printf("=");
CFObjectShow( value );
printf("\n");
}
return (value != NULL);
}
static void showCFArray (const void * value, void * parameter)
{
if (CFGetTypeID (value) != CFDictionaryGetTypeID ())
{
return;
}
CFObjectShow(value);
}
void CFObjectShow( CFTypeRef value )
{
CFTypeID type = CFGetTypeID(value);
if (type == CFArrayGetTypeID())
{
CFRange range = {0, CFArrayGetCount (value)};
//Show an element array containing one or more element dictionaries
CFArrayApplyFunction (value, range, showCFArray, 0);
}
else if (type == CFBooleanGetTypeID())
{
printf(CFBooleanGetValue(value) ? "true" : "false");
}
else if (type == CFDictionaryGetTypeID())
{
printf("Map\n");
showDictionaryElement (value, CFSTR(kIOHIDElementCookieKey));
showDictionaryElement (value, CFSTR(kIOHIDElementCollectionTypeKey));
showDictionaryElement (value, CFSTR(kIOHIDElementMinKey));
showDictionaryElement (value, CFSTR(kIOHIDElementMaxKey));
showDictionaryElement (value, CFSTR(kIOHIDElementScaledMinKey));
showDictionaryElement (value, CFSTR(kIOHIDElementScaledMaxKey));
showDictionaryElement (value, CFSTR(kIOHIDElementSizeKey));
showDictionaryElement (value, CFSTR(kIOHIDElementIsRelativeKey));
showDictionaryElement (value, CFSTR(kIOHIDElementIsWrappingKey));
showDictionaryElement (value, CFSTR(kIOHIDElementIsNonLinearKey));
#ifdef kIOHIDElementHasPreferredStateKey
showDictionaryElement (value, CFSTR(kIOHIDElementHasPreferredStateKey));
#else
showDictionaryElement (value, CFSTR(kIOHIDElementHasPreferedStateKey));
#endif
showDictionaryElement (value, CFSTR(kIOHIDElementHasNullStateKey));
showDictionaryElement (value, CFSTR(kIOHIDElementVendorSpecificKey));
showDictionaryElement (value, CFSTR(kIOHIDElementUnitKey));
showDictionaryElement (value, CFSTR(kIOHIDElementUnitExponentKey));
showDictionaryElement (value, CFSTR(kIOHIDElementNameKey));
showDictionaryElement (value, CFSTR(kIOHIDElementKey));
printf("\n\n\n");
}
else if (type == CFNumberGetTypeID())
{
long number;
if (CFNumberGetValue (value, kCFNumberLongType, &number))
{
printf("0x%lx (%ld)", number, number);
}
}
else if (type == CFStringGetTypeID())
{
const char * c = CFStringGetCStringPtr (value, CFStringGetSystemEncoding ());
if (c)
{
printf ("%s", c);
}
else
{
CFIndex bufferSize = CFStringGetLength (value) + 1;
char * buffer = (char *)malloc (bufferSize);
if (buffer)
{
if (CFStringGetCString (value, buffer, bufferSize, CFStringGetSystemEncoding ()))
{
printf ("%s", buffer);
}
free(buffer);
}
}
}
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
Boolean init(JNIEnv* env)
{
CLASS_JNIWrapper = (*env)->FindClass(env,"net/java/games/input/OSXEnvironmentPlugin");
if ( CLASS_JNIWrapper == NULL )
{
printf("Class OSXEnvironmentPlugin not found... \n");
return FALSE;
}
MID_AddController = (*env)->GetMethodID(env, CLASS_JNIWrapper, "addController", "(JLjava/lang/String;I)V");
if (MID_AddController == NULL)
{
printf("Method addController not found... \n");
return FALSE;
}
MID_AddControllerElement = (*env)->GetMethodID(env, CLASS_JNIWrapper, "addControllerElement", "(JJIIIIIIIIZZZZZ)V");
if (MID_AddControllerElement == NULL)
{
printf("Method addControllerElement not found... \n");
return FALSE;
}
return TRUE;
}
void createMasterPort()
{
IOReturn ioReturnValue = kIOReturnSuccess;
//Get a Mach port to initiate communication with I/O Kit.
//
ioReturnValue = IOMasterPort(bootstrap_port, &masterPort);
}
void disposeMasterPort()
{
//Free master port if we created one.
//
if (masterPort)
{
mach_port_deallocate(mach_task_self(), masterPort);
}
}
void createHIDDevice( io_object_t hidDevice, IOHIDDeviceInterface ***hidDeviceInterface )
{
io_name_t className;
IOCFPlugInInterface **plugInInterface = NULL;
HRESULT plugInResult = S_OK;
SInt32 score = 0;
IOReturn ioReturnValue = kIOReturnSuccess;
ioReturnValue = IOObjectGetClass(hidDevice, className);
if ( ioReturnValue != kIOReturnSuccess )
{
printf("Failed to get IOObject class name.");
}
printf("Found device type [%s]\n", className);
ioReturnValue = IOCreatePlugInInterfaceForService(hidDevice,
kIOHIDDeviceUserClientTypeID,
kIOCFPlugInInterfaceID,
&plugInInterface,
&score);
if (ioReturnValue == kIOReturnSuccess)
{
//Call a method of the intermediate plug-in to create the device
//interface
//
plugInResult = (*plugInInterface)->QueryInterface(plugInInterface,
CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
(LPVOID) hidDeviceInterface);
if ( plugInResult != S_OK )
{
printf("Couldn't create HID class device interface");
}
(*plugInInterface)->Release(plugInInterface);
}
}
IOReturn openDevice(IOHIDDeviceInterface ***hidDeviceInterface)
{
IOReturn ioReturnValue = kIOReturnSuccess;
//todo, change this to be controlled from the java layer at each device
//
ioReturnValue = (**hidDeviceInterface)->open(*hidDeviceInterface, 0 );
if ( ioReturnValue != kIOReturnSuccess )
{
printf("Unable to open device - return [%d]\n", ioReturnValue );
}
else
{
printf("Successfully opened device \n");
}
return ioReturnValue;
}
IOReturn closeDevice(IOHIDDeviceInterface ***hidDeviceInterface)
{
IOReturn ioReturnValue = kIOReturnSuccess;
ioReturnValue = (**hidDeviceInterface)->close(*hidDeviceInterface);
if ( ioReturnValue != kIOReturnSuccess )
{
printf("Unable to close device - return [%d]\n", ioReturnValue );
}
else
{
printf("Successfully closed device \n");
}
// release the device interface
//
(**hidDeviceInterface)->Release(*hidDeviceInterface);
return ioReturnValue;
}
static void sendCFArray(const void * value, void * parameter)
{
if (CFGetTypeID (value) != CFDictionaryGetTypeID ())
{
return;
}
CFObjectSend(value);
}
void CFObjectSend( CFTypeRef value )
{
CFTypeID type = CFGetTypeID(value);
if (type == CFArrayGetTypeID())
{
CFRange range = {0, CFArrayGetCount (value)};
//Show an element array containing one or more element dictionaries
CFArrayApplyFunction (value, range, sendCFArray, 0);
}
else if (type == CFDictionaryGetTypeID())
{
// printf("Sending Map\n");
CFTypeRef val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementCookieKey) );
if ( val )
{
CFNumberGetValue ( val , kCFNumberLongType, &elementCookie);
printf("ElementCookie - 0x%lx (%ld) \n", elementCookie, elementCookie);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementTypeKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &elementType);
printf("element Type - 0x%lx (%ld) \n", elementType, elementType);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementUsageKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &usage);
printf("usage - 0x%lx (%ld) \n", usage, usage);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementUsagePageKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &usagePage);
printf("usage page- 0x%lx (%ld) \n", usagePage, usagePage);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementMinKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &min);
//printf("min - 0x%lx (%ld) \n", min, min);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementMaxKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &max);
//printf("max - 0x%lx (%ld) \n", max, max);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementScaledMinKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &scaledMin);
//printf("scaledMin - 0x%lx (%ld) \n", scaledMin, scaledMin);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementScaledMaxKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &scaledMax);
//printf("scaledMax - 0x%lx (%ld) \n", scaledMax, scaledMax);
}
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementSizeKey) );
if ( val )
{
CFNumberGetValue ( val, kCFNumberLongType, &size);
//printf("Size - 0x%lx (%ld) \n", size, size);
}
jboolean isRelative = JNI_FALSE;
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementIsRelativeKey) );
if ( val )
{
isRelative = (CFBooleanGetValue(val) ? JNI_TRUE : JNI_FALSE);
}
jboolean isWrapping = JNI_FALSE;
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementIsWrappingKey) );
if ( val )
{
isWrapping = (CFBooleanGetValue(val) ? JNI_TRUE : JNI_FALSE);
}
jboolean isNonLinear = JNI_FALSE;
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementIsNonLinearKey) );
if ( val )
{
isNonLinear = (CFBooleanGetValue(val) ? JNI_TRUE : JNI_FALSE);
}
jboolean hasPreferredState = JNI_FALSE;
#ifdef kIOHIDElementHasPreferredStateKey
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementHasPreferredStateKey) );
if ( val )
{
hasPreferredState = (CFBooleanGetValue(val) ? JNI_TRUE : JNI_FALSE);
}
#else
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementHasPreferedStateKey) );
if ( val )
{
hasPreferredState = (CFBooleanGetValue(val) ? JNI_TRUE : JNI_FALSE);
}
#endif
jboolean hasNullState = JNI_FALSE;
val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementHasNullStateKey) );
if ( val )
{
hasNullState = (CFBooleanGetValue(val) ? JNI_TRUE : JNI_FALSE);
}
(*lpEnv)->CallVoidMethod(lpEnv, lpObj, MID_AddControllerElement,
(jlong)(long)lpDevice,
(jlong)(long)elementCookie,
(jint)(long)elementType,
(jint)(long)usage,
(jint)(long)usagePage,
(jint)(long)min,
(jint)(long)max,
(jint)(long)scaledMin,
(jint)(long)scaledMax,
(jint)(long)size,
(jboolean)isRelative,
(jboolean)isWrapping,
(jboolean)isNonLinear,
(jboolean)hasPreferredState,
(jboolean)hasNullState);
// printf("End of element definition \n");
CFTypeRef object = CFDictionaryGetValue (value, CFSTR(kIOHIDElementKey));
if (object)
{
CFObjectSend( object );
}
printf("\n\n\n");
}
}
void addControllerElements( CFMutableDictionaryRef dictionary, CFStringRef key )
{
printf("Adding controller elements\n");
CFTypeRef value = CFDictionaryGetValue (dictionary, key);
if (value)
{
CFRange range = {0, CFArrayGetCount (value)};
CFArrayApplyFunction (value, range, sendCFArray, 0);
}
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: hidCreate
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_hidCreate
(JNIEnv * env, jobject obj)
{
if ( init( env ) )
{
createMasterPort();
}
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: hidDispose
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_hidDispose
(JNIEnv * env, jobject obj)
{
disposeMasterPort();
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: enumDevices
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_enumDevices
(JNIEnv * env, jobject obj)
{
lpEnv = env;
lpObj = obj;
CFMutableDictionaryRef hidMatchDictionary = NULL;
IOReturn ioReturnValue = kIOReturnSuccess;
Boolean noMatchingDevices = false;
// Set up a matching dictionary to search the I/O Registry by class
// name for all HID class devices
//
hidMatchDictionary = IOServiceMatching(kIOHIDDeviceKey);
// Now search I/O Registry for matching devices.
//
ioReturnValue = IOServiceGetMatchingServices(masterPort, hidMatchDictionary, &hidObjectIterator);
noMatchingDevices = ((ioReturnValue != kIOReturnSuccess) | (hidObjectIterator == NULL));
// If search is unsuccessful, print message .
//
if (noMatchingDevices)
{
printf("No matching HID class devices found.");
return;
}
// IOServiceGetMatchingServices consumes a reference to the
// dictionary, so we don't need to release the dictionary ref.
//
hidMatchDictionary = NULL;
io_object_t hidDevice = NULL;
IOHIDDeviceInterface **hidDeviceInterface = NULL;
CFMutableDictionaryRef properties = 0;
char path[512];
kern_return_t result;
while ((hidDevice = IOIteratorNext(hidObjectIterator)))
{
result = IORegistryEntryGetPath(hidDevice, kIOServicePlane, path);
if ( result == KERN_SUCCESS )
{
result = IORegistryEntryCreateCFProperties(hidDevice,
&properties,
kCFAllocatorDefault,
kNilOptions);
}
if ((result == KERN_SUCCESS) && properties)
{
//showDictionaryElement(properties, CFSTR(kIOHIDTransportKey));
//showDictionaryElement(properties, CFSTR(kIOHIDVendorKey));
//printf("ProductID: "); showDictionaryElement(properties, CFSTR(kIOHIDProductIDKey));
//printf("VersionNumber: "); showDictionaryElement(properties, CFSTR(kIOHIDVersionNumberKey));
//printf("Manufacturer: "); showDictionaryElement(properties, CFSTR(kIOHIDManufacturerKey));
//printf("ProductKey: "); showDictionaryElement(properties, CFSTR(kIOHIDProductKey));
//printf("SerialNumber: "); showDictionaryElement(properties, CFSTR(kIOHIDSerialNumberKey));
//showDictionaryElement(properties, CFSTR(kIOHIDLocationIDKey));
//printf("PrimaryUsage: "); showDictionaryElement(properties, CFSTR(kIOHIDPrimaryUsageKey));
//showDictionaryElement(properties, CFSTR(kIOHIDPrimaryUsagePageKey));
//showDictionaryElement(properties, CFSTR(kIOHIDElementKey));
// get the product name
//
CFTypeRef productName = CFDictionaryGetValue (properties, CFSTR(kIOHIDProductKey));
// get the usage for this product
//
long usage;
CFNumberGetValue ( CFDictionaryGetValue( properties, CFSTR(kIOHIDPrimaryUsageKey) ), kCFNumberLongType, &usage);
createHIDDevice( hidDevice, &hidDeviceInterface );
IOObjectRelease( hidDevice );
if ( hidDeviceInterface != NULL )
{
(*env)->CallVoidMethod(env, obj, MID_AddController,
(jlong)(long)hidDeviceInterface,
(*env)->NewStringUTF( env, CFStringGetCStringPtr( productName, CFStringGetSystemEncoding()) ),
(jint)usage );
lpEnv = env;
lpDevice = (jlong)(long)hidDeviceInterface;
addControllerElements( properties, CFSTR(kIOHIDElementKey) );
}
//Release the properties dictionary
CFRelease(properties);
}
}
IOObjectRelease(hidObjectIterator);
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: openDevice
* Signature: (JI)J
*/
JNIEXPORT jlong JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_openDevice
(JNIEnv * env, jobject obj, jlong lpDevice, jint queueDepth)
{
IOHIDDeviceInterface **hidDeviceInterface = NULL;
hidDeviceInterface = (IOHIDDeviceInterface **) (long)lpDevice;
openDevice( &hidDeviceInterface );
IOHIDQueueInterface **queue = NULL;
queue = (*hidDeviceInterface)->allocQueue(hidDeviceInterface);
if (queue)
{
// create a queue and specify how deep they want the input queue to be
//
(*queue)->create( queue, 0, (int)queueDepth );
printf("InputQueue created %lx with depth %d \n", (long) queue, (int)queueDepth );
// start the input queue
//
(*queue)->start( queue );
}
else
{
printf("Unable to create queue for device! \n");
}
return (jlong)(long)queue;
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: closeDevice
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_closeDevice
(JNIEnv * env, jobject obj, jlong lpDevice, jlong lpQueue)
{
IOHIDDeviceInterface **hidDeviceInterface = NULL;
hidDeviceInterface = (IOHIDDeviceInterface **) (long)lpDevice;
IOHIDQueueInterface **queue = NULL;
queue = (IOHIDQueueInterface **)(long)lpQueue;
// stop the queue
//
(*queue)->stop(queue);
// dispose of the queue
//
(*queue)->dispose(queue);
// release the queue
//
(*queue)->Release(queue);
// close the input device
//
closeDevice( &hidDeviceInterface );
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: pollDevice
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_pollDevice
(JNIEnv * env, jobject obj, jlong lpQueue)
{
IOHIDEventStruct event;
IOHIDQueueInterface **queue = NULL;
queue = (IOHIDQueueInterface **)(long)lpQueue;
AbsoluteTime zeroTime = {0,0};
IOReturn ioReturnValue = kIOReturnSuccess;
ioReturnValue = (*queue)->getNextEvent(queue, &event, zeroTime, 0);
if ( ioReturnValue == kIOReturnSuccess )
{
printf("Queue getNextEvent return value: %ld\n", (long)ioReturnValue );
}
else
{
printf("Queue event[%lx] %ld\n", (unsigned long) event.elementCookie, event.value );
}
return (jint) event.value;
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: pollDevice
* Signature: (JJ)I
*/
JNIEXPORT jint JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_pollElement
(JNIEnv * env, jobject obj, jlong lpDevice, jlong hidCookie)
{
IOHIDDeviceInterface **hidDeviceInterface = NULL;
hidDeviceInterface = (IOHIDDeviceInterface **) (long)lpDevice;
IOHIDElementCookie cookie = (IOHIDElementCookie)(long)hidCookie;
IOHIDEventStruct event;
IOReturn ioReturnValue = kIOReturnSuccess;
ioReturnValue = (*hidDeviceInterface)->getElementValue(hidDeviceInterface, cookie, &event);
if ( ioReturnValue == kIOReturnSuccess )
{
printf("Queue getNextEvent return value: %ld\n", (long)ioReturnValue );
}
else
{
printf("Queue event[%lx] %ld\n", (unsigned long) event.elementCookie, event.value );
}
return (jint) event.value;
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: registerDeviceElement
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_registerDeviceElement
(JNIEnv * env, jobject obj, jlong lpQueue, jlong hidCookie)
{
IOHIDQueueInterface **queue = NULL;
queue = (IOHIDQueueInterface **)(long)lpQueue;
IOHIDElementCookie cookie = (IOHIDElementCookie)(long)hidCookie;
IOReturn ioReturnValue = kIOReturnSuccess;
ioReturnValue = (*queue)->addElement(queue, cookie, 0);
if ( ioReturnValue == kIOReturnSuccess )
{
printf("Registered pollElement: %ld\n", (long)cookie );
}
else
{
printf("Failed to add poll element: %ld\n", (long)cookie );
}
}
/*
* Class: net_java_games_input_OSXEnvironmentPlugin
* Method: deregisterDeviceElement
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_deregisterDeviceElement
(JNIEnv * env, jobject obj, jlong lpQueue, jlong hidCookie)
{
IOHIDQueueInterface **queue = NULL;
queue = (IOHIDQueueInterface **)(long)lpQueue;
IOHIDElementCookie cookie = (IOHIDElementCookie)(long)hidCookie;
IOReturn ioReturnValue = kIOReturnSuccess;
ioReturnValue = (*queue)->removeElement(queue, cookie );
if ( ioReturnValue == kIOReturnSuccess )
{
printf("Removed pollElement: %ld\n", (long)cookie );
}
else
{
printf("Failed to remove poll element: %ld\n", (long)cookie );
}
}