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

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

15 files changed, 2776 insertions, 0 deletions

diff --git a/coreAPI/src/java/net/java/games/input/AbstractAxis.java b/coreAPI/src/java/net/java/games/input/AbstractAxis.java
new file mode 100644
index 0000000..b0fa021
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/AbstractAxis.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/AbstractController.java b/coreAPI/src/java/net/java/games/input/AbstractController.java
new file mode 100644
index 0000000..99ee2da
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/AbstractController.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/Axis.java b/coreAPI/src/java/net/java/games/input/Axis.java
new file mode 100644
index 0000000..a4abced
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/Axis.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/Controller.java b/coreAPI/src/java/net/java/games/input/Controller.java
new file mode 100644
index 0000000..ebf12ee
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/Controller.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/ControllerEnvironment.java b/coreAPI/src/java/net/java/games/input/ControllerEnvironment.java
new file mode 100644
index 0000000..d58ed4e
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/ControllerEnvironment.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/ControllerEvent.java b/coreAPI/src/java/net/java/games/input/ControllerEvent.java
new file mode 100644
index 0000000..14fbbcd
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/ControllerEvent.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/ControllerListener.java b/coreAPI/src/java/net/java/games/input/ControllerListener.java
new file mode 100644
index 0000000..8c58eff
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/ControllerListener.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/DefaultControllerEnvironment.java b/coreAPI/src/java/net/java/games/input/DefaultControllerEnvironment.java
new file mode 100644
index 0000000..e72aeae
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/DefaultControllerEnvironment.java
@@ -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]);
+        }
+    }
+}
diff --git a/coreAPI/src/java/net/java/games/input/Keyboard.java b/coreAPI/src/java/net/java/games/input/Keyboard.java
new file mode 100644
index 0000000..92361af
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/Keyboard.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/Mouse.java b/coreAPI/src/java/net/java/games/input/Mouse.java
new file mode 100644
index 0000000..6029834
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/Mouse.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/PluginClassLoader.java b/coreAPI/src/java/net/java/games/input/PluginClassLoader.java
new file mode 100644
index 0000000..13c580f
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/PluginClassLoader.java
@@ -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");
+        }
+    }
+}
+
diff --git a/coreAPI/src/java/net/java/games/input/Rumbler.java b/coreAPI/src/java/net/java/games/input/Rumbler.java
new file mode 100644
index 0000000..2d4c8b8
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/Rumbler.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/StandardKeyboard.java b/coreAPI/src/java/net/java/games/input/StandardKeyboard.java
new file mode 100644
index 0000000..5dc891a
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/StandardKeyboard.java
@@ -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
diff --git a/coreAPI/src/java/net/java/games/input/test/ControllerReadTest.java b/coreAPI/src/java/net/java/games/input/test/ControllerReadTest.java
new file mode 100644
index 0000000..15668bf
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/test/ControllerReadTest.java
@@ -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);
+    }
+    
+}
diff --git a/coreAPI/src/java/net/java/games/input/test/ControllerTextTest.java b/coreAPI/src/java/net/java/games/input/test/ControllerTextTest.java
new file mode 100644
index 0000000..8b59c8f
--- /dev/null
+++ b/coreAPI/src/java/net/java/games/input/test/ControllerTextTest.java
@@ -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();
+    }
+    
+}