JProgressBar für FileUpload

[Lay-C]

Hallo,

Ich schreibe zur Zeit ein Programm das große Dateien mit Hilfe eines FileInputStreams einliest und auf einen Server läd,
dazu wäre es natürlich geschickt eine JProgressbar mit dem aktuellen Status zu aktualisieren und anzuzeigen.

So wie ich das ganze bisher gelöst habe, öffnet sich das JFrame mit der ProgressBar, hängt sich auf, und zeigt 100% wenns fertig ist.

Ich habe schon verschiedene Threads hier gelesen u.a. http://www.java-forum.org/de/viewtopic.php?t=79123&highlight=jprogressbar, http://www.java-forum.org/de/viewtopic.php?t=81952&highlight=jprogressbar und http://www.java-forum.org/de/viewtopic.php?t=81565&highlight=jprogressbar

Aber die haben mich alle nicht weitergebracht.

Und mit dem Sun Tutorial (http://java.sun.com/docs/books/tutorial/uiswing/components/progress.html)
komm ich auch nicht weiter, da ich das ganze mit dem SwingWorker nicht wirklich verstehe.

Die Klasse mit der ProgressBar sieht so aus:

public class LoadWindow extends JFrame {

	private static final long serialVersionUID = 1L;
	private JPanel jContentPane = null;
	private JPanel northPanel = null;
	private JPanel southPanel = null;
	private JProgressBar fileBar = null;
	private int width;
	private int height;
	private Sender s = null;
	private JPanel centerPanel = null;
	private JLabel statusLabel = null;
	private JButton endButton = null;
	
	/**
	 * This is the default constructor
	 */
	public LoadWindow(Sender send) {
		super();
		s = send;
		initialize();
	}

	/**
	 * This method initializes this
	 * 
	 * @return void
	 */
	private void initialize() {
		width = 400;
		height = 100;
		this.setSize(width, height);
		this.setContentPane(getJContentPane());
		this.setTitle("Upload");
		this.setVisible(false);
		this.setResizable(false);
		setStatus(0,0);
	}

	/**
	 * This method initializes jContentPane
	 * 
	 * @return javax.swing.JPanel
	 */
	private JPanel getJContentPane() {
		if (jContentPane == null) {
			jContentPane = new JPanel();
			jContentPane.setLayout(new BorderLayout());
			jContentPane.add(getNorthPanel(), BorderLayout.NORTH);
			jContentPane.add(getSouthPanel(), BorderLayout.SOUTH);
			jContentPane.add(getCenterPanel(), BorderLayout.CENTER);
		}
		return jContentPane;
	}

	/**
	 * This method initializes centerPanel	
	 * 	
	 * @return javax.swing.JPanel	
	 */
	private JPanel getNorthPanel() {
		if (northPanel == null) {
			northPanel = new JPanel();
			northPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
			northPanel.add(getFileBar(), null);
		}
		return northPanel;
	}

	/**
	 * This method initializes southPanel	
	 * 	
	 * @return javax.swing.JPanel	
	 */
	private JPanel getSouthPanel() {
		if (southPanel == null) {
			southPanel = new JPanel();
			southPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
			southPanel.add(getEndButton(), null);
		}
		return southPanel;
	}

	/**
	 * This method initializes fileBar	
	 * 	
	 * @return javax.swing.JProgressBar	
	 */
	private JProgressBar getFileBar() {
		if (fileBar == null) {
			fileBar = new JProgressBar();
			fileBar.setPreferredSize(new Dimension(width-40, 20));
			fileBar.setMinimum(0);
			fileBar.setMaximum(100);
			fileBar.setStringPainted(true);
		}
		return fileBar;
	}

	/**
	 * This method initializes centerPanel	
	 * 	
	 * @return javax.swing.JPanel	
	 */
	private JPanel getCenterPanel() {
		if (centerPanel == null) {
			statusLabel = new JLabel();
			centerPanel = new JPanel();
			centerPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
			centerPanel.add(statusLabel, null);
		}
		return centerPanel;
	}

	/**
	 * This method initializes endButton	
	 * 	
	 * @return javax.swing.JButton	
	 */
	private JButton getEndButton() {
		if (endButton == null) {
			endButton = new JButton();
			endButton.setVisible(false);
		}
		return endButton;
	}

	public void update(double reached, double max){
		if(!this.isVisible()){
			this.setVisible(true);
		}
		System.out.println(reached);
		fileBar.setValue((int)(reached/max*100));
		fileBar.setString((int)(reached/max*100)+"%");
		setStatus(reached, max);
		if(reached >= max) {
			fileBar.setString("100%");
			System.out.println((int)(reached/max*100)+"%");
			String res = s.receive();
			if(res.contains("200")){
				endButton.setVisible(true);
				endButton.setText("OK");
			} else {
				System.out.println(res);
			}
		}
	}
		
	private void setLabelText(String s){
		statusLabel.setText(s);
	}
	
	private void setStatus(double reached, double max){
		int mbBorder = 1024*1024*2;
		int mb = 1024*1024;
		int kb = 1024;
		if(reached > max) reached = max;
		double reachedKB = ((int)((reached*10)/kb))/10.;
		double reachedMB = ((int)((reached*10)/mb))/10.;
		double maxKB 	 = ((int)((max*10)/kb))/10.;
		double maxMB 	 = ((int)((max*10)/mb))/10.;
		
		if(reached > mbBorder){
			setLabelText(reachedMB+"MB/"+maxMB+"MB");
		} else if(max > mbBorder){
			setLabelText(reachedKB+"KB/"+maxMB+"MB");
		} else {
			setLabelText(reachedKB+"KB/"+maxKB+"KB");
		}
	}
	
}

Mein erster Versuch war beim Dateiupload einfach die update Funktion aufzurufen.

long max = f.length() //f ist das zu uploadende File
long reached = 0;
while((r = is.read(data, 0, data.length)) != -1) {
			out.write(data, 0, r);
			reached += r;
			loadWin.update(reached, max);
		}

Da das nicht funktioniert hat hab ich einen Thread erstellt der wie folgt aussah:

public class Updater extends Thread {

	private LoadWindow load;
	private HttpClient hc;
	private long reached;
	private long max;
	public  long count;
	
	public Updater(LoadWindow lw, HttpClient h){
		load = lw;
		hc = h;
	}
	
	public void run(){
		max = hc.getMax();
		count = 0;
		do{
			reached = hc.getReached();
			load.update(reached, max);
			count++;
			try {
				sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}while(reached <= max);
	}
}

und diesen dann vor bzw in der while Schleife gestartet, was beides jedoch zu einer endlosschleife geführt hat.

 

[Verjigorm]

Du musst den Ladevorgang IN den Thread auslagern und nach jedem lesen/schreiben die GUI aktualisieren.

Quasi Codeschnipsel 2+3 zusammengefasst

 

[Lay-C]

Hmm hab ich gemacht...

der Thread sieht jetzt so aus:

public void run(){
		
		try {
			r = is.read(data, 0, data.length); //is = FileInputStream(f)
			load.setVisible(true);
			do{
				out.write(data, 0, r);  //out = DataOutputStream(socket.getOutputStream)
				reached += r;
				load.setStatus(reached, max); //load = JFrame mit JProgressBar
				try {
					sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}while(reached <= max && (r = is.read(data, 0, data.length)) != -1);
		} catch (IOException e1) {
			e1.printStackTrace();
		} finally {
			this.interrupt();
		}
	}

Trotzdem sieht das Fenster noch genauso aus... Fenster Inhalt = "unterliegendes Fenster"

EDIT: load.setStatus(double, double) ist eine "Teilfunktion" von load.update(double, double) sie aktualisiert nur den Text unter der progressbar

 

[HoaX]

schau dir auch mal http://java.sun.com/docs/books/tutorial/uiswing/components/progress.html#monitors an. das gibts alles schon fertig