git-svn-id: http://wiiusej.googlecode.com/svn/trunk@108 ae48ae66-6a45-0410-b38e-211266189506

WiiUseJ_0.1/.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

WiiUseJ_0.1/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>WiiUseJava</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

WiiUseJ_0.1/README.TXT

@@ -0,0 +1,38 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+ 
+ 
+WiiuseJ is a java API to use wiimotes on your computer. This API is built on top of an excellent API call Wiiuse using JNI.
+
+WiiuseJ intent to be a very simple, easy to use and lightweight java API for wiimotes.
+
+Some of the great aspects of this API are :
+
+    * The compatibility which is as large as Wiiuse's API compatibility 
+
+    * Cross-platform : Windows and linux (like Wiiuse) 
+
+    * Easy to use 
+    
+    
+WiiuseJ is made by Guilhem Duch<63> : guiguito1@hotmail.com.
+You can contact me if you need more information.    
+    
+Go to : http://wiiusej.googlecode.com/   for further documentations.    
+
+
+

WiiUseJ_0.1/src/wiiusej/WiiUseApi.java

@@ -0,0 +1,211 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej;
+
+import wiiusej.wiiuseapievents.EventsGatherer;
+
+/**
+ * Singleton used to manipulate WiiUse Api.
+ * @author guiguito
+ */
+public class WiiUseApi {
+	
+	static {
+		System.loadLibrary("libWiiuseJ");
+	}
+	
+	private static WiiUseApi instance = new WiiUseApi();
+	
+	/**
+	 * Get the only instance of WiiUseApi.
+	 * @return the only instace of WiiUseApi.
+	 */
+	static WiiUseApi getInstance(){
+		return instance;
+	}	
+
+	/**
+	 * Try to connect to 2 wiimotes. Make them rumble to show they are
+	 * connected.
+	 * @param nb number of wiimotes to connect
+	 * @return 0 if there is an error otherwise it returns the number of
+	 *         wiimotes connected.
+	 */	
+	native int doConnections(int nb);
+
+	/**
+	 * Close connection to the wiimote with the given id.
+	 * 
+	 */
+	native void closeConnection(int id);	
+	
+	/**
+	 * Shutdown Wiiuse API.
+	 */
+	native void shutdownApi();
+	
+	/**
+	 * Activate rumble on the wiimote with the given id.
+	 * @param id the id of the wiimote.
+	 */
+	native void activateRumble(int id);	
+	
+	/**
+	 * Deactivate rumble on the wiimote with the given id.
+	 * 
+	 * @param id the id of the wiimote.
+	 */
+	native void deactivateRumble(int id);		
+	
+	/**
+	 * Activate IR Tracking on the wiimote with the given id.
+	 * @param id the id of the wiimote.
+	 */
+	native void activateIRTracking(int id);
+	
+	/**
+	 * Deactivate IR Tracking on the wiimote with the given id.
+	 * @param id the id of the wiimote.
+	 */
+	native void deactivateIRTracking(int id);
+	
+	/**
+	 * Activate motion sensing on the wiimote with the given id.
+	 * @param id the id of the wiimote.
+	 */
+	native void activateMotionSensing(int id);
+	
+	/**
+	 * Deactivate motion sensing on the wiimote with the given id.
+	 * @param id the id of the wiimote.
+	 */
+	native void deactivateMotionSensing(int id);
+	 
+	/**
+	 * Set wiimote leds status.
+	 * @param id the id of the wiimote concerned
+	 * @param led1 status of led1: True=ON, False=OFF
+	 * @param led2 status of led2: True=ON, False=OFF
+	 * @param led3 status of led3: True=ON, False=OFF
+	 * @param led4 status of led4: True=ON, False=OFF
+	 */
+	native void setLeds(int id, boolean led1, boolean led2, boolean led3, boolean led4);
+	
+	/**
+	 * Set how many degrees an angle must change to generate an event.
+	 * @param id id of the wiimote concerned
+	 * @param angle minimum angle detected by an event
+	 */
+	native void setOrientThreshold(int id, float angle);
+	
+	/**
+	 * Set how much acceleration must change to generate an event.
+	 * @param id id of the wiimote concerned
+	 * @param value minimum value detected by an event
+	 */
+	native void setAccelThreshold(int id, int value);
+	
+	/**
+	 * Set alpha smoothing parameter for the given id.
+	 * @param id id of the wiimote concerned
+	 * @param value alpha smoothing value
+	 */
+	native void setAlphaSmoothing(int id, float value);
+	
+	/**
+	 * Try to resync with the wiimote by starting a new handshake.
+	 * @param id id of the wiimote concerned
+	 */
+	native void reSync(int id);
+	
+	/**
+	 * Make the the accelerometers give smoother results.
+	 * This is set by default.
+	 * @param id the id of the wiimote concerned
+	 */
+    native void activateSmoothing(int id);
+    
+    /**
+	 * Make the the accelerometers give raw results.
+	 * @param id the id of the wiimote concerned
+	 */
+    native void deactivateSmoothing(int id);
+    
+    /**
+     * Make the wiimote generate an event each time we poll.
+     * Not set by default.
+     * @param id the id of the wiimote concerned
+     */
+    native void activateContinuous(int id);
+    
+    /**
+     * Make the wiimote generate an event only when there is one.
+     * @param id the id of the wiimote concerned
+     */
+    native void deactivateContinuous(int id);
+        
+    /**
+     * Notify wiiuse that your screen has an aspect ratio of 4/3.
+     * @param id the id of the wiimote of which we want the status.
+     */
+    native void setScreenRatio43(int id);
+    
+    /**
+     * Notify wiiuse that your screen has an aspect ratio of 16/9.
+     * @param id the id of the wiimote of which we want the status.
+     */
+    native void setScreenRatio169(int id);
+    
+    /**
+     * Notify wiiuse that the sensor bar is above your screen.
+     * @param id the id of the wiimote of which we want the status.
+     */
+    native void setSensorBarAboveScreen(int id);
+    
+    /**
+     * Notify wiiuse that the sensor bar is below your screen.
+     * @param id the id of the wiimote of which we want the status.
+     */
+    native void setSensorBarBelowScreen(int id);
+        
+    /**
+     * Set virtual screen resolution. It is used to automatically 
+     * compute the position of a cursor on this virtual screen
+     *  using the sensor bar. These results come in the IREvent.
+     * @param id the id of the wiimote of which we want the status.
+     * @param x x resolution.
+     * @param y y resolution.
+     */
+    native void setVirtualScreenResolution(int id, int x, int y);
+	
+	/**
+	 * Get status and values from the wiimotes and send it through callbacks.
+	 * 
+	 * @param id the id of the wiimote of which we want the status.
+	 */
+	native void getStatus(int id);	
+	
+	/**
+	 * Check for new Events and Get it.
+	 * 
+	 * @param gath the object where we store all the new events.
+	 */
+	native void specialPoll(EventsGatherer gath);
+	
+		
+
+}

WiiUseJ_0.1/src/wiiusej/WiiUseApiManager.java

