rik/mimis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Browse Source
This commit is contained in:
Rik Veenboer
2011-02-01 18:38:43 +00:00
parent 2516e790ff
commit 683ed112d4
99 changed files with 19949 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
java/src/com/melloware/jintellitype/HotkeyListener.java Normal file
View File

@@ -0,0 +1,46 @@
/**
* JIntellitype
* -----------------
* Copyright 2005-2008 Emil A. Lefkof III, Melloware Inc.
*
* I always give it my best shot to make a program useful and solid, but
* remeber that there is absolutely no warranty for using this program as
* stated in the following terms:
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.melloware.jintellitype;
/**
* Listener interface for Windows Hotkey events registered using the
* Windows API call RegisterHotKey to globally listen for a key combination
* regardless if your application has focus or not.
* <p>
* Copyright (c) 1999-2008
* Melloware, Inc. <http://www.melloware.com>
* @author Emil A. Lefkof III <info@melloware.com>
* @version 1.3.1
*
* @see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardinput/keyboardinputreference/keyboardinputfunctions/registerhotkey.asp
*/
public interface HotkeyListener
{
/**
* Event fired when a WM_HOTKEY message is received that was initiated
* by this application.
* <p>
* @param identifier the unique Identifer the Hotkey was assigned
*/
void onHotKey( int identifier );
}

51
java/src/com/melloware/jintellitype/IntellitypeListener.java Normal file
View File

@@ -0,0 +1,51 @@
/**
* JIntellitype
* -----------------
* Copyright 2005-2008 Emil A. Lefkof III, Melloware Inc.
*
* I always give it my best shot to make a program useful and solid, but
* remeber that there is absolutely no warranty for using this program as
* stated in the following terms:
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.melloware.jintellitype;
/**
* Listener interface for Windows Intellitype events. Intellitype are Windows
* App Commands that are specialand were introduced with Microsoft Keyboards
* that had special keys for Play, Pause, Stop, Next etc for controlling
* Media applications like Windows Media Player, Itunes, and Winamp.
* <p>
* If you have ever wanted your Swing/SWT application to respond to these global
* events you now can with JIntellitype. Just implement this interface and
* you can now take action when those special Media keys are pressed.
* <p>
* Copyright (c) 1999-2008
* Melloware, Inc. <http://www.melloware.com>
* @author Emil A. Lefkof III <info@melloware.com>
* @version 1.3.1
*
* @see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardinput/keyboardinputreference/keyboardinputmessages/wm_appcommand.asp
*/
public interface IntellitypeListener
{
/**
* Event fired when a WM_APPCOMMAND message is received that was initiated
* by this application.
* <p>
* @param command the WM_APPCOMMAND that was pressed
*/
void onIntellitype( int command );
}

665
java/src/com/melloware/jintellitype/JIntellitype.java Normal file
View File

@@ -0,0 +1,665 @@
/**
* JIntellitype ----------------- Copyright 2005-2008 Emil A. Lefkof III,
* Melloware Inc. I always give it my best shot to make a program useful and
* solid, but remeber that there is absolutely no warranty for using this
* program as stated in the following terms: Licensed under the Apache License,
* Version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law
* or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*/
package com.melloware.jintellitype;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.SwingUtilities;
/**
* JIntellitype A Java Implementation for using the Windows API Intellitype
* commands and the RegisterHotKey and UnRegisterHotkey API calls for globally
* responding to key events. Intellitype are commands that are using for Play,
* Stop, Next on Media keyboards or some laptops that have those special keys.
* <p>
* JIntellitype class that is used to call Windows API calls using the
* JIntellitype.dll.
* <p>
* This file comes with native code in JINTELLITYPE.DLL The DLL should go in
* C:/WINDOWS/SYSTEM or in your current directory
* <p>
* <p>
* Copyright (c) 1999-2008 Melloware, Inc. <http://www.melloware.com>
* @author Emil A. Lefkof III <info@melloware.com>
* @version 1.3.1
*/
public final class JIntellitype implements JIntellitypeConstants {
/**
* Static variable to hold singleton.
*/
private static JIntellitype jintellitype = null;
/**
* Static variable for double checked thread safety.
*/
private static boolean isInitialized = false;
/**
* Static variable to hold the libary location if set
*/
private static String libraryLocation = null;
/**
* Listeners collection for Hotkey events
*/
private final List<HotkeyListener> hotkeyListeners = Collections
.synchronizedList(new CopyOnWriteArrayList<HotkeyListener>());
/**
* Listeners collection for Hotkey events
*/
private final List<IntellitypeListener> intellitypeListeners = Collections
.synchronizedList(new CopyOnWriteArrayList<IntellitypeListener>());
/**
* Handler is used by JNI code to keep different JVM instances separate
*/
@SuppressWarnings("unused")
private final int handler = 0;
/**
* Map containing key->keycode mapping
* @see #registerHotKey(int, String)
* @see #getKey2KeycodeMapping()
*/
private final HashMap<String, Integer> keycodeMap;
/**
* Private Constructor to prevent instantiation. Initialize the library for
* calling.
*/
private JIntellitype() {
try {
// Load JNI library
System.loadLibrary("JIntellitype");
} catch (Throwable ex) {
try {
if (getLibraryLocation() != null) {
System.load(getLibraryLocation());
} else {
String jarPath = "com/melloware/jintellitype/";
String tmpDir = System.getProperty("java.io.tmpdir");
try {
String dll = "JIntellitype.dll";
fromJarToFs(jarPath + dll, tmpDir + dll);
System.load(tmpDir + dll);
} catch (UnsatisfiedLinkError e) {
String dll = "JIntellitype64.dll";
fromJarToFs(jarPath + dll, tmpDir + dll);
System.load(tmpDir + dll);
}
}
} catch (Throwable ex2) {
throw new JIntellitypeException(
"Could not load JIntellitype.dll from local file system or from inside JAR", ex2);
}
}
initializeLibrary();
this.keycodeMap = getKey2KeycodeMapping();
}
/**
* Pulls a file out of the JAR and puts it on the File Path.
* <p>
* @param jarPath the path to the JAR
* @param filePath the file path to extract to
* @throws IOException if any IO error occurs
*/
private void fromJarToFs(String jarPath, String filePath) throws IOException {
File file = new File(filePath);
if (file.exists()) {
boolean success = file.delete();
if (!success) {
throw new IOException("couldn't delete " + filePath);
}
}
InputStream is = null;
OutputStream os = null;
try {
is = ClassLoader.getSystemClassLoader().getResourceAsStream(jarPath);
os = new FileOutputStream(filePath);
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
}
} finally {
if (is != null) {
is.close();
}
if (os != null) {
os.close();
}
}
}
/**
* Gets the singleton instance of the JIntellitype object.
* <p>
* But the possibility of creation of more instance is only before the
* instance is created. Since all code defined inside getInstance method is
* in the synchronized block, even the subsequent requests will also come and
* wait in the synchronized block. This is a performance issue. The same can
* be solved using double-checked lock. Following is the implementation of
* Singleton with lazy initialization and double-checked lock.
* <p>
* @return an instance of JIntellitype class
*/
public static JIntellitype getInstance() {
if (!isInitialized) {
synchronized (JIntellitype.class) {
if (!isInitialized) {
jintellitype = new JIntellitype();
isInitialized = true;
}
}
}
return jintellitype;
}
/**
* Adds a listener for hotkeys.
* <p>
* @param listener the HotKeyListener to be added
*/
public void addHotKeyListener(HotkeyListener listener) {
hotkeyListeners.add(listener);
}
/**
* Adds a listener for intellitype commands.
* <p>
* @param listener the IntellitypeListener to be added
*/
public void addIntellitypeListener(IntellitypeListener listener) {
intellitypeListeners.add(listener);
}
/**
* Cleans up all resources used by JIntellitype.
*/
public void cleanUp() {
try {
terminate();
} catch (UnsatisfiedLinkError ex) {
throw new JIntellitypeException(ERROR_MESSAGE, ex);
} catch (RuntimeException ex) {
throw new JIntellitypeException(ex);
}
}
/**
* Registers a Hotkey with windows. This combination will be responded to by
* all registered HotKeyListeners. Uses the JIntellitypeConstants for MOD,
* ALT, CTRL, and WINDOWS keys.
* <p>
* @param identifier a unique identifier for this key combination
* @param modifier MOD_SHIFT, MOD_ALT, MOD_CONTROL, MOD_WIN from
* JIntellitypeConstants, or 0 if no modifier needed
* @param keycode the key to respond to in Ascii integer, 65 for A
*/
public void registerHotKey(int identifier, int modifier, int keycode) {
try {
int modifiers = swingToIntelliType(modifier);
if (modifiers == 0) {
modifiers = modifier;
}
regHotKey(identifier, modifier, keycode);
} catch (UnsatisfiedLinkError ex) {
throw new JIntellitypeException(ERROR_MESSAGE, ex);
} catch (RuntimeException ex) {
throw new JIntellitypeException(ex);
}
}
/**
* Registers a Hotkey with windows. This combination will be responded to by
* all registered HotKeyListeners. Use the Swing InputEvent constants from
* java.awt.InputEvent.
* <p>
* @param identifier a unique identifier for this key combination
* @param modifier InputEvent.SHIFT_MASK, InputEvent.ALT_MASK,
* InputEvent.CTRL_MASK, or 0 if no modifier needed
* @param keycode the key to respond to in Ascii integer, 65 for A
*/
public void registerSwingHotKey(int identifier, int modifier, int keycode) {
try {
regHotKey(identifier, swingToIntelliType(modifier), keycode);
} catch (UnsatisfiedLinkError ex) {
throw new JIntellitypeException(ERROR_MESSAGE, ex);
} catch (RuntimeException ex) {
throw new JIntellitypeException(ex);
}
}
/**
* Registers a Hotkey with windows. This combination will be responded to by
* all registered HotKeyListeners. Use the identifiers CTRL, SHIFT, ALT
* and/or WIN.
* <p>
* @param identifier a unique identifier for this key combination
* @param modifierAndKeyCode String with modifiers separated by + and keycode
* (e.g. CTRL+SHIFT+A)
* @see #registerHotKey(int, int, int)
* @see #registerSwingHotKey(int, int, int)
*/
public void registerHotKey(int identifier, String modifierAndKeyCode) {
String[] split = modifierAndKeyCode.split("\\+");
int mask = 0;
int keycode = 0;
for (int i = 0; i < split.length; i++) {
if ("ALT".equalsIgnoreCase(split[i])) {
mask += JIntellitype.MOD_ALT;
} else if ("CTRL".equalsIgnoreCase(split[i]) || "CONTROL".equalsIgnoreCase(split[i])) {
mask += JIntellitype.MOD_CONTROL;
} else if ("SHIFT".equalsIgnoreCase(split[i])) {
mask += JIntellitype.MOD_SHIFT;
} else if ("WIN".equalsIgnoreCase(split[i])) {
mask += JIntellitype.MOD_WIN;
} else if (keycodeMap.containsKey(split[i].toLowerCase())) {
keycode = keycodeMap.get(split[i].toLowerCase());
}
}
registerHotKey(identifier, mask, keycode);
}
/**
* Removes a listener for hotkeys.
*/
public void removeHotKeyListener(HotkeyListener listener) {
hotkeyListeners.remove(listener);
}
/**
* Removes a listener for intellitype commands.
*/
public void removeIntellitypeListener(IntellitypeListener listener) {
intellitypeListeners.remove(listener);
}
/**
* Unregisters a previously registered Hotkey identified by its unique
* identifier.
* <p>
* @param identifier the unique identifer of this Hotkey
*/
public void unregisterHotKey(int identifier) {
try {
unregHotKey(identifier);
} catch (UnsatisfiedLinkError ex) {
throw new JIntellitypeException(ERROR_MESSAGE, ex);
} catch (RuntimeException ex) {
throw new JIntellitypeException(ex);
}
}
/**
* Checks to see if this application is already running.
* <p>
* @param appTitle the name of the application to check for
* @return true if running, false if not running
*/
public static boolean checkInstanceAlreadyRunning(String appTitle) {
return getInstance().isRunning(appTitle);
}
/**
* Checks to make sure the OS is a Windows flavor and that the JIntellitype
* DLL is found in the path and the JDK is 32 bit not 64 bit. The DLL
* currently only supports 32 bit JDK.
* <p>
* @return true if Jintellitype may be used, false if not
*/
public static boolean isJIntellitypeSupported() {
boolean result = false;
String os = "none";
try {
os = System.getProperty("os.name").toLowerCase();
} catch (SecurityException ex) {
// we are not allowed to look at this property
System.err.println("Caught a SecurityException reading the system property "
+ "'os.name'; the SystemUtils property value will default to null.");
}
// only works on Windows OS currently
if (os.startsWith("windows")) {
// try an get the instance and if it succeeds then return true
try {
getInstance();
result = true;
} catch (Exception e) {
result = false;
}
}
return result;
}
/**
* Gets the libraryLocation.
* <p>
* @return Returns the libraryLocation.
*/
public static String getLibraryLocation() {
return libraryLocation;
}
/**
* Sets the libraryLocation.
* <p>
* @param libraryLocation The libraryLocation to set.
*/
public static void setLibraryLocation(String libraryLocation) {
final File dll = new File(libraryLocation);
if (!dll.isAbsolute()) {
JIntellitype.libraryLocation = dll.getAbsolutePath();
} else {
// absolute path, no further calculation needed
JIntellitype.libraryLocation = libraryLocation;
}
}
/**
* Notifies all listeners that Hotkey was pressed.
* <p>
* @param identifier the unique identifier received
*/
protected void onHotKey(final int identifier) {
for (final HotkeyListener hotkeyListener : hotkeyListeners) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
hotkeyListener.onHotKey(identifier);
}
});
}
}
/**
* Notifies all listeners that Intellitype command was received.
* <p>
* @param command the unique WM_APPCOMMAND received
*/
protected void onIntellitype(final int command) {
for (final IntellitypeListener intellitypeListener : intellitypeListeners) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
intellitypeListener.onIntellitype(command);
}
});
}
}
/**
* Swing modifier value to Jintellipad conversion. If no conversion needed
* just return the original value. This lets users pass either the original
* JIntellitype constants or Swing InputEvent constants.
* <p>
* @param swingKeystrokeModifier the Swing KeystrokeModifier to check
* @return Jintellitype the JIntellitype modifier value
*/
protected static int swingToIntelliType(int swingKeystrokeModifier) {
int mask = 0;
if ((swingKeystrokeModifier & InputEvent.SHIFT_MASK) == InputEvent.SHIFT_MASK) {
mask += JIntellitype.MOD_SHIFT;
}
if ((swingKeystrokeModifier & InputEvent.ALT_MASK) == InputEvent.ALT_MASK) {
mask += JIntellitype.MOD_ALT;
}
if ((swingKeystrokeModifier & InputEvent.CTRL_MASK) == InputEvent.CTRL_MASK) {
mask += JIntellitype.MOD_CONTROL;
}
if ((swingKeystrokeModifier & InputEvent.SHIFT_DOWN_MASK) == InputEvent.SHIFT_DOWN_MASK) {
mask += JIntellitype.MOD_SHIFT;
}
if ((swingKeystrokeModifier & InputEvent.ALT_DOWN_MASK) == InputEvent.ALT_DOWN_MASK) {
mask += JIntellitype.MOD_ALT;
}
if ((swingKeystrokeModifier & InputEvent.CTRL_DOWN_MASK) == InputEvent.CTRL_DOWN_MASK) {
mask += JIntellitype.MOD_CONTROL;
}
return mask;
}
/**
* Puts all constants from {@link java.awt.event.KeyEvent} in a keycodeMap.
* The key is the lower case form of it.
* @return Map containing key->keycode mapping DOCU Now enables the user to
* use all keys specified here instead of just [A-Z],[0-9] as before
*/
private HashMap<String, Integer> getKey2KeycodeMapping() {
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("first", KeyEvent.KEY_FIRST);
map.put("last", KeyEvent.KEY_LAST);
map.put("typed", KeyEvent.KEY_TYPED);
map.put("pressed", KeyEvent.KEY_PRESSED);
map.put("released", KeyEvent.KEY_RELEASED);
map.put("enter", 13);
map.put("back_space", KeyEvent.VK_BACK_SPACE);
map.put("tab", KeyEvent.VK_TAB);
map.put("cancel", KeyEvent.VK_CANCEL);
map.put("clear", KeyEvent.VK_CLEAR);
map.put("pause", KeyEvent.VK_PAUSE);
map.put("caps_lock", KeyEvent.VK_CAPS_LOCK);
map.put("escape", KeyEvent.VK_ESCAPE);
map.put("space", KeyEvent.VK_SPACE);
map.put("page_up", KeyEvent.VK_PAGE_UP);
map.put("page_down", KeyEvent.VK_PAGE_DOWN);
map.put("end", KeyEvent.VK_END);
map.put("home", KeyEvent.VK_HOME);
map.put("left", KeyEvent.VK_LEFT);
map.put("up", KeyEvent.VK_UP);
map.put("right", KeyEvent.VK_RIGHT);
map.put("down", KeyEvent.VK_DOWN);
map.put("comma", 188);
map.put("minus", 109);
map.put("period", 110);
map.put("slash", 191);
map.put("0", KeyEvent.VK_0);
map.put("1", KeyEvent.VK_1);
map.put("2", KeyEvent.VK_2);
map.put("3", KeyEvent.VK_3);
map.put("4", KeyEvent.VK_4);
map.put("5", KeyEvent.VK_5);
map.put("6", KeyEvent.VK_6);
map.put("7", KeyEvent.VK_7);
map.put("8", KeyEvent.VK_8);
map.put("9", KeyEvent.VK_9);
map.put("semicolon", 186);
map.put("equals", 187);
map.put("a", KeyEvent.VK_A);
map.put("b", KeyEvent.VK_B);
map.put("c", KeyEvent.VK_C);
map.put("d", KeyEvent.VK_D);
map.put("e", KeyEvent.VK_E);
map.put("f", KeyEvent.VK_F);
map.put("g", KeyEvent.VK_G);
map.put("h", KeyEvent.VK_H);
map.put("i", KeyEvent.VK_I);
map.put("j", KeyEvent.VK_J);
map.put("k", KeyEvent.VK_K);
map.put("l", KeyEvent.VK_L);
map.put("m", KeyEvent.VK_M);
map.put("n", KeyEvent.VK_N);
map.put("o", KeyEvent.VK_O);
map.put("p", KeyEvent.VK_P);
map.put("q", KeyEvent.VK_Q);
map.put("r", KeyEvent.VK_R);
map.put("s", KeyEvent.VK_S);
map.put("t", KeyEvent.VK_T);
map.put("u", KeyEvent.VK_U);
map.put("v", KeyEvent.VK_V);
map.put("w", KeyEvent.VK_W);
map.put("x", KeyEvent.VK_X);
map.put("y", KeyEvent.VK_Y);
map.put("z", KeyEvent.VK_Z);
map.put("open_bracket", 219);
map.put("back_slash", 220);
map.put("close_bracket", 221);
map.put("numpad0", KeyEvent.VK_NUMPAD0);
map.put("numpad1", KeyEvent.VK_NUMPAD1);
map.put("numpad2", KeyEvent.VK_NUMPAD2);
map.put("numpad3", KeyEvent.VK_NUMPAD3);
map.put("numpad4", KeyEvent.VK_NUMPAD4);
map.put("numpad5", KeyEvent.VK_NUMPAD5);
map.put("numpad6", KeyEvent.VK_NUMPAD6);
map.put("numpad7", KeyEvent.VK_NUMPAD7);
map.put("numpad8", KeyEvent.VK_NUMPAD8);
map.put("numpad9", KeyEvent.VK_NUMPAD9);
map.put("multiply", KeyEvent.VK_MULTIPLY);
map.put("add", KeyEvent.VK_ADD);
map.put("separator", KeyEvent.VK_SEPARATOR);
map.put("subtract", KeyEvent.VK_SUBTRACT);
map.put("decimal", KeyEvent.VK_DECIMAL);
map.put("divide", KeyEvent.VK_DIVIDE);
map.put("delete", 46);
map.put("num_lock", KeyEvent.VK_NUM_LOCK);
map.put("scroll_lock", KeyEvent.VK_SCROLL_LOCK);
map.put("f1", KeyEvent.VK_F1);
map.put("f2", KeyEvent.VK_F2);
map.put("f3", KeyEvent.VK_F3);
map.put("f4", KeyEvent.VK_F4);
map.put("f5", KeyEvent.VK_F5);
map.put("f6", KeyEvent.VK_F6);
map.put("f7", KeyEvent.VK_F7);
map.put("f8", KeyEvent.VK_F8);
map.put("f9", KeyEvent.VK_F9);
map.put("f10", KeyEvent.VK_F10);
map.put("f11", KeyEvent.VK_F11);
map.put("f12", KeyEvent.VK_F12);
map.put("f13", KeyEvent.VK_F13);
map.put("f14", KeyEvent.VK_F14);
map.put("f15", KeyEvent.VK_F15);
map.put("f16", KeyEvent.VK_F16);
map.put("f17", KeyEvent.VK_F17);
map.put("f18", KeyEvent.VK_F18);
map.put("f19", KeyEvent.VK_F19);
map.put("f20", KeyEvent.VK_F20);
map.put("f21", KeyEvent.VK_F21);
map.put("f22", KeyEvent.VK_F22);
map.put("f23", KeyEvent.VK_F23);
map.put("f24", KeyEvent.VK_F24);
map.put("printscreen", 44);
map.put("insert", 45);
map.put("help", 47);
map.put("meta", KeyEvent.VK_META);
map.put("back_quote", KeyEvent.VK_BACK_QUOTE);
map.put("quote", KeyEvent.VK_QUOTE);
map.put("kp_up", KeyEvent.VK_KP_UP);
map.put("kp_down", KeyEvent.VK_KP_DOWN);
map.put("kp_left", KeyEvent.VK_KP_LEFT);
map.put("kp_right", KeyEvent.VK_KP_RIGHT);
map.put("dead_grave", KeyEvent.VK_DEAD_GRAVE);
map.put("dead_acute", KeyEvent.VK_DEAD_ACUTE);
map.put("dead_circumflex", KeyEvent.VK_DEAD_CIRCUMFLEX);
map.put("dead_tilde", KeyEvent.VK_DEAD_TILDE);
map.put("dead_macron", KeyEvent.VK_DEAD_MACRON);
map.put("dead_breve", KeyEvent.VK_DEAD_BREVE);
map.put("dead_abovedot", KeyEvent.VK_DEAD_ABOVEDOT);
map.put("dead_diaeresis", KeyEvent.VK_DEAD_DIAERESIS);
map.put("dead_abovering", KeyEvent.VK_DEAD_ABOVERING);
map.put("dead_doubleacute", KeyEvent.VK_DEAD_DOUBLEACUTE);
map.put("dead_caron", KeyEvent.VK_DEAD_CARON);
map.put("dead_cedilla", KeyEvent.VK_DEAD_CEDILLA);
map.put("dead_ogonek", KeyEvent.VK_DEAD_OGONEK);
map.put("dead_iota", KeyEvent.VK_DEAD_IOTA);
map.put("dead_voiced_sound", KeyEvent.VK_DEAD_VOICED_SOUND);
map.put("dead_semivoiced_sound", KeyEvent.VK_DEAD_SEMIVOICED_SOUND);
map.put("ampersand", KeyEvent.VK_AMPERSAND);
map.put("asterisk", KeyEvent.VK_ASTERISK);
map.put("quotedbl", KeyEvent.VK_QUOTEDBL);
map.put("less", KeyEvent.VK_LESS);
map.put("greater", KeyEvent.VK_GREATER);
map.put("braceleft", KeyEvent.VK_BRACELEFT);
map.put("braceright", KeyEvent.VK_BRACERIGHT);
map.put("at", KeyEvent.VK_AT);
map.put("colon", KeyEvent.VK_COLON);
map.put("circumflex", KeyEvent.VK_CIRCUMFLEX);
map.put("dollar", KeyEvent.VK_DOLLAR);
map.put("euro_sign", KeyEvent.VK_EURO_SIGN);
map.put("exclamation_mark", KeyEvent.VK_EXCLAMATION_MARK);
map.put("inverted_exclamation_mark", KeyEvent.VK_INVERTED_EXCLAMATION_MARK);
map.put("left_parenthesis", KeyEvent.VK_LEFT_PARENTHESIS);
map.put("number_sign", KeyEvent.VK_NUMBER_SIGN);
map.put("plus", KeyEvent.VK_PLUS);
map.put("right_parenthesis", KeyEvent.VK_RIGHT_PARENTHESIS);
map.put("underscore", KeyEvent.VK_UNDERSCORE);
map.put("context_menu", KeyEvent.VK_CONTEXT_MENU);
map.put("final", KeyEvent.VK_FINAL);
map.put("convert", KeyEvent.VK_CONVERT);
map.put("nonconvert", KeyEvent.VK_NONCONVERT);
map.put("accept", KeyEvent.VK_ACCEPT);
map.put("modechange", KeyEvent.VK_MODECHANGE);
map.put("kana", KeyEvent.VK_KANA);
map.put("kanji", KeyEvent.VK_KANJI);
map.put("alphanumeric", KeyEvent.VK_ALPHANUMERIC);
map.put("katakana", KeyEvent.VK_KATAKANA);
map.put("hiragana", KeyEvent.VK_HIRAGANA);
map.put("full_width", KeyEvent.VK_FULL_WIDTH);
map.put("half_width", KeyEvent.VK_HALF_WIDTH);
map.put("roman_characters", KeyEvent.VK_ROMAN_CHARACTERS);
map.put("all_candidates", KeyEvent.VK_ALL_CANDIDATES);
map.put("previous_candidate", KeyEvent.VK_PREVIOUS_CANDIDATE);
map.put("code_input", KeyEvent.VK_CODE_INPUT);
map.put("japanese_katakana", KeyEvent.VK_JAPANESE_KATAKANA);
map.put("japanese_hiragana", KeyEvent.VK_JAPANESE_HIRAGANA);
map.put("japanese_roman", KeyEvent.VK_JAPANESE_ROMAN);
map.put("kana_lock", KeyEvent.VK_KANA_LOCK);
map.put("input_method_on_off", KeyEvent.VK_INPUT_METHOD_ON_OFF);
map.put("cut", KeyEvent.VK_CUT);
map.put("copy", KeyEvent.VK_COPY);
map.put("paste", KeyEvent.VK_PASTE);
map.put("undo", KeyEvent.VK_UNDO);
map.put("again", KeyEvent.VK_AGAIN);
map.put("find", KeyEvent.VK_FIND);
map.put("props", KeyEvent.VK_PROPS);
map.put("stop", KeyEvent.VK_STOP);
map.put("compose", KeyEvent.VK_COMPOSE);
map.put("alt_graph", KeyEvent.VK_ALT_GRAPH);
map.put("begin", KeyEvent.VK_BEGIN);
return map;
}
private synchronized native void initializeLibrary() throws UnsatisfiedLinkError;
private synchronized native void regHotKey(int identifier, int modifier, int keycode) throws UnsatisfiedLinkError;
private synchronized native void terminate() throws UnsatisfiedLinkError;
private synchronized native void unregHotKey(int identifier) throws UnsatisfiedLinkError;
/**
* Checks if there's an instance with hidden window title = appName running
* Can be used to detect that another instance of your app is already running
* (so exit..)
* <p>
* @param appName = the title of the hidden window to search for
*/
private synchronized native boolean isRunning(String appName);
}

