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

Move files from core.mimis to relevant subprojects

Browse Source
This commit is contained in:
Rik Veenboer
2016-07-11 22:18:05 +01:00
parent c8e113cdfb
commit 60b10632d5
55 changed files with 59 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
java/core.mimis/src/main/java/mimis/application/cmd/CMDApplication.java
View File

@@ -1,95 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.cmd;
import java.io.IOException;
import java.util.Map;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import mimis.Component;
import mimis.application.Application;
import mimis.util.Native;
import mimis.value.Registry;
public abstract class CMDApplication extends Component implements Application {
protected final static Registry REGISTRY = Registry.LOCAL_MACHINE;
protected final static String KEY = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths";
protected String program;
protected String title;
protected Process process;
protected boolean detect, running;
public CMDApplication(String program, String title) {
super(title);
this.program = program;
this.title = title;
detect = true;
}
public void activate() throws ActivateException {
detect = true;
if (!running) {
String path = getPath();
if (path == null) {
throw new ActivateException();
}
try {
String command = path.startsWith("\"") ? path : String.format("\"%s\"", path);
command = replaceVariables(command);
process = Runtime.getRuntime().exec(command);
} catch (IOException e) {
logger.error(e.getMessage());
throw new ActivateException();
}
}
super.activate();
}
public boolean active() {
if (detect) {
running = Native.isRunning(program);
if (!running) {
start();
}
}
return super.active();
}
public synchronized void deactivate() throws DeactivateException {
detect = false;
super.deactivate();
if (process != null) {
process.destroy();
}
}
public String getPath() {
String key = String.format("%s\\%s", KEY, program);
System.out.println(Native.getValue(REGISTRY, key));
return Native.getValue(REGISTRY, key);
}
public static String replaceVariables(String string) {
Map<String, String> env = System.getenv();
for (String key : env.keySet()) {
string = string.replace(String.format("%%%s%%", key), env.get(key));
}
return string;
}
}

113
java/core.mimis/src/main/java/mimis/application/cmd/windows/WindowsApplication.java
View File

@@ -1,113 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.cmd.windows;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import mimis.application.cmd.CMDApplication;
import mimis.util.Native;
import mimis.value.Command;
import mimis.value.Key;
import mimis.value.Type;
import mimis.value.Windows;
public abstract class WindowsApplication extends CMDApplication {
protected final static int TERMINATE_SLEEP = 500;
protected final static int START_SLEEP = 500;
protected String window;
protected int handle;
public WindowsApplication(String title, String window) {
this(null, title, window);
}
public WindowsApplication(String program, String title, String window) {
super(program, title);
this.window = window;
handle = 0;
}
public void activate() throws ActivateException {
if (program != null) {
super.activate();
}
handle = Native.getHandle(window);
if (handle < 1) {
sleep(START_SLEEP);
handle = Native.getHandle(window);
}
if (handle < 0) {
throw new ActivateException();
}
}
public boolean active() {
if (!super.active() || program == null) {
handle = Native.getHandle(window);
if (handle > 0 && program == null) {
start();
}
}
return program == null ? handle > 0 : super.active();
}
public void deactivate() throws DeactivateException {
if (process != null) {
close();
}
super.deactivate();
}
protected void close() {
Native.sendMessage(handle, Windows.WM_CLOSE, 0, 0);
}
protected void command(Command command) {
Native.sendMessage(handle, Windows.WM_APPCOMMAND, handle, command.getCode() << 16);
}
protected void command(int command) {
Native.sendMessage(handle, Windows.WM_COMMAND, command, 0);
}
protected int user(int wParam, int lParam) {
return Native.sendMessage(handle, Windows.WM_USER, wParam, lParam);
}
protected void system(Command.System system) {
system(system, 0);
}
protected void system(Command.System system, int lParam) {
Native.sendMessage(handle, Windows.WM_SYSCOMMAND, system.getCode(), lParam);
}
protected void key(Type type, int code) {
int scanCode = Native.mapVirtualKey(code, Windows.MAPVK_VK_TO_VSC);
Native.postMessage(handle, type.getCode(), code, 1 | (scanCode << 16) | 1 << 30);
sleep(200);
}
protected void key(Type type, char character) {
key(type, (int) Character.toUpperCase(character));
}
protected void key(Type key, Key virtualKey) {
key(key, virtualKey.getCode());
}
}

147
java/core.mimis/src/main/java/mimis/application/cmd/windows/gomplayer/GomPlayerApplication.java
View File

@@ -1,147 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.cmd.windows.gomplayer;
import mimis.application.cmd.windows.WindowsApplication;
import mimis.value.Action;
import mimis.value.Amount;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import base.work.Work;
public class GomPlayerApplication extends WindowsApplication {
protected final static String PROGRAM = "GOM.exe";
protected final static String TITLE = "GOM Player";
protected final static String WINDOW = "GomPlayer1.x";
protected static final int VOLUME_SLEEP = 100;
protected static final int SEEK_SLEEP = 100;
protected VolumeWork volumeWork;
protected SeekWork seekWork;
public GomPlayerApplication() {
super(PROGRAM, TITLE, WINDOW);
volumeWork = new VolumeWork();
seekWork = new SeekWork();
}
public void deactivate() throws DeactivateException {
super.deactivate();
volumeWork.stop();
seekWork.stop();
}
public void exit() {
super.exit();
volumeWork.exit();
seekWork.exit();
}
public void begin(Action action) {
logger.trace("GomPlayerApplication begin: " + action);
switch (action) {
case VOLUME_UP:
volumeWork.start();
break;
case VOLUME_DOWN:
volumeWork.start();
break;
case FORWARD:
seekWork.start(Amount.SMALL, 1);
break;
case REWIND:
seekWork.start(Amount.SMALL, -1);
break;
case NEXT:
seekWork.start(Amount.MEDIUM, 1);
break;
case PREVIOUS:
seekWork.start(Amount.MEDIUM, -1);
break;
default:
break;
}
}
public void end(Action action) {
logger.trace("GomPlayerApplication end: " + action);
switch (action) {
case PLAY:
command(0x800C);
break;
case MUTE:
command(0x8016);
break;
case FORWARD:
case REWIND:
case NEXT:
case PREVIOUS:
seekWork.stop();
break;
case VOLUME_UP:
case VOLUME_DOWN:
volumeWork.stop();
break;
case FULLSCREEN:
command(0x8154);
break;
default:
break;
}
}
protected class VolumeWork extends Work {
protected int volumeChangeSign;
public void start(int volumeChangeSign) throws ActivateException {
super.start();
this.volumeChangeSign = volumeChangeSign;
}
public void work() {
command(volumeChangeSign > 0 ? 0x8014 : 0x8013);
sleep(VOLUME_SLEEP);
}
};
protected class SeekWork extends Work {
protected Amount amount;
protected int seekDirection;
public void start(Amount amount, int seekDirection) {
super.start();
this.amount = amount;
this.seekDirection = seekDirection;
}
public void work() {
switch (amount) {
case SMALL:
command(seekDirection > 0 ? 0x8009 : 0x8008);
break;
case MEDIUM:
command(seekDirection > 0 ? 0x800B : 0x800A);
break;
case LARGE:
command(seekDirection > 0 ? 0x8012 : 0x8011);
break;
}
sleep(SEEK_SLEEP);
}
};
}

130
java/core.mimis/src/main/java/mimis/application/cmd/windows/photoviewer/PhotoViewerApplication.java
View File