@@ -0,0 +1,567 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej;
+
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.swing.event.EventListenerList;
+
+import wiiusej.wiiuseapievents.EventsGatherer;
+import wiiusej.wiiuseapievents.WiiUseApiEvent;
+import wiiusej.wiiuseapievents.WiiUseApiListener;
+import wiiusej.wiiuseapirequest.FloatValueRequest;
+import wiiusej.wiiuseapirequest.IntValueRequest;
+import wiiusej.wiiuseapirequest.LedsRequest;
+import wiiusej.wiiuseapirequest.TwoIntValueRequest;
+import wiiusej.wiiuseapirequest.WiiUseApiRequest;
+
+/**
+ * Class that manages the use of Wiiuse API.
+ * 
+ * @author guiguito
+ */
+public class WiiUseApiManager extends Thread {
+
+	private static WiiUseApiManager instance = new WiiUseApiManager();
+
+	private final EventListenerList listeners = new EventListenerList();
+
+	private Wiimote[] wiimotes;
+
+	private WiiUseApi wiiuse = WiiUseApi.getInstance();
+
+	private int connected = -1;
+
+	private int nbMaxWiimotes = -1;
+
+	private AtomicBoolean running = new AtomicBoolean(false);
+
+	private ConcurrentLinkedQueue<WiiUseApiRequest> requests = new ConcurrentLinkedQueue<WiiUseApiRequest>();
+
+	public static WiiUseApiManager getInstance() {
+		return instance;
+	}
+
+	/**
+	 * Get wiimotes. Load library if necessary. Connect to wiimotes if
+	 * necessary. Start polling if necessary. Return an array with the connected
+	 * wiimotes.
+	 * 
+	 * @param nb
+	 *            try to connect nb wiimotes
+	 * @return an array with connected wiimotes or NULL.
+	 */
+	public synchronized static Wiimote[] getWiimotes(int nb) {
+		WiiUseApiManager manager = getInstance();
+		if (manager.connected < 0) {
+			int nbWiimotes = manager.connectWiimotes(nb);
+			manager.wiimotes = new Wiimote[nbWiimotes];
+			for (int i = 1; i <= nbWiimotes; i++) {
+				Wiimote wim = new Wiimote(i, manager);
+				manager.wiimotes[i - 1] = wim;
+				manager.addWiiUseApiListener(wim);
+			}
+		}
+
+		if (manager.connected == 0) {
+			return new Wiimote[0];
+		}
+
+		if (!manager.isAlive())
+			manager.start();
+
+		return manager.wiimotes;
+	}
+
+	/**
+	 * Connect wiimote and get the number of wiimotes connected. Supposed to be
+	 * used once.
+	 * 
+	 * @param nb
+	 *            try to connect nb wiimotes
+	 * @return 0 if nothing connected or the number of wiimotes connected.
+	 */
+	private int connectWiimotes(int nb) {
+		nbMaxWiimotes = nb;
+		if (connected < 0) {
+			connected = wiiuse.doConnections(nb);
+			return connected;
+		} else {// library not loaded, no wiimotes connected
+			return 0;
+		}
+	}
+
+	/**
+	 * Ask the thread to close a connection.
+	 * 
+	 * @param id
+	 *            id of the wiimote to disconnect.
+	 */
+	public void closeConnection(int id) {
+		removeWiiUseApiListener(wiimotes[id - 1]);
+		wiimotes[id - 1] = null;
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_CLOSE_CONNECTION_REQUEST));
+		// System.out.println("Wiimote " + id + " disconnected !");
+	}
+
+	/**
+	 * Get the number of wiimotes connected.
+	 * 
+	 * @return the number of wiimotes connected.
+	 */
+	public int getNbConnectedWiimotes() {
+		return connected;
+	}
+
+	/**
+	 * Stop thread and shutdown wiiuse Api.
+	 */
+	public void shutdown() {
+		if (connected > 0) {
+			for (Wiimote wim : wiimotes) {
+				if (wim != null)
+					wim.disconnect();
+			}
+		}
+		running.set(false);
+		wiiuse.shutdownApi();
+	}
+
+	/**
+	 * Activate the rumble for the wiimote with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void activateRumble(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_ACTIVATE_RUMBLE_REQUEST));
+	}
+
+	/**
+	 * Deactivate the rumble for the wiimote with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void deactivateRumble(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_DEACTIVATE_RUMBLE_REQUEST));
+	}
+
+	/**
+	 * Activate IR Tracking for the wiimote with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void activateIRTRacking(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_ACTIVATE_IR_TRACKING_REQUEST));
+	}
+
+	/**
+	 * Deactivate IR Tracking for the wiimote with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void deactivateIRTRacking(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_DEACTIVATE_IR_TRACKING_REQUEST));
+	}
+
+	/**
+	 * Activate motion sensing for the wiimote with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void activateMotionSensing(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_ACTIVATE_MOTION_SENSING_REQUEST));
+	}
+
+	/**
+	 * Deactivate motion sensing for the wiimoter with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void deactivateMotionSensing(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_DEACTIVATE_MOTION_SENSING_REQUEST));
+	}
+
+	/**
+	 * Activate smoothing the wiimotes with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void activateSmoothing(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_ACTIVATE_SMOOTHING_REQUEST));
+	}
+
+	/**
+	 * Deactivate smoothing the wiimotes with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void deactivateSmoothing(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_DEACTIVATE_SMOOTHING_REQUEST));
+	}
+
+	/**
+	 * Activate continuous for the wiimotes with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 */
+	public void activateContinuous(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_ACTIVATE_CONTINUOUS_REQUEST));
+	}
+
+	/**
+	 * Deactivate continuous for the wiimotes with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void deactivateContinuous(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_DEACTIVATE_CONTINUOUS_REQUEST));
+	}
+
+	/**
+	 * Set leds for the wiimotes with the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 * @param l1
+	 *            status of led1. True : ON, False : OFF
+	 * @param l2
+	 *            status of led2. True : ON, False : OFF
+	 * @param l3
+	 *            status of led3. True : ON, False : OFF
+	 * @param l4
+	 *            status of led4. True : ON, False : OFF
+	 */
+	public void setLeds(int id, boolean l1, boolean l2, boolean l3, boolean l4) {
+		requests.add(new LedsRequest(id, WiiUseApiRequest.WIIUSE_LEDS_REQUEST,
+				l1, l2, l3, l4));
+	}
+
+	/**
+	 * Set the orientation threshold for the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 * @param th
+	 *            threshold in degrees
+	 */
+	public void setOrientationThreshold(int id, float th) {
+		requests.add(new FloatValueRequest(id,
+				WiiUseApiRequest.WIIUSE_ORIENT_THRESHOLHD_REQUEST, th));
+	}
+
+	/**
+	 * Set the acceleration threshold for the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 * @param th
+	 *            threshold
+	 */
+	public void setAccelerationThreshold(int id, int th) {
+		requests.add(new IntValueRequest(id,
+				WiiUseApiRequest.WIIUSE_ACCEL_THRESHOLHD_REQUEST, th));
+	}
+
+	/**
+	 * Set alpha smoothing for the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 * @param th
+	 *            threshold
+	 */
+	public void setAlphaSmoothing(int id, float th) {
+		requests.add(new FloatValueRequest(id,
+				WiiUseApiRequest.WIIUSE_ALPHA_SMOOTHING_REQUEST, th));
+	}
+
+	/**
+	 * Try to resync with the wiimote by starting a new handshake.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void reSync(int id) {
+		requests.add(new WiiUseApiRequest(id, WiiUseApiRequest.WIIUSE_RESYNC));
+	}
+
+	/**
+	 * Set screen aspect ratio to 4/3 for the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void setScreenAspectRatio43(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_ASPECT_RATIO_4_3));
+	}
+
+	/**
+	 * Set screen aspect ratio to 16/9 for the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void setScreenAspectRatio169(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_ASPECT_RATIO_16_9));
+	}
+
+	/**
+	 * Set the sensor bar to be above the screen.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void setSensorBarAboveScreen(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_SENSOR_BAR_ABOVE));
+	}
+
+	/**
+	 * Set the sensor bar to be below the screen.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void setSensorBarBelowScreen(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_SENSOR_BAR_BELOW));
+	}
+
+	/**
+	 * Set virtual resolution. It is used to automatically compute the position
+	 * of a cursor on this virtual screen using the sensor bar. These results
+	 * come in the IREvent.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 * @param x
+	 *            x resolution
+	 * @param y
+	 *            y resolution
+	 */
+	public void setVirtualResolution(int id, int x, int y) {
+		requests.add(new TwoIntValueRequest(id,
+				WiiUseApiRequest.WIIUSE_SET_VIRTUAL_RESOLUTION, x, y));
+	}
+
+	/**
+	 * Get Status for the wiimote for the given id.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void getStatus(int id) {
+		requests.add(new WiiUseApiRequest(id,
+				WiiUseApiRequest.WIIUSE_STATUS_REQUEST));
+	}
+
+	@Override
+	public void run() {
+
+		if (connected > 0) {
+			running.set(true);
+
+			EventsGatherer gather = new EventsGatherer(nbMaxWiimotes);
+
+			// Start polling and tell the observers when there Wiimote events
+			while (running.get() && connected > 0) {
+
+				/* Polling */
+				wiiuse.specialPoll(gather);
+
+				/* deal with events gathered in Wiiuse API */
+				for (WiiUseApiEvent evt : gather.getEvents()) {
+					if (evt.getWiimoteId() != -1) {// event filled
+						// there is an event notify observers
+						notifyWiiUseApiListener(evt);
+						if (evt.getEventType() == WiiUseApiEvent.DISCONNECTION_EVENT) {
+							// check if it was a disconnection
+							// in this case disconnect the wiimote
+							closeConnection(evt.getWiimoteId());
+						}
+					} else {
+						System.out
+								.println("There is an event with id == -1 ??? there is a problem !!! : "
+										+ evt);
+					}
+				}
+				gather.clearEvents();
+
+				/* deal with request done to wiiuse API */
+				WiiUseApiRequest req = requests.poll();
+				if (req != null) {// there is a request for the wiiuse api
+					int id = req.getId();
+					if (req.getRequestType() == WiiUseApiRequest.WIIUSE_CLOSE_CONNECTION_REQUEST) {
+						/* Close connections requests */
+						wiiuse.closeConnection(id);
+
+						connected--;
+						if (connected == 0) {// stop this thread if there is
+							// no more wiimotes connected.
+							// System.out.println("No more wiimotes connected
+							// !!!");
+							shutdown();
+						}
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_STATUS_REQUEST) {
+						/* Status requests */
+						wiiuse.getStatus(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ACTIVATE_RUMBLE_REQUEST) {
+						/* Activate Rumble requests */
+						wiiuse.activateRumble(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_DEACTIVATE_RUMBLE_REQUEST) {
+						/* Deactivate Rumble requests */
+						wiiuse.deactivateRumble(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ACTIVATE_IR_TRACKING_REQUEST) {
+						/* Activate IR Tracking requests */
+						wiiuse.activateIRTracking(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_DEACTIVATE_IR_TRACKING_REQUEST) {
+						/* Deactivate IR Tracking requests */
+						wiiuse.deactivateIRTracking(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ACTIVATE_MOTION_SENSING_REQUEST) {
+						/* Activate Motion sensing requests */
+						wiiuse.activateMotionSensing(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_DEACTIVATE_MOTION_SENSING_REQUEST) {
+						/* Deactivate Motion sensing requests */
+						wiiuse.deactivateMotionSensing(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_LEDS_REQUEST) {
+						/* leds requests */
+						LedsRequest reqLed = (LedsRequest) req;
+						wiiuse.setLeds(id, reqLed.isLed1(), reqLed.isLed2(),
+								reqLed.isLed3(), reqLed.isLed4());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ACTIVATE_SMOOTHING_REQUEST) {
+						/* Activate smoothing requests */
+						wiiuse.activateSmoothing(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_DEACTIVATE_SMOOTHING_REQUEST) {
+						/* Deactivate smoothing requests */
+						wiiuse.deactivateSmoothing(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ACTIVATE_CONTINUOUS_REQUEST) {
+						/* Activate continuous requests */
+						wiiuse.activateContinuous(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_DEACTIVATE_CONTINUOUS_REQUEST) {
+						/* Deactivate continuous requests */
+						wiiuse.deactivateContinuous(id);
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ORIENT_THRESHOLHD_REQUEST) {
+						/* set orientation threshold request */
+						wiiuse.setOrientThreshold(req.getId(),
+								((FloatValueRequest) req).getFloatValue());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ACCEL_THRESHOLHD_REQUEST) {
+						/* set acceleration threshold request */
+						wiiuse.setAccelThreshold(req.getId(),
+								((IntValueRequest) req).getIntValue());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ALPHA_SMOOTHING_REQUEST) {
+						/* set alpha smoothing request */
+						wiiuse.setAlphaSmoothing(req.getId(),
+								((FloatValueRequest) req).getFloatValue());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_RESYNC) {
+						/* set resync request */
+						wiiuse.reSync(req.getId());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ASPECT_RATIO_4_3) {
+						/* set screen aspect ratio to 4/3 */
+						wiiuse.setScreenRatio43(req.getId());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_ASPECT_RATIO_16_9) {
+						/* set screen aspect ratio to 16/9 */
+						wiiuse.setScreenRatio169(req.getId());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_SENSOR_BAR_ABOVE) {
+						/* set sensor bar above the screen */
+						wiiuse.setSensorBarAboveScreen(req.getId());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_SENSOR_BAR_BELOW) {
+						/* set sensor bar above the screen */
+						wiiuse.setSensorBarBelowScreen(req.getId());
+					} else if (req.getRequestType() == WiiUseApiRequest.WIIUSE_SET_VIRTUAL_RESOLUTION) {
+						/* set virtual resolution */
+						wiiuse.setVirtualScreenResolution(req.getId(),
+								((TwoIntValueRequest) req).getIntValue(),
+								((TwoIntValueRequest) req).getSecondIntValue());
+					} else {
+						System.out.println("Bad request to Wiiuse API !!!!!");
+					}
+				}
+			}
+		} else {
+			if (connected <= 0) {
+				System.out.println("No wiimotes connected !");
+			}
+		}
+
+	}
+
+	/**
+	 * Add WiiUseApiListener to the listeners list.
+	 * 
+	 * @param listener
+	 *            a WiiUseApiListener
+	 */
+	public void addWiiUseApiListener(WiiUseApiListener listener) {
+		listeners.add(WiiUseApiListener.class, listener);
+	}
+
+	/**
+	 * Remove WiiUseApiListener from the listeners list.
+	 * 
+	 * @param listener
+	 *            a WiiUseApiListener
+	 */
+	public void removeWiiUseApiListener(WiiUseApiListener listener) {
+		listeners.remove(WiiUseApiListener.class, listener);
+	}
+
+	/**
+	 * Get the list of WiiUseApiListeners.
+	 * 
+	 * @return the list of WiiUseApiListeners.
+	 */
+	public WiiUseApiListener[] getWiiUseApiListeners() {
+		return listeners.getListeners(WiiUseApiListener.class);
+	}
+
+	/**
+	 * Notify WiiUseApiListeners that an event occured.
+	 * 
+	 * @param evt
+	 *            WiimoteEvent occured
+	 */
+	private void notifyWiiUseApiListener(WiiUseApiEvent evt) {
+		for (WiiUseApiListener listener : getWiiUseApiListeners()) {
+			listener.onWiiUseApiEvent(evt);
+		}
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/Wiimote.java

@@ -0,0 +1,323 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej;
+
+import javax.swing.event.EventListenerList;
+
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.GenericEvent;
+import wiiusej.wiiuseapievents.WiiUseApiEvent;
+import wiiusej.wiiuseapievents.WiiUseApiListener;
+import wiiusej.wiiuseapievents.WiimoteListener;
+import wiiusej.wiiuseapirequest.WiiUseApiRequest;
+
+/**
+ * Class that represents a wiimote.
+ * You can register as an observer of this wiimote to listen events from it.
+ * You manage it.
+ * @author guiguito
+ */
+public class Wiimote implements WiiUseApiListener {
+
+	private int id = -1;//wiimote id
+	
+	private EventListenerList listeners = new EventListenerList();
+	
+	private WiiUseApiManager manager;
+	
+	
+	/**
+	 * Constructor.
+	 * @param idd id of the wiimote
+	 * @param manager manager wo built it.
+	 */
+	public Wiimote(int idd, WiiUseApiManager manager){
+		id = idd;
+		this.manager = manager;
+	}
+	
+	/**
+	 * Disconnect this wiimote.
+	 */
+	public void disconnect(){
+		deactivateIRTRacking();
+		deactivateMotionSensing();
+		deactivateRumble();
+		manager.closeConnection(id);
+	}
+	
+	/**
+	 * Activate the rumble.
+	 */
+	public void activateRumble() {
+		manager.activateRumble(id);
+	}
+
+	/**
+	 * Deactivate the rumble.
+	 */
+	public void deactivateRumble() {
+		manager.deactivateRumble(id);
+	}
+	
+	/**
+	 * Activate IR Tracking.
+	 */
+	public void activateIRTRacking() {
+		manager.activateIRTRacking(id);
+	}
+
+	/**
+	 * Deactivate IR Tracking.
+	 */
+	public void deactivateIRTRacking() {
+		manager.deactivateIRTRacking(id);
+	}
+	
+	/**
+	 * Activate motion sensing.
+	 */
+	public void activateMotionSensing() {
+		manager.activateMotionSensing(id);
+	}
+
+	/**
+	 * Deactivate motion sensing.
+	 */
+	public void deactivateMotionSensing() {
+		manager.deactivateMotionSensing(id);
+	}
+	
+	/**
+	 * Activate smoothing.
+	 */
+	public void activateSmoothing() {
+		manager.activateSmoothing(id);
+	}
+
+	/**
+	 * Deactivate smoothing.
+	 */
+	public void deactivateSmoothing() {
+		manager.deactivateSmoothing(id);
+	}
+
+	/**
+	 * Activate continuous.
+	 */
+	public void activateContinuous() {
+		manager.activateContinuous(id);
+	}
+
+	/**
+	 * Deactivate continuous.
+	 */
+	public void deactivateContinuous() {
+		manager.deactivateContinuous(id);
+		
+	}
+	
+	/**
+	 * Set leds status.
+	 * 
+	 * @param l1
+	 *            status of led1. True : ON, False : OFF
+	 * @param l2
+	 *            status of led2. True : ON, False : OFF
+	 * @param l3
+	 *            status of led3. True : ON, False : OFF
+	 * @param l4
+	 *            status of led4. True : ON, False : OFF
+	 */
+	public void setLeds(boolean l1, boolean l2, boolean l3, boolean l4) {
+		manager.setLeds(id, l1, l2, l3, l4);
+	}
+
+	/**
+	 * Set the orientation threshold (minimum angle between two degrees with accelerometer).
+	 * @param th
+	 *            threshold in degrees
+	 */
+	public void setOrientationThreshold(float th) {
+		manager.setOrientationThreshold(id,th);
+	}
+	
+	/**
+	 * Set the acceleration threshold .
+	 * @param th
+	 *            threshold
+	 */
+	public void setAccelerationThreshold(int th) {
+		manager.setAccelerationThreshold(id,th);
+	}
+	
+	/**
+	 * Set the alpha smoothing value.
+	 * @param th
+	 *            threshold
+	 */
+	public void setAlphaSmoothingValue(float th) {
+		manager.setAlphaSmoothing(id,th);
+	}
+	
+	/**
+	 * Set the screen aspect ratio to be considered as 4/3.
+	 */
+	public void setScreenAspectRatio43() {
+		manager.setScreenAspectRatio43(id);
+	}
+	
+	/**
+	 * Set the screen aspect ratio to be considered as 16/9.
+	 */
+	public void setScreenAspectRatio169() {
+		manager.setScreenAspectRatio169(id);
+	}
+	
+	/**
+	 * Set the sensor bar to be considered above the screen.
+	 */
+	public void setSensorBarAboveScreen() {
+		manager.setSensorBarAboveScreen(id);
+	}
+	
+	/**
+	 * Set the sensor bar to be considered below the screen.
+	 */
+	public void setSensorBarBelowScreen() {
+		manager.setSensorBarBelowScreen(id);
+	}
+	
+	/**
+	 * Set the screen resolution of the you are pointing at 
+	 * with your wiimote.
+	 * 
+	 * @param x x resolution.
+	 * @param y y resolution.
+	 */
+	public void setVirtualResolution(int x, int y) {
+		manager.setVirtualResolution(id, x ,y);
+	}
+
+	/**
+	 * Try to resync the wiimote by starting a new handshake.
+	 */
+	public void reSync() {
+		manager.reSync(id);
+	}
+
+	/**
+	 * Ask for the status of the wiimote.
+	 * The result will be received in a status event object.
+	 * Implements onStatusEvent on wiimote listener to get it.
+	 */
+	public void getStatus() {
+		manager.getStatus(id);
+	}
+	
+	/**
+	 * Method called when a WiiUseApiEvent occurs.
+	 * @param e the WiiUseApiEvent.
+	 */
+	public void onWiiUseApiEvent(WiiUseApiEvent e) {
+		if (e.getWiimoteId() == id){			
+			if (e.getEventType() == WiiUseApiEvent.GENERIC_EVENT){
+				notifyWiiMoteEventListeners((GenericEvent)e);
+			}else if (e.getEventType() == WiiUseApiEvent.STATUS_EVENT
+					||e.getEventType() == WiiUseApiEvent.WIIUSE_NUNCHUK_INSERTED
+					||e.getEventType() == WiiUseApiEvent.WIIUSE_NUNCHUK_REMOVED
+					||e.getEventType() == WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_INSERTED
+					||e.getEventType() == WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_REMOVED
+					||e.getEventType() == WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_INSERTED
+					||e.getEventType() == WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_REMOVED){
+				notifyStatusEventListeners((StatusEvent)e);
+			}else if (e.getEventType() == WiiUseApiEvent.DISCONNECTION_EVENT){
+				notifyDisconnectionEventListeners((DisconnectionEvent)e);
+			}			
+		}		
+	}	
+	
+	/**
+	 * Add a WiimoteListener to the listeners list.
+	 * @param listener a WiimoteListener
+	 */
+	public void addWiiMoteEventListeners(WiimoteListener listener) {
+		listeners.add(WiimoteListener.class, listener);
+	}
+
+	/**
+	 * Remove a WiimoteListener from the listeners list.
+	 * @param listener a WiimoteListener
+	 */
+	public void removeWiiMoteEventListeners(WiimoteListener listener) {
+		listeners.remove(WiimoteListener.class, listener);
+	}
+
+	/**
+	 * Get the list of WiimoteListener.
+	 * @return the list of WiimoteListener.
+	 */
+	public WiimoteListener[] getWiiMoteEventListeners() {
+		return listeners.getListeners(WiimoteListener.class);
+	}
+
+	/**
+	 * Notify WiimoteListeners that an event occured.
+	 * Notify in first the listeners for Buttons Events.
+	 * In second the listeners for IR Events.
+	 * In third the listeners for Motion sensing events.
+	 * @param evt WiimoteEvent occured
+	 */
+	private void notifyWiiMoteEventListeners(GenericEvent evt) {		
+		for (WiimoteListener listener : getWiiMoteEventListeners()) {			
+			listener.onButtonsEvent(evt.getButtonsEvent());
+			if (evt.isThereIrEvent()){
+				listener.onIrEvent(evt.getIREvent());				
+			}
+			if (evt.isThereMotionSensingEvent()){
+				listener.onMotionSensingEvent(evt.getMotionSensingEvent());				
+			}
+		}
+	}
+	
+	/**
+	 * Notify WiimoteListener that a status event occured.
+	 * @param evt status event occured
+	 */
+	private void notifyStatusEventListeners(StatusEvent evt) {		
+		for (WiimoteListener listener : getWiiMoteEventListeners()) {			
+			listener.onStatusEvent(evt);
+		}
+	}
+	
+	/**
+	 * Notify WiimoteListener that a status event occured.
+	 * @param evt status event occured
+	 */
+	private void notifyDisconnectionEventListeners(DisconnectionEvent evt) {		
+		for (WiimoteListener listener : getWiiMoteEventListeners()) {			
+			listener.onDisconnectionEvent(evt);
+		}
+	}
+	
+	@Override
+	public String toString() {		
+		return "Wiimote with ID : "+id;
+	}	
+
+}

WiiUseJ_0.1/src/wiiusej/test/CloseGuiTestCleanly.java

@@ -0,0 +1,65 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.test;
+
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import wiiusej.WiiUseApiManager;
+import wiiusej.Wiimote;
+
+/**
+ * This class is used to close wiiusej cleanly.
+ * @author guiguito
+ */
+public class CloseGuiTestCleanly implements WindowListener{
+
+    Wiimote wiimote;
+    
+    
+    public CloseGuiTestCleanly(Wiimote wim) {
+        wiimote = wim;
+    }
+
+    public void windowOpened(WindowEvent e) {
+        //nothing
+    }
+
+    public void windowClosing(WindowEvent e) {
+        WiiUseApiManager.getInstance().shutdown();
+    }
+
+    public void windowClosed(WindowEvent e) {
+       //nothing
+    }
+
+    public void windowIconified(WindowEvent e) {
+        //nothing
+    }
+
+    public void windowDeiconified(WindowEvent e) {
+       //nothing
+    }
+
+    public void windowActivated(WindowEvent e) {
+        //nothing
+    }
+
+    public void windowDeactivated(WindowEvent e) {
+        //nothing
+    }
+ 
+}

WiiUseJ_0.1/src/wiiusej/test/Main.java

@@ -0,0 +1,40 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.test;
+
+import wiiusej.WiiUseApiManager;
+import wiiusej.Wiimote;
+
+/**
+ * Main Class to launch WiiuseJ GUI Test.
+ * @author guiguito
+ */
+public class Main {
+
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) {
+        Wiimote[] wiimotes = WiiUseApiManager.getWiimotes(1);
+        if (wiimotes.length>0){
+            WiiuseJGuiTest gui = new WiiuseJGuiTest(wiimotes[0]);
+            gui.setDefaultCloseOperation(gui.EXIT_ON_CLOSE);
+            gui.setVisible(true);
+        }
+    }
+
+}

WiiUseJ_0.1/src/wiiusej/test/Tests.java

@@ -0,0 +1,354 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.test;
+
+import java.awt.AWTException;
+import java.awt.Robot;
+import java.awt.event.InputEvent;
+
+import wiiusej.WiiUseApiManager;
+import wiiusej.Wiimote;
+import wiiusej.values.IRSource;
+import wiiusej.wiiuseapievents.ButtonsEvent;
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.IREvent;
+import wiiusej.wiiuseapievents.MotionSensingEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.GenericEvent;
+import wiiusej.wiiuseapievents.WiimoteListener;
+
+/**
+ * This class used to test WiiuseJ.
+ * 
+ * @author guiguito
+ */
+public class Tests implements WiimoteListener {
+
+	Robot robot;
+
+	private static int DISPLAY_EACH_VALUE = 1;
+	private static int DUMP = 2;
+	private static int MOVE_MOUSE = 3;
+	private static int TEST_LEDS = 5;
+
+	private Wiimote wiimote;
+
+	int dump = DISPLAY_EACH_VALUE;
+
+	public Tests(Wiimote wim) {
+		wiimote = wim;
+		wiimote.addWiiMoteEventListeners(this);
+		try {
+			robot = new Robot();
+		} catch (AWTException e) {
+			e.printStackTrace();
+		}
+	}
+
+	private static int nb = 0;
+
+	public void onButtonsEvent(ButtonsEvent e) {
+		if (dump == DISPLAY_EACH_VALUE) {
+			// System.out.println("*********** WIIMOTE ID : "+
+			// e.getWiimoteId() + " **************");
+			/* button ONE */
+			if (e.isButtonOneJustPressed()) {
+				System.out.println("button one pressed");
+			}
+			if (e.isButtonOneHeld()) {
+				System.out.println("button one held");
+			}
+			if (e.isButtonOneJustReleased()) {
+				System.out.println("button one released");
+			}
+
+			/* button TWO */
+			if (e.isButtonTwoJustPressed()) {
+				System.out.println("button two pressed");
+			}
+			if (e.isButtonTwoHeld()) {
+				System.out.println("button two held");
+			}
+			if (e.isButtonTwoJustReleased()) {
+				System.out.println("button two released");
+			}
+
+			/* button A */
+			if (e.isButtonAJustPressed()) {
+				System.out.println("button A pressed");
+			}
+			if (e.isButtonAHeld()) {
+				System.out.println("button A held");
+			}
+			if (e.isButtonAJustReleased()) {
+				System.out.println("button A released");
+			}
+
+			/* button B */
+			if (e.isButtonBJustPressed()) {
+				System.out.println("button B pressed");
+			}
+			if (e.isButtonBHeld()) {
+				System.out.println("button B held");
+			}
+			if (e.isButtonBJustReleased()) {
+				System.out.println("button B released");
+			}
+
+			/* button LEFT */
+			if (e.isButtonLeftJustPressed()) {
+				System.out.println("button Left pressed");
+			}
+			if (e.isButtonLeftHeld()) {
+				System.out.println("button Left held");
+			}
+			if (e.isButtonLeftJustReleased()) {
+				System.out.println("button Left released");
+			}
+
+			/* button RIGHT */
+			if (e.isButtonRightJustPressed()) {
+				System.out.println("button Right pressed");
+			}
+			if (e.isButtonRightHeld()) {
+				System.out.println("button Right held");
+			}
+			if (e.isButtonRightJustReleased()) {
+				System.out.println("button Right released");
+			}
+
+			/* button UP */
+			if (e.isButtonUpJustPressed()) {
+				System.out.println("button UP pressed");
+			}
+			if (e.isButtonUpHeld()) {
+				System.out.println("button UP held");
+			}
+			if (e.isButtonUpJustReleased()) {
+				System.out.println("button UP released");
+			}
+
+			/* button DOWN */
+			if (e.isButtonDownJustPressed()) {
+				System.out.println("button DOWN pressed");
+			}
+			if (e.isButtonDownHeld()) {
+				System.out.println("button DOWN held");
+			}
+			if (e.isButtonDownJustReleased()) {
+				System.out.println("button DOWN released");
+			}
+
+			/* button MINUS */
+			if (e.isButtonMinusJustPressed()) {
+				System.out.println("button MINUS pressed");
+			}
+			if (e.isButtonMinusHeld()) {
+				System.out.println("button MINUS held");
+			}
+			if (e.isButtonMinusJustReleased()) {
+				System.out.println("button MINUS released");
+			}
+
+			/* button PLUS */
+			if (e.isButtonPlusJustPressed()) {
+				System.out.println("button PLUS pressed");
+			}
+			if (e.isButtonPlusHeld()) {
+				System.out.println("button PLUS held");
+			}
+			if (e.isButtonPlusJustReleased()) {
+				System.out.println("button PLUS released");
+			}
+
+			/* button HOME */
+			if (e.isButtonHomeJustPressed()) {
+				System.out.println("button HOME pressed");
+			}
+			if (e.isButtonHomeHeld()) {
+				System.out.println("button HOME held");
+			}
+			if (e.isButtonHomeJustReleased()) {
+				System.out.println("button HOME released");
+			}
+
+			/* get status */
+			if (e.isButtonUpJustPressed()) {
+				wiimote.getStatus();
+			}
+
+			/* Activate rumble */
+			if (e.isButtonOneJustPressed()) {
+				System.out.println("Rumble Activated");
+				wiimote.activateRumble();
+			}
+			if (e.isButtonTwoJustPressed()) {
+				System.out.println("Rumble Deactivated");
+				wiimote.deactivateRumble();
+			}
+
+			/* Activate IR Tracking */
+			if (e.isButtonAJustPressed()) {
+				System.out.println("IR Activated");
+				wiimote.activateIRTRacking();
+			}
+			if (e.isButtonBJustPressed()) {
+				System.out.println("IR Deactivated");
+				wiimote.deactivateIRTRacking();
+			}
+
+			/* Activate Motion sensing */
+			if (e.isButtonPlusJustPressed()) {
+				System.out.println("Motion sensing Activated");
+				wiimote.activateMotionSensing();
+			}
+			if (e.isButtonMinusJustPressed()) {
+				System.out.println("Motion sensing Deactivated");
+				wiimote.deactivateMotionSensing();
+			}
+
+			/* leave test */
+			if (e.isButtonHomeJustPressed()) {
+				System.out.println("LEAVING TEST");
+				wiimote.disconnect();
+			}
+
+		} else if (dump == DUMP) {
+			System.out.println(e);
+			/* Activate all */
+			if (e.isButtonAJustPressed()) {
+				System.out.println("IR, rumble and motion sensing Activated");
+				wiimote.activateIRTRacking();
+				wiimote.activateMotionSensing();
+				wiimote.activateRumble();
+			}
+			if (e.isButtonBJustPressed()) {
+				System.out.println("IR, rumble and motion sensing Deactivated");
+				wiimote.deactivateIRTRacking();
+				wiimote.deactivateMotionSensing();
+				wiimote.deactivateRumble();
+			}
+
+			/* leave test */
+			if (e.isButtonHomeJustPressed()) {
+				System.out.println("LEAVING TEST");
+				wiimote.disconnect();
+			}
+		} else if (dump == MOVE_MOUSE) {
+			/* Activate IR Tracking */
+			if (e.isButtonOneJustPressed()) {
+				System.out.println("IR Activated");
+				wiimote.activateIRTRacking();
+			}
+			if (e.isButtonTwoJustPressed()) {
+				System.out.println("IR Deactivated");
+				wiimote.deactivateIRTRacking();
+			}
+
+			/* button A */
+			if (e.isButtonAJustPressed()) {
+				robot.mousePress(InputEvent.BUTTON1_MASK);
+			}
+			if (e.isButtonAJustReleased()) {
+				robot.mouseRelease(InputEvent.BUTTON1_MASK);
+			}
+
+			/* button B */
+			if (e.isButtonBJustPressed()) {
+				robot.mousePress(InputEvent.BUTTON2_MASK);
+			}
+			if (e.isButtonBJustReleased()) {
+				robot.mouseRelease(InputEvent.BUTTON2_MASK);
+			}
+
+			/* leave test */
+			if (e.isButtonHomeJustPressed()) {
+				System.out.println("LEAVING TEST");
+				wiimote.disconnect();
+			}
+		} else if (dump == TEST_LEDS) {
+			wiimote.activateMotionSensing();
+			if (e.isButtonUpJustPressed()) {
+				wiimote.setLeds(true, false, false, false);
+			}
+			if (e.isButtonDownJustPressed()) {
+				wiimote.setLeds(false, true, false, false);
+			}
+			if (e.isButtonLeftJustPressed()) {
+				wiimote.setLeds(false, false, true, false);
+			}
+			if (e.isButtonRightJustPressed()) {
+				wiimote.setLeds(false, false, false, true);
+			}
+
+			/* leave test */
+			if (e.isButtonHomeJustPressed()) {
+				System.out.println("LEAVING TEST");
+				wiimote.disconnect();
+			}
+		}
+
+	}
+
+	public void onIrEvent(IREvent e) {
+		if (dump == MOVE_MOUSE) {
+			IRSource[] list = e.getIRPoints();
+			if (list.length > 0) {
+				int x1 = (int) list[0].getX();
+				int y1 = (int) list[0].getY();
+
+				int mousex = (int) Math.round(((double) x1 / 1024.0) * 1280.0);
+				int mousey = (int) Math.round(((double) y1 / 768.0) * 1024.0);
+				robot.mouseMove(mousex, mousey);
+			}
+		} else {
+			System.out.println(e);
+		}
+	}
+
+	public void onMotionSensingEvent(MotionSensingEvent e) {
+		/* display motion sensing */
+		System.out.println(e);
+	}
+
+	public void onStatusEvent(StatusEvent e) {
+		// Display status variables
+		System.out.println(e);
+	}
+
+	public void onDisconnectionEvent(DisconnectionEvent e) {
+		System.out.println(" wiimote " + e.getWiimoteId()
+				+ "has been disconnected !!");
+	}
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Wiimote[] wiimotes = WiiUseApiManager.getWiimotes(4);
+		if (wiimotes.length > 0) {
+			System.out.println(wiimotes[0]);
+			Tests tests = new Tests(wiimotes[0]);
+		} else {
+			System.out.println("No wiimotes found !!!");
+		}
+
+		// java.util.Timer timer = new java.util.Timer();
+		// timer.scheduleAtFixedRate(new LedsTask(), 0, 100);
+
+	}
+}

WiiUseJ_0.1/src/wiiusej/test/WiiuseJGuiTest.java

@@ -0,0 +1,836 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.test;
+
+import java.awt.AWTException;
+import java.awt.Robot;
+import java.awt.event.InputEvent;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import wiiusej.utils.IRPanel;
+import wiiusej.Wiimote;
+import wiiusej.utils.AccelerationPanel;
+import wiiusej.utils.GForcePanel;
+import wiiusej.utils.ButtonsEventPanel;
+import wiiusej.utils.OrientationPanel;
+import wiiusej.wiiuseapievents.ButtonsEvent;
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.IREvent;
+import wiiusej.wiiuseapievents.MotionSensingEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.WiimoteListener;
+
+/**
+ * Gui class to test WiiuseJ.
+ * @author  guiguito
+ */
+public class WiiuseJGuiTest extends javax.swing.JFrame implements WiimoteListener {
+
+    private Wiimote wiimote;
+    private Robot robot = null;
+    private boolean statusMotionRequested = false;
+    private boolean statusIRRequested = false;
+
+    /** Creates new form WiiuseJGuiTest */
+    public WiiuseJGuiTest(Wiimote wiimote) {
+        initComponents();
+        this.wiimote = wiimote;
+        wiimote.addWiiMoteEventListeners((IRPanel) irViewPanel);
+        wiimote.addWiiMoteEventListeners((ButtonsEventPanel) buttonsPanel);
+        wiimote.addWiiMoteEventListeners((OrientationPanel) motionSensingPanel);
+        wiimote.addWiiMoteEventListeners((GForcePanel) gForcePanel);
+        wiimote.addWiiMoteEventListeners((AccelerationPanel) accelerationPanel);
+        wiimote.addWiiMoteEventListeners(this);
+        wiimote.deactivateContinuous();
+        wiimote.deactivateSmoothing();
+        wiimote.setScreenAspectRatio169();
+        wiimote.setSensorBarBelowScreen();
+        getStatusButtonMousePressed(null);
+        this.addWindowListener(new CloseGuiTestCleanly(wiimote));
+    }
+
+    public void onButtonsEvent(ButtonsEvent arg0) {
+        if (robot != null) {
+            if (arg0.isButtonAPressed()) {
+                robot.mousePress(InputEvent.BUTTON1_MASK);
+
+            }
+            if (arg0.isButtonBPressed()) {
+                robot.mousePress(InputEvent.BUTTON2_MASK);
+
+            }
+            if (arg0.isButtonOnePressed()) {
+                robot.mousePress(InputEvent.BUTTON3_MASK);
+
+            }
+            if (arg0.isButtonAJustReleased()) {
+                robot.mouseRelease(InputEvent.BUTTON1_MASK);
+
+            }
+            if (arg0.isButtonBJustReleased()) {
+                robot.mouseRelease(InputEvent.BUTTON2_MASK);
+
+            }
+            if (arg0.isButtonOneJustReleased()) {
+                robot.mouseRelease(InputEvent.BUTTON3_MASK);
+
+            }
+            if (arg0.isButtonUpPressed()) {//mouse wheel up
+                robot.mouseWheel(-1);
+            }
+            if (arg0.isButtonDownPressed()) {//mouse wheel down
+                robot.mouseWheel(1);
+            }
+            
+            if (arg0.isButtonTwoPressed()) {//stop mouse control
+                mouseIRControlButtonMousePressed(null);
+            }
+        }
+    }
+
+    public void onIrEvent(IREvent arg0) {
+        if (robot != null) {//if mouse control activated
+            robot.mouseMove(arg0.getX(), arg0.getY());
+        }
+        if (statusIRRequested){
+            xResolutionTextField.setText(""+arg0.getXVRes());
+            yResolutionTextField.setText(""+arg0.getYVRes());
+            statusIRRequested = false;
+        }
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent arg0) {
+        if (statusMotionRequested){//Status requested
+            accelerationThresholdTextField.setText(""+arg0.getAccelerationThreshold());
+            orientationThresholdTextField.setText(""+arg0.getOrientationThreshold());
+            alphaSmoothingTextField.setText(""+arg0.getAlphaSmoothing());
+            statusMotionRequested = false;
+        }
+    }
+
+    public void onStatusEvent(StatusEvent arg0) {
+        messageText.setText("Status received !");
+        batteryLevelText.setText(arg0.getBatteryLevel() + " %");                
+        led1Button.setEnabled(arg0.isLed1Set());
+        led2Button.setEnabled(arg0.isLed2Set());
+        led3Button.setEnabled(arg0.isLed3Set());
+        led4Button.setEnabled(arg0.isLed4Set());
+        //attachments
+        int eventType = arg0.getEventType();
+        if (eventType == StatusEvent.WIIUSE_CLASSIC_CTRL_INSERTED){
+            expansionText.setText("Classic control connected.");
+        }else
+        if (eventType == StatusEvent.WIIUSE_CLASSIC_CTRL_REMOVED){
+            expansionText.setText("Classic control removed.");
+        }else
+        if (eventType == StatusEvent.WIIUSE_NUNCHUK_INSERTED){
+            expansionText.setText("Nunchuk connected.");
+        }else
+        if (eventType == StatusEvent.WIIUSE_NUNCHUK_REMOVED){
+            expansionText.setText("Nunchuk removed.");
+        }else
+        if (eventType == StatusEvent.WIIUSE_GUITAR_HERO_3_CTRL_INSERTED){
+            expansionText.setText("Guitar Hero 3 control connected.");
+        }else
+        if (eventType == StatusEvent.WIIUSE_GUITAR_HERO_3_CTRL_REMOVED){
+            expansionText.setText("Guitar Hero 3 control removed.");
+        }
+    }
+
+    public void onDisconnectionEvent(DisconnectionEvent arg0) {
+        messageText.setText("Wiimote Disconnected !");
+    }
+
+    /** This method is called from within the constructor to
+     * initialize the form.
+     * WARNING: Do NOT modify this code. The content of this method is
+     * always regenerated by the Form Editor.
+     */
+    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
+    private void initComponents() {
+
+        leftPanel = new javax.swing.JPanel();
+        irViewPanel = new IRPanel();
+        jTabbedPane1 = new javax.swing.JTabbedPane();
+        motionSensingPanel = new OrientationPanel();
+        gForcePanel = new wiiusej.utils.GForcePanel();
+        accelerationPanel = new AccelerationPanel();
+        rightPanel = new javax.swing.JPanel();
+        fixedWiimotePanel = new javax.swing.JPanel();
+        buttonsPanel = new ButtonsEventPanel();
+        controlsPanel = new javax.swing.JPanel();
+        activateRumblePanel = new javax.swing.JPanel();
+        toggleRumbleButton = new javax.swing.JButton();
+        deactivateRumblePanel = new javax.swing.JPanel();
+        toggleIRTrackingButton = new javax.swing.JButton();
+        activateIRtrackingPanel = new javax.swing.JPanel();
+        toggleMotionSensingTrackingButton = new javax.swing.JButton();
+        deactivateIRTrackingPanel = new javax.swing.JPanel();
+        toggleSmoothingButton = new javax.swing.JButton();
+        activateMotionSensingTrackingPanel = new javax.swing.JPanel();
+        toggleContinuousButton = new javax.swing.JButton();
+        deactivateMotionSensingTrackingPanel = new javax.swing.JPanel();
+        led1Button = new javax.swing.JButton();
+        led2Button = new javax.swing.JButton();
+        led3Button = new javax.swing.JButton();
+        led4Button = new javax.swing.JButton();
+        setLedsButton = new javax.swing.JButton();
+        activateSmoothingPanel = new javax.swing.JPanel();
+        alphaSmoothingTextField = new javax.swing.JTextField();
+        alphaSmoothingButton = new javax.swing.JButton();
+        deactivateSmoothingPanel = new javax.swing.JPanel();
+        orientationThresholdTextField = new javax.swing.JTextField();
+        orientationThresholdButton = new javax.swing.JButton();
+        activateContinuousPanel = new javax.swing.JPanel();
+        accelerationThresholdTextField = new javax.swing.JTextField();
+        accelerationThresholdButton = new javax.swing.JButton();
+        deactivateContinuousPanel = new javax.swing.JPanel();
+        getStatusButton = new javax.swing.JButton();
+        batteryText = new javax.swing.JLabel();
+        batteryLevelText = new javax.swing.JLabel();
+        ledsPanel = new javax.swing.JPanel();
+        toggleSensorBarPositionButton = new javax.swing.JButton();
+        alphaSmoothingPanel = new javax.swing.JPanel();
+        toggleScreenAspectRatioButton = new javax.swing.JButton();
+        orientationThresholdPanel = new javax.swing.JPanel();
+        xLabel = new javax.swing.JLabel();
+        xResolutionTextField = new javax.swing.JTextField();
+        yLabel = new javax.swing.JLabel();
+        yResolutionTextField = new javax.swing.JTextField();
+        setVirtualResolutionButton = new javax.swing.JButton();
+        accelerationThresholdPanel = new javax.swing.JPanel();
+        mouseIRControlButton = new javax.swing.JButton();
+        batteryPanel = new javax.swing.JPanel();
+        expansionText = new javax.swing.JLabel();
+        messagesPanel = new javax.swing.JPanel();
+        messageLabelText = new javax.swing.JLabel();
+        messageText = new javax.swing.JLabel();
+
+        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
+        setTitle("WiiuseJ Test GUI");
+        setName("WiiuseJ Test GUI"); // NOI18N
+
+        leftPanel.setBorder(javax.swing.BorderFactory.createEtchedBorder());
+
+        irViewPanel.setBackground(new java.awt.Color(0, 0, 0));
+        irViewPanel.setBorder(javax.swing.BorderFactory.createTitledBorder(new javax.swing.border.LineBorder(new java.awt.Color(0, 153, 153), 2, true), "IR View", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 0, 11), new java.awt.Color(255, 0, 51)));
+
+        javax.swing.GroupLayout irViewPanelLayout = new javax.swing.GroupLayout(irViewPanel);
+        irViewPanel.setLayout(irViewPanelLayout);
+        irViewPanelLayout.setHorizontalGroup(
+            irViewPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 272, Short.MAX_VALUE)
+        );
+        irViewPanelLayout.setVerticalGroup(
+            irViewPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 299, Short.MAX_VALUE)
+        );
+
+        javax.swing.GroupLayout motionSensingPanelLayout = new javax.swing.GroupLayout(motionSensingPanel);
+        motionSensingPanel.setLayout(motionSensingPanelLayout);
+        motionSensingPanelLayout.setHorizontalGroup(
+            motionSensingPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 279, Short.MAX_VALUE)
+        );
+        motionSensingPanelLayout.setVerticalGroup(
+            motionSensingPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 213, Short.MAX_VALUE)
+        );
+
+        jTabbedPane1.addTab("Orientation", motionSensingPanel);
+
+        javax.swing.GroupLayout gForcePanelLayout = new javax.swing.GroupLayout(gForcePanel);
+        gForcePanel.setLayout(gForcePanelLayout);
+        gForcePanelLayout.setHorizontalGroup(
+            gForcePanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 279, Short.MAX_VALUE)
+        );
+        gForcePanelLayout.setVerticalGroup(
+            gForcePanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 213, Short.MAX_VALUE)
+        );
+
+        jTabbedPane1.addTab("GForce", gForcePanel);
+
+        javax.swing.GroupLayout accelerationPanelLayout = new javax.swing.GroupLayout(accelerationPanel);
+        accelerationPanel.setLayout(accelerationPanelLayout);
+        accelerationPanelLayout.setHorizontalGroup(
+            accelerationPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 279, Short.MAX_VALUE)
+        );
+        accelerationPanelLayout.setVerticalGroup(
+            accelerationPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 213, Short.MAX_VALUE)
+        );
+
+        jTabbedPane1.addTab("Raw Acceleration", accelerationPanel);
+
+        javax.swing.GroupLayout leftPanelLayout = new javax.swing.GroupLayout(leftPanel);
+        leftPanel.setLayout(leftPanelLayout);
+        leftPanelLayout.setHorizontalGroup(
+            leftPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addComponent(irViewPanel, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+            .addComponent(jTabbedPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 284, Short.MAX_VALUE)
+        );
+        leftPanelLayout.setVerticalGroup(
+            leftPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, leftPanelLayout.createSequentialGroup()
+                .addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 238, javax.swing.GroupLayout.PREFERRED_SIZE)
+                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+                .addComponent(irViewPanel, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
+        );
+
+        jTabbedPane1.getAccessibleContext().setAccessibleName("Orientation");
+
+        rightPanel.setBorder(javax.swing.BorderFactory.createEtchedBorder());
+        rightPanel.setLayout(new javax.swing.BoxLayout(rightPanel, javax.swing.BoxLayout.LINE_AXIS));
+
+        fixedWiimotePanel.setMaximumSize(new java.awt.Dimension(120, 32767));
+        fixedWiimotePanel.setMinimumSize(new java.awt.Dimension(120, 100));
+        fixedWiimotePanel.setPreferredSize(new java.awt.Dimension(120, 100));
+        fixedWiimotePanel.setRequestFocusEnabled(false);
+        fixedWiimotePanel.setLayout(null);
+
+        buttonsPanel.setMaximumSize(new java.awt.Dimension(120, 484));
+        buttonsPanel.setMinimumSize(new java.awt.Dimension(120, 484));
+        buttonsPanel.setOpaque(false);
+        buttonsPanel.setPreferredSize(new java.awt.Dimension(120, 484));
+
+        javax.swing.GroupLayout buttonsPanelLayout = new javax.swing.GroupLayout(buttonsPanel);
+        buttonsPanel.setLayout(buttonsPanelLayout);
+        buttonsPanelLayout.setHorizontalGroup(
+            buttonsPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 120, Short.MAX_VALUE)
+        );
+        buttonsPanelLayout.setVerticalGroup(
+            buttonsPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 484, Short.MAX_VALUE)
+        );
+
+        fixedWiimotePanel.add(buttonsPanel);
+        buttonsPanel.setBounds(0, 0, 120, 484);
+
+        rightPanel.add(fixedWiimotePanel);
+
+        controlsPanel.setMinimumSize(new java.awt.Dimension(100, 264));
+        controlsPanel.setPreferredSize(new java.awt.Dimension(190, 264));
+        controlsPanel.setLayout(new java.awt.GridLayout(16, 1));
+
+        toggleRumbleButton.setText("Activate Rumble");
+        toggleRumbleButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                toggleRumbleButtonMousePressed(evt);
+            }
+        });
+        activateRumblePanel.add(toggleRumbleButton);
+
+        controlsPanel.add(activateRumblePanel);
+
+        toggleIRTrackingButton.setText("Activate IR Tracking");
+        toggleIRTrackingButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                toggleIRTrackingButtonMousePressed(evt);
+            }
+        });
+        deactivateRumblePanel.add(toggleIRTrackingButton);
+
+        controlsPanel.add(deactivateRumblePanel);
+
+        toggleMotionSensingTrackingButton.setText("Activate motion sensing Tracking");
+        toggleMotionSensingTrackingButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                toggleMotionSensingTrackingButtonMousePressed(evt);
+            }
+        });
+        activateIRtrackingPanel.add(toggleMotionSensingTrackingButton);
+
+        controlsPanel.add(activateIRtrackingPanel);
+
+        toggleSmoothingButton.setText("Activate Smoothing");
+        toggleSmoothingButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                toggleSmoothingButtonMousePressed(evt);
+            }
+        });
+        deactivateIRTrackingPanel.add(toggleSmoothingButton);
+
+        controlsPanel.add(deactivateIRTrackingPanel);
+
+        toggleContinuousButton.setText("Activate Continuous");
+        toggleContinuousButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                toggleContinuousButtonMousePressed(evt);
+            }
+        });
+        activateMotionSensingTrackingPanel.add(toggleContinuousButton);
+
+        controlsPanel.add(activateMotionSensingTrackingPanel);
+
+        led1Button.setText("Led1");
+        led1Button.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                led1ButtonMousePressed(evt);
+            }
+        });
+        deactivateMotionSensingTrackingPanel.add(led1Button);
+
+        led2Button.setText("Led2");
+        led2Button.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                led2ButtonMousePressed(evt);
+            }
+        });
+        deactivateMotionSensingTrackingPanel.add(led2Button);
+
+        led3Button.setText("Led3");
+        led3Button.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                led3ButtonMousePressed(evt);
+            }
+        });
+        deactivateMotionSensingTrackingPanel.add(led3Button);
+
+        led4Button.setText("Led4");
+        led4Button.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                led4ButtonMousePressed(evt);
+            }
+        });
+        deactivateMotionSensingTrackingPanel.add(led4Button);
+
+        setLedsButton.setText("Set leds");
+        setLedsButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                setLedsButtonMousePressed(evt);
+            }
+        });
+        deactivateMotionSensingTrackingPanel.add(setLedsButton);
+
+        controlsPanel.add(deactivateMotionSensingTrackingPanel);
+
+        alphaSmoothingTextField.setMinimumSize(new java.awt.Dimension(100, 20));
+        alphaSmoothingTextField.setPreferredSize(new java.awt.Dimension(100, 20));
+        activateSmoothingPanel.add(alphaSmoothingTextField);
+
+        alphaSmoothingButton.setText("Set alpha smoothing");
+        alphaSmoothingButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                alphaSmoothingButtonMousePressed(evt);
+            }
+        });
+        activateSmoothingPanel.add(alphaSmoothingButton);
+
+        controlsPanel.add(activateSmoothingPanel);
+
+        orientationThresholdTextField.setMinimumSize(new java.awt.Dimension(100, 20));
+        orientationThresholdTextField.setPreferredSize(new java.awt.Dimension(100, 20));
+        deactivateSmoothingPanel.add(orientationThresholdTextField);
+
+        orientationThresholdButton.setText("Set orientation threshold");
+        orientationThresholdButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                orientationThresholdButtonMousePressed(evt);
+            }
+        });
+        deactivateSmoothingPanel.add(orientationThresholdButton);
+
+        controlsPanel.add(deactivateSmoothingPanel);
+
+        accelerationThresholdTextField.setPreferredSize(new java.awt.Dimension(100, 20));
+        activateContinuousPanel.add(accelerationThresholdTextField);
+
+        accelerationThresholdButton.setText("Set acceleration threshold");
+        accelerationThresholdButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                accelerationThresholdButtonMousePressed(evt);
+            }
+        });
+        activateContinuousPanel.add(accelerationThresholdButton);
+
+        controlsPanel.add(activateContinuousPanel);
+
+        getStatusButton.setText("Get status");
+        getStatusButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                getStatusButtonMousePressed(evt);
+            }
+        });
+        deactivateContinuousPanel.add(getStatusButton);
+
+        batteryText.setFont(new java.awt.Font("Tahoma", 0, 14));
+        batteryText.setText("Battery level :");
+        deactivateContinuousPanel.add(batteryText);
+
+        batteryLevelText.setFont(new java.awt.Font("Arial", 0, 14));
+        batteryLevelText.setText(" %");
+        deactivateContinuousPanel.add(batteryLevelText);
+
+        controlsPanel.add(deactivateContinuousPanel);
+
+        toggleSensorBarPositionButton.setText("Set sensor bar above");
+        toggleSensorBarPositionButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                toggleSensorBarPositionButtonMousePressed(evt);
+            }
+        });
+        ledsPanel.add(toggleSensorBarPositionButton);
+
+        controlsPanel.add(ledsPanel);
+
+        toggleScreenAspectRatioButton.setText("Set screen aspect ratio 4/3");
+        toggleScreenAspectRatioButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                toggleScreenAspectRatioButtonMousePressed(evt);
+            }
+        });
+        alphaSmoothingPanel.add(toggleScreenAspectRatioButton);
+
+        controlsPanel.add(alphaSmoothingPanel);
+
+        xLabel.setText("X");
+        orientationThresholdPanel.add(xLabel);
+
+        xResolutionTextField.setMinimumSize(new java.awt.Dimension(40, 20));
+        xResolutionTextField.setPreferredSize(new java.awt.Dimension(40, 20));
+        orientationThresholdPanel.add(xResolutionTextField);
+
+        yLabel.setText("Y");
+        orientationThresholdPanel.add(yLabel);
+
+        yResolutionTextField.setFocusTraversalPolicyProvider(true);
+        yResolutionTextField.setMinimumSize(new java.awt.Dimension(40, 20));
+        yResolutionTextField.setPreferredSize(new java.awt.Dimension(40, 20));
+        orientationThresholdPanel.add(yResolutionTextField);
+
+        setVirtualResolutionButton.setText("Set virtual resolution");
+        setVirtualResolutionButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                setVirtualResolutionButtonMousePressed(evt);
+            }
+        });
+        orientationThresholdPanel.add(setVirtualResolutionButton);
+
+        controlsPanel.add(orientationThresholdPanel);
+
+        mouseIRControlButton.setText("Start infrared mouse control");
+        mouseIRControlButton.addMouseListener(new java.awt.event.MouseAdapter() {
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                mouseIRControlButtonMousePressed(evt);
+            }
+        });
+        accelerationThresholdPanel.add(mouseIRControlButton);
+
+        controlsPanel.add(accelerationThresholdPanel);
+
+        expansionText.setText("No expansion connected");
+        batteryPanel.add(expansionText);
+
+        controlsPanel.add(batteryPanel);
+
+        messageLabelText.setFont(new java.awt.Font("Tahoma", 0, 14));
+        messageLabelText.setText("Message : ");
+        messagesPanel.add(messageLabelText);
+
+        messageText.setFont(new java.awt.Font("Arial", 0, 14));
+        messageText.setText("None");
+        messagesPanel.add(messageText);
+
+        controlsPanel.add(messagesPanel);
+
+        rightPanel.add(controlsPanel);
+
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
+        getContentPane().setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGroup(layout.createSequentialGroup()
+                .addComponent(leftPanel, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+                .addComponent(rightPanel, javax.swing.GroupLayout.DEFAULT_SIZE, 498, Short.MAX_VALUE))
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addComponent(leftPanel, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+            .addComponent(rightPanel, javax.swing.GroupLayout.DEFAULT_SIZE, 573, Short.MAX_VALUE)
+        );
+
+        java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
+        setBounds((screenSize.width-800)/2, (screenSize.height-600)/2, 800, 600);
+    }// </editor-fold>//GEN-END:initComponents
+    private void toggleRumbleButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toggleRumbleButtonMousePressed
+        if (toggleRumbleButton.isEnabled()) {
+            wiimote.activateRumble();
+            toggleRumbleButton.setEnabled(false);
+            toggleRumbleButton.setText("Deactivate Rumble");
+            messageText.setText("Rumble activated");
+        } else {
+            wiimote.deactivateRumble();
+            toggleRumbleButton.setEnabled(true);
+            toggleRumbleButton.setText("Activate Rumble");
+            messageText.setText("Rumble deactivated");
+        }
+    }//GEN-LAST:event_toggleRumbleButtonMousePressed
+
+    private void toggleIRTrackingButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toggleIRTrackingButtonMousePressed
+        if (toggleIRTrackingButton.isEnabled()) {
+            wiimote.activateIRTRacking();
+            toggleIRTrackingButton.setEnabled(false);
+            toggleIRTrackingButton.setText("Deactivate IR Tracking");
+            messageText.setText("IR Tracking activated");
+        } else {
+            wiimote.deactivateIRTRacking();
+            toggleIRTrackingButton.setEnabled(true);
+            toggleIRTrackingButton.setText("Activate IR Tracking");
+            ((IRPanel) irViewPanel).onDisconnectionEvent(null);
+            messageText.setText("IR Tracking deactivated");
+        }
+    }//GEN-LAST:event_toggleIRTrackingButtonMousePressed
+
+    private void toggleMotionSensingTrackingButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toggleMotionSensingTrackingButtonMousePressed
+        if (toggleMotionSensingTrackingButton.isEnabled()) {
+            wiimote.activateMotionSensing();
+            toggleMotionSensingTrackingButton.setEnabled(false);
+            toggleMotionSensingTrackingButton.setText("Deactivate Motion Sensing");
+            messageText.setText("Motion Sensing activated");
+        } else {
+            wiimote.deactivateMotionSensing();
+            toggleMotionSensingTrackingButton.setEnabled(true);
+            toggleMotionSensingTrackingButton.setText("Activate Motion Sensing");
+            ((OrientationPanel) motionSensingPanel).onDisconnectionEvent(null);
+            ((GForcePanel) gForcePanel).onDisconnectionEvent(null);
+            messageText.setText("Motion Sensing deactivated");
+        }
+    }//GEN-LAST:event_toggleMotionSensingTrackingButtonMousePressed
+
+    private void toggleSmoothingButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toggleSmoothingButtonMousePressed
+        if (toggleSmoothingButton.isEnabled()) {
+            wiimote.activateSmoothing();
+            toggleSmoothingButton.setEnabled(false);
+            toggleSmoothingButton.setText("Deactivate Alpha Smoothing");
+            messageText.setText("Alpha Smoothing activated");
+        } else {
+            wiimote.deactivateSmoothing();
+            toggleSmoothingButton.setEnabled(true);
+            toggleSmoothingButton.setText("Activate Alpha Smoothing");
+            messageText.setText("Alpha Smoothing deactivated");
+        }
+    }//GEN-LAST:event_toggleSmoothingButtonMousePressed
+
+    private void toggleContinuousButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toggleContinuousButtonMousePressed
+        if (toggleContinuousButton.isEnabled()) {
+            wiimote.activateContinuous();
+            toggleContinuousButton.setEnabled(false);
+            toggleContinuousButton.setText("Deactivate Continuous");
+            messageText.setText("Continuous activated");
+        } else {
+            wiimote.deactivateContinuous();
+            toggleContinuousButton.setEnabled(true);
+            toggleContinuousButton.setText("Activate Continuous");
+            messageText.setText("Continuous deactivated");
+        }
+    }//GEN-LAST:event_toggleContinuousButtonMousePressed
+
+    private void led1ButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_led1ButtonMousePressed
+        if (led1Button.isEnabled()) {
+            led1Button.setEnabled(false);
+        } else {
+            led1Button.setEnabled(true);
+        }
+    }//GEN-LAST:event_led1ButtonMousePressed
+
+    private void led2ButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_led2ButtonMousePressed
+        if (led2Button.isEnabled()) {
+            led2Button.setEnabled(false);
+        } else {
+            led2Button.setEnabled(true);
+        }
+    }//GEN-LAST:event_led2ButtonMousePressed
+
+    private void led3ButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_led3ButtonMousePressed
+        if (led3Button.isEnabled()) {
+            led3Button.setEnabled(false);
+        } else {
+            led3Button.setEnabled(true);
+        }
+    }//GEN-LAST:event_led3ButtonMousePressed
+
+    private void led4ButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_led4ButtonMousePressed
+        if (led4Button.isEnabled()) {
+            led4Button.setEnabled(false);
+        } else {
+            led4Button.setEnabled(true);
+        }
+    }//GEN-LAST:event_led4ButtonMousePressed
+
+    private void setLedsButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_setLedsButtonMousePressed
+        wiimote.setLeds(led1Button.isEnabled(), led2Button.isEnabled(),
+                led3Button.isEnabled(), led4Button.isEnabled());
+        messageText.setText("Leds set");
+    }//GEN-LAST:event_setLedsButtonMousePressed
+
+    private void alphaSmoothingButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_alphaSmoothingButtonMousePressed
+        try {
+            float nb = Float.parseFloat(alphaSmoothingTextField.getText());
+            wiimote.setAlphaSmoothingValue(nb);
+            messageText.setText("Alpha smoothing set to " + nb);
+        } catch (NumberFormatException e) {
+            messageText.setText("Number is not a float, alpha smoothing not set !");
+        }   
+    }//GEN-LAST:event_alphaSmoothingButtonMousePressed
+
+    private void orientationThresholdButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_orientationThresholdButtonMousePressed
+        try {
+            float nb = Float.parseFloat(orientationThresholdTextField.getText());
+            wiimote.setOrientationThreshold(nb);
+            messageText.setText("Orientation threshold set to " + nb);
+        } catch (NumberFormatException e) {
+            messageText.setText("Number is not a float, orientation threshold not set !");
+        } 
+    }//GEN-LAST:event_orientationThresholdButtonMousePressed
+
+    private void accelerationThresholdButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_accelerationThresholdButtonMousePressed
+        try {
+            int nb = Integer.parseInt(accelerationThresholdTextField.getText());
+            wiimote.setAccelerationThreshold(nb);
+            messageText.setText("Acceleration threshold set to " + nb);
+        } catch (NumberFormatException e) {
+            messageText.setText("Number is not an integer, acceleration threshold not set !");
+        }
+    }//GEN-LAST:event_accelerationThresholdButtonMousePressed
+
+    private void getStatusButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_getStatusButtonMousePressed
+        wiimote.getStatus();
+        statusMotionRequested = true;
+        statusIRRequested = true;
+    }//GEN-LAST:event_getStatusButtonMousePressed
+
+    private void toggleSensorBarPositionButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toggleSensorBarPositionButtonMousePressed
+        if (toggleSensorBarPositionButton.isEnabled()) {
+            wiimote.setSensorBarBelowScreen();
+            toggleSensorBarPositionButton.setEnabled(false);
+            toggleSensorBarPositionButton.setText("Set sensor bar below");
+            messageText.setText("Sensor bar set above");
+        } else {
+            wiimote.setSensorBarAboveScreen();
+            toggleSensorBarPositionButton.setEnabled(true);
+            toggleSensorBarPositionButton.setText("Set sensor bar above");
+            messageText.setText("Sensor bar set below");
+        }
+    }//GEN-LAST:event_toggleSensorBarPositionButtonMousePressed
+
+    private void toggleScreenAspectRatioButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toggleScreenAspectRatioButtonMousePressed
+        if (toggleScreenAspectRatioButton.isEnabled()) {
+            wiimote.setScreenAspectRatio43();
+            toggleScreenAspectRatioButton.setEnabled(false);
+            toggleScreenAspectRatioButton.setText("Set screen aspect ratio 16/9");
+            messageText.setText("creen aspect ratio to 4/3");
+        } else {
+            wiimote.setScreenAspectRatio169();
+            toggleScreenAspectRatioButton.setEnabled(true);
+            toggleScreenAspectRatioButton.setText("Set screen aspect ratio 4/3");
+            messageText.setText("Screen aspect ratio to 16/9");
+        }
+    }//GEN-LAST:event_toggleScreenAspectRatioButtonMousePressed
+
+    private void setVirtualResolutionButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_setVirtualResolutionButtonMousePressed
+        try {
+            int xres = Integer.parseInt(xResolutionTextField.getText());
+            int yres = Integer.parseInt(yResolutionTextField.getText());
+            wiimote.setVirtualResolution(xres, yres);
+            messageText.setText("Virtual resolution set to " + xres + "X" + yres);
+        } catch (NumberFormatException e) {
+            messageText.setText("A number in the virtual resolution is not an integer. Virtual resolution not set!");
+        }
+    }//GEN-LAST:event_setVirtualResolutionButtonMousePressed
+
+    private void mouseIRControlButtonMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_mouseIRControlButtonMousePressed
+        if (mouseIRControlButton.isEnabled()) {
+            try {
+                mouseIRControlButton.setEnabled(false);
+                mouseIRControlButton.setText("Stop infrared mouse control");
+                robot = new Robot();
+                messageText.setText("Infrared mouse control started");
+            } catch (AWTException ex) {
+                Logger.getLogger(WiiuseJGuiTest.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        } else {
+            mouseIRControlButton.setEnabled(true);
+            mouseIRControlButton.setText("Start infrared mouse control");
+            robot = null;
+            messageText.setText("Infrared mouse control stopped");
+        }
+    }//GEN-LAST:event_mouseIRControlButtonMousePressed
+
+    // Variables declaration - do not modify//GEN-BEGIN:variables
+    private javax.swing.JPanel accelerationPanel;
+    private javax.swing.JButton accelerationThresholdButton;
+    private javax.swing.JPanel accelerationThresholdPanel;
+    private javax.swing.JTextField accelerationThresholdTextField;
+    private javax.swing.JPanel activateContinuousPanel;
+    private javax.swing.JPanel activateIRtrackingPanel;
+    private javax.swing.JPanel activateMotionSensingTrackingPanel;
+    private javax.swing.JPanel activateRumblePanel;
+    private javax.swing.JPanel activateSmoothingPanel;
+    private javax.swing.JButton alphaSmoothingButton;
+    private javax.swing.JPanel alphaSmoothingPanel;
+    private javax.swing.JTextField alphaSmoothingTextField;
+    private javax.swing.JLabel batteryLevelText;
+    private javax.swing.JPanel batteryPanel;
+    private javax.swing.JLabel batteryText;
+    private javax.swing.JPanel buttonsPanel;
+    private javax.swing.JPanel controlsPanel;
+    private javax.swing.JPanel deactivateContinuousPanel;
+    private javax.swing.JPanel deactivateIRTrackingPanel;
+    private javax.swing.JPanel deactivateMotionSensingTrackingPanel;
+    private javax.swing.JPanel deactivateRumblePanel;
+    private javax.swing.JPanel deactivateSmoothingPanel;
+    private javax.swing.JLabel expansionText;
+    private javax.swing.JPanel fixedWiimotePanel;
+    private javax.swing.JPanel gForcePanel;
+    private javax.swing.JButton getStatusButton;
+    private javax.swing.JPanel irViewPanel;
+    private javax.swing.JTabbedPane jTabbedPane1;
+    private javax.swing.JButton led1Button;
+    private javax.swing.JButton led2Button;
+    private javax.swing.JButton led3Button;
+    private javax.swing.JButton led4Button;
+    private javax.swing.JPanel ledsPanel;
+    private javax.swing.JPanel leftPanel;
+    private javax.swing.JLabel messageLabelText;
+    private javax.swing.JLabel messageText;
+    private javax.swing.JPanel messagesPanel;
+    private javax.swing.JPanel motionSensingPanel;
+    private javax.swing.JButton mouseIRControlButton;
+    private javax.swing.JButton orientationThresholdButton;
+    private javax.swing.JPanel orientationThresholdPanel;
+    private javax.swing.JTextField orientationThresholdTextField;
+    private javax.swing.JPanel rightPanel;
+    private javax.swing.JButton setLedsButton;
+    private javax.swing.JButton setVirtualResolutionButton;
+    private javax.swing.JButton toggleContinuousButton;
+    private javax.swing.JButton toggleIRTrackingButton;
+    private javax.swing.JButton toggleMotionSensingTrackingButton;
+    private javax.swing.JButton toggleRumbleButton;
+    private javax.swing.JButton toggleScreenAspectRatioButton;
+    private javax.swing.JButton toggleSensorBarPositionButton;
+    private javax.swing.JButton toggleSmoothingButton;
+    private javax.swing.JLabel xLabel;
+    private javax.swing.JTextField xResolutionTextField;
+    private javax.swing.JLabel yLabel;
+    private javax.swing.JTextField yResolutionTextField;
+    // End of variables declaration//GEN-END:variables
+}

