Improve Progress, ImageUtils

diff --git a/src/be/nikiroo/utils/ImageUtils.java b/src/be/nikiroo/utils/ImageUtils.java
index afeb5d34dd924ff4f5dd4102e548ef2a3015b1d8..9f1e06f36806d57c3876dc38b6400d4d4b371412 100644 (file)
--- a/src/be/nikiroo/utils/ImageUtils.java
+++ b/src/be/nikiroo/utils/ImageUtils.java
@@ -101,7 +101,7 @@ public class ImageUtils {
 
                return fileString;
        }
-       
+
        /**
         * Convert the given Base64 representation of an image into an {@link Image}
         * object.
@@ -136,9 +136,17 @@ public class ImageUtils {
        static public BufferedImage fromStream(InputStream in) throws IOException {
                MarkableFileInputStream tmpIn = null;
                File tmp = null;
-               try {
-                       in.reset();
-               } catch (IOException e) {
+
+               boolean repack = !in.markSupported();
+               if (!repack) {
+                       try {
+                               in.reset();
+                       } catch (IOException e) {
+                               repack = true;
+                       }
+               }
+
+               if (repack) {
                        tmp = File.createTempFile(".tmp-image", ".tmp");
                        tmp.deleteOnExit();
                        IOUtils.write(in, tmp);

diff --git a/src/be/nikiroo/utils/Progress.java b/src/be/nikiroo/utils/Progress.java
index 2872530b68542585783467e3241835072e75570a..d722fc91c3289e9f0b0425cba4bfba87fdc1b88f 100644 (file)
--- a/src/be/nikiroo/utils/Progress.java
+++ b/src/be/nikiroo/utils/Progress.java
@@ -37,8 +37,8 @@ public class Progress {
        private List<ProgressListener> 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 +106,7 @@ public class Progress {
         */
        public void setName(String name) {
                this.name = name;
-               changed(this);
+               changed(this, name);
        }
 
        /**
@@ -208,7 +208,7 @@ public class Progress {
         * @return the progress the value
         */
        public int getProgress() {
-               return progress;
+               return (int) Math.round(relativeProgress * (max - min));
        }
 
        /**
@@ -221,12 +221,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 +282,7 @@ public class Progress {
         */
        public void add(int step) {
                synchronized (getLock()) {
-                       setProgress(localProgress + step);
+                       setProgress(getLocalProgress() + step);
                }
        }
 
@@ -246,7 +293,7 @@ public class Progress {
         * @return TRUE if it is
         */
        public boolean isDone() {
-               return progress >= max;
+               return relativeProgress >= 1d;
        }
 
        /**
@@ -256,20 +303,6 @@ public class Progress {
                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;
-               }
-
-               return (((double) progress) / (max - min));
-       }
-
        /**
         * Return the list of direct children of this {@link Progress}.
         * 
@@ -280,43 +313,24 @@ public class Progress {
        }
 
        /**
-        * Set the total progress value (including the optional children
-        * {@link Progress}), on a {@link Progress#getMin()} to
-        * {@link Progress#getMax()} scale.
+        * Notify the listeners that this {@link Progress} changed value.
         * 
         * @param pg
-        *            the {@link Progress} to report as the progression emitter
+        *            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
-        * @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
-               synchronized (getLock()) {
-                       progress = Math.max(min, progress);
-                       progress = Math.min(max, progress);
-
-                       if (progress != this.progress) {
-                               this.progress = progress;
-                               changed(pg);
-                       }
-               }
-       }
-
-       /**
-        * Notify the listeners that this {@link Progress} changed value.
-        * 
-        * @param pg
-        *            the emmiter
-        */
-       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);
@@ -383,18 +397,13 @@ public class Progress {
                        @Override
                        public void progress(Progress pg, String name) {
                                synchronized (getLock()) {
-                                       double total = ((double) localProgress) / (max - min);
+                                       double total = relativeLocalProgress;
                                        for (Entry<Progress, Double> entry : children.entrySet()) {
                                                total += (entry.getValue() / (max - min))
                                                                * entry.getKey().getRelativeProgress();
                                        }
 
-                                       if (name == null) {
-                                               name = Progress.this.name;
-                                       }
-
-                                       setTotalProgress(pg, name,
-                                                       (int) Math.round(total * (max - min)));
+                                       setRelativeProgress(pg, name, total);
                                }
                        }
                });

diff --git a/src/be/nikiroo/utils/test/ProgressBarManualTest.java b/src/be/nikiroo/utils/test/ProgressBarManualTest.java
index 9b281336bf369df1be253f8d529980599c2ab1f4..1ff75c3fc50212f5d37ae78eef787888cd731c4e 100644 (file)
--- a/src/be/nikiroo/utils/test/ProgressBarManualTest.java
+++ b/src/be/nikiroo/utils/test/ProgressBarManualTest.java
@@ -17,7 +17,8 @@ public class ProgressBarManualTest extends JFrame {
        public ProgressBarManualTest() {
                final ProgressBar bar = new ProgressBar();
                final Progress pg = new Progress("name");
-               final Progress pg2 = new Progress("second level");
+               final Progress pg2 = new Progress("second level", 0, 2);
+               final Progress pg3 = new Progress("third level");
 
                setLayout(new BorderLayout());
                this.add(bar, BorderLayout.SOUTH);
@@ -34,17 +35,33 @@ public class ProgressBarManualTest extends JFrame {
                                        break;
                                case 1:
                                        pg.setProgress(20);
-                                       b.setText("Add second pg");
+                                       b.setText("Add pg2 (0-2)");
                                        break;
                                case 2:
                                        pg.addProgress(pg2, 80);
                                        pg2.setProgress(0);
-                                       b.setText("set second pg to 100%");
+                                       b.setText("Add pg3 (0-100)");
                                        break;
                                case 3:
-                                       pg2.setProgress(100);
-                                       b.setText("Set pg to 10%");
-                                       i = -1;
+                                       pg2.addProgress(pg3, 2);
+                                       pg3.setProgress(0);
+                                       b.setText("Set pg3 to 10%");
+                                       break;
+                               case 4:
+                                       pg3.setProgress(10);
+                                       b.setText("Set pg3 to 20%");
+                                       break;
+                               case 5:
+                                       pg3.setProgress(20);
+                                       b.setText("Set pg3 to 60%");
+                                       break;
+                               case 6:
+                                       pg3.setProgress(60);
+                                       b.setText("Set pg3 to 100%");
+                                       break;
+                               case 7:
+                                       pg3.setProgress(100);
+                                       b.setText("[done]");
                                        break;
                                }