Gerenciadores de Layout

Universidade Presbiteriana Mackenzie
Aula 8b: Gerenciadores de Layout
Prof. Ms. Daniel Arndt Alves
Faculdade de Computação e Informática
Linguagem de
Programação II
Daniel Arndt Alves Gerenciadores de Layout 1

Tópicos da Aula
• Gerenciadores de Layout
• Modelo de gerenciamento de
eventos no Java AWT
• Implementação básica de tratamento de
eventos

O posicionamento de componentes pode ser controlado
através de gerenciadores de layout. O AWT possui
cinco gerenciadores de layout:
• FlowLayout
• GridLayout
• BorderLayout
• CardLayout
• GridBagLayout
Gerenciadores de layout

Utilização dos gerenciadores
Uma vez instanciado o gerenciador, a atribuição deste a
um container é feita através da chamada:
container.setLayout(Instância do gerenciador);
A partir deste ponto, utiliza-se o método add para
adicionar os componentes dentro do container,
obedecendo-se as características de cada gerenciador.

FlowLayout
Trata o container como um conjunto de linhas. A
altura das linhas é determinada pela altura dos
itens nelas contidos.
A classe FlowLayout possui três construtores:
public FlowLayout() (alinhamento CENTER)
public FlowLayout(int alinhamento)
public FlowLayout(int alinhamento,
int espaçamento horizontal,
int espaçamento vertical)

FlowLayout
Alinhamento LEFT
Frame f=new Frame("Exemplo de Dialogo");
FlowLayout fluxo=new FlowLayout(FlowLayout.LEFT);
f.setLayout(fluxo);

FlowLayout
Alinhamento CENTER
FlowLayout fluxo=new flowLayout(FlowLayout.CENTER);
f.setLayout(fluxo);

FlowLayout
Alinhamento RIGHT
FlowLayout fluxo=new FlowLayout(FlowLayout.RIGHT);
f.setLayout(fluxo);

FlowLayout
Espaçamento
FlowLayout fluxo=new flowLayout(FlowLayout.CENTER, 5, 15);
f.setLayout(fluxo);

GridLayout
Trata o container como uma matriz de linhas e colunas.
Possui dois construtores:
public GridLayout(int linhas, int colunas)
public GridLayout(int linhas, int colunas,
int espaçamento horizontal,
int espaçamento vertical)

GridLayout
GridLayout grid=new GridLayout(2, 3, 20, 10);
f.setLayout(grid);

BorderLayout
Divide o container em até cinco partes, cujos
identificadores são:
North
West Center East
South
Container

BorderLayout
Frame frame=new Frame("Exemplo de Dialogo");
frame.setLayout(new BorderLayout());
add("North", new Button("Norte"));
add("South", new Button("Sul"));
add("East", new Button("Leste"));
add("West", new Button("Oeste"));
add("Center", new Button("Centro"));

CardLayout
Trata o container como uma pilha de fichas. Cada
componente é considerado uma ficha separada, e
apenas uma delas é visível de cada vez.
Possui o seguinte construtor básico:
public CardLayout()

CardLayout
frame.setLayout(new CardLayout());
add(new Button("Norte"));
add(new Button("Sul"));
add(new Button("Leste"));
add(new Button("Oeste"));
add(new Button("Centro"));

CardLayout
Cada um dos componentes adicionados segundo o
gerenciador CardLayout pode ser acessado
segundo os seguintes métodos:
public void first(Container pai);
public void last(Container pai);
public void next(Container pai);
public void previous(Container pai);
public void show(Container pai, String nome);

CardLayout
Exemplo de Acesso
CardLayout ger=new CardLayout();
frame.setLayout(ger);
frame.add(new Button("Norte"));
frame.add(new Button("Sul"));
frame.add(new Button("Leste"));
frame.add(new Button("Oeste"));
frame.add(new Button("Centro"));
ger.first(frame); // Acessa o primeiro componente
ger.next(frame); // Acessa o próximo componente