WiiUseJ_0.1/src/wiiusej/utils/AccelerationPanel.java

@@ -0,0 +1,182 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.utils;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.util.ArrayList;
+import wiiusej.values.RawAcceleration;
+import wiiusej.wiiuseapievents.ButtonsEvent;
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.IREvent;
+import wiiusej.wiiuseapievents.MotionSensingEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.WiimoteListener;
+
+/**
+ * This panel is used to watch raw acceleration values from a MotionSensingEvent.
+ * @author  guiguito
+ */
+public class AccelerationPanel extends javax.swing.JPanel implements WiimoteListener {
+
+    private Image mImage;//image for double buffering
+    private Color xColor = Color.RED;
+    private Color yColor = Color.GREEN;
+    private Color zColor = Color.BLUE;
+    private Color backgroundColor = Color.WHITE;
+    private Color lineColor = Color.BLACK;
+    private ArrayList<RawAcceleration> values = new ArrayList<RawAcceleration>();
+
+    /** Creates new form AccelerationPanel */
+    public AccelerationPanel() {
+        initComponents();
+    }
+
+    @Override
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Dimension d = getSize();
+        checkOffScreenImage();
+        Graphics offG = mImage.getGraphics();
+        offG.setColor(backgroundColor);
+        offG.fillRect(0, 0, d.width, d.height);
+        Graphics2D g2 = (Graphics2D) mImage.getGraphics();
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        //draw medium line
+        int yLine = getHeight() - 25;
+
+        g2.setPaint(lineColor);
+        g2.drawLine(0, yLine, getWidth(), yLine);
+
+        RawAcceleration[] valuesArray = values.toArray(new RawAcceleration[0]);
+        
+        double unit = yLine / 255.0;
+        int previousX = 0;
+        int previousY = 0;
+        int previousZ = 0;
+        //draw curves
+        for (int i = 0; i < valuesArray.length && i < getWidth(); i++) {
+            RawAcceleration acceleration = valuesArray[i];
+            //draw X
+            g2.setPaint(xColor);
+            int yDelta = (int) Math.round(unit * acceleration.getX());
+            int y = -1 * yDelta + yLine;
+            g2.drawLine(i - 1, previousX, i, y);
+            g2.setTransform(new AffineTransform());
+            previousX = y;
+            //draw Y
+            g2.setPaint(yColor);
+            yDelta = (int) Math.round(unit * acceleration.getY());
+            y = -1 * yDelta + yLine;
+            g2.drawLine(i - 1, previousY, i, y);
+            g2.setTransform(new AffineTransform());
+            previousY = y;
+            //draw Z
+            g2.setPaint(zColor);
+            yDelta = (int) Math.round(unit * acceleration.getZ());
+            y = -1 * yDelta + yLine;
+            g2.drawLine(i - 1, previousZ, i, y);
+            g2.setTransform(new AffineTransform());
+            previousZ = y;
+        }
+
+        //draw legend
+        g2.setPaint(xColor);
+        g2.drawLine(5, getHeight() - 10, 25, getHeight() - 10);
+        g2.setPaint(yColor);
+        g2.drawLine(60, getHeight() - 10, 80, getHeight() - 10);
+        g2.setPaint(zColor);
+        g2.drawLine(120, getHeight() - 10, 140, getHeight() - 10);
+
+        g2.setPaint(lineColor);
+        g2.drawString("X", 30, getHeight() - 5);        
+        g2.drawString("Y", 85, getHeight() - 5);
+        g2.drawString("Z", 145, getHeight() - 5);
+        g2.drawString("0", 2, yLine - 5);
+        g2.drawString("255", 2, 15);
+        //put offscreen image on the screen
+        g.drawImage(mImage, 0, 0, null);
+    }
+
+    /**
+     * check if the mImage variable has been initialized. If it's not the case it initializes it
+     * with the dimensions of the panel. mImage is for double buffering.
+     */
+    private void checkOffScreenImage() {
+        Dimension d = getSize();
+        if (mImage == null || mImage.getWidth(null) != d.width || mImage.getHeight(null) != d.height) {
+            mImage = createImage(d.width, d.height);
+        }
+    }
+
+    public void onButtonsEvent(ButtonsEvent arg0) {
+    //nothing
+    }
+
+    public void onIrEvent(IREvent arg0) {
+    //nothing
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent arg0) {
+        if (values.size() >= getWidth()) {
+            //if there are as many values as pixels in the width
+            //clear points
+            values.clear();
+        }
+        values.add(arg0.getRawAcceleration());
+        repaint();
+    }
+
+    public void onStatusEvent(StatusEvent arg0) {
+    //nothing
+    }
+
+    public void onDisconnectionEvent(DisconnectionEvent arg0) {
+        //Clear points.
+        values.clear();
+        repaint();
+    }
+
+    /** This method is called from within the constructor to
+     * initialize the form.
+     * WARNING: Do NOT modify this code. The content of this method is
+     * always regenerated by the Form Editor.
+     */
+    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
+    private void initComponents() {
+
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+        this.setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 400, Short.MAX_VALUE)
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 300, Short.MAX_VALUE)
+        );
+    }// </editor-fold>//GEN-END:initComponents
+
+    // Variables declaration - do not modify//GEN-BEGIN:variables
+    // End of variables declaration//GEN-END:variables
+}