@@ -1,130 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.cmd.windows.photoviewer;
import mimis.application.cmd.windows.WindowsApplication;
import mimis.value.Action;
import mimis.value.Key;
import mimis.value.Type;
import base.exception.worker.DeactivateException;
import base.work.Work;
public class PhotoViewerApplication extends WindowsApplication {
protected final static String TITLE = "Photo Viewer";
protected final static String WINDOW = "Photo_Lightweight_Viewer";
protected static final int ZOOM_SLEEP = 100;
protected static final int DELETE_SLEEP = 2000;
protected ZoomWork zoomWork;
protected boolean fullscreen;
public PhotoViewerApplication() {
super(TITLE, WINDOW);
zoomWork = new ZoomWork();
fullscreen = false;
}
public void deactivate() throws DeactivateException {
super.deactivate();
zoomWork.stop();
}
public void exit() {
super.exit();
zoomWork.exit();
}
public void begin(Action action) {
switch (action) {
case VOLUME_UP:
zoomWork.start(1);
break;
case VOLUME_DOWN:
zoomWork.start(-1);
break;
default:
break;
}
}
public void end(Action action) {
logger.trace("PhotoViewerApplication end: " + action);
switch (action) {
case VOLUME_UP:
case VOLUME_DOWN:
zoomWork.stop();
break;
case NEXT:
key(Type.DOWN, Key.RIGHT);
break;
case PREVIOUS:
key(Type.DOWN, Key.LEFT);
break;
case FORWARD:
key(Type.DOWN, Key.CONTROL);
//key(Type.DOWN, '.');
//key(Type.DOWN, Key.DECIMAL);
key(Type.DOWN, Key.OEM_PERIOD);
//key(Type.UP, Key.OEM_PERIOD);
//key(Type.UP, Key.CONTROL);
break;
case MUTE:
key(Type.DOWN, Key.CONTROL);
key(Type.DOWN, Key.NUMPAD0);
//press(Key.CONTROL);
//press(Key.NUMPAD0);
//release(Key.CONTROL);
break;
case FULLSCREEN:
key(Type.DOWN, fullscreen ? Key.ESCAPE : Key.F11);
fullscreen = !fullscreen;
break;
case DISLIKE:
/*boolean restore = false;
if (fullscreen) {
end(Action.FULLSCREEN);
sleep(DELETE_SLEEP);
restore = true;
}
key(Type.DOWN, Key.F16);
key(Type.DOWN, 'Y');
if (restore) {
sleep(DELETE_SLEEP);
end(Action.FULLSCREEN);
}*/
break;
default:
break;
}
}
protected class ZoomWork extends Work {
protected int zoomDirection;
public void start(int zoomDirection) {
super.start();
this.zoomDirection = zoomDirection;
}
public void work() {
Key key = zoomDirection > 0 ? Key.ADD : Key.SUBTRACT;
key(Type.DOWN, key);
sleep(ZOOM_SLEEP);
}
}
}

201
java/core.mimis/src/main/java/mimis/application/cmd/windows/winamp/WinampApplication.java
View File

@@ -1,201 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.cmd.windows.winamp;
import mimis.application.cmd.windows.WindowsApplication;
import mimis.value.Action;
import mimis.value.Command;
import base.exception.worker.DeactivateException;
import base.work.Work;
public class WinampApplication extends WindowsApplication {
protected final static String PROGRAM = "winamp.exe";
protected final static String TITLE = "Winamp";
protected final static String WINDOW = "Winamp v1.x";
protected final static int STATUS_PLAYING = 1;
protected final static int STATUS_PAUSED = 3;
protected final static int STATUS_STOPPED = 0;
protected final static int IPC_ISPLAYING = 104;
protected final static int IPC_GETOUTPUTTIME = 105;
protected final static int IPC_SETVOLUME = 122;
protected final static int WINAMP_FILE_QUIT = 40001;
protected final static int WINAMP_FILE_REPEAT = 40022;
protected final static int WINAMP_FILE_SHUFFLE = 40023;
protected final static int WINAMP_BUTTON1 = 40044;
protected final static int WINAMP_BUTTON2 = 40045;
protected final static int WINAMP_BUTTON3 = 40046;
protected final static int WINAMP_BUTTON5 = 40048;
protected final static int WINAMP_VOLUMEUP = 40058;
protected final static int WINAMP_VOLUMEDOWN = 40059;
protected final static int WINAMP_FFWD5S = 40060;
protected final static int WINAMP_REW5S = 40061;
protected final static int WINAMP_BUTTON4_SHIFT = 40147;
protected final static int WINAMP_VISPLUGIN = 40192;
protected static final int VOLUME_SLEEP = 50;
protected static final int SEEK_SLEEP = 100;
protected VolumeWork volumeWork;
protected SeekWork seekWork;
protected double volume;
protected boolean muted;
public WinampApplication() {
super(PROGRAM, TITLE, WINDOW);
volume = getVolume();
muted = volume == 0;
volumeWork = new VolumeWork();
seekWork = new SeekWork();
}
public void deactivate() throws DeactivateException {
super.deactivate();
volumeWork.stop();
seekWork.stop();
}
public void exit() {
super.exit();
volumeWork.exit();
seekWork.exit();
}
public void begin(Action action) {
logger.trace("WinampApplication begin: " + action);
switch (action) {
case VOLUME_UP:
volumeWork.start(1);
break;
case VOLUME_DOWN:
volumeWork.start(-1);
break;
case FORWARD:
seekWork.start(1);
break;
case REWIND:
seekWork.start(-1);
break;
default:
break;
}
}
public void end(Action action) {
logger.trace("WinampApplication end: " + action);
switch (action) {
case PLAY:
logger.debug("play");
switch (user(0, IPC_ISPLAYING)) {
case STATUS_STOPPED:
command(WINAMP_BUTTON2);
break;
default:
command(WINAMP_BUTTON3);
break;
}
break;
case NEXT:
command(WINAMP_BUTTON5);
break;
case PREVIOUS:
command(WINAMP_BUTTON1);
break;
case FORWARD:
case REWIND:
seekWork.stop();
break;
case MUTE:
if (muted) {
setVolume(volume);
} else {
volume = getVolume();
setVolume(0);
}
muted = !muted;
break;
case VOLUME_UP:
case VOLUME_DOWN:
volumeWork.stop();
break;
case SHUFFLE:
command(WINAMP_FILE_SHUFFLE);
break;
case REPEAT:
command(WINAMP_FILE_REPEAT);
break;
case FADEOUT:
command(WINAMP_BUTTON4_SHIFT);
break;
case QUIT:
command(WINAMP_FILE_QUIT);
break;
case VISUALISER:
system(Command.System.MAXIMIZE);
command(WINAMP_VISPLUGIN);
break;
default:
break;
}
}
public double getVolume() {
return user(-666, IPC_SETVOLUME) / 255f;
}
public void setVolume(double volume) {
user((int) Math.ceil(volume * 255), IPC_SETVOLUME);
}
public int getDuration() {
return user(1, IPC_GETOUTPUTTIME);
}
public int getElapsed() {
return user(0, IPC_GETOUTPUTTIME) / 1000;
}
protected class VolumeWork extends Work {
protected int volumeChangeSign;
public void start(int volumeChangeSign) {
super.start();
this.volumeChangeSign = volumeChangeSign;
}
public void work() {
command(volumeChangeSign > 0 ? WINAMP_VOLUMEUP : WINAMP_VOLUMEDOWN);
sleep(VOLUME_SLEEP);
}
};
protected class SeekWork extends Work {
protected int seekDirection;
public void start(int seekDirection) {
super.start();
this.seekDirection = seekDirection;
}
public void work() {
command(seekDirection > 0 ? WINAMP_FFWD5S : WINAMP_REW5S);
sleep(SEEK_SLEEP);
}
};
}

106
java/core.mimis/src/main/java/mimis/application/cmd/windows/wmp/WMPApplication.java
View File

@@ -1,106 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.cmd.windows.wmp;
import mimis.application.cmd.windows.WindowsApplication;
import mimis.value.Action;
import base.work.Work;
public class WMPApplication extends WindowsApplication {
protected final static String PROGRAM = "wmplayer.exe";
protected final static String TITLE = "Windows Media Player";
protected final static String WINDOW = "WMPlayerApp";
protected static final int VOLUME_SLEEP = 120;
protected VolumeWork volumeWork;
public WMPApplication() {
super(PROGRAM, TITLE, WINDOW);
volumeWork = new VolumeWork();
}
public void begin(Action action) {
logger.trace("WMPApplication begin: " + action);
switch (action) {
case PLAY:
command(18808);
break;
case NEXT:
command(18811);
break;
case PREVIOUS:
command(18810);
break;
case FORWARD:
command(18813);
break;
case REWIND:
command(18812);
break;
case MUTE:
command(18817);
break;
case VOLUME_UP:
volumeWork.start(1);
break;
case VOLUME_DOWN:
volumeWork.start(-1);
break;
case SHUFFLE:
command(18842);
break;
case REPEAT:
command(18843);
break;
default:
break;
}
}
public void end(Action action) {
logger.trace("WMPApplication end: " + action);
switch (action) {
case FORWARD:
command(18813);
break;
case REWIND:
command(18812);
break;
case VOLUME_UP:
case VOLUME_DOWN:
volumeWork.stop();
break;
default:
break;
}
}
protected class VolumeWork extends Work {
protected int volumeChangeSign;
public void start(int volumeChangeSign) {
super.start();
this.volumeChangeSign = volumeChangeSign;
}
public void work() {
command (volumeChangeSign > 0 ? 18815 : 18816);
sleep(VOLUME_SLEEP);
}
};
}

122
java/core.mimis/src/main/java/mimis/application/mpc/MPCApplication.java
View File

