Move files in anticipation of move to modular system

java/exec.mimis/src/main/java/mimis/Client.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;
+
+import base.exception.worker.ActivateException;
+import mimis.router.GlobalRouter;
+import mimis.util.swing.Dialog;
+
+public class Client extends Main {
+    public static final String IP = "127.0.0.1";
+    public static final int PORT = 6789;
+
+    public Client(String ip, int port) {
+        super();
+        router = new GlobalRouter(ip, port);
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+    }
+
+    public static void main(String[] args) {
+        String ip = Dialog.question("Server IP:", IP);
+        int port = Integer.valueOf(Dialog.question("Server Port:", PORT));
+        new Client(ip, port).start();
+    }
+}

java/exec.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/exec.mimis/src/main/java/mimis/Gui.java

@@ -0,0 +1,117 @@
+/**
+ * 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 java.awt.GridLayout;
+import java.awt.TextArea;
+import java.awt.event.WindowEvent;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.WindowConstants;
+
+import base.exception.worker.ActivateException;
+import mimis.input.Feedback;
+import mimis.input.Input;
+import mimis.input.Task;
+import mimis.manager.ButtonManager;
+import mimis.util.Swing;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class Gui extends Component {
+    public static final String ICON = "M.png";
+    public static final String TITLE = "MIMIS Manager";
+
+    protected JFrame frame;
+    protected Component component;
+    protected TextArea textArea;
+
+    public Gui(final Component component, ButtonManager... buttonManagerArray) {
+        frame = new JFrame(TITLE) {
+            protected static final long serialVersionUID = 1L;
+            protected void processWindowEvent(WindowEvent event) {
+                if (event.getID() == WindowEvent.WINDOW_CLOSING) {
+                    logger.debug("Window closing");
+                    route(new Task(Action.EXIT, Target.MIMIS));
+                    component.exit();
+                }
+            }
+        };
+        this.component = component;
+        frame.setIconImage(Swing.getImage(ICON));
+        createFrame(buttonManagerArray);
+    }
+
+    public void activate() throws ActivateException {
+        listen(Feedback.class);
+        super.activate();
+    }
+
+    public void exit() {
+        super.exit();
+        frame.dispose();
+    }
+
+    protected void createFrame(ButtonManager... buttonManagerArray) {
+        frame.setLayout(new GridLayout(0, 1));
+        JPanel controlPanel = createControlPanel(buttonManagerArray);
+        frame.add(controlPanel);
+        JPanel feedbackPanel = createTextPanel();
+        frame.add(feedbackPanel);
+        frame.setResizable(false);
+        frame.setVisible(true);
+        frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        frame.pack();
+    }
+
+    protected JPanel createControlPanel(ButtonManager... buttonManagerArray) {
+        JPanel controlPanel = new JPanel(new GridLayout(1, 0));
+        for (ButtonManager buttonManager  : buttonManagerArray) {
+            if (buttonManager.count() > 0) {
+                controlPanel.add(buttonManager.createPanel());
+            }
+        }
+        return controlPanel;
+    }
+
+    protected JPanel createTextPanel() {
+        JPanel textPanel = new JPanel();
+        textArea = new TextArea();
+        textArea.setEditable(false);
+        textPanel.add(textArea);
+        return textPanel;
+    }
+
+    public void input(Input input) {
+        if (input instanceof Feedback) {
+            writeLine(((Feedback) input).getText());
+        }
+    }
+
+    public void write(String string) {
+        textArea.append(string);
+    }
+
+    public void writeLine(String string) {
+        write(string + "\n");
+    }
+
+    public void clear() {
+        textArea.setText(null);
+    }
+}

java/exec.mimis/src/main/java/mimis/Main.java

@@ -0,0 +1,119 @@
+/**
+ * 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 java.util.ArrayList;
+import java.util.ServiceLoader;
+
+import javax.swing.UIManager;
+
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import mimis.input.Task;
+import mimis.manager.ButtonManager;
+import mimis.manager.CurrentButtonManager;
+import mimis.value.Action;
+
+public class Main extends Mimis {
+    protected CurrentButtonManager applicationManager;
+    protected ButtonManager deviceManager;
+    protected Gui gui;
+
+    static {
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (Exception e) {}
+    }
+
+    public static Component[] getApplications() {
+        return getComponents(mimis.application.Application.class);
+    }
+
+    public static Component[] getDevices() {
+        return getComponents(mimis.device.Device.class);
+    }
+
+    public static Component[] getComponents(Class<?> clazz) {
+        ArrayList<Component> componentList = new ArrayList<Component>();
+        for (Object object : ServiceLoader.load(clazz)) {
+            if (object instanceof Component) {
+                componentList.add((Component) object);
+            }
+        }
+        return componentList.toArray(new Component[]{});
+    }
+
+    public Main() {
+        super(getApplications());
+
+        /* Create gui from application and device managers */
+        applicationManager = new CurrentButtonManager(router, componentCycle, "Applications", currentArray);
+        deviceManager = new ButtonManager("Devices", initialize(false, getDevices()));
+        gui = new Gui(this, applicationManager, deviceManager);
+        manager.add(initialize(false, gui));
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+        listen(Task.class);
+
+        /* Start managers */
+        applicationManager.start();
+        deviceManager.start();
+
+        /* Force display of current component when gui started */
+        gui.start();
+        while (!gui.active());
+        end(Action.CURRENT);
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+
+        logger.debug("Stop managers");
+        applicationManager.stop();
+        deviceManager.stop();
+    }
+
+    public void exit() {
+        super.exit();
+
+        logger.debug("Exit managers");
+        applicationManager.exit();
+        deviceManager.exit();
+        gui.exit();
+        router.exit();
+        parser.exit();
+    }
+
+    public void end(Action action) {
+        super.end(action);
+        switch (action) {
+            case CURRENT:
+            case NEXT:
+            case PREVIOUS:
+                applicationManager.currentChanged();
+                break;
+            default:
+                break;
+        }
+    }
+
+    public static void main(String[] args) {
+        new Main().start();
+    }
+}

java/exec.mimis/src/main/java/mimis/Mimis.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;
+
+import mimis.input.Feedback;
+import mimis.input.Task;
+import mimis.manager.Manager;
+import mimis.parser.Parser;
+import mimis.router.Router;
+import mimis.value.Action;
+import mimis.value.Target;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.util.ArrayCycle;
+import base.worker.Worker;
+
+public abstract class Mimis extends Component {
+    protected Component[] currentArray;
+    protected Manager manager;
+    protected Parser parser;
+
+    protected ArrayCycle<Component> componentCycle;
+
+    public Mimis(Component... currentArray) {
+        super(Worker.Type.FOREGROUND);
+        this.currentArray = initialize(false, currentArray);        
+        componentCycle = new ArrayCycle<Component>(currentArray);        
+        router = new Router();
+        parser = new Parser();
+        manager = new Manager(initialize(true, router, parser));
+    }
+
+    public void activate() throws ActivateException {
+        manager.start();
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        manager.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        manager.exit();
+    }
+
+    public Component[] initialize(boolean start, Component... componentArray) {
+        for (Component component : componentArray) {
+            component.setRouter(router);
+            if (start) {
+                component.start();
+            }
+        }
+        return componentArray;
+    }
+
+    public void task(Task task) {
+        if (task.getTarget().equals(Target.CURRENT)) {
+            componentCycle.current().add(task);
+        } else {
+            super.task(task);
+        }
+    }
+
+    public void end(Action action) {
+        switch (action) {
+            case CURRENT:
+                route(new Feedback("Current component: " + componentCycle.current().getTitle()));
+                break;
+            case NEXT:
+                logger.debug("Next component");
+                route(new Feedback("Next component: " + componentCycle.next().getTitle()));
+                break;
+            case PREVIOUS:
+                logger.debug("Previous component");
+                route(new Feedback("Previous component: " + componentCycle.previous().getTitle()));
+                break;
+            case EXIT:
+                exit();
+                break;
+            default:
+                break;
+        }
+    }
+}

java/exec.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/exec.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/exec.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/exec.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/exec.mimis/src/main/java/mimis/application/cmd/windows/lightroom/LightroomApplication.java

