Artigos Java Conhecendo Gerenciadores de Layout GUI do Java

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.