set/getProgressListener deprecated, replaced with remove/addListener(ProgressListener).

Fixes #1446.

svn changeset:4442/svn branch:trunk

src/com/itmill/toolkit/tests/TestForUpload.java

     private final Label l;
 
     private final ProgressIndicator pi = new ProgressIndicator();
+    private final ProgressIndicator pi2 = new ProgressIndicator();
 
     private final Label memoryStatus;
 
         up.addListener((StartedListener) this);
 
         up.setProgressListener(this);
+        up.addListener(new Upload.ProgressListener() {
+
+            public void updateProgress(long readBytes, long contentLenght) {
+                pi2.setValue(new Float(readBytes / (float) contentLenght));
+
+                refreshMemUsage();
+            }
+
+        });
 
         final Button b = new Button("b", this, "readState");
 
         pi.setPollingInterval(1000);
         main.addComponent(pi);
 
+        pi2.setVisible(false);
+        pi2.setPollingInterval(1000);
+        main.addComponent(pi2);
+
         memoryStatus = new Label();
         main.addComponent(memoryStatus);
 
 
     public void uploadSucceeded(SucceededEvent event) {
         pi.setVisible(false);
+        pi2.setVisible(false);
         l.setValue("Finished upload, idle");
         System.out.println(event);
         setBuffer();
 
     public void uploadStarted(StartedEvent event) {
         pi.setVisible(true);
+        pi2.setVisible(true);
         l.setValue("Started uploading file " + event.getFilename());
         textFieldValue.setValue(" TestFields value at the upload start is:"
                 + textField.getValue());

src/com/itmill/toolkit/ui/Upload.java

 import java.io.InputStream;
 import java.io.OutputStream;
 import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.Map;
 
 import com.itmill.toolkit.Application;
      * upload
      */
     private ProgressListener progressListener;
+    private LinkedHashSet progressListeners;
 
     /* TODO: Add a default constructor, receive to temp file. */
 
                     // update progress if listener set and contentLength
                     // received
                     synchronized (application) {
-                        progressListener.updateProgress(totalBytes,
-                                contentLength);
+                        fireUpdateProgress(totalBytes, contentLength);
                     }
                 }
             }
         removeListener(SucceededEvent.class, listener, UPLOAD_SUCCEEDED_METHOD);
     }
 
+    /**
+     * Adds the upload success event listener.
+     * 
+     * @param listener
+     *                the Listener to be added.
+     */
+    public void addListener(ProgressListener listener) {
+        if (progressListeners == null) {
+            progressListeners = new LinkedHashSet();
+        }
+        progressListeners.add(listener);
+    }
+
+    /**
+     * Removes the upload success event listener.
+     * 
+     * @param listener
+     *                the Listener to be removed.
+     */
+    public void removeListener(ProgressListener listener) {
+        if (progressListeners != null) {
+            progressListeners.remove(listener);
+        }
+    }
+
     /**
      * Emit upload received event.
      * 
         fireEvent(new Upload.SucceededEvent(this, filename, MIMEType, length));
     }
 
+    /**
+     * Emits the progress event.
+     * 
+     * @param totalBytes
+     *                bytes received so far
+     * @param contentLength
+     *                actual size of the file being uploaded, if known
+     * 
+     */
+    protected void fireUpdateProgress(long totalBytes, long contentLength) {
+        // this is implemented differently than other listeners to maintain
+        // backwards compatibility
+        if (progressListeners != null) {
+            for (Iterator it = progressListeners.iterator(); it.hasNext();) {
+                ProgressListener l = (ProgressListener) it.next();
+                l.updateProgress(totalBytes, contentLength);
+            }
+        }
+        // deprecated:
+        if (progressListener != null) {
+            progressListener.updateProgress(totalBytes, contentLength);
+        }
+    }
+
     /**
      * Returns the current receiver.
      * 
     }
 
     /**
-     * Sets listener to track progress of upload.
+     * This method is deprecated, use addListener(ProgressListener) instead.
      * 
+     * @deprecated Use addListener(ProgressListener) instead.
      * @param progressListener
      */
     public void setProgressListener(ProgressListener progressListener) {
     }
 
     /**
-     * Gets listener that tracks progress of upload.
+     * This method is deprecated.
      * 
+     * @deprecated Replaced with addListener/removeListener
      * @return listener
      * 
      */