Splash em JAVA - NetBeans

Adicionar uma tela inicial para um aplicativo Java

Passei cerca de um dia pesquisando como fazer isso. É fácil e leva apenas alguns minutos, uma vez que você sabe o procedimento.

A tela inicial é útil quando o aplicativo tem um procedimento de inicialização que pode levar uma quantidade significativa de tempo para que o aplicativo se torna sensível. Também podem conter de marketing útil ou outras informações. Em suma, o propósito de uma tela de abertura é para entreter e informar o usuário, enquanto o programa está ocupado se preparando para responder. Outro benefício de mostrar uma tela inicial é que ele ajuda o desenvolvedor eo usuário final entender quanto tempo cada etapa de inicialização leva e se por algum motivo a inicialização não for concluído nós sabemos que passo causou o problema

Este projecto foi concebido para simplificar, uma vez que você entendê-lo há muito que você pode fazer para torná-la mais bonita.

Se você estiver com pressa

Se você quiser ver os resultados aqui é o jar este tutorial produz arquivo: SplashDemo.jar

Aqui está o projeto NetBeans arquivo: SplashDemo.zip Este foi desenvolvido usando o NetBeans 6.8, Java 1.6.0_18; OpenJDK 64-Bit Servidor VM 16,0-b13. Os resultados foram testados no Windows XP, Vista e 7 e Linux (Centos 5, Ubuntu 10.04). Eu também tenho verificado o projeto trabalha com NetBeans 6.9.1 e 6.10m1.

Em geral, mesmo se você não estiver usando qualquer IDE, você só precisa dar dois passos para adicionar uma tela inicial para a sua aplicação Java:

• Adicionar uma imagem à jar (PNG, JPG e GIF formatos são suportados)
• Atualize seu manifesto jar executável para especificar a imagem a ser usada como uma tela inicial. Adicionar:

  SplashScreen-Image: <full ou o caminho relativo para a imagem em jar>

O quadro acima mostra a tela inicial quando você compilar e executar o jar, mas não quando você executar ou depurar a partir do NetBeans. Para ver o splash e ser capaz de depurar modificações respingo, vá para as propriedades de execução e adicione o seguinte para as opções VM

-Splash: <full ou o caminho relativo para a imagem no projeto>

Note que se você usar a função de navegação IDE para a imagem inicial que vai usar o caminho completo para a imagem, o que é bom até que o projeto é movida para um local diferente.

Para personalizar o splash (adicionar tarefa atual e uma barra de progresso) use SplashScreen.getSplashScreen (); O que permitirá que você desenhe sobre a imagem inicial. Consulte as seções abaixo sobre como adicionar rapidamente uma tela usando o NetBeans IDE.

Eu gostaria de enfatizar a "desenhar sobre" parte. O contexto gráfico da imagem está disponível e vamos usá-lo para desenhar sobre a imagem. Isso é diferente de adicionar widgets para um recipiente Swing.

Passo a passo

Para começar, crie um projeto Java Application vazio no NetBeans IDE.

Para adicionar um respingo criar uma imagem, mas deixe algum espaço para adições na próxima parte. A imagem pode ser PNG, JPEG ou GIF. Por exemplo, no meu conhecimento a imagem da área em branco na parte inferior, que é onde a barra de texto e de progresso irá.

(Fato irrelevante: Estou no comando da T28B na foto, durante uma aula de vôo de formação).

Copie sua imagem Splash Screen para a pasta de origem no seu projeto. Nota: se você tem mais recursos que você pode querer uma pasta de recursos separado.

Em seguida, a partir da árvore de arquivos manifest.mf aberto: 

Adicione a propriedade SplashScreen-imagem como mostrado.

  Manifest-Version: 1.0
 SplashScreen-Image: splashdemo / splash.png
 X-COMMENT: Main-Class será adicionado automaticamente por construir

Construa o projeto e executar o jar. O Splash será exibido. Neste ponto, a tela inicial não será exibida quando você executar ou depurar o projeto a partir do NetBeans IDE.

Para obter o Splash para exibir com a corrida ou comando de depuração do IDE editar as propriedades correr e adicionar ao campo de opções VM

 espirrar: src / <packagename> / splash.png

A razão pela qual queremos que a tela inicial para exibir a partir de dentro do IDE é que nos dá a capacidade de depurar a personalização apresentados a seguir.

Personalizando o Splash para incluir o nome da tarefa e progresso

Nós podemos fazer pequenas alterações para o Splash em tempo de execução através da sobreposição de texto simples e objetos gráficos. Se você quer muito mais controle, você pode substituir a imagem com um Painel de Swing (ver Java Artigo Técnico sobre Splash Screen [1] ), mas que não faz parte deste tutorial.

Nesta seção, vamos substituir parte da nossa imagem inicial com uma seqüência de texto e barra de progresso (na verdade um retângulo preenchido). Lembra que eu sugeri que deixar alguma área em branco à nossa imagem para isso. I reservado o fundo 15% ou este uso.

O código a seguir pode ser colocado em qualquer lugar, mas eu prefiro métodos estáticos na classe Main. Isso nos permite chamá-los a partir de qualquer classe com uma chamada como:

 Main.splashText ("Fazer a primeira coisa.");