182
java/src/com/melloware/jintellitype/JIntellitypeConstants.java Normal file
View File

@@ -0,0 +1,182 @@
/**
* JIntellitype
* -----------------
* Copyright 2005-2008 Emil A. Lefkof III, Melloware Inc.
*
* I always give it my best shot to make a program useful and solid, but
* remeber that there is absolutely no warranty for using this program as
* stated in the following terms:
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.melloware.jintellitype;
/**
* Constants from the Windows API used in JIntellitype.
* <p>
* Message information can be found on MSDN here:
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardinput/keyboardinputreference/keyboardinputmessages/wm_appcommand.asp
* <p>
* Copyright (c) 1999-2008
* Melloware, Inc. <http://www.melloware.com>
* @author Emil A. Lefkof III <info@melloware.com>
* @version 1.3.1
*/
public interface JIntellitypeConstants {
public static final String ERROR_MESSAGE = "JIntellitype DLL Error";
// Modifier keys, can be added together
/**
* ALT key for registering Hotkeys.
*/
public static final int MOD_ALT = 1;
/**
* CONTROL key for registering Hotkeys.
*/
public static final int MOD_CONTROL = 2;
/**
* SHIFT key for registering Hotkeys.
*/
public static final int MOD_SHIFT = 4;
/**
* WINDOWS key for registering Hotkeys.
*/
public static final int MOD_WIN = 8;
// Intellitype Virtual Key Constants from MSDN
/**
* Browser Navigate backward
*/
public static final int APPCOMMAND_BROWSER_BACKWARD = 1;
/**
* Browser Navigate forward
*/
public static final int APPCOMMAND_BROWSER_FORWARD = 2;
/**
* Browser Refresh page
*/
public static final int APPCOMMAND_BROWSER_REFRESH = 3;
/**
* Browser Stop download
*/
public static final int APPCOMMAND_BROWSER_STOP = 4;
/**
* Browser Open search
*/
public static final int APPCOMMAND_BROWSER_SEARCH = 5;
/**
* Browser Open favorites
*/
public static final int APPCOMMAND_BROWSER_FAVOURITES = 6;
/**
* Browser Navigate home
*/
public static final int APPCOMMAND_BROWSER_HOME = 7;
/**
* Mute the volume
*/
public static final int APPCOMMAND_VOLUME_MUTE = 8;
/**
* Lower the volume
*/
public static final int APPCOMMAND_VOLUME_DOWN = 9;
/**
* Raise the volume
*/
public static final int APPCOMMAND_VOLUME_UP = 10;
/**
* Media application go to next track.
*/
public static final int APPCOMMAND_MEDIA_NEXTTRACK = 11;
/**
* Media application Go to previous track.
*/
public static final int APPCOMMAND_MEDIA_PREVIOUSTRACK = 12;
/**
* Media application Stop playback.
*/
public static final int APPCOMMAND_MEDIA_STOP = 13;
/**
* Media application Play or pause playback.
*/
public static final int APPCOMMAND_MEDIA_PLAY_PAUSE = 14;
/**
* Open mail application
*/
public static final int APPCOMMAND_LAUNCH_MAIL = 15;
/**
* Go to Media Select mode.
*/
public static final int APPCOMMAND_LAUNCH_MEDIA_SELECT = 16;
/**
* Start App1.
*/
public static final int APPCOMMAND_LAUNCH_APP1 = 17;
/**
* Start App2.
*/
public static final int APPCOMMAND_LAUNCH_APP2 = 18;
public static final int APPCOMMAND_BASS_DOWN = 19;
public static final int APPCOMMAND_BASS_BOOST = 20;
public static final int APPCOMMAND_BASS_UP = 21;
public static final int APPCOMMAND_TREBLE_DOWN = 22;
public static final int APPCOMMAND_TREBLE_UP = 23;
public static final int APPCOMMAND_MICROPHONE_VOLUME_MUTE = 24;
public static final int APPCOMMAND_MICROPHONE_VOLUME_DOWN = 25;
public static final int APPCOMMAND_MICROPHONE_VOLUME_UP = 26;
public static final int APPCOMMAND_HELP = 27;
public static final int APPCOMMAND_FIND = 28;
public static final int APPCOMMAND_NEW = 29;
public static final int APPCOMMAND_OPEN = 30;
public static final int APPCOMMAND_CLOSE = 31;
public static final int APPCOMMAND_SAVE = 32;
public static final int APPCOMMAND_PRINT = 33;
public static final int APPCOMMAND_UNDO = 34;
public static final int APPCOMMAND_REDO = 35;
public static final int APPCOMMAND_COPY = 36;
public static final int APPCOMMAND_CUT = 37;
public static final int APPCOMMAND_PASTE = 38;
public static final int APPCOMMAND_REPLY_TO_MAIL = 39;
public static final int APPCOMMAND_FORWARD_MAIL = 40;
public static final int APPCOMMAND_SEND_MAIL = 41;
public static final int APPCOMMAND_SPELL_CHECK = 42;
public static final int APPCOMMAND_DICTATE_OR_COMMAND_CONTROL_TOGGLE = 43;
public static final int APPCOMMAND_MIC_ON_OFF_TOGGLE = 44;
public static final int APPCOMMAND_CORRECTION_LIST = 45;
}

55
java/src/com/melloware/jintellitype/JIntellitypeException.java Normal file
View File

@@ -0,0 +1,55 @@
/**
* JIntellitype
* -----------------
* Copyright 2005-2008 Emil A. Lefkof III, Melloware Inc.
*
* I always give it my best shot to make a program useful and solid, but
* remeber that there is absolutely no warranty for using this program as
* stated in the following terms:
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.melloware.jintellitype;
/**
* Exception class for all JIntellitype Exceptions.
* <p>
* Copyright (c) 1999-2008
* Melloware, Inc. <http://www.melloware.com>
* @author Emil A. Lefkof III <info@melloware.com>
* @version 1.3.1
*/
public class JIntellitypeException extends RuntimeException {
public JIntellitypeException() {
super();
}
public JIntellitypeException(String aMessage, Throwable aCause) {
super(aMessage, aCause);
}
public JIntellitypeException(String aMessage) {
super(aMessage);
}
public JIntellitypeException(Throwable aCause) {
super(aCause);
}
}

80
java/src/com/melloware/jintellitype/Main.java Normal file
View File

@@ -0,0 +1,80 @@
/**
* JIntellitype
* -----------------
* Copyright 2005-2008 Emil A. Lefkof III, Melloware Inc.
*
* I always give it my best shot to make a program useful and solid, but
* remeber that there is absolutely no warranty for using this program as
* stated in the following terms:
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.melloware.jintellitype;
import java.util.Properties;
/**
* Simple executable class that is used as the Main-Class in the JIntellitype
* jar. Outputs version information and other information about the environment
* on which the jar is being executed.
* <p>
* Copyright (c) 1999-2008
* Melloware, Inc. <http://www.melloware.com>
* @author Emil A. Lefkof III <info@melloware.com>
* @version 1.3.1
*/
@SuppressWarnings("")
public final class Main {
/**
* Private constructor to make sure this class is never instantiated.
*
*/
private Main() {
// private constructor to make singleton.
}
/** Main method that does what the class level javadoc states. */
public static void main(String[] argv) {
System.out.println("JIntellitype version \"" + getProjectVersion() + "\"");
System.out.println(" ");
System.out.println("Running on java version \"" + System.getProperty("java.version") + "\""
+ " (build " + System.getProperty("java.runtime.version") + ")"
+ " from " + System.getProperty("java.vendor"));
System.out.println("Operating environment \"" + System.getProperty("os.name") + "\""
+ " version " + System.getProperty("os.version") + " on " + System.getProperty("os.arch"));
System.out.println("For more information on JIntellitype please visit http://www.melloware.com");
}
/**
* Attempts to read the version number out of the pom.properties. If not found
* then RUNNING.IN.IDE.FULL is returned as the version.
* <p>
* @return the full version number of this application
*/
private static String getProjectVersion() {
String version;
try {
final Properties pomProperties = new Properties();
pomProperties.load(Main.class.getResourceAsStream("/META-INF/maven/com.melloware/jintellitype/pom.properties"));
version = pomProperties.getProperty("version");
} catch (Exception e) {
version = "RUNNING.IN.IDE.FULL";
}
return version;
}
}

351
java/src/wiiusej/WiiUseApi.java Normal file
View File

@@ -0,0 +1,351 @@
/**
* 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.wiiusejevents.utils.EventsGatherer;
/**
* Singleton used to manipulate WiiUse Api.
*
* @author guiguito
*/
public class WiiUseApi {
static {
System.loadLibrary("WiiuseJ");
}
private static WiiUseApi instance = new WiiUseApi();
/**
* Get the only instance of WiiUseApi.
*
* @return the only instace of WiiUseApi.
*/
protected static WiiUseApi getInstance() {
return instance;
}
/**
* Connect to a wiimote or wiimotes once an address is known.
*
* @param nbWiimotes
* The number of wiimotes.
* @return The number of wiimotes that successfully connected.
*/
synchronized native int connect(int nbWiimotes);
/**
* Find a wiimote or wiimotes.
*
* @param nbMaxWiimotes
* The number of wiimotes.
* @param timeout
* The number of seconds before the search times out.
* @return The number of wiimotes found.
*/
synchronized native int find(int nbMaxWiimotes, int timeout);
/**
* Initialize an array of wiimote structures (for the C side of the
* library).
*
* @param nbPossibleWiimotes
* size of the array.
*/
synchronized native void init(int nbPossibleWiimotes);
/**
* Close connection to the wiimote with the given id.
*
*/
synchronized native void closeConnection(int id);
/**
* Get unique id of a wiimote in the wiimotes array. Please make sure you
* call an existing index with a wiimote initialized at this index, other
* wise you'll get a wrong value.
*
* @param index
* index of the wiimote in the wiimotes array.
* @return the unid of the wiimote, or a wrong value if the index was false.
*
*/
synchronized native int getUnId(int index);
/**
* CleanUp Wiiuse API.
*/
synchronized native void cleanUp();
/**
* Activate rumble on the wiimote with the given id.
*
* @param id
* the id of the wiimote.
*/
synchronized native void activateRumble(int id);
/**
* Deactivate rumble on the wiimote with the given id.
*
* @param id
* the id of the wiimote.
*/
synchronized native void deactivateRumble(int id);
/**
* Activate IR Tracking on the wiimote with the given id.
*
* @param id
* the id of the wiimote.
*/
synchronized native void activateIRTracking(int id);
/**
* Deactivate IR Tracking on the wiimote with the given id.
*
* @param id
* the id of the wiimote.
*/
synchronized native void deactivateIRTracking(int id);
/**
* Activate motion sensing on the wiimote with the given id.
*
* @param id
* the id of the wiimote.
*/
synchronized native void activateMotionSensing(int id);
/**
* Deactivate motion sensing on the wiimote with the given id.
*
* @param id
* the id of the wiimote.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized native void activateSmoothing(int id);
/**
* Make the the accelerometers give raw results.
*
* @param id
* the id of the wiimote concerned.
*/
synchronized 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.
*/
synchronized native void activateContinuous(int id);
/**
* Make the wiimote generate an event only when there is one.
*
* @param id
* the id of the wiimote concerned.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized 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.
*/
synchronized native void getStatus(int id);
/**
* Set the normal and expansion handshake timeouts.
*
* @param id
* the id of the wiimote concerned.
* @param normalTimeout
* The timeout in milliseconds for a normal read.
* @param expansionTimeout
* The timeout in millisecondsd to wait for an expansion
* handshake.
*/
synchronized native void setTimeout(int id, short normalTimeout,
short expansionTimeout);
/**
* Set the IR sensitivity.
*
* @param id
* the id of the wiimote concerned.
* @param level
* 1-5, same as Wii system sensitivity setting. If the level is <
* 1, then level will be set to 1. If the level is > 5, then
* level will be set to 5.
*/
synchronized native void setIrSensitivity(int id, int level);
/**
* Set how many degrees an angle must change to generate an event for the
* nunchuk.
*
* @param id
* id of the wiimote concerned.
* @param angle
* minimum angle detected by an event.
*/
synchronized native void setNunchukOrientationThreshold(int id, float angle);
/**
* Set how much acceleration must change to generate an event for the
* nunchuk.
*
* @param id
* id of the wiimote concerned.
* @param value
* minimum value detected by an event.
*/
synchronized native void setNunchukAccelerationThreshold(int id, int value);
/**
* Force the bluetooth stack type.(useful only for windows)
*
* @param bluetoothStackType
* must be WiiUseApi.WIIUSE_STACK_UNKNOWN or
* WiiUseApi.WIIUSE_STACK_MS or
* WiiUseApi.WIIUSE_STACK_BLUESOLEIL.
*/
native void windowsSetBluetoothStack(int bluetoothStackType);
/**
* Check for new Events and Get it.
*
* @param gath
* the object where we store all the new events.
*/
native void specialPoll(EventsGatherer gath);
}

664
java/src/wiiusej/WiiUseApiManager.java Normal file
View File

