Swing Frage zu modalem JDialog.

[nohfreak]

Moin Leute,

ich habe gerade ein kleines Problem mit einem JDialog. Ich möchte im Prinzip einen modalen Dialog erzeugen, warten bis eine Operation fertig ist, und dann den Dialog wieder zu machen. In der Zeit soll der parent-Frame gesperrt werden, also hab ich den Dialog modal gemacht.

Problem ist nur, dass die weitere Ausführung dann nicht mehr stattfindet, nachdem ich den Dialog sichtbar geschaltet habe, sprich die Operation, das warten auf deren Ende und dann das schließen des Dialogs.

Kennt da jemand nen Trick, wie man das dennoch hinkriegen kann ?

Gruß,
nohfreak

 

[L-ectron-X]

Code?

 

[SlaterB]

> dass die weitere Ausführung dann nicht mehr stattfindet

der restliche Code wird nie ausgeführt? so gehts ja nun nicht, Code kann doch nicht ignoriert werden, da muss ein Fehler vorliegen, siehe erste Antwort

der restliche Code wird verzögert bis zum Ende des Dialogs? normalerweise möchte man das doch so, ist ein Feature,
ansonsten mit Threads arbeiten, wenn der Dialog in eigenem Thread gestartet wird, wird auch nur dieser unterbrochen, sonstiger Code läuft weiter,
oder den sonstigen Code in einen Thread und VOR dem Dialog starten

 

[Ebenius]

Der Aufruf von [c]setVisible(true)[/c] (respektive [c]show()[/c]) kehrt erst zurück, wenn der modale Dialog geschlossen wird. Wenn man nebenher eine Arbeit erledigen muss, dann muss man, wie SlaterB schrieb, mit Threads arbeiten. Am besten benutzt man dafür die SwingWorker-Klasse.

In der API-Doc von SwingWorker.get() findet sich ein gutes Beispiel, wie ein modaler Dialog mit einem SwingWorker verbunden werden kann.

Ebenius

 

[nohfreak]

Jau, genau das was Ebenius da als Beispiel anführt habe ich gebraucht. Vielen Dank.

Ich wollte euch nicht meinen ganzen Code-Batzen zumuten, da der derzeit doch noch ziemlich wirr ist. Das nächste Mal werf ich ihn dann einfach dazu.

Danke an alle, die probiert haben mir zu helfen.

 

[nohfreak]

Habe probiert das Ganze mal bei mir einzubauen, aber irgendwie klappt das noch nicht so recht, und mir ist gerade nicht ganz so klar wieso. Diesmal mit Code:

import java.awt.BorderLayout;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.concurrent.ExecutionException;

import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;

public abstract class ProgressWorker extends SwingWorker<String, Object> {
	
	private final JProgressBar progressBar = new JProgressBar();
	private JDialog dialog;
	
	public ProgressWorker(JFrame parent, String title, String msg){
		
		dialog = new JDialog(parent, true);
		
		progressBar.setIndeterminate(true);
		
		JLabel msgLabel = new JLabel(msg);
		
		dialog.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
		
		dialog.setTitle(title);
		dialog.setLayout(new BorderLayout());
		
		dialog.add(msgLabel, BorderLayout.CENTER);
		dialog.add(progressBar, BorderLayout.SOUTH);
		
		dialog.setLocationRelativeTo(parent);
		
		dialog.pack();
		
		this.addPropertyChangeListener(new PropertyChangeListener(){
	     public void propertyChange(PropertyChangeEvent event) {
	         if ("state".equals(event.getPropertyName())
	                 && SwingWorker.StateValue.DONE == event.getNewValue()) {
	             dialog.setVisible(false);
	             dialog.dispose();
	         }
	     }});

		
	}
	
	// Progressbar anwerfen und execute starten
	public void doWork(){
		dialog.setVisible(true);
		this.execute();
	}
	
}

Und noch die Klasse zum Testen der ganzen Geschichte:

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.util.Arrays;

import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		JFrame frm = new JFrame("Test");
		frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frm.setSize(new Dimension(800, 600));
		
		frm.setVisible(true);
		
		ProgressWorker t = new ProgressWorker(frm, "Laden,....", "Lange Dateioperation läuft,..."){
			
			public String doInBackground(){
				
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				return "boa";
			}
			
		};
		
		t.doWork();

	}

}

Was ich eigentlich bauen möchte ist eine Klasse, die eine ProgressBar rattern lässt in einem modalen Dialog, nebenbei eine Aktion ausführt, und wenn die Aktion fertig ist den Dialog unauffällig verschwinden lässt.

Problem ist, der Listener scheint nicht zufunktionieren, da der Dialog ja nach einer Sekunde verschwinden sollte, er aber leider die ganze Zeit dableibt. :/

Wär super, wenn mir noch ein barhmerziger Mensch das letzte Brett vorm Kopf abmachen könnte. *gg*

 

[SlaterB]

this.execute();
VOR
dialog.setVisible(true);

 

[nohfreak]

*Runtergefallenes Brett mit dem Fuß wegkick*

Super, ich danke dir vielmals, klappt nun astrein. Wie doof von mir. Eigentlich weiß ich das ja. Eigentlich,.... Hehe. Jaja, wenn man intensiv sowas lange genug anstarrt findet man solche kleinen, aber feinen und äußerst dämlichen Fehler nicht mehr. :>

 

[nohfreak]

Heute habe ich die done()-Methode vom SwingWorker entdeckt. Funktioniert auch super, das einfach dort hineinzupacken. Oder ist bringt das irgendeinen Nachteil mit sich, oder ist design-technisch schlecht ?

