src/be/nikiroo/fanfix_swing/gui/utils/DelayWorker.java

   1 package be.nikiroo.fanfix_swing.gui.utils;
   2
   3 import java.util.HashMap;
   4 import java.util.LinkedList;
   5 import java.util.List;
   6 import java.util.Map;
   7
   8 import javax.swing.SwingWorker;
   9
  10 @SuppressWarnings("rawtypes")
  11 public class DelayWorker {
  12         private Map<String, SwingWorker> lazyEnCours;
  13         private Object lazyEnCoursLock;
  14
  15         private Object waiter;
  16
  17         private boolean cont;
  18         private boolean paused;
  19         private Thread loop;
  20
  21         public DelayWorker(final int delayMs) {
  22                 lazyEnCours = new HashMap<String, SwingWorker>();
  23                 lazyEnCoursLock = new Object();
  24                 waiter = new Object();
  25                 cont = true;
  26                 paused = false;
  27
  28                 loop = new Thread(new Runnable() {
  29                         @Override
  30                         public void run() {
  31                                 while (cont) {
  32                                         try {
  33                                                 Thread.sleep(delayMs);
  34                                         } catch (InterruptedException e) {
  35                                         }
  36
  37                                         List<SwingWorker> workers;
  38                                         synchronized (lazyEnCoursLock) {
  39                                                 workers = new LinkedList<SwingWorker>(
  40                                                                 lazyEnCours.values());
  41                                                 lazyEnCours.clear();
  42                                         }
  43                                         for (SwingWorker worker : workers) {
  44                                                 worker.execute();
  45                                         }
  46
  47                                         synchronized (waiter) {
  48                                                 do {
  49                                                         try {
  50                                                                 if (cont)
  51                                                                         waiter.wait();
  52                                                         } catch (InterruptedException e) {
  53                                                         }
  54                                                 } while (cont && paused);
  55                                         }
  56                                 }
  57                         }
  58                 });
  59                 loop.setDaemon(true);
  60                 loop.setName("Loop for DelayWorker");
  61         }
  62
  63         // twice = not legal
  64         public void start() {
  65                 loop.start();
  66         }
  67
  68         public void pause() {
  69                 paused = true;
  70         }
  71
  72         public boolean isPaused() {
  73                 return paused;
  74         }
  75
  76         public void resume() {
  77                 synchronized (waiter) {
  78                         paused = false;
  79                         wakeup();
  80                 }
  81         }
  82
  83         public void stop() {
  84                 synchronized (waiter) {
  85                         cont = false;
  86                         wakeup();
  87                 }
  88         }
  89
  90         public void clear() {
  91                 synchronized (lazyEnCoursLock) {
  92                         lazyEnCours.clear();
  93                 }
  94         }
  95
  96         public <T, V> void delay(final String id, final SwingWorker<T, V> worker) {
  97                 synchronized (lazyEnCoursLock) {
  98                         lazyEnCours.put(id, worker);
  99                 }
 100
 101                 wakeup();
 102         }
 103
 104         private void wakeup() {
 105                 synchronized (waiter) {
 106                         waiter.notifyAll();
 107                 }
 108         }
 109 }