WiiUseJ_0.1/src/wiiusej/utils/ButtonsEventPanel.java

@@ -0,0 +1,297 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.utils;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.Toolkit;
+import java.awt.geom.AffineTransform;
+import wiiusej.wiiuseapievents.ButtonsEvent;
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.IREvent;
+import wiiusej.wiiuseapievents.MotionSensingEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.WiimoteListener;
+
+/**
+ * This panel is used to see what buttons are pressed.
+ * It displays the result of last ButtonsEvent.
+ * @author  guiguito
+ */
+public class ButtonsEventPanel extends javax.swing.JPanel implements WiimoteListener {
+
+    private Image mImage;//image for double buffering
+    private Image wiimoteImage;//image for double buffering
+    private ButtonsEvent buttons;
+    private Color pressedColor = Color.RED;
+    private Color heldColor = Color.ORANGE;
+    private Color releasedColor = Color.YELLOW;
+    private Shape shape;
+
+    /**
+     * Default constructor.
+     * Red : button just pressed.
+     * Orange : button held.
+     * Yellow : button just released.
+     */
+    public ButtonsEventPanel() {
+        Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();
+        java.net.URL url = ButtonsEventPanel.class.getResource("/img/wiimote.png");
+        wiimoteImage = toolkit.createImage(url);
+        shape = new java.awt.geom.Ellipse2D.Double(0, 0, 13, 13);
+        initComponents();
+    }
+    
+    /**
+     * Constructor used to set colors and shape used.
+     * @param pressColor color of a button just pressed.
+     * @param hColor color of a button held.
+     * @param relColor color of a button just released.
+     * @param sh shape draw on the buttons.
+     */
+    public ButtonsEventPanel(Color pressColor, Color hColor, Color relColor, Shape sh) {
+        pressedColor = pressColor;
+        heldColor = hColor;
+        releasedColor = relColor;
+        shape = sh;
+        Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();
+        wiimoteImage = toolkit.createImage("img\\wiimote.png");
+        shape = new java.awt.geom.Ellipse2D.Double(0, 0, 13, 13);
+        initComponents();
+    }
+
+    @Override
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Dimension d = getSize();
+        checkOffScreenImage();
+        Graphics offG = mImage.getGraphics();
+        //offG.setColor(backgroundColor);
+        offG.fillRect(0, 0, d.width, d.height);
+        Graphics2D g2 = (Graphics2D) mImage.getGraphics();
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        //draw buttons pushed
+        g2.drawImage(wiimoteImage, 0, 0, this);
+        g2.setTransform(new AffineTransform());
+
+        if (buttons != null) {
+            /* button ONE */
+            if (buttons.isButtonOneJustPressed()) {
+                drawFunction(g2,pressedColor,53,353);
+            }
+            if (buttons.isButtonOneHeld()) {
+                drawFunction(g2,heldColor,53,353);
+            }
+            if (buttons.isButtonOneJustReleased()) {
+                drawFunction(g2, releasedColor, 53, 353);
+            }
+            
+            /* button TWO */
+            if (buttons.isButtonTwoJustPressed()) {
+                drawFunction(g2,pressedColor,53,395);
+            }
+            if (buttons.isButtonTwoHeld()) {
+                drawFunction(g2,heldColor,53,395);
+            }
+            if (buttons.isButtonTwoJustReleased()) {
+                drawFunction(g2,releasedColor,53,395);
+            }
+
+            /* button A */
+            if (buttons.isButtonAJustPressed()) {
+                drawFunction(g2,pressedColor,53,150);
+            }
+            if (buttons.isButtonAHeld()) {
+                drawFunction(g2,heldColor,53,150);
+            }
+            if (buttons.isButtonAJustReleased()) {
+                drawFunction(g2,releasedColor,53,150);
+            }
+
+            /* button B */
+            if (buttons.isButtonBJustPressed()) {
+                drawFunction(g2,pressedColor,16,149);
+            }
+            if (buttons.isButtonBHeld()) {
+                drawFunction(g2,heldColor,16,149);
+            }
+            if (buttons.isButtonBJustReleased()) {
+                drawFunction(g2,releasedColor,16,149);
+            }
+
+            /* button LEFT */
+            if (buttons.isButtonLeftJustPressed()) {
+                drawFunction(g2,pressedColor,33,77);
+            }
+            if (buttons.isButtonLeftHeld()) {
+                drawFunction(g2,heldColor,33,77);
+            }
+            if (buttons.isButtonLeftJustReleased()) {
+                drawFunction(g2,releasedColor,33,77);
+            }
+
+            /* button RIGHT */
+            if (buttons.isButtonRightJustPressed()) {
+               drawFunction(g2,pressedColor,73,77);
+            }
+            if (buttons.isButtonRightHeld()) {
+                drawFunction(g2,heldColor,73,77);
+            }
+            if (buttons.isButtonRightJustReleased()) {
+                drawFunction(g2,releasedColor,73,77);
+            }
+            
+            /* button UP */
+            if (buttons.isButtonUpJustPressed()) {
+                drawFunction(g2,pressedColor,54,60);
+            }
+            if (buttons.isButtonUpHeld()) {
+                drawFunction(g2,heldColor,54,60);
+            }
+            if (buttons.isButtonUpJustReleased()) {
+                drawFunction(g2,releasedColor,54,60);
+            }
+
+            /* button DOWN */
+            if (buttons.isButtonDownJustPressed()) {
+                drawFunction(g2,pressedColor,54,97);
+            }
+            if (buttons.isButtonDownHeld()) {
+                drawFunction(g2,heldColor,54,97);
+            }
+            if (buttons.isButtonDownJustReleased()) {
+                drawFunction(g2,releasedColor,54,97);
+            }
+
+            /* button MINUS */
+            if (buttons.isButtonMinusJustPressed()) {
+               drawFunction(g2,pressedColor,20,230);
+            }
+            if (buttons.isButtonMinusHeld()) {
+                drawFunction(g2,heldColor,20,230);
+            }
+            if (buttons.isButtonMinusJustReleased()) {
+                drawFunction(g2,releasedColor,20,230);
+            }
+
+            /* button PLUS */
+            if (buttons.isButtonPlusJustPressed()) {
+                drawFunction(g2,pressedColor,86,230);
+            }
+            if (buttons.isButtonPlusHeld()) {
+                drawFunction(g2,heldColor,86,230);
+            }
+            if (buttons.isButtonPlusJustReleased()) {
+                drawFunction(g2,releasedColor,86,230);
+            }
+
+            /* button HOME */
+            if (buttons.isButtonHomeJustPressed()) {
+                drawFunction(g2,pressedColor,53,230);
+            }
+            if (buttons.isButtonHomeHeld()) {
+                drawFunction(g2,heldColor,53,230);
+            }
+            if (buttons.isButtonHomeJustReleased()) {
+                drawFunction(g2,releasedColor,53,230);
+            }
+
+            buttons = null;
+        }
+
+
+        //put offscreen image on the screen
+        g.drawImage(mImage, 0, 0, null);
+    }
+
+    /**
+     * Function used to factorize code.
+     * @param g2 where to draw a shape.
+     * @param col color to use.
+     * @param x x coordinates.
+     * @param y y coordinates.
+     */
+    private void drawFunction(Graphics2D g2, Color col, int x, int y) {
+        g2.setPaint(col);
+        g2.translate(x, y);
+        g2.draw(shape);
+        g2.fill(shape);
+        g2.setTransform(new AffineTransform());
+    }
+
+    /**
+     * check if the mImage variable has been initialized. If it's not the case it initializes it
+     * with the dimensions of the panel. mImage is for double buffering.
+     */
+    private void checkOffScreenImage() {
+        Dimension d = getSize();
+        if (mImage == null || mImage.getWidth(null) != d.width || mImage.getHeight(null) != d.height) {
+            mImage = createImage(d.width, d.height);
+        }
+    }
+
+    public void onButtonsEvent(ButtonsEvent arg0) {
+        setSize(wiimoteImage.getWidth(this), wiimoteImage.getHeight(this));
+        buttons = arg0;
+        repaint();
+    }
+
+    public void onIrEvent(IREvent arg0) {
+    //nothing
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent arg0) {
+    //nothing
+    }
+
+    public void onStatusEvent(StatusEvent arg0) {
+    //nothing
+    }
+
+    public void onDisconnectionEvent(DisconnectionEvent arg0) {       
+        buttons = null;
+        repaint();
+    }
+
+    /** This method is called from within the constructor to
+     * initialize the form.
+     * WARNING: Do NOT modify this code. The content of this method is
+     * always regenerated by the Form Editor.
+     */
+    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
+    private void initComponents() {
+
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+        this.setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 400, Short.MAX_VALUE)
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 300, Short.MAX_VALUE)
+        );
+    }// </editor-fold>//GEN-END:initComponents
+    // Variables declaration - do not modify//GEN-BEGIN:variables
+    // End of variables declaration//GEN-END:variables
+}

