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

Initial check-in of the Java Games Initiative's game controller discovery and input library.

Browse source
This commit is contained in:
jeffpk 2003-06-06 21:04:07 +00:00
parent 1467eacaaf
commit 38a5315d76
27 changed files with 5234 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

54
coreAPI/README.txt Normal file
View file

@ -0,0 +1,54 @@
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 of the project you will have the following sub directories:
-- apidocs Where the javadocs get built to
-- lib Where dependant libraries are kept.
-- bin Where the actual API is built to
-- src The source files.
-- src/test Execution directories and data for tests.
Build instructions:
To clean: ant clean
To build: ant all (or just ant)
To build docs: ant javadoc
To test:
Textest: A simple discovery test that dumps
the data about the discovered controllers to stdout
To run: ant textest
Readtest: A test that creates a window for each discovered
controller (or sub-controller) which displays the
current state of all the controller's axiis.
(Note: The windows currrently all open at the same
place on the screen so yo uwill have to move them to
see them all.)
To run: ant readtest
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.)

116
coreAPI/build.xml Normal file
View file

@ -0,0 +1,116 @@
<?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="Game Input API" 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" -->
<!-- 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="utils" value="lib/jutils.jar"/>
<mkdir dir="apidocs"/>
<mkdir dir="classes"/>
<mkdir dir="bin"/>
</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">
<include name="net/**"/>
<!-- To add something to the classpath: -->
<classpath>
<pathelement location="${utils}"/>
</classpath>
<!-- To exclude some files: -->
<!--
<exclude name="com/foo/SomeFile.java"/>
<exclude name="com/foo/somepackage/"/>
-->
</javac>
</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/controller.jar" compress="true" basedir="classes">
<include name="net/**"/>
<exclude name="**/*.java"/>
<exclude name="**/*.form"/>
<exclude name="myapp.mf"/>
<exclude name="myapp.jar"/>
</jar>
<copy file="bin/controller.jar" todir="../plugins/DX8/lib" />
</target>
<target name="all" depends="init,jar" description="Build everything.">
<echo message="Application built. Hello ${hello}!"/>
</target>
<target name="texttest" depends="init,all" description="Try running it.">
<java classname="net.java.games.input.test.ControllerTextTest"
fork="true" failonerror="true" dir="src/tests">
<classpath>
<pathelement location="bin/controller.jar"/>
<pathelement location="${utils}"/>
</classpath>
<!-- Pass some args, perhaps: -->
<!-- <arg value="-myfile"/> -->
<!-- Will be given as an absolute path: -->
<!-- <arg file="myfile.txt"/> -->
</java>
</target>
<target name="readtest" depends="init,all" description="Try running it.">
<java classname="net.java.games.input.test.ControllerReadTest"
fork="true" failonerror="true" dir="src/tests">
<classpath>
<pathelement location="bin/controller.jar"/>
<pathelement location="${utils}"/>
</classpath>
<!-- Pass some args, perhaps: -->
<!-- <arg value="-myfile"/> -->
<!-- Will be given as an absolute path: -->
<!-- <arg file="myfile.txt"/> -->
</java>
</target>
<target name="javadoc" depends="init" description="Javadoc for my API.">
<javadoc packagenames="net.java.games.input.*"
destdir="apidocs"
additionalparam="-source 1.4">
<sourcepath>
<pathelement location="src/java"/>
</sourcepath>
<classpath>
<pathelement location="${utils}"/>
</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/controller.jar"/>
<delete dir="apidocs"/>
<delete file="../plugins/DX8/lib/controller.jar" />
</target>
</project>

153
coreAPI/src/java/net/java/games/input/AbstractAxis.java Normal file
View file

@ -0,0 +1,153 @@
/*
* %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;
/**
* Skeleton implementation of a named axis.
*/
public abstract class AbstractAxis implements Axis {
/**
* Human-readable name for this Axis
*/
protected String name;
/**
* Identifier for the axis
*/
protected Identifier id;
/**
* Whether this axis is ready to receive polling data
*/
private boolean polling;
/**
* Protected constructor
* @param name A name for the axis
*/
protected AbstractAxis(String name, Identifier id) {
this.name = name;
this.id = id;
this.polling = true;
}
/**
* Returns the type or identifier of the axis.
*/
public Identifier getIdentifier() {
return id;
}
/**
* Returns whether or not the axis is analog, or false if it is digital.
* @return false by default, can be overridden
*/
public boolean isAnalog() {
return false;
}
/**
* Returns whether or not data polled from this axis is normalized
* between the values of -1.0f and 1.0f.
* @return true by default, can be overridden
*/
public boolean isNormalized() {
return true;
}
/**
* Returns whether or not this axis is ready to receive polling data.
* By default, an abstract axis is set to receive polling data.
*/
public boolean isPolling() {
return polling;
}
/**
* Sets whether or not the axis should receive polling data.
*/
public void setPolling(boolean polling) {
this.polling = polling;
}
/**
* Returns the suggested dead zone for this axis. Dead zone is the
* amount polled data can vary before considered a significant change
* in value. An application can safely ignore changes less than this
* value in the positive or negative direction.
* @return 0.0f by default, can be overridden
*/
public float getDeadZone() {
return 0.0f;
}
/**
* Returns the data from the last time the control has been polled.
* If this axis is a button, the value returned will be either 0.0f or 1.0f.
* If this axis is normalized, the value returned will be between -1.0f and
* 1.0f.
* @return 0.0f by default, can be overridden
*/
public float getPollData() {
return 0.0f;
}
/**
* Returns a human-readable name for this axis.
*/
public String getName() {
return name;
}
/**
* Returns a non-localized string description of this axis.
*/
public String toString() {
return name;
}
/**
* Changes the name of this Axis. This should be done only during
* initialization of the axis so that its name remains immutable.
*/
public void setName(String name) {
this.name = name;
}
} // AbstractAxis

194
coreAPI/src/java/net/java/games/input/AbstractController.java Normal file
View file

@ -0,0 +1,194 @@
/*
* %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;
/**
* An AbstractController is a skeleton implementation of a controller that
* contains a fixed number of axes, controllers, and rumblers.
*/
public abstract class AbstractController implements Controller {
/**
* Null array representing no axes
*/
protected static final Axis[] NO_AXES = {};
/**
* Null array representing no child controllers
*/
protected static final Controller[] NO_CONTROLLERS = {};
/**
* Null array representing no rumblers
*/
protected static final Rumbler[] NO_RUMBLERS = {};
/**
* Human-readable name for this Controller
*/
private final String name;
/**
* Array of axes
*/
protected Axis[] axes;
/**
* Array of child controllers
*/
protected Controller[] children;
/**
* Array of rumblers
*/
protected Rumbler[] rumblers;
/**
* Protected constructor for a controller; initially contains no axes,
* child controllers, or rumblers.
* @param name The name for the controller
*/
protected AbstractController(String name) {
this(name, NO_AXES, NO_CONTROLLERS, NO_RUMBLERS);
}
/**
* Protected constructor for a controller containing the specified
* axes, child controllers, and rumblers
* @param name name for the controller
* @param axes axes for the controller
* @param children child controllers for the controller
* @param rumblers rumblers for the controller
*/
protected AbstractController(String name, Axis[] axes,
Controller[] children, Rumbler[] rumblers) {
this.name = name;
this.axes = axes;
this.children = children;
this.rumblers = rumblers;
}
/**
* Returns the controllers connected to make up this controller, or
* an empty array if this controller contains no child controllers.
* The objects in the array are returned in order of assignment priority
* (primary stick, secondary buttons, etc.).
*/
public Controller[] getControllers() {
return children;
}
/**
* Returns the axes on this controller, in order of assignment priority.
* For example, the button controller on a mouse returns an array containing
* the primary or leftmost mouse button, followed by the secondary or
* rightmost mouse button (if present), followed by the middle mouse button
* (if present).
* The array returned is an empty array if this controller contains no axes
* (such as a logical grouping of child controllers).
*/
public Axis[] getAxes() {
return axes;
}
/**
* Returns a single axis based on its identifier, or null
* if no axis with the specified type could be found.
* By default, AbstractController calls getAxes in this method so that
* subclasses may lazily initialize the array of axes, if necessary.
*/
public Axis getAxis(Axis.Identifier id) {
// Calls getAxes() so that subclasses may lazily set the array of axes.
Axis[] axes = getAxes();
if (axes.length == 0) {
return null;
}
for (int i = 0; i < axes.length; i++) {
if (axes[i].getIdentifier() == id) {
return axes[i];
}
}
return null;
}
/**
* Returns the rumblers for sending feedback to this controller, or an
* empty array if there are no rumblers on this controller.
*/
public Rumbler[] getRumblers() {
return rumblers;
}
/**
* Returns the port type for this Controller.
* @return PortType.UNKNOWN by default, can be overridden
*/
public PortType getPortType() {
return PortType.UNKNOWN;
}
/**
* Returns the zero-based port number for this Controller.
* @return 0 by default, can be overridden
*/
public int getPortNumber() {
return 0;
}
/**
* Returns a human-readable name for this Controller.
*/
public String getName() {
return name;
}
/**
* Returns a non-localized string description of this controller.
*/
public String toString() {
return name;
}
/** Returns the type of the Controller.
*/
public Type getType() {
return Type.UNKNOWN;
}
} // class AbstractController