@@ -0,0 +1,664 @@
/**
* 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.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.swing.event.EventListenerList;
import wiiusej.wiiusejevents.utils.EventsGatherer;
import wiiusej.wiiusejevents.utils.WiiUseApiListener;
import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent;
/**
* 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 Semaphore semaphore = new Semaphore(0);
private Wiimote[] wiimotes;
private WiiUseApi wiiuse = WiiUseApi.getInstance();
private int connected = -1;
private AtomicBoolean running = new AtomicBoolean(false);
private boolean leave = false;
public static int WIIUSE_STACK_UNKNOWN = 0;
public static int WIIUSE_STACK_MS = 1;
public static int WIIUSE_STACK_BLUESOLEIL = 2;
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.
* @param rumble
* make the connected wiimotes rumble.
*
* @return an array with connected wiimotes or NULL.
*/
public static Wiimote[] getWiimotes(int nb, boolean rumble) {
return getWiimotesPrivate(nb, rumble, false, WIIUSE_STACK_UNKNOWN);
}
/**
* 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.
* @param rumble
* make the connected wiimotes rumble.*
* @param stackType
* the stack type : WiiUseApiManager.WIIUSE_STACK_UNKNOWN or
* WiiUseApiManager.WIIUSE_STACK_MS or
* WiiUseApiManager.WIIUSE_STACK_BLUESOLEIL
*
* @return an array with connected wiimotes or NULL.
*/
public static Wiimote[] getWiimotes(int nb, boolean rumble, int stackType) {
return getWiimotesPrivate(nb, rumble, true, stackType);
}
/**
* 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.
* @param rumble
* make the connected wiimotes rumble.*
* @param forceStackType
* true if we want to force the stack type.
* @param stackType
* the stack type : WiiUseApiManager.WIIUSE_STACK_UNKNOWN or
* WiiUseApiManager.WIIUSE_STACK_MS or
* WiiUseApiManager.WIIUSE_STACK_BLUESOLEIL
*
* @return an array with connected wiimotes or NULL.
*/
private synchronized static Wiimote[] getWiimotesPrivate(int nb,
boolean rumble, boolean forceStackType, int stackType) {
WiiUseApiManager manager = getInstance();
if (manager.leave)
return null;// wiiusej definitively stopped
if (manager.connected <= 0 && !manager.running.get()) {
// connect wiimotes.
int nbWiimotes = manager.connectWiimotes(nb, rumble,
forceStackType, stackType);
manager.wiimotes = new Wiimote[nbWiimotes];
for (int i = 0; i < nbWiimotes; i++) {
Wiimote wim = new Wiimote(WiiUseApi.getInstance().getUnId(i),
manager);
manager.wiimotes[i] = wim;
manager.addWiiUseApiListener(wim);
}
// Set leds on wiimote
for (Wiimote wiimote : manager.wiimotes) {
int id = wiimote.getId();
if (id % 4 == 0) {
wiimote.setLeds(true, true, true, true);
} else if (id % 4 == 1) {
wiimote.setLeds(true, false, false, false);
} else if (id % 4 == 2) {
wiimote.setLeds(true, true, false, false);
} else if (id % 4 == 3) {
wiimote.setLeds(true, true, true, false);
}
}
// make the connected wiimotes rumble
if (rumble) {
for (Wiimote wiimote : manager.wiimotes) {
wiimote.activateRumble();
}
try {
sleep(500);
} catch (InterruptedException e) {
}
for (Wiimote wiimote : manager.wiimotes) {
wiimote.deactivateRumble();
}
}
}
if (manager.connected == 0) {// no wiimote connected
// return empty array
return new Wiimote[0];
}
if (!manager.isAlive())// start wiiuseJ polling
manager.start();
manager.semaphore.release(1);
return manager.wiimotes;
}
/**
* Connect wiimote and get the number of wiimotes connected. Supposed to be
* used once.
*
* @param nb
* try to connect nb wiimotes
* @param rumble
* make the connected wiimotes rumble
* @param forceStackType
* true if we want to force the stack type.
* @param stackType
* the stack type : WiiUseApiManager.WIIUSE_STACK_UNKNOWN or
* WiiUseApiManager.WIIUSE_STACK_MS or
* WiiUseApiManager.WIIUSE_STACK_BLUESOLEIL
* @return 0 if nothing connected or the number of wiimotes connected.
*/
private int connectWiimotes(int nb, boolean rumble, boolean forceStackType,
int stackType) {
if (connected <= 0) {
int nbWiimotesFound;
wiiuse.init(nb);
// force bluetooth stack type ?
if (forceStackType)
setBlueToothstackType(stackType);
nbWiimotesFound = wiiuse.find(nb, 3);
connected = wiiuse.connect(nbWiimotesFound);
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.
*/
protected void closeConnection(int id) {
int index = 0;
boolean found = false;
while (index < wiimotes.length && !found) {
if (wiimotes[index]!=null && wiimotes[index].getId() == id) {// we have a wiimote with this
// id
// remove the wiimote
removeWiiUseApiListener(wiimotes[index]);
wiimotes[index] = null;
connected--;
if (connected == 0) {// stop this thread if there is
// no more wiimotes connected.
// stop thread
running.set(false);
}
/* Close connection in wiiuse */
wiiuse.closeConnection(index);
}
index++;
}
}
/**
* Get the number of wiimotes connected.
*
* @return the number of wiimotes connected.
*/
public static int getNbConnectedWiimotes() {
return getInstance().connected;
}
/**
* Stop thread and shutdown wiiuse Api.
*/
public static void shutdown() {
WiiUseApiManager manager = getInstance();
int pastConnected = manager.connected;
if (manager.connected > 0) {
for (Wiimote wim : manager.wiimotes) {
if (wim != null)
wim.disconnect();
}
}
manager.running.set(false);
if (pastConnected > 0) {
manager.wiiuse.cleanUp();
}
}
/**
* Stop wiiuseJ definitively for this program. It finishes Wiiusej thread
* and shutdown wiiuse API.
*/
public static void definitiveShutdown() {
getInstance().leave = true;
shutdown();
}
/**
* Activate the rumble for the wiimote with the given id.
*
* @param id
* id of the wiimote.
*/
protected void activateRumble(int id) {
wiiuse.activateRumble(id);
}
/**
* Deactivate the rumble for the wiimote with the given id.
*
* @param id
* id of the wiimote.
*/
protected void deactivateRumble(int id) {
wiiuse.deactivateRumble(id);
}
/**
* Activate IR Tracking for the wiimote with the given id.
*
* @param id
* id of the wiimote.
*/
protected void activateIRTRacking(int id) {
wiiuse.activateIRTracking(id);
}
/**
* Deactivate IR Tracking for the wiimote with the given id.
*
* @param id
* id of the wiimote.
*/
protected void deactivateIRTRacking(int id) {
wiiuse.deactivateIRTracking(id);
}
/**
* Activate motion sensing for the wiimote with the given id.
*
* @param id
* id of the wiimote.
*/
protected void activateMotionSensing(int id) {
wiiuse.activateMotionSensing(id);
}
/**
* Deactivate motion sensing for the wiimoter with the given id.
*
* @param id
* id of the wiimote.
*/
protected void deactivateMotionSensing(int id) {
wiiuse.deactivateMotionSensing(id);
}
/**
* Activate smoothing the wiimotes with the given id.
*
* @param id
* id of the wiimote.
*/
protected void activateSmoothing(int id) {
wiiuse.activateSmoothing(id);
}
/**
* Deactivate smoothing the wiimotes with the given id.
*
* @param id
* id of the wiimote.
*/
protected void deactivateSmoothing(int id) {
wiiuse.deactivateSmoothing(id);
}
/**
* Activate continuous for the wiimotes with the given id.
*
* @param id
* id of the wiimote.
*/
protected void activateContinuous(int id) {
wiiuse.activateContinuous(id);
}
/**
* Deactivate continuous for the wiimotes with the given id.
*
* @param id
* id of the wiimote.
*/
protected void deactivateContinuous(int id) {
wiiuse.deactivateContinuous(id);
}
/**
* 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.
*/
protected void setLeds(int id, boolean l1, boolean l2, boolean l3,
boolean l4) {
wiiuse.setLeds(id, l1, l2, l3, l4);
}
/**
* Set the orientation threshold for the given id. (minimum angle between
* two events)
*
* @param id
* id of the wiimote.
* @param th
* threshold in degrees.
*/
protected void setOrientationThreshold(int id, float th) {
wiiuse.setOrientThreshold(id, th);
}
/**
* Set the acceleration threshold for the given id. (minimum angle between
* two events)
*
* @param id
* id of the wiimote.
* @param th
* threshold.
*/
protected void setAccelerationThreshold(int id, int th) {
wiiuse.setAccelThreshold(id, th);
}
/**
* Set alpha smoothing for the given id.
*
* @param id
* id of the wiimote.
* @param th
* threshold.
*/
protected void setAlphaSmoothing(int id, float th) {
wiiuse.setAlphaSmoothing(id, th);
}
/**
* Try to resync with the wiimote by starting a new handshake.
*
* @param id
* id of the wiimote.
*/
protected void reSync(int id) {
wiiuse.reSync(id);
}
/**
* Set screen aspect ratio to 4/3 for the given id.
*
* @param id
* id of the wiimote.
*/
protected void setScreenAspectRatio43(int id) {
wiiuse.setScreenRatio43(id);
}
/**
* Set screen aspect ratio to 16/9 for the given id.
*
* @param id
* id of the wiimote.
*/
protected void setScreenAspectRatio169(int id) {
wiiuse.setScreenRatio169(id);
}
/**
* Set the sensor bar to be above the screen.
*
* @param id
* id of the wiimote.
*/
protected void setSensorBarAboveScreen(int id) {
wiiuse.setSensorBarAboveScreen(id);
}
/**
* Set the sensor bar to be below the screen.
*
* @param id
* id of the wiimote.
*/
protected void setSensorBarBelowScreen(int id) {
wiiuse.setSensorBarBelowScreen(id);
}
/**
* 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.
*/
protected void setVirtualResolution(int id, int x, int y) {
wiiuse.setVirtualScreenResolution(id, x, y);
}
/**
* Get Status for the wiimote for the given id.
*
* @param id
* id of the wiimote.
*/
protected void getStatus(int id) {
wiiuse.getStatus(id);
}
/**
* Set the normal and expansion handshake timeouts.
*
* @param id
* the id of the wiimote concerned.
* @param normalTimeout
* The timeout in milliseconds for a normal read.
* @param expansionTimeout
* The timeout in millisecondsd to wait for an expansion
* handshake.
*/
protected void setTimeout(int id, short normalTimeout,
short expansionTimeout) {
wiiuse.setTimeout(id, normalTimeout, expansionTimeout);
}
/**
* Set the IR sensitivity.
*
* @param id
* the id of the wiimote concerned.
* @param level
* 1-5, same as Wii system sensitivity setting. If the level is <
* 1, then level will be set to 1. If the level is > 5, then
* level will be set to 5.
*/
protected void setIrSensitivity(int id, int level) {
wiiuse.setIrSensitivity(id, level);
}
/**
* Set the nunchuk orientation threshold for the given id. (minimum angle
* between two events)
*
* @param id
* id of the wiimote.
* @param th
* threshold in degrees.
*/
protected void setNunchukOrientationThreshold(int id, float th) {
wiiuse.setNunchukOrientationThreshold(id, th);
}
/**
* Set the nunchuk acceleration threshold for the given id. (minimum angle
* between two events)
*
* @param id
* id of the wiimote.
* @param th
* threshold.
*/
protected void setNunchukAccelerationThreshold(int id, int th) {
wiiuse.setNunchukAccelerationThreshold(id, th);
}
/**
* Force the bluetooth stack type.(useful only for windows)
*
* @param type
* must be WIIUSE_STACK_UNKNOWN or WIIUSE_STACK_MS or
* WIIUSE_STACK_BLUESOLEIL.
*/
private void setBlueToothstackType(int type) {
wiiuse.windowsSetBluetoothStack(type);
}
@Override
public void run() {
while (!leave) {
try {
semaphore.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (connected > 0) {
running.set(true);
EventsGatherer gather = new EventsGatherer(connected);
// Start polling and tell the observers when there are 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();
}
}/* else {
if (connected <= 0) {
System.out.println("No wiimotes connected !");
}
}*/
}// end while true
}
/**
* Add WiiUseApiListener to the listeners list.
*
* @param listener
* a WiiUseApiListener
*/
protected void addWiiUseApiListener(WiiUseApiListener listener) {
listeners.add(WiiUseApiListener.class, listener);
}
/**
* Remove WiiUseApiListener from the listeners list.
*
* @param listener
* a WiiUseApiListener
*/
protected void removeWiiUseApiListener(WiiUseApiListener listener) {
listeners.remove(WiiUseApiListener.class, listener);
}
/**
* Get the list of WiiUseApiListeners.
*
* @return the list of WiiUseApiListeners.
*/
protected WiiUseApiListener[] getWiiUseApiListeners() {
return listeners.getListeners(WiiUseApiListener.class);
}
/**
* Notify WiiUseApiListeners that an event occured.
*
* @param evt
* GenericEvent occured
*/
private void notifyWiiUseApiListener(WiiUseApiEvent evt) {
for (WiiUseApiListener listener : getWiiUseApiListeners()) {
listener.onWiiUseApiEvent(evt);
}
}
/**
* Called by the garbage collector at the end.
*/
protected void finalize() throws Throwable {
shutdown();
}
}

495
java/src/wiiusej/Wiimote.java Normal file
View File

@@ -0,0 +1,495 @@
/**
* 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.wiiusejevents.utils.WiiUseApiListener;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent;
import wiiusej.wiiusejevents.wiiuseapievents.WiimoteEvent;
/**
* 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;
}
/**
* Get the unique id of the wiimote.
*
* @return the id
*/
public int getId() {
return id;
}
/**
* 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(minimum angle between two degrees with
* accelerometer).
*
* @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);
}
/**
* Set the nunchuk orientation threshold for the given id. (minimum angle
* between two events)
*
* @param th
* threshold in degrees.
*/
public void setNunchukOrientationThreshold(float th) {
manager.setNunchukOrientationThreshold(id, th);
}
/**
* Set the nunchuk acceleration threshold for the given id. (minimum angle
* between two events)
*
* @param th
* threshold.
*/
public void setNunchukAccelerationThreshold(int th) {
manager.setNunchukAccelerationThreshold(id, th);
}
/**
* 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);
}
/**
* Set the normal and expansion handshake timeouts for this wiimote. Normal
* time out is for classic polling. The expansion timeout is used when an
* expansion is detected until the expansion successfully handshakes.
*
* @param normalTimeout
* The timeout in milliseconds for a normal read.
* @param expansionTimeout
* The timeout in millisecondsd to wait for an expansion
* handshake.
*/
public void setTimeout(short normalTimeout, short expansionTimeout) {
manager.setTimeout(id, normalTimeout, expansionTimeout);
}
/**
* Set the IR sensitivity.
*
* @param level
* 1-5, same as Wii system sensitivity setting. If the level is <
* 1, then level will be set to 1. If the level is > 5, then
* level will be set to 5.
*/
public void setIrSensitivity(int level) {
manager.setIrSensitivity(id, level);
}
/**
* 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((WiimoteEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.STATUS_EVENT) {
notifyStatusEventListeners((StatusEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.DISCONNECTION_EVENT) {
notifyDisconnectionEventListeners((DisconnectionEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.WIIUSE_NUNCHUK_INSERTED) {
notifyNunchukInsertedEventListeners((NunchukInsertedEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.WIIUSE_NUNCHUK_REMOVED) {
notifyNunchukRemovedEventListeners((NunchukRemovedEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_INSERTED) {
notifyGuitarHeroInsertedEventListeners((GuitarHeroInsertedEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.WIIUSE_GUITAR_HERO_3_CTRL_REMOVED) {
notifyGuitarHeroRemovedEventListeners((GuitarHeroRemovedEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_INSERTED) {
notifyClassicControllerInsertedEventListeners((ClassicControllerInsertedEvent) e);
} else if (e.getEventType() == WiiUseApiEvent.WIIUSE_CLASSIC_CTRL_REMOVED) {
notifyClassicControllerRemovedEventListeners((ClassicControllerRemovedEvent) e);
}
/*
* events not managed yet || e.getEventType() == WIIUSE_READ_DATA
* 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
*/
}
}
/**
* 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
* GenericEvent occured
*/
private void notifyWiiMoteEventListeners(WiimoteEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onButtonsEvent(evt.getButtonsEvent());
if (evt.isThereIrEvent()) {
listener.onIrEvent(evt.getIREvent());
}
if (evt.isThereMotionSensingEvent()) {
listener.onMotionSensingEvent(evt.getMotionSensingEvent());
}
if (evt.isThereExpansionEvent()) {
listener.onExpansionEvent(evt.getExpansionEvent());
}
}
}
/**
* 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 disconnection event occured.
*
* @param evt
* disconnection event occured
*/
private void notifyDisconnectionEventListeners(DisconnectionEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onDisconnectionEvent(evt);
}
}
/**
* Notify WiimoteListener that a NunchukInserted Event occured.
*
* @param evt
* NunchukInserted Event occured
*/
private void notifyNunchukInsertedEventListeners(NunchukInsertedEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onNunchukInsertedEvent(evt);
}
}
/**
* Notify WiimoteListener that a NunchukRemoved Event occured.
*
* @param evt
* NunchukRemoved Event occured
*/
private void notifyNunchukRemovedEventListeners(NunchukRemovedEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onNunchukRemovedEvent(evt);
}
}
/**
* Notify WiimoteListener that a GuitarHeroInserted Event occured.
*
* @param evt
* GuitarHeroInserted Event occured
*/
private void notifyGuitarHeroInsertedEventListeners(GuitarHeroInsertedEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onGuitarHeroInsertedEvent(evt);
}
}
/**
* Notify WiimoteListener that a GuitarHeroRemoved Event occured.
*
* @param evt
* GuitarHeroRemoved Event occured
*/
private void notifyGuitarHeroRemovedEventListeners(GuitarHeroRemovedEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onGuitarHeroRemovedEvent(evt);
}
}
/**
* Notify WiimoteListener that a ClassicControllerInserted Event occured.
*
* @param evt
* ClassicControllerInserted Event occured
*/
private void notifyClassicControllerInsertedEventListeners(ClassicControllerInsertedEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onClassicControllerInsertedEvent(evt);
}
}
/**
* Notify WiimoteListener that a ClassicControllerRemoved Event occured.
*
* @param evt
* ClassicControllerRemoved Event occured
*/
private void notifyClassicControllerRemovedEventListeners(ClassicControllerRemovedEvent evt) {
for (WiimoteListener listener : getWiiMoteEventListeners()) {
listener.onClassicControllerRemovedEvent(evt);
}
}
@Override
public String toString() {
return "Wiimote with ID : " + id;
}
}

179
java/src/wiiusej/test/ClassicControllerGuiTest.java Normal file
View File

@@ -0,0 +1,179 @@
/**
* 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;
import wiiusej.utils.ClassicControllerButtonsEventPanel;
import wiiusej.wiiusejevents.physicalevents.ClassicControllerEvent;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This frame is used to display events from a classic controller.
*
* @author guiguito
*/
public class ClassicControllerGuiTest extends javax.swing.JFrame implements WiimoteListener {
private Wiimote wiimote;
private static int MAX_SHOULDER = 100;
/** Creates new form ClassicControllerGuiTest */
public ClassicControllerGuiTest(Wiimote wiimote) {
initComponents();
this.wiimote = wiimote;
registerListeners();
leftShoulderBar.setMaximum(MAX_SHOULDER);
rightShoulderBar.setMaximum(MAX_SHOULDER);
}
private void registerListeners() {
wiimote.addWiiMoteEventListeners(this);
wiimote.addWiiMoteEventListeners((ClassicControllerButtonsEventPanel) classicControllerPanel);
}
public void unRegisterListeners() {
wiimote.removeWiiMoteEventListeners(this);
wiimote.removeWiiMoteEventListeners((ClassicControllerButtonsEventPanel) classicControllerPanel);
}
/** 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() {
shouldersPanel = new javax.swing.JPanel();
leftShoulderBar = new javax.swing.JProgressBar();
rightShoulderBar = new javax.swing.JProgressBar();
classicControllerPanel = new wiiusej.utils.ClassicControllerButtonsEventPanel();
setTitle("WiiuseJ Classic Controller Test GUI");
setResizable(false);
getContentPane().setLayout(new javax.swing.BoxLayout(getContentPane(), javax.swing.BoxLayout.Y_AXIS));
shouldersPanel.setMaximumSize(new java.awt.Dimension(350, 16));
shouldersPanel.setMinimumSize(new java.awt.Dimension(350, 16));
shouldersPanel.setPreferredSize(new java.awt.Dimension(350, 16));
shouldersPanel.setLayout(new javax.swing.BoxLayout(shouldersPanel, javax.swing.BoxLayout.LINE_AXIS));
shouldersPanel.add(leftShoulderBar);
shouldersPanel.add(rightShoulderBar);
getContentPane().add(shouldersPanel);
classicControllerPanel.setMaximumSize(new java.awt.Dimension(350, 182));
classicControllerPanel.setMinimumSize(new java.awt.Dimension(350, 182));
javax.swing.GroupLayout classicControllerPanelLayout = new javax.swing.GroupLayout(classicControllerPanel);
classicControllerPanel.setLayout(classicControllerPanelLayout);
classicControllerPanelLayout.setHorizontalGroup(
classicControllerPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 350, Short.MAX_VALUE)
);
classicControllerPanelLayout.setVerticalGroup(
classicControllerPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 182, Short.MAX_VALUE)
);
getContentPane().add(classicControllerPanel);
pack();
}// </editor-fold>//GEN-END:initComponents
public void onButtonsEvent(WiimoteButtonsEvent arg0) {
// nothing to do
}
public void onIrEvent(IREvent arg0) {
// nothing to do
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
// nothing to do
}
public void onExpansionEvent(ExpansionEvent arg0) {
if (arg0 instanceof ClassicControllerEvent) {
ClassicControllerEvent classicController = (ClassicControllerEvent) arg0;
float leftShoulder = classicController.getLeftShoulder();
float rightShoulder = classicController.getRightShoulder();
leftShoulderBar.setValue(Math.round(leftShoulder * MAX_SHOULDER));
rightShoulderBar.setValue(Math.round(rightShoulder * MAX_SHOULDER));
}
}
public void onStatusEvent(StatusEvent arg0) {
// nothing to do
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
// nothing to do
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
// nothing to do
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
// nothing to do
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing to do
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing to do
}
public void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent arg0) {
// nothing to do
}
public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent arg0) {
// nothing to do
}
public static void main(String[] args) {
Wiimote[] wiimotes = WiiUseApiManager.getWiimotes(1, true);
ClassicControllerGuiTest gui = null;
if (wiimotes.length > 0) {
gui = new ClassicControllerGuiTest(wiimotes[0]);
}
gui.setDefaultCloseOperation(WiiuseJGuiTest.EXIT_ON_CLOSE);
gui.setVisible(true);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JPanel classicControllerPanel;
private javax.swing.JProgressBar leftShoulderBar;
private javax.swing.JProgressBar rightShoulderBar;
private javax.swing.JPanel shouldersPanel;
// End of variables declaration//GEN-END:variables
}

58
java/src/wiiusej/test/CloseGuiTestCleanly.java Normal file
View File

@@ -0,0 +1,58 @@
/**
* 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;
/**
* This class is used to close wiiusej cleanly.
*
* @author guiguito
*/
public class CloseGuiTestCleanly implements WindowListener {
public void windowOpened(WindowEvent e) {
// nothing
}
public void windowClosing(WindowEvent e) {
WiiUseApiManager.definitiveShutdown();
}
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
}
}

168
java/src/wiiusej/test/GuitarHero3GuiTest.java Normal file
View File