WiiUseJ_0.1/src/wiiusej/utils/GForcePanel.java

@@ -0,0 +1,201 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.utils;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.util.ArrayList;
+import wiiusej.values.GForce;
+import wiiusej.wiiuseapievents.ButtonsEvent;
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.IREvent;
+import wiiusej.wiiuseapievents.MotionSensingEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.WiimoteListener;
+
+/**
+ * This panel is used to watch gravity force values from a MotionSensingEvent.
+ * @author  guiguito
+ */
+public class GForcePanel extends javax.swing.JPanel implements WiimoteListener {
+
+    private Image mImage;//image for double buffering
+    private Color xColor = Color.RED;
+    private Color yColor = Color.GREEN;
+    private Color zColor = Color.BLUE;
+    private Color backgroundColor = Color.WHITE;
+    private Color lineColor = Color.BLACK;
+    private ArrayList<GForce> values = new ArrayList<GForce>();
+
+    /**
+     * Default constructor of the AccelerationPanel.
+     */
+    public GForcePanel() {
+        initComponents();
+    }
+    
+    /**
+     * Constructor used to choose the colors used by the AccelerationPanel.
+     * @param bgColor background color.
+     * @param xxColor color of the acceleration on X axis.
+     * @param yyColor color of the acceleration on Y axis.
+     * @param zzColor color of the acceleration on Z axis.
+     * @param lColor line color.
+     */
+    public GForcePanel(Color bgColor, Color xxColor, Color yyColor, Color zzColor, Color lColor) {
+        backgroundColor = bgColor;
+        xColor = xxColor;
+        yColor = yyColor;
+        zColor = zzColor;
+        lineColor = lColor;
+        initComponents();
+    }
+
+    @Override
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Dimension d = getSize();
+        checkOffScreenImage();
+        Graphics offG = mImage.getGraphics();
+        offG.setColor(backgroundColor);
+        offG.fillRect(0, 0, d.width, d.height);
+        Graphics2D g2 = (Graphics2D) mImage.getGraphics();
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        //draw medium line
+        double yMiddleFloat = getHeight() / 2.0;
+        int yMiddle = (int) Math.round(yMiddleFloat);
+
+        g2.setPaint(lineColor);
+        g2.drawLine(0, yMiddle, getWidth(), yMiddle);
+
+        GForce[] valuesArray = values.toArray(new GForce[0]);
+        double unit = yMiddleFloat / 5.0;
+        int previousX = 0;
+        int previousY = 0;
+        int previousZ = 0;
+        //draw curves
+        for (int i = 0; i < valuesArray.length && i < getWidth(); i++) {
+            GForce gforce = valuesArray[i];
+            //draw X
+            g2.setPaint(xColor);
+            int yDelta = (int) Math.round(unit * gforce.getX());
+            int y = -1 * yDelta + yMiddle;
+            g2.drawLine(i - 1, previousX, i, y);
+            g2.setTransform(new AffineTransform());
+            previousX = y;
+            //draw Y
+            g2.setPaint(yColor);
+            yDelta = (int) Math.round(unit * gforce.getY());
+            y = -1 * yDelta + yMiddle;
+            g2.drawLine(i - 1, previousY, i, y);
+            g2.setTransform(new AffineTransform());
+            previousY = y;
+            //draw Z
+            g2.setPaint(zColor);
+            yDelta = (int) Math.round(unit * gforce.getZ());
+            y = -1 * yDelta + yMiddle;
+            g2.drawLine(i - 1, previousZ, i, y);
+            g2.setTransform(new AffineTransform());
+            previousZ = y;
+        }
+
+        //draw legend
+        g2.setPaint(xColor);
+        g2.drawLine(5, getHeight() - 10, 25, getHeight() - 10);
+        g2.setPaint(yColor);
+        g2.drawLine(60, getHeight() - 10, 80, getHeight() - 10);
+        g2.setPaint(zColor);
+        g2.drawLine(120, getHeight() - 10, 140, getHeight() - 10);
+
+        g2.setPaint(lineColor);
+        g2.drawString("X", 30, getHeight() - 5);
+        g2.drawString("Y", 85, getHeight() - 5);
+        g2.drawString("Z", 145, getHeight() - 5);
+        g2.drawString("0", 2, yMiddle-5);
+        g2.drawString("5", 2, 10);
+        g2.drawString("-5", 2, getHeight()-15);
+        //put offscreen image on the screen
+        g.drawImage(mImage, 0, 0, null);
+    }
+
+    /**
+     * check if the mImage variable has been initialized. If it's not the case it initializes it
+     * with the dimensions of the panel. mImage is for double buffering.
+     */
+    private void checkOffScreenImage() {
+        Dimension d = getSize();
+        if (mImage == null || mImage.getWidth(null) != d.width || mImage.getHeight(null) != d.height) {
+            mImage = createImage(d.width, d.height);
+        }
+    }
+
+    public void onButtonsEvent(ButtonsEvent arg0) {
+    //nothing
+    }
+
+    public void onIrEvent(IREvent arg0) {
+    //nothing
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent arg0) {
+        if (values.size() >= getWidth()) {
+            //if there are as many values as pixels in the width
+            //clear points
+            values.clear();
+        }
+        values.add(arg0.getGforce());
+        repaint();
+    }
+
+    public void onStatusEvent(StatusEvent arg0) {
+    //nothing
+    }
+
+    public void onDisconnectionEvent(DisconnectionEvent arg0) {
+        //Clear points.
+        values.clear();
+        repaint();
+    }
+
+    /** This method is called from within the constructor to
+     * initialize the form.
+     * WARNING: Do NOT modify this code. The content of this method is
+     * always regenerated by the Form Editor.
+     */
+    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
+    private void initComponents() {
+
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+        this.setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 400, Short.MAX_VALUE)
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 300, Short.MAX_VALUE)
+        );
+    }// </editor-fold>//GEN-END:initComponents
+    // Variables declaration - do not modify//GEN-BEGIN:variables
+    // End of variables declaration//GEN-END:variables
+}

WiiUseJ_0.1/src/wiiusej/utils/IRPanel.java

@@ -0,0 +1,192 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.utils;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import wiiusej.wiiuseapievents.ButtonsEvent;
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.IREvent;
+import wiiusej.wiiuseapievents.MotionSensingEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.WiimoteListener;
+
+/**
+ * This panel is used to see what the IR camera of the wiimote sees.
+ * @author  guiguito
+ */
+public class IRPanel extends javax.swing.JPanel implements WiimoteListener {
+
+    private static int MAX_NB_POINTS = 4;
+    private Color color = Color.YELLOW;
+    private Color backgroundColor = Color.BLACK;
+    private Color borderColor = Color.BLUE;
+    private Shape shape;
+    private Image mImage;//image for double buffering
+    private int[] xCoordinates;
+    private int[] yCoordinates;
+    private int nbPoints=-1;
+
+    /**
+     * Default constructor for IR Panel.
+     * Background color : black.
+     * IR sources color : yellow.
+     * Border color of IR sources : blue.
+     * Shape of the IR sources : circle with a diameter of 10.
+     */
+    public IRPanel() {
+        shape = new java.awt.geom.Ellipse2D.Double(0, 0, 10, 10);
+        initArrays();
+        initComponents();
+    }
+    
+    /**
+     * Constructor used to parameterize the IR panel.
+     * @param bgColor color.
+     * @param ptColor IR sources color.
+     * @param bdColor border color of IR sources.
+     * @param sh Shape of the IR sources.
+     */
+    public IRPanel(Color bgColor, Color ptColor, Color bdColor, Shape sh) {
+        backgroundColor = bgColor;
+        color = ptColor;
+        borderColor = bdColor;
+        shape = sh;
+        initArrays();
+        initComponents();
+    }
+    
+    private void initArrays(){
+        xCoordinates = new int[MAX_NB_POINTS];
+        yCoordinates = new int[MAX_NB_POINTS];
+        for (int i = 0; i < MAX_NB_POINTS; i++) {
+            xCoordinates[i] = -1;
+            yCoordinates[i] = -1;
+        }
+    }
+
+    @Override
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Dimension d = getSize();
+        checkOffScreenImage();
+        Graphics offG = mImage.getGraphics();
+        offG.setColor(backgroundColor);
+        offG.fillRect(0, 0, d.width, d.height);
+        Graphics2D g2 = (Graphics2D) mImage.getGraphics();
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        //draw points
+        int i = 0;
+        while (xCoordinates[i] != -1 && yCoordinates[i] != -1 && i < nbPoints) {
+            double x = xCoordinates[i];
+            double y = yCoordinates[i];
+
+            long xx = getWidth() - Math.round((double) getWidth() * x / 1024.0);
+            long yy = getHeight() - Math.round((double) getHeight() * y / 768.0);
+            g2.translate(xx, yy);
+
+            g2.setPaint(borderColor);
+            g2.draw(shape);
+            g2.setPaint(color);
+            g2.fill(shape);
+
+            g2.setTransform(new AffineTransform());
+            i++;
+        }
+        //put offscreen image on the screen
+        g.drawImage(mImage, 0, 0, null);
+    }
+
+    /**
+     * check if the mImage variable has been initialized. If it's not the case it initializes it
+     * with the dimensions of the panel. mImage is for double buffering.
+     */
+    private void checkOffScreenImage() {
+        Dimension d = getSize();
+        if (mImage == null || mImage.getWidth(null) != d.width || mImage.getHeight(null) != d.height) {
+            mImage = createImage(d.width, d.height);
+        }
+    }
+
+    public void onButtonsEvent(ButtonsEvent arg0) {
+        //nothing
+    }
+
+    public void onIrEvent(IREvent arg0) {
+        //transfer points
+        wiiusej.values.IRSource[] points = arg0.getIRPoints();
+        nbPoints = points.length;
+        for (int i = 0; i < points.length; i++) {
+            xCoordinates[i] = (int) points[i].getRx();
+            yCoordinates[i] = (int) points[i].getRy();
+        }
+        for (int i = points.length; i < MAX_NB_POINTS; i++) {
+            xCoordinates[i] = -1;
+            yCoordinates[i] = -1;
+        }
+
+        //redraw panel
+        repaint();
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent arg0) {
+    //nothing
+    }
+
+    public void onStatusEvent(StatusEvent arg0) {
+    //nothing
+    }
+
+    public void onDisconnectionEvent(DisconnectionEvent arg0) {
+        //clear previous points
+        for (int i = 0; i < MAX_NB_POINTS; i++) {
+            xCoordinates[i] = -1;
+            yCoordinates[i] = -1;
+        }
+        //redraw panel
+        repaint();
+    }
+
+    /** This method is called from within the constructor to
+     * initialize the form.
+     * WARNING: Do NOT modify this code. The content of this method is
+     * always regenerated by the Form Editor.
+     */
+    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
+    private void initComponents() {
+
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+        this.setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 400, Short.MAX_VALUE)
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 300, Short.MAX_VALUE)
+        );
+    }// </editor-fold>//GEN-END:initComponents
+    // Variables declaration - do not modify//GEN-BEGIN:variables
+    // End of variables declaration//GEN-END:variables
+}

WiiUseJ_0.1/src/wiiusej/utils/OrientationPanel.java

