Conhecendo Gerenciadores de Layout GUI do Java
Veja neste artigo como os gerenciadores de layout organizam os componentes GUI em um contêiner para propósitos de apresentação. Saiba as capacidades básicas de layout para determinar a posição e o tamanho exato de cada componente GUI.
Gerenciadores de Layout
Todos os gerenciadores de layout implementam a interface LayoutManager que faz parte do pacote java.awt. Existe o método setLayout da classe Container que aceita um objeto que implementa a interface LayoutManager como um argumento.
Veja três maneiras básicas de organizar componentes em uma GUI:
- Posicionamento absoluto: fornece o maior nível de controle sobre a aparência de uma GUI, pois configura o layout de um Container como null podendo especificar a posição absoluta de cada componente GUI em relação ao canto superior esquerdo do Container usando os métodos Component setSize e setLocation ou setBounds.
- Gerenciadores de layout: é mais simples e mais rápido para criar uma posição GUI com posicionamento absoluto, mas acaba perdendo controle sobre tamanho e o posicionamento dos componentes GUI.
- Programação visual em uma IDE: facilita o desenvolvimento em GUI, pois toda IDE tem uma ferramenta de design que permite arrastar e soltar (drag and drop) os componentes para uma área de desenho.
Cada contêiner individual pode ter apenas um gerenciador de layout, mas vários contêineres no mesmo aplicativo podem utilizar cada um gerenciador de layout. Os gerenciadores de layout são diversos, mas nesse artigo vamos conhecer o FlowLayout, BorderLayout e GridLayout como apresentado abaixo.
FlowLayout
Ocorre quando os componentes GUI são colocados em um contêiner da esquerda para a direita na ordem em que são adicionados no contêiner. Quando a borda do contêiner é alcançada, os componentes continuarão a ser exibidos na próxima linha. A classe FlowLayout permite aos componentes GUI ser alinhados à esquerda, centralizados (padrão) e alinhados à direita.
Na Listagem 1 a classe está criando e adicionando 3 objetos Jbutton ao aplicativo. Os componentes ficam centralizados por padrão. A ação desse aplicativo será relacionada aos botões. Quando o usuário clicar no botão “Direita” o alinhamento do gerenciador muda para um FlowLayout à direita e assim acontece com os outros botões quando clicado, cada um com seu alinhamento.
Cada botão tem seu próprio handler de evento que é declarado com um uma classe interna anônima que implementa ActionListener.
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
public class FlowLayoutFrame extends JFrame {
private JButton botaoEsquerdo;
//BOTÃO PARA CONFIGURAR O ALINHAMENTO À ESQUERDA
private JButton botaoDireito;
//BOTÃO PARA CONFIGURAR O ALINHAMENTO À DIREITA
private JButton botaoCentral;
//BOTÃO PARA CONFIGURAR O ALINHAMENTO CENTRALIZADO
private FlowLayout layout;
//OBJETO LAYOUT
private Container container;
//CONTÊINER PARA CONFIGURAR LAYOUT
//CONFIGURA GUI E REGISTRA LISTENERS DE BOTÃO
public FlowLayoutFrame()
{
super("Demonstração de um FlowLayout");
layout = new FlowLayout(); //CRIA FLOWLAYOUT
container = getContentPane(); //OBTÊM CONTEINER PARA LAYOUT
setLayout(layout); //CONFIGURA O LAYOUT DE FRAME
//CONFIGURA LEFTBUTTON E REGISTRA LISTENER
botaoEsquerdo = new JButton("Esquerda"); //CRIA O BOTÃO LEFT
add(botaoEsquerdo); //ADICIONA O BOTÃO ESQUERDO AO FRAME
botaoEsquerdo.addActionListener(new ActionListener() {
@Override
//PROCESSA O EVENTO BOTÃO ESQUERDO
public void actionPerformed(ActionEvent e) {
layout.setAlignment(FlowLayout.LEFT);
//REALINHA OS COMPONENTES ANEXADOS
layout.layoutContainer(container);
}
}
);
//CONFIGURA O BOTÃO CENTRAL E REGISTRA O LISTENER
botaoCentral = new JButton("Centro"); //CRIA P BOTÃO CENTRAL
add(botaoCentral); //ADICIONO O BOTÃO AO FRAME
botaoCentral.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
layout.setAlignment(FlowLayout.CENTER);
//REALINHA OS COMPONENTES ANEXADOS
layout.layoutContainer(container);
}
}
);
//CONFIGURA O BOTÃO DIREITO E REGISTRA O LISTENER
botaoDireito = new JButton("Direita");
add(botaoDireito); //ADICIONA BOTÃO
botaoDireito.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
layout.setAlignment(FlowLayout.RIGHT);
layout.layoutContainer(container);
}
}
);
}
}Listagem 1. Classe com as funções FlowLayout
import javax.swing.JFrame;
public class TestaFlowLayout {
public static void main(String[] args) {
FlowLayoutFrame fl = new FlowLayoutFrame();
fl.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fl.setSize(600, 75); //CONFIGURA O TAMANHO DA TELA
fl.setVisible(true); //CONFIGURA A VISIBILIDADE
}
}Listagem 2. Classe testadora
Border Layout
É um gerenciador de layout que organiza os componentes, sendo a parte superior do contêiner dividida em cinco regiões:
- NORTH
- SOUTH
- EAST
- WEST
- CENTER
A classe BorderLayout estende a Object e implementa a interface LayoutManager2 sendo uma subinterface de LayoutManager que adiciona vários métodos para obter um processamento de layout aprimorado.
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
public class BorderLayoutFrame extends JFrame implements ActionListener {
private JButton[] botoes; //ARRAY DE BOTÕES PARA OCULTAR PARTES
private static final String[] nomes = {"Esconde Norte", "Esconde Sul",
"Esconde Leste", "Esconde Oeste", "Esconde Centro"};
private BorderLayout layout;
public BorderLayoutFrame()
{
super("Demo LayoutFrame");
layout = new BorderLayout(5,5); //ESPAÇOS DE 5 PIXELS
setLayout(layout);
botoes = new JButton[nomes.length]; //CONFIGURA O TAMANHO DO ARRAY
//CRIA JBUTTONS E REGISTRA OUVINTES
for(int count = 0; count < nomes.length; count++){
botoes[count] = new JButton(nomes[count]);
botoes[count].addActionListener(this);
}
//ADICIONA A POSIÇÃO DOS BOTÕES
add(botoes[0], BorderLayout.NORTH);
add(botoes[1], BorderLayout.SOUTH);
add(botoes[2], BorderLayout.EAST);
add(botoes[3], BorderLayout.WEST);
add(botoes[4], BorderLayout.CENTER);
}
@Override
public void actionPerformed(ActionEvent evento) {
//VERIFICA A ORIGEM DE EVENTO E O PAINEL DE CONTEÚDO DE LAYOUT CORRESPONDENTE
for(JButton botao : botoes){
if(evento.getSource() == botao)
botao.setVisible(false); //OCULTA O BOTÃO QUANDO CLICADO
else
botao.setVisible(true);
}
layout.layoutContainer(getContentPane());
}
}Listagem 3. Classe de funções Border Layout
import javax.swing.JFrame;
public class TestaBorderLayoutFrame {
public static void main(String[] args) {
BorderLayoutFrame border = new BorderLayoutFrame();
border.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
border.setSize(400,200);
border.setVisible(true);
}
}Listagem 4. Classe testadora Border Layout
Grid Layout
É um gerenciador de layout que divide o contêiner em uma grade de modo que os componentes podem ser colocados nas linhas e colunas. A classe GridLayout estende a classe Object e implementa a interface LayoutManager.
Cada componente no GridLayout tem os mesmos tamanhos, onde podem ser inserida uma célula na parte superior esquerda da grade que prossegue da esquerda para a direita até preencher por completa.
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
public class GridLayoutFrame extends JFrame implements ActionListener {
private JButton[] botoes;
private static final String[] nomes = {"um", "dois", "três",
"quatro", "cinco", "seis"};
private boolean toggle = true;
private Container container;
private GridLayout gridLayout1;
private GridLayout gridLayout2;
public GridLayoutFrame()
{
super("Demo Grid Layout");
gridLayout1 = new GridLayout(2, 3, 5, 5); //2 POR 3; LACUNAS DE 5
gridLayout2 = new GridLayout(3,2); //3 POR 2; NENHUMA LACUNA
container = getContentPane(); //OBTÉM O PAINEL DE CONTEÚDO
setLayout(gridLayout1);
botoes = new JButton[nomes.length];
for(int count = 0; count < nomes.length; count++)
{
botoes[count] = new JButton(nomes[count]);
botoes[count].addActionListener(this); //OUVINTE REGISTRADO
add(botoes[count]);
}
}
//TRATA EVENTOS DE BOTÃO ALTERNANDO ENTRE LAYOUTS
public void actionPerformed(ActionEvent event)
{
if(toggle)
container.setLayout(gridLayout2);
else
container.setLayout(gridLayout1);
toggle = !toggle; //ALTERNA PARA O VALOR OPOSTO
container.validate(); //REFAZ O LAYOUT DO LAYOUT
}
}Listagem 5. Classe com as funções do GridLayout
import javax.swing.JFrame;
public class TestaGridLayout {
public static void main(String[] args) {
GridLayoutFrame glf = new GridLayoutFrame();
glf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
glf.setSize(300,200);
glf.setVisible(true);
}
}Listagem 6. Classe Testadora GridLayout
Conclusão
Quando se desenvolve em interface GUI, são usadas ferramentas de design como NetBeans ou Eclipse, mas o mais usado ainda é o NetBeans para esse tipo de desenvolvimento, pois fornece um maior controle na posição dos elementos e dos tamanhos.
Artigos relacionados
-
Artigo
-
Artigo
-
Artigo
-
Artigo
-
Vídeo