@@ -0,0 +1,168 @@
/*
* GuitarHeroGUITest.java
*
* Created on 12 juin 2008, 23:10
*/
package wiiusej.test;
import wiiusej.Wiimote;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.GuitarHeroEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This frame is used to display events from a Guitar Hero 3.
* @author guiguito
*/
public class GuitarHero3GuiTest extends javax.swing.JFrame implements WiimoteListener {
private Wiimote wiimote;
private static int MAX_WHAMMY_BAR = 100;
/** Creates new form GuitarHeroGUITest */
public GuitarHero3GuiTest(Wiimote wiimote) {
initComponents();
this.wiimote = wiimote;
whammyProgressBar.setMaximum(MAX_WHAMMY_BAR);
registerListeners();
}
private void registerListeners() {
wiimote.addWiiMoteEventListeners(this);
//register panel buttons
wiimote.addWiiMoteEventListeners(guitarHero3ButtonsEventPanel);
//register joystick panel
wiimote.addWiiMoteEventListeners(guitarHero3JoystickPanel);
}
public void unRegisterListeners() {
wiimote.removeWiiMoteEventListeners(this);
wiimote.removeWiiMoteEventListeners(guitarHero3ButtonsEventPanel);
wiimote.removeWiiMoteEventListeners(guitarHero3JoystickPanel);
}
/** 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() {
buttonsEventPanel = new javax.swing.JPanel();
guitarHero3ButtonsEventPanel = new wiiusej.utils.GuitarHero3ButtonsEventPanel();
bottomPanel = new javax.swing.JPanel();
guitarHero3JoystickPanel = new wiiusej.utils.GuitarHeroJoystickEventPanel();
whammyProgressBar = new javax.swing.JProgressBar();
setTitle("WiiuseJ Guitar Hero 3 Test GUI");
getContentPane().setLayout(new javax.swing.BoxLayout(getContentPane(), javax.swing.BoxLayout.Y_AXIS));
buttonsEventPanel.setBackground(new java.awt.Color(0, 0, 0));
javax.swing.GroupLayout buttonsEventPanelLayout = new javax.swing.GroupLayout(buttonsEventPanel);
buttonsEventPanel.setLayout(buttonsEventPanelLayout);
buttonsEventPanelLayout.setHorizontalGroup(
buttonsEventPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 526, Short.MAX_VALUE)
.addGroup(buttonsEventPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(buttonsEventPanelLayout.createSequentialGroup()
.addGap(0, 0, Short.MAX_VALUE)
.addComponent(guitarHero3ButtonsEventPanel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(0, 0, Short.MAX_VALUE)))
);
buttonsEventPanelLayout.setVerticalGroup(
buttonsEventPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 96, Short.MAX_VALUE)
.addGroup(buttonsEventPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(buttonsEventPanelLayout.createSequentialGroup()
.addGap(0, 0, Short.MAX_VALUE)
.addComponent(guitarHero3ButtonsEventPanel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(0, 0, Short.MAX_VALUE)))
);
getContentPane().add(buttonsEventPanel);
bottomPanel.setBackground(new java.awt.Color(0, 0, 0));
bottomPanel.setLayout(new javax.swing.BoxLayout(bottomPanel, javax.swing.BoxLayout.X_AXIS));
bottomPanel.add(guitarHero3JoystickPanel);
whammyProgressBar.setBackground(new java.awt.Color(255, 255, 255));
whammyProgressBar.setForeground(new java.awt.Color(255, 0, 255));
bottomPanel.add(whammyProgressBar);
getContentPane().add(bottomPanel);
pack();
}// </editor-fold>//GEN-END:initComponents
public void onButtonsEvent(WiimoteButtonsEvent arg0) {
// nothing to do
}
public void onIrEvent(IREvent arg0) {
// nothing to do
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
// nothing to do
}
public void onExpansionEvent(ExpansionEvent arg0) {
if (arg0 instanceof GuitarHeroEvent) {
GuitarHeroEvent guitar = (GuitarHeroEvent) arg0;
//move progress bar for whammy bar
whammyProgressBar.setValue(Math.round(MAX_WHAMMY_BAR*guitar.getWhammyBar()));
}
}
public void onStatusEvent(StatusEvent arg0) {
// nothing to do
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
// nothing to do
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
// nothing to do
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
// nothing to do
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing to do
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing to do
}
public void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent arg0) {
// nothing to do
}
public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent arg0) {
// nothing to do
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JPanel bottomPanel;
private javax.swing.JPanel buttonsEventPanel;
private wiiusej.utils.GuitarHero3ButtonsEventPanel guitarHero3ButtonsEventPanel;
private wiiusej.utils.GuitarHeroJoystickEventPanel guitarHero3JoystickPanel;
private javax.swing.JProgressBar whammyProgressBar;
// End of variables declaration//GEN-END:variables
}

45
java/src/wiiusej/test/Main.java Normal file
View File

@@ -0,0 +1,45 @@
/**
* 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, true);
WiiuseJGuiTest gui = null;
if (wiimotes.length > 0) {
gui = new WiiuseJGuiTest(wiimotes[0]);
} else {
gui = new WiiuseJGuiTest();
}
gui.setDefaultCloseOperation(WiiuseJGuiTest.EXIT_ON_CLOSE);
gui.setVisible(true);
}
}

450
java/src/wiiusej/test/NunchukGuiTest.java Normal file
View File

@@ -0,0 +1,450 @@
/**
* 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.Wiimote;
import wiiusej.utils.AccelerationExpansionEventPanel;
import wiiusej.utils.AccelerationPanel;
import wiiusej.utils.GForceExpansionEventPanel;
import wiiusej.utils.GForcePanel;
import wiiusej.utils.NunchukJoystickEventPanel;
import wiiusej.utils.OrientationExpansionEventPanel;
import wiiusej.utils.OrientationPanel;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.NunchukButtonsEvent;
import wiiusej.wiiusejevents.physicalevents.NunchukEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This frame is used to display events from a nunchuk.
*
* @author guiguito
*/
public class NunchukGuiTest extends javax.swing.JFrame implements
WiimoteListener {
private Wiimote wiimote;
private boolean isThresholdsRequested = true;
/** Creates new form NunchukGuiTest */
public NunchukGuiTest(Wiimote wiimote) {
initComponents();
this.wiimote = wiimote;
registerListeners();
}
private void registerListeners() {
wiimote.addWiiMoteEventListeners(this);
wiimote.addWiiMoteEventListeners((OrientationPanel) orientationPanel);
wiimote.addWiiMoteEventListeners((GForcePanel) gForcePanel);
wiimote
.addWiiMoteEventListeners((AccelerationPanel) rawAccelerationPanel);
wiimote
.addWiiMoteEventListeners((NunchukJoystickEventPanel) joystickEventsPanel);
}
public void unRegisterListeners() {
wiimote
.removeWiiMoteEventListeners((OrientationPanel) orientationPanel);
wiimote.removeWiiMoteEventListeners((GForcePanel) gForcePanel);
wiimote
.removeWiiMoteEventListeners((AccelerationPanel) rawAccelerationPanel);
wiimote
.removeWiiMoteEventListeners((NunchukJoystickEventPanel) joystickEventsPanel);
wiimote.removeWiiMoteEventListeners(this);
}
public void requestThresholdsUpdate() {
isThresholdsRequested = true;
}
/**
* 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
// <editor-fold defaultstate="collapsed" desc="Generated
// Code">//GEN-BEGIN:initComponents
private void initComponents() {
topPanels = new javax.swing.JPanel();
joystickEventsPanel = new NunchukJoystickEventPanel();
motionSensingEventsPanel = new javax.swing.JPanel();
motionSensingEventsTabbedPanels = new javax.swing.JTabbedPane();
rawAccelerationPanel = new AccelerationExpansionEventPanel();
orientationPanel = new OrientationExpansionEventPanel();
gForcePanel = new GForceExpansionEventPanel();
setNunchukValuesPanel = new javax.swing.JPanel();
nunchukButtonsEventPanel = new javax.swing.JPanel();
cButton = new javax.swing.JButton();
zButton = new javax.swing.JButton();
nunchukOrientationPanel = new javax.swing.JPanel();
nunchukOrientationTextField = new javax.swing.JTextField();
nunchukOrientationButton = new javax.swing.JButton();
nunchukAccelerationPanel = new javax.swing.JPanel();
nunchukAccelerationTextField = new javax.swing.JTextField();
nunchukAccelerationButton = new javax.swing.JButton();
messagePanel = new javax.swing.JPanel();
messageText = new javax.swing.JLabel();
setTitle("WiiuseJ Nunchuk Test GUI");
setMinimumSize(new java.awt.Dimension(400, 400));
getContentPane().setLayout(
new javax.swing.BoxLayout(getContentPane(),
javax.swing.BoxLayout.Y_AXIS));
topPanels.setMinimumSize(new java.awt.Dimension(400, 200));
topPanels.setPreferredSize(new java.awt.Dimension(400, 200));
topPanels.setLayout(new javax.swing.BoxLayout(topPanels,
javax.swing.BoxLayout.LINE_AXIS));
joystickEventsPanel.setBackground(new java.awt.Color(0, 0, 0));
joystickEventsPanel.setBorder(javax.swing.BorderFactory
.createTitledBorder(new javax.swing.border.LineBorder(
new java.awt.Color(51, 153, 0), 2, true),
"Joystick View",
javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION,
javax.swing.border.TitledBorder.DEFAULT_POSITION,
new java.awt.Font("Tahoma", 0, 11), new java.awt.Color(
204, 102, 0)));
joystickEventsPanel.setToolTipText("JoystickEvent");
joystickEventsPanel.setMinimumSize(new java.awt.Dimension(200, 200));
javax.swing.GroupLayout joystickEventsPanelLayout = new javax.swing.GroupLayout(
joystickEventsPanel);
joystickEventsPanel.setLayout(joystickEventsPanelLayout);
joystickEventsPanelLayout.setHorizontalGroup(joystickEventsPanelLayout
.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 601, Short.MAX_VALUE));
joystickEventsPanelLayout.setVerticalGroup(joystickEventsPanelLayout
.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 174, Short.MAX_VALUE));
topPanels.add(joystickEventsPanel);
joystickEventsPanel.getAccessibleContext()
.setAccessibleName("Joystick");
motionSensingEventsPanel
.setMinimumSize(new java.awt.Dimension(200, 200));
rawAccelerationPanel.setToolTipText("Nunchuk MotionSensingEvent");
javax.swing.GroupLayout rawAccelerationPanelLayout = new javax.swing.GroupLayout(
rawAccelerationPanel);
rawAccelerationPanel.setLayout(rawAccelerationPanelLayout);
rawAccelerationPanelLayout
.setHorizontalGroup(rawAccelerationPanelLayout
.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 597, Short.MAX_VALUE));
rawAccelerationPanelLayout.setVerticalGroup(rawAccelerationPanelLayout
.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 175, Short.MAX_VALUE));
motionSensingEventsTabbedPanels.addTab("RawAcceleration",
rawAccelerationPanel);
javax.swing.GroupLayout orientationPanelLayout = new javax.swing.GroupLayout(
orientationPanel);
orientationPanel.setLayout(orientationPanelLayout);
orientationPanelLayout.setHorizontalGroup(orientationPanelLayout
.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 597, Short.MAX_VALUE));
orientationPanelLayout.setVerticalGroup(orientationPanelLayout
.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 175, Short.MAX_VALUE));
motionSensingEventsTabbedPanels.addTab("Orientation", orientationPanel);
javax.swing.GroupLayout gForcePanelLayout = new javax.swing.GroupLayout(
gForcePanel);
gForcePanel.setLayout(gForcePanelLayout);
gForcePanelLayout.setHorizontalGroup(gForcePanelLayout
.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 597, Short.MAX_VALUE));
gForcePanelLayout.setVerticalGroup(gForcePanelLayout
.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 175, Short.MAX_VALUE));
motionSensingEventsTabbedPanels.addTab("GForce", gForcePanel);
javax.swing.GroupLayout motionSensingEventsPanelLayout = new javax.swing.GroupLayout(
motionSensingEventsPanel);
motionSensingEventsPanel.setLayout(motionSensingEventsPanelLayout);
motionSensingEventsPanelLayout
.setHorizontalGroup(motionSensingEventsPanelLayout
.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(motionSensingEventsTabbedPanels,
javax.swing.GroupLayout.DEFAULT_SIZE, 602,
Short.MAX_VALUE));
motionSensingEventsPanelLayout
.setVerticalGroup(motionSensingEventsPanelLayout
.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(motionSensingEventsTabbedPanels,
javax.swing.GroupLayout.DEFAULT_SIZE, 200,
Short.MAX_VALUE));
topPanels.add(motionSensingEventsPanel);
getContentPane().add(topPanels);
setNunchukValuesPanel.setMinimumSize(new java.awt.Dimension(400, 200));
setNunchukValuesPanel
.setPreferredSize(new java.awt.Dimension(400, 200));
setNunchukValuesPanel.setLayout(new javax.swing.BoxLayout(
setNunchukValuesPanel, javax.swing.BoxLayout.Y_AXIS));
nunchukButtonsEventPanel.setToolTipText("Nunchuk ButtonsEvent");
nunchukButtonsEventPanel
.setMinimumSize(new java.awt.Dimension(100, 100));
nunchukButtonsEventPanel.setPreferredSize(new java.awt.Dimension(100,
100));
nunchukButtonsEventPanel.setLayout(new javax.swing.BoxLayout(
nunchukButtonsEventPanel, javax.swing.BoxLayout.LINE_AXIS));
cButton.setText("C");
cButton.setMaximumSize(new java.awt.Dimension(50, 50));
cButton.setMinimumSize(new java.awt.Dimension(50, 50));
cButton.setPreferredSize(new java.awt.Dimension(50, 50));
nunchukButtonsEventPanel.add(cButton);
zButton.setText("Z");
zButton.setMaximumSize(new java.awt.Dimension(50, 50));
zButton.setMinimumSize(new java.awt.Dimension(50, 50));
zButton.setPreferredSize(new java.awt.Dimension(50, 50));
nunchukButtonsEventPanel.add(zButton);
setNunchukValuesPanel.add(nunchukButtonsEventPanel);
nunchukOrientationTextField.setPreferredSize(new java.awt.Dimension(60,
20));
nunchukOrientationPanel.add(nunchukOrientationTextField);
nunchukOrientationButton.setText("Set Orientation Threshold");
nunchukOrientationButton
.addMouseListener(new java.awt.event.MouseAdapter() {
public void mousePressed(java.awt.event.MouseEvent evt) {
nunchukOrientationButtonMousePressed(evt);
}
});
nunchukOrientationPanel.add(nunchukOrientationButton);
setNunchukValuesPanel.add(nunchukOrientationPanel);
nunchukAccelerationTextField.setPreferredSize(new java.awt.Dimension(
60, 20));
nunchukAccelerationPanel.add(nunchukAccelerationTextField);
nunchukAccelerationButton.setText("Set Acceleration Threshold");
nunchukAccelerationButton
.addMouseListener(new java.awt.event.MouseAdapter() {
public void mousePressed(java.awt.event.MouseEvent evt) {
nunchukAccelerationButtonMousePressed(evt);
}
});
nunchukAccelerationPanel.add(nunchukAccelerationButton);
setNunchukValuesPanel.add(nunchukAccelerationPanel);
messageText.setText("Message:");
javax.swing.GroupLayout messagePanelLayout = new javax.swing.GroupLayout(
messagePanel);
messagePanel.setLayout(messagePanelLayout);
messagePanelLayout
.setHorizontalGroup(messagePanelLayout
.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 1216, Short.MAX_VALUE)
.addGroup(
messagePanelLayout
.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(
messagePanelLayout
.createSequentialGroup()
.addGap(0, 0,
Short.MAX_VALUE)
.addComponent(
messageText)
.addGap(0, 0,
Short.MAX_VALUE))));
messagePanelLayout
.setVerticalGroup(messagePanelLayout
.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 34, Short.MAX_VALUE)
.addGroup(
messagePanelLayout
.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(
messagePanelLayout
.createSequentialGroup()
.addGap(0, 0,
Short.MAX_VALUE)
.addComponent(
messageText)
.addGap(0, 0,
Short.MAX_VALUE))));
setNunchukValuesPanel.add(messagePanel);
getContentPane().add(setNunchukValuesPanel);
pack();
}// </editor-fold>//GEN-END:initComponents
private void nunchukOrientationButtonMousePressed(
java.awt.event.MouseEvent evt) {// GEN-FIRST:event_nunchukOrientationButtonMousePressed
try {
float nb = Float.parseFloat(nunchukOrientationTextField.getText());
wiimote.setNunchukOrientationThreshold(nb);
messageText.setText("Nunchuk orientation threshold set to " + nb);
} catch (NumberFormatException e) {
messageText
.setText("Number is not an integer, nunchuk orientation threshold not set !");
}
}// GEN-LAST:event_nunchukOrientationButtonMousePressed
private void nunchukAccelerationButtonMousePressed(
java.awt.event.MouseEvent evt) {// GEN-FIRST:event_nunchukAccelerationButtonMousePressed
try {
int nb = Integer.parseInt(nunchukAccelerationTextField.getText());
wiimote.setNunchukAccelerationThreshold(nb);
messageText.setText("Nunchuk acceleration threshold set to " + nb);
} catch (NumberFormatException e) {
messageText
.setText("Number is not an integer, nunchuk acceleration threshold not set !");
}
}// GEN-LAST:event_nunchukAccelerationButtonMousePressed
public void onButtonsEvent(WiimoteButtonsEvent arg0) {
// nothing to do
}
public void onIrEvent(IREvent arg0) {
// nothing to do
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
// nothing to do
}
public void onExpansionEvent(ExpansionEvent arg0) {
if (arg0 instanceof NunchukEvent) {
NunchukEvent nunchuk = (NunchukEvent) arg0;
NunchukButtonsEvent buttons = nunchuk.getButtonsEvent();
//C button
if (buttons.isButtonCJustPressed()) {
cButton.setEnabled(false);
}else if (buttons.isButtonCJustReleased()) {
cButton.setEnabled(true);
}
//Z button
if(buttons.isButtonZJustPressed()) {
zButton.setEnabled(false);
}else if (buttons.isButtonZJustReleased()) {
zButton.setEnabled(true);
}
if (isThresholdsRequested) {
MotionSensingEvent evt = nunchuk.getNunchukMotionSensingEvent();
nunchukAccelerationTextField.setText(evt
.getAccelerationThreshold()
+ "");
nunchukOrientationTextField.setText(evt
.getOrientationThreshold()
+ "");
isThresholdsRequested = false;
}
}
}
public void onStatusEvent(StatusEvent arg0) {
// nothing to do
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
// nothing
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
// nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
// nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent arg0) {
// nothing
}
public void onClassicControllerRemovedEvent(
ClassicControllerRemovedEvent arg0) {
// nothing
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton cButton;
private javax.swing.JPanel gForcePanel;
private javax.swing.JPanel joystickEventsPanel;
private javax.swing.JPanel messagePanel;
private javax.swing.JLabel messageText;
private javax.swing.JPanel motionSensingEventsPanel;
private javax.swing.JTabbedPane motionSensingEventsTabbedPanels;
private javax.swing.JButton nunchukAccelerationButton;
private javax.swing.JPanel nunchukAccelerationPanel;
private javax.swing.JTextField nunchukAccelerationTextField;
private javax.swing.JPanel nunchukButtonsEventPanel;
private javax.swing.JButton nunchukOrientationButton;
private javax.swing.JPanel nunchukOrientationPanel;
private javax.swing.JTextField nunchukOrientationTextField;
private javax.swing.JPanel orientationPanel;
private javax.swing.JPanel rawAccelerationPanel;
private javax.swing.JPanel setNunchukValuesPanel;
private javax.swing.JPanel topPanels;
private javax.swing.JButton zButton;
// End of variables declaration//GEN-END:variables
}

389
java/src/wiiusej/test/Tests.java Normal file
View File

@@ -0,0 +1,389 @@
/**
* 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.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This class used to test WiiuseJ in text mode.
*
* @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();
}
}
public void onButtonsEvent(WiimoteButtonsEvent 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();
WiiUseApiManager.definitiveShutdown();
}
} 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 onExpansionEvent(ExpansionEvent e) {
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 !!");
}
public void onNunchukInsertedEvent(NunchukInsertedEvent e) {
System.out.println(e);
}
public void onNunchukRemovedEvent(NunchukRemovedEvent e) {
System.out.println(e);
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent e) {
System.out.println(e);
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent e) {
System.out.println(e);
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent e) {
System.out.println(e);
}
public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent e) {
System.out.println(e);
}
/**
* @param args
*/
public static void main(String[] args) {
Wiimote[] wiimotes = WiiUseApiManager.getWiimotes(1, true);
if (wiimotes.length > 0) {
System.out.println(wiimotes[0]);
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);
}
}

1379
java/src/wiiusej/test/WiiuseJGuiTest.java Normal file
View File

File diff suppressed because it is too large Load Diff

39
java/src/wiiusej/utils/AccelerationExpansionEventPanel.java Normal file
View File

@@ -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.utils;
import wiiusej.values.RawAcceleration;
import wiiusej.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.NunchukEvent;
/**
* Panel to display Acceleration in a MotionSensingEvent from an expansion.
*
* @author guiguito
*/
public class AccelerationExpansionEventPanel extends AccelerationPanel {
@Override
public RawAcceleration getRawAccelerationValue(GenericEvent e) {
if (e instanceof NunchukEvent) {
return ((NunchukEvent) e).getNunchukMotionSensingEvent()
.getRawAcceleration();
}
return null;
}
}

303
java/src/wiiusej/utils/AccelerationPanel.java Normal file
View File

@@ -0,0 +1,303 @@
/**
* 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.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This panel is used to watch raw acceleration values from a
* MotionSensingEvent.
*
* @author guiguito
*/
public abstract 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();
}
/**
* Constructor used to choose the colors used by the AccelerationPanel.
*
* @param bgColor
* background color.
* @param xColor
* x color.
* @param yColor
* y color.
* @param zColor
* z color.
* @param lColor
* line color.
*/
public AccelerationPanel(Color bgColor, Color xColor, Color yColor,
Color zColor, Color lColor) {
backgroundColor = bgColor;
this.xColor = xColor;
this.yColor = yColor;
this.zColor = zColor;
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
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(WiimoteButtonsEvent arg0) {
// nothing
}
public void onIrEvent(IREvent arg0) {
// nothing
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
draw(arg0);
}
public void onExpansionEvent(ExpansionEvent arg0) {
draw(arg0);
}
public void onStatusEvent(StatusEvent arg0) {
// nothing
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
// Clear points.
values.clear();
repaint();
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
// nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
// nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent arg0) {
// nothing
}
public void onClassicControllerRemovedEvent(
ClassicControllerRemovedEvent arg0) {
// nothing
}
private void draw(GenericEvent arg0) {
if (values.size() >= getWidth()) {
// if there are as many values as pixels in the width
// clear points
values.clear();
}
RawAcceleration rawAcceleration = getRawAccelerationValue(arg0);
if (rawAcceleration != null)
values.add(rawAcceleration);
repaint();
}
public abstract RawAcceleration getRawAccelerationValue(GenericEvent e);
public Color getBackgroundColor() {
return backgroundColor;
}
public Color getLineColor() {
return lineColor;
}
public Color getXColor() {
return xColor;
}
public Color getYColor() {
return yColor;
}
public Color getZColor() {
return zColor;
}
public void setBackgroundColor(Color backgroundColor) {
this.backgroundColor = backgroundColor;
}
public void setLineColor(Color lineColor) {
this.lineColor = lineColor;
}
public void setXColor(Color xColor) {
this.xColor = xColor;
}
public void setYColor(Color yColor) {
this.yColor = yColor;
}
public void setZColor(Color zColor) {
this.zColor = zColor;
}
public void clearView() {
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
}

37
java/src/wiiusej/utils/AccelerationWiimoteEventPanel.java Normal file
View File

@@ -0,0 +1,37 @@
/**
* 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 wiiusej.values.RawAcceleration;
import wiiusej.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
/**
* Panel to display Acceleration in a MotionSensingEvent from a wiimote.
* @author guiguito
*/
public class AccelerationWiimoteEventPanel extends AccelerationPanel {
@Override
public RawAcceleration getRawAccelerationValue(GenericEvent e) {
if (e instanceof MotionSensingEvent) {
return ((MotionSensingEvent) e).getRawAcceleration();
}
return null;
}
}

382
java/src/wiiusej/utils/ButtonsEventPanel.java Normal file
View File

@@ -0,0 +1,382 @@
/**
* 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.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This panel is used to see what buttons are pressed on the wiimote. 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 WiimoteButtonsEvent buttons;
private Color pressedColor = Color.RED;
private Color heldColor = Color.ORANGE;
private Color releasedColor = Color.YELLOW;
private Shape shape = new java.awt.geom.Ellipse2D.Double(0, 0, 13, 13);
/**
* 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);
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");
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(WiimoteButtonsEvent 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 onExpansionEvent(ExpansionEvent e) {
// nothing
}
public void onStatusEvent(StatusEvent arg0) {
// nothing
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
clearView();
}
public void onNunchukInsertedEvent(NunchukInsertedEvent e) {
// nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent e) {
// nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent arg0) {
// nothing
}
public void onClassicControllerRemovedEvent(
ClassicControllerRemovedEvent arg0) {
// nothing
}
public Color getHeldColor() {
return heldColor;
}
public Color getPressedColor() {
return pressedColor;
}
public Color getReleasedColor() {
return releasedColor;
}
public Shape getShape() {
return shape;
}
public void setHeldColor(Color heldColor) {
this.heldColor = heldColor;
}
public void setPressedColor(Color pressedColor) {
this.pressedColor = pressedColor;
}
public void setReleasedColor(Color releasedColor) {
this.releasedColor = releasedColor;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public void clearView() {
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
}

500
java/src/wiiusej/utils/ClassicControllerButtonsEventPanel.java Normal file
View File

@@ -0,0 +1,500 @@
/**
* 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.wiiusejevents.physicalevents.ClassicControllerButtonsEvent;
import wiiusej.wiiusejevents.physicalevents.ClassicControllerEvent;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.JoystickEvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This panel is used to display what happens on the classic controller.
*
* @author guiguito
*/
public class ClassicControllerButtonsEventPanel extends javax.swing.JPanel implements WiimoteListener {
private Image mImage;// image for double buffering
private Image wiimoteImage;// image for double buffering
private ClassicControllerEvent event;
private Color pressedColor = Color.RED;
private Color heldColor = Color.ORANGE;
private Color releasedColor = Color.YELLOW;
private Color joystickColor = Color.PINK;
private Color shoulderColor = Color.BLUE;
private Shape shapeJoystick = new java.awt.geom.Ellipse2D.Double(0, 0, 15, 15);
private Shape shapeButton = new java.awt.geom.Ellipse2D.Double(0, 0, 20, 20);
private static int xAmplitude = 20;
private static int yAmplitude = 20;
/**
* Default constructor. Red : button just pressed. Orange : button held.
* Yellow : button just released.
*/
public ClassicControllerButtonsEventPanel() {
Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();
java.net.URL url = ButtonsEventPanel.class.getResource("/img/classiccontroller.png");
wiimoteImage = toolkit.createImage(url);
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 jsColor
* color of the joysticks.
* @param shouldColor
* color of the shoulders.
* @param js
* shape drawn on the joysticks.
* @param sh
* shape drawn on the buttons.
*/
public ClassicControllerButtonsEventPanel(Color pressColor, Color hColor, Color relColor,
Color jsColor, Color shouldColor, Shape js, Shape sh) {
pressedColor = pressColor;
heldColor = hColor;
releasedColor = relColor;
shapeButton = sh;
shapeJoystick = js;
joystickColor = jsColor;
shoulderColor = shouldColor;
Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();
wiimoteImage = toolkit.createImage("img\\wiimote.png");
initComponents();
}
/** 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
@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 classic controller
g2.drawImage(wiimoteImage, 0, 0, this);
g2.setTransform(new AffineTransform());
if (event != null) {
// draw buttons pushed
ClassicControllerButtonsEvent buttons = event.getButtonsEvent();
/* button A */
if (buttons.isButtonAJustPressed()) {
drawFunction(g2, pressedColor, 304, 76, shapeButton);
}
if (buttons.isButtonAHeld()) {
drawFunction(g2, heldColor, 304, 76, shapeButton);
}
if (buttons.isButtonAJustReleased()) {
drawFunction(g2, releasedColor, 304, 76, shapeButton);
}
/* button B */
if (buttons.isButtonBJustPressed()) {
drawFunction(g2, pressedColor, 269, 98, shapeButton);
}
if (buttons.isButtonBHeld()) {
drawFunction(g2, heldColor, 269, 98, shapeButton);
}
if (buttons.isButtonBJustReleased()) {
drawFunction(g2, releasedColor, 269, 98, shapeButton);
}
/* button Down */
if (buttons.isButtonDownJustPressed()) {
drawFunction(g2, pressedColor, 60, 97, shapeButton);
}
if (buttons.isButtonDownHeld()) {
drawFunction(g2, heldColor, 60, 97, shapeButton);
}
if (buttons.isButtonDownJustReleased()) {
drawFunction(g2, releasedColor, 60, 97, shapeButton);
}
/* button FullLeft */
if (buttons.isButtonFullLeftJustPressed()) {
drawFunction(g2, pressedColor, 55, 4, shapeButton);
}
if (buttons.isButtonFullLeftHeld()) {
drawFunction(g2, heldColor, 55, 4, shapeButton);
}
if (buttons.isButtonFullLeftJustReleased()) {
drawFunction(g2, releasedColor, 55, 4, shapeButton);
}
/* button FullRight */
if (buttons.isButtonFullRightJustPressed()) {
drawFunction(g2, pressedColor, 276, 4, shapeButton);
}
if (buttons.isButtonFullRightHeld()) {
drawFunction(g2, heldColor, 276, 4, shapeButton);
}
if (buttons.isButtonFullRightJustReleased()) {
drawFunction(g2, releasedColor, 276, 4, shapeButton);
}
/* button Home */
if (buttons.isButtonHomeJustPressed()) {
drawFunction(g2, pressedColor, 166, 76, shapeButton);
}
if (buttons.isButtonHomeHeld()) {
drawFunction(g2, heldColor, 166, 76, shapeButton);
}
if (buttons.isButtonHomeJustReleased()) {
drawFunction(g2, releasedColor, 166, 76, shapeButton);
}
/* button Left */
if (buttons.isButtonLeftJustPressed()) {
drawFunction(g2, pressedColor, 34, 75, shapeButton);
}
if (buttons.isButtonLeftHeld()) {
drawFunction(g2, heldColor, 34, 75, shapeButton);
}
if (buttons.isButtonLeftJustReleased()) {
drawFunction(g2, releasedColor, 34, 75, shapeButton);
}
/* button Minus */
if (buttons.isButtonMinusJustPressed()) {
drawFunction(g2, pressedColor, 140, 76, shapeButton);
}
if (buttons.isButtonMinusHeld()) {
drawFunction(g2, heldColor, 140, 76, shapeButton);
}
if (buttons.isButtonMinusJustReleased()) {
drawFunction(g2, releasedColor, 140, 76, shapeButton);
}
/* button Plus */
if (buttons.isButtonPlusJustPressed()) {
drawFunction(g2, pressedColor, 191, 76, shapeButton);
}
if (buttons.isButtonPlusHeld()) {
drawFunction(g2, heldColor, 191, 76, shapeButton);
}
if (buttons.isButtonPlusJustReleased()) {
drawFunction(g2, releasedColor, 191, 76, shapeButton);
}
/* button Right */
if (buttons.isButtonRightJustPressed()) {
drawFunction(g2, pressedColor, 86, 75, shapeButton);
}
if (buttons.isButtonRightHeld()) {
drawFunction(g2, heldColor, 86, 75, shapeButton);
}
if (buttons.isButtonRightJustReleased()) {
drawFunction(g2, releasedColor, 86, 353, shapeButton);
}
/* button Up */
if (buttons.isButtonUpJustPressed()) {
drawFunction(g2, pressedColor, 60, 50, shapeButton);
}
if (buttons.isButtonUpHeld()) {
drawFunction(g2, heldColor, 60, 50, shapeButton);
}
if (buttons.isButtonUpJustReleased()) {
drawFunction(g2, releasedColor, 60, 50, shapeButton);
}
/* button X */
if (buttons.isButtonXJustPressed()) {
drawFunction(g2, pressedColor, 271, 53, shapeButton);
}
if (buttons.isButtonXHeld()) {
drawFunction(g2, heldColor, 271, 53, shapeButton);
}
if (buttons.isButtonXJustReleased()) {
drawFunction(g2, releasedColor, 271, 53, shapeButton);
}
/* button Y */
if (buttons.isButtonYJustPressed()) {
drawFunction(g2, pressedColor, 237, 76, shapeButton);
}
if (buttons.isButtonYHeld()) {
drawFunction(g2, heldColor, 237, 76, shapeButton);
}
if (buttons.isButtonYJustReleased()) {
drawFunction(g2, releasedColor, 237, 76, shapeButton);
}
/* button ZL */
if (buttons.isButtonZLJustPressed()) {
drawFunction(g2, pressedColor, 123, 4, shapeButton);
}
if (buttons.isButtonZLHeld()) {
drawFunction(g2, heldColor, 123, 4, shapeButton);
}
if (buttons.isButtonZLJustReleased()) {
drawFunction(g2, releasedColor, 123, 4, shapeButton);
}
/* button ZR */
if (buttons.isButtonZRJustPressed()) {
drawFunction(g2, pressedColor, 208, 4, shapeButton);
}
if (buttons.isButtonZRHeld()) {
drawFunction(g2, heldColor, 208, 4, shapeButton);
}
if (buttons.isButtonZRJustReleased()) {
drawFunction(g2, releasedColor, 208, 4, shapeButton);
}
//joysticks
int halfWidth = (int) Math.round(shapeJoystick.getBounds().getWidth() / 2);
int halfHeight = (int) Math.round(shapeJoystick.getBounds().getHeight() / 2);
// left joystick
JoystickEvent jl = event.getClassicControllerLeftJoystickEvent();
int xCenter1 = 121;
int yCenter1 = 125;
double xAng1 = Math.sin(jl.getAngle() * Math.PI / 180.0) * jl.getMagnitude();
double yAng1 = Math.cos(jl.getAngle() * Math.PI / 180.0) * jl.getMagnitude();
int xShift1 = (int) Math.round(xAng1 * xAmplitude);
int yShift1 = (int) Math.round(yAng1 * yAmplitude);
int x1 = xCenter1 + xShift1 - halfWidth;
int y1 = yCenter1 - yShift1 - halfHeight;
// draw shape
drawFunction(g2, joystickColor, x1, y1, shapeJoystick);
//Right joystick
JoystickEvent jr = event.getClassicControllerRightJoystickEvent();
int xCenter2 = 213;
int yCenter2 = 125;
double xAng2 = Math.sin(jr.getAngle() * Math.PI / 180.0) * jr.getMagnitude();
double yAng2 = Math.cos(jr.getAngle() * Math.PI / 180.0) * jr.getMagnitude();
int xShift2 = (int) Math.round(xAng2 * xAmplitude);
int yShift2 = (int) Math.round(yAng2 * yAmplitude);
int x2 = xCenter2 + xShift2 - halfWidth;
int y2 = yCenter2 - yShift2 - halfHeight;
// draw shape
drawFunction(g2, joystickColor, x2, y2, shapeJoystick);
event = 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.
* @param sh
* shape to draw.
*/
private void drawFunction(Graphics2D g2, Color col, int x, int y, Shape sh) {
g2.setPaint(col);
g2.translate(x, y);
g2.draw(sh);
g2.fill(sh);
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(WiimoteButtonsEvent arg0) {
//do nothing
}
public void onIrEvent(IREvent arg0) {
//do nothing
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
//do nothing
}
public void onExpansionEvent(ExpansionEvent arg0) {
if (arg0 instanceof ClassicControllerEvent) {
event = (ClassicControllerEvent) arg0;
}
repaint();
}
public void onStatusEvent(StatusEvent arg0) {
//do nothing
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
//do nothing
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
//do nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
//do nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
//do nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
//do nothing
}
public void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent arg0) {
//do nothing
}
public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent arg0) {
clearView();
}
public Color getHeldColor() {
return heldColor;
}
public Color getJoystickColor() {
return joystickColor;
}
public Color getPressedColor() {
return pressedColor;
}
public Color getReleasedColor() {
return releasedColor;
}
public Color getShoulderColor() {
return shoulderColor;
}
public Shape getShapeButton() {
return shapeButton;
}
public Shape getShapeJoystick() {
return shapeJoystick;
}
public void setHeldColor(Color heldColor) {
this.heldColor = heldColor;
}
public void setJoystickColor(Color joystickColor) {
this.joystickColor = joystickColor;
}
public void setPressedColor(Color pressedColor) {
this.pressedColor = pressedColor;
}
public void setReleasedColor(Color releasedColor) {
this.releasedColor = releasedColor;
}
public void setShoulderColor(Color shoulderColor) {
this.shoulderColor = shoulderColor;
}
public void setShapeButton(Shape shapeButton) {
this.shapeButton = shapeButton;
}
public void setShapeJoystick(Shape shapeJoystick) {
this.shapeJoystick = shapeJoystick;
}
public void clearView() {
event = null;
repaint();
}
// Variables declaration - do not modify//GEN-BEGIN:variables
// End of variables declaration//GEN-END:variables
}

38
java/src/wiiusej/utils/GForceExpansionEventPanel.java Normal file
View File

@@ -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/>.
*/
package wiiusej.utils;
import wiiusej.values.GForce;
import wiiusej.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.NunchukEvent;
/**
* Panel to display GForce in a MotionSensingEvent from an expansion.
*
* @author guiguito
*/
public class GForceExpansionEventPanel extends GForcePanel{
@Override
public GForce getGForceValue(GenericEvent e) {
if (e instanceof NunchukEvent){
return ((NunchukEvent)e).getNunchukMotionSensingEvent().getGforce();
}
return null;
}
}

304
java/src/wiiusej/utils/GForcePanel.java Normal file
View File

@@ -0,0 +1,304 @@
/**
* 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.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This panel is used to watch gravity force values from a MotionSensingEvent.
*
* @author guiguito
*/
public abstract 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(WiimoteButtonsEvent arg0) {
// nothing
}
public void onIrEvent(IREvent arg0) {
// nothing
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
draw(arg0);
}
public void onExpansionEvent(ExpansionEvent arg0) {
draw(arg0);
}
public void onStatusEvent(StatusEvent arg0) {
// nothing
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
// Clear points.
values.clear();
repaint();
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
// nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
// nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent arg0) {
// nothing
}
public void onClassicControllerRemovedEvent(
ClassicControllerRemovedEvent arg0) {
// nothing
}
private void draw(GenericEvent arg0) {
if (values.size() >= getWidth()) {
// if there are as many values as pixels in the width
// clear points
values.clear();
}
GForce gforce = getGForceValue(arg0);
if (gforce != null)
values.add(gforce);
repaint();
}
public abstract GForce getGForceValue(GenericEvent e);
public Color getBackgroundColor() {
return backgroundColor;
}
public Color getLineColor() {
return lineColor;
}
public Color getXColor() {
return xColor;
}
public Color getYColor() {
return yColor;
}
public Color getZColor() {
return zColor;
}
public void setBackgroundColor(Color backgroundColor) {
this.backgroundColor = backgroundColor;
}
public void setLineColor(Color lineColor) {
this.lineColor = lineColor;
}
public void setXColor(Color xColor) {
this.xColor = xColor;
}
public void setYColor(Color yColor) {
this.yColor = yColor;
}
public void setZColor(Color zColor) {
this.zColor = zColor;
}
public void clearView() {
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
}

37
java/src/wiiusej/utils/GForceWiimoteEventPanel.java Normal file
View File

@@ -0,0 +1,37 @@
/**
* 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 wiiusej.values.GForce;
import wiiusej.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
/**
* Panel to display GForce in a MotionSensingEvent from a wiimote.
*
* @author guiguito
*/
public class GForceWiimoteEventPanel extends GForcePanel {
@Override
public GForce getGForceValue(GenericEvent e) {
if (e instanceof MotionSensingEvent) {
return ((MotionSensingEvent) e).getGforce();
}
return null;
}
}

274
java/src/wiiusej/utils/GuitarHero3ButtonsEventPanel.java Normal file
View File

@@ -0,0 +1,274 @@
/**
* 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 wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.GuitarHeroButtonsEvent;
import wiiusej.wiiusejevents.physicalevents.GuitarHeroEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This panel is used to display what happens on the buttons of the
* Guitar Hero 3 controller.
* @author guiguito
*/
public class GuitarHero3ButtonsEventPanel extends javax.swing.JPanel implements WiimoteListener {
/** Creates new form GuitarHero3ButtonsEventPanel */
public GuitarHero3ButtonsEventPanel() {
initComponents();
}
/** 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();
plusButton = new javax.swing.JToggleButton();
minusButton = new javax.swing.JToggleButton();
strumPanel = new javax.swing.JPanel();
strumUpButton = new javax.swing.JToggleButton();
strumDownButton = new javax.swing.JToggleButton();
RightPanel = new javax.swing.JPanel();
coloredButtonsPanel = new javax.swing.JPanel();
orangeButton = new javax.swing.JToggleButton();
blueButton = new javax.swing.JToggleButton();
yellowButton = new javax.swing.JToggleButton();
redButton = new javax.swing.JToggleButton();
greenButton = new javax.swing.JToggleButton();
setBackground(new java.awt.Color(0, 0, 0));
setLayout(new javax.swing.BoxLayout(this, javax.swing.BoxLayout.X_AXIS));
leftPanel.setBackground(new java.awt.Color(0, 0, 0));
leftPanel.setLayout(new javax.swing.BoxLayout(leftPanel, javax.swing.BoxLayout.LINE_AXIS));
plusButton.setBackground(new java.awt.Color(255, 255, 255));
plusButton.setFont(new java.awt.Font("Arial", 1, 24));
plusButton.setText("+");
leftPanel.add(plusButton);
minusButton.setBackground(new java.awt.Color(255, 255, 255));
minusButton.setFont(new java.awt.Font("Arial", 1, 24));
minusButton.setText("-");
leftPanel.add(minusButton);
strumPanel.setBackground(new java.awt.Color(0, 0, 0));
strumPanel.setLayout(new javax.swing.BoxLayout(strumPanel, javax.swing.BoxLayout.Y_AXIS));
strumUpButton.setBackground(new java.awt.Color(255, 255, 255));
strumUpButton.setFont(new java.awt.Font("Arial", 1, 24));
strumUpButton.setText("Strum UP");
strumPanel.add(strumUpButton);
strumDownButton.setBackground(new java.awt.Color(255, 255, 255));
strumDownButton.setFont(new java.awt.Font("Arial", 1, 24));
strumDownButton.setText("Strum DOWN");
strumPanel.add(strumDownButton);
leftPanel.add(strumPanel);
add(leftPanel);
RightPanel.setBackground(new java.awt.Color(0, 0, 0));
RightPanel.setLayout(new javax.swing.BoxLayout(RightPanel, javax.swing.BoxLayout.LINE_AXIS));
coloredButtonsPanel.setLayout(new javax.swing.BoxLayout(coloredButtonsPanel, javax.swing.BoxLayout.LINE_AXIS));
orangeButton.setBackground(new java.awt.Color(255, 153, 0));
orangeButton.setFont(new java.awt.Font("Arial", 1, 24));
orangeButton.setText("O");
coloredButtonsPanel.add(orangeButton);
blueButton.setBackground(new java.awt.Color(0, 0, 204));
blueButton.setFont(new java.awt.Font("Arial", 1, 24));
blueButton.setText("O");
coloredButtonsPanel.add(blueButton);
yellowButton.setBackground(new java.awt.Color(255, 255, 0));
yellowButton.setFont(new java.awt.Font("Arial", 1, 24));
yellowButton.setText("O");
coloredButtonsPanel.add(yellowButton);
redButton.setBackground(new java.awt.Color(255, 0, 0));
redButton.setFont(new java.awt.Font("Arial", 1, 24));
redButton.setText("O");
coloredButtonsPanel.add(redButton);
greenButton.setBackground(new java.awt.Color(51, 255, 0));
greenButton.setFont(new java.awt.Font("Arial", 1, 24));
greenButton.setText("O");
coloredButtonsPanel.add(greenButton);
RightPanel.add(coloredButtonsPanel);
add(RightPanel);
}// </editor-fold>//GEN-END:initComponents
public void onButtonsEvent(WiimoteButtonsEvent arg0) {
//do nothing
}
public void onIrEvent(IREvent arg0) {
//do nothing
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
//do nothing
}
public void onExpansionEvent(ExpansionEvent arg0) {
if (arg0 instanceof GuitarHeroEvent) {
GuitarHeroEvent guitar = (GuitarHeroEvent) arg0;
GuitarHeroButtonsEvent buttons = guitar.getButtonsEvent();
//orange button
if (buttons.isButtonOrangeJustPressed()) {
orangeButton.setSelected(true);
orangeButton.setText("X");
} else if (buttons.isButtonOrangeJustReleased()) {
orangeButton.setSelected(false);
orangeButton.setText("O");
}
//blue button
if (buttons.isButtonBlueJustPressed()) {
blueButton.setSelected(true);
blueButton.setText("X");
} else if (buttons.isButtonBlueJustReleased()) {
blueButton.setSelected(false);
blueButton.setText("O");
}
//Yellow button
if (buttons.isButtonYellowJustPressed()) {
yellowButton.setSelected(true);
yellowButton.setText("X");
} else if (buttons.isButtonYellowJustReleased()) {
yellowButton.setSelected(false);
yellowButton.setText("O");
}
//Red button
if (buttons.isButtonRedJustPressed()) {
redButton.setSelected(true);
redButton.setText("X");
} else if (buttons.isButtonRedJustReleased()) {
redButton.setSelected(false);
redButton.setText("O");
}
//Green button
if (buttons.isButtonGreenJustPressed()) {
greenButton.setSelected(true);
greenButton.setText("X");
} else if (buttons.isButtonGreenJustReleased()) {
greenButton.setSelected(false);
greenButton.setText("O");
}
//Plus button
if (buttons.isButtonPlusJustPressed()) {
plusButton.setSelected(true);
} else if (buttons.isButtonPlusJustReleased()) {
plusButton.setSelected(false);
}
//Minus button
if (buttons.isButtonMinusJustPressed()) {
minusButton.setSelected(true);
} else if (buttons.isButtonMinusJustReleased()) {
minusButton.setSelected(false);
}
//Strum up button
if (buttons.isButtonStrumUpJustPressed()) {
strumUpButton.setSelected(true);
} else if (buttons.isButtonStrumUpJustReleased()) {
strumUpButton.setSelected(false);
}
//Strum down button
if (buttons.isButtonStrumDownJustPressed()) {
strumDownButton.setSelected(true);
} else if (buttons.isButtonStrumDownJustReleased()) {
strumDownButton.setSelected(false);
}
}
}
public void onStatusEvent(StatusEvent arg0) {
//do nothing
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
//do nothing
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
//do nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
//do nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
//do nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
//do nothing
}
public void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent arg0) {
//do nothing
}
public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent arg0) {
//do nothing
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JPanel RightPanel;
private javax.swing.JToggleButton blueButton;
private javax.swing.JPanel coloredButtonsPanel;
private javax.swing.JToggleButton greenButton;
private javax.swing.JPanel leftPanel;
private javax.swing.JToggleButton minusButton;
private javax.swing.JToggleButton orangeButton;
private javax.swing.JToggleButton plusButton;
private javax.swing.JToggleButton redButton;
private javax.swing.JToggleButton strumDownButton;
private javax.swing.JPanel strumPanel;
private javax.swing.JToggleButton strumUpButton;
private javax.swing.JToggleButton yellowButton;
// End of variables declaration//GEN-END:variables
}

39
java/src/wiiusej/utils/GuitarHeroJoystickEventPanel.java Normal file
View File

@@ -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.utils;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.GuitarHeroEvent;
import wiiusej.wiiusejevents.physicalevents.JoystickEvent;
/**
* Panel to display Guitar Hero 3 controller joystick events.
*
* @author guiguito
*/
public class GuitarHeroJoystickEventPanel extends JoystickEventPanel{
@Override
public JoystickEvent getJoystickEvent(ExpansionEvent e) {
if (e instanceof GuitarHeroEvent){
return ((GuitarHeroEvent)e).getGuitarHeroJoystickEvent();
}
return null;
}
}

275
java/src/wiiusej/utils/IRPanel.java Normal file
View File

@@ -0,0 +1,275 @@
/**
* 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.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* 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 (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(WiimoteButtonsEvent arg0) {
// nothing
repaint();
}
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 onExpansionEvent(ExpansionEvent e) {
// 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();
}
public void onNunchukInsertedEvent(NunchukInsertedEvent e) {
// nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent e) {
// nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent arg0) {
// nothing
}
public void onClassicControllerRemovedEvent(
ClassicControllerRemovedEvent arg0) {
// nothing
}
public Color getBackgroundColor() {
return backgroundColor;
}
public Color getBorderColor() {
return borderColor;
}
public Color getColor() {
return color;
}
public Shape getShape() {
return shape;
}
public void setBackgroundColor(Color backgroundColor) {
this.backgroundColor = backgroundColor;
}
public void setBorderColor(Color borderColor) {
this.borderColor = borderColor;
}
public void setColor(Color color) {
this.color = color;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public void clearView() {
initArrays();
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
}

248
java/src/wiiusej/utils/JoystickEventPanel.java Normal file
View File

@@ -0,0 +1,248 @@
/**
* 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.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.JoystickEvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* Panel to display joystick events.
*
* @author guiguito
*/
public abstract class JoystickEventPanel extends javax.swing.JPanel implements
WiimoteListener {
private Image mImage;// image for double buffering
private Color backgroundColor = Color.BLACK;
private Color borderColor = Color.RED;
private Color pointColor = Color.RED;
private Shape shape = new java.awt.geom.Ellipse2D.Double(0, 0, 30, 30);
private JoystickEvent lastJoystickEvent = null;
/** Creates new form JoystickPanel */
public JoystickEventPanel() {
initComponents();
}
/**
* Constructor used to choose the colors used by the JoystickPanel.
*
* @param bgColor
* background color.
* @param pColor
* point color.
* @param bdColor
* border color for the shape.
* @param sh
* shape of what is drawn.
*/
public JoystickEventPanel(Color bgColor, Color pColor, Color bdColor,
Shape sh) {
backgroundColor = bgColor;
pointColor = pColor;
shape = sh;
borderColor = bdColor;
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);
g2.setTransform(new AffineTransform());
// compute center
int xCenter = (int) Math.round(d.getWidth() / 2.0);
int yCenter = (int) Math.round(d.getHeight() / 2.0);
// compute coordinates
if (lastJoystickEvent != null) {
double xAng = Math.sin(lastJoystickEvent.getAngle() * Math.PI
/ 180.0)
* lastJoystickEvent.getMagnitude();
double yAng = Math.cos(lastJoystickEvent.getAngle() * Math.PI
/ 180.0)
* lastJoystickEvent.getMagnitude();
int halfWidth = (int) Math.round(shape.getBounds().getWidth() / 2);
int halHeight = (int) Math.round(shape.getBounds().getHeight() / 2);
int xAmplitude = (int) Math.round(xCenter - shape.getBounds().getWidth());
int yAmplitude = (int) Math.round(xCenter - shape.getBounds().getHeight());
int xShift = (int) Math.round(xAng * xAmplitude);
int yShift = (int) Math.round(yAng * yAmplitude);
int x = xCenter + xShift - halfWidth;
int y = yCenter - yShift - halHeight;
// shape
g2.translate(x, y);
g2.setPaint(borderColor);
g2.draw(shape);
g2.setPaint(pointColor);
g2.fill(shape);
}
// 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(WiimoteButtonsEvent arg0) {
// nothing
}
public void onIrEvent(IREvent arg0) {
// nothing
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
// nothing
}
public void onExpansionEvent(ExpansionEvent arg0) {
JoystickEvent joy = getJoystickEvent(arg0);
if (joy != null) {
lastJoystickEvent = joy;
}
repaint();
}
public void onStatusEvent(StatusEvent arg0) {
// nothing
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
// nothing
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
// nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
// nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent arg0) {
// nothing
}
public void onClassicControllerRemovedEvent(
ClassicControllerRemovedEvent arg0) {
// nothing
}
public Color getBackgroundColor() {
return backgroundColor;
}
public Color getPointColor() {
return pointColor;
}
public Color getBorderColor() {
return borderColor;
}
public Shape getShape() {
return shape;
}
public void setBackgroundColor(Color backgroundColor) {
this.backgroundColor = backgroundColor;
}
public void setPointColor(Color pointColor) {
this.pointColor = pointColor;
}
public void setBorderColor(Color borderColor) {
this.borderColor = borderColor;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public abstract JoystickEvent getJoystickEvent(ExpansionEvent e);
/**
* 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
}

38
java/src/wiiusej/utils/NunchukJoystickEventPanel.java Normal file
View File

@@ -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/>.
*/
package wiiusej.utils;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.JoystickEvent;
import wiiusej.wiiusejevents.physicalevents.NunchukEvent;
/**
* Panel to display nunchuk joystick events.
*
* @author guiguito
*/
public class NunchukJoystickEventPanel extends JoystickEventPanel {
@Override
public JoystickEvent getJoystickEvent(ExpansionEvent e) {
if (e instanceof NunchukEvent) {
return ((NunchukEvent) e).getNunchukJoystickEvent();
}
return null;
}
}

38
java/src/wiiusej/utils/OrientationExpansionEventPanel.java Normal file
View File

@@ -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/>.
*/
package wiiusej.utils;
import wiiusej.values.Orientation;
import wiiusej.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.NunchukEvent;
/**
* Panel to display Orientation in a MotionSensingEvent from an expansion.
*
* @author guiguito
*/
public class OrientationExpansionEventPanel extends OrientationPanel {
@Override
public Orientation getOrientationValue(GenericEvent e) {
if (e instanceof NunchukEvent) {
return ((NunchukEvent) e).getNunchukMotionSensingEvent()
.getOrientation();
}
return null;
}
}

305
java/src/wiiusej/utils/OrientationPanel.java Normal file
View File

@@ -0,0 +1,305 @@
/**
* 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.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.utils.WiimoteListener;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This panel is used to watch orientation values from a MotionSensingEvent.
*
* @author guiguito
*/
public abstract 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(WiimoteButtonsEvent arg0) {
// nothing
}
public void onIrEvent(IREvent arg0) {
// nothing
}
public void onMotionSensingEvent(MotionSensingEvent arg0) {
draw(arg0);
}
public void onExpansionEvent(ExpansionEvent arg0) {
draw(arg0);
}
public void onStatusEvent(StatusEvent arg0) {
// nothing
}
public void onDisconnectionEvent(DisconnectionEvent arg0) {
// Clear points.
values.clear();
repaint();
}
public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {
// nothing
}
public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {
// nothing
}
public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent arg0) {
// nothing
}
public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent arg0) {
// nothing
}
public void onClassicControllerInsertedEvent(
ClassicControllerInsertedEvent arg0) {
// nothing
}
public void onClassicControllerRemovedEvent(
ClassicControllerRemovedEvent arg0) {
// nothing
}
private void draw(GenericEvent arg0) {
if (values.size() >= getWidth()) {
// if there are as many values as pixels in the width
// clear points
values.clear();
}
Orientation orientation = getOrientationValue(arg0);
if (orientation != null)
values.add(orientation);
repaint();
}
public abstract Orientation getOrientationValue(GenericEvent e);
public Color getBackgroundColor() {
return backgroundColor;
}
public Color getLineColor() {
return lineColor;
}
public Color getPitchColor() {
return pitchColor;
}
public Color getRollColor() {
return rollColor;
}
public Color getYawColor() {
return yawColor;
}
public void setBackgroundColor(Color backgroundColor) {
this.backgroundColor = backgroundColor;
}
public void setLineColor(Color lineColor) {
this.lineColor = lineColor;
}
public void setPitchColor(Color pitchColor) {
this.pitchColor = pitchColor;
}
public void setRollColor(Color rollColor) {
this.rollColor = rollColor;
}
public void setYawColor(Color yawColor) {
this.yawColor = yawColor;
}
public void clearView() {
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
}

38
java/src/wiiusej/utils/OrientationWiimoteEventPanel.java Normal file
View File

@@ -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/>.
*/
package wiiusej.utils;
import wiiusej.values.Orientation;
import wiiusej.wiiusejevents.GenericEvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
/**
* Panel to display Orientation in a MotionSensingEvent from a wiimote.
*
* @author guiguito
*/
public class OrientationWiimoteEventPanel extends OrientationPanel {
@Override
public Orientation getOrientationValue(GenericEvent e) {
if (e instanceof MotionSensingEvent) {
return ((MotionSensingEvent) e).getOrientation();
}
return null;
}
}

80
java/src/wiiusej/values/GForce.java Normal file
View File

@@ -0,0 +1,80 @@
/**
* 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 + ")";
}
}

106
java/src/wiiusej/values/IRSource.java Normal file
View File

@@ -0,0 +1,106 @@
/**
* 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 + ")";
}
}

117
java/src/wiiusej/values/Orientation.java Normal file
View File

@@ -0,0 +1,117 @@
/**
* 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;
private float a_roll;
private float a_pitch;
/**
* Default constructor.
*/
public Orientation() {
roll = 0;
pitch = 0;
yaw = 0;
a_roll = 0;
a_pitch = 0;
}
/**
* Contructor with raw, pitch , yaw.
*
* @param r
* roll (can be smoothed)
* @param p
* pitch (can be smoothed)
* @param y
* yaw
* @param ar
* absolute roll
* @param ap
* absolute pitch
*/
public Orientation(float r, float p, float y, float ar, float ap) {
roll = r;
pitch = p;
yaw = y;
a_roll = ar;
a_pitch = ap;
}
/**
* Get the roll (can be smoothed).
*
* @return the roll
*/
public float getRoll() {
return roll;
}
/**
* Get the pitch (can be smoothed).
*
* @return the pitch
*/
public float getPitch() {
return pitch;
}
/**
* Get the yaw.
*
* @return the yaw
*/
public float getYaw() {
return yaw;
}
/**
* Get absolute roll (can not be smoothed).
*
* @return the a_roll
*/
public float getARoll() {
return a_roll;
}
/**
* Get absolute pitch (can not be smoothed).
*
* @return the a_pitch
*/
public float getAPitch() {
return a_pitch;
}
@Override
public String toString() {
return "Orientation : (roll: " + roll + ", pitch: " + pitch + ", yaw: "
+ yaw + ", absolute roll: " + a_roll + ", absolute pitch: "
+ a_pitch + ")";
}
}

