Artigos Java Como criar um JFrame com imagem de fundo

Imagens de fundo (backgrounds) são extremamente essenciais para certos layouts. Um simples gradient ou uma marca d’água representam um grande diferencial e tornam a aplicação mais agradável.

Infelizmente, o componente JFrame, até a versão 6.0 do JDK, não possui uma propriedade específica que possibilite configurar uma imagem como plano de fundo. Nesse caso é necessário implementar uma maneira, das várias possíveis, para disponibilizar esse recurso.

Definindo uma imagem de fundo

Para o exemplo do artigo, será usada uma imagem simples representando um gradient com dimensões 1024x768, que é a resolução mais utilizada atualmente nos desktops e armazenada no “C:\” como indica a figura a seguir:

ascjfiffig01.jpg

O caminho da imagem que será utilizado pelo Java nesse caso será: “C:\bg_gradient.jpg”.

O método paintComponent

Como citado anteriormente, para se criar a possibilidade de definição de uma imagem de fundo, é necessário implementá-la manualmente.

Os JFrames possuem uma propriedade chamada contentPane que é o componente padrão onde são adicionados todos os componentes específicos como botões, labels, áreas de texto, etc.

Este contentPane possui um método chamado paintComponent que é o método responsável por desenhá-lo (o que é exibido para o usuário). E é ele quem será implementado.

A Listagem 01 exibe uma private class que será utilizada mais adiante no artigo. Primeiramente é interessante focar na implementação de paintComponent.


 private class NewContentPane extends JPanel{
 //método implementado de JPanel
 protected void paintComponent(final Graphics g) {
                super.paintComponent(g);
                g.drawImage(bImage, 0, 0, this);
         }
 }

Listagem 01 – Classe interna que implementa paintComponent

A classe interna NewContentPane é uma classe filha de JPanel e será o novo contentPane de JFrame.

Super.paintComponent(g) chama o respectivo método, porém, de JPanel, para que não sejam perdidas as visualizações-padrão de um JPanel. Em seguida, o método drawImage “desenha” bImage (imagem utilizada como background – descrita na próxima etapa do artigo).

Com isso tem-se uma classe filha de JPanel, porém com uma imagem desenhada ao invés de uma cor padrão.

O JFrame com o novo contentPane

Será desenvolvido agora o JFrame adaptado com o novo contentPane.

A Listagem 02 representa o código-fonte da classe JFrameWithBackground com a classe interna criada anteriormente.


 package br.com.jm.jframes;
  
 import java.awt.Graphics;
 import java.awt.Image;
 import java.awt.Toolkit;
  
 import javax.swing.JFrame;
 import javax.swing.JPanel;
  
 public class JFrameWithBackground extends JFrameFactory{
         
         Image bImage;
         
         public JFrameWithBackground(String path){
                this.bImage = this.createImage(path);
                this.initComponents();
         }
         
         public void initComponents(){
                super.setContentPane(new NewContentPane());
                super.setExtendedState(JFrame.MAXIMIZED_BOTH);               
         }
         
         private Image createImage(String path){
                return Toolkit.getDefaultToolkit().createImage(path);
         }
         
         private class NewContentPane extends JPanel{
                protected void paintComponent(final Graphics g) {
                        super.paintComponent(g);
                        g.drawImage(bImage, 0, 0, this);
                }
         }
 }

Listagem 02 – JFrameWithBackground

O construtor da classe recebe uma String que representa o caminho da imagem e em seguida chama o método createImage. Esse método chama a função createImage da classe Toolkit (java.awt.Toolkit) que retorna uma imagem de acordo com esse caminho. A variável, anteriormente citada, bImage agora representa a imagem de fundo do JFrame.

É dentro do método initComponents que se faz a alteração do contentPane que agora será uma instância de NewContentPane (classe interna criada no início do artigo e que implementa paintComponent).

Como isso tem-se um JFrame que possui um contentPane diferente do padrão; que possui uma imagem de fundo.

Testando o novo JFrame

Falta apenas testar o novo JFrame e sua nova capacidade (possuir uma imagem de fundo). A Listagem 03 exibe uma classe simples com um panel adicionado.


 import java.awt.BorderLayout;
 import java.awt.Dimension;
  
 import javax.swing.BorderFactory;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTextArea;
 import javax.swing.UIManager;
  
 import br.com.jm.jframes.JFrameWithBackground;
  
 public class TesteJFrameWithBackground {
         public static void main(String[] args) {
                try{
                        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch(Exception exception){
                        
                }
                
                JPanel jPanel3 = new JPanel(new BorderLayout());
                jPanel3.add(new JLabel("teste-background"), BorderLayout.NORTH);
                jPanel3.add(new JLabel("texto:"), BorderLayout.WEST);
                jPanel3.add(new JScrollPane(new JTextArea()), BorderLayout.CENTER);
                jPanel3.add(new JLabel("teste-background-fim"), BorderLayout.SOUTH);
                jPanel3.setPreferredSize(new Dimension(400,500));
                jPanel3.setBorder(BorderFactory.createTitledBorder("jPanel3"));
                jPanel3.setOpaque(false);
                
                JFrameWithBackground jFrame = new JFrameWithBackground("C:\\bg_gradient.jpg");
                jFrame.setLayout(new BorderLayout());
                jFrame.getContentPane().add(jPanel3, BorderLayout.NORTH);
                jFrame.setVisible(true);
         }
 }

Listagem 03 – Classe de testes

A imagem passada como parâmetro para JFrameWithBackground é a citada no início do artigo.

Conclusão

Implementando paintComponent de JPanel e armazenando essa implementação como novo contentPane de um JFrame foi possível criar um frame com uma imagem de fundo. À medida que essa nova classe vai sendo desenvolvida, pode-se criar métodos set e get que permitam atualizar, em tempo de execução, a imagem de fundo, tornando-a dinâmica.