GridBagLayout
Funciona como o GridLayout, dividindo o container
em linhas e colunas. Porém, um componente pode
ocupar mais de uma célula. Ao adicionar um
componente num gerenciamento por
GridBagLayout, ele recebe uma
GridBagConstraint, que tem instruções de
posicionamento e dimensionamento.
O construtor da classe é bem simples:
public GridBagLayout()

GridBagConstraint
Classe que especifica os detalhes de inserção de
componentes em containers, segundo o gerenciador
GridBagLayout.
Algumas atributos importantes da classe são:
• gridwidth: número de células em uma linha para
exibição do componente
• gridheight: número de células em uma coluna
para exibição do componente
O valor padrão de cada um destes atributos é 1.

GridBagConstraint
Os atributos gridwidth e gridweight também podem
assumir valores especiais, indicados por:
• GridBagConstraints.REMAINDER : especifica que o
componente é último da linha.
• GridBagConstraints.RELATIVE : especifica que o componente é
o próximo numa linha/coluna.

GridBagConstraint
Para atribuir uma “constraint” a um componente, faz-se:
1. Instancia-se a classe GridBagConstraints
2. Altera-se os atributos destas instância
3. Utiliza-se o método setContraints, da classe
GridBagLayout, com os seguintes parâmetros:
void setContraints(Component c,
GridBagConstraints g)

GridBagLayout

GridBagLayout
import java.awt.*;
import java.util.*;
import java.applet.Applet;
public class GridBagEx1 extends Applet {
void makebutton(String name,
GridBagLayout gridbag,
GridBagConstraints c) {
Button button = new Button(name);
gridbag.setConstraints(button, c);
add(button);
}

GridBagLayout
public void init() {
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c =
new GridBagConstraints();
setFont(new Font("Helvetica", Font.PLAIN, 14));
setLayout(gridbag);
// Distribuição horizontal de espaço
c.weightx = 1.0;
makebutton("Button1", gridbag, c);

GridBagLayout
c.gridwidth = GridBagConstraints.REMAINDER;
c.weightx = 0.0;
c.gridwidth = GridBagConstraints.RELATIVE;

GridBagLayout
c.gridwidth = 1;
c.gridheight = 2;
c.weighty = 1.0; // Distribuição vertical de espaço
c.weighty = 0.0;
c.gridheight = 1;
setSize(300, 100);
}

Não há necessidade de se ficar vinculado
exclusivamente às classes de gerenciamento vistas
anteriormente.
Classes que definem gerenciamento de layout
implementam uma das seguintes interfaces:
• LayoutManager : layout sem constraints
• LayoutManager2: layout com constraints
Implementação de gerenciadores de
Layout

Eventos estão relacionados com a parte dinâmica
de uma interface. Por exemplo, se houve um
clique de mouse em cima de um botão da
interface, diz-se que ocorreu um evento de
mouse.
O Java AWT implementa um mecanismo
bastante robusto para gerenciamento de
eventos.
Eventos

Java AWT consegue gerenciar diretamente os seguintes
tipos básicos de eventos:
• eventos de mouse
• eventos de teclado
• eventos de ação
• eventos de foco
Tipos de Eventos

Modelo de gerenciamento de eventos em Java AWT
A notificação de ocorrência e tratamento do evento
é baseada em dois métodos da classe
java.awt.Component:
• deliverEvent() : despacha o evento para o
componente
• postEvent() : chama o método
handleEvent() para verificar se o
componente poderia tratar o evento.

Container
Componente Componente
Container
Componente Componente Componente
Container
Evento

Componente
Container
Componente Container
Componente Componente Componente Container
deliverEvent()
deliverEvent()
deliverEvent()
deliverEvent()

Componente
Container
Componente Container
Componente Componente Componente Container
postEvent()
postEvent()
*
*
**
postEvent()
* if (handleEvent(Event) == false)
super.postEvent()
** handleEvent(Event)== true)

Tratamento de eventos
Existem várias maneiras que um componente
pode implementar seu tratamento para um
determinado evento.
O ponto importante é entender que o método
handleEvent(Event) é o despachante de
eventos central para um componente.