81
java/src/wiiusej/values/RawAcceleration.java Normal file
View File

@@ -0,0 +1,81 @@
/**
* 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 + ")";
}
}

59
java/src/wiiusej/wiiusejevents/GenericEvent.java Normal file
View File

@@ -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.wiiusejevents;
/**
* Abstract mother class representing an event with a wiimote id.
*
* @author guiguito
*/
public abstract class GenericEvent {
/* ID */
private int wiimoteId = -1;
/**
* Construct the WiiUseApiEvent setting up the id.
*
* @param id
* the Wiimote id
*/
public GenericEvent(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();
}

128
java/src/wiiusej/wiiusejevents/physicalevents/ButtonsEvent.java Normal file
View File

@@ -0,0 +1,128 @@
/**
* 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.wiiusejevents.physicalevents;
import wiiusej.wiiusejevents.GenericEvent;
/**
* Class which represents a buttons event.
*
* @author guiguito
*/
public abstract class ButtonsEvent extends GenericEvent {
/* 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 */
protected boolean buttonTest(int buttonBitsDefinition, int buttons) {
return (buttons & buttonBitsDefinition) == buttonBitsDefinition;
}
protected boolean isButtonJustPressed(int buttonBitsDefinition) {
return buttonTest(buttonBitsDefinition, buttonsJustPressed)
&& !isButtonHeld(buttonBitsDefinition);
}
protected boolean isButtonJustReleased(int buttonBitsDefinition) {
return buttonTest(buttonBitsDefinition, buttonsJustReleased);
}
protected boolean isButtonHeld(int buttonBitsDefinition) {
return buttonTest(buttonBitsDefinition, buttonsHeld);
}
protected boolean isButtonPressed(int buttonBitsDefinition) {
return isButtonHeld(buttonBitsDefinition)
|| isButtonJustPressed(buttonBitsDefinition);
}
@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;
}
}

