tratamento eventos
TRANSCRIPT
Prof. Ms. André Marcelo Farina
Manipulação
de Eventos
01-Abr-2013
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.
• 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.
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.
Manipulação de Eventos
Manipulação de Eventos
OuvinteOriginador
Registra
Ouvintes
EventObject
Reage ao
Evento
Interface Ouvinte
Um componente,
um botão por ex.
Um objeto ouvinte, um
ActionListener, por ex.
Um objeto Evento
Manipulação de Eventos
Diagrama esquemático
• 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);
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.
Manipulação de Eventos
class Ouvinte implements ActionListener {
public void actionPerformed(ActionEvent evt){
//a reação ao clique do botão
}
}
Manipulação de Eventos
• 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;
Criando 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);
}
}
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);
}
}
Criando e adicionando botões
Resultado
Resultado da janela (JFrame) com o painel (JPanel) que
contém botões e é ouvinte de ação
• 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;
Tratando os eventos
public void actionPerformed(ActionEvent evt) {
Object source = evt.getSource();
if(source == yellowBtn) {
//trata evento
} else if(source == blueBtn) {
//trata evento
} else if(source == redBtn) {
//trata evento
}
}
Tratando os eventos
class MyPanel extends JPanel implements ActionListener {
public void actionPerformed(ActionEvent evt) {
Object source = evt.getSource();
if(source == yellowBtn) {
setBackground(Color.YELLOW);
} else if(source == blueBtn) {
setBackground(Color.BLUE);
} else if(source == redBtn) {
setBackground(Color.RED);
}
}
...
}
Tratando os eventos
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); } }
Registrando os Ouvintes
• 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.
Captura de Eventos de Janelas
public class AcaoFechar implements WindowListener{
....
}
public class FirstFrame extends JFrame {
public FirstFrame() {
this.addWindowListener(new AcaoFechar());
}
...
}
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)
– ...
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.
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);
}
}
Captura de Eventos de Janelas
• 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.
Classes Adaptadoras
class AcaoFechar extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
Classes Adaptadoras
• Uma lista de tipos de eventos AWT destinados a ouvintes: –ActionEvent; –AdjustmentEvent; –ComponentEvent; –ContainerEvent; –FocusEvent; – ItemEvent; –KeyEvent; –MouseEvent; –TextEvent; –WindowEvent.
A Hierarquia de Eventos AWT
• Existem onze interfaces ouvintes para esses eventos:
– ActionEvent -> ActionListener;
– AdjustmentEvent -> AdjustmentListener
– ComponentEvent -> ComponentListener
– ContainerEvent -> ContainerListener
– FocusEvent -> FocusListener
– ItemEvent ->ItemListener
– KeyEvent -> KeyListener
– MouseEvent -> MouseListener e
MouseMotionListener;
– TextEvent -> TextListener
– WindowEvent -> WindowListener
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
A Hierarquia de Eventos AWT
• 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.
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.
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());
}
}
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);
}
}
}
}
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);
}
}
Eventos de Foco
• 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.
Eventos de Janela
• 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.
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;
Eventos de Teclado
public class MyPanel extends JPanel {
....
class OuvinteTeclado extends KeyAdapter{
public void keyPressed(KeyEvent evt){
if(evt.getKeyCode() == KeyEvent.VK_ENTER){
...
}
}
}
}
Eventos de Teclado - Código
• 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();
Eventos de Teclado
• 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().
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.
Eventos de Mouse
• 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.
Multidifusão (Multicast)
Multidifusão (Multicast)
public class SimpleFrame extends JFrame
implements ActionListener {
public void actionPerformed(ActionEvent e) {
dispose();
}
}
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);
}
}
Multidifusão (Multicast)
public class MulticastFrame extends JFrame {
public MulticastFrame() {
setTitle("MulticastTest");
setSize(300,200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
add(new MulticastPanel());
}
}
Multidifusão (Multicast)
public class Programa {
public static void main(String[] args) {
MulticastFrame frame =
new MulticastFrame();
frame.setVisible(true);
}
}
Multidifusão (Multicast)
• 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.
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) { }
}
}
Alterando o Estilo Visual
• 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)
Atividades