Método handleEvent
O método handleEvent é definido segundo o
seguinte protótipo:
public boolean handleEvent(Event evt);
Event é uma classe do AWT que abstrai as
características do evento e já vem instanciada
na chamada do método.

Classe Event
A classe Event possui três atributos
importantes no tratamento de eventos:
• Object target : alvo do evento
• int id : tipo do evento (constantes)
• int key : código de tecla pressionada

Atributo id
A consulta ao atributo id geralmente é feita via
constantes da classe Event:
Event.MOUSE_ENTER Event.MOUSE_EXIT
Event.MOUSE_MOVE Event.MOUSE_DOWN
Event.MOUSE_DRAG Event.MOUSE_UP
Event.MOUSE_UP Event.KEY_PRESS
Event.KEY_ACTION Event.KEY_RELEASE
Event.KEY_ACTION_RELEASE Event.ACTION_EVENT
Event.GOT_FOCUS Event.LOST_FOCUS

Método handleEvent
O comportamento padrão do método handleEvent é
determinar se ocorreu (na seguinte ordem) os
eventos:
1. De mouse
2. De teclado
3. De ação (usuário quer que alguma ação ocorra)
4. De foco no componente
5. De perda de foco no componente
e chamar o método de tratamento correspondente.

Eventos de mouse
Os eventos de mouse tratados pelo AWT são:
• entrar com mouse num componente
(id=Event.MOUSE_ENTER)
• sair com mouse de um componente
(id=Event.MOUSE_EXIT)
• movimentar o mouse sobre um componente
(id=Event.MOUSE_MOVE)

Eventos de mouse
• Apertar botão do mouse sobre um componente
(id=Event.MOUSE_DOWN)
• Arrastar mouse com botão pressionado sobre um
componente (id = Event.MOUSE_DRAG)
• soltar botão do mouse sobre um componente
(id=Event.MOUSE_UP)

Event.MOUSE_ENTER
Pode ser tratado dentro do método:
public boolean mouseEnter(Event evt, int x, int y)
(x, y) : coordenadas de entrada

Event.MOUSE_EXIT
public boolean mouseExit(Event evt, int x, int y)
(x, y) : coordenada de saída

Event.MOUSE_MOVE
public boolean mouseMove(Event evt, int x, int y)
(x, y) : coordenada do movimento

Event.MOUSE_DOWN
public boolean mouseDown(Event evt, int x, int y)
(x, y) : coordenada de pressionamento do botão

Event.MOUSE_DRAG
public boolean mouseDrag(Event evt, int x, int y)
(x, y) : coordenada de arrasto

Event.MOUSE_UP
public boolean mouseUp(Event evt, int x, int y)
(x, y) : coordenada onde botão foi solto

Ainda dentro dos eventos de mouse, o método
handleEvent faz a verificação na
sequência:
1. MOUSE_ENTER
2. MOUSE_EXIT
3. MOUSE_MOVE
4. MOUSE_DOWN
5. MOUSE_DRAG
6. MOUSE_UP
Ordem de Verificação

Exemplo
// Botão com todos os tratamentos de evento
import java.awt.*;
public class botao
extends Button{
botao(String rotulo){
// Construtor
super(rotulo);
}

Exemplo
public boolean mouseEnter(Event evt, int x, int y){
System.out.println("Entrou no componente");
return(true);
}
public boolean mouseExit(Event evt, int x, int y){
System.out.println("Saiu do componente");
return(true);
}
public boolean mouseMove(Event evt, int x, int y){
System.out.println("Movimento sobre botão");
return(true);
}

Exemplo
public boolean mouseDown(Event evt,int x,int y){
System.out.println(“Clique no componente”);
return(true);
}
public boolean mouseDrag(Event evt,int x,int y){
System.out.println(“Arrasto em cima do componente”);
return(true);
}
public boolean mouseUp(Event evt,int x,int y){
System.out.println(“Soltou em cima do botão”);
return(true);
}
} // Botão