@@ -1,122 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.mpc;
import mimis.application.cmd.windows.WindowsApplication;
import mimis.value.Action;
import base.work.Work;
public class MPCApplication extends WindowsApplication {
protected final static String PROGRAM = "mpc-hc.exe";
protected final static String TITLE = "Media Player Classic";
protected final static String WINDOW = "MediaPlayerClassicW";
protected static final int VOLUME_SLEEP = 50;
protected static final int SEEK_SLEEP = 50;
protected VolumeWork volumeWork;
protected SeekWork seekWork;
public MPCApplication() {
super(PROGRAM, TITLE, WINDOW);
volumeWork = new VolumeWork();
seekWork = new SeekWork();
}
public void begin(Action action) {
logger.trace("MPCApplication: " + action);
switch (action) {
case FORWARD:
seekWork.start(1);
break;
case REWIND:
seekWork.start(-1);
break;
case VOLUME_UP:
volumeWork.start(1);
break;
case VOLUME_DOWN:
volumeWork.start(-1);
break;
default:
break;
}
}
public void end(Action action) {
logger.trace("MPCApplication: " + action);
switch (action) {
case PLAY:
command(889);
break;
case NEXT:
command(921);
break;
case PREVIOUS:
command(920);
break;
case FORWARD:
case REWIND:
seekWork.stop();
break;
case MUTE:
command(909);
break;
case VOLUME_UP:
case VOLUME_DOWN:
volumeWork.stop();
break;
case FULLSCREEN:
command(830);
break;
default:
break;
}
}
public String getTitle() {
return TITLE;
}
protected class VolumeWork extends Work {
protected int volumeChangeSign;
public void start(int volumeChangeSign) {
super.start();
this.volumeChangeSign = volumeChangeSign;
}
public void work() {
command(volumeChangeSign > 0 ? 907 : 908);
sleep(VOLUME_SLEEP);
}
}
protected class SeekWork extends Work {
protected int seekDirection;
public void start(int seekDirection) {
super.start();
this.seekDirection = seekDirection;
}
public void work() {
command(seekDirection > 0 ? 900 : 889);
sleep(SEEK_SLEEP);
}
};
}

51
java/core.mimis/src/main/java/mimis/application/robot/RobotApplication.java
View File

@@ -1,51 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.robot;
import java.awt.AWTException;
import java.awt.Robot;
import base.exception.worker.ActivateException;
import mimis.Component;
import mimis.value.Key;
public class RobotApplication extends Component {
protected Robot robot;
public void activate() throws ActivateException {
try {
robot = new Robot();
robot.setAutoWaitForIdle(true);
} catch (AWTException e) {
logger.error("", e);
throw new ActivateException();
}
super.activate();
}
public void press(Key key) {
robot.keyPress(key.getCode());
}
public void press(char key) {
robot.keyPress(key);
}
public void release(Key key) {
robot.keyRelease(key.getCode());
}
}

218
java/core.mimis/src/main/java/mimis/application/vlc/VLCApplication.java
View File

@@ -1,218 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.application.vlc;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import mimis.application.cmd.CMDApplication;
import mimis.util.Native;
import mimis.value.Action;
import mimis.value.Amount;
import mimis.value.Registry;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import base.work.Work;
public class VLCApplication extends CMDApplication {
protected final static Registry REGISTRY = Registry.CLASSES_ROOT;
protected final static String KEY = "Applications\\vlc.exe\\shell\\Open\\command";
protected final static String PROGRAM = "vlc.exe";
protected final static String TITLE = "VLC media player";
protected static final int POSTION_CHANGE_RATE = 1;
protected static final int VOLUME_CHANGE_RATE = 20;
protected static final String HOST = "localhost";
protected static final int PORT = 8080;
protected static final int VOLUME_SLEEP = 100;
protected static final int SEEK_SLEEP = 100;
protected VolumeWork volumeWorker;
protected SeekWork seekWorker;
protected int volume = 255;
protected boolean muted = false;
public VLCApplication() {
super(PROGRAM, TITLE);
volumeWorker = new VolumeWork();
seekWorker = new SeekWork();
}
public String getPath() {
Pattern pattern = Pattern.compile("\"([^\"]+)\"");
Matcher matcher = pattern.matcher(Native.getValue(REGISTRY, KEY));
return matcher.find() ? matcher.group(1) : null;
}
public void command(String command) {
String request = String.format("http://%s:%d/requests/status.xml?command=%s", HOST, PORT, command);
try {
URL url = new URL(request);
HttpURLConnection httpUrlConnection = (HttpURLConnection) url.openConnection();
int response = httpUrlConnection.getResponseCode();
logger.trace("Response: " + response);
} catch (MalformedURLException e) {
logger.error("", e);
} catch (IOException e) {
logger.error("", e);
}
}
public void deactivate() throws DeactivateException {
super.deactivate();
volumeWorker.stop();
seekWorker.stop();
Native.terminate(program);
}
public void exit() {
super.exit();
volumeWorker.exit();
seekWorker.exit();
}
public void begin(Action action) {
logger.trace("VLCApplication begin: " + action);
try {
switch (action) {
case VOLUME_UP:
volumeWorker.activate("+");
break;
case VOLUME_DOWN:
volumeWorker.activate("-");
break;
case FORWARD:
seekWorker.start(Amount.SMALL, "+");
break;
case REWIND:
seekWorker.start(Amount.SMALL, "-");
break;
default:
break;
}
} catch (ActivateException e) {
logger.error("", e);
}
}
public void end(Action action) {
logger.trace("VLCApplication end: " + action);
switch (action) {
case PLAY:
command("pl_pause");
break;
case PAUSE:
command("pl_pause");
break;
case NEXT:
command("pl_next");
break;
case PREVIOUS:
command("pl_previous");
break;
case FORWARD:
case REWIND:
seekWorker.stop();
break;
case MUTE:
command("volume&val=" + toggleMute());
break;
case VOLUME_UP:
case VOLUME_DOWN:
volumeWorker.stop();
break;
case SHUFFLE:
command("command=pl_random");
break;
case REPEAT:
command("command=pl_repeat");
break;
default:
break;
}
}
protected void volumeUp() {
if (!muted) {
volume += VOLUME_CHANGE_RATE;
command("volume&val=+" + VOLUME_CHANGE_RATE);
}
}
protected void volumeDown() {
if (!muted) {
volume -= VOLUME_CHANGE_RATE;
command("volume&val=-" + VOLUME_CHANGE_RATE);
}
}
protected int toggleMute() {
return (muted = !muted) ? 0 : volume;
}
public String getTitle() {
return TITLE;
}
protected class VolumeWork extends Work {
protected String volumeChangeSign;
public void activate(String volumeChangeSign) throws ActivateException {
super.activate();
this.volumeChangeSign = volumeChangeSign;
}
public void work() {
volume += VOLUME_CHANGE_RATE;
command("volume&val=" + volumeChangeSign + VOLUME_CHANGE_RATE);
sleep(VOLUME_SLEEP);
}
};
protected class SeekWork extends Work {
protected Amount amount;
protected String seekDirection;
public void start(Amount amount, String seekDirection) {
super.start();
this.amount = amount;
this.seekDirection = seekDirection;
}
public void work() {
switch (amount) {
case SMALL:
command("command=seek&val=" + seekDirection + POSTION_CHANGE_RATE);
break;
case MEDIUM:
command("command=seek&val=" + seekDirection + POSTION_CHANGE_RATE * 2);
break;
case LARGE:
command("command=seek&val=" + seekDirection + POSTION_CHANGE_RATE * 3);
break;
}
sleep(SEEK_SLEEP);
}
};
}

55
java/core.mimis/src/main/java/mimis/device/javainput/DirectionButton.java
View File

@@ -1,55 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput;
import mimis.input.Button;
import mimis.exception.button.UnknownDirectionException;
import de.hardcode.jxinput.event.JXInputDirectionalEvent;
public enum DirectionButton implements Button {
NORTH (0),
NORTHEAST (45),
EAST (90),
SOUTHEAST (135),
SOUTH (180),
SOUTHWEST (225),
WEST (270),
NORTHWEST (315);
protected int code;
private DirectionButton(int code) {
this.code = code;
}
public int getCode() {
return code;
}
public static DirectionButton create(int angle) throws UnknownDirectionException {
for (DirectionButton button : DirectionButton.values()) {
if (button.getCode() == angle) {
return button;
}
}
throw new UnknownDirectionException();
}
public static DirectionButton create(JXInputDirectionalEvent event) throws UnknownDirectionException {
return create(event.getDirectional().getDirection() / 100);
}
}

291
java/core.mimis/src/main/java/mimis/device/javainput/JXInputTestDialog.java
View File