EDIT: Es hat sich noch ein ganz anderes Problem ergeben. In der Methode doWork() geht es nach dem setVisible(true) nie weiter, auch wenn der Dialog schon disposed worden ist. Das hat zur Folge, dass es im Test Programm nach dem doWork()-Aufruf auch niemals weitergeht, und ich versteh ehrlichgesagt nicht warum. Wie kann ich das beheben ? Hier nochmal der jetztige Code:

Der Worker:

import java.awt.BorderLayout;
import java.awt.Window;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.concurrent.ExecutionException;

import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;

public abstract class ProgressWorker<T, O> extends SwingWorker {
	
	private ProgressDialog dialog;
	
	public ProgressWorker(JFrame parent, String title, String msg, boolean indeterminateProgressBar){
		
		dialog = new ProgressDialog(parent, title, msg, true, true);
		
	}
	
	/**
	 * Ausführung beginnen und Dialog sichtbar machen.
	 *
	 */
	public void doWork(){
		this.execute();
		dialog.setVisible(true);
	}
	
	/**
	 * Dialog wegmachen, wenn fertig mit der Arbeit.
	 */
	public void done(){
		dialog.setVisible(false);
		dialog.dispose();
	}

	
}

Der Dialog:

import java.awt.BorderLayout;
import java.awt.Frame;

import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;

/**
 * The Class ProgressDialog.
 * 
 * @author nils
 */
public class ProgressDialog extends JDialog {
	
	/** The msg label. */
	private JLabel msgLabel;
	
	/** The progress bar. */
	private JProgressBar progressBar;

	/**
	 * The Constructor.
	 * 
	 * @param parent Parentframe
	 * @param title Title
	 * @param msg the Nachricht, die über der ProgressBar stehen soll
	 * @param modal Ist der Dialog modal ?
	 * @param indeterminateProgress Ist die Progressbar Indeterminate ?
	 */
	public ProgressDialog(	Frame parent,
						    String title, 
						    String msg,
							boolean modal, 
							boolean indeterminateProgress ) {
		
		super(parent, modal);
		
		msgLabel = new JLabel(msg);
		JProgressBar progressBar = new JProgressBar(0, 100);
		progressBar.setIndeterminate(indeterminateProgress);
		
		this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
		this.setTitle(title);
		this.setLayout(new BorderLayout());
		
		this.add(msgLabel, BorderLayout.CENTER);
		this.add(progressBar, BorderLayout.SOUTH);
		
		this.setLocationRelativeTo(parent);
		
		this.pack();
	}
}

Der Test:

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.util.Arrays;

import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		JFrame frm = new JFrame("Test");
		frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frm.setSize(new Dimension(800, 600));
		
		frm.setVisible(true);
		
		ProgressWorker t = new ProgressWorker(frm, "Laden,....", "Lange Dateioperation läuft,...", true){
			
			public String doInBackground(){
				
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				// Tja, die Methode erwartet leider, dass man irgendwas zurückgibt. :-)
				// Kann man scheinbar nicht abstellen, aber man kann nunmal nicht alles
				// haben, ne ?
				return "boa";
			}
			
		};
		
		t.doWork();

                // hier kommts quasi niemals an
		System.out.println("Finished");

	}

Also das "Finished" kommt leider niemals an. :/

 

[nohfreak]

Okay, habe nun eine eine funktionierende Lösung anscheinend ist das dispose() schuld gewesen. Es ergibt für mich zwar keinen Sinn, aber wenn ich das dispose() weglasse funktioniert es. Hat da dennoch jemand eine Erklärung dafür ? Ich find das irgendwie unschön, wenn ich den Dialog nur unsichtbar mache gammelt der ja immernoch im Speicher rum, wenn ich mich nicht irre, oder ?

 

[javimka]

Mit dispose() gibst du alle nativen Ressourcen wieder frei. Also z.B. der Speicher des Betriebssystems für die Graphik.

 

[nohfreak]

Okay, aber ich dachte das betrifft dann nur diejenigen von dem Objekt, an dem ich dispose aufrufe. Inwiefern erklärt das, warum es an der problematischen Stelle oben nicht weitergeht ?

 

[javimka]

Bei mir kommt nach einiger zeit "Finished" auf der Konsole. Habe es mehrere Male getestet und es hat immer funktioniert.

 

[nohfreak]

Hrm. Sehr merkwürdig. Bei mir kommt nix, hab über 30 sec gewartet.

Ich hab das java6-openjdk unter Ubuntu 8.10.

 

[javimka]

ich habe das sun-jdk unter Windows 7

 

[Ebenius]

Was passiert, wenn Du die GUI auf dem EDT erzeugst (das sollte man ohnehin immer machen)?

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.util.Arrays;
 
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.SwingUtilities;
 
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
          @Override
          public void run() {
            createAndShowGUI();
          }
        });
    }

    private static void createAndShowGUI() {
        JFrame frm = new JFrame("Test");
        frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frm.setSize(new Dimension(800, 600));
        
        frm.setVisible(true);
        
        ProgressWorker t = new ProgressWorker(frm, "Laden,....", "Lange Dateioperation läuft,...", true){
            
            public String doInBackground(){
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                // Tja, die Methode erwartet leider, dass man irgendwas zurückgibt. :-)
                // Kann man scheinbar nicht abstellen, aber man kann nunmal nicht alles
                // haben, ne ?
                return "boa";
            }
            
        };
        
        t.doWork();
 
                // hier kommts quasi niemals an
        System.out.println("Finished");
 
    }

Ebenius

 

[nohfreak]

Ah, super, danke dir Ebenius. So klappt es! Nun dümpelt der Dialog nachdem er seinen Zweck erfüllt hat auch nichtmehr weiter im Speicher herum.