Para gerenciar o Splash criamos três métodos:

• splashInit - definir as propriedades dos objetos que precisamos para os outros métodos
• splashText - exibe uma seqüência de texto
• splashProgress - update barra de progresso

Suponha que o intialization é feito em um AppInit chamada de método. Nosso método AppInit só vai exibir uma lista de seqüências de um de cada vez e esperar um segundo para simular uma tarefa de inicialização.

O método principal contém:

     void main (String [] args) public static
     {
         splashInit ();  / / Inicializa respingo sobreposição desenho parâmetros
         AppInit ();  / / Simular o que um aplicativo poderia fazer 
                                 / / Antes de iniciar
         if (mySplash! = null) / / verifica se realmente tinha uma tela spash
             mySplash.close ();  / / Se por isso estamos agora feito com ele
        
         / / Começam com a porção interactiva do programa
     }

Os métodos de suporte do Splash são descritos abaixo:

     / **
      * Preparar as variáveis ​​globais para as outras funções respingo
      * /
     splashInit private static void ()
     {
         mySplash SplashScreen.getSplashScreen = ();
         if (mySplash! = null)
         {/ / Se houver algum problema que indicam o respingo este será nulo
             Dimensão ssDim = mySplash.getSize ();
             int height = ssDim.height;
             int width = ssDim.width;
             / / Demarcar alguma área para o nosso informações de status
             splashTextArea = new Rectangle2D.Double (. 15, altura 0,88 *, * largura 0,45, 32.);
             splashProgressArea = new Rectangle2D.Double (largura * 0,55, altura * 0,92, largura * 0,4, 12);

             / / Cria o ambiente gráfico para desenhar informações de status
             splashGraphics mySplash.createGraphics = ();
             font = new Font ("Dialog", Font.PLAIN, 14);
             splashGraphics.setFont (fonte);
            
             / / Inicializar a informação de status
             splashText ("Iniciando");
             splashProgress (0);
         }
     }

Na área alocamos para o texto, primeiro apagar um retângulo, em seguida, desenhar texto. Se você não estiver familiarizado com o texto primitivos área de aprendizagem cobrindo texto [2] é uma leitura que vale a pena. Uma melhoria que poderíamos fazer é determinar se o texto vai caber na área alocada e truncar-lo, ou envolvê-lo em várias linhas.

     / *** Exibe texto na área de status do Splash.  Nota: nenhuma validação vai se encaixar.  * @ Param str - texto a ser exibido * / splashText public static void (String str) {if (! MySplash = null && mySplash.isVisible ()) {/ / importante verificar aqui, então há outros métodos precisa de saber se existe / / é realmente um respingo sendo exibido / / apagar o último status de texto splashGraphics.setPaint (Color.LIGHT_GRAY);  splashGraphics.fill (splashTextArea);  / / Desenha o splashGraphics.setPaint texto (Color.BLACK);  splashGraphics.drawString (str, (int) (splashTextArea.getX () + 10), (int) (splashTextArea.getY () + 15));  / / Verifique se ele é exibido mySplash.update ();  }} 

Para uma barra de progresso que vamos usar um longo retângulo fino e preencher uma percentagem adequada do mesmo. Se você não estiver familiarizado com as primitivas de desenho, a trilha do aprendizado [3] é um excelente lugar para aprender.

     / **
      * Apresentar um (muito) barra de progresso básico
      * @ Param pct quanto da barra de progresso para exibir 0-100
      * /
     splashProgress public static void (int pct)
     {
         if (mySplash! = null && mySplash.isVisible ())
         {

             / / Nota: 3 cores são usadas aqui para demonstrar passos
             / / Apagar o antigo
             splashGraphics.setPaint (Color.LIGHT_GRAY);
             splashGraphics.fill (splashProgressArea);

             / / Desenha um esboço
             splashGraphics.setPaint (Color.BLUE);
             splashGraphics.draw (splashProgressArea);

             / / Calcula a largura correspondente à porcentagem correta
             int x = (int) splashProgressArea.getMinX ();
             int y = (int) splashProgressArea.getMinY ();
             int wid = (int) splashProgressArea.getWidth ();
             int hgt = (int) splashProgressArea.getHeight ();

             int doneWidth = Math.round (pct * wid/100.f);
             doneWidth = Math.max (0, Math.min (doneWidth, wid-1));  / / Limite de 0-largura

             / / Preenchendo a parte feito um pixel menor que o contorno
             splashGraphics.setPaint (Color.GREEN);
             splashGraphics.fillRect (x, y +1, doneWidth, hgt-1);

             / / Verifique se ele é exibido
             mySplash.update ();
         }
     }

     / **
      * Apenas um esboço para simular uma tarefa de inicialização muito tempo que atualiza
      * as partes do texto e progresso do estado o Splash
      * /
     AppInit private static void ()
     {
         for (int i = 1; i <= 10; i + +)
         {
             int pctDone = i * 10;
             splashText ("Fazer tarefa #" + i);
             splashProgress (pctDone);
             tentar
             {
                 Thread.sleep (1000);
             }
             catch (InterruptedException ex)
             {
                 / / Ignorá-la
             }
         }
     }