Eventos de teclado
Dois tipos de evento podem ocorrer no teclado:
• pressionar teclas
– Event.KEY_PRESS : teclas ASCII
– Event.KEY_ACTION : teclas não-ASCII
• soltar teclas
– Event.KEY_RELEASE : teclas ASCII
– Event.KEY_ACTION_RELEASE: teclas não-ASCII

Event.KEY_PRESS
Event.KEY_ACTION
Podem ser tratados dentro do método:
public boolean keyDown(Event evt, int key)
key : código da tecla pressionada

Event.KEY_RELEASE
Event.KEY_ACTION_RELEASE
Podem ser tratados dentro do método:
public boolean keyUp(Event evt, int key)
key : código da tecla pressionada

Ordem de Verificação
Ainda dentro dos eventos de teclado, o método
handleEvent faz a verificação na seqüência:
1. KEY_PRESS e KEY_ACTION
2. KEY_RELEASE e KEY_ACTION_RELEASE

Exemplo
// Botão com tratamento de teclado no botão
import java.awt.*;
public class botao
extends Button{
botao(String rotulo){
// Construtor
super(rotulo);
}

Exemplo
public boolean keyDown(Event evt,int key){
if (key=='a')
setLabel("Tecla a pressionada");
else if (key==Event.LEFT)
setLabel("Seta esquerda pressionada");
else if (key==Event.RIGHT)
setLabel("Seta direita pressionada");
return(true);
}
}// botao

Eventos de ação
Quando ocorre um evento de ação
(Event.ACTION_EVENT), o tratamento pode ser
colocado dentro do método:
public boolean action(Event evt, Object arg)
arg - depende do componente onde ocorreu a ação

Argumento do evento de ação
Componente arg
Button Rótulo do botão
Checkbox Estado do checkbox
Choice Opção escolhida
List Opção escolhida
com duplo clique
TextField Conteúdo após
return pressionado

Exemplo
public boolean action(Event evt,Object arg){
// Verifica se foi ação no botão
if (evt.target instanceof Button)
// Mostra rótulo do botão em maiúsculas
System.out.println(((String) arg).toUpperCase());
return(true);
}

Evento de ganho de foco
Quando ocorre um evento de ganho de foco
(Event.GOT_FOCUS), o tratamento pode ser
public boolean gotFocus(Event evt, Object arg)

Evento de perda de foco
Quando ocorre um evento de perda de foco
(Event.LOST_FOCUS), o tratamento pode ser
public boolean lostFocus(Event evt, Object arg)

Outros Eventos
Alguns eventos, porém, não possuem uma rota
de tratamento bem definida como nos eventos
anteriores.
Neste caso, uma solução bem simples é alterar a
implementação do método handleEvent para
direcionar o tratamento de tais eventos.

Exemplo 1
Tratamento de barras de rolagem
import java.awt.*;
class exemplo
extends Frame{
Scrollbar barra=new Scrollbar();
...
public boolean handleEvent(Event evt){
if (evt.target==barra)
barra.setValue(((Integer) evt.arg).intValue());
return(true);
}
}

Exemplo 2
Tratamento de fechamento da janela principal
import java.awt.*;
class exemplo
extends Frame{
Scrollbar barra=new Scrollbar();
...
public boolean handleEvent(Event evt){
if (evt.id==Event.WINDOW_DESTROY)
System.exit(0);
return(true);
}
}

Tratamento mais complexo de eventos
Para um tratamento mais complexo de eventos podem ser
implementados métodos de várias interfaces de eventos
do pacote java.awt.Event. Por exemplo:
• MouseListener
• ActionListener
• WindowListener

Imagens
• http://www.goldb.org/goldblog/cmg_images/
real_programmers_binary.jpg
• http://sandersconsulting.com/Portals/58319/i
mages/checklist.jpg

Obrigado
Daniel Arndt Alves
http://www.progdan.pro.br/
daniel.alves@mackenzie.br
progdan@progdan.pro.br

Gerenciadores de Layout

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Gerenciadores de Layout

Mais de Daniel Arndt Alves

Último

Gerenciadores de Layout