349
coreAPI/src/java/net/java/games/input/Axis.java Normal file
View file

@ -0,0 +1,349 @@
/*
* %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;
/**
* An axis is a single button, slider, or dial, which has a single range. An
* axis can hold information for motion (linear or rotational), velocity,
* force, or acceleration.
*/
public interface Axis {
/**
* Returns the identifier of the axis.
*/
public abstract Identifier getIdentifier();
/**
* Returns <code>true</code> if data returned from <code>poll</code>
* is relative to the last call, or <code>false</code> if data
* is absolute.
*/
public abstract boolean isRelative();
/**
* Returns whether or not the axis is analog, or false if it is digital.
*/
public abstract boolean isAnalog();
/**
* Returns whether or not data polled from this axis is normalized
* between the values of -1.0f and 1.0f.
* @see #getPollData
*/
public abstract boolean isNormalized();
/**
* Returns whether or not this axis is ready to receive polling data.
* @see #getPollData
* @see Controller#poll
* @see #setPolling
*/
public abstract boolean isPolling();
/**
* Sets whether or not the axis should receive polling data.
* @see #getPollData
* @see Controller#poll
* @see #isPolling
*/
public abstract void setPolling(boolean polling);
/**
* Returns the suggested dead zone for this axis. Dead zone is the
* amount polled data can vary before considered a significant change
* in value. An application can safely ignore changes less than this
* value in the positive or negative direction.
* @see #getPollData
*/
public abstract float getDeadZone();
/**
* 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.
* @see Controller#poll
*/
public abstract float getPollData();
/**
* Returns a human-readable name for this axis.
*/
public abstract String getName();
/**
* Identifiers for different Axes.
*/
public static class Identifier {
/**
* Name of axis type
*/
private final String name;
/**
* Protected constructor
*/
protected Identifier(String name) {
this.name = name;
}
/**
* Returns a non-localized string description of this axis type.
*/
public String getName() {
return name;
}
/**
* Returns a non-localized string description of this axis type.
*/
public String toString() {
return name;
}
/**
* An axis for specifying vertical data.
*/
public static final Identifier X = new Identifier("x");
/**
* An axis for specifying horizontal data.
*/
public static final Identifier Y = new Identifier("y");
/**
* An axis for specifying third dimensional up/down
* data, or linear data in any direction that is
* neither horizontal nor vertical.
*/
public static final Identifier Z = new Identifier("z");
/**
* An axis for specifying left-right rotational data.
*/
public static final Identifier RX = new Identifier("rx");
/**
* An axis for specifying forward-back rotational data.
*/
public static final Identifier RY = new Identifier("ry");
/**
* An axis for specifying up-down rotational data
* (rudder control).
*/
public static final Identifier RZ = new Identifier("rz");
/**
* An axis for a button or key.
*/
public static final Identifier BUTTON = new Identifier("button");
/**
* An axis for a slider or mouse wheel.
*/
public static final Identifier SLIDER = new Identifier("slider");
/**
* An axis for a point-of-view control.
*/
public static final Identifier POV = new Identifier("pov");
/**
* An axis for specifying vertical velocity data.
*/
public static final Identifier X_VELOCITY =
new Identifier("x-velocity");
/**
* An axis for specifying horizontal velocity data.
*/
public static final Identifier Y_VELOCITY =
new Identifier("y-velocity");
/**
* An axis for specifying third dimensional up/down velocity
* data.
*/
public static final Identifier Z_VELOCITY =
new Identifier("z-velocity");
/**
* An axis for specifying left-right angular velocity data.
*/
public static final Identifier RX_VELOCITY =
new Identifier("rx-velocity");
/**
* An axis for specifying forward-back angular velocity data.
*/
public static final Identifier RY_VELOCITY =
new Identifier("ry-velocity");
/**
* An axis for specifying up-down angular velocity data.
*/
public static final Identifier RZ_VELOCITY =
new Identifier("rz-velocity");
/**
* An axis for slider or mouse wheel velocity data.
*/
public static final Identifier SLIDER_VELOCITY =
new Identifier("slider-velocity");
/**
* An axis for specifying vertical acceleration data.
*/
public static final Identifier X_ACCELERATION =
new Identifier("x-acceleration");
/**
* An axis for specifying horizontal acceleration data.
*/
public static final Identifier Y_ACCELERATION =
new Identifier("y-acceleration");
/**
* An axis for specifying third dimensional up/down acceleration
* data.
*/
public static final Identifier Z_ACCELERATION =
new Identifier("z-acceleration");
/**
* An axis for specifying left-right angular acceleration data.
*/
public static final Identifier RX_ACCELERATION =
new Identifier("rx-acceleration");
/**
* An axis for specifying forward-back angular acceleration data.
*/
public static final Identifier RY_ACCELERATION =
new Identifier("ry-acceleration");
/**
* An axis for specifying up-down angular acceleration data.
*/
public static final Identifier RZ_ACCELERATION =
new Identifier("rz-acceleration");
/**
* An axis for slider or mouse wheel acceleration data.
*/
public static final Identifier SLIDER_ACCELERATION =
new Identifier("slider-acceleration");
/**
* An axis for specifying vertical force data.
*/
public static final Identifier X_FORCE =
new Identifier("x-force");
/**
* An axis for specifying horizontal force data.
*/
public static final Identifier Y_FORCE =
new Identifier("y-force");
/**
* An axis for specifying third dimensional up/down force
* data.
*/
public static final Identifier Z_FORCE =
new Identifier("z-force");
/**
* An axis for specifying left-right angular force (torque) data.
*/
public static final Identifier RX_FORCE =
new Identifier("rx-force");
/**
* An axis for specifying forward-back angular force (torque) data.
*/
public static final Identifier RY_FORCE =
new Identifier("ry-force");
/**
* An axis for specifying up-down angular force (torque) data.
*/
public static final Identifier RZ_FORCE =
new Identifier("rz-force");
/**
* An axis for slider force data.
*/
public static final Identifier SLIDER_FORCE =
new Identifier("slider-force");
} // class Axis.Identifier
/**
* POV enum for different positions.
*/
public static class POV {
/**
* Standard value for center HAT position
*/
public static final float OFF = 0.0f;
/**
* Synonmous with OFF
*/
public static final float CENTER = OFF;
/**
* Standard value for up HAT position
*/
public static final float UP = 0.25f;
/**
* Standard value for right HAT position
*/
public static final float RIGHT = 0.50f;
/**
* Standard value for down HAT position
*/
public static final float DOWN = 0.75f;
/**
* Standard value for left HAT position
*/
public static final float LEFT = 1.0f;
} // class Axis.POV
} // interface Axis

253
coreAPI/src/java/net/java/games/input/Controller.java Normal file
View file