329
java/src/wiiusej/wiiusejevents/physicalevents/ClassicControllerButtonsEvent.java Normal file
View File

@@ -0,0 +1,329 @@
/* 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.wiiusejevents.physicalevents;
/**
* Class which represents a buttons event from a Classic controller.
*
* @author guiguito
*/
public class ClassicControllerButtonsEvent extends ButtonsEvent{
private static short CLASSIC_CTRL_BUTTON_UP = 0x0001;
private static short CLASSIC_CTRL_BUTTON_LEFT = 0x0002;
private static short CLASSIC_CTRL_BUTTON_ZR = 0x0004;
private static short CLASSIC_CTRL_BUTTON_X = 0x0008;
private static short CLASSIC_CTRL_BUTTON_A = 0x0010;
private static short CLASSIC_CTRL_BUTTON_Y = 0x0020;
private static short CLASSIC_CTRL_BUTTON_B = 0x0040;
private static short CLASSIC_CTRL_BUTTON_ZL = 0x0080;
private static short CLASSIC_CTRL_BUTTON_FULL_R = 0x0200;
private static short CLASSIC_CTRL_BUTTON_PLUS = 0x0400;
private static short CLASSIC_CTRL_BUTTON_HOME = 0x0800;
private static short CLASSIC_CTRL_BUTTON_MINUS = 0x1000;
private static short CLASSIC_CTRL_BUTTON_FULL_L = 0x2000;
private static short CLASSIC_CTRL_BUTTON_DOWN = 0x4000;
private static int CLASSIC_CTRL_BUTTON_RIGHT = 0x8000;
private static int CLASSIC_CTRL_BUTTON_ALL = 0xFEFF;
/**
* Constructor of the classic controller buttons Event.
*
* @param id
* id of the wiimote.
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
*/
public ClassicControllerButtonsEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld) {
super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld);
}
/* Button LEFT */
public boolean isButtonLeftJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_LEFT);
}
public boolean isButtonLeftJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_LEFT);
}
public boolean isButtonLeftHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_LEFT);
}
public boolean isButtonLeftPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_LEFT);
}
/* Button RIGHT */
public boolean isButtonRightJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_RIGHT);
}
public boolean isButtonRightJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_RIGHT);
}
public boolean isButtonRightHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_RIGHT);
}
public boolean isButtonRightPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_RIGHT);
}
/* Button UP */
public boolean isButtonUpJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_UP);
}
public boolean isButtonUpJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_UP);
}
public boolean isButtonUpHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_UP);
}
public boolean isButtonUpPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_UP);
}
/* Button DOWN */
public boolean isButtonDownJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_DOWN);
}
public boolean isButtonDownJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_DOWN);
}
public boolean isButtonDownHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_DOWN);
}
public boolean isButtonDownPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_DOWN);
}
/* Button A */
public boolean isButtonAJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_A);
}
public boolean isButtonAJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_A);
}
public boolean isButtonAHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_A);
}
public boolean isButtonAPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_A);
}
/* Button B */
public boolean isButtonBJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_B);
}
public boolean isButtonBJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_B);
}
public boolean isButtonBHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_B);
}
public boolean isButtonBPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_B);
}
/* Button X */
public boolean isButtonXJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_X);
}
public boolean isButtonXJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_X);
}
public boolean isButtonXHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_X);
}
public boolean isButtonXPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_X);
}
/* Button Y */
public boolean isButtonYJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_Y);
}
public boolean isButtonYJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_Y);
}
public boolean isButtonYHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_Y);
}
public boolean isButtonYPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_Y);
}
/* Button FullLeft */
public boolean isButtonFullLeftJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_FULL_L);
}
public boolean isButtonFullLeftJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_FULL_L);
}
public boolean isButtonFullLeftHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_FULL_L);
}
public boolean isButtonFullLeftPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_FULL_L);
}
/* Button FullRight */
public boolean isButtonFullRightJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_FULL_R);
}
public boolean isButtonFullRightJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_FULL_R);
}
public boolean isButtonFullRightHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_FULL_R);
}
public boolean isButtonFullRightPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_FULL_R);
}
/* Button Home */
public boolean isButtonHomeJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_HOME);
}
public boolean isButtonHomeJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_HOME);
}
public boolean isButtonHomeHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_HOME);
}
public boolean isButtonHomePressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_HOME);
}
/* Button Minus */
public boolean isButtonMinusJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_MINUS);
}
public boolean isButtonMinusJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_MINUS);
}
public boolean isButtonMinusHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_MINUS);
}
public boolean isButtonMinusPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_MINUS);
}
/* Button Plus */
public boolean isButtonPlusJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_PLUS);
}
public boolean isButtonPlusJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_PLUS);
}
public boolean isButtonPlusHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_PLUS);
}
public boolean isButtonPlusPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_PLUS);
}
/* Button ZL */
public boolean isButtonZLJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_ZL);
}
public boolean isButtonZLJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_ZL);
}
public boolean isButtonZLHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_ZL);
}
public boolean isButtonZLPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_ZL);
}
/* Button ZR */
public boolean isButtonZRJustPressed() {
return isButtonJustPressed(CLASSIC_CTRL_BUTTON_ZR);
}
public boolean isButtonZRJustReleased() {
return isButtonJustReleased(CLASSIC_CTRL_BUTTON_ZR);
}
public boolean isButtonZRHeld() {
return isButtonHeld(CLASSIC_CTRL_BUTTON_ZR);
}
public boolean isButtonZRPressed() {
return isButtonPressed(CLASSIC_CTRL_BUTTON_ZR);
}
}

177
java/src/wiiusej/wiiusejevents/physicalevents/ClassicControllerEvent.java Normal file
View File

@@ -0,0 +1,177 @@
/**
* 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.wiiusejevents.physicalevents;
/**
* This class represents the values from the classic controller and its events.
*
* @author guiguito
*/
public class ClassicControllerEvent extends ExpansionEvent {
private float rightShoulder;
private float leftShoulder;
private ClassicControllerButtonsEvent buttonsEvent;
private JoystickEvent classicControllerRightJoystickEvent;
private JoystickEvent classicControllerLeftJoystickEvent;
/**
* Constructor of ClassicControllerEvent.
*
* @param id
* id of the wiimote.
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @param rightShoulder
* right shoulder button (range 0-1).
* @param leftShoulder
* left shoulder button (range 0-1).
* @param langle
* angle the left joystick is being held.
* @param lmagnitude
* magnitude of the left joystick (range 0-1).
* @param lmax1
* maximum left joystick value 1.
* @param lmax2
* maximum left joystick value 2.
* @param lmin1
* minimum left joystick value 1.
* @param lmin2
* minimum left joystick value 2.
* @param lcenter1
* center left joystick value 1.
* @param lcenter2
* center left joystick value 2.
* @param rangle
* angle the right joystick is being held.
* @param rmagnitude
* magnitude of the right joystick (range 0-1).
* @param rmax1
* maximum right joystick value 1.
* @param rmax2
* maximum right joystick value 2.
* @param rmin1
* minimum right joystick value 1.
* @param rmin2
* minimum right joystick value 2.
* @param rcenter1
* center right joystick value 1.
* @param rcenter2
* center right joystick value 2.
*/
public ClassicControllerEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld, float rightShoulder,
float leftShoulder, float langle, float lmagnitude, short lmax1,
short lmax2, short lmin1, short lmin2, short lcenter1,
short lcenter2, float rangle, float rmagnitude, short rmax1,
short rmax2, short rmin1, short rmin2, short rcenter1,
short rcenter2) {
super(id);
this.leftShoulder = leftShoulder;
this.rightShoulder = rightShoulder;
buttonsEvent = new ClassicControllerButtonsEvent(id,
buttonsJustPressed, buttonsJustReleased, buttonsHeld);
classicControllerLeftJoystickEvent = new JoystickEvent(id, langle,
lmagnitude, lmax1, lmax2, lmin1, lmin2, lcenter1, lcenter2);
classicControllerRightJoystickEvent = new JoystickEvent(id, rangle,
rmagnitude, rmax1, rmax2, rmin1, rmin2, rcenter1, rcenter2);
}
/**
* Tell if there is a classic controller left joystick event.
*
* @return TRUE if there is a classic controller left joystick event, false
* otherwise.
*/
public boolean isThereClassicControllerLeftJoystickEvent() {
return classicControllerLeftJoystickEvent != null;
}
/**
* Tell if there is a classic controller right joystick event.
*
* @return TRUE if there is a classic controller right joystick event, false
* otherwise.
*/
public boolean isThereClassicControllerRightJoystickEvent() {
return classicControllerRightJoystickEvent != null;
}
/**
* Get the right shoulder button(range 0-1).
*
* @return value of the rightShoulder button.
*/
public float getRightShoulder() {
return rightShoulder;
}
/**
* Get the left shoulder button(range 0-1).
*
* @return value of the leftShoulder button.
*/
public float getLeftShoulder() {
return leftShoulder;
}
/**
* Get buttons event for the classic controller.
*
* @return the classic controller buttons event if there is one or null.
*/
public ClassicControllerButtonsEvent getButtonsEvent() {
return buttonsEvent;
}
/**
* Get event from the right joystick of the classic controller.
*
* @return the classic controller right Joystick Event if there is one or null.
*/
public JoystickEvent getClassicControllerRightJoystickEvent() {
return classicControllerRightJoystickEvent;
}
/**
* Get event from the left joystick of the classic controller.
*
* @return the classic controller left Joystick Event if there is one or null.
*/
public JoystickEvent getClassicControllerLeftJoystickEvent() {
return classicControllerLeftJoystickEvent;
}
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** Classic Controller EVENT : WIIMOTE ID :"
+ getWiimoteId() + " ********/\n";
out += buttonsEvent;
out += "Left shoulder : " + leftShoulder + "\n";
out += "Right shoulder : " + rightShoulder + "\n";
out += classicControllerLeftJoystickEvent;
out += classicControllerRightJoystickEvent;
return out;
}
}

