Macro systeem veralgemeniseerd naar Sequence. Sequence maakt het mogelijk om de automatische toegevoegde events bij macro's te omzeilen. Hier wordt gebruik van gemaakt bij de Continuous task, want deze moet alle vrijheid hebben. Nu is in de vele shortcut-sequence add functies nog geen beveiliging om oneindige Continuous tasks uit te voeren. De verantwoordelijkheid hiervoor ligt bij de gebruiker of een toekomstige controle.

java/src/pm/Application.java

@@ -11,7 +11,7 @@ public abstract class Application extends TaskListener {
             initialise();
             super.run();
         } catch (ApplicationInitialiseException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // Todo: dit "over" de thread heengooien / loggen?
         }
     }
 
@@ -25,10 +25,10 @@ public abstract class Application extends TaskListener {
         Action action = task.getAction();
         if (task instanceof Continuous) {
             Continuous continuous = (Continuous) task;
-            int sleep = continuous.getSleep();
             do {
                 action(action);
-                sleep(sleep);
+                continuous.nextIteration();
+                sleep(continuous.getSleep());
             } while (run && !continuous.getStop());
             continuous.reset();
         } else {

java/src/pm/Device.java

@@ -3,32 +3,37 @@ package pm;
 import pm.exception.device.DeviceExitException;
 import pm.exception.device.DeviceInitialiseException;
 import pm.macro.Event;
-import pm.macro.MacroListener;
 import pm.macro.event.Hold;
 import pm.macro.event.Press;
 import pm.macro.event.Release;
+import pm.macro.event.Sequence;
+import pm.macro.event.SequenceListener;
 import pm.task.Continuous;
 import pm.task.Stopper;
 
 public abstract class Device {
-    protected MacroListener macroListener;
+    protected SequenceListener sequenceListener;
 
     public Device() {
-        macroListener = new MacroListener();
+        sequenceListener = new SequenceListener();
     }
 
     /* Register macro's */
-    protected void add(Macro macro, Task task) {
+    protected void add(Sequence sequence, Task task) {
-        macroListener.add(macro, task);
+        sequenceListener.add(sequence, task);
+    }
+
+    protected void add(Press press, Task task) {
+        add(new Macro(press), task);
     }
 
     protected void add(Event event, Task task) {
-        add(new Macro(event), task);
+        add(new Sequence(event), task);
     }
 
-    protected void add(Macro startMacro, Macro stopMacro, Continuous continuous) {
+    protected void add(Sequence startSequence, Sequence stopSequence, Continuous continuous) {
-        add(startMacro, continuous);
+        add(startSequence, continuous);
-        add(stopMacro, new Stopper(continuous));        
+        add(stopSequence, new Stopper(continuous));        
     }
 
     protected void add(Event startEvent, Event stopEvent, Continuous continuous) {
@@ -36,6 +41,11 @@ public abstract class Device {
         add(stopEvent, new Stopper(continuous));        
     }
 
+    protected void add(Press startPress, Press stopPress, Continuous continuous) {
+        add(new Macro(startPress), continuous);
+        add(new Macro(stopPress), new Stopper(continuous));        
+    }
+
     protected void add(Hold hold, Continuous continuous) {
         Button button = hold.getButton();
         add(new Press(button), new Release(button), continuous);
@@ -43,7 +53,7 @@ public abstract class Device {
 
     /* Recognize events */
     protected void add(Event event) {
-        macroListener.add(event);
+        sequenceListener.add(event);
     }
 
     /* Device default methods */

java/src/pm/Macro.java

@@ -5,15 +5,15 @@ import java.util.ArrayList;
 import pm.exception.MacroException;
 import pm.exception.macro.MacroEventOrderException;
 import pm.macro.Event;
+import pm.macro.event.Sequence;
 import pm.macro.event.Hold;
 import pm.macro.event.Press;
 import pm.macro.event.Release;
 
-public class Macro {
+public class Macro extends Sequence {
-    protected Event[] eventArray;
+    public Macro(Press press) {
-
+        Button button = press.getButton();
-    public Macro(Event event) {
+        this.eventArray = new Event[] {press, new Release(button)};
-        eventArray = new Event[]{event};
     }
 
     public Macro(Event... eventArray) throws MacroException {
@@ -44,14 +44,6 @@ public class Macro {
         if (!holdList.isEmpty()) {
             throw new MacroEventOrderException("One or more buttons are not released.");
         }
-        this.eventArray = (Event[]) eventList.toArray(new Event[0]);
+        eventArray = (Event[]) eventList.toArray(new Event[0]);
-    }
-
-    public int count() {
-        return eventArray.length;
-    }
-
-    public Event get(int i) {
-        return eventArray[i];
     }
 }

java/src/pm/application/iTunes/iTunesApplication.java

@@ -10,7 +10,7 @@ import com.dt.iTunesController.iTunes;
 import com.dt.iTunesController.iTunesEventsInterface;
 
 public class iTunesApplication extends Application implements iTunesEventsInterface {
-    protected static final int POSTION_CHANGE_RATE = 5;
+    protected static final int POSTION_CHANGE_RATE = 1;
     protected static final int VOLUME_CHANGE_RATE = 5;
     protected static final int SEEK_TIME = 1000;
 

java/src/pm/device/javainput/rumblepad/RumblepadDevice.java

@@ -37,10 +37,12 @@ public class RumblepadDevice extends JavaInputDevice {
             new Task(Action.PREVIOUS, Target.APPLICATION));
         add(
             new Hold(RumblepadButton.FIVE),
-            new Continuous(Action.FORWARD, Target.APPLICATION, 300));
+            new Continuous(Action.FORWARD, Target.APPLICATION, 200){
+                public int getSleep() {return sleep - 30 * iteration;}});
         add(
             new Hold(RumblepadButton.SEVEN),
-            new Continuous(Action.REWIND, Target.APPLICATION, 300));
+            new Continuous(Action.REWIND, Target.APPLICATION, 200){
+                public int getSleep() {return sleep - 30 * iteration;}});
         add(
             new Hold(RumblepadButton.NINE),
             new Continuous(Action.VOLUME_DOWN, Target.APPLICATION, 100));

java/src/pm/macro/Active.java

@@ -1,26 +1,26 @@
 package pm.macro;
 
-import pm.Macro;
+import pm.macro.event.Sequence;
 
 public class Active {
-    protected Macro macro;
+    protected Sequence sequence;
     protected int step;
 
-    public Active(Macro macro) {
+    public Active(Sequence sequence) {
-        this.macro = macro;
+        this.sequence = sequence;
         step = -1;
     }
 
-    public Macro getMacro() {
+    public Sequence getSequence() {
-        return macro;
+        return sequence;
     }
 
     public boolean next(Event event) {
-        Event next = macro.get(++step);
+        Event next = sequence.get(++step);
         return next == null ? false : event.equals(next);
     }
 
     public boolean last() {
-        return step == macro.count() - 1;
+        return step == sequence.count() - 1;
     }
 }

java/src/pm/macro/event/Sequence.java

@@ -0,0 +1,20 @@
+package pm.macro.event;
+
+import pm.macro.Event;
+
+
+public class Sequence {
+    protected Event[] eventArray;
+
+    public Sequence(Event... eventArray) {
+        this.eventArray = eventArray;
+    }
+
+    public int count() {
+        return eventArray.length;
+    }
+
+    public Event get(int i) {
+        return eventArray.length > 0 ? eventArray[i] : null;
+    }
+}

java/src/pm/macro/event/SequenceListener.java

@@ -1,37 +1,38 @@
-package pm.macro;
+package pm.macro.event;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 
-import pm.Macro;
 import pm.Task;
+import pm.macro.Active;
+import pm.macro.Event;
 import pm.task.TaskGatherer;
 
-public class MacroListener {
+public class SequenceListener {
-    public ArrayList<Macro> macroList;
+    public ArrayList<Sequence> sequenceList;
-    public HashMap<Macro, Task> taskMap;
+    public HashMap<Sequence, Task> taskMap;
     public ArrayList<Active> activeList;
 
-    public MacroListener() {
+    public SequenceListener() {
-        macroList = new ArrayList<Macro>();
+        sequenceList = new ArrayList<Sequence>();
-        taskMap = new HashMap<Macro, Task>();
+        taskMap = new HashMap<Sequence, Task>();
         activeList = new ArrayList<Active>();
     }
 
-    public void add(Macro macro, Task task) {
+    public void add(Sequence sequence, Task task) {
-        macroList.add(macro);
+        sequenceList.add(sequence);
-        taskMap.put(macro, task);
+        taskMap.put(sequence, task);
     }
 
     public void add(Event event) {
-        for (Macro macro : macroList) {
+        for (Sequence sequence : sequenceList) {
-            activeList.add(new Active(macro));
+            activeList.add(new Active(sequence));
         }
         ArrayList<Active> removeList = new ArrayList<Active>();
         for (Active active : activeList) {
             if (active.next(event)) {
                 if (active.last()) {
-                    Task task = taskMap.get(active.getMacro());
+                    Task task = taskMap.get(active.getSequence());
                     TaskGatherer.add(task);
                     removeList.add(active);
                 }

java/src/pm/task/Continuous.java

@@ -6,6 +6,7 @@ import pm.Task;
 
 public class Continuous extends Task {
     protected int sleep;
+    protected int iteration;
     protected boolean stop;
 
     public Continuous(Action action, Target target, int sleep) {
@@ -18,11 +19,16 @@ public class Continuous extends Task {
         this(action, target, 0);
     }
 
+    public void nextIteration() {
+        ++iteration;
+    }
+
     public void stop() {
         stop = true;
     }
 
     public void reset() {
+        iteration = 0;
         stop = false;
     }
 

java/src/pm/task/TaskListener.java

@@ -41,7 +41,9 @@ public abstract class TaskListener implements Runnable {
 
     protected void sleep(int time) {
         try {
-            Thread.sleep(time);
+            if (time > 0) {
+                Thread.sleep(time);
+            }
         } catch (InterruptedException e) {}
     }