X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2FProgress.java;h=6f05110e8715305b438258b45cf1674b992a4451;hb=f4053377fa15da2f11e82955bfab86e673fa371c;hp=2872530b68542585783467e3241835072e75570a;hpb=cd0c27d2e457ea19fcd9def879e1534a528292c2;p=nikiroo-utils.git diff --git a/src/be/nikiroo/utils/Progress.java b/src/be/nikiroo/utils/Progress.java index 2872530..6f05110 100644 --- a/src/be/nikiroo/utils/Progress.java +++ b/src/be/nikiroo/utils/Progress.java @@ -6,7 +6,6 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; -import java.util.Set; /** * Progress reporting system, possibly nested. @@ -14,6 +13,12 @@ import java.util.Set; * @author niki */ public class Progress { + /** + * This event listener is designed to report progress events from + * {@link Progress}. + * + * @author niki + */ public interface ProgressListener extends EventListener { /** * A progression event. @@ -37,8 +42,8 @@ public class Progress { private List listeners; private int min; private int max; - private int localProgress; - private int progress; // children included + private double relativeLocalProgress; + private double relativeProgress; // children included /** * Create a new default unnamed {@link Progress}, from 0 to 100. @@ -106,7 +111,7 @@ public class Progress { */ public void setName(String name) { this.name = name; - changed(this); + changed(this, name); } /** @@ -125,17 +130,17 @@ public class Progress { * the min to set * * - * @throws Error + * @throws RuntimeException * if min < 0 or if min > max */ public void setMin(int min) { if (min < 0) { - throw new Error("negative values not supported"); + throw new RuntimeException("negative values not supported"); } synchronized (getLock()) { if (min > max) { - throw new Error( + throw new RuntimeException( "The minimum progress value must be <= the maximum progress value"); } @@ -159,7 +164,7 @@ public class Progress { * the max to set * * - * @throws Error + * @throws RuntimeException * if max < min */ public void setMax(int max) { @@ -181,16 +186,16 @@ public class Progress { * @param max * the max * - * @throws Error + * @throws RuntimeException * if min < 0 or if min > max */ public void setMinMax(int min, int max) { if (min < 0) { - throw new Error("negative values not supported"); + throw new RuntimeException("negative values not supported"); } if (min > max) { - throw new Error( + throw new RuntimeException( "The minimum progress value must be <= the maximum progress value"); } @@ -208,7 +213,7 @@ public class Progress { * @return the progress the value */ public int getProgress() { - return progress; + return (int) Math.round(relativeProgress * (max - min)); } /** @@ -221,12 +226,59 @@ public class Progress { */ public void setProgress(int progress) { synchronized (getLock()) { - int diff = this.progress - this.localProgress; - this.localProgress = progress; - setTotalProgress(this, name, progress + diff); + double childrenProgress = relativeProgress - relativeLocalProgress; + + relativeLocalProgress = ((double) progress) / (max - min); + + setRelativeProgress(this, name, relativeLocalProgress + + childrenProgress); } } + /** + * Get the total progress value (including the optional children + * {@link Progress}) on a 0.0 to 1.0 scale. + * + * @return the progress + */ + public double getRelativeProgress() { + return relativeProgress; + } + + /** + * Set the total progress value (including the optional children + * {@link Progress}), on a 0 to 1 scale. + * + * @param pg + * the {@link Progress} to report as the progression emitter + * @param name + * the current name (if it is NULL, the first non-null name in + * the hierarchy will overwrite it) of the {@link Progress} who + * emitted this change + * @param relativeProgress + * the progress to set + */ + private void setRelativeProgress(Progress pg, String name, + double relativeProgress) { + synchronized (getLock()) { + relativeProgress = Math.max(0, relativeProgress); + relativeProgress = Math.min(1, relativeProgress); + this.relativeProgress = relativeProgress; + + changed(pg, name); + } + } + + /** + * Get the total progress value (including the optional children + * {@link Progress}) on a 0 to 1 scale. + * + * @return the progress the value + */ + private int getLocalProgress() { + return (int) Math.round(relativeLocalProgress * (max - min)); + } + /** * Add some value to the current progression of this {@link Progress}. * @@ -235,7 +287,7 @@ public class Progress { */ public void add(int step) { synchronized (getLock()) { - setProgress(localProgress + step); + setProgress(getLocalProgress() + step); } } @@ -246,28 +298,18 @@ public class Progress { * @return TRUE if it is */ public boolean isDone() { - return progress >= max; + return getProgress() == max; } /** * Mark the {@link Progress} as done by setting its value to max. */ public void done() { - setProgress(getMax()); - } - - /** - * Get the total progress value (including the optional children - * {@link Progress}) on a 0.0 to 1.0 scale. - * - * @return the progress - */ - public double getRelativeProgress() { - if (max == min) { - return 1; + synchronized (getLock()) { + double childrenProgress = relativeProgress - relativeLocalProgress; + relativeLocalProgress = 1 - childrenProgress; + setRelativeProgress(this, name, 1d); } - - return (((double) progress) / (max - min)); } /** @@ -275,34 +317,9 @@ public class Progress { * * @return the children (Who will think of the children??) */ - public Set getChildren() { - return children.keySet(); - } - - /** - * Set the total progress value (including the optional children - * {@link Progress}), on a {@link Progress#getMin()} to - * {@link Progress#getMax()} scale. - * - * @param pg - * the {@link Progress} to report as the progression emitter - * @param name - * the current name (if it is NULL, the first non-null name in - * the hierarchy will overwrite it) of the {@link Progress} who - * emitted this change - * @param progress - * the progress to set - */ - private void setTotalProgress(Progress pg, String name, int progress) { - // TODO: name is not used... and this is probably a bug in this case + public List getChildren() { synchronized (getLock()) { - progress = Math.max(min, progress); - progress = Math.min(max, progress); - - if (progress != this.progress) { - this.progress = progress; - changed(pg); - } + return new ArrayList(children.keySet()); } } @@ -311,12 +328,20 @@ public class Progress { * * @param pg * the emmiter + * @param name + * the current name (if it is NULL, the first non-null name in + * the hierarchy will overwrite it) of the {@link Progress} who + * emitted this change */ - private void changed(Progress pg) { + private void changed(Progress pg, String name) { if (pg == null) { pg = this; } + if (name == null) { + name = this.name; + } + synchronized (getLock()) { for (ProgressListener l : listeners) { l.progress(pg, name); @@ -335,7 +360,9 @@ public class Progress { * the listener */ public void addProgressListener(ProgressListener l) { - this.listeners.add(l); + synchronized (getLock()) { + this.listeners.add(l); + } } /** @@ -347,7 +374,9 @@ public class Progress { * @return TRUE if it was found (and removed) */ public boolean removeProgressListener(ProgressListener l) { - return this.listeners.remove(l); + synchronized (getLock()) { + return this.listeners.remove(l); + } } /** @@ -360,20 +389,20 @@ public class Progress { * {@link Progress#getMax()} scale) of this child * {@link Progress} in relation to its parent * - * @throws Error + * @throws RuntimeException * if weight exceed {@link Progress#getMax()} or if progress * already has a parent */ public void addProgress(Progress progress, double weight) { if (weight < min || weight > max) { - throw new Error(String.format( + throw new RuntimeException(String.format( "Progress object %s cannot have a weight of %f, " + "it is outside of its parent (%s) range (%f)", progress.name, weight, name, max)); } if (progress.parent != null) { - throw new Error(String.format( + throw new RuntimeException(String.format( "Progress object %s cannot be added to %s, " + "as it already has a parent (%s)", progress.name, name, progress.parent.name)); @@ -383,23 +412,23 @@ public class Progress { @Override public void progress(Progress pg, String name) { synchronized (getLock()) { - double total = ((double) localProgress) / (max - min); - for (Entry entry : children.entrySet()) { - total += (entry.getValue() / (max - min)) - * entry.getKey().getRelativeProgress(); - } - - if (name == null) { - name = Progress.this.name; + double total = relativeLocalProgress; + synchronized (getLock()) { + for (Entry entry : children + .entrySet()) { + total += (entry.getValue() / (max - min)) + * entry.getKey().getRelativeProgress(); + } } - setTotalProgress(pg, name, - (int) Math.round(total * (max - min))); + setRelativeProgress(pg, name, total); } } }); - this.children.put(progress, weight); + synchronized (getLock()) { + this.children.put(progress, weight); + } } /**