Ciao a tutti,

sto sviluppando un'applicazione che si interfaccia con un database. Quando reperisco i dati possono passare svariati secondi, avrei bisogno di una finestra di attesa. Ho cercato un po' a tal proposito e mi sono imbattuto in soluzioni (per me) un po' complicate, molte usano la classe Thread. Ho provato a crearne una versione semplificata solo che mi imbatto in un comportamento particolare. Mi spiego meglio:
Ho pensato di fare nella maniera seguente, disabilito la JFrame principale faccio apparire un JDialog prima del reperimento dei dati a db (operazione che dura qualche secondo) e alla fine faccio scomparire il JDialog e riabilito la JFrame. Il comportamento che ottengo è quello desiderato solo che il JDialog che appare risulta vuoto, si vede la barra del titolo e il bordo ma il contenuto non compare, come se fosse bucato.

Di seguito posto un semplice esempio che riproduce il problema che incontro:

codice:
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.WindowConstants;


public class Prova extends JFrame implements ActionListener {
	
	JPanel panel = new JPanel();
	JButton bottone = new JButton("Clicca per iniziare");
	Finestra_Attesa finestra_attesa = new Finestra_Attesa(this, "Attendere prego");
	
	public Prova() {
		
		super("Prova");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setSize(new Dimension(400, 400));
		panel.setLayout(new BorderLayout());
		panel.setOpaque(true);
		panel.setBackground(Color.CYAN);
		add(panel);
		panel.add(bottone, BorderLayout.SOUTH);
		bottone.addActionListener(this);
		this.setVisible(true);
		//finestra_attesa.setVisible(true);
	}
	
	class Finestra_Attesa extends JDialog {
		
		JLabel label = new JLabel("Attendere prego");
		
		public Finestra_Attesa(JFrame owner, String titolo) {
			
			super(owner, titolo, false);
			this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
			this.setSize(new Dimension(100, 100));
			this.add(label);
		}
	}

	public static void main(String[] args) {
		
		new Prova();
	}

	public void actionPerformed(ActionEvent arg0) {

		this.setEnabled(false);
		finestra_attesa.setVisible(true);
		
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		this.setEnabled(true);
		finestra_attesa.setVisible(false);
	}
}
Premendo sul pulsante simulo l'esecuzione di codice con il comando Thread.sleep.
Per vedere la differenza con l'effetto desiderato basta decommentare l'istruzione //finestra_attesa.setVisible(true);
nel costruttore della classe principale.

In definitiva, all'infuori del fatto che una finestra di attesa si possa fare in maniera più elegante/efficiente, qualcuno sa come mai si verifica questo strano comportamento e come fare per evitarlo?

Grazie per l'attenzione.