2. Manipulação de Eventos
• A monitoração do que está ocorrendo em uma
interface gráfica é feita através de eventos;
• Na manipulação de eventos, temos dois
extremos:
– o originador (interface gráfica) e;
– o ouvinte (quem trata) dos eventos;
• Para uma classe ser ouvinte é preciso que a
mesma implemente uma interface Listener
(Ouvinte) e depois que seja registrada por uma
classe originadora.
3. Manipulação de Eventos
• Em Java um evento é um objeto do tipo
– java.util.EventObject ou um subtipo
como
– ActionEvent ou
– WindowEvent;
• Origens diferentes de eventos podem
produzir eventos diferentes.
4. Manipulação de Eventos
Visão geral da manipulação de eventos:
1. Ouvinte implementa uma interface ouvinte;
2. Origem de evento registra objetos ouvintes;
3. Origem de evento envia objetos eventos
para todos os ouvintes registrados;
4. Os objetos ouvintes utilizam a informação
do objeto evento para determinar sua
reação.
5. Manipulação de Eventos
Interface Ouvinte
R i ta
es
g r
O i ts
un
v e
Eet b c
vn j t
Oe
Og ao
r i dr
i n Oit
un
v e
Um objeto Evento
R ga
e eo
a
Um componente, Eet
vn o
um botão por ex.
Um objeto ouvinte, um
ActionListener, por ex.
7. Manipulação de Eventos
• O objeto ouvinte é registrado no objeto origem com
o seguinte código :
objetoEventoOrigem.addEventListener(objetoOuvinte)
• Por exemplo:
public class Ouvinte implements ActionListener{
public void actionPerformed(ActionEvent evt){
//ação
}
}
Ouvinte acao = new Ouvinte();
JButton botao = new JButton(“Limpar”);
botao.addActionListener(acao);
8. Manipulação de Eventos
• A classe do objeto ouvinte deve implementar a
interface ouvinte apropriada (ex.:
ActionListener);
• Para implementar (CONTRATO) a interface
ActionListener, a classe ouvinte precisa ter
um método (actionPerformed) que recebe o
evento ActionEvent.
9. Manipulação de Eventos
class Ouvinte implements ActionListener {
public void actionPerformed(ActionEvent evt){
//a reação ao clique do botão
}
}
10. Criando Botões
• Um botão é um objeto do tipo JButton;
JButton yellowButton = new JButton(“Yellow”);
• Para se adicionar um botão a um painel,
usamos o método add() do painel;
11. Criando e adicionando botões
//Painel que possui botões e é ouvinte de ação
public class MyPanel extends JPanel
implements ActionListener {
private JButton yellowBtn = new
JButton("Yellow");
private JButton blueBtn = new JButton("Blue");
private JButton redBtn = new JButton("Red");
public MyPanel() {
this.add(yellowBtn);
this.add(blueBtn);
this.add(redBtn);
}
}
12. Criando e adicionando botões
//Janela que possui o painel criado anteriomente
public class FirstFrame extends JFrame {
public FirstFrame() {
setTitle("FirstFrame");
setSize(300, 200);
setDefaultCloseOperation(
EXIT_ON_CLOSE);
add(new MyPanel());
}
public static void main(String[] args) {
JFrame frame = new FirstFrame();
frame.setVisible(true);
}
}
14. Tratando os eventos
• Após adicionar os botões é necessário tratar
os eventos dos mesmos;
• Isto requer a implementação da interface
ActionListener
– implementação do método
actionPerformed;
• Para verificar em qual origem o evento
ocorreu, podemos usar o método
getSource;
17. Registrando os Ouvintes
public class MyPanel extends JPanel implements
ActionListener {
private JButton yellowButton = new JButton("Yellow");
private JButton blueButton = new JButton("Blue");
private JButton redButton = new JButton("Red");
public MyPanel() {
this.add(yellowButton);
this.add(blueButton);
this.add(redButton);
yellowButton.addActionListener(this);
blueButton.addActionListener(this);
redButton.addActionListener(this);
}
}
18. Captura de Eventos de Janelas
• Quando um usuário tenta fechar uma
janela, um evento WindowEvent é
gerado pela classe Jframe;
• Assim, é possível se construir um ouvinte
de janela (WindowListener) para se
determinar o que fazer quando uma janela
é fechada.
19. Captura de Eventos de Janelas
public class AcaoFechar implements WindowListener{
....
}
public class FirstFrame extends JFrame {
public FirstFrame() {
this.addWindowListener(new AcaoFechar());
}
...
}
20. Captura de Eventos de Janelas
• A classe ouvinte AcaoFechar precisa
implementar a interface WindowListener;
• A interface WindowListener define os
seguintes métodos:
– public void windowActivated(WindowEvent e)
– public void windowClosed(WindowEvent e)
– public void windowClosing(WindowEvent e)
– public void windowOpened(WindowEvent e)
– ...
21. Captura de Eventos de Janelas
• Assim, como WindowListerner é uma
interface, todos os métodos devem ser
implementados;
• Se estivermos interessados em somente
um método (p.ex. windowClosing()),
todos os outros devem ser
implementados com corpo vazio.
22. Captura de Eventos de Janelas
class AcaoFechar implements WindowListener {
public void windowActivated(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
public void windowOpened(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
....
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
23. Classes Adaptadoras
• Para se evitar isso, Java oferece as classes
adaptadoras, que já implementam tais
métodos com corpo vazio;
• Dessa forma, ao invés de se implementar
uma interface ouvinte pode-se estender
uma classe adaptadora;
• Para o controle de Janela, a classe
adaptadora é chamada WindowAdapter.
27. A Hierarquia de Eventos AWT
• Dessas interfaces (especificamente aquelas que
têm mais de um método), sete vêem junto com
classes adaptadoras:
– ComponentListener -> ComponentAdapter
– ContainerListener -> ContainerAdapter
– FocusListener -> FocusAdapter
– KeyListener -> KeyAdapter
– MouseListener -> MouseAdapter
– MouseMotionListener -> MouseMotionAdapter
– WindowListener -> WindowAdapter
28. Eventos de Foco
• Na linguagem Java, um componente tem
o foco se puder receber pressionamentos
de teclas;
• Somente um componente pode ter o foco
de cada vez;
• Um componente pode ganhar o foco se o
usuário clicar o mouse dentro dele, ou
quando o usuário usa a tecla <TAB> para
trocar de componente;
• A priori, os componentes são percorridos
da esquerda para a direita e de cima para
baixo quando o <TAB> é pressionado.
29. Eventos de Foco
• Por fim, pode-se usar o método
requestFocus() para mover o foco até
qualquer componente visível em tempo de
execução;
• Um ouvinte de foco precisa implementar dois
métodos: focusGained() e focusLost().
Esses métodos são acionados quando a
origem do evento ganhar ou perder o foco.
30. Eventos de Foco
public class MyPanel extends JPanel {
private JButton yellowButton = new JButton("Yellow");
private JButton blueButton = new JButton("Blue");
private JButton redButton = new JButton("Red");
public MyPanel() {
this.add(yellowButton);
this.add(blueButton);
this.add(redButton);
yellowButton.addFocusListener(new OuvinteBotao());
blueButton.addFocusListener(new OuvinteBotao());
redButton.addFocusListener(new OuvinteBotao());
}
}
31. Eventos de Foco
public class MyPanel extends JPanel {
//Classe interna ouvinte de foco
class OuvinteBotao extends FocusAdapter {
public void focusGained(FocusEvent e) {
Object source = evt.getSource();
if(source == yellowButton) {
setBackground(Color.YELLOW);
} else if(source == blueButton) {
setBackground(Color.BLUE);
} else if(source == redButton) {
setBackground(Color.RED);
}
}
}
}
32. Eventos de Foco
public class FirstFrame extends JFrame {
public FirstFrame() {
setTitle("FirstFrame");
setSize(300, 200);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.getContentPane().add(new MyPanel());
}
public static void main(String[] args) {
JFrame frame = new FirstFrame();
frame.setVisible(true);
}
}
33. Eventos de Janela
• Como já foi visto, é possível ser notificado
sempre que uma janela:
– Foi aberta;
– Foi fechada;
– Tornou-se ativa;
– Tornou-se inativa;
– Foi minimizada;
– Foi restaurada, voltando ao tamanho original;
– Está tentando ser fechada pelo usuário.
34. Eventos de Teclado
• Quando uma tecla é pressionada um
evento KeyEvent.KEY_PRESSED é
gerado;
• Quando a mesma é solta, um evento
KeyEvent.KEY_RELEASE é gerado;
• Esses eventos são capturados pelos
métodos keyPressed() e
KeyReleased() de qualquer classe que
implemente a interface KeyListener.
35. Eventos de Teclado
• Usando a classe adaptadora KeyAdapter não
é necessário implementar todos os métodos de
tratamento de teclado;
• Para se trabalhar com esses métodos, primeiro
deve-se verificar o código da tecla com o
método getKeyCode();
• Para identificar teclas, Java usa a seguinte
nomenclatura:
– VK_A ... VK_Z;
– VK_0 ... VK_9;
– VK_COMMA, VK_ENTER...;
– Etc;
36. Eventos de Teclado - Código
public class MyPanel extends JPanel {
....
class OuvinteTeclado extends KeyAdapter{
public void keyPressed(KeyEvent evt){
if(evt.getKeyCode() == KeyEvent.VK_ENTER){
...
}
}
}
}
37. Eventos de Teclado
• Para saber se as teclas shift, alt,
ctrl ou meta (Alt ou Win) estão
pressionadas, é possível empregar os
seguintes métodos:
– isShiftDown();
– isAltDown();
– isCrtlDown();
– isMetaDown();
38. Eventos de Mouse
• Não é necessário processar
explicitamente os eventos do mouse caso
só seja necessário verificar se um usuário
clicou em um botão;
• Essas operações são processadas
internamente e convertidas em eventos
semânticos apropriados;
• Por exemplo, pode-se reagir a esses
eventos com um método
actionPerformed().
39. Eventos de Mouse
• Contudo é possível capturar os eventos de
movimentação de um mouse;
• Quando um cliente clica em um botão de
um mouse três métodos ouvintes são
chamados: mousePressed(),
mouseReleased() e mouseClicked();
• A seção Eventos de Mouse do livro Core
Java 2 Volume I (pág. 305-313) apresenta
mais detalhes sobre os eventos de mouse.
40. Multidifusão (Multicast)
• Até agora implementamos várias origens
de eventos informando um único ouvinte
de eventos;
• É possível fazer o oposto: um evento
único pode ser enviado para mais de um
objeto ouvinte. Isto é chamado de
multidifusão;
• A multidifusão é útil quando um evento
desperta o interesse potencial de muitas
partes;
• Para isso basta adicionar vários ouvintes a
uma única origem de eventos.
42. Multidifusão (Multicast)
public class SimpleFrame extends JFrame
implements ActionListener {
public void actionPerformed(ActionEvent e) {
dispose();
}
}
43. Multidifusão (Multicast)
public class MulticastPanel extends JPanel
implements ActionListener {
private JButton closeAllButton= new JButton("Close all");
private JButton newButton= new JButton("New");
public MulticastPanel() {
this.add(newButton);
this.add(closeAllButton);
newButton.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
SimpleFrame f = new SimpleFrame();
f.setTitle(“Multicast Window ");
f.setSize(200, 150);
f.setVisible(true);
closeAllButton.addActionListener(f);
}
}
44. Multidifusão (Multicast)
public class MulticastFrame extends JFrame {
public MulticastFrame() {
setTitle("MulticastTest");
setSize(300,200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
add(new MulticastPanel());
}
}
45. Multidifusão (Multicast)
public class Programa {
public static void main(String[] args) {
MulticastFrame frame =
new MulticastFrame();
frame.setVisible(true);
}
}
46. Alterando o Estilo Visual
• Existem três possíveis estilos visuais de
apresentação em Java:
– Motif: com.sun.java.swing.plaf.motif.MotifLookAndFeel
– Windows: com.sun.java.swing.plaf.windows.WindowsLookAndFeel
– Metal: javax.swing.plaf.metal.MetalLookAndFeel
• O estilo windows só esta presente para o
sistema operacional Microsoft Windows, e
por padrão o estilo usado é o metal.
47. Alterando o Estilo Visual
public class FirstFrame extends JFrame {
public FirstFrame() {
setTitle("FirstFrame");
setSize(300, 200);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.getContentPane().add(new MyPanel());
try {
UIManager.setLookAndFeel(
"com.sun.java.swing.plaf. motif.MotifLookAndFeel"
);
SwingUtilities.updateComponentTreeUI(
this.getContentPane() );
} catch(Exception e) { }
}
}
48. Atividades
• Altere o último exemplo (multicast) para o seguinte:
– Conter um combobox com 3 opções de formas
geométricas
– Ao criar um novo frame que este desenhe a forma
escolhida no combo
– Alterar o look and feel para Windows (ou Motif para
Linux)