@@ -1,291 +0,0 @@
//**********************************************************************************************
// Dipl. Phys. Joerg Plewe, HARDCODE Development
// Created on 27. Dezember 2001, 01:15
//**********************************************************************************************
package mimis.device.javainput;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import de.hardcode.jxinput.Axis;
import de.hardcode.jxinput.Button;
import de.hardcode.jxinput.JXInputDevice;
import de.hardcode.jxinput.JXInputManager;
import de.hardcode.jxinput.keyboard.JXKeyboardInputDevice;
import de.hardcode.jxinput.test.JXInputDevicePanel;
import de.hardcode.jxinput.virtual.JXVirtualInputDevice;
import de.hardcode.jxinput.virtual.VirtualAxis;
/**
* Test dialog showing some features of JXInput.
* @author Herkules
*/
public class JXInputTestDialog extends javax.swing.JDialog
implements ActionListener
{
private JXKeyboardInputDevice mKeyboardDevice = null;
private JXVirtualInputDevice mVirtualDevice = null;
Button mButtonUp;
Button mButtonDown;
Button mButtonLeft;
Button mButtonRight;
Button mButtonFire;
Button mButtonSpace;
/** Creates new form JXInputTestDialog */
public JXInputTestDialog(java.awt.Frame parent, boolean modal)
{
super(parent, modal);
initComponents();
configureKeyboardInputDevice();
configureVirtualInputDevice();
initDevicePanels();
pack();
// Request the focus so that the keyboarddevice can work
mMainPanel.requestFocus();
new Timer( 50, this ).start();
// Uncomment this line as an alternative to the Timer above.
// Don't use both!!
//JXInputEventManager.setTriggerIntervall( 50 );
}
/**
* Implement ActionListener#actionPerformed().
* This is called by the Timer.
*/
public void actionPerformed( ActionEvent e )
{
JXInputManager.updateFeatures();
SwingUtilities.invokeLater(
new Runnable()
{
public void run()
{
for ( int i = 0; i < mDevicesTabbedPane.getComponentCount(); ++i )
{
((JXInputDevicePanel)mDevicesTabbedPane.getComponent( i )).update();
}
}
}
);
}
/**
* Configure a test JXKeyboardInputdevice.
*/
void configureKeyboardInputDevice()
{
mKeyboardDevice = JXInputManager.createKeyboardDevice();
mKeyboardDevice.createButton( KeyEvent.VK_ESCAPE );
mKeyboardDevice.createButton( KeyEvent.VK_F1 );
mKeyboardDevice.createButton( KeyEvent.VK_F2 );
mKeyboardDevice.createButton( KeyEvent.VK_F3 );
mKeyboardDevice.createButton( KeyEvent.VK_F4 );
mKeyboardDevice.createButton( KeyEvent.VK_LEFT );
mKeyboardDevice.createButton( KeyEvent.VK_RIGHT );
mKeyboardDevice.createButton( KeyEvent.VK_UP );
mKeyboardDevice.createButton( KeyEvent.VK_DOWN );
mKeyboardDevice.createButton( KeyEvent.VK_PAGE_UP );
mKeyboardDevice.createButton( KeyEvent.VK_PAGE_DOWN );
mButtonSpace = mKeyboardDevice.createButton( KeyEvent.VK_SPACE );
mButtonLeft = mKeyboardDevice.createButton( KeyEvent.VK_A );
mButtonRight = mKeyboardDevice.createButton( KeyEvent.VK_D );
mButtonDown = mKeyboardDevice.createButton( KeyEvent.VK_S );
mButtonUp = mKeyboardDevice.createButton( KeyEvent.VK_W );
// Configure it to make it listen to the main panel.
// I try to keep the kbd focus on it.
mKeyboardDevice.listenTo( mMainPanel );
}
/**
* Configure a test JXVirtualInputdevice.
*/
void configureVirtualInputDevice()
{
mVirtualDevice = JXInputManager.createVirtualDevice();
Button firebutton;
//
// Remember 'fire' button of first device for use
// in the virtual device.
// For we ran configureKeyboardInputDevice() before,
// getJXInputDevice( 0 ) should not return null
//
firebutton = JXInputManager.getJXInputDevice( 0 ).getButton( 0 );
VirtualAxis x = mVirtualDevice.createAxis( Axis.ID_X );
x.setButtons( mButtonRight, mButtonLeft );
x.setName( "x: A-D" );
VirtualAxis y = mVirtualDevice.createAxis( Axis.ID_Y );
y.setButtons( mButtonUp, mButtonDown );
y.setSpringSpeed( 0.0 );
y.setName( "y: S|W" );
VirtualAxis slider = mVirtualDevice.createAxis( Axis.ID_SLIDER0 );
slider.setIncreaseButton( mButtonSpace );
slider.setTimeFor0To1( 2000 );
slider.setName( "<space>" );
slider.setType( Axis.SLIDER );
if ( null != firebutton )
{
slider = mVirtualDevice.createAxis( Axis.ID_SLIDER1 );
slider.setIncreaseButton( firebutton );
slider.setTimeFor0To1( 2000 );
slider.setName( "JoyButton 0" );
}
}
/**
* Initialize one panel for each device available.
*/
void initDevicePanels()
{
int cnt = JXInputManager.getNumberOfDevices();
mLabelNoDevice.setVisible( cnt == 0 );
mDevicesTabbedPane.setVisible( cnt != 0 );
for ( int i = 0; i < cnt; ++i )
{
JXInputDevice dev = JXInputManager.getJXInputDevice( i );
if ( null != dev )
{
//
// Setup an own panel for each device.
//
JPanel panel = new JXInputDevicePanel( dev );
mDevicesTabbedPane.addTab( dev.getName(), panel );
}
}
}
/** 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()
{
mMainPanel = new javax.swing.JPanel();
mLabelNoDevice = new javax.swing.JLabel();
mDevicesTabbedPane = new javax.swing.JTabbedPane();
mButtonReset = new javax.swing.JButton();
setTitle("JXInput (C) 2001-2006 HARDCODE Dev.");
addWindowListener(new java.awt.event.WindowAdapter()
{
public void windowClosing(java.awt.event.WindowEvent evt)
{
closeDialog(evt);
}
});
mMainPanel.setLayout(new java.awt.BorderLayout(10, 0));
mLabelNoDevice.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
mLabelNoDevice.setText("No JXInputDevice available!");
mLabelNoDevice.setBorder(new javax.swing.border.SoftBevelBorder(javax.swing.border.BevelBorder.RAISED));
mMainPanel.add(mLabelNoDevice, java.awt.BorderLayout.NORTH);
mDevicesTabbedPane.addFocusListener(new java.awt.event.FocusAdapter()
{
public void focusGained(java.awt.event.FocusEvent evt)
{
mDevicesTabbedPaneFocusGained(evt);
}
});
mMainPanel.add(mDevicesTabbedPane, java.awt.BorderLayout.CENTER);
mButtonReset.setText("Reset ");
mButtonReset.addActionListener(new java.awt.event.ActionListener()
{
public void actionPerformed(java.awt.event.ActionEvent evt)
{
mButtonResetActionPerformed(evt);
}
});
mMainPanel.add(mButtonReset, java.awt.BorderLayout.SOUTH);
getContentPane().add(mMainPanel, java.awt.BorderLayout.CENTER);
pack();
}// </editor-fold>//GEN-END:initComponents
private void mButtonResetActionPerformed(java.awt.event.ActionEvent evt)//GEN-FIRST:event_mButtonResetActionPerformed
{//GEN-HEADEREND:event_mButtonResetActionPerformed
while ( this.mDevicesTabbedPane.getTabCount() > 0 )
this.mDevicesTabbedPane.removeTabAt( 0 );
JXInputManager.reset();
configureKeyboardInputDevice();
configureVirtualInputDevice();
initDevicePanels();
pack();
// Request the focus so that the keyboarddevice can work
mMainPanel.requestFocus();
}//GEN-LAST:event_mButtonResetActionPerformed
private void mDevicesTabbedPaneFocusGained(java.awt.event.FocusEvent evt)//GEN-FIRST:event_mDevicesTabbedPaneFocusGained
{//GEN-HEADEREND:event_mDevicesTabbedPaneFocusGained
// Switch focus back to main panel!
this.mMainPanel.requestFocus();
}//GEN-LAST:event_mDevicesTabbedPaneFocusGained
/** Closes the dialog */
private void closeDialog(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_closeDialog
setVisible(false);
dispose();
System.exit( 0 );
}//GEN-LAST:event_closeDialog
/**
* Allow the dialog to run standalone.
* @param args the command line arguments
*/
public static void main(String args[])
{
new JXInputTestDialog(new javax.swing.JFrame(), true).setVisible(true);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton mButtonReset;
private javax.swing.JTabbedPane mDevicesTabbedPane;
private javax.swing.JLabel mLabelNoDevice;
private javax.swing.JPanel mMainPanel;
// End of variables declaration//GEN-END:variables
}

110
java/core.mimis/src/main/java/mimis/device/javainput/JavaInputDevice.java
View File

@@ -1,110 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput;
import mimis.Component;
import mimis.device.Device;
import mimis.exception.ButtonException;
import mimis.exception.button.UnknownButtonException;
import mimis.exception.button.UnknownDirectionException;
import mimis.exception.device.DeviceNotFoundException;
import mimis.input.Button;
import mimis.input.state.Press;
import mimis.input.state.Release;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import de.hardcode.jxinput.Axis;
import de.hardcode.jxinput.JXInputDevice;
import de.hardcode.jxinput.JXInputManager;
import de.hardcode.jxinput.event.JXInputAxisEvent;
import de.hardcode.jxinput.event.JXInputButtonEvent;
import de.hardcode.jxinput.event.JXInputDirectionalEvent;
public abstract class JavaInputDevice extends Component implements Device {
protected String name;
public JavaInputDevice(String title, String name) {
super(title);
this.name = name;
}
protected JavaInputListener javaInputListener;
protected Button previousDirectionalButton;
public void activate() throws ActivateException {
try {
JXInputDevice jxinputDevice = getDevice(name);
logger.debug(jxinputDevice.getName());
javaInputListener = new JavaInputListener(this, jxinputDevice);
} catch (DeviceNotFoundException e) {
throw new ActivateException();
}
javaInputListener.start();
super.activate();
}
public void deactivate() throws DeactivateException {
super.deactivate();
javaInputListener.stop();
}
public void processEvent(JXInputAxisEvent event) {
logger.error("AxisEvent");
Axis axis = event.getAxis();
double delta = event.getDelta();
System.out.println(axis.getName());
System.out.println(axis.getResolution());
System.out.println(axis.getType());
System.out.println(axis.getValue());
System.out.println(delta);
}
public void processEvent(JXInputButtonEvent event) throws ButtonException {
Button button = getButton(event);
if (event.getButton().getState()) {
route(new Press(button));
} else {
route(new Release(button));
}
}
public void processEvent(JXInputDirectionalEvent event) throws UnknownDirectionException {
Button button = getButton(event);
if (event.getDirectional().isCentered()) {
if (previousDirectionalButton != null) {
route(new Release(previousDirectionalButton));
}
} else {
route(new Press(button));
previousDirectionalButton = button;
}
}
protected abstract Button getButton(JXInputButtonEvent event) throws UnknownButtonException;
protected abstract Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException;
public static JXInputDevice getDevice(String name) throws DeviceNotFoundException {
int numberOfDevices = JXInputManager.getNumberOfDevices();
for (int i = 0; i < numberOfDevices; ++i) {
JXInputDevice device = JXInputManager.getJXInputDevice(i);
if (device.getName().startsWith(name)) {
return device;
}
}
throw new DeviceNotFoundException();
}
}

102
java/core.mimis/src/main/java/mimis/device/javainput/JavaInputListener.java
View File

@@ -1,102 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput;
import java.util.LinkedList;
import java.util.Queue;
import mimis.exception.ButtonException;
import base.work.Work;
import de.hardcode.jxinput.Axis;
import de.hardcode.jxinput.Button;
import de.hardcode.jxinput.Directional;
import de.hardcode.jxinput.JXInputDevice;
import de.hardcode.jxinput.JXInputManager;
import de.hardcode.jxinput.event.JXInputAxisEvent;
import de.hardcode.jxinput.event.JXInputAxisEventListener;
import de.hardcode.jxinput.event.JXInputButtonEvent;
import de.hardcode.jxinput.event.JXInputButtonEventListener;
import de.hardcode.jxinput.event.JXInputDirectionalEvent;
import de.hardcode.jxinput.event.JXInputDirectionalEventListener;
import de.hardcode.jxinput.event.JXInputEventManager;
public class JavaInputListener extends Work implements JXInputAxisEventListener, JXInputButtonEventListener, JXInputDirectionalEventListener {
protected JavaInputDevice javaInputDevice;
protected JXInputDevice jxinputDevice;
protected Queue<JXInputAxisEvent> axisEventQueue;
protected Queue<JXInputButtonEvent> buttonEventQueue;
protected Queue<JXInputDirectionalEvent> directionalEventQueue;
public JavaInputListener(JavaInputDevice javaInputDevice, JXInputDevice jxinputDevice) {
this.javaInputDevice = javaInputDevice;
this.jxinputDevice = jxinputDevice;
axisEventQueue = new LinkedList<JXInputAxisEvent>();
buttonEventQueue = new LinkedList<JXInputButtonEvent>();
directionalEventQueue = new LinkedList<JXInputDirectionalEvent>();
addListeners();
}
protected void addListeners() {
for (int i = 0; i < jxinputDevice.getMaxNumberOfAxes(); ++i) {
Axis axis = jxinputDevice.getAxis(i);
if (axis != null) {
JXInputEventManager.addListener(this, axis);
}
}
for (int i = 0; i < jxinputDevice.getMaxNumberOfButtons(); ++i) {
Button button = jxinputDevice.getButton(i);
if (button != null) {
JXInputEventManager.addListener(this, button);
}
}
for (int i = 0; i < jxinputDevice.getMaxNumberOfDirectionals(); ++i) {
Directional directional = jxinputDevice.getDirectional(i);
if (directional != null) {
JXInputEventManager.addListener(this, directional);
}
}
}
public void changed(JXInputAxisEvent event) {
axisEventQueue.add(event);
}
public void changed(JXInputButtonEvent event) {
buttonEventQueue.add(event);
}
public void changed(JXInputDirectionalEvent event) {
directionalEventQueue.add(event);
}
public void work() {
JXInputManager.updateFeatures();
if (!axisEventQueue.isEmpty()) {
javaInputDevice.processEvent(axisEventQueue.poll());
} else if (!buttonEventQueue.isEmpty()) {
try {
javaInputDevice.processEvent(buttonEventQueue.poll());
} catch (ButtonException e) {logger.error("fail", e);}
} else if (!directionalEventQueue.isEmpty()) {
try {
javaInputDevice.processEvent(directionalEventQueue.poll());
} catch (ButtonException e) {logger.error("fail", e);}
} else {
worker.sleep();
}
}
}

59
java/core.mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DButton.java
View File

@@ -1,59 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.extreme3d;
import mimis.exception.button.UnknownButtonException;
import mimis.input.Button;
import de.hardcode.jxinput.event.JXInputButtonEvent;
public enum Extreme3DButton implements Button {
ONE ("Button 0"),
TWO ("Button 1"),
THREE ("Button 2"),
FOUR ("Button 3"),
FIVE ("Button 4"),
SIX ("Button 5"),
SEVEN ("Button 6"),
EIGHT ("Button 7"),
NINE ("Button 8"),
TEN ("Button 9"),
ELEVEN ("Button 10"),
TWELVE ("Button 11");
protected String code;
private Extreme3DButton(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public static Extreme3DButton create(String code) throws UnknownButtonException {
for (Extreme3DButton button : Extreme3DButton.values()) {
if (button.getCode().equals(code)) {
return button;
}
}
throw new UnknownButtonException();
}
public static Extreme3DButton create(JXInputButtonEvent event) throws UnknownButtonException {
return create(event.getButton().getName());
}
}

54
java/core.mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DDevice.java
View File

@@ -1,54 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.extreme3d;
import base.exception.worker.ActivateException;
import mimis.device.javainput.DirectionButton;
import mimis.device.javainput.JavaInputDevice;
import mimis.exception.button.UnknownButtonException;
import mimis.exception.button.UnknownDirectionException;
import mimis.input.Button;
import mimis.value.Action;
import de.hardcode.jxinput.event.JXInputButtonEvent;
import de.hardcode.jxinput.event.JXInputDirectionalEvent;
public class Extreme3DDevice extends JavaInputDevice {
protected static final String TITLE = "Extreme 3D";
protected static final String NAME = "Logitech Extreme 3D";
protected static Extreme3DTaskMapCycle taskMapCycle;
public Extreme3DDevice() {
super(TITLE, NAME);
taskMapCycle = new Extreme3DTaskMapCycle();
}
public void activate() throws ActivateException {
parser(Action.ADD, taskMapCycle.mimis);
parser(Action.ADD, taskMapCycle.player);
parser(Action.ADD, taskMapCycle.like);
super.activate();
}
protected Button getButton(JXInputButtonEvent event) throws UnknownButtonException {
return Extreme3DButton.create(event);
}
protected Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException {
return DirectionButton.create(event);
}
}

86
java/core.mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DTaskMapCycle.java
View File

@@ -1,86 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.extreme3d;
import mimis.device.javainput.DirectionButton;
import mimis.input.Task;
import mimis.input.state.Press;
import mimis.state.TaskMap;
import mimis.state.TaskMapCycle;
import mimis.value.Action;
import mimis.value.Target;
public class Extreme3DTaskMapCycle extends TaskMapCycle {
protected static final long serialVersionUID = 1L;
public TaskMap mimis, player, like;
public Extreme3DTaskMapCycle() {
/* Mimis */
mimis = new TaskMap();
mimis.add(
new Press(Extreme3DButton.SEVEN),
new Task(Action.PREVIOUS, Target.MAIN));
mimis.add(
new Press(Extreme3DButton.EIGHT),
new Task(Action.NEXT, Target.MAIN));
add(mimis);
/* Player */
player = new TaskMap();
player.add(
new Press(Extreme3DButton.ONE),
new Task(Action.PLAY, Target.CURRENT));
player.add(
new Press(Extreme3DButton.TWO),
new Task(Action.MUTE, Target.CURRENT));
player.add(
new Press(Extreme3DButton.NINE),
new Task(Action.SHUFFLE, Target.CURRENT));
player.add(
new Press(Extreme3DButton.TEN),
new Task(Action.REPEAT, Target.CURRENT));
player.add(
new Press(Extreme3DButton.SIX),
new Task(Action.NEXT, Target.CURRENT));
player.add(
new Press(Extreme3DButton.FOUR),
new Task(Action.PREVIOUS, Target.CURRENT));
player.add(
new Press(Extreme3DButton.FIVE),
new Task(Action.FORWARD, Target.CURRENT));
player.add(
new Press(Extreme3DButton.THREE),
new Task(Action.REWIND, Target.CURRENT));
player.add(
new Press(DirectionButton.SOUTH),
new Task(Action.VOLUME_DOWN, Target.CURRENT));
player.add(
new Press(DirectionButton.NORTH),
new Task(Action.VOLUME_UP, Target.CURRENT));
add(player);
like = new TaskMap();
like.add(
new Press(Extreme3DButton.ELEVEN),
new Task(Action.LIKE, Target.CURRENT));
like.add(
new Press(Extreme3DButton.TWELVE),
new Task(Action.DISLIKE, Target.CURRENT));
add(like);
}
}

57
java/core.mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadButton.java
View File

@@ -1,57 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.rumblepad;
import mimis.exception.button.UnknownButtonException;
import mimis.input.Button;
import de.hardcode.jxinput.event.JXInputButtonEvent;
public enum RumblepadButton implements Button {
ONE ("Button 0"),
TWO ("Button 1"),
THREE ("Button 2"),
FOUR ("Button 3"),
FIVE ("Button 4"),
SIX ("Button 5"),
SEVEN ("Button 6"),
EIGHT ("Button 7"),
NINE ("Button 8"),
TEN ("Button 9");
protected String code;
private RumblepadButton(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public static RumblepadButton create(String code) throws UnknownButtonException {
for (RumblepadButton button : RumblepadButton.values()) {
if (button.getCode().equals(code)) {
return button;
}
}
throw new UnknownButtonException();
}
public static RumblepadButton create(JXInputButtonEvent event) throws UnknownButtonException {
return create(event.getButton().getName());
}
}

54
java/core.mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadDevice.java
View File

@@ -1,54 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.rumblepad;
import base.exception.worker.ActivateException;
import mimis.device.javainput.DirectionButton;
import mimis.device.javainput.JavaInputDevice;
import mimis.exception.button.UnknownButtonException;
import mimis.exception.button.UnknownDirectionException;
import mimis.input.Button;
import mimis.value.Action;
import de.hardcode.jxinput.event.JXInputButtonEvent;
import de.hardcode.jxinput.event.JXInputDirectionalEvent;
public class RumblepadDevice extends JavaInputDevice {
protected static final String TITLE = "RumblePad";
protected static final String NAME = "Logitech RumblePad 2 USB";
protected static RumblepadTaskMapCycle taskMapCycle;
public RumblepadDevice() {
super(TITLE, NAME);
taskMapCycle = new RumblepadTaskMapCycle();
}
public void activate() throws ActivateException {
super.activate();
parser(Action.ADD, taskMapCycle.mimis);
parser(Action.ADD, taskMapCycle.player);
parser(Action.ADD, taskMapCycle.like);
}
protected Button getButton(JXInputButtonEvent event) throws UnknownButtonException {
return RumblepadButton.create(event);
}
protected Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException {
return DirectionButton.create(event);
}
}

86
java/core.mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadTaskMapCycle.java
View File

@@ -1,86 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.rumblepad;
import mimis.device.javainput.DirectionButton;
import mimis.input.Task;
import mimis.input.state.Press;
import mimis.state.TaskMap;
import mimis.state.TaskMapCycle;
import mimis.value.Action;
import mimis.value.Target;
public class RumblepadTaskMapCycle extends TaskMapCycle {
protected static final long serialVersionUID = 1L;
public TaskMap mimis, player, like;
public RumblepadTaskMapCycle() {
/* Mimis */
mimis = new TaskMap();
mimis.add(
new Press(RumblepadButton.ONE),
new Task(Action.PREVIOUS, Target.MAIN));
mimis.add(
new Press(RumblepadButton.THREE),
new Task(Action.NEXT, Target.MAIN));
add(mimis);
/* Player */
player = new TaskMap();
player.add(
new Press(DirectionButton.WEST),
new Task(Action.PLAY, Target.CURRENT));
player.add(
new Press(DirectionButton.EAST),
new Task(Action.MUTE, Target.CURRENT));
player.add(
new Press(RumblepadButton.NINE),
new Task(Action.SHUFFLE, Target.CURRENT));
player.add(
new Press(RumblepadButton.TEN),
new Task(Action.REPEAT, Target.CURRENT));
player.add(
new Press(RumblepadButton.EIGHT),
new Task(Action.NEXT, Target.CURRENT));
player.add(
new Press(RumblepadButton.SIX),
new Task(Action.PREVIOUS, Target.CURRENT));
player.add(
new Press(RumblepadButton.SEVEN),
new Task(Action.FORWARD, Target.CURRENT));
player.add(
new Press(RumblepadButton.FIVE),
new Task(Action.REWIND, Target.CURRENT));
player.add(
new Press(DirectionButton.SOUTH),
new Task(Action.VOLUME_DOWN, Target.CURRENT));
player.add(
new Press(DirectionButton.NORTH),
new Task(Action.VOLUME_UP, Target.CURRENT));
add(player);
like = new TaskMap();
like.add(
new Press(RumblepadButton.FOUR),
new Task(Action.LIKE, Target.CURRENT));
like.add(
new Press(RumblepadButton.TWO),
new Task(Action.DISLIKE, Target.CURRENT));
add(like);
}
}

57
java/core.mimis/src/main/java/mimis/device/javainput/xbox360/Xbox360Button.java
View File

@@ -1,57 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.xbox360;
import mimis.exception.button.UnknownButtonException;
import mimis.input.Button;
import de.hardcode.jxinput.event.JXInputButtonEvent;
public enum Xbox360Button implements Button {
GREEN ("Button 0"), // A
RED ("Button 1"), // B
BLUE ("Button 2"), // X
YELLOW ("Button 3"), // Y
LB ("Button 4"),
RB ("Button 5"),
BACK ("Button 6"),
START ("Button 7"),
LEFT_STICK ("Button 8"),
RIGHT_STICK ("Button 9");
protected String code;
private Xbox360Button(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public static Xbox360Button create(String code) throws UnknownButtonException {
for (Xbox360Button button : Xbox360Button.values()) {
if (button.getCode().equals(code)) {
return button;
}
}
throw new UnknownButtonException();
}
public static Xbox360Button create(JXInputButtonEvent event) throws UnknownButtonException {
return create(event.getButton().getName());
}
}

53
java/core.mimis/src/main/java/mimis/device/javainput/xbox360/Xbox360Device.java
View File

@@ -1,53 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.xbox360;
import base.exception.worker.ActivateException;
import de.hardcode.jxinput.event.JXInputButtonEvent;
import de.hardcode.jxinput.event.JXInputDirectionalEvent;
import mimis.device.javainput.DirectionButton;
import mimis.device.javainput.JavaInputDevice;
import mimis.exception.button.UnknownButtonException;
import mimis.exception.button.UnknownDirectionException;
import mimis.input.Button;
import mimis.value.Action;
public class Xbox360Device extends JavaInputDevice {
protected static final String TITLE = "Xbox360";
protected static final String NAME = "Controller (XBOX 360 For Windows)";
protected static Xbox360TaskMapCycle taskMapCycle;
public Xbox360Device() {
super(TITLE, NAME);
taskMapCycle = new Xbox360TaskMapCycle();
}
public void activate() throws ActivateException {
super.activate();
parser(Action.ADD, taskMapCycle.mimis);
parser(Action.ADD, taskMapCycle.player);
}
protected Button getButton(JXInputButtonEvent event) throws UnknownButtonException {
return Xbox360Button.create(event);
}
protected Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException {
return DirectionButton.create(event);
}
}

59
java/core.mimis/src/main/java/mimis/device/javainput/xbox360/Xbox360TaskMapCycle.java
View File

@@ -1,59 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.javainput.xbox360;
import mimis.device.javainput.DirectionButton;
import mimis.input.Task;
import mimis.input.state.Press;
import mimis.state.TaskMap;
import mimis.state.TaskMapCycle;
import mimis.value.Action;
import mimis.value.Target;
public class Xbox360TaskMapCycle extends TaskMapCycle {
protected static final long serialVersionUID = 1L;
public TaskMap mimis, player;
public Xbox360TaskMapCycle() {
/* Mimis */
mimis = new TaskMap();
mimis.add(
new Press(Xbox360Button.GREEN),
new Task(Action.PREVIOUS, Target.MAIN));
mimis.add(
new Press(Xbox360Button.RED),
new Task(Action.NEXT, Target.MAIN));
add(mimis);
/* Player */
player = new TaskMap();
player.add(
new Press(DirectionButton.WEST),
new Task(Action.PREVIOUS, Target.CURRENT));
player.add(
new Press(DirectionButton.EAST),
new Task(Action.NEXT, Target.CURRENT));
player.add(
new Press(DirectionButton.SOUTH),
new Task(Action.VOLUME_DOWN, Target.CURRENT));
player.add(
new Press(DirectionButton.NORTH),
new Task(Action.VOLUME_UP, Target.CURRENT));
add(player);
}
}

90
java/core.mimis/src/main/java/mimis/device/jintellitype/CommandButton.java
View File

@@ -1,90 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.jintellitype;
import mimis.exception.button.UnknownButtonException;
import mimis.input.Button;
import com.melloware.jintellitype.JIntellitype;
public enum CommandButton implements Button {
BROWSER_BACKWARD (JIntellitype.APPCOMMAND_BROWSER_BACKWARD),
BROWSER_FORWARD (JIntellitype.APPCOMMAND_BROWSER_FORWARD),
BROWSER_REFRESH (JIntellitype.APPCOMMAND_BROWSER_REFRESH),
BROWSER_STOP (JIntellitype.APPCOMMAND_BROWSER_STOP),
BROWSER_SEARCH (JIntellitype.APPCOMMAND_BROWSER_SEARCH),
BROWSER_FAVOURITES (JIntellitype.APPCOMMAND_BROWSER_FAVOURITES),
BROWSER_HOME (JIntellitype.APPCOMMAND_BROWSER_HOME),
VOLUME_MUTE (JIntellitype.APPCOMMAND_VOLUME_MUTE),
VOLUME_DOWN (JIntellitype.APPCOMMAND_VOLUME_DOWN),
VOLUME_UP (JIntellitype.APPCOMMAND_VOLUME_UP),
MEDIA_NEXTTRACK (JIntellitype.APPCOMMAND_MEDIA_NEXTTRACK),
MEDIA_PREVIOUSTRACK (JIntellitype.APPCOMMAND_MEDIA_PREVIOUSTRACK),
MEDIA_STOP (JIntellitype.APPCOMMAND_MEDIA_STOP),
MEDIA_PLAY_PAUSE (JIntellitype.APPCOMMAND_MEDIA_PLAY_PAUSE),
LAUNCH_MAIL (JIntellitype.APPCOMMAND_LAUNCH_MAIL),
LAUNCH_MEDIA_SELECT (JIntellitype.APPCOMMAND_LAUNCH_MEDIA_SELECT),
LAUNCH_APP1 (JIntellitype.APPCOMMAND_LAUNCH_APP1),
LAUNCH_APP2 (JIntellitype.APPCOMMAND_LAUNCH_APP2),
BASS_DOWN (JIntellitype.APPCOMMAND_BASS_DOWN),
BASS_BOOST (JIntellitype.APPCOMMAND_BASS_BOOST),
BASS_UP (JIntellitype.APPCOMMAND_BASS_UP),
TREBLE_DOWN (JIntellitype.APPCOMMAND_TREBLE_DOWN),
TREBLE_UP (JIntellitype.APPCOMMAND_TREBLE_UP),
MICROPHONE_VOLUME_MUTE (JIntellitype.APPCOMMAND_MICROPHONE_VOLUME_MUTE),
MICROPHONE_VOLUME_DOWN (JIntellitype.APPCOMMAND_MICROPHONE_VOLUME_DOWN),
MICROPHONE_VOLUME_UP (JIntellitype.APPCOMMAND_MICROPHONE_VOLUME_UP),
HELP (JIntellitype.APPCOMMAND_HELP),
FIND (JIntellitype.APPCOMMAND_FIND),
NEW (JIntellitype.APPCOMMAND_NEW),
OPEN (JIntellitype.APPCOMMAND_OPEN),
CLOSE (JIntellitype.APPCOMMAND_CLOSE),
SAVE (JIntellitype.APPCOMMAND_SAVE),
PRINT (JIntellitype.APPCOMMAND_PRINT),
UNDO (JIntellitype.APPCOMMAND_UNDO),
REDO (JIntellitype.APPCOMMAND_REDO),
COPY (JIntellitype.APPCOMMAND_COPY),
CUT (JIntellitype.APPCOMMAND_CUT),
PASTE (JIntellitype.APPCOMMAND_PASTE),
REPLY_TO_MAIL (JIntellitype.APPCOMMAND_REPLY_TO_MAIL),
FORWARD_MAIL (JIntellitype.APPCOMMAND_FORWARD_MAIL),
SEND_MAIL (JIntellitype.APPCOMMAND_SEND_MAIL),
SPELL_CHECK (JIntellitype.APPCOMMAND_SPELL_CHECK),
DICTATE_OR_COMMAND_CONTROL_TOGGLE (JIntellitype.APPCOMMAND_DICTATE_OR_COMMAND_CONTROL_TOGGLE),
MIC_ON_OFF_TOGGLE (JIntellitype.APPCOMMAND_MIC_ON_OFF_TOGGLE),
CORRECTION_LIST (JIntellitype.APPCOMMAND_CORRECTION_LIST);
protected int code;
private CommandButton(int code) {
this.code = code;
}
public int getCode() {
return code;
}
public static CommandButton create(int code) throws UnknownButtonException {
for (CommandButton button : CommandButton.values()) {
if (button.getCode() == code) {
return button;
}
}
throw new UnknownButtonException();
}
}

62
java/core.mimis/src/main/java/mimis/device/jintellitype/Hotkey.java
View File

@@ -1,62 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.jintellitype;
import java.util.ArrayList;
import mimis.input.Button;
import mimis.value.Key;
import com.melloware.jintellitype.JIntellitype;
public class Hotkey implements Button {
protected static final long serialVersionUID = 1L;
protected static ArrayList<Hotkey> hotkeyList;
protected static JIntellitype jit;
public Hotkey(int modifier, int keycode) {
int id = hotkeyList.size();
jit.registerHotKey(id, modifier, keycode);
hotkeyList.add(this);
}
public Hotkey(int modifier, char character) {
this(modifier, (int) Character.toUpperCase(character));
}
public Hotkey(char character) {
this(0, (int) Character.toUpperCase(character));
}
public Hotkey(int keycode) {
this(0, keycode);
}
public Hotkey(Key key) {
this(key.getCode());
}
public Hotkey(int modifier, Key key) {
this(modifier, key.getCode());
}
public static void initialise(ArrayList<Hotkey> actionList, JIntellitype jit) {
Hotkey.hotkeyList = actionList;
Hotkey.jit = jit;
}
}

87
java/core.mimis/src/main/java/mimis/device/jintellitype/JIntellitypeDevice.java
View File

@@ -1,87 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.jintellitype;
import java.util.ArrayList;
import mimis.Component;
import mimis.device.Device;
import mimis.exception.button.UnknownButtonException;
import mimis.input.state.Press;
import mimis.input.state.Release;
import mimis.value.Action;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import com.melloware.jintellitype.HotkeyListener;
import com.melloware.jintellitype.IntellitypeListener;
import com.melloware.jintellitype.JIntellitype;
public class JIntellitypeDevice extends Component implements Device, HotkeyListener, IntellitypeListener {
protected static final String TITLE = "Keyboard";
protected JIntellitypeTaskMapCycle taskMapCycle;
protected ArrayList<Hotkey> hotkeyList;
protected JIntellitype jit;
public JIntellitypeDevice() {
super(TITLE);
hotkeyList = new ArrayList<Hotkey>();
jit = JIntellitype.getInstance();
Hotkey.initialise(hotkeyList, jit);
taskMapCycle = new JIntellitypeTaskMapCycle();
}
public void activate() throws ActivateException {
super.activate();
jit.addHotKeyListener(this);
jit.addIntellitypeListener(this);
parser(Action.ADD, taskMapCycle.mimis);
parser(Action.ADD, taskMapCycle.player);
}
public void onIntellitype(int command) {
if (active()) {
try {
CommandButton commandButton = CommandButton.create(command);
route(new Press(commandButton));
route(new Release(commandButton));
} catch (UnknownButtonException e) {
logger.error("", e);
}
}
}
public void onHotKey(int id) {
if (active()) {
Hotkey hotkey = hotkeyList.get(id);
route(new Press(hotkey));
route(new Release(hotkey));
}
}
public void deactivate() throws DeactivateException {
super.deactivate();
jit.removeHotKeyListener(this);
jit.removeIntellitypeListener(this);
}
public void exit() {
super.exit();
jit.cleanUp();
}
}

61
java/core.mimis/src/main/java/mimis/device/jintellitype/JIntellitypeTaskMapCycle.java
View File

@@ -1,61 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.jintellitype;
import mimis.input.Task;
import mimis.state.TaskMap;
import mimis.state.TaskMapCycle;
import mimis.value.Action;
import mimis.value.Key;
import mimis.value.Target;
public class JIntellitypeTaskMapCycle extends TaskMapCycle {
protected static final long serialVersionUID = 1L;
public TaskMap mimis, player;
public JIntellitypeTaskMapCycle() {
/* Mimis */
mimis = new TaskMap();
mimis.add(
new Hotkey(Key.PRIOR),
new Task(Action.PREVIOUS, Target.MAIN));
mimis.add(
new Hotkey(Key.NEXT),
new Task(Action.NEXT, Target.MAIN));
add(mimis);
/* Player */
player = new TaskMap();
player.add(
CommandButton.VOLUME_DOWN,
new Task(Action.VOLUME_DOWN, Target.CURRENT));
player.add(
CommandButton.VOLUME_UP,
new Task(Action.VOLUME_UP, Target.CURRENT));
player.add(
new Hotkey(Modifier.CTRL | Modifier.WIN, 'x'),
new Task(Action.EXIT, Target.MAIN));
player.add(
new Hotkey(Modifier.CTRL | Modifier.SHIFT | Modifier.WIN, 'n'),
new Task(Action.NEXT, Target.CURRENT));
player.add(
new Hotkey(Modifier.CTRL | Modifier.SHIFT | Modifier.WIN, 'p'),
new Task(Action.PREVIOUS, Target.CURRENT));
add(player);
}
}

41
java/core.mimis/src/main/java/mimis/device/jintellitype/Modifier.java
View File

@@ -1,41 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.jintellitype;
import mimis.input.Button;
import com.melloware.jintellitype.JIntellitype;
public class Modifier implements Button {
protected static final long serialVersionUID = 1L;
public static final int
ALT = JIntellitype.MOD_ALT,
CTRL = JIntellitype.MOD_CONTROL,
SHIFT = JIntellitype.MOD_SHIFT,
WIN = JIntellitype.MOD_WIN;
protected int code;
protected Modifier(int code) {
this.code = code;
}
public int getCode() {
return code;
}
}

201
java/core.mimis/src/main/java/mimis/device/network/NetworkDevice.java
View File

@@ -1,201 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.device.network;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentLinkedQueue;
import mimis.Component;
import mimis.device.Device;
import mimis.input.Feedback;
import mimis.input.Input;
import mimis.input.Task;
import mimis.value.Action;
import mimis.value.Target;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import base.work.Work;
public class NetworkDevice extends Component implements Device {
protected static final String TITLE = "Network";
public static final int PORT = 6789;
protected Server server;
protected ConcurrentLinkedQueue<Client> clientList;
public NetworkDevice(int port) {
super(TITLE);
clientList = new ConcurrentLinkedQueue<Client>();
server = new Server(port);
}
public NetworkDevice() {
this(PORT);
}
public void activate() throws ActivateException {
server.start();
super.activate();
}
public boolean active() {
for (Client client : clientList) {
if (!client.active()) {
client.stop();
}
}
return server.active();
}
public void deactivate() throws DeactivateException {
super.deactivate();
server.stop();
}
public synchronized void exit() {
super.exit();
server.exit();
}
protected void feedback(Feedback feedback) {
for (Client client : clientList) {
client.send(feedback);
}
}
protected class Server extends Work {
protected ServerSocket serverSocket;
protected int port;
public Server(int port) {
this.port = port;
}
public void activate() throws ActivateException {
try {
serverSocket = new ServerSocket(port);
} catch (IOException e) {
throw new ActivateException();
}
super.activate();
}
public synchronized boolean active() {
return serverSocket != null && !serverSocket.isClosed();
}
public synchronized void deactivate() throws DeactivateException {
super.deactivate();
try {
route(new Feedback("[NetworkDevice] Closing server socket"));
serverSocket.close();
} catch (IOException e) {
logger.error("", e);
} finally {
for (Client client : clientList) {
client.stop();
}
}
}
public void work() {
try {
route(new Feedback("[NetworkDevice] Wating for clients"));
Socket socket = serverSocket.accept();
Client client = new Client(socket);
client.start();
route(new Feedback("[NetworkDevice] Client connected: " + socket.getInetAddress()));
} catch (IOException e) {
logger.error("", e);
}
}
public synchronized void exit() {
super.exit();
for (Client client : clientList) {
client.exit();
}
}
}
protected class Client extends Work {
protected Socket socket;
protected InputStream inputStream;
protected OutputStream outputStream;
protected ObjectOutputStream objectOutputStream;
public Client(Socket socket) throws IOException {
this.socket = socket;
inputStream = socket.getInputStream();
outputStream = socket.getOutputStream();
objectOutputStream = new ObjectOutputStream(outputStream);
clientList.add(this);
}
public boolean active() {
return socket.isConnected();
}
public void work() {
ObjectInputStream objectInputStream;
try {
objectInputStream = new ObjectInputStream(inputStream);
Object object;
do {
object = objectInputStream.readObject();
if (object instanceof Input) {
logger.trace("", object);
route((Input) object);
}
} while (object != null);
} catch (IOException e) {
logger.error("", e);
stop();
} catch (ClassNotFoundException e) {
logger.error("", e);
}
}
public void deactivate() throws DeactivateException {
super.deactivate();
send(new Task(Action.STOP, Target.SELF));
clientList.remove(this);
try {
inputStream.close();
outputStream.close();
socket.close();
} catch (IOException e) {
logger.error("", e);
}
route(new Feedback("[NetworkDevice] Client disconnected: " + socket.getInetAddress()));
}
public void send(Object object) {
try {
objectOutputStream.writeObject(object);
} catch (IOException e) {
logger.error("", e);
}
}
}
}

23
java/core.mimis/src/main/java/mimis/exception/application/windows/WindowsApplicationException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.application.windows;
import mimis.exception.ApplicationException;
public class WindowsApplicationException extends ApplicationException {
protected static final long serialVersionUID = 1L;
}

23
java/core.mimis/src/main/java/mimis/exception/device/DeviceExitException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.device;
import mimis.exception.DeviceException;
public class DeviceExitException extends DeviceException {
protected static final long serialVersionUID = 1L;
}

23
java/core.mimis/src/main/java/mimis/exception/device/DeviceInitialiseException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.device;
import mimis.exception.InitialiseException;
public class DeviceInitialiseException extends InitialiseException {
protected static final long serialVersionUID = 1L;
}

21
java/core.mimis/src/main/java/mimis/exception/device/DeviceNotFoundException.java
View File

@@ -1,21 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.device;
public class DeviceNotFoundException extends DeviceInitialiseException {
protected static final long serialVersionUID = 1L;
}

23
java/core.mimis/src/main/java/mimis/exception/device/JavaInputDeviceException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.device;
import mimis.exception.DeviceException;
public class JavaInputDeviceException extends DeviceException {
protected static final long serialVersionUID = 1L;
}

23
java/core.mimis/src/main/java/mimis/exception/device/javainput/JavaInputDeviceSpecificException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.device.javainput;
import mimis.exception.DeviceException;
public class JavaInputDeviceSpecificException extends DeviceException {
protected static final long serialVersionUID = 1L;
}

23
java/core.mimis/src/main/java/mimis/exception/event/router/GlobalRouterException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.event.router;
import mimis.exception.event.SpreaderException;
public class GlobalRouterException extends SpreaderException {
protected static final long serialVersionUID = 1L;
}

23
java/core.mimis/src/main/java/mimis/exception/util/SendCommandException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.util;
import mimis.exception.application.windows.WindowsApplicationException;
public class SendCommandException extends WindowsApplicationException {
protected static final long serialVersionUID = 1L;
}

23
java/core.mimis/src/main/java/mimis/exception/util/SendKeyException.java
View File

@@ -1,23 +0,0 @@
/**
* Copyright (C) 2015 Rik Veenboer <rik.veenboer@gmail.com>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package mimis.exception.util;
import mimis.exception.application.windows.WindowsApplicationException;
public class SendKeyException extends WindowsApplicationException {
protected static final long serialVersionUID = 1L;
}