@@ -0,0 +1,205 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.utils;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.util.ArrayList;
+import wiiusej.values.Orientation;
+import wiiusej.wiiuseapievents.ButtonsEvent;
+import wiiusej.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiuseapievents.IREvent;
+import wiiusej.wiiuseapievents.MotionSensingEvent;
+import wiiusej.wiiuseapievents.StatusEvent;
+import wiiusej.wiiuseapievents.WiimoteListener;
+
+/**
+ * This panel is used to watch orientation values from a MotionSensingEvent.
+ * @author  guiguito
+ */
+public class OrientationPanel extends javax.swing.JPanel implements WiimoteListener {
+
+    private Image mImage;//image for double buffering
+    private Color rollColor = Color.RED;
+    private Color pitchColor = Color.GREEN;
+    private Color yawColor = Color.BLUE;
+    private Color backgroundColor = Color.WHITE;
+    private Color lineColor = Color.BLACK;
+    private ArrayList<Orientation> values = new ArrayList<Orientation>();
+
+    /**
+     * Default constructor.
+     * Background color : White.
+     * Roll color : Red.
+     * Pitch color : Green.
+     * Yaw color : Blue.
+     */
+    public OrientationPanel() {
+        initComponents();
+    }
+    
+    /**
+     * Constructor used to choose the colors used by the OrientationPanel.
+     * @param bgColor background color.
+     * @param rColor roll color.
+     * @param pColor pitch color.
+     * @param yColor yaw color.
+     * @param lColor line color.
+     */
+    public OrientationPanel(Color bgColor, Color rColor, Color pColor, Color yColor, Color lColor) {
+        backgroundColor = bgColor;
+        rollColor = rColor;
+        pitchColor = pColor;
+        yawColor = yColor;
+        lineColor = lColor;
+        initComponents();
+    }
+
+    @Override
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Dimension d = getSize();
+        checkOffScreenImage();
+        Graphics offG = mImage.getGraphics();
+        offG.setColor(backgroundColor);
+        offG.fillRect(0, 0, d.width, d.height);
+        Graphics2D g2 = (Graphics2D) mImage.getGraphics();
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        //draw medium line
+        double yMiddleFloat = getHeight() / 2.0;
+        int yMiddle = (int) Math.round(yMiddleFloat);
+
+        g2.setPaint(lineColor);
+        g2.drawLine(0, yMiddle, getWidth(), yMiddle);
+
+        Orientation[] valuesArray = values.toArray(new Orientation[0]);
+        double unit = yMiddleFloat / 180.0;
+        int previousRoll = 0;
+        int previousPitch = 0;
+        int previousYaw = 0;
+        //draw curves
+        for (int i = 0; i < valuesArray.length && i < getWidth(); i++) {
+            Orientation orientation = valuesArray[i];           
+             //draw roll
+            g2.setPaint(rollColor);
+            int yDelta = (int) Math.round(unit * orientation.getRoll());
+            int y = -1 * yDelta + yMiddle;
+            g2.drawLine(i-1, previousRoll, i, y);
+            g2.setTransform(new AffineTransform());
+            previousRoll = y;
+            //draw pitch
+            g2.setPaint(pitchColor);
+            yDelta = (int) Math.round(unit * orientation.getPitch());
+            y = -1 * yDelta + yMiddle;
+            g2.drawLine(i-1, previousPitch, i, y);
+            g2.setTransform(new AffineTransform());
+            previousPitch = y;
+            //draw yaw
+            g2.setPaint(yawColor);
+            yDelta = (int) Math.round(unit * orientation.getYaw());
+            y = -1 * yDelta + yMiddle;
+            g2.drawLine(i-1, previousYaw, i, y);
+            g2.setTransform(new AffineTransform());
+            previousYaw = y;
+        }
+        
+        //draw legend
+        g2.setPaint(rollColor);
+        g2.drawLine(5, getHeight()-10, 25, getHeight()-10);                
+        g2.setPaint(pitchColor);
+        g2.drawLine(60, getHeight()-10, 80, getHeight()-10);
+        g2.setPaint(yawColor);
+        g2.drawLine(120, getHeight()-10, 140, getHeight()-10);
+        
+        g2.setPaint(lineColor);
+        g2.drawString("Roll", 30, getHeight()-5);
+        g2.drawString("Pitch", 85, getHeight()-5);
+        g2.drawString("Yaw", 145, getHeight()-5);
+        g2.drawString("0", 2, yMiddle-5);
+        g2.drawString("180", 2, 10);
+        g2.drawString("-180", 2, getHeight()-15);
+        //put offscreen image on the screen
+        g.drawImage(mImage, 0, 0, null);
+    }
+
+    /**
+     * check if the mImage variable has been initialized. If it's not the case it initializes it
+     * with the dimensions of the panel. mImage is for double buffering.
+     */
+    private void checkOffScreenImage() {
+        Dimension d = getSize();
+        if (mImage == null || mImage.getWidth(null) != d.width || mImage.getHeight(null) != d.height) {
+            mImage = createImage(d.width, d.height);
+        }
+    }
+
+    public void onButtonsEvent(ButtonsEvent arg0) {
+    //nothing
+    }
+
+    public void onIrEvent(IREvent arg0) {
+    //nothing
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent arg0) {
+        if (values.size() >= getWidth()) {
+            //if there are as many values as pixels in the width
+            //clear points
+            values.clear();
+        }
+        values.add(arg0.getOrientation());
+        repaint();
+    }
+
+    public void onStatusEvent(StatusEvent arg0) {
+    //nothing
+    }
+
+    public void onDisconnectionEvent(DisconnectionEvent arg0) {
+        //Clear points.
+        values.clear();
+        repaint();
+    }
+
+    /** This method is called from within the constructor to
+     * initialize the form.
+     * WARNING: Do NOT modify this code. The content of this method is
+     * always regenerated by the Form Editor.
+     */
+    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
+    private void initComponents() {
+
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+        this.setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 400, Short.MAX_VALUE)
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGap(0, 300, Short.MAX_VALUE)
+        );
+    }// </editor-fold>//GEN-END:initComponents
+    // Variables declaration - do not modify//GEN-BEGIN:variables
+    // End of variables declaration//GEN-END:variables
+}

WiiUseJ_0.1/src/wiiusej/values/GForce.java

@@ -0,0 +1,75 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.values;
+
+/**
+ * Represents gravity force on each axis.
+ * @author guiguito
+ */
+public class GForce {
+
+	private float x;
+	private float y;
+	private float z;
+	
+	/**
+	 * Default constructor;
+	 */
+	public GForce(){
+		x = 0;
+		y = 0;
+		z = 0;
+	}
+	
+	/**
+	 * Constructor with gravity force on each axis.
+	 * @param xx x value
+	 * @param yy x value
+	 * @param zz x value
+	 */
+	public GForce(float xx, float yy, float zz){
+		x = xx;
+		y = yy;
+		z = zz;
+	}
+
+	/**
+	 * @return the x
+	 */
+	public float getX() {
+		return x;
+	}
+
+	/**
+	 * @return the y
+	 */
+	public float getY() {
+		return y;
+	}
+
+	/**
+	 * @return the z
+	 */
+	public float getZ() {
+		return z;
+	}
+	
+	@Override
+	public String toString() {
+		return "Gravity force : ("+x+", "+y+","+z+")";
+	}
+}

WiiUseJ_0.1/src/wiiusej/values/IRSource.java

