Dialog während warten anzeigen

[m@nu]

hiho!

meine applikation speichert beim schliessen des programmes die daten in ein xml-file.
während diesem speichern möchte ich gerne einen kleinen dialog modal anzeigen, in welchem eine kurze meldung steht dass die daten gespeichert werden. anschliessend wird das programm beendet.

per WindowListener und windowClosing-Event funktioniert das einzeigen des dialoges prächtig.
doch leider will das zeichnen des dialoges nicht richtig klappen (es wird einfach eine leere, graua fläche gezeigt)

hier meine idee:

/*
 * Created on 19.05.2005
 */
package manu.drivesync.gui.reusable.dialogs;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

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

/**
 * @author Manuel Alabor
 */
public class JWaitDialog extends JDialog {

    /* GUI-Komponenten: */
    private JLabel lblMessage = new JLabel("");
    
    /* Objekte: */
    private ActionListener actionListener;
    
    /**
     * @param owner "Besitzer" des Dialoges
     * @param message Nachricht
     * @param actionListener Auszuführender Code
     */
    public JWaitDialog(JFrame owner, String message, ActionListener actionListener) {
        /* Initialisieren: */
        super(owner);
        
        lblMessage.setText(message);
        this.actionListener = actionListener;
        
        addWindowListener(new windowListener());
        
        initGui();
    }
    
    
    // Initialisierung ---------------------------------------------------------
    private void initGui() {
        
        /* Dialog anpassen: */
        setResizable(false);
        setModal(true);
        setSize(150,60);
        
        /* Message anordnen: */
        JPanel contentPane = (JPanel)getContentPane();
        contentPane.setLayout(new BorderLayout());
        contentPane.add(lblMessage, BorderLayout.CENTER);
    }
    
    
    
    // Überschreibungen --------------------------------------------------------
	/**
	 * show-Methode überschreiben damit JWaitDialog immer zentriert auf
	 * owner angezeigt wird.
	 */
	public void show() {
		Component owner = getOwner();
	    
	    Dimension d = owner.getSize();
		Point p = owner.getLocation();
		setLocation(((d.width - getWidth()) / 2) + p.x, ((d.height - getHeight()) / 2) +p.y);
		
		super.show();
	}
	
	// Hilfsklassen ------------------------------------------------------------
    private class windowListener extends WindowAdapter {
	    public void windowOpened(WindowEvent arg0) {
			actionListener.actionPerformed(new ActionEvent(this, 0, "waitDialogAction"));
			dispose();
	    }
    }
	
}

beim instanzieren des dialoges wird ein ActionListener übergeben, welcher den auszuführenden code enthält (in meinem falle irgendwelche anweisungen fürs speichern der daten).
nach dem anzeigen des dialoges wird dann ein actionPerformed an den listener geschickt und der code somit ausgeführt.


hat jemand eine idee wie man dies eleganter lösen könnte, oder aber eine lösung für mein oben geschildertes problem?

vielen dank im voraus & greetz
m@nu

 

[m@nu]

hat sich erledigt...

 

[AlArenal]

Das geht viel cooler:

http://www.jroller.com/page/gfx/?anchor=progress_components_hacked

Romain ist einfach cool. Sein Weblog wird täglich besucht und fast ebenso häufig findet man was nettes. Und sei es nur der Hinweis darauf, dass er gerade 23 geworden ist.. 😉

 

[m@nu]

wow, danke für den typ! coole GUI's! :-D

falls jemand interesse hat 🙂
folgend ist der code von meinem JWaitDialog zu finden:

/*
 * Created on 19.05.2005
 */
package manu.drivesync.gui.reusable.dialogs;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Window;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.BorderFactory;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

/**
 * Dem <code>JWorkDialog</code> kann eine Meldung sowie ein <code>Runnable</code>-
 * Interface übergeben werden.

 * Der Dialog zeigt die Meldung an, und führt im Hintergrund das übergebene
 * <code>Runnable</code>-Interface in einem Thread aus. Ist die Verarbeitung
 * abgeschlossen, wird der Dialog geschlossen.

 * 

 * Der <code>JWaitDialog</code> eignet sich hervorragend um z.b. beim beenden
 * einer Applikation während dem speichern von daten eine kleine Meldung an-
 * zuzeigen.
 * 
 * @author Manuel Alabor
 * @author thanks for tips & help: Thomas Myrberg @ [url]http://forum.java.sun.com/[/url]
 * @version 1.0
 */
