debug
[fanfix.git] / src / be / nikiroo / utils / ui / DelayWorker.java
1 package be.nikiroo.utils.ui;
2
3 import java.beans.PropertyChangeEvent;
4 import java.beans.PropertyChangeListener;
5 import java.util.ArrayList;
6 import java.util.HashMap;
7 import java.util.Map;
8 import java.util.TreeSet;
9
10 import javax.swing.SwingWorker;
11
12 /**
13 * This class helps you delay some graphical actions and execute the most recent
14 * ones when under contention.
15 * <p>
16 * How does it work?
17 * <ul>
18 * <li>it takes an ID and an associated {@link SwingWorker} and will call
19 * {@link SwingWorker#execute()} after a small delay (see
20 * {@link DelayWorker#DelayWorker(int)})</li>
21 * <li>if a second call to {@link DelayWorker#delay(String, SwingWorker)} comes
22 * with the same ID before the first one is done, it will be put on a waiting
23 * queue</li>
24 * <li>if a third call still with the same ID comes, its associated worker will
25 * <b>replace</b> the one in the queue (only one worker per ID in the queue,
26 * always the latest one)</li>
27 * <li>when the first worker is done, it will check the waiting queue and
28 * execute that latest worker if any</li>
29 * </ul>
30 *
31 * @author niki
32 *
33 */
34 @SuppressWarnings("rawtypes")
35 public class DelayWorker {
36 private Map<String, SwingWorker> lazyEnCours;
37 private Object lazyEnCoursLock;
38
39 private TreeSet<String> wip;
40
41 private Object waiter;
42
43 private boolean cont;
44 private boolean paused;
45 private Thread loop;
46
47 /**
48 * Create a new {@link DelayWorker} with the given delay (in milliseconds)
49 * before each drain of the queue.
50 *
51 * @param delayMs
52 * the delay in milliseconds (can be 0, cannot be negative)
53 */
54 public DelayWorker(final int delayMs) {
55 if (delayMs < 0) {
56 throw new IllegalArgumentException(
57 "A waiting delay cannot be negative");
58 }
59
60 lazyEnCours = new HashMap<String, SwingWorker>();
61 lazyEnCoursLock = new Object();
62 wip = new TreeSet<String>();
63 waiter = new Object();
64 cont = true;
65 paused = false;
66
67 loop = new Thread(new Runnable() {
68 @Override
69 public void run() {
70 while (cont) {
71 try {
72 Thread.sleep(delayMs);
73 } catch (InterruptedException e) {
74 }
75
76 Map<String, SwingWorker> workers = new HashMap<String, SwingWorker>();
77 synchronized (lazyEnCoursLock) {
78 for (String key : new ArrayList<String>(
79 lazyEnCours.keySet())) {
80 if (!wip.contains(key)) {
81 workers.put(key, lazyEnCours.remove(key));
82 }
83 }
84 }
85
86 for (final String key : workers.keySet()) {
87 SwingWorker worker = workers.get(key);
88
89 synchronized (lazyEnCoursLock) {
90 wip.add(key);
91 }
92
93 worker.addPropertyChangeListener(
94 new PropertyChangeListener() {
95 @Override
96 public void propertyChange(
97 PropertyChangeEvent evt) {
98 synchronized (lazyEnCoursLock) {
99 wip.remove(key);
100 }
101 wakeup();
102 }
103 });
104
105 // Start it, at last
106 worker.execute();
107 }
108
109 synchronized (waiter) {
110 do {
111 try {
112 if (cont)
113 waiter.wait();
114 } catch (InterruptedException e) {
115 }
116 } while (cont && paused);
117 }
118 }
119 }
120 });
121
122 loop.setDaemon(true);
123 loop.setName("Loop for DelayWorker");
124 }
125
126 /**
127 * Start the internal loop that will drain the processing queue. <b>MUST
128 * NOT</b> be started twice (but see {@link DelayWorker#pause()} and
129 * {@link DelayWorker#resume()} instead).
130 */
131 public void start() {
132 loop.start();
133 }
134
135 /**
136 * Pause the system until {@link DelayWorker#resume()} is called -- note
137 * that it will still continue on the processes currently scheduled to run,
138 * but will pause after that.
139 * <p>
140 * Can be called even if already paused, will just do nothing in that
141 * context.
142 */
143 public void pause() {
144 paused = true;
145 }
146
147 /**
148 * Check if the {@link DelayWorker} is currently paused.
149 *
150 * @return TRUE if it is
151 */
152 public boolean isPaused() {
153 return paused;
154 }
155
156 /**
157 * Resume the system after a pause.
158 * <p>
159 * Can be called even if already running, will just do nothing in that
160 * context.
161 */
162 public void resume() {
163 synchronized (waiter) {
164 paused = false;
165 wakeup();
166 }
167 }
168
169 /**
170 * Stop the system.
171 * <p>
172 * Note: this is final, you <b>MUST NOT</b> call {@link DelayWorker#start()}
173 * a second time (but see {@link DelayWorker#pause()} and
174 * {@link DelayWorker#resume()} instead).
175 */
176 public void stop() {
177 synchronized (waiter) {
178 cont = false;
179 wakeup();
180 }
181 }
182
183 /**
184 * Clear all the processes that were put on the queue but not yet scheduled
185 * to be executed -- note that it will still continue on the processes
186 * currently scheduled to run.
187 */
188 public void clear() {
189 synchronized (lazyEnCoursLock) {
190 lazyEnCours.clear();
191 wip.clear();
192 }
193 }
194
195 /**
196 * Put a new process in the delay queue.
197 *
198 * @param id
199 * the ID of this process (if you want to skip workers when they
200 * are superseded by a new one, you need to use the same ID key)
201 * @param worker
202 * the process to delay
203 */
204 public void delay(String id, SwingWorker worker) {
205 synchronized (lazyEnCoursLock) {
206 lazyEnCours.put(id, worker);
207 }
208
209 wakeup();
210 }
211
212 /**
213 * Wake up the loop thread.
214 */
215 private void wakeup() {
216 synchronized (waiter) {
217 waiter.notifyAll();
218 }
219 }
220 }