@ -0,0 +1,253 @@
/*
* %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;
/**
* A Controller represents a physical device, such as a keyboard, mouse,
* or joystick, or a logical grouping of related controls, such as a button
* pad or mouse ball. A controller can be composed of multiple controllers.
* For example, the ball of a mouse and its buttons are two separate
* controllers.
*/
public interface Controller {
/**
* Returns the controllers connected to make up this controller, or
* an empty array if this controller contains no child controllers.
* The objects in the array are returned in order of assignment priority
* (primary stick, secondary buttons, etc.).
*/
public abstract Controller[] getControllers();
/**
* Returns the type of the Controller.
*/
public abstract Type getType();
/**
* Returns the axes on this controller, in order of assignment priority.
* For example, the button controller on a mouse returns an array containing
* the primary or leftmost mouse button, followed by the secondary or
* rightmost mouse button (if present), followed by the middle mouse button
* (if present).
* The array returned is an empty array if this controller contains no axes
* (such as a logical grouping of child controllers).
*/
public abstract Axis[] getAxes();
/**
* Returns a single axis based on its type, or null
* if no axis with the specified type could be found.
*/
public abstract Axis getAxis(Axis.Identifier id);
/**
* Returns the rumblers for sending feedback to this controller, or an
* empty array if there are no rumblers on this controller.
*/
public abstract Rumbler[] getRumblers();
/**
* Polls axes for data. Returns false if the controller is no longer valid.
* Polling reflects the current state of the device when polled.
*/
public abstract boolean poll();
/**
* Returns the port type for this Controller.
*/
public abstract PortType getPortType();
/**
* Returns the zero-based port number for this Controller.
*/
public abstract int getPortNumber();
/**
* Returns a human-readable name for this Controller.
*/
public abstract String getName();
/**
* Types of controller objects.
*/
public static class Type {
/**
* Name of controller type
*/
private final String name;
/**
* Protected constructor
*/
protected Type(String name) {
this.name = name;
}
/**
* Returns a non-localized string description of this controller type.
*/
public String toString() {
return name;
}
/**
* Mouse controller.
*/
public static final Type UNKNOWN = new Type("unknown");
/**
* Mouse controller.
*/
public static final Type MOUSE = new Type("mouse");
/**
* A mouse ball or the ball part of a trackball controller.
* Note that a mouse wheel is considered part of a ball controller.
*/
public static final Type BALL = new Type("ball");
/**
* A group of buttons on a pad (mouse buttons, for
* example) or a keyboard.
*/
public static final Type BUTTONS = new Type("buttons");
/**
* A keyboard controller (same as BUTTONS)
* @see #BUTTONS
*/
public static final Type KEYBOARD = BUTTONS;
/**
* Fingerstick controller; note that this may be sometimes treated as a
* type of mouse or stick.
*/
public static final Type FINGERSTICK = new Type("fingerstick");
/**
* Gamepad controller.
*/
public static final Type GAMEPAD = new Type("gamepad");
/**
* Headtracker controller.
*/
public static final Type HEADTRACKER = new Type("headtracker");
/**
* Rudder controller.
*/
public static final Type RUDDER = new Type("rudder");
/**
* Stick controller, such as a joystick or flightstick.
*/
public static final Type STICK = new Type("stick");
/**
* A trackball controller; note that this may sometimes be treated as a
* type of mouse.
*/
public static final Type TRACKBALL = new Type("trackball");
/**
* A trackpad, such as a tablet, touchpad, or glidepad;
* note that this may sometimes be treated as a type of mouse.
*/
public static final Type TRACKPAD = new Type("trackpad");
/**
* A wheel controller, such as a steering wheel (note
* that a mouse wheel is considered part of a ball control, not a
* wheel controller).
*/
public static final Type WHEEL = new Type("wheel");
} // class Controller.Type
/**
* Common controller port types.
*/
public static final class PortType {
/**
* Name of port type
*/
private final String name;
/**
* Protected constructor
*/
protected PortType(String name) {
this.name = name;
}
/**
* Returns a non-localized string description of this port type.
*/
public String toString() {
return name;
}
/**
* Unknown port type
*/
public static final PortType UNKNOWN = new PortType("Unknown");
/**
* USB port
*/
public static final PortType USB = new PortType("USB port");
/**
* Standard game port
*/
public static final PortType GAME = new PortType("Game port");
/**
* Network port
*/
public static final PortType NETWORK = new PortType("Network port");
/**
* Serial port
*/
public static final PortType SERIAL = new PortType("Serial port");
} // class Controller.PortType
} // interface Controller

140
coreAPI/src/java/net/java/games/input/ControllerEnvironment.java Normal file
View file

@ -0,0 +1,140 @@
/*
* %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.util.ArrayList;
import java.util.Iterator;
/**
* A ControllerEnvironment represents a collection of controllers that are
* physically or logically linked. By default, this corresponds to the
* environment for the local machine.
* <p>
* In this reference implementation, this class can also be used to register
* controllers with the default environment as "plug-ins". A plug-in is
* created by subclassing ControllerEnvironment with a class that has a public
* no-argument constructor, implements the org.java.games.util.plugins.Plugin
* interface and has a name ending in "Plugin".
* (See org.java.games.input.DirectInputEnvironmentPlugin in the DXplugin
* part of the source tree for an example.)
*
* When the DefaultControllerEnvrionment is instanced it uses the plugin library
* to look for Plugins in both [java.home]/lib/controller and
* [user.dir]/controller. This allows controller plugins to be installed either
* globally for the entire Java environment or locally for just one particular
* Java app.
*
* For more information on the organization of plugins within the controller
* root directories, see org.java.games.util.plugins.Plugins (Note the
* plural -- "Plugins" not "Plugin" which is just a marker interface.)
*
*/
public abstract class ControllerEnvironment {
/**
* The default controller environment
*/
private static ControllerEnvironment defaultEnvironment =
new DefaultControllerEnvironment();
/**
* List of controller listeners
*/
protected final ArrayList controllerListeners = new ArrayList();
/**
* Protected constructor for subclassing.
*/
protected ControllerEnvironment() {
}
/**
* Returns a list of all controllers available to this environment,
* or an empty array if there are no controllers in this environment.
*/
public abstract Controller[] getControllers();
/**
* Adds a listener for controller state change events.
*/
public void addControllerListener(ControllerListener l) {
assert l != null;
controllerListeners.add(l);
}
/**
* Removes a listener for controller state change events.
*/
public void removeControllerListener(ControllerListener l) {
assert l != null;
controllerListeners.remove(l);
}
/**
* Creates and sends an event to the controller listeners that a controller
* has been added.
*/
protected void fireControllerAdded(Controller c) {
ControllerEvent ev = new ControllerEvent(c);
Iterator it = controllerListeners.iterator();
while (it.hasNext()) {
((ControllerListener)it.next()).controllerAdded(ev);
}
}
/**
* Creates and sends an event to the controller listeners that a controller
* has been lost.
*/
protected void fireControllerRemoved(Controller c) {
ControllerEvent ev = new ControllerEvent(c);
Iterator it = controllerListeners.iterator();
while (it.hasNext()) {
((ControllerListener)it.next()).controllerRemoved(ev);
}
}
/**
* Returns the default environment for input controllers.
* This usually corresponds to the environment for the local machine.
*/
public static ControllerEnvironment getDefaultEnvironment() {
return defaultEnvironment;
}
} // ControllerEnvironment

61
coreAPI/src/java/net/java/games/input/ControllerEvent.java Normal file
View file

@ -0,0 +1,61 @@
/*
* %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;
/**
* An event that is fired when the state of a controller changes
*/
public class ControllerEvent {
private Controller controller;
/**
* Creates a controller event object.
*/
public ControllerEvent(Controller c) {
controller = c;
}
/**
* Returns the controller for this event.
*/
public Controller getController() {
return controller;
}
} // class ControllerEvent

55
coreAPI/src/java/net/java/games/input/ControllerListener.java Normal file
View file

@ -0,0 +1,55 @@
/*
* %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;
/**
* A listener for changes in the state of controllers
*/
public interface ControllerListener {
/**
* Invoked when a controller is lost.
*/
public abstract void controllerRemoved(ControllerEvent ev);
/**
* Invoked when a controller has been added.
*/
public abstract void controllerAdded(ControllerEvent ev);
} // interface ControllerListener

232
coreAPI/src/java/net/java/games/input/DefaultControllerEnvironment.java Normal file
View file