40
java/src/wiiusej/wiiusejevents/physicalevents/ExpansionEvent.java Normal file
View File

@@ -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.wiiusejevents.physicalevents;
import wiiusej.wiiusejevents.GenericEvent;
/**
* Mother Class of all expansions event.
*
* @author guiguito
*/
public abstract class ExpansionEvent extends GenericEvent {
/**
* Constructor of an ExpansionEvent.
*
* @param id
* id of the wiimote to which the expansion is connected.
*/
public ExpansionEvent(int id) {
super(id);
}
public abstract String toString();
}

214
java/src/wiiusej/wiiusejevents/physicalevents/GuitarHeroButtonsEvent.java Normal file
View File

@@ -0,0 +1,214 @@
/* 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.wiiusejevents.physicalevents;
/**
* Class which represents a buttons event from a Guitar Hero controller.
*
* @author guiguito
*/
public class GuitarHeroButtonsEvent extends ButtonsEvent {
private static short GUITAR_HERO_3_BUTTON_STRUM_UP = 0x0001;
private static short GUITAR_HERO_3_BUTTON_YELLOW = 0x0008;
private static short GUITAR_HERO_3_BUTTON_GREEN = 0x0010;
private static short GUITAR_HERO_3_BUTTON_BLUE = 0x0020;
private static short GUITAR_HERO_3_BUTTON_RED = 0x0040;
private static short GUITAR_HERO_3_BUTTON_ORANGE = 0x0080;
private static short GUITAR_HERO_3_BUTTON_PLUS = 0x0400;
private static short GUITAR_HERO_3_BUTTON_MINUS = 0x1000;
private static short GUITAR_HERO_3_BUTTON_STRUM_DOWN = 0x4000;
private static int GUITAR_HERO_3_BUTTON_ALL = 0xFEFF;
/**
* Constructor of the guitar hero buttons Event.
*
* @param id
* id of the wiimote.
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
*/
public GuitarHeroButtonsEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld) {
super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld);
}
/* Button Strum Up */
public boolean isButtonStrumUpJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_STRUM_UP);
}
public boolean isButtonStrumUpJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_STRUM_UP);
}
public boolean isButtonStrumUpeHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_STRUM_UP);
}
public boolean isButtonStrumUpPressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_STRUM_UP);
}
/* Button Strum Down */
public boolean isButtonStrumDownJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_STRUM_DOWN);
}
public boolean isButtonStrumDownJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_STRUM_DOWN);
}
public boolean isButtonStrumDowneHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_STRUM_DOWN);
}
public boolean isButtonStrumDownPressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_STRUM_DOWN);
}
/* Button blue */
public boolean isButtonBlueJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_BLUE);
}
public boolean isButtonBlueJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_BLUE);
}
public boolean isButtonBlueHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_BLUE);
}
public boolean isButtonBluePressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_BLUE);
}
/* Button Green */
public boolean isButtonGreenJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_GREEN);
}
public boolean isButtonGreenJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_GREEN);
}
public boolean isButtonGreenHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_GREEN);
}
public boolean isButtonGreenPressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_GREEN);
}
/* Button Minus */
public boolean isButtonMinusJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_MINUS);
}
public boolean isButtonMinusJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_MINUS);
}
public boolean isButtonMinusHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_MINUS);
}
public boolean isButtonMinusPressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_MINUS);
}
/* Button Orange */
public boolean isButtonOrangeJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_ORANGE);
}
public boolean isButtonOrangeJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_ORANGE);
}
public boolean isButtonOrangeHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_ORANGE);
}
public boolean isButtonOrangePressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_ORANGE);
}
/* Button Plus */
public boolean isButtonPlusJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_PLUS);
}
public boolean isButtonPlusJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_PLUS);
}
public boolean isButtonPlusHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_PLUS);
}
public boolean isButtonPlusPressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_PLUS);
}
/* Button Red */
public boolean isButtonRedJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_RED);
}
public boolean isButtonRedJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_RED);
}
public boolean isButtonRedHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_RED);
}
public boolean isButtonRedPressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_RED);
}
/* Button Yellow */
public boolean isButtonYellowJustPressed() {
return isButtonJustPressed(GUITAR_HERO_3_BUTTON_YELLOW);
}
public boolean isButtonYellowJustReleased() {
return isButtonJustReleased(GUITAR_HERO_3_BUTTON_YELLOW);
}
public boolean isButtonYellowHeld() {
return isButtonHeld(GUITAR_HERO_3_BUTTON_YELLOW);
}
public boolean isButtonYellowPressed() {
return isButtonPressed(GUITAR_HERO_3_BUTTON_YELLOW);
}
}

119
java/src/wiiusej/wiiusejevents/physicalevents/GuitarHeroEvent.java Normal file
View File

@@ -0,0 +1,119 @@
/**
* 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.wiiusejevents.physicalevents;
/**
* This class represents the values from the GuitarHero and its events.
*
* @author guiguito
*/
public class GuitarHeroEvent extends ExpansionEvent{
private float whammyBar;
private GuitarHeroButtonsEvent buttonsEvent;
private JoystickEvent guitarHeroJoystickEvent;
/**
* Constructor of GuitarHeroEvent.
*
* @param id
* id of the wiimote.
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @param whammyBar
* whammy bar (range 0-1).
* @param angle
* angle the joystick is being held.
* @param magnitude
* magnitude of the joystick (range 0-1).
* @param max1
* maximum joystick value 1.
* @param max2
* maximum joystick value 2.
* @param min1
* minimum joystick value 1.
* @param min2
* minimum joystick value 2.
* @param center1
* center joystick value 1.
* @param center2
* center joystick value 2.
*/
public GuitarHeroEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld, float whammyBar,
float angle, float magnitude, short max1,
short max2, short min1, short min2, short center1,
short center2) {
super(id);
this.whammyBar = whammyBar;
buttonsEvent = new GuitarHeroButtonsEvent(id,
buttonsJustPressed, buttonsJustReleased, buttonsHeld);
guitarHeroJoystickEvent = new JoystickEvent(id, angle,
magnitude, max1, max2, min1, min2, center1, center2);
}
/**
* Tell if there is a Guitar Hero joystick event.
*
* @return TRUE if there is a Guitar Hero joystick event, false otherwise.
*/
public boolean isThereGuitarHeroJoystickEvent() {
return guitarHeroJoystickEvent != null;
}
/**
* Whammy bar (range 0-1).
* @return the whammyBar value.
*/
public float getWhammyBar() {
return whammyBar;
}
/**
* Get buttons event for the guitar hero controller.
* @return the guitar hero controller buttons event if there is one or null.
*/
public GuitarHeroButtonsEvent getButtonsEvent() {
return buttonsEvent;
}
/**
* Get event from the joystick of the guitar hero controller.
* @return the guitar hero controller joystick Event if there is one or null.
*/
public JoystickEvent getGuitarHeroJoystickEvent() {
return guitarHeroJoystickEvent;
}
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** Guitar Hero 3 EVENT : WIIMOTE ID :" + getWiimoteId()
+ " ********/\n";
out += buttonsEvent;
out += "Whammy Bar : "+whammyBar+"\n";
out += guitarHeroJoystickEvent;
return out;
}
}

319
java/src/wiiusej/wiiusejevents/physicalevents/IREvent.java Normal file
View File

@@ -0,0 +1,319 @@
/**
* 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.wiiusejevents.physicalevents;
import wiiusej.values.IRSource;
import wiiusej.wiiusejevents.GenericEvent;
/**
* Class which represents an IR event.
*
* @author guiguito
*/
public class IREvent extends GenericEvent {
/* IR Tracking */
private IRSource[] IRPoints;
private short indexPoints = 0;
private int x;
private int y;
private float 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;
private short irSensitivity;
private float distance;
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.
* @param irSensitivity
* Sensitivity of the infrared camera.
* @param distance
* Pixel Distance between first two dots
*/
public IREvent(int id, int x, int y, float z, int ax, int ay, int xVRes,
int yVRes, int xOffset, int yOffset, short sensorBarPostion,
short screenAsPectRatio, short irSensitivity, float distance) {
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;
this.irSensitivity = irSensitivity;
this.distance = distance;
IRPoints = new IRSource[NB_POINTS];
}
/**
* Get list of IR points.
*
* @return the list of 2D points
*/
public IRSource[] getIRPoints() {
IRSource[] ir = new IRSource[indexPoints];
System.arraycopy(IRPoints, 0, ir, 0, indexPoints);
return ir;
}
/**
* 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 float 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;
}
/**
* The sensitivity of the IR camera can be turned up or down depending on
* your needs. Like the Wii, wiiusej and wiiuse can set the camera
* sensitivity to a degree between 1 (lowest) and 5 (highest). The default
* is 3.
*
* @return the irSensitivity
*/
public short getIrSensitivity() {
return irSensitivity;
}
/**
* Pixel distance between first 2 dots.
*
* @return the distance between first 2 dots.
*/
public float getDistance() {
return distance;
}
@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 Z coordinate : " + z + "\n";
out += "--- calculated distance : " + distance + "\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";
out += "--- IR Sensitivity (between 1-5) : " + irSensitivity + "\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;
}
}

135
java/src/wiiusej/wiiusejevents/physicalevents/JoystickEvent.java Normal file
View File

@@ -0,0 +1,135 @@
/**
* 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.wiiusejevents.physicalevents;
import wiiusej.wiiusejevents.GenericEvent;
/**
* Class that stores values on a joystick Event.
*
* @author guiguito
*/
public class JoystickEvent extends GenericEvent {
private float angle;
private float magnitude;
private short[] max;
private short[] min;
private short[] center;
/**
* Constructor of a JoystickEvent.
*
* @param id
* id of the wiimote connected.
* @param angle
* angle the joystick is being held.
* @param magnitude
* magnitude of the joystick (range 0-1).
* @param max1
* maximum joystick value 1.
* @param max2
* maximum joystick value 2.
* @param min1
* minimum joystick value 1.
* @param min2
* minimum joystick value 2.
* @param center1
* center joystick value 1.
* @param center2
* center joystick value 2.
*/
public JoystickEvent(int id, float angle, float magnitude, short max1,
short max2, short min1, short min2, short center1, short center2) {
super(id);
this.angle = angle;
this.magnitude = magnitude;
max = new short[2];
max[0] = max1;
max[1] = max2;
min = new short[2];
min[0] = min1;
min[1] = min2;
center = new short[2];
center[0] = center1;
center[1] = center2;
}
/**
* Get angle the joystick is being held.
*
* @return the angle angle the joystick.
*/
public float getAngle() {
return angle;
}
/**
* Get magnitude of the joystick (range 0-1).
*
* @return the magnitude magnitude of the joystick.
*/
public float getMagnitude() {
return magnitude;
}
/**
* Maximum joystick values.
*
* @return the max
*/
public short[] getMax() {
return max;
}
/**
* Minimum joystick values.
*
* @return the min
*/
public short[] getMin() {
return min;
}
/**
* Center joystick values.
*
* @return the center
*/
public short[] getCenter() {
return center;
}
/*
* (non-Javadoc)
*
* @see wiiusej.wiiusejevents.GenericEvent#toString()
*/
@Override
public String toString() {
String out = "";
/* Display IR Tracking */
out += "/******** Joystick ********/\n";
out += "--- angle : " + angle + "\n";
out += "--- magnitude : " + magnitude + "\n";
out += "--- maximum values : " + max[0] + "," + max[1] + "\n";
out += "--- minimum values : " + min[0] + "," + min[1] + "\n";
out += "--- center values : " + center[0] + "," + center[1] + "\n";
return out;
}
}

203
java/src/wiiusej/wiiusejevents/physicalevents/MotionSensingEvent.java Normal file
View File

@@ -0,0 +1,203 @@
/**
* 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.wiiusejevents.physicalevents;
import wiiusej.values.GForce;
import wiiusej.values.Orientation;
import wiiusej.values.RawAcceleration;
import wiiusej.wiiusejevents.GenericEvent;
/**
* Class which represents a motion sensing event.
*
* @author guiguito
*/
public class MotionSensingEvent extends GenericEvent {
/* 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 ar
* absolute roll.
* @param ap
* absolute pitch.
* @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 ar, float ap,
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, ar, ap, x, y, z, xx, yy, zz);
}
/**
* Set orientation, gravity force and raw acceleration.
*
* @param r
* roll
* @param p
* pitch
* @param ya
* yaw
* @param ar
* absolute roll
* @param ap
* absolute pitch
* @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 ar,
float ap, float x, float y, float z, short xx, short yy, short zz) {
this.orientation = new Orientation(r, p, ya, ar, ap);
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;
}
}

89
java/src/wiiusej/wiiusejevents/physicalevents/NunchukButtonsEvent.java Normal file
View File

@@ -0,0 +1,89 @@
/**
* 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.wiiusejevents.physicalevents;
/**
* Class which represents a buttons event from a Nunchuk.
*
* @author guiguito
*/
public class NunchukButtonsEvent extends ButtonsEvent {
private static short NUNCHUK_BUTTON_Z = 0x01;
private static short NUNCHUK_BUTTON_C = 0x02;
private static short NUNCHUK_BUTTON_ALL = 0x03;
/**
* Constructor of the nunchuk buttons Event.
*
* @param id
* id of the wiimote.
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
*/
public NunchukButtonsEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld) {
super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld);
}
/* Button Z */
public boolean isButtonZJustPressed() {
return isButtonJustPressed(NUNCHUK_BUTTON_Z);
}
public boolean isButtonZJustReleased() {
return isButtonJustReleased(NUNCHUK_BUTTON_Z);
}
public boolean isButtonZeHeld() {
return isButtonHeld(NUNCHUK_BUTTON_Z);
}
public boolean isButtonZPressed() {
return isButtonPressed(NUNCHUK_BUTTON_Z);
}
/* Button Z */
public boolean isButtonCJustPressed() {
return isButtonJustPressed(NUNCHUK_BUTTON_C);
}
public boolean isButtonCJustReleased() {
return isButtonJustReleased(NUNCHUK_BUTTON_C);
}
public boolean isButtonCHeld() {
return isButtonHeld(NUNCHUK_BUTTON_C);
}
public boolean isButtonCPressed() {
return isButtonPressed(NUNCHUK_BUTTON_C);
}
@Override
public String toString() {
return "/******** Buttons for Nunchuk Event ********/\n"
+ super.toString();
}
}

169
java/src/wiiusej/wiiusejevents/physicalevents/NunchukEvent.java Normal file
View File

@@ -0,0 +1,169 @@
/**
* 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.wiiusejevents.physicalevents;
/**
* This class represents the values from the joystick and its events.
*
* @author guiguito
*/
public class NunchukEvent extends ExpansionEvent {
private NunchukButtonsEvent buttonsEvent;
private MotionSensingEvent nunchukMotionSensingEvent;
private JoystickEvent nunchukJoystickEvent;
/**
* Constructor of NunchukEvent.
*
* @param id
* id of the wiimote.
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @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 ar
* absolute roll.
* @param ap
* absolute pitch.
* @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.
* @param angle
* angle the joystick is being held.
* @param magnitude
* magnitude of the joystick (range 0-1).
* @param max1
* maximum joystick value 1.
* @param max2
* maximum joystick value 2.
* @param min1
* minimum joystick value 1.
* @param min2
* minimum joystick value 2.
* @param center1
* center joystick value 1.
* @param center2
* center joystick value 2.
*/
public NunchukEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld,
float orientationThreshold, int accelerationThreshold,
boolean smoothingState, float alphaSmooth, float r, float p,
float ya, float ar, float ap, float x, float y, float z, short xx,
short yy, short zz, float angle, float magnitude, short max1,
short max2, short min1, short min2, short center1, short center2) {
super(id);
buttonsEvent = new NunchukButtonsEvent(id, buttonsJustPressed,
buttonsJustReleased, buttonsHeld);
nunchukMotionSensingEvent = new MotionSensingEvent(id,
orientationThreshold, accelerationThreshold, smoothingState,
alphaSmooth, r, p, ya, ar, ap, x, y, z, xx, yy, zz);
nunchukJoystickEvent = new JoystickEvent(id, angle, magnitude, max1,
max2, min1, min2, center1, center2);
}
/**
* Tell if there is a nunchuk motion sensing Event.
*
* @return TRUE if there is a nunchuk motion sensing event, false otherwise.
*/
public boolean isThereMotionSensingEvent() {
return nunchukMotionSensingEvent != null;
}
/**
* Tell if there is a nunchuk joystick event.
*
* @return TRUE if there is a nunchuk joystick event, false otherwise.
*/
public boolean isThereNunchukJoystickEvent() {
return nunchukJoystickEvent != null;
}
/**
* Get nunchuk buttons event.
*
* @return the nunchuk buttons event if there is one or null.
*/
public NunchukButtonsEvent getButtonsEvent() {
return buttonsEvent;
}
/**
* Get the nunchuk motion sensing event.
*
* @return the nunchuk motion sensing event if there is one or null.
*/
public MotionSensingEvent getNunchukMotionSensingEvent() {
return nunchukMotionSensingEvent;
}
/**
* Get the nunchuk joystick event.
*
* @return the nunchuk Joystick Event if there is one or null.
*/
public JoystickEvent getNunchukJoystickEvent() {
return nunchukJoystickEvent;
}
/*
* (non-Javadoc)
*
* @see wiiusej.wiiusejevents.GenericEvent#toString()
*/
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** Nunchuk EVENT : WIIMOTE ID :" + getWiimoteId()
+ " ********/\n";
out += buttonsEvent;
out += nunchukJoystickEvent;
out += nunchukMotionSensingEvent;
return out;
}
}

267
java/src/wiiusej/wiiusejevents/physicalevents/WiimoteButtonsEvent.java Normal file
View File

@@ -0,0 +1,267 @@
/**
* 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.wiiusejevents.physicalevents;
/**
* Class which represents a buttons event for a generic event. It means buttons
* from a wiimote.
*
* @author guiguito
*/
public class WiimoteButtonsEvent extends ButtonsEvent {
/* 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;
/**
* Constructor of the wiimote button Event.
*
* @param id
* id of the wiimote.
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons held.
*/
public WiimoteButtonsEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld) {
super(id, buttonsJustPressed, buttonsJustReleased, buttonsHeld);
}
/* 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() {
return "/******** Buttons for Wiimote generic Event ********/\n"
+ super.toString();
}
}

509
java/src/wiiusej/wiiusejevents/utils/EventsGatherer.java Normal file
View File

