001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.gui.progress;
003
004import java.util.Arrays;
005import java.util.Iterator;
006import java.util.LinkedList;
007import java.util.Queue;
008
009/**
010 * This class contains the progress logic required to implement a {@link ProgressMonitor}.
011 */
012public abstract class AbstractProgressMonitor implements ProgressMonitor {
013
014    private static final class Request {
015        private AbstractProgressMonitor originator;
016        private int childTicks;
017        private double currentValue;
018
019        private String title;
020        private String customText;
021        private String extraText;
022        private Boolean intermediate;
023
024        private boolean finishRequested;
025    }
026
027    private final CancelHandler cancelHandler;
028
029    /**
030     * Progress monitor state
031     * @since 12675 (visibility)
032     */
033    public enum State {
034        /** Initialization. Next valid states are {@link #IN_TASK} or {@link #FINISHED} */
035        INIT,
036        /** In task. Next valid states are {@link #IN_SUBTASK} or {@link #FINISHED} */
037        IN_TASK,
038        /** In subtask. Next valid states is {@link #IN_TASK} */
039        IN_SUBTASK,
040        /** Finished. Can't change state after that */
041        FINISHED
042    }
043
044    protected State state = State.INIT;
045
046    private int ticksCount;
047    private int ticks;
048    private int childTicks;
049
050    private String taskTitle;
051    private String customText;
052    private String extraText;
053    private String shownTitle;
054    private String shownCustomText;
055    private boolean intermediateTask;
056
057    private final Queue<Request> requests = new LinkedList<>();
058    private AbstractProgressMonitor currentChild;
059    private Request requestedState = new Request();
060
061    protected abstract void doBeginTask();
062
063    protected abstract void doFinishTask();
064
065    protected abstract void doSetIntermediate(boolean value);
066
067    protected abstract void doSetTitle(String title);
068
069    protected abstract void doSetCustomText(String title);
070
071    /**
072     * Create a new {@link AbstractProgressMonitor}
073     * @param cancelHandler The handler that gets notified when the process is canceled.
074     */
075    protected AbstractProgressMonitor(CancelHandler cancelHandler) {
076        this.cancelHandler = cancelHandler;
077    }
078
079    protected void checkState(State... expectedStates) {
080        for (State s:expectedStates) {
081            if (s == state)
082                return;
083        }
084        throw new ProgressException("Expected states are %s but current state is %s", Arrays.asList(expectedStates).toString(), state);
085    }
086
087    /*=======
088     * Tasks
089     =======*/
090
091    @Override
092    public void beginTask(String title) {
093        beginTask(title, DEFAULT_TICKS);
094    }
095
096    @Override
097    public synchronized void beginTask(String title, int ticks) {
098        this.taskTitle = title;
099        checkState(State.INIT);
100        state = State.IN_TASK;
101        doBeginTask();
102        setTicksCount(ticks);
103        resetState();
104    }
105
106    @Override
107    public synchronized void finishTask() {
108        if (state != State.FINISHED) {
109
110            if (state == State.IN_SUBTASK) {
111                requestedState.finishRequested = true;
112            } else {
113                checkState(State.IN_TASK);
114                state = State.FINISHED;
115                doFinishTask();
116            }
117        }
118    }
119
120    @Override
121    public synchronized void invalidate() {
122        if (state == State.INIT) {
123            state = State.FINISHED;
124            doFinishTask();
125        }
126    }
127
128    @Override
129    public synchronized void subTask(final String title) {
130        if (state == State.IN_SUBTASK) {
131            if (title != null) {
132                requestedState.title = title;
133            }
134            requestedState.intermediate = Boolean.FALSE;
135        } else {
136            checkState(State.IN_TASK);
137            if (title != null) {
138                this.taskTitle = title;
139                resetState();
140            }
141            this.intermediateTask = false;
142            doSetIntermediate(false);
143        }
144    }
145
146    @Override
147    public synchronized void indeterminateSubTask(String title) {
148        if (state == State.IN_SUBTASK) {
149            if (title != null) {
150                requestedState.title = title;
151            }
152            requestedState.intermediate = Boolean.TRUE;
153        } else {
154            checkState(State.IN_TASK);
155            if (title != null) {
156                this.taskTitle = title;
157                resetState();
158            }
159            this.intermediateTask = true;
160            doSetIntermediate(true);
161        }
162    }
163
164    @Override
165    public synchronized void setCustomText(String text) {
166        if (state == State.IN_SUBTASK) {
167            requestedState.customText = text;
168        } else {
169            this.customText = text;
170            resetState();
171        }
172    }
173
174    @Override
175    public synchronized void setExtraText(String text) {
176        if (state == State.IN_SUBTASK) {
177            requestedState.extraText = text;
178        } else {
179            this.extraText = text;
180            resetState();
181        }
182    }
183
184    /**
185     * Default implementation is empty. Override in subclasses to display the log messages.
186     */
187    @Override
188    public void appendLogMessage(String message) {
189        // do nothing
190    }
191
192    private void resetState() {
193        String newTitle;
194        if (extraText != null) {
195            newTitle = taskTitle + ' ' + extraText;
196        } else {
197            newTitle = taskTitle;
198        }
199
200        if (newTitle == null ? shownTitle != null : !newTitle.equals(shownTitle)) {
201            shownTitle = newTitle;
202            doSetTitle(shownTitle);
203        }
204
205        if (customText == null ? shownCustomText != null : !customText.equals(shownCustomText)) {
206            shownCustomText = customText;
207            doSetCustomText(shownCustomText);
208        }
209        doSetIntermediate(intermediateTask);
210    }
211
212    @Override
213    public void cancel() {
214        cancelHandler.cancel();
215    }
216
217    @Override
218    public boolean isCanceled() {
219        return cancelHandler.isCanceled();
220    }
221
222    @Override
223    public void addCancelListener(CancelListener listener) {
224        cancelHandler.addCancelListener(listener);
225    }
226
227    @Override
228    public void removeCancelListener(CancelListener listener) {
229        cancelHandler.removeCancelListener(listener);
230    }
231
232    /*=================
233     * Ticks handling
234    ==================*/
235
236    /**
237     * Update progress message
238     * @param value The percentage of completion (this and child progress)
239     */
240    protected abstract void updateProgress(double value);
241
242    @Override
243    public synchronized void setTicks(int ticks) {
244        if (ticks >= ticksCount) {
245            ticks = ticksCount - 1;
246        }
247        this.ticks = ticks;
248        internalUpdateProgress(0);
249    }
250
251    @Override
252    public synchronized void setTicksCount(int ticks) {
253        this.ticksCount = ticks;
254        internalUpdateProgress(0);
255    }
256
257    @Override
258    public void worked(int ticks) {
259        if (ticks == ALL_TICKS) {
260            setTicks(this.ticksCount - 1);
261        } else {
262            setTicks(this.ticks + ticks);
263        }
264    }
265
266    private void internalUpdateProgress(double childProgress) {
267        if (childProgress > 1) {
268            childProgress = 1;
269        }
270        checkState(State.IN_TASK, State.IN_SUBTASK);
271        updateProgress(ticksCount == 0 ? 0 : (ticks + childProgress * childTicks) / ticksCount);
272    }
273
274    @Override
275    public synchronized int getTicks() {
276        return ticks;
277    }
278
279    @Override
280    public synchronized int getTicksCount() {
281        return ticksCount;
282    }
283
284    /*==========
285     * Subtasks
286     ==========*/
287
288    @Override
289    public synchronized ProgressMonitor createSubTaskMonitor(int ticks, boolean internal) {
290        if (ticks == ALL_TICKS) {
291            ticks = ticksCount - this.ticks;
292        }
293
294        if (state == State.IN_SUBTASK) {
295            Request request = new Request();
296            request.originator = new ChildProgress(this, cancelHandler, internal);
297            request.childTicks = ticks;
298            requests.add(request);
299            return request.originator;
300        } else {
301            checkState(State.IN_TASK);
302            state = State.IN_SUBTASK;
303            this.childTicks = ticks;
304            currentChild = new ChildProgress(this, cancelHandler, internal);
305            return currentChild;
306        }
307    }
308
309    private void applyChildRequest(Request request) {
310        if (request.customText != null) {
311            doSetCustomText(request.customText);
312        }
313
314        if (request.title != null) {
315            doSetTitle(request.title);
316        }
317
318        if (request.intermediate != null) {
319            doSetIntermediate(request.intermediate);
320        }
321
322        internalUpdateProgress(request.currentValue);
323    }
324
325    private void applyThisRequest(Request request) {
326        if (request.finishRequested) {
327            finishTask();
328        } else {
329            if (request.customText != null) {
330                this.customText = request.customText;
331            }
332
333            if (request.title != null) {
334                this.taskTitle = request.title;
335            }
336
337            if (request.intermediate != null) {
338                this.intermediateTask = request.intermediate;
339            }
340
341            if (request.extraText != null) {
342                this.extraText = request.extraText;
343            }
344
345            resetState();
346        }
347    }
348
349    protected synchronized void childFinished(AbstractProgressMonitor child) {
350        checkState(State.IN_SUBTASK);
351        if (currentChild == child) {
352            setTicks(ticks + childTicks);
353            if (requests.isEmpty()) {
354                state = State.IN_TASK;
355                applyThisRequest(requestedState);
356                requestedState = new Request();
357            } else {
358                Request newChild = requests.poll();
359                currentChild = newChild.originator;
360                childTicks = newChild.childTicks;
361                applyChildRequest(newChild);
362            }
363        } else {
364            Iterator<Request> it = requests.iterator();
365            while (it.hasNext()) {
366                if (it.next().originator == child) {
367                    it.remove();
368                    return;
369                }
370            }
371            throw new ProgressException("Subtask %s not found", child);
372        }
373    }
374
375    private Request getRequest(AbstractProgressMonitor child) {
376        for (Request request:requests) {
377            if (request.originator == child)
378                return request;
379        }
380        throw new ProgressException("Subtask %s not found", child);
381    }
382
383    protected synchronized void childSetProgress(AbstractProgressMonitor child, double value) {
384        checkState(State.IN_SUBTASK);
385        if (currentChild == child) {
386            internalUpdateProgress(value);
387        } else {
388            getRequest(child).currentValue = value;
389        }
390    }
391
392    protected synchronized void childSetTitle(AbstractProgressMonitor child, String title) {
393        checkState(State.IN_SUBTASK);
394        if (currentChild == child) {
395            doSetTitle(title);
396        } else {
397            getRequest(child).title = title;
398        }
399    }
400
401    protected synchronized void childSetCustomText(AbstractProgressMonitor child, String customText) {
402        checkState(State.IN_SUBTASK);
403        if (currentChild == child) {
404            doSetCustomText(customText);
405        } else {
406            getRequest(child).customText = customText;
407        }
408    }
409
410    protected synchronized void childSetIntermediate(AbstractProgressMonitor child, boolean value) {
411        checkState(State.IN_SUBTASK);
412        if (currentChild == child) {
413            doSetIntermediate(value);
414        } else {
415            getRequest(child).intermediate = value;
416        }
417    }
418}