@ -0,0 +1,232 @@
/*
* %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.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Properties;
import net.java.games.util.plugins.*;
/**
* The default controller environment.
*
* @version %I% %G%
* @author Michael Martak
*/
class DefaultControllerEnvironment extends ControllerEnvironment {
static final boolean DEBUG =false;
/**
* The name of the properties file to find plugins.
*/
private final static String PROPERTY_FILENAME =
"controller.properties";
/**
* The name of the property for identifying a plugin (used
* as the value, the key being the class name).
*/
private final static String ID_PLUGIN =
"ControllerEnvironment";
/**
* Location of the LIB directory.
*/
static String libPath;
/**
* List of all controllers in this environment
*/
private ArrayList controllers;
/**
* Plug-in properties.
*/
private Properties properties = new Properties();
/**
* Plug-in class loader.
*/
private PluginClassLoader pluginLoader = new PluginClassLoader();
/**
* Public no-arg constructor.
*/
public DefaultControllerEnvironment() {
}
/**
* Returns a list of all controllers available to this environment,
* or an empty array if there are no controllers in this environment.
*/
public Controller[] getControllers() {
if (controllers == null) {
// Controller list has not been scanned.
controllers = new ArrayList();
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
scanControllers();
return DefaultControllerEnvironment.this;
}
});
}
Controller[] ret = new Controller[controllers.size()];
Iterator it = controllers.iterator();
int i = 0;
while (it.hasNext()) {
ret[i] = (Controller)it.next();
i++;
}
return ret;
}
/**
* Scans for controllers, placing them in the controllers list.
*/
/* This is Mike's old plugin code.
private void scanControllers() {
// Load properties object.
try {
loadProperties();
} catch (IOException e) {
// Could not find or read file, simply return.
return;
}
// Create a list of ControllerEnvironment classes.
// For each ControllerEnvironment, locate the class
// using the plugin class loader.
Iterator it = properties.keySet().iterator();
while (it.hasNext()) {
Object key = it.next();
assert key != null;
Object value = properties.get(key);
assert value != null;
if (value.equals(ID_PLUGIN)) {
try {
ControllerEnvironment plugin =
newPlugin(key.toString());
addControllers(plugin.getControllers());
} catch (Throwable t) {
System.err.println(
"Warning : could not load plugin " +
key.toString() + ", received exeption " +
t.toString());
t.printStackTrace(System.err);
}
}
}
}*/
/* This is jeff's new plugin code using Jeff's Plugin manager */
private void scanControllers() {
scanControllersAt(System.getProperty("java.home") +
File.separator + "lib"+File.separator+"controller");
scanControllersAt(System.getProperty("user.dir")+
File.separator+ "controller");
}
private void scanControllersAt(String path) {
try {
Plugins plugins = new Plugins(new File(path));
Class[] envClasses = plugins.getExtends(ControllerEnvironment.class);
for(int i=0;i<envClasses.length;i++){
try {
if (DEBUG) {
System.out.println("ControllerEnvironment "+
envClasses[i].getName()
+" loaded by "+envClasses[i].getClassLoader());
}
ControllerEnvironment ce = (ControllerEnvironment)
envClasses[i].newInstance();
addControllers(ce.getControllers());
} catch (Exception e) {
e.printStackTrace();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Retrieve the file "lib/control.properties" and
* load properties into properties object.
*/
private void loadProperties() throws IOException {
if (libPath == null) {
libPath = System.getProperty("java.home") +
File.separator + "lib";
}
File file = new File(libPath + File.separator +
PROPERTY_FILENAME);
FileInputStream inputStream = new FileInputStream(file);
properties.load(inputStream);
inputStream.close();
}
/**
* Create a new plugin ControllerEnvironment object
*/
/*
private ControllerEnvironment newPlugin(String name) throws
ClassNotFoundException, InstantiationException,
IllegalAccessException {
Class pluginClass = pluginLoader.loadClass(name);
if (!ControllerEnvironment.class.isAssignableFrom(pluginClass)) {
throw new ClassCastException(
"Plugin class must be assignable from " +
ControllerEnvironment.class.getName());
}
Object instance = pluginClass.newInstance();
return (ControllerEnvironment)instance;
}
*/
/**
* Add the array of controllers to our list of controllers.
*/
private void addControllers(Controller[] c) {
for (int i = 0; i < c.length; i++) {
controllers.add(c[i]);
}
}
}

168
coreAPI/src/java/net/java/games/input/Keyboard.java Normal file
View file

@ -0,0 +1,168 @@
/*
* %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;
/**
* A Keyboard is a type of controller consisting of a single controller,
* they keypad, which contains several axes (the keys). By default, all keys
* are set to receive polling data.
*/
public abstract class Keyboard extends AbstractController {
/**
* Protected constructor.
* Subclasses should initialize the array of axes to an array of keys.
* @param name The name of the keyboard
*/
protected Keyboard(String name) {
super(name);
}
/**
* Returns the type of the Controller.
*/
public Type getType() {
return Type.KEYBOARD;
}
/**
* Returns the axis corresponding to a particular key on the keypad,
* or null if a key with the specified ID could not be found.
*/
public Axis getAxis(Axis.Identifier id) {
assert axes != null;
// Default implementation uses indices to lookup keys
// in the array of axes
if (id instanceof KeyID) {
KeyID kid = (KeyID)id;
int index = kid.getKeyIndex();
assert axes.length > index;
return axes[index];
}
return null;
}
/**
* Returns whether or not the given key has been pressed since the last
* call to poll. This is called from a key's getPollData method.
*/
protected abstract boolean isKeyPressed(Key key);
/**
* Axis representing a single key. By default, all keys are set to receive
* polling data.
*/
public class Key extends AbstractAxis {
/**
* Key identifier
*/
private final KeyID keyID;
/**
* Construct a new key object
*/
public Key(KeyID keyID) {
super(keyID.toString(), keyID);
this.keyID = keyID;
}
/**
* 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 false by default, can be overridden
*/
public final boolean isRelative() {
return false;
}
/**
* Returns the data from the last time the control has been polled.
* The value returned will be either 0.0f or 1.0f. The result is always
* 0.0f if polling is turned off.
*/
public float getPollData() {
if (!isPolling()) {
return 0.0f;
}
return (isKeyPressed(this) ? 1.0f : 0.0f);
}
} // class Keyboard.Key
/**
* Identifiers for physical keys.
*/
public static class KeyID extends Axis.Identifier {
/**
* Key string
*/
private static final String NAME_KEY = "key";
/**
* Index in the array of axes supplied to the keyboard contructor for
* this key.
*/
protected final int keyIndex;
/**
* Protected constructor
* @param keyIndex the index for looking up the key in the array of axes
*/
protected KeyID(int keyIndex) {
super(NAME_KEY);
this.keyIndex = keyIndex;
}
/**
* The index for this key for looking up the in the array of axes.
*/
public int getKeyIndex() {
return keyIndex;
}
/**
* Returns a non-localized string description of this control type.
*/
public String toString() {
return super.toString() + " " + Integer.toString(keyIndex);
}
} // class Keyboard.KeyID
} // class Keyboard

315
coreAPI/src/java/net/java/games/input/Mouse.java Normal file
View file

@ -0,0 +1,315 @@
/*
* %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;
/**
* A Mouse is a type of controller consisting of two child controllers,
* a ball and a button pad. This includes devices such as touch pads,
* trackballs, and fingersticks.
*/
public abstract class Mouse extends AbstractController {
/**
* Mouse ball; should be initialized by subclasses
*/
protected Ball ball;
/**
* Mouse buttons; should be initialized by subclasses
*/
protected Buttons buttons;
/**
* Protected constructor;
* Subclasses should initialize the ball and buttons
*/
protected Mouse(String name) {
super(name);
}
/**
* Returns the controllers connected to make up this controller, or
* an empty array if this controller contains no child controllers.
* The objects in the array are returned in order of assignment priority
* (primary stick, secondary buttons, etc.).
*/
public Controller[] getControllers() {
if (children.length == 0 && ball != null && buttons != null) {
children = new Controller[] { ball, buttons };
}
return children;
}
/**
* Returns the control for the ball of the mouse, never null.
*/
public Ball getBall() {
return ball;
}
/**
* Returns the control for the buttons of the mouse, never null.
*/
public Buttons getButtons() {
return buttons;
}
/**
* Returns the type of the Controller.
*/
public Type getType() {
return Type.MOUSE;
}
/**
* Mouse ball controller
*/
public abstract class Ball extends AbstractController {
/**
* X-axis; should be initialized by subclasses
*/
protected Axis x;
/**
* Y-axis; should be initialized by subclasses
*/
protected Axis y;
/**
* Mouse wheel; should be initialized by subclasses
*/
protected Axis wheel;
/**
* Protected constructor
*/
protected Ball(String name) {
super(name);
}
/**
* Returns the type of Controller.
*/
public Type getType() {
return Type.BALL;
}
/**
* Returns the x-axis for the mouse ball, never null.
*/
public Axis getX() {
return x;
}
/**
* Returns the y-axis for the mouse ball, never null.
*/
public Axis getY() {
return y;
}
/**
* Returns the mouse wheel, or null if no mouse wheel is present.
*/
public Axis getWheel() {
return wheel;
}
/**
* Returns the axes on this controller, in order of assignment priority.
* Overridden to return the x-axis, followed by the y-axes, followed by
* the wheel (if present).
* The array returned is an empty array if this controller contains no
* axes (such as a logical grouping of child controllers).
*/
public Axis[] getAxes() {
if (axes.length == 0 && x != null && y != null) {
if (wheel == null) {
axes = new Axis[] { x, y };
} else {
axes = new Axis[] { x, y, wheel };
}
}
return axes;
}
/**
* Polls axes for data. Returns false if the controller is no longer
* valid. Polling reflects the current state of the device when polled.
* By default, polling a mouse ball or button polls the entire mouse
* control.
*/
public boolean poll() {
return Mouse.this.poll();
}
} // class Mouse.Ball
/**
* Mouse buttons controller
*/
public abstract class Buttons extends AbstractController {
/**
* Left button; should be initialized by subclasses
*/
protected Button left;
/**
* Right button; should be initialized by subclasses
*/
protected Button right;
/**
* Middle button; should be initialized by subclasses
*/
protected Button middle;
/**
* Protected constructor
*/
protected Buttons(String name) {
super(name);
}
/**
* Returns the type or identifier of the Controller.
*/
public Type getType() {
return Type.BUTTONS;
}
/**
* Returns the left or primary mouse button, never null.
*/
public Button getLeft() {
return left;
}
/**
* Returns the right or secondary mouse button, null if the mouse is
* a single-button mouse.
*/
public Button getRight() {
return right;
}
/**
* Returns the middle or tertiary mouse button, null if the mouse has
* fewer than three buttons.
*/
public Button getMiddle() {
return middle;
}
/**
* Returns the axes on this controller, in order of assignment priority.
* Overridden to return the the primary or leftmost mouse button,
* followed by the secondary or rightmost mouse button (if present),
* followed by the middle mouse button (if present).
* The array returned is an empty array if this controller contains no
* axes (such as a logical grouping of child controllers).
*/
public Axis[] getAxes() {
if (axes.length == 0 && left != null) {
if (right == null) {
axes = new Axis[] { left };
} else if (middle == null) {
axes = new Axis[] { left, right };
} else {
axes = new Axis[] { left, right, middle };
}
}
return axes;
}
/**
* Polls axes for data. Returns false if the controller is no longer
* valid. Polling reflects the current state of the device when polled.
* By default, polling a mouse ball or button polls the entire mouse
* control.
*/
public boolean poll() {
return Mouse.this.poll();
}
} // class Mouse.Buttons
/**
* Mouse button axis
*/
public abstract class Button extends AbstractAxis {
/**
* Protected constructor
*/
protected Button(String name, ButtonID id) {
super(name, id);
}
} // class Mouse.Button
/**
* Identifier for types of mouse buttons
*/
public static class ButtonID extends Axis.Identifier {
/**
* Protected constructor
*/
protected ButtonID(String name) {
super(name);
}
/**
* The primary or leftmost mouse button.
*/
public static final ButtonID LEFT = new ButtonID("left");
/**
* The secondary or rightmost mouse button, not present if
* the mouse is a single-button mouse.
*/
public static final ButtonID RIGHT = new ButtonID("right");
/**
* Returns the middle mouse button, not present if the
* mouse has fewer than three buttons.
*/
public static final ButtonID MIDDLE = new ButtonID("middle");
} // class Mouse.ButtonID
} // class Mouse

175
coreAPI/src/java/net/java/games/input/PluginClassLoader.java Normal file
View file

@ -0,0 +1,175 @@
/*
* %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.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
/**
* Loads all plugins.
*
* @version %I% %G%
* @author Michael Martak
*/
class PluginClassLoader extends ClassLoader {
/**
* Location of directory to look for plugins
*/
private static String pluginDirectory;
/**
* File filter for JAR files
*/
private static final FileFilter JAR_FILTER = new JarFileFilter();
/**
* Create a new class loader for loading plugins
*/
public PluginClassLoader() {
super(Thread.currentThread().getContextClassLoader());
}
/**
* Overrides findClass to first look in the parent class loader,
* then try loading the class from the plugin file system.
*/
protected Class findClass(String name)
throws ClassNotFoundException {
// Try loading the class from the file system.
byte[] b = loadClassData(name);
return defineClass(name, b, 0, b.length);
}
/**
* Load the class data from the file system
*/
private byte[] loadClassData(String name)
throws ClassNotFoundException {
if (pluginDirectory == null) {
pluginDirectory = DefaultControllerEnvironment.libPath +
File.separator + "controller";
}
try {
return loadClassFromDirectory(name);
} catch (Exception e) {
try {
return loadClassFromJAR(name);
} catch (IOException e2) {
throw new ClassNotFoundException(name, e2);
}
}
}
/**
* Load the class data from the file system based on parsing
* the class name (packages).
*/
private byte[] loadClassFromDirectory(String name)
throws ClassNotFoundException, IOException {
// Parse the class name into package directories.
// Look for the class in the plugin directory.
StringTokenizer tokenizer = new StringTokenizer(name, ".");
StringBuffer path = new StringBuffer(pluginDirectory);
while (tokenizer.hasMoreTokens()) {
path.append(File.separator);
path.append(tokenizer.nextToken());
}
path.append(".class");
File file = new File(path.toString());
if (!file.exists()) {
throw new ClassNotFoundException(name);
}
FileInputStream fileInputStream = new FileInputStream(file);
assert file.length() <= Integer.MAX_VALUE;
int length = (int)file.length();
byte[] bytes = new byte[length];
int length2 = fileInputStream.read(bytes);
assert length == length2;
return bytes;
}
/**
* Scans through the plugin directory for JAR files and
* attempts to load the class data from each JAR file.
*/
private byte[] loadClassFromJAR(String name)
throws ClassNotFoundException, IOException {
File dir = new File(pluginDirectory);
File[] jarFiles = dir.listFiles(JAR_FILTER);
if (jarFiles == null) {
throw new ClassNotFoundException("Could not find class " + name);
}
for (int i = 0; i < jarFiles.length; i++) {
JarFile jarfile = new JarFile(jarFiles[i]);
JarEntry jarentry = jarfile.getJarEntry(name + ".class");
if (jarentry != null) {
InputStream jarInputStream = jarfile.getInputStream(jarentry);
assert jarentry.getSize() <= Integer.MAX_VALUE;
int length = (int)jarentry.getSize();
assert length >= 0;
byte[] bytes = new byte[length];
int length2 = jarInputStream.read(bytes);
assert length == length2;
return bytes;
}
}
throw new FileNotFoundException(name);
}
/**
* Filters out all non-JAR files, based on whether or not they
* end in ".JAR" (case-insensitive).
*/
private static class JarFileFilter implements FileFilter {
public boolean accept(File file) {
return file.getName().toUpperCase().endsWith(".JAR");
}
}
}

52
coreAPI/src/java/net/java/games/input/Rumbler.java Normal file
View file

@ -0,0 +1,52 @@
/*
* %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;
/**
* A Rumbler is a controller's mechanism for delivering feedback
* to the user through the device.
*/
public interface Rumbler {
/**
* Rumble with the specified intensity.
*/
public abstract void rumble(float intensity);
} // interface Rumbler

261
coreAPI/src/java/net/java/games/input/StandardKeyboard.java Normal file
View file

@ -0,0 +1,261 @@
/*
* %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;
/**
* Identifiers for physical keys for standard PC (LATIN-1) keyboards.
*/
public abstract class StandardKeyboard extends Keyboard {
private Key[] standardKeys = {
new Key(KeyID.VOID ), new Key(KeyID.ESCAPE ),
new Key(KeyID._1 ), new Key(KeyID._2 ),
new Key(KeyID._3 ), new Key(KeyID._4 ),
new Key(KeyID._5 ), new Key(KeyID._6 ),
new Key(KeyID._7 ), new Key(KeyID._8 ),
new Key(KeyID._9 ), new Key(KeyID._0 ),
new Key(KeyID.MINUS ), new Key(KeyID.EQUALS ),
new Key(KeyID.BACK ), new Key(KeyID.TAB ),
new Key(KeyID.Q ), new Key(KeyID.W ),
new Key(KeyID.E ), new Key(KeyID.R ),
new Key(KeyID.T ), new Key(KeyID.Y ),
new Key(KeyID.U ), new Key(KeyID.I ),
new Key(KeyID.O ), new Key(KeyID.P ),
new Key(KeyID.LBRACKET ), new Key(KeyID.RBRACKET ),
new Key(KeyID.RETURN ), new Key(KeyID.LCONTROL ),
new Key(KeyID.A ), new Key(KeyID.S ),
new Key(KeyID.D ), new Key(KeyID.F ),
new Key(KeyID.G ), new Key(KeyID.H ),
new Key(KeyID.J ), new Key(KeyID.K ),
new Key(KeyID.L ), new Key(KeyID.SEMICOLON ),
new Key(KeyID.APOSTROPHE ), new Key(KeyID.GRAVE ),
new Key(KeyID.LSHIFT ), new Key(KeyID.BACKSLASH ),
new Key(KeyID.Z ), new Key(KeyID.X ),
new Key(KeyID.C ), new Key(KeyID.V ),
new Key(KeyID.B ), new Key(KeyID.N ),
new Key(KeyID.M ), new Key(KeyID.COMMA ),
new Key(KeyID.PERIOD ), new Key(KeyID.SLASH ),
new Key(KeyID.RSHIFT ), new Key(KeyID.MULTIPLY ),
new Key(KeyID.LALT ), new Key(KeyID.SPACE ),
new Key(KeyID.CAPITAL ), new Key(KeyID.F1 ),
new Key(KeyID.F2 ), new Key(KeyID.F3 ),
new Key(KeyID.F4 ), new Key(KeyID.F5 ),
new Key(KeyID.F6 ), new Key(KeyID.F7 ),
new Key(KeyID.F8 ), new Key(KeyID.F9 ),
new Key(KeyID.F10 ), new Key(KeyID.NUMLOCK ),
new Key(KeyID.SCROLL ), new Key(KeyID.NUMPAD7 ),
new Key(KeyID.NUMPAD8 ), new Key(KeyID.NUMPAD9 ),
new Key(KeyID.SUBTRACT ), new Key(KeyID.NUMPAD4 ),
new Key(KeyID.NUMPAD5 ), new Key(KeyID.NUMPAD6 ),
new Key(KeyID.ADD ), new Key(KeyID.NUMPAD1 ),
new Key(KeyID.NUMPAD2 ), new Key(KeyID.NUMPAD3 ),
new Key(KeyID.NUMPAD0 ), new Key(KeyID.DECIMAL ),
new Key(KeyID.F11 ), new Key(KeyID.F12 ),
new Key(KeyID.F13 ), new Key(KeyID.F14 ),
new Key(KeyID.F15 ), new Key(KeyID.KANA ),
new Key(KeyID.CONVERT ), new Key(KeyID.NOCONVERT ),
new Key(KeyID.YEN ), new Key(KeyID.NUMPADEQUAL),
new Key(KeyID.CIRCUMFLEX ), new Key(KeyID.AT ),
new Key(KeyID.COLON ), new Key(KeyID.UNDERLINE ),
new Key(KeyID.KANJI ), new Key(KeyID.STOP ),
new Key(KeyID.AX ), new Key(KeyID.UNLABELED ),
new Key(KeyID.NUMPADENTER), new Key(KeyID.RCONTROL ),
new Key(KeyID.NUMPADCOMMA), new Key(KeyID.DIVIDE ),
new Key(KeyID.SYSRQ ), new Key(KeyID.RALT ),
new Key(KeyID.PAUSE ), new Key(KeyID.HOME ),
new Key(KeyID.UP ), new Key(KeyID.PRIOR ),
new Key(KeyID.LEFT ), new Key(KeyID.RIGHT ),
new Key(KeyID.END ), new Key(KeyID.DOWN ),
new Key(KeyID.NEXT ), new Key(KeyID.INSERT ),
new Key(KeyID.DELETE ), new Key(KeyID.LWIN ),
new Key(KeyID.RWIN ), new Key(KeyID.APPS ),
new Key(KeyID.POWER ), new Key(KeyID.SLEEP ),
};
/**
* Creates a new standard keyboard object with the default keys
* for a standard keyboard.
*/
protected StandardKeyboard(String name) {
super(name);
axes = standardKeys;
}
/**
* KeyIDs for standard PC (LATIN-1) keyboards
*/
public static class KeyID extends Keyboard.KeyID {
/**
* Protected constructor
*/
protected KeyID(int keyID) {
super(keyID);
}
/**
* Standard keyboard (LATIN-1) keys
* UNIX X11 keysym values are listed to the right
*/
public static final KeyID VOID = new KeyID(0); // MS 0x00 UNIX 0xFFFFFF
public static final KeyID ESCAPE = new KeyID(1); // MS 0x01 UNIX 0xFF1B
public static final KeyID _1 = new KeyID(2); // MS 0x02 UNIX 0x031 EXCLAM 0x021
public static final KeyID _2 = new KeyID(3); // MS 0x03 UNIX 0x032 AT 0x040
public static final KeyID _3 = new KeyID(4); // MS 0x04 UNIX 0x033 NUMBERSIGN 0x023
public static final KeyID _4 = new KeyID(5); // MS 0x05 UNIX 0x034 DOLLAR 0x024
public static final KeyID _5 = new KeyID(6); // MS 0x06 UNIX 0x035 PERCENT 0x025
public static final KeyID _6 = new KeyID(7); // MS 0x07 UNIX 0x036 CIRCUMFLEX 0x05e
public static final KeyID _7 = new KeyID(8); // MS 0x08 UNIX 0x037 AMPERSAND 0x026
public static final KeyID _8 = new KeyID(9); // MS 0x09 UNIX 0x038 ASTERISK 0x02a
public static final KeyID _9 = new KeyID(10); // MS 0x0A UNIX 0x039 PARENLEFT 0x028
public static final KeyID _0 = new KeyID(11); // MS 0x0B UNIX 0x030 PARENRIGHT 0x029
public static final KeyID MINUS = new KeyID(12); // MS 0x0C UNIX 0x02d UNDERSCORE 0x05f
public static final KeyID EQUALS = new KeyID(13); // MS 0x0D UNIX 0x03d PLUS 0x02b
public static final KeyID BACK = new KeyID(14); // MS 0x0E UNIX 0xFF08
public static final KeyID TAB = new KeyID(15); // MS 0x0F UNIX 0xFF09
public static final KeyID Q = new KeyID(16); // MS 0x10 UNIX 0x071 UPPER 0x051
public static final KeyID W = new KeyID(17); // MS 0x11 UNIX 0x077 UPPER 0x057
public static final KeyID E = new KeyID(18); // MS 0x12 UNIX 0x065 UPPER 0x045
public static final KeyID R = new KeyID(19); // MS 0x13 UNIX 0x072 UPPER 0x052
public static final KeyID T = new KeyID(20); // MS 0x14 UNIX 0x074 UPPER 0x054
public static final KeyID Y = new KeyID(21); // MS 0x15 UNIX 0x079 UPPER 0x059
public static final KeyID U = new KeyID(22); // MS 0x16 UNIX 0x075 UPPER 0x055
public static final KeyID I = new KeyID(23); // MS 0x17 UNIX 0x069 UPPER 0x049
public static final KeyID O = new KeyID(24); // MS 0x18 UNIX 0x06F UPPER 0x04F
public static final KeyID P = new KeyID(25); // MS 0x19 UNIX 0x070 UPPER 0x050
public static final KeyID LBRACKET = new KeyID(26); // MS 0x1A UNIX 0x05b BRACE 0x07b
public static final KeyID RBRACKET = new KeyID(27); // MS 0x1B UNIX 0x05d BRACE 0x07d
public static final KeyID RETURN = new KeyID(28); // MS 0x1C UNIX 0xFF0D
public static final KeyID LCONTROL = new KeyID(29); // MS 0x1D UNIX 0xFFE3
public static final KeyID A = new KeyID(30); // MS 0x1E UNIX 0x061 UPPER 0x041
public static final KeyID S = new KeyID(31); // MS 0x1F UNIX 0x073 UPPER 0x053
public static final KeyID D = new KeyID(32); // MS 0x20 UNIX 0x064 UPPER 0x044
public static final KeyID F = new KeyID(33); // MS 0x21 UNIX 0x066 UPPER 0x046
public static final KeyID G = new KeyID(34); // MS 0x22 UNIX 0x067 UPPER 0x047
public static final KeyID H = new KeyID(35); // MS 0x23 UNIX 0x068 UPPER 0x048
public static final KeyID J = new KeyID(36); // MS 0x24 UNIX 0x06A UPPER 0x04A
public static final KeyID K = new KeyID(37); // MS 0x25 UNIX 0x06B UPPER 0x04B
public static final KeyID L = new KeyID(38); // MS 0x26 UNIX 0x06C UPPER 0x04C
public static final KeyID SEMICOLON = new KeyID(39); // MS 0x27 UNIX 0x03b COLON 0x03a
public static final KeyID APOSTROPHE = new KeyID(40); // MS 0x28 UNIX 0x027 QUOTEDBL 0x022
public static final KeyID GRAVE = new KeyID(41); // MS 0x29 UNIX 0x060 TILDE 0x07e
public static final KeyID LSHIFT = new KeyID(42); // MS 0x2A UNIX 0xFFE1
public static final KeyID BACKSLASH = new KeyID(43); // MS 0x2B UNIX 0x05c BAR 0x07c
public static final KeyID Z = new KeyID(44); // MS 0x2C UNIX 0x07A UPPER 0x05A
public static final KeyID X = new KeyID(45); // MS 0x2D UNIX 0x078 UPPER 0x058
public static final KeyID C = new KeyID(46); // MS 0x2E UNIX 0x063 UPPER 0x043
public static final KeyID V = new KeyID(47); // MS 0x2F UNIX 0x076 UPPER 0x056
public static final KeyID B = new KeyID(48); // MS 0x30 UNIX 0x062 UPPER 0x042
public static final KeyID N = new KeyID(49); // MS 0x31 UNIX 0x06E UPPER 0x04E
public static final KeyID M = new KeyID(50); // MS 0x32 UNIX 0x06D UPPER 0x04D
public static final KeyID COMMA = new KeyID(51); // MS 0x33 UNIX 0x02c LESS 0x03c
public static final KeyID PERIOD = new KeyID(52); // MS 0x34 UNIX 0x02e GREATER 0x03e
public static final KeyID SLASH = new KeyID(53); // MS 0x35 UNIX 0x02f QUESTION 0x03f
public static final KeyID RSHIFT = new KeyID(54); // MS 0x36 UNIX 0xFFE2
public static final KeyID MULTIPLY = new KeyID(55); // MS 0x37 UNIX 0xFFAA
public static final KeyID LALT = new KeyID(56); // MS 0x38 UNIX 0xFFE9
public static final KeyID SPACE = new KeyID(57); // MS 0x39 UNIX 0x020
public static final KeyID CAPITAL = new KeyID(58); // MS 0x3A UNIX 0xFFE5 SHIFTLOCK 0xFFE6
public static final KeyID F1 = new KeyID(59); // MS 0x3B UNIX 0xFFBE
public static final KeyID F2 = new KeyID(60); // MS 0x3C UNIX 0xFFBF
public static final KeyID F3 = new KeyID(61); // MS 0x3D UNIX 0xFFC0
public static final KeyID F4 = new KeyID(62); // MS 0x3E UNIX 0xFFC1
public static final KeyID F5 = new KeyID(63); // MS 0x3F UNIX 0xFFC2
public static final KeyID F6 = new KeyID(64); // MS 0x40 UNIX 0xFFC3
public static final KeyID F7 = new KeyID(65); // MS 0x41 UNIX 0xFFC4
public static final KeyID F8 = new KeyID(66); // MS 0x42 UNIX 0xFFC5
public static final KeyID F9 = new KeyID(67); // MS 0x43 UNIX 0xFFC6
public static final KeyID F10 = new KeyID(68); // MS 0x44 UNIX 0xFFC7
public static final KeyID NUMLOCK = new KeyID(69); // MS 0x45 UNIX 0xFF7F
public static final KeyID SCROLL = new KeyID(70); // MS 0x46 UNIX 0xFF14
public static final KeyID NUMPAD7 = new KeyID(71); // MS 0x47 UNIX 0xFFB7 HOME 0xFF95
public static final KeyID NUMPAD8 = new KeyID(72); // MS 0x48 UNIX 0xFFB8 UP 0xFF97
public static final KeyID NUMPAD9 = new KeyID(73); // MS 0x49 UNIX 0xFFB9 PRIOR 0xFF9A
public static final KeyID SUBTRACT = new KeyID(74); // MS 0x4A UNIX 0xFFAD
public static final KeyID NUMPAD4 = new KeyID(75); // MS 0x4B UNIX 0xFFB4 LEFT 0xFF96
public static final KeyID NUMPAD5 = new KeyID(76); // MS 0x4C UNIX 0xFFB5
public static final KeyID NUMPAD6 = new KeyID(77); // MS 0x4D UNIX 0xFFB6 RIGHT 0xFF98
public static final KeyID ADD = new KeyID(78); // MS 0x4E UNIX 0xFFAB
public static final KeyID NUMPAD1 = new KeyID(79); // MS 0x4F UNIX 0xFFB1 END 0xFF9C
public static final KeyID NUMPAD2 = new KeyID(80); // MS 0x50 UNIX 0xFFB2 DOWN 0xFF99
public static final KeyID NUMPAD3 = new KeyID(81); // MS 0x51 UNIX 0xFFB3 NEXT 0xFF9B
public static final KeyID NUMPAD0 = new KeyID(82); // MS 0x52 UNIX 0xFFB0 INSERT 0xFF9E
public static final KeyID DECIMAL = new KeyID(83); // MS 0x53 UNIX 0xFFAE DELETE 0xFF9F
public static final KeyID F11 = new KeyID(84); // MS 0x57 UNIX 0xFFC8
public static final KeyID F12 = new KeyID(85); // MS 0x58 UNIX 0xFFC9
public static final KeyID F13 = new KeyID(86); // MS 0x64 UNIX 0xFFCA
public static final KeyID F14 = new KeyID(87); // MS 0x65 UNIX 0xFFCB
public static final KeyID F15 = new KeyID(88); // MS 0x66 UNIX 0xFFCC
public static final KeyID KANA = new KeyID(89); // MS 0x70 UNIX 0xFF2D
public static final KeyID CONVERT = new KeyID(90); // MS 0x79 Japanese keyboard
public static final KeyID NOCONVERT = new KeyID(91); // MS 0x7B Japanese keyboard
public static final KeyID YEN = new KeyID(92); // MS 0x7D UNIX 0x0a5
public static final KeyID NUMPADEQUAL = new KeyID(93); // MS 0x8D UNIX 0xFFBD
public static final KeyID CIRCUMFLEX = new KeyID(94); // MS 0x90 Japanese keyboard
public static final KeyID AT = new KeyID(95); // MS 0x91 UNIX 0x040
public static final KeyID COLON = new KeyID(96); // MS 0x92 UNIX 0x03a
public static final KeyID UNDERLINE = new KeyID(97); // MS 0x93 NEC PC98
public static final KeyID KANJI = new KeyID(98); // MS 0x94 UNIX 0xFF21
public static final KeyID STOP = new KeyID(99); // MS 0x95 UNIX 0xFF69
public static final KeyID AX = new KeyID(100); // MS 0x96 Japan AX
public static final KeyID UNLABELED = new KeyID(101); // MS 0x97 J3100
public static final KeyID NUMPADENTER = new KeyID(102); // MS 0x9C UNIX 0xFF8D
public static final KeyID RCONTROL = new KeyID(103); // MS 0x9D UNIX 0xFFE4
public static final KeyID NUMPADCOMMA = new KeyID(104); // MS 0xB3 UNIX 0xFFAC
public static final KeyID DIVIDE = new KeyID(105); // MS 0xB5 UNIX 0xFFAF
public static final KeyID SYSRQ = new KeyID(106); // MS 0xB7 UNIX 0xFF15 PRINT 0xFF61
public static final KeyID RALT = new KeyID(107); // MS 0xB8 UNIX 0xFFEA
public static final KeyID PAUSE = new KeyID(108); // MS 0xC5 UNIX 0xFF13 BREAK 0xFF6B
public static final KeyID HOME = new KeyID(109); // MS 0xC7 UNIX 0xFF50
public static final KeyID UP = new KeyID(110); // MS 0xC8 UNIX 0xFF52
public static final KeyID PRIOR = new KeyID(111); // MS 0xC9 UNIX 0xFF55
public static final KeyID LEFT = new KeyID(112); // MS 0xCB UNIX 0xFF51
public static final KeyID RIGHT = new KeyID(113); // MS 0xCD UNIX 0xFF53
public static final KeyID END = new KeyID(114); // MS 0xCF UNIX 0xFF57
public static final KeyID DOWN = new KeyID(115); // MS 0xD0 UNIX 0xFF54
public static final KeyID NEXT = new KeyID(116); // MS 0xD1 UNIX 0xFF56
public static final KeyID INSERT = new KeyID(117); // MS 0xD2 UNIX 0xFF63
public static final KeyID DELETE = new KeyID(118); // MS 0xD3 UNIX 0xFFFF
public static final KeyID LWIN = new KeyID(119); // MS 0xDB UNIX META 0xFFE7 SUPER 0xFFEB HYPER 0xFFED
public static final KeyID RWIN = new KeyID(120); // MS 0xDC UNIX META 0xFFE8 SUPER 0xFFEC HYPER 0xFFEE
public static final KeyID APPS = new KeyID(121); // MS 0xDD UNIX 0xFF67
public static final KeyID POWER = new KeyID(122); // MS 0xDE Sun 0x1005FF76 SHIFT 0x1005FF7D
public static final KeyID SLEEP = new KeyID(123); // MS 0xDF No UNIX keysym
protected static final KeyID FIRST = VOID;
protected static final KeyID LAST = SLEEP;
} // class StandardKeyboard.KeyID
} // class StandardKeyboard

279
coreAPI/src/java/net/java/games/input/test/ControllerReadTest.java Normal file
View file

@ -0,0 +1,279 @@
/*
* ConrtollerReadTest.java
*
* Created on May 5, 2003, 3:15 PM
*/
/*****************************************************************************
* 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.test;
/**
*
* @author administrator
*/
import net.java.games.input.*;
import javax.swing.*;
import java.util.*;
import java.util.List;
import java.awt.*;
abstract class AxisPanel extends JPanel{
Axis axis;
float data;
public AxisPanel(Axis ax){
axis = ax;
setLayout(new BorderLayout());
add(new JLabel(ax.getName()+"("+ax.getIdentifier()+")"),
BorderLayout.NORTH);
}
public void poll(){
data = axis.getPollData();
renderData();
}
protected abstract void renderData();
}
class DigitalAxisPanel extends AxisPanel {
JLabel digitalState = new JLabel("<unread>");
public DigitalAxisPanel(Axis ax) {
super(ax);
add(digitalState,BorderLayout.CENTER);
}
protected void renderData(){
if (data == 0.0f){
digitalState.setBackground(getBackground());
digitalState.setText("OFF");
} else if ( data == 1.0f) {
digitalState.setBackground(Color.green);
digitalState.setText("ON");
}else { // shoudl never happen
digitalState.setBackground(Color.red);
digitalState.setText("ERR:"+data);
}
digitalState.repaint();
}
}
class DigitalHatPanel extends AxisPanel {
JLabel digitalState = new JLabel("<unread>");
public DigitalHatPanel(Axis ax) {
super(ax);
add(digitalState,BorderLayout.CENTER);
}
protected void renderData(){
if (data == Axis.POV.OFF){
digitalState.setBackground(getBackground());
digitalState.setText("OFF");
} else if ( data == Axis.POV.UP) {
digitalState.setBackground(Color.green);
digitalState.setText("UP");
} else if ( data == Axis.POV.RIGHT) {
digitalState.setBackground(Color.green);
digitalState.setText("RIGHT");
} else if ( data == Axis.POV.DOWN) {
digitalState.setBackground(Color.green);
digitalState.setText("DOWN");
} else if ( data == Axis.POV.LEFT) {
digitalState.setBackground(Color.green);
digitalState.setText("LEFT");
}else { // shoudl never happen
digitalState.setBackground(Color.red);
digitalState.setText("ERR:"+data);
}
digitalState.repaint();
}
}
class AnalogAxisPanel extends AxisPanel {
JLabel analogState = new JLabel("<unread>");
public AnalogAxisPanel(Axis ax) {
super(ax);
add(analogState,BorderLayout.CENTER);
}
protected void renderData(){
analogState.setText(""+data);
analogState.repaint();
}
}
class ControllerWindow extends JFrame {
Controller ca;
List axisList = new ArrayList();
boolean disabled = false;
public ControllerWindow(JFrame frame,Controller ca){
super(ca.getName());
this.setName(ca.getName());
this.ca = ca;
Container c = this.getContentPane();
c.setLayout(new BorderLayout());
Axis[] axis = ca.getAxes();
System.out.println("Axis count = "+axis.length);
if (axis.length>0) {
int width = (int)Math.ceil(Math.sqrt(axis.length));
JPanel p = new JPanel();
p.setLayout(new GridLayout(width,0));
for(int j=0;j<axis.length;j++){
addAxis(p,axis[j]);
}
c.add(new JScrollPane(p),BorderLayout.CENTER);
}
setSize(400,400);
setLocation(50,50);
setVisible(true);
}
public boolean disabled() {
return disabled;
}
private void setDisabled(boolean b){
disabled = b;
if (!disabled){
this.setTitle(ca.getName());
System.out.println(ca.getName()+" enabled");
} else {
this.setTitle(ca.getName()+" DISABLED!");
System.out.println(ca.getName()+" disabled");
}
repaint();
}
private void addAxis(JPanel p, Axis ax){
JPanel p2;
if (ax.isAnalog()) {
p2 = new AnalogAxisPanel(ax);
} else {
if (ax.getIdentifier() == Axis.Identifier.POV) {
p2 = new DigitalHatPanel(ax);
} else {
p2 = new DigitalAxisPanel(ax);
}
}
p.add(p2);
axisList.add(p2);
ax.setPolling(true);
}
public void poll(){
if (!ca.poll()) {
if (!disabled()){
setDisabled(true);
}
return;
}
if (disabled()){
setDisabled(false);
}
//System.out.println("Polled "+ca.getName());
for(Iterator i =axisList.iterator();i.hasNext();){
try {
((AxisPanel)i.next()).poll();
}catch (Exception e) {
e.printStackTrace();
}
}
}
}
public class ControllerReadTest extends JFrame{
static final long HEARTBEATMS =100; // 10th of a second
List controllers = new ArrayList();
/** Creates a new instance of ConrtollerReadTest */
public ControllerReadTest() {
super("Controller Read Test");
ControllerEnvironment ce = ControllerEnvironment.getDefaultEnvironment();
Controller[] ca = ce.getControllers();
for(int i =0;i<ca.length;i++){
makeController(ca[i]);
}
new Thread(new Runnable() {
public void run(){
try {
while(true){
for(Iterator i=controllers.iterator();i.hasNext();){
try {
ControllerWindow cw = (ControllerWindow)i.next();
cw.poll();
} catch (Exception e) {
e.printStackTrace();
}
}
Thread.sleep(HEARTBEATMS);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
pack();
setSize(400,400);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
private void makeController(Controller c) {
Controller[] subControllers = c.getControllers();
if (subControllers.length == 0 ) {
createControllerWindow(c);
} else {
for(int i=0;i<subControllers.length;i++){
makeController(subControllers[i]);
}
}
}
private void createControllerWindow(Controller c){
controllers.add(new ControllerWindow(this,c));
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new ControllerReadTest().setVisible(true);
}
}

89
coreAPI/src/java/net/java/games/input/test/ControllerTextTest.java Normal file
View file

@ -0,0 +1,89 @@
/*
* ControllerScanner.java
*
* Created on April 14, 2003, 3:45 PM
*/
/*****************************************************************************
* 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.test;
/**
*
* @author administrator
*/
import net.java.games.input.*;
public class ControllerTextTest {
ControllerEnvironment ce;
/** Creates a new instance of ControllerScanner */
public ControllerTextTest() {
ce = ControllerEnvironment.getDefaultEnvironment();
System.out.println("Controller Env = "+ce.toString());
Controller[] ca = ce.getControllers();
for(int i =0;i<ca.length;i++){
System.out.println(ca[i].getName());
System.out.println("Type: "+ca[i].getType().toString());
Axis[] axis = ca[i].getAxes();
System.out.println("Axis Count: "+axis.length);
for(int j=0;j<axis.length;j++){
System.out.println("Axis "+j+": "+axis[j].getName());
System.out.println(" Identifier: "+
axis[j].getIdentifier().getName());
System.out.print(" AxisType: ");
if (axis[j].isRelative()) {
System.out.print("Relative");
} else {
System.out.print("Absolute");
}
if (axis[j].isAnalog()) {
System.out.print(" Analog");
} else {
System.out.print(" Digital");
}
System.out.println();
}
System.out.println("---------------------------------");
}
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new ControllerTextTest();
}
}