Zeer veel aanpassingen:

- omslachtigheden verbeterd
- netwerking gefixt
- ...

java/src/pm/event/EventHandler.java

@@ -0,0 +1,45 @@
+package pm.event;
+
+import pm.Event;
+import pm.event.task.Continuous;
+import pm.exception.InitialiseException;
+import pm.value.Action;
+
+public abstract class EventHandler extends EventListener {
+    protected static EventSpreader eventSpreader;
+
+    public static void initialise(EventSpreader eventSpreader) {
+        EventHandler.eventSpreader = eventSpreader;
+    }
+
+    public void initialise() throws InitialiseException {
+        eventSpreader.add(this);
+    }
+
+    public void event(Event event) {
+        if (event instanceof Feedback) {
+            feedback((Feedback) event);
+        } else if (event instanceof Task) {
+            task((Task) event);
+        }
+    }
+
+    protected void feedback(Feedback feedback) {}
+
+    protected void task(Task task) {
+        Action action = task.getAction();
+        if (task instanceof Continuous) {
+            Continuous continuous = (Continuous) task;
+            do {
+                action(action);
+                continuous.nextIteration();
+                sleep(continuous.getSleep());
+            } while (run && !continuous.getStop());
+            continuous.reset();
+        } else {
+            action(action);
+        }        
+    }
+
+    protected void action(Action action) {}
+}

java/src/pm/event/EventListener.java

@@ -1,47 +1,123 @@
 package pm.event;
 
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import pm.Event;
-import pm.Listener;
-import pm.event.task.Continuous;
-import pm.value.Action;
+import pm.Worker;
 