public class JWaitDialog extends JDialog {

    /* GUI-Komponenten: */
    private JLabel lblMessage = new JLabel();
    
    /* Objekte: */
    private Runnable workToDo;
    
    /**
     * Standartkonstruktor.
     * 
     * @param owner "Besitzer" des Dialoges
     * @param message Nachricht
     * @param work Auszuführender Code in einem Runnable-Interface
     */
    public JWaitDialog(JFrame owner, String message, Runnable work) {
        /* Initialisieren: */
        super(owner);
        
        /* Werte übernehmen: */
        lblMessage.setText(message);
        this.workToDo = work;
        
        /* WindowListener erstellen: */
        addWindowListener(new WindowListener());
        
        /* GUI initialisieren: */
        initGui();
    }
    
    
    // Initialisierung ---------------------------------------------------------
    /**
     * Initialisiert das GUI.
     */
    private void initGui() {
        /* Vorbereiten: */
        JPanel contentPane = (JPanel)getContentPane();
        
        /* Dialog anpassen: */
        setResizable(false);
        setSize(250,60);
        setUndecorated(true);
        setModal(true);
        
        /* Message anpassen: */
        lblMessage.setHorizontalAlignment(JLabel.CENTER);
        lblMessage.setBorder(BorderFactory.createRaisedBevelBorder());
        
        /* Message anordnen: */
        contentPane.setLayout(new BorderLayout());
        contentPane.add(lblMessage, BorderLayout.CENTER);
    }
    
    
    // Überschreibungen --------------------------------------------------------
	/**
	 * show-Methode überschreiben damit JWaitDialog immer zentriert auf
	 * owner angezeigt wird.
	 */
	public void show() {
		Component owner = getOwner();
	    
	    Dimension d = owner.getSize();
		Point p = owner.getLocation();
		setLocation(((d.width - getWidth()) / 2) + p.x, ((d.height - getHeight()) / 2) +p.y);
		
		super.show();
	}
	
	// Hilfsklassen ------------------------------------------------------------
    /**
     * Dieser <code>WindowListener</code> führt beim anzeigen den Code in
     * <code>workToDo</code> als Thread aus. Nachdem der Code abgearbeitet wurde,
     * wird der Dialog automatisch geschlossen.
     * 
     * @author Manuel Alabor
     */
	private class WindowListener extends WindowAdapter {
	    public void windowOpened(WindowEvent arg0) {
			/* Thread erstellen: */
	        WorkerThread worker = new WorkerThread(workToDo, JWaitDialog.this);
	        
	        /* Thread starten: */
	        worker.start();
	    }
    }
	
	/**
	 * <code>WorkerThread</code> ermöglicht das Ausführen des <code>workToDo</code>-
	 * Codes und das anschliessende schliessen eines Fensters.
	 * 
	 * @author Manuel Alabor
	 */
	private class WorkerThread extends Thread {
	    
	    /* Eigenschaften: */
	    private Runnable workToDo;
	    private Window toDispose;
	    
	    /**
	     * Standartkonstruktor.
	     * 
	     * @param workToDo Runnable-Interface mit auszuführendem Code
	     * @param toDispose zu schliessendes Fenster
	     */
	    public WorkerThread(Runnable workToDo, Window toDispose) {
	        this.workToDo = workToDo;
	        this.toDispose = toDispose;
	    }
	    
	    /**
	     * Führt den im Runnable-Interface enthaltenen Code aus und schliesst
	     * das entsprechende Fenster.
	     */
	    public void run() {
	        /* workToDo ausführen: */
	        workToDo.run();
	        
	        /* Fenster schliessen: */
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    toDispose.dispose();
                }
            });
	    }
	    
	}
	
}

der aufruf kann z.b. so gemacht werden:

Runnable work = new Runnable() {
  public void run() {
    saveData();
  };

  JWaitDialog dlg = new JWaitDialog(this, "Daten werden gespeichert. Bitte warten...", work);
  dlg.show();