@@ -0,0 +1,96 @@
+/**
+ * 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.lightroom;
+
+import mimis.application.cmd.windows.WindowsApplication;
+import mimis.input.Task;
+import mimis.value.Action;
+import winapi.Amount;
+import winapi.Slider;
+import winapi.Test;
+import base.exception.worker.ActivateException;
+import base.util.ArrayCycle;
+
+public class LightroomApplication extends WindowsApplication {
+    protected final static String PROGRAM = "lightroom.exe";
+    protected final static String TITLE = "Lightroom";
+    protected final static String WINDOW = "";
+
+    protected static Test test;
+    protected ArrayCycle<Slider> sliderCycle;
+
+    public LightroomApplication() {
+        super(PROGRAM, TITLE, WINDOW);
+        detect = false;
+        running = true;
+        test = new Test();
+        try {
+            test.start();
+            sliderCycle = new ArrayCycle<Slider>(Slider.values());
+            test.moveSlider(sliderCycle.current(), Amount.INCREASE_LITTLE);
+        } catch (Exception e) {
+            logger.error("", e);
+            //throw new ActivateException();
+        }
+    }
+
+    public static void main(String[] args) {
+        new LightroomApplication();
+    }
+
+    /*public boolean active() {
+        return true;
+    }*/
+
+    public void activate() throws ActivateException {
+        listen(Task.class);
+        super.activate();
+    }
+
+    public void begin(Action action) {
+        logger.trace("LightroomApplication begin: " + action);
+        try {
+            switch (action) {
+                case NEXT:    
+                    test.moveSlider(sliderCycle.current(), Amount.INCREASE_LITTLE);
+                    break;
+                case PREVIOUS:
+                    test.moveSlider(sliderCycle.current(), Amount.DECREASE_LITTLE);
+                    break;
+                case VOLUME_UP:
+                    sliderCycle.previous();
+                    break;
+                case VOLUME_DOWN:
+                    sliderCycle.next();
+                    break;
+                default:
+                    break;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        logger.debug("Slider = " + test.getValue(sliderCycle.current()));
+    }
+
+    public void end(Action action) {
+        logger.trace("LightroomApplication end: " + action);
+        switch (action) {
+            default:
+                break;
+        }
+    }
+}

java/exec.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/exec.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/exec.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/exec.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/exec.mimis/src/main/java/mimis/application/lirc/LircApplication.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.application.lirc;
+
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import mimis.Component;
+import mimis.application.Application;
+import mimis.device.lirc.LircButton;
+import mimis.device.lirc.LircService;
+import mimis.device.lirc.remote.WC02IPOButton;
+
+public class LircApplication extends Component implements Application {
+    protected LircService lircService;
+
+    public LircApplication(String title) {
+        super(title);
+        lircService = new LircService();
+        lircService.put(WC02IPOButton.NAME, WC02IPOButton.values());
+    }
+
+    public void activate() throws ActivateException {
+        lircService.activate();
+        super.activate();
+    }
+
+    public boolean active() {
+        return lircService.active();
+    }
+
+    public void deactivate() throws DeactivateException  {
+        super.deactivate();
+        lircService.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        lircService.exit();
+    }
+
+    public void send(LircButton button) {
+        lircService.send(button);
+    }
+}

java/exec.mimis/src/main/java/mimis/application/lirc/ipod/iPodApplication.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.lirc.ipod;
+
+import mimis.application.lirc.LircApplication;
+import mimis.device.lirc.remote.WC02IPOButton;
+import mimis.value.Action;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public class iPodApplication extends LircApplication {
+    protected static final String TITLE = "iPod";
+    protected static final int VOLUME_SLEEP = 100;
+
+    protected VolumeWork volumeWork;
+
+    public iPodApplication() {
+        super(TITLE);
+        volumeWork = new VolumeWork();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        volumeWork.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        volumeWork.exit();
+    }
+
+    protected void begin(Action action) {
+        logger.trace("iPodApplication begin: " + action);
+        if (!active()) return;
+        switch (action) {
+            case VOLUME_UP:
+                try {
+                    volumeWork.activate(1);
+                } catch (ActivateException e) {
+                    logger.error("", e);
+                }
+                break;
+            case VOLUME_DOWN:
+                try {
+                    volumeWork.activate(-1);
+                } catch (ActivateException e) {
+                    logger.error("", e);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    protected void end(Action action) {
+        logger.trace("iPodApplication end: " + action);
+        if (!active()) return;
+        switch (action) {
+            case PLAY:
+                send(WC02IPOButton.PLAY);
+                break;
+            case NEXT:
+                send(WC02IPOButton.NEXT);
+                break;
+            case PREVIOUS:
+                send(WC02IPOButton.PREVIOUS);
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWork.stop();
+                break;
+            default:
+                break;
+        }
+    }
+
+    protected class VolumeWork extends Work {
+        protected int volumeChangeRate;
+
+        public void activate(int volumeChangeRate) throws ActivateException {
+            super.activate();
+            this.volumeChangeRate = volumeChangeRate;
+            send(volumeChangeRate > 0 ? WC02IPOButton.PLUS : WC02IPOButton.MINUS);
+        }
+
+        public void work() {
+            lircService.send(WC02IPOButton.HOLD);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+}

java/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.mimis/src/main/java/mimis/device/javainput/xbox360/Xbox360Device.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.javainput.xbox360;
+
+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.router.Router;
+import mimis.value.Action;
+import base.exception.worker.ActivateException;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+import de.hardcode.jxinput.event.JXInputDirectionalEvent;
+
+public class Xbox360Device extends JavaInputDevice {
+    public static void main(String[] args) {
+        Xbox360Device device = new Xbox360Device();
+        Router router = new Router();
+        router.start();
+        device.setRouter(router);        
+        device.start();
+    }
+
+    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/exec.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/exec.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/exec.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/exec.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/exec.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.APPLICATIONS));
+        player.add(
+            CommandButton.VOLUME_UP,
+            new Task(Action.VOLUME_UP, Target.APPLICATIONS));
+        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/exec.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/exec.mimis/src/main/java/mimis/device/lirc/LircButton.java

@@ -0,0 +1,26 @@
+/**
+ * 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.lirc;
+
+import mimis.input.Button;
+
+public interface LircButton extends Button {
+    public static final String NAME = null;
+
+    public String getCode();
+    public String getName();
+}

java/exec.mimis/src/main/java/mimis/device/lirc/LircButtonListener.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.lirc;
+
+public interface LircButtonListener {
+    public void add(LircButton lircButton);
+}

java/exec.mimis/src/main/java/mimis/device/lirc/LircDevice.java

@@ -0,0 +1,126 @@
+/**
+ * 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.lirc;
+
+import mimis.application.cmd.CMDApplication;
+import mimis.device.Device;
+import mimis.device.lirc.remote.DenonRC176Button;
+import mimis.device.lirc.remote.PhiliphsRCLE011Button;
+import mimis.device.lirc.remote.SamsungBN5901015AButton;
+import mimis.input.Button;
+import mimis.input.button.ColorButton;
+import mimis.input.button.NumberButton;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.util.Multiplexer;
+import mimis.util.Native;
+import mimis.util.multiplexer.SignalListener;
+import mimis.value.Action;
+import mimis.value.Signal;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+
+public class LircDevice extends CMDApplication implements Device, LircButtonListener, SignalListener<Button> {
+    protected final static String PROGRAM = "winlirc.exe";
+    protected static final String TITLE = "Lirc";
+
+    protected Multiplexer<Button> multiplexer;
+    protected LircService lircService;
+    protected LircTaskMapCycle taskMapCycle;
+
+    public LircDevice() {
+        super(PROGRAM, TITLE);
+        multiplexer = new Multiplexer<Button>(this);
+        lircService = new LircService();
+        lircService.put(PhiliphsRCLE011Button.NAME, PhiliphsRCLE011Button.values());
+        lircService.put(DenonRC176Button.NAME, DenonRC176Button.values());
+        lircService.put(SamsungBN5901015AButton.NAME, SamsungBN5901015AButton.values());
+        lircService.add(this);
+        taskMapCycle = new LircTaskMapCycle();
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+        lircService.start();
+        parser(Action.ADD, taskMapCycle.denonRC176);
+        parser(Action.ADD, taskMapCycle.philiphsRCLE011);
+        parser(Action.ADD, taskMapCycle.samsungBN5901015A);
+    }
+
+    public boolean active() {
+        if (detect) {
+            if (active() && !lircService.active()) {
+                stop();
+            } else if (!active()) {
+                running = Native.isRunning(PROGRAM);
+                if (running) {
+                    start();
+                }
+            }
+        }
+        return super.active();
+    }
+
+    public void deactivate() throws DeactivateException {
+        logger.debug("Deactivate LircDevice");
+        super.deactivate();
+        lircService.stop();
+        multiplexer.stop();
+    }
+
+    public void exit() {
+        logger.debug("Exit LircDevice");
+        super.exit();
+        lircService.exit();
+        multiplexer.exit();
+    }
+
+    public void add(LircButton lircButton) {
+        multiplexer.add(lircButton);
+    }
+
+    public void add(Signal signal, Button button) {
+        add(signal, button, true);
+    }
+
+    public void add(Signal signal, Button button, boolean general) {
+        switch (signal) {
+            case BEGIN:
+                route(new Press(button));
+                break;
+            case END:
+                route(new Release(button));
+                break;
+            default:
+                break;
+        }
+
+        if (general) {
+            String string = button.toString();
+            for (Button colorButton : ColorButton.values()) {
+                if (colorButton.toString().equals(string)) {
+                    add(signal, ColorButton.valueOf(string), false);
+                }
+            }
+            for (Button numberButton : NumberButton.values()) {
+                if (numberButton.toString().equals(string)) {
+                    add(signal, NumberButton.valueOf(string), false);
+                }
+            }
+        }
+    }    
+}

java/exec.mimis/src/main/java/mimis/device/lirc/LircService.java

@@ -0,0 +1,136 @@
+/**
+ * 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.lirc;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.InputMismatchException;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
+import mimis.exception.button.UnknownButtonException;
+import mimis.util.Native;
+import mimis.value.Registry;
+import base.exception.worker.ActivateException;
+import base.server.socket.TcpClient;
+
+public class LircService extends TcpClient {
+    public static final String IP = "atom";
+    public static final int PORT = 8765;
+
+    protected ArrayList<LircButtonListener> lircButtonListenerList;
+
+    // Pluggable reader and writer?
+    // Receive strings via callback?
+    protected BufferedReader bufferedReader;
+    protected PrintWriter printWriter;
+    protected HashMap<String, LircButton[]> buttonMap;
+    protected String send;
+
+    public static void main(String[] args) {
+        LircService lircService = new LircService();
+        lircService.start();
+    }
+
+    public LircService() {
+        super(IP, PORT);
+        buttonMap = new HashMap<String, LircButton[]>();
+        send = Native.getValue(Registry.CURRENT_USER, "Software\\LIRC", "password");
+        lircButtonListenerList = new ArrayList<LircButtonListener>();
+    }
+
+    public void put(String name, LircButton[] LircButtonArray) {
+        buttonMap.put(name, LircButtonArray);
+    }
+
+    public void add(LircButtonListener lircButtonListener) {
+        lircButtonListenerList.add(lircButtonListener);
+    }
+
+    public void remove(LircButtonListener lircButtonListener) {
+        lircButtonListenerList.remove(lircButtonListener);
+    }
+
+
+    public void activate() throws ActivateException {
+        super.activate();
+        bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+        printWriter = new PrintWriter(outputStream);
+    }
+
+    public void work() {
+        try {
+            String line = bufferedReader.readLine();
+            while (line.equals("BEGIN")) {
+                while (!bufferedReader.readLine().equals("END"));
+                line = bufferedReader.readLine();
+            }
+            try {
+                LircButton lircButton = parseButton(new Scanner(line));
+                for (LircButtonListener lircbuttonListener : lircButtonListenerList) {
+                    lircbuttonListener.add(lircButton);
+                }
+            } catch (UnknownButtonException e) {
+                logger.error("", e);
+            }
+        } catch (SocketTimeoutException e) {
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public LircButton parseButton(Scanner scanner) throws UnknownButtonException {
+        try {
+            scanner.next();
+            scanner.next();
+            String code = scanner.next();
+            String remote = scanner.next();
+            logger.trace(String.format("%s: %s", remote, code));
+            LircButton[] buttonArray = buttonMap.get(remote);
+            if (buttonArray != null) {            
+                for (LircButton button : buttonArray) {
+                    if (button.getCode().equals(code)) {
+                        return button;
+                    }
+                }
+            }
+        } catch (InputMismatchException e) {
+            logger.error("", e);
+        } catch (NoSuchElementException e) {
+            logger.error("", e);
+        }
+        throw new UnknownButtonException();
+    }
+
+    public void send(LircButton button) {
+        send(button, 0);
+    }
+
+    public void send(LircButton button, int repeat) {
+        if (send == null) {
+            return;
+        }
+        String command = String.format("%s %s %s \n", send, button.getName(), button.getCode());
+        printWriter.append(command);
+        printWriter.flush();
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/LircTaskMapCycle.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.device.lirc;
+
+import mimis.device.lirc.remote.DenonRC176EventMap;
+import mimis.device.lirc.remote.PhiliphsRCLE011EventMap;
+import mimis.device.lirc.remote.SamsungBN5901015AEventMap;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+
+public class LircTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap denonRC176, philiphsRCLE011, samsungBN5901015A;
+
+    public LircTaskMapCycle() {      
+        add(denonRC176 = new DenonRC176EventMap());
+        add(philiphsRCLE011 = new PhiliphsRCLE011EventMap());
+        add(samsungBN5901015A = new SamsungBN5901015AEventMap());
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/remote/DenonRC176Button.java

@@ -0,0 +1,66 @@
+/**
+ * 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.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum DenonRC176Button implements LircButton {
+    TAPE_AB ("TAPE_AB"),
+    TAPE_REC ("TAPE_REC"),
+    TAPE_PAUSE ("TAPE_PAUSE"),
+    TAPE_STOP ("TAPE_STOP"),
+    TAPE_REWIND ("TAPE_REW"),
+    TAPE_FORWARD ("TAPE_FF"),
+    TAPE_PREIVOUS ("TAPE_PLAYREV"),
+    TAPE_NEXT ("TAPE_PLAY"),
+    CD_PREVIOUS ("CD_TRACK_-"),
+    CD_NEXT ("CD_TRACK_+"),
+    CD_SHUFFLE ("CD_RANDOM"),
+    CD_REPEAT ("CD_REPEAT"),
+    CD_SKIP ("CD_SKIP"),
+    CD_PAUSE ("CD_PAUSE"),
+    CD_STOP ("CD_STOP"),
+    CD_PLAY ("CD_PLAY"),
+    AMP_TAPE2 ("AMP_TAPE2"),
+    AMP_TAPE1 ("AMP_TAPE1"),
+    AMP_AUX ("AMP_AUX"),
+    AMP_TUNER ("AMP_TUNER"),
+    AMP_CD ("AMP_CD"),
+    AMP_PHONO ("AMP_PHONO"),
+    AMP_VOLUME_UP ("AMP_VOL_UP"),
+    AMP_VOLUME_DOWN ("AMP_VOL_DOWN"),
+    AMP_POWER ("AMP_POWER"),
+    AMP_MUTE ("AMP_MUTE"),
+    TUNER_UP ("TUN_CH_UP"),
+    TUNER_DOWN ("TUN_CH_DOWN");    
+
+    public static final String NAME = "DENON_RC-176";
+
+    protected String code;
+
+    private DenonRC176Button(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public String getName() {
+        return NAME;
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/remote/DenonRC176EventMap.java

@@ -0,0 +1,48 @@
+/**
+ * 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.lirc.remote;
+
+import mimis.input.Task;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class DenonRC176EventMap extends TaskMap {
+    protected static final long serialVersionUID = 1L;
+    
+    public DenonRC176EventMap() {
+        /* Mimis */
+        add(DenonRC176Button.TUNER_UP, new Task(Action.NEXT, Target.MAIN));
+        add(DenonRC176Button.TUNER_DOWN, new Task(Action.PREVIOUS, Target.MAIN));
+
+        /* Application */
+        add(DenonRC176Button.AMP_POWER, new Task(Action.START, Target.CURRENT));
+        add(DenonRC176Button.CD_NEXT, new Task(Action.NEXT, Target.CURRENT));
+        add(DenonRC176Button.CD_PREVIOUS, new Task(Action.PREVIOUS, Target.CURRENT));
+        add(DenonRC176Button.TAPE_REWIND, new Task(Action.REWIND, Target.CURRENT));
+        add(DenonRC176Button.CD_PLAY, new Task(Action.PLAY, Target.CURRENT));
+        add(DenonRC176Button.CD_PAUSE, new Task(Action.PLAY, Target.CURRENT));
+        add(DenonRC176Button.TAPE_FORWARD, new Task(Action.FORWARD, Target.CURRENT));
+        add(DenonRC176Button.AMP_MUTE, new Task(Action.MUTE, Target.CURRENT));
+        add(DenonRC176Button.AMP_VOLUME_UP, new Task(Action.VOLUME_UP, Target.CURRENT));
+        add(DenonRC176Button.AMP_VOLUME_DOWN, new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        add(DenonRC176Button.CD_REPEAT, new Task(Action.REPEAT, Target.CURRENT));
+        add(DenonRC176Button.CD_SHUFFLE, new Task(Action.SHUFFLE, Target.CURRENT));
+        add(DenonRC176Button.TAPE_AB, new Task(Action.LIKE, Target.CURRENT));
+        add(DenonRC176Button.TAPE_REC, new Task(Action.DISLIKE, Target.CURRENT));
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/remote/PhiliphsRCLE011Button.java

@@ -0,0 +1,73 @@
+/**
+ * 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.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum PhiliphsRCLE011Button implements LircButton {
+    POWER ("Standby"),
+    RED ("Red"),
+    GREEN ("Green"),
+    YELLOW ("Yellow"),
+    BLUE ("Blue"),
+    TUNE ("Tune"),
+    RADIO ("Radio"),
+    SQUARE ("Square"),
+    MENU ("Menu"),
+    TEXT ("Text"),
+    UP ("Up"),
+    DOWN ("Down"),
+    LEFT ("Left"),
+    RIGHT ("Right"),
+    VOLUME_UP ("Volume+"),
+    VOLUME_DOWN ("Volume-"),
+    MUTE ("Mute"),
+    PROGRAM_UP ("Program+"),
+    PROGRAM_DOWN ("Program-"),
+    ONE ("1"),
+    TWO ("2"),
+    THREE ("3"),
+    FOUR ("4"),
+    FIVE ("5"),
+    SIX ("6"),
+    SEVEN ("7"),
+    EIGHT ("8"),
+    NINE ("9"),
+    ZERO ("0"),
+    CLOCK ("Clock"),
+    OUT ("Out"),
+    INFO ("i+"),
+    SCREEN_UP ("screenup"),
+    SCREEN_DOWN ("screendown"),
+    QUESTION ("question");
+
+    public static final String NAME = "Philips_RCLE011";
+
+    protected String code;
+
+    private PhiliphsRCLE011Button(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public String getName() {
+        return NAME;
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/remote/PhiliphsRCLE011EventMap.java

@@ -0,0 +1,48 @@
+/**
+ * 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.lirc.remote;
+
+import mimis.input.Task;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class PhiliphsRCLE011EventMap extends TaskMap {
+    protected static final long serialVersionUID = 1L;
+    
+    public PhiliphsRCLE011EventMap() {
+        /* Mimis */
+        add(PhiliphsRCLE011Button.UP, new Task(Action.NEXT, Target.MAIN));
+        add(PhiliphsRCLE011Button.DOWN, new Task(Action.PREVIOUS, Target.MAIN));
+
+        /* Application */
+        add(PhiliphsRCLE011Button.POWER, new Task(Action.START, Target.CURRENT));
+        add(PhiliphsRCLE011Button.PROGRAM_UP, new Task(Action.NEXT, Target.CURRENT));
+        add(PhiliphsRCLE011Button.PROGRAM_DOWN, new Task(Action.PREVIOUS, Target.CURRENT));
+        add(PhiliphsRCLE011Button.LEFT, new Task(Action.REWIND, Target.CURRENT));
+        add(PhiliphsRCLE011Button.TUNE, new Task(Action.PLAY, Target.CURRENT));
+        add(PhiliphsRCLE011Button.RIGHT, new Task(Action.FORWARD, Target.CURRENT));
+        add(PhiliphsRCLE011Button.VOLUME_DOWN, new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        add(PhiliphsRCLE011Button.MUTE, new Task(Action.MUTE, Target.CURRENT));
+        add(PhiliphsRCLE011Button.VOLUME_UP, new Task(Action.VOLUME_UP, Target.CURRENT));
+        add(PhiliphsRCLE011Button.CLOCK, new Task(Action.REPEAT, Target.CURRENT));
+        add(PhiliphsRCLE011Button.OUT, new Task(Action.SHUFFLE, Target.CURRENT));
+        add(PhiliphsRCLE011Button.SQUARE, new Task(Action.FULLSCREEN, Target.CURRENT));
+        add(PhiliphsRCLE011Button.RED, new Task(Action.DISLIKE, Target.CURRENT));
+        add(PhiliphsRCLE011Button.GREEN, new Task(Action.LIKE, Target.CURRENT));
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/remote/SamsungBN5901015AButton.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.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum SamsungBN5901015AButton implements LircButton {
+    POWER ("Power"),
+    SOURCE ("Source"),
+    ONE ("1"),
+    TWO ("2"),
+    THREE ("3"),
+    FOUR ("4"),
+    FIVE ("5"),
+    SIX ("6"),
+    SEVEN ("7"),
+    EIGHT ("8"),
+    NINE ("9"),
+    ZERO ("0"),
+    TEXT ("TTX/Mix"),
+    CHANNEL_TOGGLE ("Pre-Ch"),
+    VOLUME_DOWN ("Vol+"),
+    VOLUME_UP ("Vol-"),
+    MUTE ("Mute"),
+    CHANNEL_LIST ("Ch.List"),
+    CHANNEL_NEXT ("Ch+"),
+    CHANNEL_PREVIOUS ("Ch-"),
+    MEDIA ("Media.P"),
+    MENU ("Menu"),
+    GUIDE ("Guide"),
+    TOOLS ("Tools"),
+    UP ("Up"),
+    INFO ("Info"),
+    RETURN ("Return"),
+    EXIT ("Exit"),
+    LEFT ("Left"),
+    ENTER ("Enter"),
+    RIGHT ("Right"),
+    DOWN ("Down"),
+    RED ("Red"),
+    GREEN ("Green"),
+    YELLOW ("Yellow"),
+    BLUE ("Blue"),
+    MODE_P ("P.Mode"),
+    MODE_S ("S.Mode"),
+    SIZE_P ("P.Size"),
+    Dual ("Dual"),
+    AUDIO ("AD"),
+    SUBTITLE ("Subt."),
+    REWIND ("Rewind"),
+    PAUSE ("Pause"),
+    FORWARD ("Forward"),
+    RECORD ("Record"),
+    PLAY ("Play"),
+    STOP ("Stop");
+
+    public static final String NAME = "Samsung_BN59-01015A";
+
+    protected String code;
+
+    private SamsungBN5901015AButton(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+    
+    public String getName() {
+        return NAME;
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/remote/SamsungBN5901015AEventMap.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.device.lirc.remote;
+
+import mimis.input.Task;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class SamsungBN5901015AEventMap extends TaskMap {
+    protected static final long serialVersionUID = 1L;
+
+    public SamsungBN5901015AEventMap() {
+        add(SamsungBN5901015AButton.VOLUME_UP, new Task(Action.VOLUME_UP, Target.CURRENT));
+    }
+}

java/exec.mimis/src/main/java/mimis/device/lirc/remote/WC02IPOButton.java

@@ -0,0 +1,44 @@
+/**
+ * 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.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum WC02IPOButton implements LircButton {
+    MINUS ("MINUS"),
+    PLUS ("PLUS"),
+    NEXT ("NEXT"),
+    PREVIOUS ("PREVIOUS"),
+    PLAY ("PLAY"),
+    HOLD ("HOLD");
+
+    public static final String NAME = "WC02-IPO";
+
+    protected String code;
+
+    private WC02IPOButton(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+    
+    public String getName() {
+        return NAME;
+    }
+}

java/exec.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/exec.mimis/src/main/java/mimis/device/panel/Panel.java

@@ -0,0 +1,197 @@
+/**
+ * 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.panel;
+
+import java.awt.BorderLayout;
+import java.awt.event.WindowEvent;
+
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.WindowConstants;
+
+import mimis.Gui;
+import mimis.util.Swing;
+import mimis.util.swing.HoldButton;
+import mimis.util.swing.HoldButtonListener;
+import mimis.util.swing.ToggleButton;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Panel extends JFrame implements HoldButtonListener {
+    protected static final long serialVersionUID = 1L;
+
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+    protected final static String TITLE = "MIMIS Panel Device";
+
+    protected PanelDevice panelDevice;
+
+    protected HoldButton upButton;
+    protected HoldButton previousButton;
+    protected HoldButton rewindButton;
+    protected HoldButton stopButton;
+    protected ToggleButton playPauseToggleButton;
+    protected HoldButton forwardButton;
+    protected HoldButton downButton;
+    protected HoldButton nextButton;
+    protected HoldButton volumeDownButton;
+    protected ToggleButton muteToggleButton;
+    protected HoldButton volumeUpButton;
+    protected HoldButton repeatButton;
+    protected HoldButton shuffleButton;
+
+    Panel(PanelDevice panelDevice) {
+        super(TITLE);
+        this.panelDevice = panelDevice;
+        setIconImage(Swing.getImage(Gui.ICON));
+        createControls();
+        layoutControls();
+        pack();
+        setResizable(false);
+        setVisible(true);
+        setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+    }
+
+    protected HoldButton getButton(String name, String text) {
+        HoldButton button = new HoldButton(this);
+        button.setIcon(Swing.getImageIcon(name));
+        button.setToolTipText(text);
+        button.setFocusPainted(false);
+        return button;
+    }
+
+    protected ToggleButton getToggleButton(String firstName, String secondName, String text) {
+        ImageIcon firstImageIcon = Swing.getImageIcon(firstName);
+        ImageIcon secondImageIcon = Swing.getImageIcon(secondName);
+        ToggleButton button = new ToggleButton(this, firstImageIcon, secondImageIcon);
+        button.setToolTipText(text);
+        button.setFocusPainted(false);
+        return button;
+    }
+
+    protected void createControls() {
+        upButton = getButton("icons/up.png", "Go to previous application");
+        nextButton = getButton("icons/next.png", "Go to next track");
+        previousButton = getButton("icons/previous.png", "Go to previous track");
+        rewindButton = getButton("icons/rewind.png", "Skip backward");
+        playPauseToggleButton = getToggleButton("icons/play.png", "icons/pause.png", "Play/pause");
+        forwardButton = getButton("icons/forward.png", "Skip forward");
+        downButton = getButton("icons/down.png", "Go to next application");
+        volumeDownButton = getButton("icons/volumeDown.png", "Decrease volume");
+        muteToggleButton = getToggleButton("icons/mute.png", "icons/unmute.png", "Toggle Mute");
+        volumeUpButton = getButton("icons/volumeUp.png", "Increase volume");
+        repeatButton = getButton("icons/repeat.png", "Repeat");
+        shuffleButton = getButton("icons/shuffle.png", "Shuffle");
+    }
+
+    protected void layoutControls() {
+        setLayout(new BorderLayout());
+        layoutControlPanel();
+    }
+    
+    protected void layoutControlPanel() {
+        JPanel controlPanel = new JPanel();
+        controlPanel.setLayout(new BorderLayout());
+        
+        JPanel upperControlPanel = new JPanel();
+        controlPanel.add(upperControlPanel, BorderLayout.NORTH);
+        upperControlPanel.add(upButton);
+        upperControlPanel.add(previousButton);
+        upperControlPanel.add(rewindButton);
+        upperControlPanel.add(playPauseToggleButton);
+        upperControlPanel.add(forwardButton);
+        upperControlPanel.add(nextButton);
+        
+        JPanel lowerControlPanel = new JPanel();
+        controlPanel.add(lowerControlPanel, BorderLayout.SOUTH);
+        lowerControlPanel.add(downButton);
+        lowerControlPanel.add(repeatButton);
+        lowerControlPanel.add(volumeDownButton);
+        lowerControlPanel.add(muteToggleButton);
+        lowerControlPanel.add(volumeUpButton);
+        lowerControlPanel.add(shuffleButton);
+
+        add(controlPanel, BorderLayout.CENTER);
+    }
+
+    /* Listeners */
+    public void buttonPressed(HoldButton button) {
+        if (button.equals(previousButton)) {
+            panelDevice.buttonPressed(PanelButton.PREVIOUS);
+        } else if (button.equals(rewindButton)) {
+            panelDevice.buttonPressed(PanelButton.REWIND);
+        } else if (button.equals(playPauseToggleButton)) {
+            panelDevice.buttonPressed(PanelButton.PLAY);
+        } else if (button.equals(forwardButton)) {
+            panelDevice.buttonPressed(PanelButton.FORWARD);
+        } else if (button.equals(nextButton)) {
+            panelDevice.buttonPressed(PanelButton.NEXT);
+        } else if (button.equals(volumeDownButton)) {
+            panelDevice.buttonPressed(PanelButton.VOLUME_DOWN);
+        } else if (button.equals(muteToggleButton)) {
+            panelDevice.buttonPressed(PanelButton.MUTE);
+        } else if (button.equals(volumeUpButton)) {
+            panelDevice.buttonPressed(PanelButton.VOLUME_UP);
+        } else if (button.equals(repeatButton)) {
+            panelDevice.buttonPressed(PanelButton.REPEAT);
+        } else if (button.equals(shuffleButton)) {
+            panelDevice.buttonPressed(PanelButton.SHUFFLE);
+        } else if (button.equals(upButton)) {
+            panelDevice.buttonPressed(PanelButton.UP);
+        }  else if (button.equals(downButton)) {
+            panelDevice.buttonPressed(PanelButton.DOWN);
+        }
+    }
+
+    public void buttonReleased(HoldButton button) {
+        if (button.equals(previousButton)) {
+            panelDevice.buttonReleased(PanelButton.PREVIOUS);
+        } else if (button.equals(rewindButton)) {
+            panelDevice.buttonReleased(PanelButton.REWIND);
+        } else if (button.equals(playPauseToggleButton)) {
+            panelDevice.buttonReleased(PanelButton.PLAY);
+            playPauseToggleButton.toggle();
+        } else if (button.equals(forwardButton)) {
+            panelDevice.buttonReleased(PanelButton.FORWARD);
+        } else if (button.equals(nextButton)) {
+            panelDevice.buttonReleased(PanelButton.NEXT);
+        } else if (button.equals(volumeDownButton)) {
+            panelDevice.buttonReleased(PanelButton.VOLUME_DOWN);
+        } else if (button.equals(muteToggleButton)) {
+            panelDevice.buttonReleased(PanelButton.MUTE);
+            muteToggleButton.toggle();
+        } else if (button.equals(volumeUpButton)) {
+            panelDevice.buttonReleased(PanelButton.VOLUME_UP);
+        } else if (button.equals(repeatButton)) {
+            panelDevice.buttonReleased(PanelButton.REPEAT);
+        } else if (button.equals(shuffleButton)) {
+            panelDevice.buttonReleased(PanelButton.SHUFFLE);
+        } else if (button.equals(upButton)) {
+            panelDevice.buttonReleased(PanelButton.UP);
+        }  else if (button.equals(downButton)) {
+            panelDevice.buttonReleased(PanelButton.DOWN);
+        }
+    }
+
+    protected void processWindowEvent(WindowEvent event) {
+        if (event.getID() == WindowEvent.WINDOW_CLOSING) {
+            logger.debug("Window closing");
+            panelDevice.stop();
+        }
+    }
+}

java/exec.mimis/src/main/java/mimis/device/panel/PanelButton.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.device.panel;
+
+import mimis.input.Button;
+
+public enum PanelButton implements Button {
+    PREVIOUS,
+    REWIND,
+    STOP,
+    PAUSE,
+    PLAY,
+    FORWARD,
+    NEXT,
+    VOLUME_DOWN,
+    MUTE,
+    VOLUME_UP,
+    REPEAT,
+    SHUFFLE,
+    UP,
+    DOWN;
+}

java/exec.mimis/src/main/java/mimis/device/panel/PanelDevice.java

@@ -0,0 +1,60 @@
+/**
+ * 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.panel;
+
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import mimis.Component;
+import mimis.device.Device;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.value.Action;
+
+public class PanelDevice extends Component implements Device {
+    protected static final String TITLE = "Panel";
+    protected Panel panel;
+    protected PanelTaskMapCycle taskMapCycle;
+
+    public PanelDevice() {
+        super(TITLE);
+        taskMapCycle = new PanelTaskMapCycle();
+    }
+
+    public void activate() throws ActivateException {
+        panel = new Panel(this);
+        parser(Action.ADD, taskMapCycle.player);
+        super.activate();
+    }
+
+    public boolean active() {
+        return panel != null;
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        panel.dispose();
+        panel = null;
+    }
+
+    public void buttonPressed(PanelButton panelButton) {
+        route(new Press(panelButton));
+    }
+
+    public void buttonReleased(PanelButton panelButton) {
+        route(new Release(panelButton));
+    }
+}

java/exec.mimis/src/main/java/mimis/device/panel/PanelTaskMapCycle.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.device.panel;
+
+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 PanelTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap player;
+
+    public PanelTaskMapCycle() {
+        /* Player */
+        player = new TaskMap();
+        player.add(new Press(PanelButton.UP), new Task(Action.PREVIOUS, Target.MAIN));
+        player.add(new Press(PanelButton.PREVIOUS), new Task(Action.PREVIOUS, Target.CURRENT));
+        player.add(new Press(PanelButton.REWIND), new Task(Action.REWIND, Target.CURRENT));
+        player.add(new Press(PanelButton.STOP), new Task(Action.STOP, Target.CURRENT));
+        player.add(new Press(PanelButton.PAUSE), new Task(Action.PAUSE, Target.CURRENT));
+        player.add(new Press(PanelButton.PLAY), new Task(Action.PLAY, Target.CURRENT));
+        player.add(new Press(PanelButton.FORWARD), new Task(Action.FORWARD, Target.CURRENT));
+        player.add(new Press(PanelButton.DOWN), new Task(Action.NEXT, Target.MAIN));
+        player.add(new Press(PanelButton.NEXT), new Task(Action.NEXT, Target.CURRENT));
+        player.add(new Press(PanelButton.VOLUME_DOWN), new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        player.add(new Press(PanelButton.MUTE), new Task(Action.MUTE, Target.CURRENT));
+        player.add(new Press(PanelButton.VOLUME_UP), new Task(Action.VOLUME_UP, Target.CURRENT));
+        player.add(new Press(PanelButton.REPEAT), new Task(Action.REPEAT, Target.CURRENT));
+        player.add(new Press(PanelButton.SHUFFLE), new Task(Action.SHUFFLE, Target.CURRENT));
+        add(player);
+    }

java/exec.mimis/src/main/java/mimis/device/wiimote/WiimoteButton.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.wiimote;
+
+import mimis.exception.button.UnknownButtonException;
+import mimis.input.Button;
+
+public enum WiimoteButton implements Button {
+    TWO   (0x0001),
+    ONE   (0x0002),
+    B     (0x0004),
+    A     (0x0008),
+    MINUS (0x0010),
+    HOME  (0x0080),
+    LEFT  (0x0100),
+    RIGHT (0x0200),
+    DOWN  (0x0400),
+    UP    (0x0800),
+    PLUS  (0x1000),
+    ALL   (0x1F9F);
+
+    protected int code;
+
+    private WiimoteButton(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public static WiimoteButton create(int code) throws UnknownButtonException {
+        for (WiimoteButton button : WiimoteButton.values()) {
+            if (button.getCode() == code) {
+                return button;
+            }
+        }
+        throw new UnknownButtonException();
+    }
+}

java/exec.mimis/src/main/java/mimis/device/wiimote/WiimoteDevice.java

@@ -0,0 +1,288 @@
+/**
+ * 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.wiimote;
+
+import mimis.Component;
+import mimis.device.Device;
+import mimis.device.wiimote.gesture.GestureDevice;
+import mimis.device.wiimote.motion.MotionDevice;
+import mimis.exception.button.UnknownButtonException;
+import mimis.exception.device.DeviceNotFoundException;
+import mimis.input.Button;
+import mimis.input.Feedback;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.value.Action;
+import mimis.value.Signal;
+
+import org.wiigee.event.GestureEvent;
+import org.wiigee.event.GestureListener;
+import org.wiigee.util.Log;
+
+import wiiusej.Wiimote;
+import wiiusej.wiiusejevents.physicalevents.IREvent;
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.util.ArrayCycle;
+import base.work.Work;
+
+public class WiimoteDevice extends Component implements Device, GestureListener {
+    protected static final String TITLE = "Wiimote";
+    protected static final int RUMBLE = 50;
+    protected static final int CONNECTED_TIMEOUT = 500;
+    protected static final int LED_TIMEOUT = 1000;
+    protected static final int LED_SLEEP = 50;
+
+    protected static WiimoteService wiimoteService;
+    protected WiimoteTaskMapCycle taskMapCycle;
+    protected Wiimote wiimote;
+    protected boolean connected;
+    protected GestureDevice gestureDevice;
+    protected MotionDevice motionDevice;
+    protected int gestureId;
+    protected LedWork ledWork;
+    protected boolean disconnect;
+
+    static {
+        WiimoteDevice.wiimoteService = new WiimoteService();
+        Log.setLevel(Log.DEBUG);
+    }
+
+    public WiimoteDevice() {
+        super(TITLE);
+        taskMapCycle = new WiimoteTaskMapCycle();
+        gestureDevice = new GestureDevice();
+        gestureDevice.add(this);
+        motionDevice = new MotionDevice(this);
+        gestureId = 0;
+        ledWork = new LedWork();
+    }
+
+    /* Worker */
+    public void activate() throws ActivateException {
+        if (wiimote == null) {
+            motionDevice.setRouter(router);
+            motionDevice.start();
+            parser(Action.ADD, taskMapCycle.player);
+        }
+        try {
+            connect();
+        } catch (DeviceNotFoundException e) {
+            logger.warn("", e);
+        }
+        super.activate();
+    }
+
+    public synchronized boolean active() {
+        if (wiimote != null) {
+            connected = false;
+            wiimote.getStatus();
+            try {
+                wait(CONNECTED_TIMEOUT);
+            } catch (InterruptedException e) {
+                logger.error("", e);
+            }
+            if (!connected) {
+                try {
+                    connect();
+                } catch (DeviceNotFoundException e) {
+                    disconnect = true;
+                    stop();
+                }
+            }
+        }
+        return super.active();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        ledWork.stop();
+        motionDevice.stop();
+        if (disconnect && wiimote != null) {
+            wiimote.disconnect();
+            disconnect = false;
+        }
+    }
+
+    public void exit() {
+        super.exit();
+        ledWork.exit();
+        if (wiimote != null) {
+            wiimote.disconnect();
+            wiimote = null;
+        }
+        wiimoteService.exit();
+        motionDevice.exit();
+    }
+
+    /* Events */
+    public void begin(Action action) {
+        switch (action) {
+            case SHIFT:
+                logger.debug("Shift");
+                parser(Action.RESET, taskMapCycle.player);
+                parser(Action.ADD, taskMapCycle.mimis);
+                parser(Action.ADD, taskMapCycle.like);
+                break;
+            case UNSHIFT:
+                logger.debug("Unshift");
+                parser(Action.RESET, taskMapCycle.mimis);
+                parser(Action.RESET, taskMapCycle.like);
+                parser(Action.ADD, taskMapCycle.player);
+                break;
+            case RECOGNIZE:
+                logger.debug("Gesture recognize press");
+                gestureDevice.recognize(Signal.BEGIN);
+                break;
+            case TRAIN:
+                logger.debug("Gesture train press");
+                gestureDevice.train(Signal.BEGIN);
+                break;
+            case CLOSE:
+                logger.debug("Gesture close press");
+                gestureDevice.close(Signal.BEGIN);
+                break;
+            case SAVE:
+                logger.debug("Gesture save");
+                gestureDevice.close(Signal.END);
+                gestureDevice.saveGesture(gestureId, "tmp/gesture #" + gestureId);
+                ++gestureId;
+                break;
+            case LOAD:
+                logger.debug("Gesture load");
+                for (int i = 0; i < gestureId; ++i) {
+                    gestureDevice.loadGesture("tmp/gesture #" + gestureId);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    public void end(Action action) {
+        switch (action) {
+            case RECOGNIZE:
+                logger.debug("Gesture recognize release");
+                gestureDevice.recognize(Signal.END);
+                break;
+            case TRAIN:
+                logger.debug("Gesture train release");
+                gestureDevice.train(Signal.END);
+                break;
+            case CLOSE:
+                logger.debug("Gesture close release");
+                gestureDevice.close(Signal.END);
+                break;
+            default:
+                break;
+        }
+    }
+
+    public void feedback(Feedback feedback) {
+        if (wiimote != null && active()) {
+            logger.debug("Wiimote rumble feedback");
+            //wiimote.rumble(RUMBLE);
+        }
+    }
+
+    /* Connectivity */
+    public synchronized void connect() throws DeviceNotFoundException {
+        wiimote = wiimoteService.getDevice(this);
+        //wiimote.activateContinuous();
+        //wiimote.activateMotionSensing();
+        ledWork.start();
+    }
+
+    /* Listeners */
+    public void onButtonsEvent(WiimoteButtonsEvent event) {
+        if (!active()) {
+            return;
+        }
+        int pressed = event.getButtonsJustPressed() - event.getButtonsHeld();
+        int released = event.getButtonsJustReleased();
+        try {
+            if (pressed != 0 && released == 0) {
+                Button button = WiimoteButton.create(pressed);
+                logger.trace("Press: " + button);
+                route(new Press(button));
+            } else if (pressed == 0 && released != 0) {
+                Button button = WiimoteButton.create(released);
+                logger.trace("Release: " + button);
+                route(new Release(button));
+            }
+        } catch (UnknownButtonException e) {}
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent event) {
+        if (!active()) {
+            return;
+        }
+        gestureDevice.add(event.getGforce());
+        motionDevice.add(event);
+    }
+
+    public void onIrEvent(IREvent event) {
+        
+    }
+
+    public void gestureReceived(GestureEvent event) {
+        if (event.isValid()) {
+            System.out.printf("id #%d, prob %.0f%%, valid %b\n", event.getId(), 100 * event.getProbability(), event.isValid());
+        }
+    }
+
+    class LedWork extends Work {
+        protected ArrayCycle<Integer> ledCycle;
+
+        public LedWork() {
+            ledCycle = new ArrayCycle<Integer>();
+            ledCycle.add(1);
+            ledCycle.add(3);
+            ledCycle.add(6);
+            ledCycle.add(12);
+            ledCycle.add(8);
+            ledCycle.add(12);
+            ledCycle.add(6);
+            ledCycle.add(3);
+            ledCycle.add(1);
+        }
+
+        public void activate() throws ActivateException {
+            sleep(LED_TIMEOUT);
+            super.activate();
+        }
+        
+        public void deactivate() throws DeactivateException {
+            super.deactivate();
+            setLeds(1);
+        }
+
+        public void work() {
+            setLeds(ledCycle.next());
+            sleep(LED_SLEEP);
+        }
+
+        protected void setLeds(int leds) {
+            if (wiimote != null) {
+                wiimote.setLeds((leds & 1) > 0, (leds & 2) > 0, (leds & 4) > 0, (leds & 8) > 0);
+                sleep((leds == 8 ? 2 : 1) * LED_SLEEP);
+            }
+        }
+    }
+}

java/exec.mimis/src/main/java/mimis/device/wiimote/WiimoteDiscovery.java

@@ -0,0 +1,99 @@
+/**
+ * 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.wiimote;
+
+import java.io.IOException;
+import java.util.Scanner;
+
+import mimis.exception.device.DeviceNotFoundException;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public class WiimoteDiscovery extends Work {
+    protected static final String WIISCAN = "wiiscan";
+    protected static final int TIMEOUT = 1000;
+    protected WiimoteDevice wiimoteDevice;
+    protected Process process;
+    protected boolean disconnect;
+
+    public WiimoteDiscovery(WiimoteDevice wiimoteDevice) {
+        this.wiimoteDevice = wiimoteDevice;
+    }
+
+    protected boolean connect() {
+        logger.debug("Connect");
+        return execute("-c nintendo"); // Nintendo RVL-CNT-01 RVL-WBC-01 Nintendo RVL-CNT-01-TR
+    }
+
+    protected boolean disconnect() {
+        logger.debug("Disconnect");
+        return execute("-d nintendo");
+    }
+
+    public boolean execute(String parameters) {
+        String command = WIISCAN + " -l wiiuse " + parameters;
+        try {
+            process = Runtime.getRuntime().exec(command);
+            Scanner scanner = new Scanner(process.getInputStream());
+            while (scanner.hasNext()) {
+                String line = scanner.nextLine();
+                if (line.contains("error: BluetoothSetServiceState()")) {
+                    disconnect = true;
+                    scanner.close();
+                    return false;
+                } else if (line.contains("[OK]")) {
+                    scanner.close();
+                    return true;
+                }
+            }
+            scanner.close();
+        } catch (IOException e) {
+            logger.error("", e);
+        } finally {
+            process = null;
+        }
+        return false;
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        if (process != null) {
+            process.destroy();
+        }
+    }
+
+    public void work() {
+        if (disconnect) {
+            disconnect();
+            disconnect = false;
+        }
+        if (connect()) {
+            logger.debug("Connected");
+            try {
+                sleep(TIMEOUT);
+                wiimoteDevice.connect();
+            } catch (DeviceNotFoundException e) {
+                disconnect = true;
+            }
+        }
+    }
+}

java/exec.mimis/src/main/java/mimis/device/wiimote/WiimoteService.java

@@ -0,0 +1,136 @@
+/**
+ * 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.wiimote;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import mimis.exception.device.DeviceNotFoundException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import wiiusej.WiiUseApiManager;
+import wiiusej.Wiimote;
+import wiiusej.wiiusejevents.GenericEvent;
+import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
+import wiiusej.wiiusejevents.physicalevents.IREvent;
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
+import wiiusej.wiiusejevents.utils.WiimoteListener;
+import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
+
+public class WiimoteService extends WiiUseApiManager implements WiimoteListener {
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+    
+    public static void main(String[] args) {
+        Logger logger = LoggerFactory.getLogger(WiimoteService.class);
+        for (Wiimote wm : WiiUseApiManager.getWiimotes(1, false)) {
+            logger.debug("" + wm.getId());
+        }
+    }
+
+    protected final boolean RUMBLE = false;
+
+    protected ArrayList<Integer> wiimoteList;
+    protected Wiimote[] wiimoteArray;
+    protected HashMap<Integer, WiimoteDevice> wiimoteDeviceMap;
+
+    public WiimoteService() {
+       wiimoteList = new ArrayList<Integer>();
+       wiimoteArray = new Wiimote[0];
+       wiimoteDeviceMap = new HashMap<Integer, WiimoteDevice>();
+    }
+
+    public void exit() {
+        if (wiimoteArray != null) {
+            for (Wiimote wiimote : wiimoteArray) {
+                wiimote.disconnect();
+            }
+        }
+        definitiveShutdown();
+    }
+
+    public Wiimote getDevice(WiimoteDevice wiimoteDevice) throws DeviceNotFoundException {
+        Wiimote[] wiimoteArray = getWiimotes(1, RUMBLE);
+        for (Wiimote wiimote : wiimoteArray) {
+            int id = wiimote.getId();
+            if (!wiimoteList.contains(id)) {
+                wiimote.addWiiMoteEventListeners(this);
+                wiimoteList.add(id);
+                wiimoteDeviceMap.put(id, wiimoteDevice);
+            }
+            return wiimote;
+        }
+        throw new DeviceNotFoundException();
+    }
+
+    public Wiimote getWiimote(GenericEvent event) {
+        return wiimoteArray[event.getWiimoteId() - 1];
+    }
+
+    public WiimoteDevice getWiimoteDevice(GenericEvent event){
+        return wiimoteDeviceMap.get(event.getWiimoteId());
+    }
+
+    public void onButtonsEvent(WiimoteButtonsEvent event) {
+        getWiimoteDevice(event).onButtonsEvent(event);
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent event) {
+
+        getWiimoteDevice(event).onMotionSensingEvent(event);
+    }
+
+    public void onStatusEvent(StatusEvent event) {
+        if (event.isConnected()) {
+            WiimoteDevice wiimoteDevice = getWiimoteDevice(event);            
+            wiimoteDevice.connected = true;
+            synchronized (wiimoteDevice) {
+                wiimoteDevice.notifyAll();
+            }
+        }
+    }
+
+    public void onIrEvent(IREvent event) {
+        getWiimoteDevice(event).onIrEvent(event);
+    }
+
+    public void onExpansionEvent(ExpansionEvent event) {}
+    public void onDisconnectionEvent(DisconnectionEvent event) {}
+    public void onNunchukInsertedEvent(NunchukInsertedEvent event) {}
+    public void onNunchukRemovedEvent(NunchukRemovedEvent event) {}
+    public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent event) {}
+    public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent event) {}
+    public void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent event) {}
+    public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent event) {}
+
+    /*public void onBalanceBoardInsertedEvent(BalanceBoardInsertedEvent e) {
+        logger.debug("", e);        
+    }
+
+    public void onBalanceBoardRemovedEvent(BalanceBoardRemovedEvent e) {
+        
+    }*/
+}

java/exec.mimis/src/main/java/mimis/device/wiimote/WiimoteTaskMapCycle.java

@@ -0,0 +1,66 @@
+/**
+ * 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.wiimote;
+
+import mimis.input.Task;
+import mimis.input.state.Release;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class WiimoteTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap mimis, player, gesture, like;
+
+    public WiimoteTaskMapCycle() {
+        /* Mimis */
+        mimis = new TaskMap();
+        mimis.add(WiimoteButton.HOME, new Task(Action.NEXT, Target.MAIN));
+        mimis.add(new Release(WiimoteButton.B), new Task(Action.UNSHIFT, Target.SELF));
+
+        /* Gesture */
+        gesture = new TaskMap();
+        gesture.add(WiimoteButton.A, new Task(Action.TRAIN, Target.SELF));
+        gesture.add(WiimoteButton.B, new Task(Action.SAVE, Target.SELF));
+        gesture.add(WiimoteButton.DOWN, new Task(Action.LOAD, Target.SELF));
+        gesture.add(WiimoteButton.HOME, new Task(Action.RECOGNIZE, Target.SELF));
+        add(gesture);
+
+        /* Player */
+        player = new TaskMap();
+        player.add(WiimoteButton.A, new Task(Action.PLAY, Target.CURRENT));
+        player.add(WiimoteButton.B, new Task(Action.SHIFT, Target.SELF));
+        player.add(WiimoteButton.HOME, new Task(Action.MUTE, Target.CURRENT));
+        player.add(WiimoteButton.ONE, new Task(Action.SHUFFLE, Target.CURRENT));
+        player.add(WiimoteButton.TWO, new Task(Action.REPEAT, Target.CURRENT));
+        player.add(WiimoteButton.UP, new Task(Action.NEXT, Target.CURRENT));
+        player.add(WiimoteButton.DOWN, new Task(Action.PREVIOUS, Target.CURRENT));    
+        player.add(WiimoteButton.RIGHT, new Task(Action.FORWARD, Target.CURRENT));
+        player.add(WiimoteButton.LEFT, new Task(Action.REWIND, Target.CURRENT));
+        player.add(WiimoteButton.MINUS, new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        player.add(WiimoteButton.PLUS, new Task(Action.VOLUME_UP, Target.CURRENT));
+        add(player);
+
+        /* Like */
+        like = new TaskMap();
+        like.add(WiimoteButton.PLUS, new Task(Action.LIKE, Target.CURRENT));
+        like.add(WiimoteButton.MINUS, new Task(Action.DISLIKE, Target.CURRENT));
+        add(like);
+    }
+}

java/exec.mimis/src/main/java/mimis/device/wiimote/gesture/GestureDevice.java

@@ -0,0 +1,128 @@
+/**
+ * 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.wiimote.gesture;
+
+import mimis.value.Signal;
+
+import org.wiigee.device.Device;
+import org.wiigee.event.AccelerationEvent;
+import org.wiigee.event.AccelerationListener;
+import org.wiigee.event.ButtonListener;
+import org.wiigee.event.ButtonPressedEvent;
+import org.wiigee.event.ButtonReleasedEvent;
+import org.wiigee.event.GestureListener;
+import org.wiigee.event.MotionStartEvent;
+import org.wiigee.event.MotionStopEvent;
+
+import wiiusej.values.GForce;
+
+public class GestureDevice extends Device implements AccelerationListener {
+    public static final boolean AUTOFILTERING = true;
+    public static final boolean AUTOMOTION = false;
+
+    public GestureDevice() {
+        this(AUTOFILTERING, AUTOMOTION);
+    }
+
+    public GestureDevice(boolean autofiltering, boolean automotion) {
+        super(autofiltering);
+        if (automotion) {
+            addAccelerationListener(this);
+        }
+        this.setRecognitionButton(ButtonPressedEvent.BUTTON_A);
+        this.setTrainButton(ButtonPressedEvent.BUTTON_B);
+        this.setCloseGestureButton(ButtonPressedEvent.BUTTON_HOME);
+    }
+
+    public void add(GestureListener gestureListener) {
+        addGestureListener(gestureListener);
+    }
+
+    public void add(GForce gforce) {
+        add(new double[] {
+            gforce.getX(),
+            gforce.getY(),
+            gforce.getY()});        
+    }
+
+    public void add(double[] vector) {
+        //System.out.printf("%f %f %f\n", vector[0], vector[1], vector[2]);
+        fireAccelerationEvent(vector);
+    }
+
+    public void recognize(Signal signal) { 
+        switch (signal) {
+            case BEGIN:
+                fireButtonPressedEvent(ButtonPressedEvent.BUTTON_A);
+                break;
+            case END:
+                fireButtonReleasedEvent(ButtonPressedEvent.BUTTON_A);
+                break;
+        }
+    }
+
+    public void train(Signal signal) {
+        switch (signal) {
+            case BEGIN:
+                fireButtonPressedEvent(ButtonPressedEvent.BUTTON_B);
+                break;
+            case END:
+                fireButtonReleasedEvent(ButtonPressedEvent.BUTTON_B);
+                break;
+        }
+    }
+
+    public void close(Signal signal) {
+        switch (signal) {
+            case BEGIN:
+                fireButtonPressedEvent(ButtonPressedEvent.BUTTON_HOME);
+                break;
+            case END:
+                fireButtonReleasedEvent(ButtonPressedEvent.BUTTON_HOME);
+                break;
+        }
+    }
+
+    public void fireButtonPressedEvent(int button) {
+        ButtonPressedEvent buttonPressedEvent = new ButtonPressedEvent(this, button);
+        for (ButtonListener buttonListener : buttonlistener) {
+            buttonListener.buttonPressReceived(buttonPressedEvent);
+        }
+        if (buttonPressedEvent.isRecognitionInitEvent() || buttonPressedEvent.isTrainInitEvent()) {
+            resetAccelerationFilters();
+        }
+    }
+
+    public void fireButtonReleasedEvent(int button) {
+        ButtonReleasedEvent buttonReleasedEvent = new ButtonReleasedEvent(this, button); 
+        for (ButtonListener buttonListener : buttonlistener) {
+            buttonListener.buttonReleaseReceived(buttonReleasedEvent);
+        }
+    }
+
+    public void accelerationReceived(AccelerationEvent event) {}
+
+    public void motionStartReceived(MotionStartEvent event) {
+        System.out.println("Motion start !" + System.currentTimeMillis());
+        recognize(Signal.BEGIN);
+    }
+
+    public void motionStopReceived(MotionStopEvent event) {
+        System.out.println("Motion stop! " +  + System.currentTimeMillis());
+        recognize(Signal.END);
+    }
+}

java/exec.mimis/src/main/java/mimis/device/wiimote/motion/MotionData.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.device.wiimote.motion;
+
+import java.io.Serializable;
+
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+
+public class MotionData implements Serializable {
+    protected static final long serialVersionUID = 1L;
+
+    protected int time;
+    protected MotionSensingEvent event;
+
+    public MotionData(long time, MotionSensingEvent event) {
+        this((int) time, event);
+    }
+
+    public MotionData(int time, MotionSensingEvent event) {
+        this.time = time;
+        this.event = event;
+    }
+
+    public int getTime() {
+        return time;
+    }
+
+    public MotionSensingEvent getEvent() {
+        return event;
+    }
+}

java/exec.mimis/src/main/java/mimis/device/wiimote/motion/MotionDevice.java

@@ -0,0 +1,210 @@
+/**
+ * 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.wiimote.motion;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+
+import mimis.Component;
+import mimis.device.lirc.LircButton;
+import mimis.device.lirc.remote.PhiliphsRCLE011Button;
+import mimis.device.wiimote.WiimoteDevice;
+import mimis.input.Button;
+import mimis.input.button.ColorButton;
+import mimis.input.button.NumberButton;
+import mimis.input.state.State;
+import mimis.value.Action;
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public class MotionDevice extends Component {
+    protected WiimoteDevice wiimoteDevice;
+    protected int id;
+    protected long start;
+    protected boolean replay;
+    protected Action action;
+
+    public ReplayWork replayWork;
+    public ArrayList<MotionData> motionList;
+
+    public MotionDevice(WiimoteDevice wiimoteDevice) {
+        this.wiimoteDevice = wiimoteDevice;
+        id = 0;
+        start = -1;
+        replay = false;
+        action = Action.TRAIN;
+        replayWork = new ReplayWork();
+        motionList = new ArrayList<MotionData>();
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+        listen(State.class);
+    }
+
+    public void deactivate() throws DeactivateException {
+        replayWork.stop();
+        super.deactivate();
+    }
+
+    public void exit() {
+        super.exit();
+        replayWork.exit();
+    }
+
+    public void release(Button button) {
+        if (button instanceof LircButton) {
+            PhiliphsRCLE011Button lircButton = (PhiliphsRCLE011Button) button;
+            logger.debug(lircButton.getName());
+            switch (lircButton) {
+                case CLOCK:
+                    action = Action.TRAIN;
+                    break;
+                case OUT:
+                    action = Action.RECOGNIZE;
+                    break;
+                case MUTE:
+                    wiimoteDevice.begin(Action.CLOSE);
+                    break;
+                case SCREEN_UP:
+                    wiimoteDevice.begin(Action.SAVE);
+                    break;
+                case SCREEN_DOWN:
+                    wiimoteDevice.begin(Action.LOAD);
+                    break;
+                default:
+                    break;
+            }
+        } else if (button instanceof NumberButton) {
+            NumberButton numberButton = (NumberButton) button;
+            id = numberButton.ordinal();
+            if (replay == false) {
+                release(ColorButton.YELLOW);
+            } else {
+                logger.debug("Set file to #" + id);
+            }
+        } else if (button instanceof ColorButton) {
+            ColorButton colorButton = (ColorButton) button;
+            logger.debug(colorButton.name());
+            synchronized (motionList) {
+                switch (colorButton) {
+                    case GREEN:
+                        logger.debug("Start capturing motion");
+                        motionList.clear();
+                        start = System.currentTimeMillis();
+                        break;
+                    case RED:
+                        if (replayWork.active()) {
+                            logger.debug("Stop replaying motion");
+                            replayWork.stop();
+                        } else {
+                            logger.debug("Writing motion to file #" + id);
+                            try {                            
+                                FileOutputStream fileOutputStream = new FileOutputStream(String.format("tmp/motion #%d.bin", id));
+                                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
+                                objectOutputStream.writeObject(motionList.size());
+                                for (MotionData motionData : motionList) {
+                                    objectOutputStream.writeObject(motionData);
+                                }
+                                objectOutputStream.close();
+                            } catch (IOException e) {
+                                logger.error("", e);
+                            }
+                            motionList.clear();
+                            start = -1;
+                        }
+                        break;
+                    case YELLOW:
+                        logger.debug("Replaying motion from file #" + id);
+                        replay = true;
+                        replayWork.start();
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+
+    public void add(MotionSensingEvent event) {
+        if (start > 0) {
+            synchronized (motionList) {
+                motionList.add(new MotionData(System.currentTimeMillis() - start, event));
+            }
+        }
+    }
+
+    class ReplayWork extends Work {
+        protected ObjectInputStream objectInputStream;
+        protected int count, i, time;
+
+        public void activate() throws ActivateException {
+            try {
+                FileInputStream fileInputStream = new FileInputStream(String.format("tmp/motion #%d.bin", id));
+                objectInputStream = new ObjectInputStream(fileInputStream);
+                count = (Integer) objectInputStream.readObject();
+                i = time = 0;
+                wiimoteDevice.begin(action);
+                super.activate();
+                return;
+            } catch (FileNotFoundException e) {
+                logger.error("", e);
+            } catch (IOException e) {
+                logger.error("", e);
+            } catch (ClassNotFoundException e) {
+                logger.error("", e);
+            }
+        }
+
+        public void deactivate() throws DeactivateException {
+            logger.debug(String.format("Replay stopped (%d ms)", time));
+            wiimoteDevice.end(action);
+            replay = false;
+            try {
+                objectInputStream.close();
+            } catch (IOException e) {
+                logger.debug("", e);
+            }
+            super.deactivate();
+        }
+
+        public void work() {
+            if (i++ < count) {                
+                try {
+                    Object object = objectInputStream.readObject();
+                    MotionData motionData = (MotionData) object;
+                    wiimoteDevice.onMotionSensingEvent(motionData.getEvent());
+                    sleep(motionData.getTime() - time);
+                    time = motionData.getTime();                    
+                    return;
+                } catch (IOException e) {
+                    logger.error("", e);
+                } catch (ClassNotFoundException e) {
+                    logger.error("", e);
+                }
+            }
+            stop();
+        }        
+    }
+}

java/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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.value.Action;
+import mimis.input.Task;
+
+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/exec.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/exec.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/exec.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/exec.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/exec.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/exec.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);
+    }
+}