-public abstract class EventListener extends Listener implements Runnable {
-    protected static EventManager eventManager;
+public abstract class EventListener extends Worker {
+    protected Queue<Event> eventQueue;
+    protected Object available;
 
-    public static void initialise(EventManager eventManager) {
-        EventListener.eventManager = eventManager;
+    public EventListener() {
+        eventQueue = new ConcurrentLinkedQueue<Event>();
+        available = new Object();
     }
-    
+
+    public void add(Event event) {
+        eventQueue.add(event);
+        synchronized (available) {
+            available.notifyAll();
+        }
+    }
+
+    /*public Event get(Target target) {
+        while (eventQueue.isEmpty()) {
+            synchronized (available) {
+                try {
+                    available.await();
+                } catch (InterruptedException e) {}
+            }
+        }
+        Event event = eventQueue.peek();
+        if (event instanceof Task) {
+            Task task = (Task) event;
+            if (task.getTarget() == target) {
+                return eventQueue.poll();
+            } else {
+                return null;
+            }
+        } else {
+            return eventQueue.poll();
+        }
+    }
+
+    public Event gett(Target target) {
+        while (true) {
+            Event event = eventQueue.peek();
+            if (event instanceof Task) {
+                Task task = (Task) event;
+                if (task.getTarget() == target) {
+                    return get();
+                }
+            }
+        }
+    }
+
+    public Event get() {
+        return get(Target.ALL);
+    }*/
+
     public final void run() {
         while (run) {
-             event(eventManager.get());
-        }
+            while (eventQueue.isEmpty()) {
+                synchronized (available) {
+                    try {
+                        available.wait();
+                    } catch (InterruptedException e) {}
+                }
+            }
+            event(eventQueue.poll());
+       }
     }
 
-    protected void event(Event event) {
-        if (event instanceof Feedback) {
-            event((Feedback) event);
-        } else if (event instanceof Task) {
-            event((Task) event);
+    public abstract void event(Event event);
+
+    /*public static void add(Feedback feedback) {
+        for (EventListener eventListener : eventListenerList) {
+            eventListener.add(feedback);
         }
-    }
+    }*/
 
-    protected void event(Feedback feedback) {}
-
-    protected void event(Task task) {
-        Action action = task.getAction();
-        if (task instanceof Continuous) {
-            Continuous continuous = (Continuous) task;
-            do {
-                action(action);
-                continuous.nextIteration();
-                sleep(continuous.getSleep());
-            } while (run && !continuous.getStop());
-            continuous.reset();
+    /*public static void add(EventListener self, Task task) {
+        if (task instanceof Stopper) {
+            ((Stopper) task).stop();
         } else {
-            action(action);
-        }        
-    }
-
-    protected void action(Action action) {}
+            Target target = task.getTarget();
+            switch (target) {
+                case SELF:
+                    self.add(task);
+                    break;
+                case APPLICATION:
+                    if (applicationCycle.size() > 0) {
+                        applicationCycle.current().add(task);
+                    }
+                    break;
+                default: {
+                    for (EventListener eventListener : eventListenerList) {
+                        switch (target) {
+                            case ALL:
+                                eventListener.add(task);
+                                break;
+                            case MAIN:
+                                if (eventListener instanceof Main) {
+                                    eventListener.add(task);
+                                } 
+                                break;
+                            case DEVICES:
+                                if (eventListener instanceof Device) {
+                                    eventListener.add(task);
+                                } 
+                                break;
+                            case APPLICATIONS:
+                                if (eventListener instanceof Application) {
+                                    eventListener.add(task);
+                                } 
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+    }*/
 }

java/src/pm/event/EventManager.java

@@ -1,116 +0,0 @@
-package pm.event;
-
-import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
-import pm.Application;
-import pm.Event;
-import pm.util.ArrayCycle;
-import pm.value.Target;
-
-public class EventManager {
-    protected Queue<Event> eventQueue;
-    protected Lock lock;
-    protected Condition available;
-
-    public EventManager(ArrayCycle<Application> applicationCycle) {
-        eventQueue = new ConcurrentLinkedQueue<Event>();
-        lock = new ReentrantLock();
-        available = lock.newCondition();
-    }
-
-    public void add(Event event) {
-        eventQueue.add(event);
-        synchronized (available) {
-            lock.notifyAll();
-        }
-    }
-
-    public Event get(Target target) {
-        while (eventQueue.isEmpty()) {
-            synchronized (available) {
-                try {
-                    available.await();
-                } catch (InterruptedException e) {}
-            }
-        }
-        Event event = eventQueue.peek();
-        if (event instanceof Task) {
-            Task task = (Task) event;
-            if (task.getTarget() == target) {
-                return eventQueue.poll();
-            } else {
-                return null;
-            }
-        } else {
-            return eventQueue.poll();
-        }
-    }
-
-    public Event gett(Target target) {
-        while (true) {
-            Event event = eventQueue.peek();
-            if (event instanceof Task) {
-                Task task = (Task) event;
-                if (task.getTarget() == target) {
-                    return get();
-                }
-            }
-        }
-    }
-
-    public Event get() {
-        return get(Target.ALL);
-    }
-
-    /*public static void add(Feedback feedback) {
-        for (EventListener eventListener : eventListenerList) {
-            eventListener.add(feedback);
-        }
-    }*/
-
-    /*public static void add(EventListener self, Task task) {
-        if (task instanceof Stopper) {
-            ((Stopper) task).stop();
-        } else {
-            Target target = task.getTarget();
-            switch (target) {
-                case SELF:
-                    self.add(task);
-                    break;
-                case APPLICATION:
-                    if (applicationCycle.size() > 0) {
-                        applicationCycle.current().add(task);
-                    }
-                    break;
-                default: {
-                    for (EventListener eventListener : eventListenerList) {
-                        switch (target) {
-                            case ALL:
-                                eventListener.add(task);
-                                break;
-                            case MAIN:
-                                if (eventListener instanceof Main) {
-                                    eventListener.add(task);
-                                } 
-                                break;
-                            case DEVICES:
-                                if (eventListener instanceof Device) {
-                                    eventListener.add(task);
-                                } 
-                                break;
-                            case APPLICATIONS:
-                                if (eventListener instanceof Application) {
-                                    eventListener.add(task);
-                                } 
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-    }*/
-}

java/src/pm/event/EventSpreader.java

@@ -0,0 +1,26 @@
+package pm.event;
+
+import java.util.ArrayList;
+
+import pm.Application;
+
+public abstract class EventSpreader extends EventListener {
+    protected ArrayList<EventListener> eventListenerList;
+    protected Application application;
+
+    public void set(Application application) {
+        this.application = application;
+    }
+
+    public EventSpreader() {
+        eventListenerList = new ArrayList<EventListener>();
+    }
+
+    public void add(EventListener eventListener) {
+        eventListenerList.add(eventListener);
+    }
+
+    public void remove(EventListener eventListener) {
+        eventListenerList.remove(eventListener);
+    }
+}

java/src/pm/event/Feedback.java

@@ -1,7 +1,10 @@
 package pm.event;
 
 import pm.Event;
+import pm.value.Target;
 
-public class Feedback implements Event {
-    
-}
+public class Feedback extends Event {
+    public Feedback() {
+        super(Target.ALL);
+    }    
+}

java/src/pm/event/Task.java

@@ -4,13 +4,12 @@ import pm.Event;
 import pm.value.Action;
 import pm.value.Target;
 
-public class Task implements Event {
+public class Task extends Event {
     protected Action action;
-    protected Target target;
 
     public Task(Action action, Target target) {
+        super(target);
         this.action = action;
-        this.target = target;
     }
 
     public Task(Action action) {
@@ -20,8 +19,4 @@ public class Task implements Event {
     public Action getAction() {
         return action;
     }
-
-    public Target getTarget() {
-        return target;
-    }
 }

java/src/pm/event/spreader/LocalSpreader.java

@@ -0,0 +1,27 @@
+package pm.event.spreader;
+
+import pm.Event;
+import pm.event.EventListener;
+import pm.event.EventSpreader;
+import pm.value.Target;
+
+public class LocalSpreader extends EventSpreader {
+    public void event(Event event) {
+        System.out.println("localspread");
+        System.out.println(application);
+        Target target = event.getTarget();
+        switch (target) {
+            case APPLICATION:
+                if (application != null) {
+                    application.add(event);
+                }
+                break;
+            default:
+                for (EventListener eventListener : eventListenerList) {
+                    if (event.compatible(eventListener)) {
+                        eventListener.add(event);
+                    }
+                }
+        }
+    }
+}

java/src/pm/event/spreader/NetworkSpreader.java

@@ -0,0 +1,34 @@
+package pm.event.spreader;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import pm.Event;
+import pm.event.EventSpreader;
+import pm.exception.event.spreader.NetworkSpreaderException;
+
+public class NetworkSpreader extends EventSpreader {
+    protected Socket socket;
+    protected ObjectOutputStream objectOutputStream;
+
+    public NetworkSpreader(String ip, int port) throws NetworkSpreaderException {
+        try {
+            socket = new Socket(ip, port);
+            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
+            return;
+        } catch (UnknownHostException e) {
+        } catch (IOException e) {}
+        throw new NetworkSpreaderException();
+    }
+
+    public void event(Event event) {
+        System.out.println("NetworkSpreader: event!");
+        //System.out.println(socket.isConnected());
+        try {
+            objectOutputStream.writeObject(event);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}