Move part of exec.mimis into core.mimis, correct most compile errors

java/core.mimis/build.gradle

@@ -0,0 +1,12 @@
+dependencies {
+	compile project(':core.legacy')
+
+	compile 'com.github.boukefalos:jlibmimis:0.1'
+	compile 'com.github.boukefalos:jlibxinput:1.0'
+	compile 'com.github.boukefalos:jlibitunes:0.3'
+	compile 'com.github.boukefalos:jlibintellitype:1.3.9'
+
+	compile 'org.slf4j:slf4j-log4j12:1.7.7'	
+	compile 'org.picocontainer:picocontainer:2.15'
+	compile 'junit:junit:4.12'	
+}

java/core.mimis/src/main/java/mimis/Component.java

@@ -0,0 +1,148 @@
+/**
+ * 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;
+
+import mimis.input.Button;
+import mimis.input.Feedback;
+import mimis.input.Input;
+import mimis.input.Task;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.input.state.State;
+import mimis.parser.ParserInput;
+import mimis.router.Router;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import base.work.Listen;
+import base.worker.Worker;
+import base.worker.Worker.Type;
+
+public abstract class Component extends Listen<Input> {
+    protected static final String TITLE = "Component";
+
+    protected String title;
+    protected Router router;
+
+    public Component() {
+        this(TITLE);
+    }
+
+    public Component(Type type) {
+        super(type);
+    }
+
+    public Component(String title) {
+        super(Worker.Type.BACKGROUND);
+        this.title = title;
+    }
+
+    public void setRouter(Router router) {
+        this.router = router;        
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void listen(Class<? extends Input> clazz) {
+        if (router == null) {
+            logger.error("Router not set");
+        } else {
+            router.listen(this, clazz);
+        }
+    }
+
+    public void ignore(Class<? extends Input> clazz) {
+        if (router == null) {
+            logger.error("Router not set");
+        } else {
+            router.ignore(this, clazz);
+        }
+    }
+
+    public void route(Input input) {
+        if (router == null) {
+            logger.error("Router not set");
+        } else {
+            if (input instanceof State) {
+                State state = (State) input;
+                if (state.getComponent() == null) {
+                    state.setComponent(this);
+                }
+            }
+            router.add(input);
+        }
+    }
+
+    public void input(Input input) {
+        if (input instanceof State) {
+            state((State) input);
+        } else if (input instanceof Task) {
+            task((Task) input);
+        } else if (input instanceof Feedback) {
+            feedback((Feedback) input);
+        }
+    }
+
+    protected void state(State state) {
+        Button button = state.getButton();
+        if (state instanceof Press) {
+            press(button);
+        } else if (state instanceof Release) {
+            release(button);
+        }
+    }
+
+    protected void task(Task task) {
+        Action action = task.getAction();
+        switch (task.getSignal()) {
+            case BEGIN:
+                switch (action) {
+                    case START:
+                        start();
+                        break;
+                    case STOP:
+                        stop();
+                        break;
+                    case EXIT:
+                        exit();
+                        break;
+                    default:
+                        begin(action);
+                        break;
+                }
+                break;
+            case END:
+                end(action);
+                break;
+            default:
+                action(action);
+                break;
+        }
+    }
+
+    protected void press(Button button) {}
+    protected void release(Button button) {}
+    protected void feedback(Feedback feedback) {}
+    protected void action(Action action) {}
+    protected void begin(Action action) {}
+    protected void end(Action action) {}
+
+    protected void parser(Action action, TaskMap taskMap) {
+        route(new ParserInput(action, taskMap));
+    }
+}

java/core.mimis/src/main/java/mimis/application/Application.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public interface Application {
+
+}

java/core.mimis/src/main/java/mimis/application/cmd/CMDApplication.java

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

java/core.mimis/src/main/java/mimis/application/cmd/windows/WindowsApplication.java

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

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

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

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

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

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

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

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

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

java/core.mimis/src/main/java/mimis/application/itunes/iTunesApplication.java

@@ -0,0 +1,196 @@
+/**
+ * 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.itunes;
+
+import mimis.Component;
+import mimis.application.Application;
+import mimis.value.Action;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+import com.dt.iTunesController.ITCOMDisabledReason;
+import com.dt.iTunesController.ITTrack;
+import com.dt.iTunesController.iTunes;
+import com.dt.iTunesController.iTunesEventsInterface;
+
+public class iTunesApplication extends Component implements Application, iTunesEventsInterface {
+    protected static final String TITLE = "iTunes";
+    protected static final boolean EVENTS = false;
+
+    protected static final int VOLUME_CHANGE_RATE = 5;
+    protected static final int VOLUME_SLEEP = 100;
+    protected static final String PLAYLIST_LIKE = "Like";
+    protected static final String PLAYLIST_DISLIKE = "Dislike";
+
+    protected iTunes iTunes;
+    protected VolumeWork volumeWork;
+    protected boolean events;
+
+    public iTunesApplication() {
+        this(EVENTS);
+    }
+
+    public iTunesApplication(boolean events) {
+        super(TITLE);
+        this.events = events;
+        volumeWork = new VolumeWork();
+    }
+
+    public synchronized void activate() throws ActivateException {
+        iTunes = new iTunes();
+        iTunes.connect();
+        if (events) {
+            iTunes.addEventHandler(this);
+        }
+        super.activate();
+    }
+
+    public synchronized boolean active() {
+        try {
+            iTunes.getMute();
+        } catch (Exception e) {
+            stop();
+        }
+        return super.active();
+    }
+
+    public synchronized void deactivate() throws DeactivateException  {
+        if (events) {
+            exit();
+        } else {
+            super.deactivate();
+            volumeWork.stop();
+            try {
+                iTunes.release();
+            } catch (Exception e) {
+                logger.error("", e);
+                throw new DeactivateException();
+            }
+        }
+    }
+
+    public synchronized void exit() {
+        try {
+            iTunes.quit();
+        } catch (Exception e) {}
+        volumeWork.exit();
+        super.exit();
+    }
+
+    protected void begin(Action action) {
+        logger.trace("iTunesApplication begin: " + action);
+        if (!active()) return;
+        switch (action) {
+            case FORWARD:
+                iTunes.fastForward();
+                break;
+            case REWIND:
+                iTunes.rewind();
+                break;
+            case VOLUME_UP:
+                volumeWork.start(VOLUME_CHANGE_RATE);
+                break;
+            case VOLUME_DOWN:
+                volumeWork.start(-VOLUME_CHANGE_RATE);
+                break;
+            default:
+                break;
+        }
+    }
+
+    protected void end(Action action) {
+        logger.trace("iTunesApplication end: " + action);
+        if (!active()) return;
+        switch (action) {
+            case PLAY:
+                iTunes.playPause();
+                break;
+            case NEXT:
+                iTunes.nextTrack();
+                break;
+            case PREVIOUS:
+                iTunes.previousTrack();
+                break;
+            case FORWARD:
+                iTunes.resume();
+                break;
+            case REWIND:
+                iTunes.resume();
+                break;
+            case MUTE:
+                iTunes.toggleMute();
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWork.stop();
+                break;
+            case SHUFFLE:
+                iTunes.toggleShuffle();
+                break;
+            case REPEAT:
+                iTunes.cycleSongRepeat();
+                break;
+            case LIKE:
+                iTunes.playlistAddCurrentTrack(PLAYLIST_LIKE);
+                break;
+            case DISLIKE:
+                iTunes.playlistAddCurrentTrack(PLAYLIST_DISLIKE);
+                break;
+            default:
+                break;
+        }
+    }
+
+    protected int getVolume() {
+        return iTunes.getSoundVolume();
+    }
+
+    public void onDatabaseChangedEvent(int[][] deletedObjectIDs, int[][] changedObjectIDs) {}
+    public void onPlayerPlayEvent(ITTrack iTrack) {
+        if (active()) {
+            logger.trace("iTunesEvent: play");
+        }
+    }
+
+    public void onPlayerStopEvent(ITTrack iTrack) {
+        if (active()) {
+            logger.trace("iTunesEvent: stop");
+        }
+    }
+
+    public void onPlayerPlayingTrackChangedEvent(ITTrack iTrack) {}
+    public void onCOMCallsDisabledEvent(ITCOMDisabledReason reason) {}
+    public void onCOMCallsEnabledEvent() {}
+    public void onQuittingEvent() {}
+    public void onAboutToPromptUserToQuitEvent() {}
+    public void onSoundVolumeChangedEvent(int newVolume) {}    
+
+    protected class VolumeWork extends Work {
+        protected int volumeChangeRate;
+
+        public void start(int volumeChangeRate) {
+            super.start();
+            this.volumeChangeRate = volumeChangeRate;
+        }
+
+        public void work() {
+            iTunes.setSoundVolume(getVolume() + volumeChangeRate);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+}

java/core.mimis/src/main/java/mimis/application/mpc/MPCApplication.java

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

java/core.mimis/src/main/java/mimis/application/robot/RobotApplication.java

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

java/core.mimis/src/main/java/mimis/application/vlc/VLCApplication.java

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

java/core.mimis/src/main/java/mimis/device/Device.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public interface Device {
+
+}

java/core.mimis/src/main/java/mimis/device/javainput/DirectionButton.java

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

java/core.mimis/src/main/java/mimis/device/javainput/JXInputTestDialog.java

@@ -0,0 +1,291 @@
+//**********************************************************************************************
+// 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
+    
+}

java/core.mimis/src/main/java/mimis/device/javainput/JavaInputDevice.java

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

java/core.mimis/src/main/java/mimis/device/javainput/JavaInputListener.java

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

java/core.mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DButton.java

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

java/core.mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DDevice.java

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

java/core.mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DTaskMapCycle.java

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

java/core.mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadButton.java

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

java/core.mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadDevice.java

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

java/core.mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadTaskMapCycle.java

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

java/core.mimis/src/main/java/mimis/device/javainput/xbox360/Xbox360Button.java

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

java/core.mimis/src/main/java/mimis/device/javainput/xbox360/Xbox360Device.java

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

java/core.mimis/src/main/java/mimis/device/javainput/xbox360/Xbox360TaskMapCycle.java

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

java/core.mimis/src/main/java/mimis/device/jintellitype/CommandButton.java

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

java/core.mimis/src/main/java/mimis/device/jintellitype/Hotkey.java

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

java/core.mimis/src/main/java/mimis/device/jintellitype/JIntellitypeDevice.java

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

java/core.mimis/src/main/java/mimis/device/jintellitype/JIntellitypeTaskMapCycle.java

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

java/core.mimis/src/main/java/mimis/device/jintellitype/Modifier.java

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

java/core.mimis/src/main/java/mimis/device/network/NetworkDevice.java

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

java/core.mimis/src/main/java/mimis/exception/ApplicationException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class ApplicationException extends HandlerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/ButtonException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class ButtonException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/DeviceException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class DeviceException extends HandlerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/EventException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class EventException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/ExitException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class ExitException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/HandlerException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class HandlerException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/InitialiseException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class InitialiseException extends HandlerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/MacroException.java

@@ -0,0 +1,25 @@
+/**
+ * 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;
+
+public class MacroException extends Exception {
+    protected static final long serialVersionUID = 1L;
+
+    public MacroException(String message) {
+        super(message);
+    }
+}

java/core.mimis/src/main/java/mimis/exception/TaskException.java

@@ -0,0 +1,21 @@
+/**
+ * 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;
+
+public class TaskException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/application/ApplicationExitException.java

@@ -0,0 +1,23 @@
+/**
+ * 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;
+
+import mimis.exception.ApplicationException;
+
+public class ApplicationExitException extends ApplicationException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/application/ApplicationInitialiseException.java

@@ -0,0 +1,23 @@
+/**
+ * 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;
+
+import mimis.exception.InitialiseException;
+
+public class ApplicationInitialiseException extends InitialiseException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/application/windows/WindowsApplicationException.java

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

java/core.mimis/src/main/java/mimis/exception/button/UnknownButtonException.java

@@ -0,0 +1,23 @@
+/**
+ * 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.button;
+
+import mimis.exception.ButtonException;
+
+public class UnknownButtonException extends ButtonException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/button/UnknownDirectionException.java

@@ -0,0 +1,23 @@
+/**
+ * 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.button;
+
+import mimis.exception.ButtonException;
+
+public class UnknownDirectionException extends ButtonException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/device/DeviceExitException.java

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

java/core.mimis/src/main/java/mimis/exception/device/DeviceInitialiseException.java

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

java/core.mimis/src/main/java/mimis/exception/device/DeviceNotFoundException.java

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

java/core.mimis/src/main/java/mimis/exception/device/JavaInputDeviceException.java

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

java/core.mimis/src/main/java/mimis/exception/device/javainput/JavaInputDeviceSpecificException.java

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

java/core.mimis/src/main/java/mimis/exception/event/SpreaderException.java

@@ -0,0 +1,23 @@
+/**
+ * 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;
+
+import mimis.exception.EventException;
+
+public class SpreaderException extends EventException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/event/router/GlobalRouterException.java

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

java/core.mimis/src/main/java/mimis/exception/macro/StateOrderException.java

@@ -0,0 +1,27 @@
+/**
+ * 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.macro;
+
+import mimis.exception.MacroException;
+
+public class StateOrderException extends MacroException {
+    protected static final long serialVersionUID = 1L;
+
+    public StateOrderException(String message) {
+        super(message);
+    }
+}

java/core.mimis/src/main/java/mimis/exception/task/ActionException.java

@@ -0,0 +1,23 @@
+/**
+ * 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.task;
+
+import mimis.exception.TaskException;
+
+public class ActionException extends TaskException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/task/TaskNotSupportedException.java

@@ -0,0 +1,21 @@
+/**
+ * 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.task;
+
+public class TaskNotSupportedException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/task/action/ActionDeserializeException.java

@@ -0,0 +1,23 @@
+/**
+ * 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.task.action;
+
+import mimis.exception.task.ActionException;
+
+public class ActionDeserializeException extends ActionException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.mimis/src/main/java/mimis/exception/util/SendCommandException.java

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

java/core.mimis/src/main/java/mimis/exception/util/SendKeyException.java

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

java/core.mimis/src/main/java/mimis/input/Button.java

@@ -0,0 +1,21 @@
+/**
+ * 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.input;
+
+import mimis.input.Input;
+
+public interface Button extends Input {}

java/core.mimis/src/main/java/mimis/input/Feedback.java

@@ -0,0 +1,31 @@
+/**
+ * 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.input;
+
+public class Feedback implements Input {
+    protected static final long serialVersionUID = 1L;
+
+    protected String text;
+
+    public Feedback(String text) {
+        this.text = text;
+    }
+
+    public String getText() {
+        return text;
+    }
+}

java/core.mimis/src/main/java/mimis/input/Input.java

@@ -0,0 +1,21 @@
+/**
+ * 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.input;
+
+import java.io.Serializable;
+
+public interface Input extends Serializable {}

java/core.mimis/src/main/java/mimis/input/Task.java

@@ -0,0 +1,63 @@
+/**
+ * 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.input;
+
+import mimis.input.Input;
+import mimis.value.Action;
+import mimis.value.Signal;
+import mimis.value.Target;
+
+public class Task implements Input {
+    protected static final long serialVersionUID = 1L;
+
+    public static final Target TARGET = Target.ALL;
+    public static final Signal SIGNAL = Signal.NONE;
+
+    protected Target target;
+    protected Action action;
+    protected Signal signal;
+
+    public Task(Action action) {
+        this(action, TARGET);
+    }
+
+    public Task(Action action, Target target) {
+        this(action, target, SIGNAL);
+    }
+
+    public Task(Action action, Target target, Signal signal) {
+        this.target = target;
+        this.action = action;
+        this.signal = signal;
+    }
+
+    public Target getTarget() {
+        return target;
+    }
+
+    public Action getAction() {
+        return action;
+    }
+
+    public Signal getSignal() {
+        return signal;
+    }
+
+    public Task setSignal(Signal signal) {
+        return new Task(action, target, signal);
+    }
+}

java/core.mimis/src/main/java/mimis/input/button/ColorButton.java

@@ -0,0 +1,23 @@
+/**
+ * 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.input.button;
+
+import mimis.input.Button;
+
+public enum ColorButton implements Button {
+    RED, GREEN, YELLOW, BLUE;
+}

java/core.mimis/src/main/java/mimis/input/button/NumberButton.java

@@ -0,0 +1,23 @@
+/**
+ * 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.input.button;
+
+import mimis.input.Button;
+
+public enum NumberButton implements Button {
+    ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE;
+}

java/core.mimis/src/main/java/mimis/input/state/Hold.java

@@ -0,0 +1,27 @@
+/**
+ * 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.input.state;
+
+import mimis.input.Button;
+
+public class Hold extends State {  
+    protected static final long serialVersionUID = 1L;
+
+    public Hold(Button button) {
+        super(button);
+    }
+}

java/core.mimis/src/main/java/mimis/input/state/Press.java

@@ -0,0 +1,27 @@
+/**
+ * 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.input.state;
+
+import mimis.input.Button;
+
+public class Press extends State {
+    protected static final long serialVersionUID = 1L;
+
+    public Press(Button button) {
+        super(button);
+    }
+}

java/core.mimis/src/main/java/mimis/input/state/Release.java

@@ -0,0 +1,27 @@
+/**
+ * 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.input.state;
+
+import mimis.input.Button;
+
+public class Release extends State {
+    protected static final long serialVersionUID = 1L;
+
+    public Release(Button button) {
+        super(button);
+    }
+}

java/core.mimis/src/main/java/mimis/input/state/State.java

@@ -0,0 +1,49 @@
+/**
+ * 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.input.state;
+
+import mimis.Component;
+import mimis.input.Button;
+import mimis.input.Input;
+import mimis.input.state.State;
+
+public abstract class State implements Input {
+    protected static final long serialVersionUID = 1L;
+
+    protected Button button;
+    protected Component component;
+
+    public Button getButton() {
+        return button;
+    }
+
+    public State(Button button) {
+        this.button = button;
+    }
+
+    public void setComponent(Component component) {
+        this.component = component;        
+    }
+
+    public Component getComponent() {
+        return component;
+    }
+
+    public boolean equals(State state, boolean type) {
+        return (type || state.getClass().equals(getClass())) && state.getButton().equals(button);
+    }
+}

java/core.mimis/src/main/java/mimis/input/state/sequence/Macro.java

@@ -0,0 +1,65 @@
+/**
+ * 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.input.state.sequence;
+
+import java.util.ArrayList;
+
+import mimis.exception.macro.StateOrderException;
+import mimis.input.Button;
+import mimis.input.state.Hold;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.input.state.State;
+
+
+public class Macro extends Sequence {
+    public Macro(Press press) {
+        Button button = press.getButton();
+        this.eventArray = new State[] {press, new Release(button)};
+    }
+
+    public Macro(State... eventArray) throws StateOrderException {
+        ArrayList<Button> holdList = new ArrayList<Button>();
+        ArrayList<State> eventList = new ArrayList<State>();
+        for (State state : eventArray) {
+            Button button = state.getButton();
+            if (state instanceof Press) {
+                if (holdList.contains(button)) {
+                    throw new StateOrderException("Press events cannot follow hold events for the same button.");
+                }
+                eventList.add(state);
+                eventList.add(new Release(button));
+            } else if (state instanceof Release) {
+                if (!holdList.contains(button)) {
+                    throw new StateOrderException("Cannot release a button that is not held.");
+                }
+                holdList.remove(button);
+                eventList.add(state);
+            } else if (state instanceof Hold) {
+                if (holdList.contains(button)) {
+                    throw new StateOrderException("Cannot hold a button more than once.");
+                }
+                holdList.add(button);
+                eventList.add(new Press(button));
+            }
+        }
+        if (!holdList.isEmpty()) {
+            throw new StateOrderException("One or more buttons are not released.");
+        }        
+        this.eventArray = (State[]) eventList.toArray(new State[0]);
+    }
+}

java/core.mimis/src/main/java/mimis/input/state/sequence/Sequence.java

@@ -0,0 +1,35 @@
+/**
+ * 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.input.state.sequence;
+
+import mimis.input.state.State;
+
+public class Sequence {
+    protected State[] eventArray;
+
+    public Sequence(State... eventArray) {
+        this.eventArray = eventArray;
+    }
+
+    public int count() {
+        return eventArray.length;
+    }
+
+    public State get(int i) {
+        return eventArray.length > 0 ? eventArray[i] : null;
+    }
+}

java/core.mimis/src/main/java/mimis/parser/Parser.java

@@ -0,0 +1,153 @@
+/**
+ * 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.parser;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map.Entry;
+
+import mimis.Component;
+import mimis.input.Input;
+import mimis.input.Task;
+import mimis.input.state.State;
+import mimis.input.state.sequence.Sequence;
+import mimis.state.Active;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import mimis.value.Signal;
+import mimis.value.Target;
+import base.exception.worker.ActivateException;
+
+public class Parser extends Component {
+    protected TaskMap taskMap;
+    protected ArrayList<Sequence> sequenceList;
+    protected HashMap<Component, ArrayList<Active>> activeMap;
+
+    public Parser() {
+        taskMap = new TaskMap();
+        sequenceList = new ArrayList<Sequence>();
+        activeMap = new HashMap<Component, ArrayList<Active>>();
+    }
+
+    public void activate() throws ActivateException {
+        listen(ParserInput.class);
+        listen(State.class);
+        super.activate();
+    }
+
+    public void input(Input input) {
+        if (input instanceof ParserInput) {
+            input((ParserInput) input);            
+        } else if (input instanceof State) {
+            input((State) input);            
+        }       
+    }
+
+    public void input(ParserInput parserInput) {
+        logger.trace("input(ParserInput)");
+        Action action = parserInput.getAction();
+        try {
+            switch (action) {
+                case ADD:
+                    add(parserInput.getTaskMap());
+                    return;
+                case REMOVE:
+                    remove(parserInput.getTaskMap());
+                    return;
+                case RESET:
+                    reset(parserInput.getComponent(), parserInput.getEnd());
+                    return;
+                default:
+                    break;
+            }
+        } catch (NullPointerException e) {
+            logger.error("Illegal use of ParserInput");
+        }
+    }
+
+    public void input(State state) {
+        logger.trace("input(State)");
+        Component component = state.getComponent();
+        if (!activeMap.containsKey(component)) {
+            activeMap.put(component, new ArrayList<Active>());
+        }
+        ArrayList<Active> activeList = activeMap.get(component);
+        for (Sequence sequence : sequenceList) {
+            activeList.add(new Active(sequence));
+        }
+        ArrayList<Active> removeList = new ArrayList<Active>();
+        for (Active active : activeList) {
+            if (active.next(state)) {
+                Task task = taskMap.get(active.getSequence());
+                if (active.first()) {
+                    route(component, (Task) task, Signal.BEGIN);
+                }
+                if (active.last()) {
+                    route(component, (Task) task, Signal.END);
+                    removeList.add(active);
+                }
+            } else {
+                removeList.add(active);
+            }
+        }
+        for (Active active : removeList) {
+            activeList.remove(active);
+        }
+        activeMap.put(component, activeList);
+        if (activeList.isEmpty()) {
+            activeMap.remove(activeList);
+        }
+    }
+
+    protected void add(TaskMap taskMap) {
+        logger.trace("add(TaskMap)");
+        this.taskMap.putAll(taskMap);
+        sequenceList.addAll(taskMap.keySet());
+    }
+
+    protected void remove(TaskMap taskMap) {
+        for (Entry<Sequence, Task> eventEntry : taskMap.entrySet()) {
+            Sequence sequence = eventEntry.getKey();
+            this.taskMap.remove(sequence);
+            sequenceList.remove(sequence);
+            for (Entry<Component, ArrayList<Active>> activeEntry : activeMap.entrySet()) {
+                ArrayList<Active> activeList = activeEntry.getValue();
+                activeList.remove(sequence);
+            }
+        }
+    }
+
+    protected void reset(Component component, boolean end) {
+        ArrayList<Active> activeList = activeMap.get(component);
+        if (end) {
+            for (Active active : activeList) {
+                Task task = taskMap.get(active.getSequence());
+                route(component, task, Signal.END);
+            }
+        }
+        activeList.clear();
+    }
+
+    protected void route(Component component, Task task, Signal signal) {
+        task = task.setSignal(signal);
+        if (task.getTarget().equals(Target.SELF)) {
+            component.add(task);
+        } else {
+            route(task);
+        }        
+    }
+}

java/core.mimis/src/main/java/mimis/parser/ParserInput.java

@@ -0,0 +1,58 @@
+/**
+ * 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.parser;
+
+import mimis.Component;
+import mimis.input.Input;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+
+public class ParserInput implements Input {
+    protected static final long serialVersionUID = 1L;
+
+    protected Action action;
+    protected TaskMap taskMap;
+    protected Component component;
+    protected boolean end;
+
+    public ParserInput(Action action, TaskMap taskMap) {
+        this.action = action;
+        this.taskMap = taskMap;
+    }
+
+    public ParserInput(Action action, Component component, boolean end) {
+        this.action = action;
+        this.component = component;
+        this.end = end;
+    }
+
+    public Action getAction() {
+        return action;
+    }
+
+    public TaskMap getTaskMap() {
+        return taskMap;
+    }
+
+    public Component getComponent() {
+        return component;
+    }
+
+    public boolean getEnd() {
+        return end;
+    }
+}

java/core.mimis/src/main/java/mimis/router/Router.java

@@ -0,0 +1,80 @@
+/**
+ * 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.router;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map.Entry;
+
+import mimis.Component;
+import mimis.input.Input;
+import mimis.input.Task;
+
+public abstract class Router extends Component {
+    protected HashMap<Component, ArrayList<Class<? extends Input>>> listenMap;
+
+    public Router() {
+        listenMap = new HashMap<Component, ArrayList<Class<? extends Input>>>();
+    }
+
+    public synchronized void listen(Component component, Class<? extends Input> clazz) {
+        logger.debug(component + " is listening to " + clazz);
+        if (!listenMap.containsKey(component)) {
+            listenMap.put(component, new ArrayList<Class<? extends Input>>());
+        }
+        ArrayList<Class<? extends Input>> listenList = listenMap.get(component);
+        if (!listenList.contains(clazz)) {
+            listenList.add(clazz);
+        }
+    }
+
+    public synchronized void ignore(Component component, Class<?> clazz) {
+        if (listenMap.containsKey(component)) {
+            ArrayList<Class<? extends Input>> listenList = listenMap.get(component);
+            listenList.remove(clazz);
+            if (listenList.isEmpty()) {
+                listenMap.remove(listenList);
+            }
+        }        
+    }
+
+    public void input(Input input) {
+        for (Entry<Component, ArrayList<Class<? extends Input>>> entry : listenMap.entrySet()) {
+            Component component = entry.getKey();
+
+            if (input instanceof Task) {
+                System.err.println(component + " " + target((Task) input, component));
+                
+                Task x = (Task) input;
+                System.err.println(x.getTarget());
+                
+                if (!target((Task) input, component)) {
+                    continue;
+                }
+            }
+
+            ArrayList<Class<? extends Input>> listenList = entry.getValue();
+            for (Class<?> clazz : listenList) {
+                if (clazz.isInstance(input)) {
+                    component.add(input);
+                }
+            }
+        }
+    }
+
+    protected abstract boolean target(Task task, Component component);
+}

java/core.mimis/src/main/java/mimis/state/Active.java

@@ -0,0 +1,53 @@
+/**
+ * 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.state;
+
+import mimis.input.state.Hold;
+import mimis.input.state.Press;
+import mimis.input.state.State;
+import mimis.input.state.sequence.Sequence;
+
+public class Active {
+    protected Sequence sequence;
+    protected int step;
+
+    public Active(Sequence sequence) {
+        this.sequence = sequence;
+        step = -1;
+    }
+
+    public Sequence getSequence() {
+        return sequence;
+    }
+
+    public boolean next(State state) {
+        State next = sequence.get(++step);
+        if (next == null) {
+            return false;
+        }
+        boolean type = state instanceof Press && next instanceof Hold;
+        return state.equals(next, type);
+    }
+
+    public boolean first() {
+        return step == 0;
+    }
+
+    public boolean last() {
+        return step == sequence.count() - 1;
+    }
+}

java/core.mimis/src/main/java/mimis/state/TaskMap.java

@@ -0,0 +1,55 @@
+/**
+ * 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.state;
+
+import java.util.HashMap;
+
+import mimis.input.Button;
+import mimis.input.Input;
+import mimis.input.Task;
+import mimis.input.state.Press;
+import mimis.input.state.State;
+import mimis.input.state.sequence.Macro;
+import mimis.input.state.sequence.Sequence;
+
+public class TaskMap extends HashMap<Sequence, Task> implements Input {
+    protected static final long serialVersionUID = 1L;
+
+    public void add(Button button, Task task) {
+        add(new Press(button), task);
+    }
+
+    public void add(Press press, Task task) {
+        add(press, task, true);
+    }
+
+    protected void add(Press press, Task task, boolean macro) {
+        if (macro) {
+            add(new Macro(press), task);
+        } else {
+            add((State) press, task);
+        }
+    }
+
+    public void add(State state, Task task) {
+        add(new Sequence(state), task);
+    }
+
+    public void add(Sequence sequence, Task task) {
+        put(sequence, task);
+    }
+}

java/core.mimis/src/main/java/mimis/state/TaskMapCycle.java

@@ -0,0 +1,30 @@
+/**
+ * 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.state;
+
+import mimis.input.Input;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.util.ArrayCycle;
+
+public class TaskMapCycle extends ArrayCycle<TaskMap> implements Input {
+    protected static final long serialVersionUID = 1L;
+    
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+}

java/core.mimis/src/main/java/mimis/util/Multiplexer.java

@@ -0,0 +1,70 @@
+/**
+ * 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.util;
+
+import mimis.util.multiplexer.SignalListener;
+import mimis.value.Signal;
+import base.work.Work;
+
+public class Multiplexer<T> extends Work {
+    public static final int TIMEOUT = 150;
+
+    protected int threshold;
+    protected T type;
+    protected SignalListener<T> signalListener;
+    protected boolean end;
+
+    public Multiplexer(SignalListener<T> signalListener) {
+        this(signalListener, TIMEOUT);
+    }
+
+    public Multiplexer(SignalListener<T> signalListener, int treshold) {
+        this.signalListener = signalListener;
+    }
+
+    public synchronized void add(T object) {
+        if (type == null) {
+            signalListener.add(Signal.BEGIN, object);
+            type = object;
+            end = true;
+            start();
+        } else if (type.equals(object)) {
+            end = false;
+            notifyAll();
+        } else {
+            end = true;
+            synchronized (this) {
+                notifyAll();
+            }
+            add(object);
+        }
+    }
+
+    public void work() {
+        try {
+            synchronized (this) {
+                wait(TIMEOUT);
+            }
+        } catch (InterruptedException e) {}
+        if (end) {
+            signalListener.add(Signal.END, type);
+            type = null;
+            stop();
+        }
+        end = !end;
+    }
+}

java/core.mimis/src/main/java/mimis/util/Reader.java

@@ -0,0 +1,36 @@
+/**
+ * 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.util;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Reader {
+    public static String getContents(File file) throws IOException {
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
+        StringBuffer stringBuffer = new StringBuffer();
+        String line;
+        while ((line = bufferedReader.readLine()) != null) {
+            stringBuffer.append(line + "\n");
+        }
+        bufferedReader.close();
+        return stringBuffer.toString();
+    }
+}

java/core.mimis/src/main/java/mimis/util/Swing.java

@@ -0,0 +1,45 @@
+/**
+ * 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.util;
+
+import java.awt.Image;
+import java.awt.Toolkit;
+import java.net.URL;
+
+import javax.swing.ImageIcon;
+
+public class Swing {
+    protected static ClassLoader classLoader;
+    protected static Toolkit toolkit;
+
+    static {
+        classLoader = Swing.class.getClassLoader();
+        toolkit = Toolkit.getDefaultToolkit();
+    }
+
+    public static URL getResource(String name) {
+        return classLoader.getResource(name);
+    }
+
+    public static Image getImage(String name) {
+        return toolkit.getImage(getResource(name));
+    }
+
+    public static ImageIcon getImageIcon(String name) {
+        return new ImageIcon(getResource(name));
+    }
+}

java/core.mimis/src/main/java/mimis/util/Type.java

@@ -0,0 +1,41 @@
+/**
+ * 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.util;
+
+public class Type {
+    public static final int BITS_PER_BYTE = 8;
+    
+    public static byte[] intToBytes(int paramInt) {
+        return intToBytes(paramInt, true);
+    }
+
+    public static byte[] intToBytes(int paramInt, boolean paramBoolean) {
+        byte[] arrayOfByte = new byte[4];
+        int i;
+        if (paramBoolean) {
+            for (i = 0; i < arrayOfByte.length; i++) {
+                arrayOfByte[(arrayOfByte.length - i - 1)] = (byte) (paramInt >> i
+                        * BITS_PER_BYTE & 0xFF);
+            }
+        } else {
+            for (i = 0; i < arrayOfByte.length; i++) {
+                arrayOfByte[i] = (byte) (paramInt >> i * BITS_PER_BYTE & 0xFF);
+            }
+        }
+        return arrayOfByte;
+    }
+}

java/core.mimis/src/main/java/mimis/util/multiplexer/SignalListener.java

@@ -0,0 +1,23 @@
+/**
+ * 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.util.multiplexer;
+
+import mimis.value.Signal;
+
+public interface SignalListener<T> {
+    public void add(Signal signal, T type);
+}

java/core.mimis/src/main/java/mimis/util/swing/CycleButton.java

@@ -0,0 +1,39 @@
+/**
+ * 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.util.swing;
+
+import javax.swing.ImageIcon;
+
+import base.util.ArrayCycle;
+
+
+public class CycleButton extends HoldButton {
+    protected static final long serialVersionUID = 1L;
+
+    protected ArrayCycle<ImageIcon> imageIconCycle;
+
+    public CycleButton(HoldButtonListener holdButtonListener, ArrayCycle<ImageIcon> imageIconCycle) {
+        super(holdButtonListener);
+        this.imageIconCycle = imageIconCycle;
+        cycle();
+    }
+
+    public void cycle() {
+        setIcon(imageIconCycle.current());
+        imageIconCycle.next();
+    }
+}

java/core.mimis/src/main/java/mimis/util/swing/Dialog.java

@@ -0,0 +1,34 @@
+/**
+ * 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.util.swing;
+
+import javax.swing.JOptionPane;
+
+public class Dialog {
+    public static final String TITLE = "MIMIS Dialog";
+
+    public static String question(String message, Object initial) {
+        return question(TITLE, message, initial);
+    }
+    
+    public static String question(String title, String message, Object initial) {
+        return (String) JOptionPane.showInputDialog(
+            null, message, title,
+            JOptionPane.QUESTION_MESSAGE,
+            null, null, initial);
+    }
+}

java/core.mimis/src/main/java/mimis/util/swing/HoldButton.java

@@ -0,0 +1,49 @@
+/**
+ * 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.util.swing;
+
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+
+import javax.swing.JButton;
+
+public class HoldButton extends JButton implements MouseListener {
+    protected static final long serialVersionUID = 1L;
+
+    protected HoldButtonListener holdButtonListener;
+
+    public HoldButton(HoldButtonListener holdButtonListener) {
+        this.holdButtonListener = holdButtonListener;
+        addMouseListener(this);
+    }
+
+    public void mousePressed(MouseEvent event) {
+        if (event.getButton() == MouseEvent.BUTTON1) {
+            holdButtonListener.buttonPressed(this);
+        }
+    }
+
+    public void mouseReleased(MouseEvent event) {
+        if (event.getButton() == MouseEvent.BUTTON1) {
+            holdButtonListener.buttonReleased(this);
+        }
+    }
+
+    public void mouseClicked(MouseEvent event) {}
+    public void mouseEntered(MouseEvent event) {}
+    public void mouseExited(MouseEvent event) {}
+}

java/core.mimis/src/main/java/mimis/util/swing/HoldButtonListener.java

@@ -0,0 +1,22 @@
+/**
+ * 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.util.swing;
+
+public interface HoldButtonListener {
+    public void buttonPressed(HoldButton button);    
+    public void buttonReleased(HoldButton button);
+}

java/core.mimis/src/main/java/mimis/util/swing/ToggleButton.java

@@ -0,0 +1,33 @@
+/**
+ * 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.util.swing;
+
+import javax.swing.ImageIcon;
+
+import base.util.ArrayCycle;
+
+public class ToggleButton extends CycleButton {
+    protected static final long serialVersionUID = 1L;
+
+    public ToggleButton(HoldButtonListener holdButtonListener, ImageIcon firstImageIcon, ImageIcon secondImageIcon) {
+        super(holdButtonListener, new ArrayCycle<ImageIcon>(firstImageIcon, secondImageIcon));
+    }
+
+    public void toggle() {
+        cycle();
+    }
+}

java/core.mimis/src/main/java/mimis/value/Action.java

@@ -0,0 +1,21 @@
+/**
+ * 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.value;
+
+public enum Action {
+    EXIT, FORWARD, MUTE, NEXT, PAUSE, PLAY, PREVIOUS, REPEAT, RESUME, REWIND, START, TEST, VOLUME_DOWN, VOLUME_UP, FULLSCREEN, TRAIN, STOP, SAVE, RECOGNIZE, LOAD, SHUFFLE, FADEOUT, QUIT, VISUALISER, LIKE, DISLIKE, ACTIVATE, SHIFT, UNSHIFT, ADD, REMOVE, RESET, CURRENT, CLOSE;
+}

java/core.mimis/src/main/java/mimis/value/Amount.java

@@ -0,0 +1,21 @@
+/**
+ * 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.value;
+
+public enum Amount {
+    SMALL, MEDIUM, LARGE
+}

java/core.mimis/src/main/java/mimis/value/Command.java

@@ -0,0 +1,100 @@
+/**
+ * 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.value;
+
+public enum Command {
+    BROWSER_BACKWARD       (1),
+    BROWSER_FORWARD        (2),
+    BROWSER_REFRESH        (3),
+    BROWSER_STOP           (4),
+    BROWSER_SEARCH         (5),
+    BROWSER_FAVORITES      (6),
+    BROWSER_HOME           (7),
+    VOLUME_MUTE            (8),
+    VOLUME_DOWN            (9),
+    VOLUME_UP              (10),
+    MEDIA_NEXTTRACK        (11),
+    MEDIA_PREVIOUSTRACK    (12),
+    MEDIA_STOP             (13),
+    MEDIA_PLAY_PAUSE       (14),
+    LAUNCH_MAIL            (15),
+    LAUNCH_MEDIA_SELECT    (16),
+    LAUNCH_APP1            (17),
+    LAUNCH_APP2            (18),
+    BASS_DOWN              (19),
+    BASS_BOOST             (20),
+    BASS_UP                (21),
+    TREBLE_DOWN            (22),
+    TREBLE_UP              (23),
+    MICROPHONE_VOLUME_MUTE (24),
+    MICROPHONE_VOLUME_DOWN (25),
+    MICROPHONE_VOLUME_UP   (26),
+    HELP                   (27),
+    FIND                   (28),
+    NEW                    (29),
+    OPEN                   (30),
+    CLOSE                  (31),
+    SAVE                   (32),
+    PRINT                  (33),
+    UNDO                   (34),
+    REDO                   (35),
+    COPY                   (36),
+    CUT                    (37),
+    PASTE                  (38),
+    REPLY_TO_MAIL          (39),
+    FORWARD_MAIL           (40),
+    SEND_MAIL              (41),
+    SPELL_CHECK            (42),
+    DICTATE_OR_COMMAND_CONTROL_TOGGLE (43),
+    MIC_ON_OFF_TOGGLE      (44),
+    CORRECTION_LIST        (45),
+    MEDIA_PLAY             (46),
+    MEDIA_PAUSE            (47),
+    MEDIA_RECORD           (48),
+    MEDIA_FAST_FORWARD     (49),
+    MEDIA_REWIND           (50),
+    MEDIA_CHANNEL_UP       (51),
+    MEDIA_CHANNEL_DOWN     (52),
+    DELETE                 (53),
+    DWM_FLIP3D             (54);
+
+    protected int code;
+
+    private Command(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public enum System {
+        MOVE     (0xf010),
+        MAXIMIZE (0xf030),
+        MINIMIZE (0xf020);
+        
+        protected int code;
+
+        private System(int code) {
+            this.code = code;
+        }
+
+        public int getCode() {
+            return code;
+        }
+    }
+}

java/core.mimis/src/main/java/mimis/value/Key.java

@@ -0,0 +1,196 @@
+/**
+ * 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.value;
+
+public enum Key {
+    /*
+     * VK_0 - VK_9 are the same as ASCII '0' - '9' (0x30 - 0x39)
+     * 0x40 : unassigned
+     * VK_A - VK_Z are the same as ASCII 'A' - 'Z' (0x41 - 0x5A)
+     */
+    LBUTTON (0x01),
+    RBUTTON (0x02),
+    CANCEL (0x03),
+    MBUTTON (0x04),
+    XBUTTON1 (0x05),
+    XBUTTON2 (0x06),
+    BACK (0x08),
+    TAB (0x09),
+    CLEAR (0x0C),
+    RETURN (0x0D),
+    SHIFT (0x10),
+    CONTROL (0x11),
+    MENU (0x12),
+    PAUSE (0x13),
+    CAPITAL (0x14),
+    KANA (0x15),
+    HANGEUL (0x15),
+    HANGUL (0x15),
+    JUNJA (0x17),
+    FINAL (0x18),
+    HANJA (0x19),
+    KANJI (0x19),
+    ESCAPE (0x1B),
+    CONVERT (0x1C),
+    NONCONVERT (0x1D),
+    ACCEPT (0x1E),
+    MODECHANGE (0x1F),
+    SPACE (0x20),
+    PRIOR (0x21),
+    NEXT (0x22),
+    END (0x23),
+    HOME (0x24),
+    LEFT (0x25),
+    UP (0x26),
+    RIGHT (0x27),
+    DOWN (0x28),
+    SELECT (0x29),
+    PRINT (0x2A),
+    EXECUTE (0x2B),
+    SNAPSHOT (0x2C),
+    INSERT (0x2D),
+    DELETE (0x2E),
+    HELP (0x2F),
+    LWIN (0x5B),
+    RWIN (0x5C),
+    APPS (0x5D),
+    SLEEP (0x5F),
+    NUMPAD0 (0x60),
+    NUMPAD1 (0x61),
+    NUMPAD2 (0x62),
+    NUMPAD3 (0x63),
+    NUMPAD4 (0x64),
+    NUMPAD5 (0x65),
+    NUMPAD6 (0x66),
+    NUMPAD7 (0x67),
+    NUMPAD8 (0x68),
+    NUMPAD9 (0x69),
+    MULTIPLY (0x6A),
+    ADD (0x6B),
+    SEPARATOR (0x6C),
+    SUBTRACT (0x6D),
+    DECIMAL (0x6E),
+    DIVIDE (0x6F),
+    F1 (0x70),
+    F2 (0x71),
+    F3 (0x72),
+    F4 (0x73),
+    F5 (0x74),
+    F6 (0x75),
+    F7 (0x76),
+    F8 (0x77),
+    F9 (0x78),
+    F10 (0x79),
+    F11 (0x7A),
+    F12 (0x7B),
+    F13 (0x7C),
+    F14 (0x7D),
+    F15 (0x7E),
+    F16 (0x7F),
+    F17 (0x80),
+    F18 (0x81),
+    F19 (0x82),
+    F20 (0x83),
+    F21 (0x84),
+    F22 (0x85),
+    F23 (0x86),
+    F24 (0x87),
+    NUMLOCK (0x90),
+    SCROLL (0x91),
+    OEM_NEC_EQUAL (0x92),
+    OEM_FJ_JISHO (0x92),
+    OEM_FJ_MASSHOU (0x93),
+    OEM_FJ_TOUROKU (0x94),
+    OEM_FJ_LOYA (0x95),
+    OEM_FJ_ROYA (0x96),
+    LSHIFT (0xA0),
+    RSHIFT (0xA1),
+    LCONTROL (0xA2),
+    RCONTROL (0xA3),
+    LMENU (0xA4),
+    RMENU (0xA5),
+    BROWSER_BACK (0xA6),
+    BROWSER_FORWARD (0xA7),
+    BROWSER_REFRESH (0xA8),
+    BROWSER_STOP (0xA9),
+    BROWSER_SEARCH (0xAA),
+    BROWSER_FAVORITES (0xAB),
+    BROWSER_HOME (0xAC),
+    VOLUME_MUTE (0xAD),
+    VOLUME_DOWN (0xAE),
+    VOLUME_UP (0xAF),
+    MEDIA_NEXT_TRACK (0xB0),
+    MEDIA_PREV_TRACK (0xB1),
+    MEDIA_STOP (0xB2),
+    MEDIA_PLAY_PAUSE (0xB3),
+    LAUNCH_MAIL (0xB4),
+    LAUNCH_MEDIA_SELECT (0xB5),
+    LAUNCH_APP1 (0xB6),
+    LAUNCH_APP2 (0xB7),
+    OEM_1 (0xBA),
+    OEM_PLUS (0xBB),
+    OEM_COMMA (0xBC),
+    OEM_MINUS (0xBD),
+    OEM_PERIOD (0xBE),
+    OEM_2 (0xBF),
+    OEM_3 (0xC0),
+    OEM_4 (0xDB),
+    OEM_5 (0xDC),
+    OEM_6 (0xDD),
+    OEM_7 (0xDE),
+    OEM_8 (0xDF),
+    OEM_AX (0xE1),
+    OEM_102 (0xE2),
+    ICO_HELP (0xE3),
+    ICO_00 (0xE4),
+    PROCESSKEY (0xE5),
+    ICO_CLEAR (0xE6),
+    PACKET (0xE7),
+    OEM_RESET (0xE9),
+    OEM_JUMP (0xEA),
+    OEM_PA1 (0xEB),
+    OEM_PA2 (0xEC),
+    OEM_PA3 (0xED),
+    OEM_WSCTRL (0xEE),
+    OEM_CUSEL (0xEF),
+    OEM_ATTN (0xF0),
+    OEM_FINISH (0xF1),
+    OEM_COPY (0xF2),
+    OEM_AUTO (0xF3),
+    OEM_ENLW (0xF4),
+    OEM_BACKTAB (0xF5),
+    ATTN (0xF6),
+    CRSEL (0xF7),
+    EXSEL (0xF8),
+    EREOF (0xF9),
+    PLAY (0xFA),
+    ZOOM (0xFB),
+    NONAME (0xFC),
+    PA1 (0xFD),
+    OEM_CLEAR (0xFE);
+    
+    protected int code;
+
+    private Key(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+}

java/core.mimis/src/main/java/mimis/value/Signal.java

@@ -0,0 +1,21 @@
+/**
+ * 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.value;
+
+public enum Signal {
+    BEGIN, END, NONE;
+}

java/core.mimis/src/main/java/mimis/value/Target.java

@@ -0,0 +1,5 @@
+package mimis.value;
+
+public enum Target {
+	MAIN, CURRENT, SELF, ALL
+}

java/core.mimis/src/main/java/mimis/value/Type.java

@@ -0,0 +1,34 @@
+/**
+ * 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.value;
+
+public enum Type {
+    UP      (0x0101), // WM_KEYUP
+    DOWN    (0x0100), // WM_KEYDOWN
+    SYSUP   (0x0105), // WM_SYSKEYUP
+    SYSDOWN (0x0104); // WM_SYSKEYDOWN
+
+    protected int code;
+
+    private Type(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+}