@@ -0,0 +1,509 @@
/**
* 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.wiiusejevents.utils;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent;
import wiiusej.wiiusejevents.wiiuseapievents.WiimoteEvent;
/**
* 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 WiimoteEvent 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 WiimoteEvent(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.
* @param irSensitivity
* Sensitivity of the infrared camera.
* @param distance
* Pixel Distance between first two dots.
*/
public void prepareIRevent(int x, int y, float z, int ax, int ay,
int xVRes, int yVRes, int xOffset, int yOffset,
short sensorBarPostion, short screenAsPectRatio,
short irSensitivity, float distance) {
genericEvent.prepareIRevent(x, y, z, ax, ay, xVRes, yVRes, xOffset,
yOffset, sensorBarPostion, screenAsPectRatio, irSensitivity,
distance);
}
/**
* 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 ar
* absolute roll.
* @param ap
* absolute pitch.
* @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 ar, float ap,
float x, float y, float z, short xx, short yy, short zz) {
if (genericEvent != null) {
genericEvent.setMotionSensingEvent(orientationThreshold,
accelerationThreshold, smoothingState, alphaSmooth, r, p,
ya, ar, ap, x, y, z, xx, yy, zz);
}
}
/**
* Set a NunchukEvent to the prepared WiimoteEvent.
*
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @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 ar
* absolute roll.
* @param ap
* absolute pitch.
* @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.
* @param angle
* angle the joystick is being held.
* @param magnitude
* magnitude of the joystick (range 0-1).
* @param max1
* maximum joystick value 1.
* @param max2
* maximum joystick value 2.
* @param min1
* minimum joystick value 1.
* @param min2
* minimum joystick value 2.
* @param center1
* center joystick value 1.
* @param center2
* center joystick value 2.
*/
public void addNunchunkEventToPreparedWiimoteEvent(
short buttonsJustPressed, short buttonsJustReleased,
short buttonsHeld, float orientationThreshold,
int accelerationThreshold, boolean smoothingState,
float alphaSmooth, float r, float p, float ya, float ar, float ap,
float x, float y, float z, short xx, short yy, short zz,
float angle, float magnitude, short max1, short max2, short min1,
short min2, short center1, short center2) {
if (genericEvent != null) {
genericEvent.setNunchukEvent(buttonsJustPressed,
buttonsJustReleased, buttonsHeld, orientationThreshold,
accelerationThreshold, smoothingState, alphaSmooth, r, p,
ya, ar, ap, x, y, z, xx, yy, zz, angle, magnitude, max1,
max2, min1, min2, center1, center2);
}
}
/**
* Set a GuitarHeroEvent to the prepared WiimoteEvent.
*
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @param whammyBar
* whammy bar (range 0-1).
* @param angle
* angle the joystick is being held.
* @param magnitude
* magnitude of the joystick (range 0-1).
* @param max1
* maximum joystick value 1.
* @param max2
* maximum joystick value 2.
* @param min1
* minimum joystick value 1.
* @param min2
* minimum joystick value 2.
* @param center1
* center joystick value 1.
* @param center2
* center joystick value 2.
*/
public void addGuitarHeroEventToPreparedWiimoteEvent(
short buttonsJustPressed, short buttonsJustReleased,
short buttonsHeld, float whammyBar, float angle, float magnitude,
short max1, short max2, short min1, short min2, short center1,
short center2) {
if (genericEvent != null) {
genericEvent.setGuitarHeroEvent(buttonsJustPressed,
buttonsJustReleased, buttonsHeld, whammyBar, angle,
magnitude, max1, max2, min1, min2, center1, center2);
}
}
/**
* Set a ClassicControllerEvent to the prepared WiimoteEvent.
*
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @param rightShoulder
* right shoulder button (range 0-1).
* @param leftShoulder
* left shoulder button (range 0-1).
* @param langle
* angle the left joystick is being held.
* @param lmagnitude
* magnitude of the left joystick (range 0-1).
* @param lmax1
* maximum left joystick value 1.
* @param lmax2
* maximum left joystick value 2.
* @param lmin1
* minimum left joystick value 1.
* @param lmin2
* minimum left joystick value 2.
* @param lcenter1
* center left joystick value 1.
* @param lcenter2
* center left joystick value 2.
* @param rangle
* angle the right joystick is being held.
* @param rmagnitude
* magnitude of the right joystick (range 0-1).
* @param rmax1
* maximum right joystick value 1.
* @param rmax2
* maximum right joystick value 2.
* @param rmin1
* minimum right joystick value 1.
* @param rmin2
* minimum right joystick value 2.
* @param rcenter1
* center right joystick value 1.
* @param rcenter2
* center right joystick value 2.
*/
public void addClassicControllerEventToPreparedWiimoteEvent(short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld, float rightShoulder,
float leftShoulder, float langle, float lmagnitude, short lmax1,
short lmax2, short lmin1, short lmin2, short lcenter1,
short lcenter2, float rangle, float rmagnitude, short rmax1,
short rmax2, short rmin1, short rmin2, short rcenter1,
short rcenter2) {
if (genericEvent != null) {
genericEvent.setClassicControllerEvent(buttonsJustPressed,
buttonsJustReleased, buttonsHeld, rightShoulder,
leftShoulder, langle, lmagnitude, lmax1, lmax2, lmin1,
lmin2, lcenter1, lcenter2, rangle, rmagnitude, rmax1,
rmax2, rmin1, rmin2, rcenter1, rcenter2);
}
}
/**
* 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);
}
/**
* Add a NunchukInsertedEvent to the gatherer.
*
* @param id
* id of the wiimote.
*/
public void addNunchukInsertedEvent(int id) {
NunchukInsertedEvent evt = new NunchukInsertedEvent(id);
addEvent(evt);
}
/**
* Add a NunchukRemovedEvent to the gatherer.
*
* @param id
* id of the wiimote.
*/
public void addNunchukRemovedEvent(int id) {
NunchukRemovedEvent evt = new NunchukRemovedEvent(id);
addEvent(evt);
}
/**
* Add a GuitarHeroInsertedEvent to the gatherer.
*
* @param id
* id of the wiimote.
*/
public void addGuitarHeroInsertedEvent(int id) {
GuitarHeroInsertedEvent evt = new GuitarHeroInsertedEvent(id);
addEvent(evt);
}
/**
* Add a GuitarHeroRemovedEvent to the gatherer.
*
* @param id
* id of the wiimote.
*/
public void addGuitarHeroRemovedEvent(int id) {
GuitarHeroRemovedEvent evt = new GuitarHeroRemovedEvent(id);
addEvent(evt);
}
/**
* Add a ClassicControllerInsertedEvent to the gatherer.
*
* @param id
* id of the wiimote.
*/
public void addClassicControllerInsertedEvent(int id) {
ClassicControllerInsertedEvent evt = new ClassicControllerInsertedEvent(
id);
addEvent(evt);
}
/**
* Add a ClassicControllerRemovedEvent to the gatherer.
*
* @param id
* id of the wiimote.
*/
public void addClassicControllerRemovedEvent(int id) {
ClassicControllerRemovedEvent evt = new ClassicControllerRemovedEvent(
id);
addEvent(evt);
}
/**
* Return an array containing the events.
*
* @return events received.
*/
public WiiUseApiEvent[] getEvents() {
WiiUseApiEvent[] ev = new WiiUseApiEvent[index];
System.arraycopy(events, 0, ev, 0, index);
return ev;
}
/**
* Clear the gatherer and remove objects.
*/
public void clearEvents() {
for (int i = 0; i < events.length; i++) {
events[i] = null;
}
genericEvent = null;
index = 0;
}
}

37
java/src/wiiusej/wiiusejevents/utils/WiiUseApiListener.java Normal file
View File

@@ -0,0 +1,37 @@
/**
* 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.wiiusejevents.utils;
import wiiusej.wiiusejevents.wiiuseapievents.WiiUseApiEvent;
/**
* 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 : -
* WiimoteEvent (Storing ButtonsEvent and eventually IREvent and
* MotionSensingEvent) - StatusEvent - DisconnectionEvent
*
* @param e
*/
void onWiiUseApiEvent(WiiUseApiEvent e);
}

145
java/src/wiiusej/wiiusejevents/utils/WiimoteListener.java Normal file
View File

@@ -0,0 +1,145 @@
/**
* 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.wiiusejevents.utils;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
/**
* This is the interface to implement to listen to events from wiimotes. The
* differents methods are called in this order : onButtonsEvent, onIrEvent,
* onMotionSensingEvent, onExpansionEvent, onStatusEvent, onDisconnectionEvent
* onNunchukInsertedEvent, onNunchukRemovedEvent.
*
* @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(WiimoteButtonsEvent 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 when an expansion event occurs.
*
* @param e
* the expansion event occured.
*/
void onExpansionEvent(ExpansionEvent 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);
/**
* This is the method called when a NunchukInsertedEvent occurs.
*
* @param e
* the NunchukInsertedEvent.
*/
void onNunchukInsertedEvent(NunchukInsertedEvent e);
/**
* This is the method called when a NunchukRemovedEvent occurs.
*
* @param e
* the NunchukRemovedEvent.
*/
void onNunchukRemovedEvent(NunchukRemovedEvent e);
/**
* This is the method called when a GuitarHeroInsertedEvent occurs.
*
* @param e
* the GuitarHeroInsertedEvent.
*/
void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent e);
/**
* This is the method called when a GuitarHeroRemovedEvent occurs.
*
* @param e
* the GuitarHeroRemovedEvent.
*/
void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent e);
/**
* This is the method called when a ClassicControllerInsertedEvent occurs.
*
* @param e
* the ClassicControllerInsertedEvent.
*/
void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent e);
/**
* This is the method called when a ClassicControllerRemovedEvent occurs.
*
* @param e
* the ClassicControllerRemovedEvent.
*/
void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent e);
}

46
java/src/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerInsertedEvent.java Normal file
View File

@@ -0,0 +1,46 @@
/**
* 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.wiiusejevents.wiiuseapievents;
/**
* Event that represents the connection of a classic controller to a wiimote.
*
* @author guiguito
*
*/
public class ClassicControllerInsertedEvent extends WiiUseApiEvent {
/**
* Construct the ClassicControllerInsertedEvent setting up the id.
*
* @param id
* id of the wiimote.
*/
public ClassicControllerInsertedEvent(int id) {
super(id, WIIUSE_CLASSIC_CTRL_INSERTED);
}
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** CLASSIC CONTROLLER INSERTED EVENT : WIIMOTE ID :"
+ super.getWiimoteId() + " ********/\n";
return out;
}
}

47
java/src/wiiusej/wiiusejevents/wiiuseapievents/ClassicControllerRemovedEvent.java Normal file
View File

@@ -0,0 +1,47 @@
/**
* 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.wiiusejevents.wiiuseapievents;
/**
* Event that represents the disconnection of a classic controller from a
* wiimote.
*
* @author guiguito
*
*/
public class ClassicControllerRemovedEvent extends WiiUseApiEvent {
/**
* Construct the ClassicControllerRemovedEvent setting up the id.
*
* @param id
* id of the wiimote.
*/
public ClassicControllerRemovedEvent(int id) {
super(id, WIIUSE_CLASSIC_CTRL_REMOVED);
}
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** CLASSIC CONTROLLER REMOVED EVENT : WIIMOTE ID :"
+ super.getWiimoteId() + " ********/\n";
return out;
}
}

45
java/src/wiiusej/wiiusejevents/wiiuseapievents/DisconnectionEvent.java Normal file
View File

@@ -0,0 +1,45 @@
/**
* 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.wiiusejevents.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;
}
}

47
java/src/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroInsertedEvent.java Normal file
View File

@@ -0,0 +1,47 @@
/**
* 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.wiiusejevents.wiiuseapievents;
/**
* Event that represents the connection of a Guitar hero controller to a
* wiimote.
*
* @author guiguito
*
*/
public class GuitarHeroInsertedEvent extends WiiUseApiEvent {
/**
* Construct the GuitarHeroInsertedEvent setting up the id.
*
* @param id
* id of the wiimote.
*/
public GuitarHeroInsertedEvent(int id) {
super(id, WIIUSE_GUITAR_HERO_3_CTRL_INSERTED);
}
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** GUITAR HERO INSERTED EVENT : WIIMOTE ID :"
+ super.getWiimoteId() + " ********/\n";
return out;
}
}

47
java/src/wiiusej/wiiusejevents/wiiuseapievents/GuitarHeroRemovedEvent.java Normal file
View File

@@ -0,0 +1,47 @@
/**
* 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.wiiusejevents.wiiuseapievents;
/**
* Event that represents the disconnection of a guitar hero controller from a
* wiimote.
*
* @author guiguito
*
*/
public class GuitarHeroRemovedEvent extends WiiUseApiEvent {
/**
* Construct the GuitarHeroRemovedEvent setting up the id.
*
* @param id
* id of the wiimote.
*/
public GuitarHeroRemovedEvent(int id) {
super(id, WIIUSE_GUITAR_HERO_3_CTRL_REMOVED);
}
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** GUITAR HERO REMOVED EVENT : WIIMOTE ID :"
+ super.getWiimoteId() + " ********/\n";
return out;
}
}

51
java/src/wiiusej/wiiusejevents/wiiuseapievents/NunchukInsertedEvent.java Normal file
View File

@@ -0,0 +1,51 @@
/**
* 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.wiiusejevents.wiiuseapievents;
/**
* Event that represents the connection of a nunchuk to a wiimote.
*
* @author guiguito
*
*/
public class NunchukInsertedEvent extends WiiUseApiEvent {
/**
* Construct the NunchukInsertedEvent setting up the id.
*
* @param id
* id of the wiimote.
*/
public NunchukInsertedEvent(int id) {
super(id, WIIUSE_NUNCHUK_INSERTED);
}
/*
* (non-Javadoc)
*
* @see wiiusej.wiiusejevents.WiiUseApiEvent#toString()
*/
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** NUNCHUK INSERTED EVENT : WIIMOTE ID :"
+ super.getWiimoteId() + " ********/\n";
return out;
}
}

50
java/src/wiiusej/wiiusejevents/wiiuseapievents/NunchukRemovedEvent.java Normal file
View File

@@ -0,0 +1,50 @@
/**
* 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.wiiusejevents.wiiuseapievents;
/**
* Event that represents the disconnection of a nunchuk from a wiimote.
*
* @author guiguito
*/
public class NunchukRemovedEvent extends WiiUseApiEvent {
/**
* Construct the NunchukInsertedEvent setting up the id.
*
* @param id
* id of the wiimote.
*/
public NunchukRemovedEvent(int id) {
super(id, WIIUSE_NUNCHUK_REMOVED);
}
/*
* (non-Javadoc)
*
* @see wiiusej.wiiusejevents.WiiUseApiEvent#toString()
*/
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** NUNCHUK REMOVED EVENT : WIIMOTE ID :"
+ super.getWiimoteId() + " ********/\n";
return out;
}
}

293
java/src/wiiusej/wiiusejevents/wiiuseapievents/StatusEvent.java Normal file
View File

@@ -0,0 +1,293 @@
/**
* 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.wiiusejevents.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 {
protected static short WIIMOTE_LED_1 = 1;
protected static short WIIMOTE_LED_2 = 2;
protected static short WIIMOTE_LED_3 = 4;
protected 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;
}
/**
* Tells if the given led is turned on according to the leds status int.
*
* @param led
* the int encoding a led.
* @return true if the led is turned on false otherwise.
*/
private boolean ledStatusCheck(short led) {
if ((leds & led) > 0) {
return true;
} else {
return false;
}
}
/**
* Get led1 status.
*
* @return true if the led is set.
*/
public boolean isLed1Set() {
return ledStatusCheck(WIIMOTE_LED_1);
}
/**
* Get led2 status.
*
* @return true if the led is set.
*/
public boolean isLed2Set() {
return ledStatusCheck(WIIMOTE_LED_2);
}
/**
* Get led3 status.
*
* @return true if the led is set.
*/
public boolean isLed3Set() {
return ledStatusCheck(WIIMOTE_LED_3);
}
/**
* Get led4 status.
*
* @return true if the led is set.
*/
public boolean isLed4Set() {
return ledStatusCheck(WIIMOTE_LED_4);
}
/**
* 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;
}
/**
* Tells if an attachment is connected.
*
* @return true if anything is connected to the wiimote false otherwise.
*/
public boolean isAttachmentConnected() {
return attachment == EXP_NONE;
}
/**
* Tells if a nunchuk is connected.
*
* @return true if a nunchuk is connected to the wiimote false otherwise.
*/
public boolean isNunchukConnected() {
return attachment == EXP_NUNCHUK;
}
/**
* Tells if a classic controller is connected.
*
* @return true if a classic controller is connected to the wiimote false otherwise.
*/
public boolean isClassicControllerConnected() {
return attachment == EXP_CLASSIC;
}
/**
* Tells if a guitar hero controller is connected.
*
* @return true if a guitar hero controllerr is connected to the wiimote false otherwise.
*/
public boolean isGuitarHeroConnected() {
return attachment == EXP_GUITAR_HERO_3;
}
@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;
}
}

66
java/src/wiiusej/wiiusejevents/wiiuseapievents/WiiUseApiEvent.java Normal file
View File

@@ -0,0 +1,66 @@
/**
* 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.wiiusejevents.wiiuseapievents;
import wiiusej.wiiusejevents.GenericEvent;
/**
* This class describes the structure of an event from the WiiUse API event.
*
* @author guiguito
*/
public abstract class WiiUseApiEvent extends GenericEvent{
public static int NONE_EVENT = 0;
public static int GENERIC_EVENT = 1;
public static int STATUS_EVENT = 2;
public static int DISCONNECTION_EVENT = 3;
public static int WIIUSE_READ_DATA = 4;
public static int WIIUSE_NUNCHUK_INSERTED = 5;
public static int WIIUSE_NUNCHUK_REMOVED = 6;
public static int WIIUSE_CLASSIC_CTRL_INSERTED = 7;
public static int WIIUSE_CLASSIC_CTRL_REMOVED = 8;
public static int WIIUSE_GUITAR_HERO_3_CTRL_INSERTED = 9;
public static int WIIUSE_GUITAR_HERO_3_CTRL_REMOVED = 10;
/* 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();
}

441
java/src/wiiusej/wiiusejevents/wiiuseapievents/WiimoteEvent.java Normal file
View File

@@ -0,0 +1,441 @@
/**
* 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.wiiusejevents.wiiuseapievents;
import wiiusej.wiiusejevents.physicalevents.ClassicControllerEvent;
import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
import wiiusej.wiiusejevents.physicalevents.GuitarHeroEvent;
import wiiusej.wiiusejevents.physicalevents.IREvent;
import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
import wiiusej.wiiusejevents.physicalevents.NunchukEvent;
import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
/**
* Class that is a bean to be filled by the wiiuse API on an event that occurs
* on a wiimote.
*
* @author guiguito
*/
public class WiimoteEvent extends WiiUseApiEvent {
private WiimoteButtonsEvent buttonsEvent = null;
private IREvent infraredEvent = null;
private MotionSensingEvent motionSensingEvent = null;
private ExpansionEvent expansionEvent = null;
/**
* Construct the Wiimote setting up the id.
*
* @param id
* the Wiimote id
*/
public WiimoteEvent(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 WiimoteEvent(int id, short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld) {
super(id, WiiUseApiEvent.GENERIC_EVENT);
buttonsEvent = new WiimoteButtonsEvent(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;
}
/**
* Tell if there is an expansion Event.
*
* @return TRUE if there is an expansion event.
*/
public boolean isThereExpansionEvent() {
return expansionEvent != null;
}
/**
* Get buttons event.
*
* @return the buttons event.
*/
public WiimoteButtonsEvent getButtonsEvent() {
return buttonsEvent;
}
/**
* Get the IR event.
*
* @return the IR event if there is one or null.
*/
public IREvent getIREvent() {
return infraredEvent;
}
/**
* Get the motion sensing event.
*
* @return the motion sensing event if there is one or null.
*/
public MotionSensingEvent getMotionSensingEvent() {
return motionSensingEvent;
}
/**
* Get the expansion event.
*
* @return the expansion event if there is one or null.
*/
public ExpansionEvent getExpansionEvent() {
return expansionEvent;
}
/**
* 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.
* @param irSensitivity
* Sensitivity of the infrared camera.
* @param distance
* Pixel Distance between first two dots
*/
public void prepareIRevent(int x, int y, float z, int ax, int ay,
int xVRes, int yVRes, int xOffset, int yOffset,
short sensorBarPostion, short screenAsPectRatio,
short irSensitivity, float distance) {
if (infraredEvent == null) {
infraredEvent = new IREvent(getWiimoteId(), x, y, z, ax, ay, xVRes,
yVRes, xOffset, yOffset, sensorBarPostion,
screenAsPectRatio, irSensitivity, distance);
}
}
/**
* 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 ar
* absolute roll.
* @param ap
* absolute pitch.
* @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 ar, float ap,
float x, float y, float z, short xx, short yy, short zz) {
motionSensingEvent = new MotionSensingEvent(getWiimoteId(),
orientationThreshold, accelerationThreshold, smoothingState,
alphaSmooth, r, p, ya, ar, ap, x, y, z, xx, yy, zz);
}
/**
* Set a NunchukEvent for the expansion event.
*
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @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 ar
* absolute roll.
* @param ap
* absolute pitch.
* @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.
* @param angle
* angle the joystick is being held.
* @param magnitude
* magnitude of the joystick (range 0-1).
* @param max1
* maximum joystick value 1.
* @param max2
* maximum joystick value 2.
* @param min1
* minimum joystick value 1.
* @param min2
* minimum joystick value 2.
* @param center1
* center joystick value 1.
* @param center2
* center joystick value 2.
*/
public void setNunchukEvent(short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld,
float orientationThreshold, int accelerationThreshold,
boolean smoothingState, float alphaSmooth, float r, float p,
float ya, float ar, float ap, float x, float y, float z, short xx,
short yy, short zz, float angle, float magnitude, short max1,
short max2, short min1, short min2, short center1, short center2) {
expansionEvent = new NunchukEvent(getWiimoteId(), buttonsJustPressed,
buttonsJustReleased, buttonsHeld, orientationThreshold,
accelerationThreshold, smoothingState, alphaSmooth, r, p, ya,
ar, ap, x, y, z, xx, yy, zz, angle, magnitude, max1, max2,
min1, min2, center1, center2);
}
/**
* Set a ClassicControllerEvent for the expansionEvent.
*
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @param rightShoulder
* right shoulder button (range 0-1).
* @param leftShoulder
* left shoulder button (range 0-1).
* @param langle
* angle the left joystick is being held.
* @param lmagnitude
* magnitude of the left joystick (range 0-1).
* @param lmax1
* maximum left joystick value 1.
* @param lmax2
* maximum left joystick value 2.
* @param lmin1
* minimum left joystick value 1.
* @param lmin2
* minimum left joystick value 2.
* @param lcenter1
* center left joystick value 1.
* @param lcenter2
* center left joystick value 2.
* @param rangle
* angle the right joystick is being held.
* @param rmagnitude
* magnitude of the right joystick (range 0-1).
* @param rmax1
* maximum right joystick value 1.
* @param rmax2
* maximum right joystick value 2.
* @param rmin1
* minimum right joystick value 1.
* @param rmin2
* minimum right joystick value 2.
* @param rcenter1
* center right joystick value 1.
* @param rcenter2
* center right joystick value 2.
*/
public void setClassicControllerEvent(short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld, float rightShoulder,
float leftShoulder, float langle, float lmagnitude, short lmax1,
short lmax2, short lmin1, short lmin2, short lcenter1,
short lcenter2, float rangle, float rmagnitude, short rmax1,
short rmax2, short rmin1, short rmin2, short rcenter1,
short rcenter2) {
expansionEvent = new ClassicControllerEvent(getWiimoteId(),
buttonsJustPressed, buttonsJustReleased, buttonsHeld,
rightShoulder, leftShoulder, langle, lmagnitude, lmax1, lmax2,
lmin1, lmin2, lcenter1, lcenter2, rangle, rmagnitude, rmax1,
rmax2, rmin1, rmin2, rcenter1, rcenter2);
}
/**
* Set a GuitarHeroEvent for the expansionEvent.
*
* @param buttonsJustPressed
* buttons just pressed.
* @param buttonsJustReleased
* buttons just released.
* @param buttonsHeld
* buttons just pressed.
* @param whammyBar
* whammy bar (range 0-1).
* @param angle
* angle the joystick is being held.
* @param magnitude
* magnitude of the joystick (range 0-1).
* @param max1
* maximum joystick value 1.
* @param max2
* maximum joystick value 2.
* @param min1
* minimum joystick value 1.
* @param min2
* minimum joystick value 2.
* @param center1
* center joystick value 1.
* @param center2
* center joystick value 2.
*/
public void setGuitarHeroEvent(short buttonsJustPressed,
short buttonsJustReleased, short buttonsHeld, float whammyBar,
float angle, float magnitude, short max1, short max2, short min1,
short min2, short center1, short center2) {
expansionEvent = new GuitarHeroEvent(getWiimoteId(),
buttonsJustPressed, buttonsJustReleased, buttonsHeld,
whammyBar, angle, magnitude, max1, max2, min1, min2, center1,
center2);
}
@Override
public String toString() {
String out = "";
/* Status */
out += "/*********** GENERIC EVENT : WIIMOTE ID :" + 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";
}
if (expansionEvent != null) {
out += expansionEvent;
} else {
out += "/******** Expansion ********/\n";
out += "--- No expansion connected \n";
}
return out;
}
}