@@ -0,0 +1,109 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.values;
+
+/**
+ * Class used for IR sources.
+ * @author guiguito
+ */
+public class IRSource{
+	
+	private int x;
+	private int y;
+	private short rx;
+	private short ry;
+	private short size;
+	
+	/**
+	 * Build an IR source with all details.
+	 * 
+	 * @param xx
+	 *            xx interpolated coordinates.
+	 * @param yy
+	 *            yy interpolated coordinates.
+	 * @param rxx
+	 *            raw X coordinate (0-1023).
+	 * @param ryy
+	 *            raw Y coordinate (0-1023).
+	 * @param si
+	 *            size of the IR dot (0-15).
+	 */
+	public IRSource(int xx, int yy, short rxx, short ryy, short si) {		
+		x = xx;
+		y = yy;
+		rx = rxx;
+		ry = ryy;
+		size = si;
+	}
+		
+	
+	/**
+	 * Return x interpolated coordinates.
+	 * @return the x
+	 */
+	public int getX() {
+		return x;
+	}
+
+
+
+	/**
+	 * Return y interpolated coordinates.
+	 * @return the y
+	 */
+	public int getY() {
+		return y;
+	}
+
+
+
+	/**
+	 * Return raw X coordinate (0-1023).
+	 * @return the rx
+	 */
+	public short getRx() {
+		return rx;
+	}
+
+
+
+	/**
+	 * Return raw Y coordinate (0-1023).
+	 * @return the ry
+	 */
+	public short getRy() {
+		return ry;
+	}
+
+
+
+	/**
+	 * Return size of the IR dot (0-15).
+	 * @return the size
+	 */
+	public short getSize() {
+		return size;
+	}
+
+
+
+	@Override
+	public String toString() {
+		return "Interpolated coordinates ("+x+","+y+"), Raw coordinates("+rx+","+ry+"), source size : "+size+")";
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/values/Orientation.java

@@ -0,0 +1,76 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.values;
+
+/**
+ * Class that represents the orientation of the wiimote.
+ * @author guiguito
+ */
+public class Orientation {
+	
+		private float roll;
+		private float pitch;
+		private float yaw;
+		
+		/**
+		 * Default constructor.
+		 */
+		public Orientation(){
+			roll = 0;
+			pitch = 0;
+			yaw = 0;
+		}
+		
+		/**
+		 * Contructor with raw, pitch , yaw.
+		 * @param r raw
+		 * @param p pitch
+		 * @param y yaw
+		 */
+		public Orientation(float r, float p, float y){
+			roll = r;
+			pitch = p;
+			yaw = y;
+		}
+		
+		/**
+		 * @return the roll
+		 */
+		public float getRoll() {
+			return roll;
+		}
+
+		/**
+		 * @return the pitch
+		 */
+		public float getPitch() {
+			return pitch;
+		}
+
+		/**
+		 * @return the yaw
+		 */
+		public float getYaw() {
+			return yaw;
+		}
+		
+		@Override
+		public String toString() {
+			return "Orientation : (roll: "+roll+", pitch: "+pitch+", yaw: "+yaw+")";			
+		}
+	
+}

WiiUseJ_0.1/src/wiiusej/values/RawAcceleration.java

@@ -0,0 +1,75 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.values;
+
+/**
+ * Represents raw acceleration on each axis.
+ * @author guiguito
+ */
+public class RawAcceleration {
+	
+	private short x;
+	private short y;
+	private short z;
+	
+	/**
+	 * Default constructor;
+	 */
+	public RawAcceleration() {
+		x = 0;
+		y = 0;
+		z = 0;
+	}
+	
+	/**
+	 * Constructor with raw acceleration on each axis.
+	 * @param xx x value
+	 * @param yy x value
+	 * @param zz x value
+	 */
+	public RawAcceleration(short xx, short yy, short zz) {
+		x = xx;
+		y = yy;
+		z = zz;
+	}
+
+	/**
+	 * @return the x
+	 */
+	public short getX() {
+		return x;
+	}
+	/**
+	 * @return the y
+	 */
+	public short getY() {
+		return y;
+	}
+
+	/**
+	 * @return the z
+	 */
+	public short getZ() {
+		return z;
+	}
+	
+	@Override
+	public String toString() {
+		return "Raw acceleration : ("+x+", "+y+","+z+")";
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/ButtonsEvent.java

@@ -0,0 +1,335 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * Class which represents a buttons event.
+ * @author guiguito
+ */
+public class ButtonsEvent extends WiimoteEvent{
+	
+	/* Buttons MACRO */
+	private static short WIIMOTE_BUTTON_TWO = 0x0001;
+	private static short WIIMOTE_BUTTON_ONE = 0x0002;
+	private static short WIIMOTE_BUTTON_B = 0x0004;
+	private static short WIIMOTE_BUTTON_A = 0x0008;
+	private static short WIIMOTE_BUTTON_MINUS = 0x0010;
+	private static short WIIMOTE_BUTTON_ZACCEL_BIT6 = 0x0020;
+	private static short WIIMOTE_BUTTON_ZACCEL_BIT7 = 0x0040;
+	private static short WIIMOTE_BUTTON_HOME = 0x0080;
+	private static short WIIMOTE_BUTTON_LEFT = 0x0100;
+	private static short WIIMOTE_BUTTON_RIGHT = 0x0200;
+	private static short WIIMOTE_BUTTON_DOWN = 0x0400;
+	private static short WIIMOTE_BUTTON_UP = 0x0800;
+	private static short WIIMOTE_BUTTON_PLUS = 0x1000;
+	private static short WIIMOTE_BUTTON_ZACCEL_BIT4 = 0x2000;
+	private static short WIIMOTE_BUTTON_ZACCEL_BIT5 = 0x4000;
+	private static int WIIMOTE_BUTTON_UNKNOWN = 0x8000;
+	private static short WIIMOTE_BUTTON_ALL = 0x1F9F;
+	
+	/* Buttons */
+	private short buttonsJustPressed = 0;
+	private short buttonsJustReleased = 0;
+	private short buttonsHeld = 0;
+	
+	/**
+	 * Constructor of the button Event.
+	 * @param id id of the wiimote concerned.
+	 * @param buttonsJustPressed buttons just pressed.
+	 * @param buttonsJustReleased buttons just released.
+	 * @param buttonsHeld buttons just held.
+	 */
+	public ButtonsEvent(int id, short buttonsJustPressed,
+			short buttonsJustReleased, short buttonsHeld){
+		super(id);
+		setAllButtons(buttonsJustPressed, buttonsJustReleased, buttonsHeld);
+	}
+	
+	/**
+	 * Set all buttons in one method.
+	 * 
+	 * @param buttonsJustPressed
+	 * @param buttonsJustReleased
+	 * @param buttonsHeld
+	 */
+	private void setAllButtons(short buttonsJustPressed,
+			short buttonsJustReleased, short buttonsHeld) {
+		this.buttonsJustPressed = buttonsJustPressed;
+		this.buttonsJustReleased = buttonsJustReleased;
+		this.buttonsHeld = buttonsHeld;
+	}
+	
+	/**
+	 * Get the short storing the buttons just pressed
+	 * 
+	 * @return the short storing the buttons just pressed
+	 */
+	public short getButtonsJustPressed() {
+		return buttonsJustPressed;
+	}
+
+	/**
+	 * Get the short storing the buttons just released
+	 * 
+	 * @return the short storing the buttons just released
+	 */
+	public short getButtonsJustReleased() {
+		return buttonsJustReleased;
+	}
+
+	/**
+	 * get the short storing the buttons held
+	 * 
+	 * @return the short storing the buttons held
+	 */
+	public short getButtonsHeld() {
+		return buttonsHeld;
+	}
+	
+	/** **************** BUTTONS Methods ***************** */
+	/* generic button functions */
+
+	private boolean buttonTest(short buttonBitsDefinition, short buttons) {
+		return (buttons & buttonBitsDefinition) == buttonBitsDefinition;
+	}
+
+	private boolean isButtonJustPressed(short buttonBitsDefinition) {
+		return buttonTest(buttonBitsDefinition, buttonsJustPressed)
+				&& !isButtonHeld(buttonBitsDefinition);
+	}
+
+	private boolean isButtonJustReleased(short buttonBitsDefinition) {
+		return buttonTest(buttonBitsDefinition, buttonsJustReleased);
+	}
+
+	private boolean isButtonHeld(short buttonBitsDefinition) {
+		return buttonTest(buttonBitsDefinition, buttonsHeld);
+	}
+	
+	private boolean isButtonPressed(short buttonBitsDefinition) {
+		return isButtonHeld(buttonBitsDefinition)||isButtonJustPressed(buttonBitsDefinition);
+	}
+	/* Button ONE */
+
+	public boolean isButtonOneJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_ONE);
+	}
+
+	public boolean isButtonOneJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_ONE);
+	}
+
+	public boolean isButtonOneHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_ONE);
+	}
+	
+	public boolean isButtonOnePressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_ONE);
+	}
+
+	/* Button TWO */
+
+	public boolean isButtonTwoJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_TWO);
+	}
+
+	public boolean isButtonTwoJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_TWO);
+	}
+
+	public boolean isButtonTwoHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_TWO);
+	}
+	
+	public boolean isButtonTwoPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_TWO);
+	}
+
+	/* Button A */
+
+	public boolean isButtonAJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_A);
+	}
+
+	public boolean isButtonAJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_A);
+	}
+
+	public boolean isButtonAHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_A);
+	}
+	
+	public boolean isButtonAPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_A);
+	}
+
+	/* Button B */
+
+	public boolean isButtonBJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_B);
+	}
+
+	public boolean isButtonBJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_B);
+	}
+
+	public boolean isButtonBHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_B);
+	}
+	
+	public boolean isButtonBPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_B);
+	}
+
+	/* Button LEFT */
+
+	public boolean isButtonLeftJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_LEFT);
+	}
+
+	public boolean isButtonLeftJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_LEFT);
+	}
+
+	public boolean isButtonLeftHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_LEFT);
+	}
+	
+	public boolean isButtonLeftPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_LEFT);
+	}
+
+	/* Button RIGHT */
+
+	public boolean isButtonRightJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_RIGHT);
+	}
+
+	public boolean isButtonRightJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_RIGHT);
+	}
+
+	public boolean isButtonRightHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_RIGHT);
+	}
+	
+	public boolean isButtonRightPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_RIGHT);
+	}
+
+	/* Button UP */
+
+	public boolean isButtonUpJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_UP);
+	}
+
+	public boolean isButtonUpJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_UP);
+	}
+
+	public boolean isButtonUpHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_UP);
+	}
+	
+	public boolean isButtonUpPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_UP);
+	}
+
+	/* Button DOWN */
+
+	public boolean isButtonDownJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_DOWN);
+	}
+
+	public boolean isButtonDownJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_DOWN);
+	}
+
+	public boolean isButtonDownHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_DOWN);
+	}
+	
+	public boolean isButtonDownPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_DOWN);
+	}
+
+	/* Button - */
+
+	public boolean isButtonMinusJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_MINUS);
+	}
+
+	public boolean isButtonMinusJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_MINUS);
+	}
+
+	public boolean isButtonMinusHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_MINUS);
+	}
+	
+	public boolean isButtonMinusPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_MINUS);
+	}
+
+	/* Button + */
+
+	public boolean isButtonPlusJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_PLUS);
+	}
+
+	public boolean isButtonPlusJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_PLUS);
+	}
+
+	public boolean isButtonPlusHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_PLUS);
+	}
+	
+	public boolean isButtonPlusPressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_PLUS);
+	}
+
+	/* Button HOME */
+
+	public boolean isButtonHomeJustPressed() {
+		return isButtonJustPressed(WIIMOTE_BUTTON_HOME);
+	}
+
+	public boolean isButtonHomeJustReleased() {
+		return isButtonJustReleased(WIIMOTE_BUTTON_HOME);
+	}
+
+	public boolean isButtonHomeHeld() {
+		return isButtonHeld(WIIMOTE_BUTTON_HOME);
+	}
+	
+	public boolean isButtonHomePressed() {
+		return isButtonPressed(WIIMOTE_BUTTON_HOME);
+	}
+	
+	@Override
+	public String toString() {
+		String out = "";
+		/* Display buttons */
+		out += "/******** Buttons ********/\n";
+		out += "--- Buttons just pressed : " + buttonsJustPressed + "\n";
+		out += "--- Buttons just released : " + buttonsJustReleased + "\n";
+		out += "--- Buttons held : " + buttonsHeld + "\n";
+		return out;
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/DisconnectionEvent.java

@@ -0,0 +1,44 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * Class representing a disconnection event.
+ * @author guiguito
+ */
+public class DisconnectionEvent extends WiiUseApiEvent {
+
+	/**
+	 * Construct the DisconnectionEvent setting up the id.
+	 * 
+	 * @param id
+	 *            the Wiimote id
+	 */
+	public DisconnectionEvent(int id) {
+		super(id,WiiUseApiEvent.DISCONNECTION_EVENT);
+	}
+		
+	@Override
+	public String toString() {
+		String out = "";
+		/* Status */
+		out += "/*********** DISCONNECTION EVENT : WIIMOTE   ID :" + super.getWiimoteId() + " ********/\n";
+
+		return out;
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/EventsGatherer.java

@@ -0,0 +1,241 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * This class is used to gather events during a call to the Wiiuse API.
+ * 
+ * @author guiguito
+ */
+public class EventsGatherer {
+
+	private WiiUseApiEvent[] events;
+	private int index = 0;
+	private GenericEvent genericEvent = null;
+
+	/**
+	 * Create EventsGatherer.
+	 * 
+	 * @param nbWiimotes
+	 *            nb wiimotes (nb a of events possible in a call to Wiiuse API)
+	 */
+	public EventsGatherer(int nbWiimotes) {
+		events = new WiiUseApiEvent[nbWiimotes];
+	}
+
+	/**
+	 * Add an event to the array.
+	 * 
+	 * @param e
+	 *            the event to add.
+	 */
+	private void addEvent(WiiUseApiEvent e) {
+		events[index] = e;
+		index++;
+	}
+
+	/**
+	 * Prepare a wiimote event to add.
+	 * 
+	 * @param id
+	 *            id of the wiimote.
+	 * @param buttonsJustPressed
+	 *            buttons just pressed
+	 * @param buttonsJustReleased
+	 *            buttons just released
+	 * @param buttonsHeld
+	 *            buttons held
+	 */
+	public void prepareWiiMoteEvent(int id, short buttonsJustPressed,
+			short buttonsJustReleased, short buttonsHeld) {
+		genericEvent = new GenericEvent(id, buttonsJustPressed,
+				buttonsJustReleased, buttonsHeld);
+	}
+
+	/**
+	 * Prepare an IR event to populate.
+	 * 
+	 * @param x
+	 *            calculated X coordinate.
+	 * @param y
+	 *            calculated Y coordinate.
+	 * @param z
+	 *            calculated distance.
+	 * @param ax
+	 *            absolute X coordinate.
+	 * @param ay
+	 *            absolute Y coordinate
+	 * @param xVRes
+	 *            IR virtual screen x resolution.
+	 * @param yVRes
+	 *            IR virtual screen y resolution.
+	 * @param xOffset
+	 *            IR X correction offset.
+	 * @param yOffset
+	 *            IR Y correction offset.
+	 * @param sensorBarPostion
+	 *            aspect ratio of the screen.
+	 * @param screenAsPectRatio
+	 *            IR sensor bar position.
+	 */
+	public void prepareIRevent(int x, int y, int z, int ax, int ay, int xVRes,
+			int yVRes, int xOffset, int yOffset, short sensorBarPostion,
+			short screenAsPectRatio) {
+		genericEvent.prepareIRevent(x, y, z, ax, ay, xVRes, yVRes, xOffset,
+				yOffset, sensorBarPostion, screenAsPectRatio);
+
+	}
+
+	/**
+	 * Add an IR point to the WiiMoteEvent prepared
+	 * 
+	 * @param x
+	 *            x coordinates
+	 * @param y
+	 *            y coordinates
+	 * @param rx
+	 *            raw X coordinate (0-1023).
+	 * @param ry
+	 *            raw Y coordinate (0-1023).
+	 * @param size
+	 *            size of the IR dot (0-15).
+	 */
+	public void addIRPointToPreparedWiiMoteEvent(int x, int y, short rx,
+			short ry, short size) {
+		if (genericEvent != null) {
+			genericEvent.addIRpoint(x, y, rx, ry, size);
+		}
+	}
+
+	/**
+	 * Set orientation and gravity force of the prepared event.
+	 * 
+	 * @param orientationThreshold
+	 *            value of the minimum angle between two events with the
+	 *            accelerometer
+	 * @param accelerationThreshold
+	 *            value of the value variation between two events with the
+	 *            accelerometer
+	 * @param smoothingState
+	 *            true if smoothing flag is activated
+	 * @param alphaSmooth
+	 *            value of the alpha smoothing parameter
+	 * @param r
+	 *            roll
+	 * @param p
+	 *            pitch
+	 * @param ya
+	 *            yaw
+	 * @param x
+	 *            gravity force on x axis
+	 * @param y
+	 *            gravity force on y axis
+	 * @param z
+	 *            gravity force on z axis
+	 * @param xx
+	 *            raw acceleration on x axis
+	 * @param yy
+	 *            raw acceleration on y axis
+	 * @param zz
+	 *            raw acceleration on z axis
+	 */
+	public void addMotionSensingValues(float orientationThreshold,
+			int accelerationThreshold, boolean smoothingState,
+			float alphaSmooth, float r, float p, float ya, float x, float y,
+			float z, short xx, short yy, short zz) {
+		if (genericEvent != null) {
+			genericEvent.setMotionSensingEvent(orientationThreshold,
+					accelerationThreshold, smoothingState, alphaSmooth, r, p,
+					ya, x, y, z, xx, yy, zz);
+		}
+	}
+
+	/**
+	 * Add the prepared WiimoteEvent to the gatherer.
+	 */
+	public void addWiimoteEvent() {
+		if (genericEvent != null) {
+			addEvent(genericEvent);
+			genericEvent = null;
+		}
+	}
+
+	/**
+	 * Add a StatusEvent to the gatherer.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 * @param connect
+	 *            true if the wiimote is connected
+	 * @param batt
+	 *            battery level
+	 * @param led
+	 *            status of leds
+	 * @param speak
+	 *            speakers status
+	 * @param attach
+	 *            attachment status
+	 * @param rumbleState
+	 *            true if rumble is active
+	 * @param continuousState
+	 *            true if continuous flag is activated
+	 * @param irState
+	 *            true if ir is active
+	 * @param motionSensingState
+	 *            true if accelerometer is active
+	 */
+	public void addStatusEvent(int id, boolean connect, float batt, short led,
+			boolean speak, int attach, boolean rumbleState,
+			boolean continuousState, boolean irState, boolean motionSensingState) {
+		StatusEvent evt = new StatusEvent(id, connect, batt, led, speak,
+				attach, rumbleState, continuousState, irState,
+				motionSensingState);
+		addEvent(evt);
+	}
+
+	/**
+	 * Add a DisconnectionEvent to the gatherer.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 */
+	public void addDisconnectionEvent(int id) {
+		DisconnectionEvent evt = new DisconnectionEvent(id);
+		addEvent(evt);
+	}
+
+	/**
+	 * Return an array containing the events.
+	 * 
+	 * @return events received
+	 */
+	public WiiUseApiEvent[] getEvents() {
+		return java.util.Arrays.copyOfRange(events, 0, index);
+	}
+
+	/**
+	 * Clear the gatherer and remove objects.
+	 */
+	public void clearEvents() {
+		for (int i = 0; i < events.length; i++) {
+			events[i] = null;
+		}
+		genericEvent = null;
+		index = 0;
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/GenericEvent.java

@@ -0,0 +1,227 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * Class that is a bean to be filled by the wiiuse API.
+ * 
+ * @author guiguito
+ */
+public class GenericEvent extends WiiUseApiEvent {
+
+	ButtonsEvent buttonsEvent = null;
+	IREvent infraredEvent = null;
+	MotionSensingEvent motionSensingEvent = null;
+
+	/**
+	 * Construct the Wiimote setting up the id.
+	 * 
+	 * @param id
+	 *            the Wiimote id
+	 */
+	public GenericEvent(int id) {
+		super(id, WiiUseApiEvent.GENERIC_EVENT);
+	}
+
+	/**
+	 * Construct the Wiimote setting up the id and the buttons.
+	 * 
+	 * @param id
+	 *            the Wiimote id
+	 * @param buttonsJustPressed
+	 *            buttons just pressed
+	 * @param buttonsJustReleased
+	 *            buttons just released
+	 * @param buttonsHeld
+	 *            buttons held
+	 */
+	public GenericEvent(int id, short buttonsJustPressed,
+			short buttonsJustReleased, short buttonsHeld) {
+		super(id, WiiUseApiEvent.GENERIC_EVENT);
+		buttonsEvent = new ButtonsEvent(id, buttonsJustPressed,
+				buttonsJustReleased, buttonsHeld);
+	}
+
+	/**
+	 * Tell if there is an IR Event.
+	 * 
+	 * @return TRUE if there is an IR event.
+	 */
+	public boolean isThereIrEvent() {
+		return infraredEvent != null;
+	}
+
+	/**
+	 * Tell if there is a motion sensing Event.
+	 * 
+	 * @return TRUE if there is a motion sensing event.
+	 */
+	public boolean isThereMotionSensingEvent() {
+		return motionSensingEvent != null;
+	}
+
+	/**
+	 * Get buttons event.
+	 * 
+	 * @return the buttons event.
+	 */
+	public ButtonsEvent getButtonsEvent() {
+		return buttonsEvent;
+	}
+
+	/**
+	 * Get IR event.
+	 * 
+	 * @return the IR event if there is one or null.
+	 */
+	public IREvent getIREvent() {
+		return infraredEvent;
+	}
+
+	/**
+	 * Get motion sensing event.
+	 * 
+	 * @return the motion sensing event if there is one or null.
+	 */
+	public MotionSensingEvent getMotionSensingEvent() {
+		return motionSensingEvent;
+	}
+
+	/**
+	 * Prepare an IR event to populate.
+	 * 
+	 * @param x
+	 *            calculated X coordinate.
+	 * @param y
+	 *            calculated Y coordinate.
+	 * @param z
+	 *            calculated distance.
+	 * @param ax
+	 *            absolute X coordinate.
+	 * @param ay
+	 *            absolute Y coordinate
+	 * @param xVRes
+	 *            IR virtual screen x resolution.
+	 * @param yVRes
+	 *            IR virtual screen y resolution.
+	 * @param xOffset
+	 *            IR X correction offset.
+	 * @param yOffset
+	 *            IR Y correction offset.
+	 * @param sensorBarPostion
+	 *            aspect ratio of the screen.
+	 * @param screenAsPectRatio
+	 *            IR sensor bar position.
+	 */
+	public void prepareIRevent(int x, int y, int z, int ax, int ay, int xVRes,
+			int yVRes, int xOffset, int yOffset, short sensorBarPostion,
+			short screenAsPectRatio) {
+		if (infraredEvent == null) {
+			infraredEvent = new IREvent(getWiimoteId(), x, y, z, ax, ay, xVRes,
+					yVRes, xOffset, yOffset, sensorBarPostion,
+					screenAsPectRatio);
+		}
+	}
+
+	/**
+	 * Add an IR point to the generic event. Create an IR Event if it's not
+	 * created yet.
+	 * 
+	 * @param x
+	 *            x coordinates.
+	 * @param y
+	 *            y coordinates
+	 * @param rx
+	 *            raw X coordinate (0-1023).
+	 * @param ry
+	 *            raw Y coordinate (0-1023).
+	 * @param size
+	 *            size of the IR dot (0-15).
+	 */
+	public void addIRpoint(int x, int y, short rx, short ry, short size) {
+		if (infraredEvent != null)
+			infraredEvent.addIRpoint(x, y, rx, ry, size);
+	}
+
+	/**
+	 * Set the Motion Sensing Event.
+	 * 
+	 * @param orientationThreshold
+	 *            value of the minimum angle between two events with the
+	 *            accelerometer
+	 * @param accelerationThreshold
+	 *            value of the value variation between two events with the
+	 *            accelerometer
+	 * @param smoothingState
+	 *            true if smoothing flag is activated
+	 * @param alphaSmooth
+	 *            value of the alpha smoothing parameter
+	 * @param r
+	 *            roll
+	 * @param p
+	 *            pitch
+	 * @param ya
+	 *            yaw
+	 * @param x
+	 *            gravity force on x axis
+	 * @param y
+	 *            gravity force on y axis
+	 * @param z
+	 *            gravity force on z axis
+	 * @param xx
+	 *            raw acceleration on x axis
+	 * @param yy
+	 *            raw acceleration on y axis
+	 * @param zz
+	 *            raw acceleration on z axis
+	 */
+	public void setMotionSensingEvent(float orientationThreshold,
+			int accelerationThreshold, boolean smoothingState,
+			float alphaSmooth, float r, float p, float ya, float x, float y,
+			float z, short xx, short yy, short zz) {
+		motionSensingEvent = new MotionSensingEvent(getWiimoteId(),
+				orientationThreshold, accelerationThreshold, smoothingState,
+				alphaSmooth, r, p, ya, x, y, z, xx, yy, zz);
+	}
+
+	@Override
+	public String toString() {
+		String out = "";
+		/* Status */
+		out += "/*********** GENERIC EVENT : WIIMOTE   ID :"
+				+ super.getWiimoteId() + " ********/\n";
+
+		out += buttonsEvent;
+
+		if (infraredEvent != null) {
+			out += infraredEvent;
+		} else {
+			out += "/******** IR Tracking ********/\n";
+			out += "--- Active : false\n";
+		}
+
+		if (motionSensingEvent != null) {
+			out += motionSensingEvent;
+		} else {
+			out += "/******** Motion sensing ********/\n";
+			out += "--- Motion sensing : false \n";
+		}
+
+		return out;
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/IREvent.java

@@ -0,0 +1,285 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+import wiiusej.values.IRSource;
+
+/**
+ * Class which represents an IR event.
+ * 
+ * @author guiguito
+ */
+public class IREvent extends WiimoteEvent {
+
+	/* IR Tracking */
+	private IRSource[] IRPoints;
+	private short indexPoints = 0;
+	private int x;
+	private int y;
+	private int z;// distance from the sensor bar
+	private int ax;
+	private int ay;
+	private int xVRes;
+	private int yVRes;
+	private int xOffset;
+	private int yOffset;
+	private short sensorBarPostion;
+	private short screenAsPectRatio;
+
+	static private short WIIUSE_IR_ABOVE = 0;
+	static private short WIIUSE_IR_BELOW = 1;
+	static private short WIIUSE_SCREEN_RATIO_4_3 = 0;
+	static private short WIIUSE_SCREEN_RATIO_16_9 = 1;
+
+	private static short NB_POINTS = 4;// number of points IR can track
+
+	/**
+	 * Constructor of IREvent with full infos.
+	 * 
+	 * @param id
+	 *            d of the wiimote concerned.
+	 * @param x
+	 *            calculated X coordinate.
+	 * @param y
+	 *            calculated Y coordinate.
+	 * @param z
+	 *            calculated distance.
+	 * @param ax
+	 *            absolute X coordinate.
+	 * @param ay
+	 *            absolute Y coordinate
+	 * @param xVRes
+	 *            IR virtual screen x resolution.
+	 * @param yVRes
+	 *            IR virtual screen y resolution.
+	 * @param xOffset
+	 *            IR X correction offset.
+	 * @param yOffset
+	 *            IR Y correction offset.
+	 * @param sensorBarPostion
+	 *            aspect ratio of the screen.
+	 * @param screenAsPectRatio
+	 *            IR sensor bar position.
+	 */
+	public IREvent(int id, int x, int y, int z, int ax, int ay, int xVRes,
+			int yVRes, int xOffset, int yOffset, short sensorBarPostion,
+			short screenAsPectRatio) {
+		super(id);
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.ax = ax;
+		this.ay = ay;
+		this.xVRes = xVRes;
+		this.yVRes = yVRes;
+		this.xOffset = xOffset;
+		this.yOffset = yOffset;
+		this.sensorBarPostion = sensorBarPostion;
+		this.screenAsPectRatio = screenAsPectRatio;
+		IRPoints = new IRSource[NB_POINTS];
+	}
+
+	/**
+	 * Get list of IR points.
+	 * 
+	 * @return the list of 2D points
+	 */
+	public IRSource[] getIRPoints() {
+		return java.util.Arrays.copyOfRange(IRPoints, 0, indexPoints);
+	}
+
+	/**
+	 * Add IR Point in the list (Max 4 points)
+	 * 
+	 * @param x
+	 *            x value
+	 * @param y
+	 *            y value
+	 * @param rx
+	 *            raw X coordinate (0-1023).
+	 * @param ry
+	 *            raw Y coordinate (0-1023).
+	 * @param size
+	 *            size of the IR dot (0-15).
+	 */
+	public void addIRpoint(int x, int y, short rx, short ry, short size) {
+		IRPoints[indexPoints] = new IRSource(x, y, rx, ry, size);
+		indexPoints++;
+		return;
+	}
+
+	/**
+	 * Return calculated X coordinate.
+	 * 
+	 * @return the x
+	 */
+	public int getX() {
+		return x;
+	}
+
+	/**
+	 * Return calculated Y coordinate.
+	 * 
+	 * @return the y
+	 */
+	public int getY() {
+		return y;
+	}
+
+	/**
+	 * Return calculated distance.
+	 * 
+	 * @return the z
+	 */
+	public int getZ() {
+		return z;
+	}
+
+	/**
+	 * Return absolute X coordinate.
+	 * 
+	 * @return the ax
+	 */
+	public int getAx() {
+		return ax;
+	}
+
+	/**
+	 * Return absolute Y coordinate.
+	 * 
+	 * @return the ay
+	 */
+	public int getAy() {
+		return ay;
+	}
+
+	/**
+	 * Return IR virtual screen x resolution.
+	 * 
+	 * @return the xVRes
+	 */
+	public int getXVRes() {
+		return xVRes;
+	}
+
+	/**
+	 * Return IR virtual screen y resolution.
+	 * 
+	 * @return the yVRes
+	 */
+	public int getYVRes() {
+		return yVRes;
+	}
+
+	/**
+	 * Return IR X correction offset.
+	 * 
+	 * @return the xOffset
+	 */
+	public int getXOffset() {
+		return xOffset;
+	}
+
+	/**
+	 * Return IR Y correction offset.
+	 * 
+	 * @return the yOffset
+	 */
+	public int getYOffset() {
+		return yOffset;
+	}
+
+	/**
+	 * Return true if the sensor bar is above.
+	 * 
+	 * @return true if the sensor bar is above.
+	 */
+	public boolean isSensorBarAbove() {
+		return sensorBarPostion == WIIUSE_IR_ABOVE;
+	}
+
+	/**
+	 * Return true if the sensor bar is below.
+	 * 
+	 * @return true if the sensor bar is below.
+	 */
+	public boolean isSensorBarBelow() {
+		return sensorBarPostion == WIIUSE_IR_BELOW;
+	}
+
+	/**
+	 * Return true if screen aspect ratio set is 4/3.
+	 * 
+	 * @return true if screen aspect ratio set is 4/3.
+	 */
+	public boolean isScreenAspectRatio43() {
+		return screenAsPectRatio == WIIUSE_SCREEN_RATIO_4_3;
+	}
+
+	/**
+	 * Return true if screen aspect ratio set is 16/9.
+	 * 
+	 * @return true if screen aspect ratio set is 16/9.
+	 */
+	public boolean isScreenAspectRatio169() {
+		return screenAsPectRatio == WIIUSE_SCREEN_RATIO_16_9;
+	}
+
+	/**
+	 * Return aspect ratio of the screen.
+	 * 
+	 * @return the screenAsPectRatio
+	 */
+	public short getScreenAsPectRatio() {
+		return screenAsPectRatio;
+	}
+
+	@Override
+	public String toString() {
+		String out = "";
+		/* Display IR Tracking */
+		out += "/******** IR Tracking ********/\n";
+		out += "--- Active : true\n";
+		out += "--- calculated X coordinate : " + x + "\n";
+		out += "--- calculated Y coordinate : " + y + "\n";
+		out += "--- calculated distance : " + z + "\n";
+		out += "--- absolute X coordinate : " + ax + "\n";
+		out += "--- absolute Y coordinate : " + ay + "\n";
+		out += "--- IR virtual screen x resolution : " + xVRes + "\n";
+		out += "--- IR virtual screen y resolution : " + yVRes + "\n";
+		out += "--- IR X correction offset : " + xOffset + "\n";
+		out += "--- IR Y correction offset : " + yOffset + "\n";
+		if (isScreenAspectRatio43()) {
+			out += "--- aspect ratio of the screen : 4/3\n";
+		} else if (isScreenAspectRatio169()) {
+			out += "--- aspect ratio of the screen : 16/9\n";
+		}
+		if (isSensorBarAbove()) {
+			out += "--- IR sensor bar position. : Above\n";
+		} else if (isSensorBarBelow()) {
+			out += "--- IR sensor bar position. : Below\n";
+		}
+		out += "--- Seen points\n";
+		for (int i = 0; i < IRPoints.length; i++) {
+			if (IRPoints[i] != null) {
+				out += IRPoints[i].toString();
+			}
+		}
+		out += "\n";
+		return out;
+	}
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/MotionSensingEvent.java

@@ -0,0 +1,194 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+import wiiusej.values.GForce;
+import wiiusej.values.Orientation;
+import wiiusej.values.RawAcceleration;
+
+/**
+ * Class which represents a motion sensing event.
+ * 
+ * @author guiguito
+ */
+public class MotionSensingEvent extends WiimoteEvent {
+
+	/* Motion Sensing */
+	private Orientation orientation;
+	private GForce gforce;
+	private RawAcceleration acceleration;
+
+	private float orientationThreshold = 0;
+	private int accelerationThreshold = 0;
+	private float alphaSmoothing = 0;
+	private boolean isSmoothingActive = false;
+
+	/**
+	 * Constructor for a Motion Sensing Event.
+	 * 
+	 * @param id
+	 *            id of the wiimote concerned.
+	 * @param orientationThreshold
+	 *            value of the minimum angle between two events with the
+	 *            accelerometer
+	 * @param accelerationThreshold
+	 *            value of the value variation between two events with the
+	 *            accelerometer
+	 * @param smoothingState
+	 *            true if smoothing flag is activated
+	 * @param alphaSmooth
+	 *            value of the alpha smoothing parameter
+	 * @param r
+	 *            roll
+	 * @param p
+	 *            pitch
+	 * @param ya
+	 *            yaw
+	 * @param x
+	 *            gravity force on x axis
+	 * @param y
+	 *            gravity force on y axis
+	 * @param z
+	 *            gravity force on z axis
+	 * @param xx
+	 *            raw acceleration on x axis
+	 * @param yy
+	 *            raw acceleration on y axis
+	 * @param zz
+	 *            raw acceleration on z axis
+	 */
+	public MotionSensingEvent(int id, float orientationThreshold,
+			int accelerationThreshold, boolean smoothingState,
+			float alphaSmooth, float r, float p, float ya, float x, float y,
+			float z, short xx, short yy, short zz) {
+		super(id);
+		this.orientationThreshold = orientationThreshold;
+		this.accelerationThreshold = accelerationThreshold;
+		this.isSmoothingActive = smoothingState;
+		this.alphaSmoothing = alphaSmooth;
+		setOrientationAndGforce(r, p, ya, x, y, z, xx, yy, zz);
+	}
+
+	/**
+	 * Set orientation, gravity force and raw acceleration.
+	 * 
+	 * @param r
+	 *            roll
+	 * @param p
+	 *            pitch
+	 * @param ya
+	 *            yaw
+	 * @param x
+	 *            gravity force on x axis
+	 * @param y
+	 *            gravity force on y axis
+	 * @param z
+	 *            gravity force on z axis
+	 * @param xx
+	 *            raw acceleration on x axis
+	 * @param yy
+	 *            raw acceleration on y axis
+	 * @param zz
+	 *            raw acceleration on z axis
+	 */
+	private void setOrientationAndGforce(float r, float p, float ya, float x,
+			float y, float z, short xx, short yy, short zz) {
+		this.orientation = new Orientation(r, p, ya);
+		this.gforce = new GForce(x, y, z);
+		this.acceleration = new RawAcceleration(xx, yy, zz);
+	}
+
+	/**
+	 * @return the orientation
+	 */
+	public Orientation getOrientation() {
+		return orientation;
+	}
+
+	/**
+	 * Get the gravity force.
+	 * 
+	 * @return the gforce
+	 */
+	public GForce getGforce() {
+		return gforce;
+	}
+
+	/**
+	 * Get the raw acceleration.
+	 * 
+	 * @return the raw acceleration
+	 */
+	public RawAcceleration getRawAcceleration() {
+		return acceleration;
+	}
+
+	/**
+	 * Get orientation threshold.
+	 * 
+	 * @return the orientationThreshold
+	 */
+	public float getOrientationThreshold() {
+		return orientationThreshold;
+	}
+
+	/**
+	 * Get acceleration threshold.
+	 * 
+	 * @return the accelerationThreshold
+	 */
+	public int getAccelerationThreshold() {
+		return accelerationThreshold;
+	}
+
+	/**
+	 * Get alpha smoothing.
+	 * 
+	 * @return the alphaSmoothing
+	 */
+	public float getAlphaSmoothing() {
+		return alphaSmoothing;
+	}
+
+	/**
+	 * Tell if the option SMOOTHING is activated.
+	 * 
+	 * @return the isSmoothingActive
+	 */
+	public boolean isSmoothingActive() {
+		return isSmoothingActive;
+	}
+
+	@Override
+	public String toString() {
+		String out = "";
+		/* Motion sensing */
+		out += "/******** Motion sensing ********/\n";
+		out += "--- Motion sensing : true \n";
+		out += "--- Orientation threshold value ? : " + orientationThreshold
+				+ "\n";
+		out += "--- Acceleration threshold value ? : " + accelerationThreshold
+				+ "\n";
+		out += "--- Alpha smoothing threshold value ? : " + alphaSmoothing
+				+ "\n";
+		out += "--- Smoothing ? : " + isSmoothingActive + "\n";
+		out += "--- " + orientation + "\n";
+		out += "--- " + gforce + "\n";
+		out += "--- " + acceleration + "\n";
+		return out;
+	}
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/StatusEvent.java

@@ -0,0 +1,258 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * Class used to represent a status event. This class is used to know what are
+ * the settings of the wiimote.
+ * 
+ * @author guiguito
+ */
+public class StatusEvent extends WiiUseApiEvent {
+
+	private static short WIIMOTE_LED_1 = 1;
+	private static short WIIMOTE_LED_2 = 2;
+	private static short WIIMOTE_LED_3 = 4;
+	private static short WIIMOTE_LED_4 = 8;
+
+	/* ATTACHMENT CONSTANTS */
+
+	private static short EXP_NONE = 0;
+	private static short EXP_NUNCHUK = 1;
+	private static short EXP_CLASSIC = 2;
+	private static short EXP_GUITAR_HERO_3 = 3;
+
+	/* Status variables */
+	private boolean connected = false;
+
+	private float batteryLevel = -1;
+
+	private short leds = 0;
+
+	private boolean isSpeakerEnabled = false;
+
+	private int attachment = 0;
+
+	private boolean isRumbleActive = false;
+
+	private boolean isContinuousActive = false;
+
+	private boolean isIrActive = false;
+
+	private boolean isMotionSensingActive = false;
+
+	/**
+	 * Construct the StatusEvent setting up the id.
+	 * 
+	 * @param id
+	 *            the Wiimote id
+	 */
+	public StatusEvent(int id) {
+		super(id, WiiUseApiEvent.STATUS_EVENT);
+	}
+
+	/**
+	 * Build a StatusEvent with all fields set.
+	 * 
+	 * @param id
+	 *            id of the wiimote
+	 * @param connect
+	 *            true if the wiimote is connected
+	 * @param batt
+	 *            battery level
+	 * @param led
+	 *            status of leds
+	 * @param speak
+	 *            speakers status
+	 * @param attach
+	 *            attachment status
+	 * @param rumbleState
+	 *            true if rumble is active
+	 * @param continuousState
+	 *            true if continuous flag is activated
+	 * @param irState
+	 *            true if ir is active
+	 * @param motionSensingState
+	 *            true if accelerometer is active
+	 */
+	public StatusEvent(int id, boolean connect, float batt, short led,
+			boolean speak, int attach, boolean rumbleState,
+			boolean continuousState, boolean irState, boolean motionSensingState) {
+		super(id, WiiUseApiEvent.STATUS_EVENT);
+		connected = connect;
+		this.batteryLevel = batt;
+		this.leds = led;
+		this.isSpeakerEnabled = speak;
+		this.attachment = attach;
+		isRumbleActive = rumbleState;
+		isContinuousActive = continuousState;
+		isIrActive = irState;
+		isMotionSensingActive = motionSensingState;
+	}
+
+	/**
+	 * True if the wiimote is connected false otherwise.
+	 * 
+	 * @return return the connected status.
+	 */
+	public boolean isConnected() {
+		return connected;
+	}
+
+	/**
+	 * Get battery level.
+	 * 
+	 * @return battery level. 1 = 100%
+	 */
+	public float getBatteryLevel() {
+		return batteryLevel;
+	}
+
+	/**
+	 * Get status of the leds .
+	 * 
+	 * @return a short representing LEDS turned on.
+	 */
+	public short getLeds() {
+		return leds;
+	}
+
+	/**
+	 * Get led1 status.
+	 * 
+	 * @return true if the led is set.
+	 */
+	public boolean isLed1Set() {
+		if ((leds & WIIMOTE_LED_1) > 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Get led2 status.
+	 * 
+	 * @return true if the led is set.
+	 */
+	public boolean isLed2Set() {
+		if ((leds & WIIMOTE_LED_2) > 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Get led3 status.
+	 * 
+	 * @return true if the led is set.
+	 */
+	public boolean isLed3Set() {
+		if ((leds & WIIMOTE_LED_3) > 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Get led4 status.
+	 * 
+	 * @return true if the led is set.
+	 */
+	public boolean isLed4Set() {
+		if ((leds & WIIMOTE_LED_4) > 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Tell if the speaker is enable for this wiimote
+	 * 
+	 * @return TRUE if it enabled false otherwise
+	 */
+	public boolean isSpeakerEnabled() {
+		return isSpeakerEnabled;
+	}
+
+	/**
+	 * Get the int representing the attachment type.
+	 * 
+	 * @return value of the Attachment Type
+	 */
+	public int getAttachment() {
+		return attachment;
+	}
+
+	/**
+	 * Get the status of rumble.
+	 * 
+	 * @return true if the rumble is active false otherwise
+	 */
+	public boolean isRumbleActive() {
+		return isRumbleActive;
+	}
+
+	/**
+	 * Tell if the CONTINUOUS option is activated.
+	 * 
+	 * @return the isContinuousActive
+	 */
+	public boolean isContinuousActive() {
+		return isContinuousActive;
+	}
+
+	/**
+	 * Tell if the IR Tracking is active.
+	 * 
+	 * @return TRUE if it is active or false otherwise.
+	 */
+	public boolean isIrActive() {
+		return isIrActive;
+	}
+
+	/**
+	 * Get the flag indicating if the motion sensing is active.
+	 * 
+	 * @return true if the motion sensing is active false otherwise
+	 */
+	public boolean isMotionSensingActive() {
+		return isMotionSensingActive;
+	}
+
+	@Override
+	public String toString() {
+		String out = "";
+		/* Status */
+		out += "/*********** STATUS EVENT : WIIMOTE ID :"
+				+ super.getWiimoteId() + " ********/\n";
+		out += "--- connected : " + connected + "\n";
+		out += "--- Battery level : " + batteryLevel + "\n";
+		out += "--- Leds : " + leds + "\n";
+		out += "--- Speaker enabled : " + isSpeakerEnabled + "\n";
+		out += "--- Attachment ? : " + attachment + "\n";
+		out += "--- Rumble ? : " + isRumbleActive + "\n";
+		out += "--- Continuous ? : " + isContinuousActive + "\n";
+		out += "--- IR active ? : " + isIrActive + "\n";
+		out += "--- Motion sensing active ? : " + isMotionSensingActive + "\n";
+		return out;
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/WiiUseApiEvent.java

@@ -0,0 +1,62 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * This class describes the structure of an event from the WiiUse API event.
+ * 
+ * @author guiguito
+ */
+public abstract class WiiUseApiEvent extends WiimoteEvent{
+	
+	public static int GENERIC_EVENT = 1;
+	public static int STATUS_EVENT = 2;
+	public static int DISCONNECTION_EVENT = 3;
+	public static int WIIUSE_NUNCHUK_INSERTED = 4;	
+	public static int WIIUSE_NUNCHUK_REMOVED = 5;
+	public static int WIIUSE_CLASSIC_CTRL_INSERTED = 6;
+	public static int WIIUSE_CLASSIC_CTRL_REMOVED = 7;
+	public static int WIIUSE_GUITAR_HERO_3_CTRL_INSERTED = 8;
+	public static int WIIUSE_GUITAR_HERO_3_CTRL_REMOVED = 9;
+	
+	/* Event Type */
+	private int eventType;
+	
+	/**
+	 * Construct the WiiUseApiEvent setting up the id.
+	 * 
+	 * @param id
+	 *            the Wiimote id
+	 * @param type
+	 *            type of the event            
+	 */
+	public WiiUseApiEvent(int id, int type) {
+		super(id);
+		eventType = type;
+	}		
+	
+	/**
+	 * Get the event type.
+	 * @return the eventType
+	 */
+	public int getEventType() {
+		return eventType;
+	}
+	
+	public abstract String toString();	
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/WiiUseApiListener.java

@@ -0,0 +1,39 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+
+
+/**
+ * This is the interface to implement to listen to events from the wiiuse API.
+ * 
+ * @author guiguito
+ */
+public interface WiiUseApiListener extends java.util.EventListener {
+	
+	/**
+	 * Method called when a WiiUseApiEvent occurs.
+	 * A WiiUseApiEvent can be :
+	 * 					- GenericEvent (Storing ButtonsEvent and
+	 * 					 eventually IREvent and MotionSensingEvent)
+	 * 					- StatusEvent
+	 * 					- DisconnectionEvent
+	 * @param e
+	 */
+	void onWiiUseApiEvent(WiiUseApiEvent e);
+			
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/WiimoteEvent.java

@@ -0,0 +1,59 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * Abstract mother class representing an event with a wiimote id.
+ * 
+ * @author guiguito
+ */
+public abstract class WiimoteEvent {
+	
+	/* ID */
+	private int wiimoteId = -1;
+	
+	/**
+	 * Construct the WiiUseApiEvent setting up the id.
+	 * 
+	 * @param id
+	 *            the Wiimote id           
+	 */
+	public WiimoteEvent(int id) {
+		wiimoteId = id;
+	}
+	
+	/**
+	 * Get Wiimote ID
+	 * 
+	 * @return the wiimote id.
+	 */
+	public int getWiimoteId() {
+		return wiimoteId;
+	}
+	
+	/**
+	 * Set Wiimote ID
+	 * 
+	 * @param wiimoteId
+	 *            id of the wiimote
+	 */
+	void setWiimoteId(int wiimoteId) {
+		this.wiimoteId = wiimoteId;
+	}
+	
+	public abstract String toString();
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapievents/WiimoteListener.java

@@ -0,0 +1,69 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapievents;
+
+/**
+ * This is the interface to implement to listen to events from wiimotes.
+ * The differents methods are called in this order : 
+ * onButtonsEvent, onIrEvent, onMotionSensingEvent, onStatusEvent, onDisconnectionEvent. 
+ * 
+ * @author guiguito
+ */
+public interface WiimoteListener extends java.util.EventListener {
+
+	/**
+	 * Method called on a button Event.
+	 * @param e the buttonEvent with the last informations 
+	 * 			about the buttons of the wiimote.
+	 */
+	void onButtonsEvent(ButtonsEvent e);
+	
+	/**
+	 * Method called when an IR event occurs.
+	 * @param e the IREvent with the IR points seen.
+	 */
+	void onIrEvent(IREvent e);
+	
+	/**
+	 * Method called when a motion sensing event occurs.
+	 * @param e the motion sensing event with orientation and acceleration.
+	 */
+	void onMotionSensingEvent(MotionSensingEvent e);
+	
+	/**
+	 * Method called on a status event.
+	 * A status event occurs when :
+	 * 						- we ask it
+	 * 						- an expansion controller has been plugged
+	 * 						- an expansion controller has been unplugged
+	 * This is where you can get the different values of
+	 * the parameters setup on your wiimote. 
+	 * @param e the status event.
+	 */
+	void onStatusEvent(StatusEvent e);
+
+	/**
+	 * This is the method called when a disconnection event occurs.
+	 * A disconnection event happens when :
+	 * 						- there are no battery left
+	 * 						- the wiimote has just been turned off
+	 *   					- the connection is dropped
+	 * @param e the disconnection event.
+	 */
+	void onDisconnectionEvent(DisconnectionEvent e);
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapirequest/FloatValueRequest.java

@@ -0,0 +1,71 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapirequest;
+
+/**
+ * Represents a request with a float value to pass to wiiuse API.
+ * 
+ * @author guiguito
+ */
+public class FloatValueRequest extends WiiUseApiRequest {
+
+	private float floatValue;
+
+	/**
+	 * Constructor setting the id of the wiimote concerned.
+	 * 
+	 * @param id
+	 *            the id of the wiimote concerned.
+	 */
+	public FloatValueRequest(int id, int type) {
+		super(id, type);
+	}
+
+	/**
+	 * Constructor setting the id of the wiimote concerned.
+	 * 
+	 * @param id
+	 *            the id of the wiimote concerned.
+	 * @param type
+	 *            type of the request
+	 * @param th
+	 *            threshold in degrees
+	 */
+	public FloatValueRequest(int id, int type, float th) {
+		super(id, type);
+		floatValue = th;
+	}
+
+	/**
+	 * Get the float value.
+	 * @return the float value
+	 */
+	public float getFloatValue() {
+		return floatValue;
+	}
+
+	/**
+	 * Set the float value.
+	 * @param val the value to set
+	 */
+	public void setFloatValue(float val) {
+		this.floatValue = val;
+	}
+	
+	
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapirequest/IntValueRequest.java

@@ -0,0 +1,74 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapirequest;
+
+/**
+ * Represents a request with an int value to pass to wiiuse API.
+ * 
+ * @author guiguito
+ */
+public class IntValueRequest extends WiiUseApiRequest {
+
+	private int intValue;
+
+	/**
+	 * Constructor setting the id of the wiimote 
+	 * concerned and the type of the request.
+	 * 
+	 * @param id
+	 *            the id of the wiimote concerned.
+	 */
+	public IntValueRequest(int id, int type) {
+		super(id, type);
+	}
+
+	/**
+	 * Constructor setting the id of the wiimote 
+	 * concerned, the type of the request 
+	 * and the int value.
+	 * 
+	 * @param id
+	 *            the id of the wiimote concerned.
+	 * @param type
+	 *            type of the request
+	 * @param th
+	 *            the int value.
+	 */
+	public IntValueRequest(int id, int type, int th) {
+		super(id, type);
+		intValue = th;
+	}
+
+	/**
+	 * Get the int value.
+	 * @return the int value
+	 */
+	public int getIntValue() {
+		return intValue;
+	}
+
+	/**
+	 * Set the int value.
+	 * @param val the value to set
+	 */
+	public void setIntValue(int val) {
+		this.intValue = val;
+	}
+	
+	
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapirequest/LedsRequest.java

@@ -0,0 +1,125 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapirequest;
+
+/**
+ * Represents a request to set leds of the wiimote with WiiUse API.
+ * 
+ * @author guiguito
+ */
+public class LedsRequest extends wiiusej.wiiuseapirequest.WiiUseApiRequest {
+
+	private boolean led1, led2, led3, led4;
+
+	/**
+	 * Constructor setting the id of the wiimote concerned.
+	 * 
+	 * @param id
+	 *            id of the wiimote concerned
+	 * @param type
+	 *            type of the request
+	 */
+	public LedsRequest(int id, int type) {
+		super(id, type);
+	}
+
+	/**
+	 * Constructor setting the id of the wiimote concerned.
+	 * 
+	 * @param id
+	 *            id of the wiimote concerned
+	 * @param type
+	 *            type of the request
+	 * @param l1
+	 *            led1 status. True=ON, False=OFF
+	 * @param l2
+	 *            led2 status. True=ON, False=OFF
+	 * @param l3
+	 *            led3 status. True=ON, False=OFF
+	 * @param l4
+	 *            led4 status. True=ON, False=OFF
+	 */
+	public LedsRequest(int id, int type, boolean l1, boolean l2, boolean l3,
+			boolean l4) {
+		super(id, type);
+		led1 = l1;
+		led2 = l2;
+		led3 = l3;
+		led4 = l4;
+	}
+
+	/**
+	 * @return the led1
+	 */
+	public boolean isLed1() {
+		return led1;
+	}
+
+	/**
+	 * @param led1
+	 *            the led1 to set
+	 */
+	public void setLed1(boolean led1) {
+		this.led1 = led1;
+	}
+
+	/**
+	 * @return the led2
+	 */
+	public boolean isLed2() {
+		return led2;
+	}
+
+	/**
+	 * @param led2
+	 *            the led2 to set
+	 */
+	public void setLed2(boolean led2) {
+		this.led2 = led2;
+	}
+
+	/**
+	 * @return the led3
+	 */
+	public boolean isLed3() {
+		return led3;
+	}
+
+	/**
+	 * @param led3
+	 *            the led3 to set
+	 */
+	public void setLed3(boolean led3) {
+		this.led3 = led3;
+	}
+
+	/**
+	 * @return the led4
+	 */
+	public boolean isLed4() {
+		return led4;
+	}
+
+	/**
+	 * @param led4
+	 *            the led4 to set
+	 */
+	public void setLed4(boolean led4) {
+		this.led4 = led4;
+	}
+
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapirequest/TwoIntValueRequest.java

@@ -0,0 +1,73 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapirequest;
+
+
+/**
+ * Represents a request with two int values to pass to wiiuse API.
+ * 
+ * @author guiguito
+ */
+public class TwoIntValueRequest extends IntValueRequest {
+	
+	private int secondIntValue;
+	
+	/**
+	 * Constructor setting the id of the wiimote 
+	 * concerned and the type of the request.
+	 * 
+	 * @param id the id of the wiimote concerned.
+	 * @param type type of the request
+	 */
+	public TwoIntValueRequest(int id, int type) {
+		super(id, type);
+	}
+
+	/**
+	 * Constructor setting the id of the wiimote 
+	 * concerned, the type of the request 
+	 * and the two int values.
+	 * 
+	 * @param id the id of the wiimote concerned.
+	 * @param type type of the request
+	 * @param x first int value.
+	 * @param y second int value.
+	 */
+	public TwoIntValueRequest(int id, int type, int x, int y) {
+		super(id, type, x);
+		secondIntValue = y;
+	}
+
+	/**
+	 * Get the second int value.
+	 * @return the secondIntValue
+	 */
+	public int getSecondIntValue() {
+		return secondIntValue;
+	}
+
+	/**
+	 * Set the second int value.
+	 * @param secondIntValue the secondIntValue to set.
+	 */
+	public void setSecondIntValue(int secondIntValue) {
+		this.secondIntValue = secondIntValue;
+	}
+	
+	
+	
+}

WiiUseJ_0.1/src/wiiusej/wiiuseapirequest/WiiUseApiRequest.java

@@ -0,0 +1,112 @@
+/**
+ * This file is part of WiiuseJ.
+ *
+ *  WiiuseJ is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WiiuseJ is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WiiuseJ.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package wiiusej.wiiuseapirequest;
+
+/**
+ * Represents a request we could do to the WiiUse API.
+ * 
+ * @author guiguito
+ */
+public class WiiUseApiRequest {
+
+	public static int WIIUSE_STATUS_REQUEST = 1;
+	public static int WIIUSE_ACTIVATE_SMOOTHING_REQUEST = 2;
+	public static int WIIUSE_DEACTIVATE_SMOOTHING_REQUEST = -2;
+	public static int WIIUSE_ACTIVATE_IR_TRACKING_REQUEST = 3;
+	public static int WIIUSE_DEACTIVATE_IR_TRACKING_REQUEST = -3;
+	public static int WIIUSE_ACTIVATE_MOTION_SENSING_REQUEST = 4;
+	public static int WIIUSE_DEACTIVATE_MOTION_SENSING_REQUEST = -4;
+	public static int WIIUSE_CLOSE_CONNECTION_REQUEST = 5;
+	public static int WIIUSE_ACTIVATE_CONTINUOUS_REQUEST = 6;
+	public static int WIIUSE_DEACTIVATE_CONTINUOUS_REQUEST = -6;
+	public static int WIIUSE_ACTIVATE_RUMBLE_REQUEST = 7;
+	public static int WIIUSE_DEACTIVATE_RUMBLE_REQUEST = -7;
+	public static int WIIUSE_LEDS_REQUEST = 8;
+	public static int WIIUSE_ORIENT_THRESHOLHD_REQUEST = 9;
+	public static int WIIUSE_ACCEL_THRESHOLHD_REQUEST = 10;
+	public static int WIIUSE_ALPHA_SMOOTHING_REQUEST = 11;
+	public static int WIIUSE_RESYNC = 12;
+	public static int WIIUSE_ASPECT_RATIO_4_3 = 13;
+	public static int WIIUSE_ASPECT_RATIO_16_9 = 14;
+	public static int WIIUSE_SENSOR_BAR_ABOVE = 15;
+	public static int WIIUSE_SENSOR_BAR_BELOW = 16;	
+	public static int WIIUSE_SET_VIRTUAL_RESOLUTION = 17;
+
+	private int wiimoteId = 0;
+	private int requestType = 0;
+
+	/**
+	 * Constructor setting the id of the wiimote concerned.
+	 * 
+	 * @param id
+	 *            the id of the wiimote concerned.
+	 */
+	public WiiUseApiRequest(int id) {
+		wiimoteId = id;
+	}
+
+	/**
+	 * Constructor setting the id of the wiimote concerned.
+	 * 
+	 * @param id
+	 *            the id of the wiimote concerned.
+	 * 
+	 */
+	public WiiUseApiRequest(int id, int type) {
+		wiimoteId = id;
+		requestType = type;
+	}
+
+	/**
+	 * Get id of the wiimote concerned by this request.
+	 * 
+	 * @return id of the wiimote concerned
+	 */
+	public int getId() {
+		return wiimoteId;
+	}
+
+	/**
+	 * Set id of the wiimote concerned by this request.
+	 * 
+	 * @param id
+	 *            id fh the wiimote concernet
+	 */
+	public void setId(int id) {
+		wiimoteId = id;
+	}
+
+	/**
+	 * Get the request type.
+	 * 
+	 * @return the requestType
+	 */
+	public int getRequestType() {
+		return requestType;
+	}
+
+	/**
+	 * Set the request type.
+	 * 
+	 * @param requestType
+	 *            the requestType to set
+	 */
+	public void setRequestType(int requestType) {
+		this.requestType = requestType;
+	}
+
+}