Versão atual:

SplashScreen OK!, mas pisca muito rápido, thread.sleep() não funciona.

Pessoal, implementei a splash screen abaixo, ta funcionando, ela apresenta a gif bonitinha, eu já fiz o teste comentando parte do codigo que fecha a splash.

Abaixo também esta a parte do código onde inicializo a splash screen, o problema é que o diabo do sistema é leve, e ela aparece e some praticamente ao mesmo tempo, indo direto para a janela do menu principal (classe GSTtelaMenu), onde o primero comando do construtor GSTtelaMenu é fechar a janela de GSTSplashWindow

        GSTSplashWindow.disposeSplash();

Bom, já tentei usar o código de thread.sleep(), mas o que acontece é que quando ponho este código, por exemplo logo depois de SetVisible(true) do construtor da classe GSTSplashWindow ou logo antes de fechar em disposeSplash(), de nada me adianta. A ampulheta do SO aparece, passa-se o tempo do sleep e popa o menu (e naturalmente a splash, mas como aparecem juntas,nem da pra ver pois logo é fechada).

Ou seja, eu queria algo do tipo janela splash-->delay 4 seg-->janela menu, mas eu tenho delay 4 seg-->janela splash-->janela menu :(

    try {
        Thread.sleep(4000);
    } catch (InterruptedException e) {

    }

PARTE DO CODIGO ONDE INICIALIZO A SPLASH SCREEN

    // metodo principal main
    public static void main(String[] args) {

            EventQueue.invokeLater(new Runnable() {  
            public void run() {  
                try {
                  GSTSplashWindow.splash(this.getClass().getResource("image/correlograma2.gif"));                     
                  // chama construtor da classe;
                  @SuppressWarnings("unused")
                  GSTJava GSTMainWindow = new GSTJava(); // inicializa ScreenWIDTH e ScreenHEIGHT
                  GSTMainWindow=null; // não preciso mais da classe, ja inicializei as variáveis static (que nao dependem da instancia do objeto)        
                  //Cria Janela do menu principal        
                  GSTtelaMenu frameTelaPrincipal = new GSTtelaMenu(); 


               try 
               {

                  UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
             } catch (InstantiationException e) {
                 e.printStackTrace();
             } catch (IllegalAccessException e) {
                 e.printStackTrace();
             } catch (UnsupportedLookAndFeelException e) {
                 e.printStackTrace();
             }
             setUIFont (new javax.swing.plaf.FontUIResource("Courier New",Font.TRUETYPE_FONT,12));
             SwingUtilities.updateComponentTreeUI(frameTelaPrincipal);       
             frameTelaPrincipal.setVisible(true);
             frameTelaPrincipal.setResizable(false);
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
        });                  
    }

CLASSE da SPLASH SCREEN

package gstjava;

import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.net.URL;
import java.util.Date;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;


public class GSTSplashWindow extends JFrame {

  private static final long serialVersionUID = 9090438525613758648L;

  private static GSTSplashWindow instance;

  private boolean paintCalled = false;

  private Image image;

  private GSTSplashWindow(Image image) {
    super();
    this.image = image;
    JLabel label = new JLabel();
    label.setIcon(new ImageIcon(image));
    this.add(label);    
    this.setUndecorated(true);
    this.setAlwaysOnTop(true);
    this.pack();
    this.setLocationRelativeTo(null);
    this.setVisible(true);                  


    try { Thread.sleep(3000);  

    } catch (Exception e) {}  
        setVisible(false);      
  }

  public static void splash(URL imageURL) {
    if (imageURL != null) {
      System.out.println("Abri Splash"); 
      splash(Toolkit.getDefaultToolkit().createImage(imageURL));
    }
  }

  public static void splash(Image image) {
    if (instance == null && image != null) {
      instance = new GSTSplashWindow(image);
      instance.setVisible(true);

      if (!EventQueue.isDispatchThread() && Runtime.getRuntime().availableProcessors() == 1) {

        synchronized (instance) {
          while (!instance.paintCalled) {
            try {
              instance.wait();
            } catch (InterruptedException e) {
            }
          }
        }
      }
    }
  }

  @Override
  public void update(Graphics g) {
    paint(g);
  }

  @Override
  public void paint(Graphics g) {
    g.drawImage(image, 0, 0, this);
    if (!paintCalled) {
      paintCalled = true;
      synchronized (this) {
        notifyAll();
      }
    }
  }

  public static void disposeSplash() {
     System.out.println("Fechei Splash");  
    instance.setVisible(false);
    instance.dispose();
  }

}

NOTA: Consegui resolver!!, estudando um pouco mais sobre Threads, achei um ótimo site gringo aqui, é um preparatório para certificação (mas está em inglês) :

http://inheritingjava.blogspot.com.br/2011/02/chapter-57-thread-states-and.html

Eu fiz as seguintes alterações, chamei a janela splashscreen dentro do metodo InvokeandWait na main()

        try {
            SwingUtilities.invokeAndWait(new Runnable() {
                public void run() {

                    GSTSplashWindow.splash(this.getClass().getResource("image/splashscreen.jpg")); 
                }
            });
        } catch (InvocationTargetException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

E mais importante, pus a thread.sleep(), dentro de um bloco "sinchronized", logo antes de eu liberar o "lock" com o NotifyAll

 @Override
  public void paint(Graphics g) {
    g.drawImage(image, 0, 0, this);
    if (!paintCalled) {
      paintCalled = true;
      synchronized (this) 
      {
      try { Thread.sleep(1500);  
            } 
      catch (Exception e) {}  
         notifyAll();
      }
    }
  }

O código para fechar a splash screen continuou dentro do construtor da classe de menu.

Funcionou que nem uma uva!!

Obrigado pelas respostas de qualquer forma.

Um pouco mais sobre o método InvokeandWait : " Para entender o que invokeAndWait () faz, você primeiro precisa entender o model "event/thread" do Swing

Basicamente, tudo o que afeta o GUI de qualquer forma deve acontecer em um única thread. Isso ocorre porque a experiência mostra que uma GUI multi-threaded é impossível de se funcionar corretamente.

No Swing, estas threads de GUI são chamadas de Event Dispatch Thread, ou EDT. Ele é iniciadoa assim que qualquer componente top-level do Swing é mostrado, e é basicamente uma "thread de trabalho" que tem uma fila FIFO (First In, First Out) de objetos de eventos que são executados uma após a outra.

Quando um GUI do Swing precisa ser desenhada ou atualizada, o JRE coloca um evento na fila do EDT. Ações do usuário que trigam os "listeners" e seu código a eles associados serem executados trigam eventos na fila de EDT. E (esta é esta é a parte importante) tudo o que o programa faz que muda a GUI (como o registro de de "listeners" adicionar / remover componentes GUI, ou alterar os dados mostrados na GUI) deve ser colocado na fila de EDT, ou a GUI ficar corrompida.

Pra finalizar, InvokeAndWait () coloca o código que vc passa pelo Runnable() na fila de eventos EDT e ESPERA até a execução deste código. Isso deve ser usado quando uma thread não-GUI precisa fazer algo que afeta a GUI, mas também precisa esperar até que a execução do código seja concluida para continuar. Se você quiser apenas fazer algo que afeta a GUI, mas não se importa quando este código é executado (fica a merce do temporização do EDT, que vc não tem controle), você deve usar invokeLater ()."

credito: http://stackoverflow.com/questions/5499921/invokeandwait-method-in-swingutilities

Versões(5):

Ver a versão formatada

SplashScreen OK!, mas pisca muito rápido, thread.sleep() não funciona.

Comentário

new question