tratamento eventos

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