COMPONENTES GUI (capítulo 11 Deitel)

1

COMPONENTES GUICOMPONENTES GUI(capítulo 11 Deitel)(capítulo 11 Deitel)

Roberto WillrichRoberto WillrichINE-CTC-UFSCINE-CTC-UFSC

Carla Merkle WestphallCarla Merkle WestphallINE-CTC-UFSCINE-CTC-UFSC

E-Mail: [email protected]: [email protected]: http://moodle.inf.ufsc.brURL: http://moodle.inf.ufsc.br

INE5605-Turma 0238AINE5605-Turma 0238A

2

2005 Pearson Education, Inc. All rights reserved.

2

Objetivos

Neste capítulo aprenderemos: Construir interfaces gráficas e tratar

eventos gerados pelas interações do usuário.

Entender os pacotes contendo componentes GUI, classes de tratamento de eventos e interfaces.

Criar e manipular botões, labels, listas, campos de texto e painéis.

Tratar eventos de manipulação do mouse e de teclado.

Usar o layout managers para organizar os componentes GUI

3


3

Introdução

• Interfaces gráficas (GUI)– Oferecem um mecanismo amigável de interação com

as aplicações

– Normalmente contém barra de título, barra de menu contendo menus, botões e campos de texto

– Construídos a partir de componentes GUI

4


4

Internet Explorer com componentes GUI.

Botão Menus Barra de título Barra de menus Campo de texto

Barras de rolagem

5


5

Entrada/Saída Simples Baseada em GUI comJOptionPane

• Caixas de diálogo– Usada pelas aplicações para interagir com o usuário

– Oferecida pela classe Java JOptionPane• Contém diálogos de entrada e de mensagem

6


6

Resumo

Adicao.java

(1 de 2)

1 // Arquivo: Adicao.java

2 // Programa Adicao que usa JOptionPane para entrada e saída.

3 import javax.swing.JOptionPane; // programa usa JOptionPane

4

5 public class Adicao

6 {

7 public static void main( String args[] )

8 {

9 // Obtém entradas do usuário a partir do diálogos de entrada JOptionPane

10 String primeiroNumero =

11 JOptionPane.showInputDialog( "Digite primeiro numero" );

12 String segundoNumero =

13 JOptionPane.showInputDialog( "Digite segundo numero" );

14

15 // converte entrada em String para um valor int para usar no cálculo

16 int numero1 = Integer.parseInt( primeiroNumero );

17 int numero2 = Integer.parseInt( segundoNumero );

18

19 int soma = numero1 + numero2; // adiciona os números

20

21 // Apresenta o resultado em uma janela de diálogo JOptionPane x

22 JOptionPane.showMessageDialog( null, "A soma é " + soma,

23 "Soma de dois inteiros", JOptionPane.PLAIN_MESSAGE );

24 } // fim do método main

25 } // fim da classe Adição

Mostra caixa de entrada para receber o primeiro inteiro

Mostra caixa de entrada para receber o segundo inteiro

Mostra caixa de mensagem para apresentar a soma ao usuário

7


7

Caixa de Dialogo: Caixa de Mensagem

• Classe JOptionPane – Método JOptionPane.showMessageDialog

• Argumentos– Primeiro usado para posicionamento na tela

• Null para colocar a caixa no centro da tela do frame default– Segundo é a String a apresentar– Terceiro é o titulo da janela– Quarto é o tipo de mensagem

// Imprime linhas na caixa de dialogo

import javax.swing.JOptionPane; // importa classe JOptionPane

public class Dialog2 {

public static void main( String args[] ) {

// apresenta um dialogo com a mensagem

JOptionPane.showMessageDialog( null, "Bem vindo\na\nJava" ,

"Titulo", JOptionPane.INFORMATION_MESSAGE);

}

}

8


8

Adicao.java

(2 de 2)

Caixas de diálogos apresentadas pelas linhas 10–11

Caixa de entrada apresentada pelas linhas 12–13

Caixa de mensagem apresentada pelas linhas 22–23

Campo de texto em que o usuário digita um valor

Prompt para o usuário

Quando o usuário clica em OK,

showInputDialog retorna para o programa o 2 digitado pelo usuário

como uma String. O programa deve converter

o String para um int

Barra de titulo

Quando o usuário clica em OK, a caixa de

mensagem desaparece

9


9

Constantes static JOptionPane para caixas de dialogo.

Tipo de mensagens Icone Descrição

ERROR_MESSAGE

Um diálogo que indica um erro ao usuario.

INFORMATION_MESSAGE

Um diálogo com uma mensagem informacional para o usuário.

WARNING_MESSAGE

Um diálogo de advertência indicando um problema potencial.

QUESTION_MESSAGE

Um diálogo que questiona o usuário. Ela normalmente requer uma resposta, tal como clicar um botão Sim ou um Não.

PLAIN_MESSAGE sem icone

Um diálogo que contém uma mensagem, mas sem icone.

10


10

Visão Geral dos Componentes Swing

• Componentes GUI Swing– Declarados no pacote javax.swing

– Muitos deles são componentes Java puros

– Parte das Java Foundation Classes (JFC)• É um framework gráfico para construir interfaces gráficas

(GUIs) portáveis baseadas em Java. JFC consiste do AWT (Abstract Window Toolkit), Swing e Java 2D. Juntos, eles oferecem uma interface gráfica para programas em Java que rodam em plataformas populares como Microsoft Windows, Linux, e Mac OSX.

11


11

Alguns componentes gráficos básicos.

Componente Descrição

JLabel Apresenta ícones e textos não editáveis.

JTextField Permite ao usuário digitar dados a partir do teclado. Ela pode também ser usada para apresentar texto editável ou não editável.

JButton Ativa um evento quando clicado com o mouse.

JCheckBox Componente GUI que pode estar no estado selecionado ou não selecionado.

JComboBox Fornece uma lista escamoteável de itens a partir da qual o usuário pode fazer uma seleção clicando um item ou possivelmente digitando na caixa.

JList Fornece uma lista de itens no qual o usuário pode fazer uma seleção clicando em qualquer item na lista. Vários elementos podem ser selecionados.

JPanel Fonece uma área na qual componentes podem ser colocados e organizados. Podem também ser usados como uma área de desenho para grafismos.

12


12

Swing vs. AWT

• Abstract Window Toolkit (AWT)– Precursor do Swing

– Declarado no pacote java.awt

– Não oferece uma apresentação multi-plataforma consistente

13


13

Tópico de portabilidade

Componentes Swing são implementados em Java, assim elas são mais portáveis e flexíveis que os componentes GUI Java do pacote java.awt, que foram baseadas nos componentes GUI da plataforma de base. Por esta razão, componentes Swing são geralmente preferidos.

14


14

Componentes GUI Leves vs. Pesados

• Componentes leves– Não depende diretamente de componentes GUI suportados

pela plataforma de base

• Componentes pesados– Dependentes diretamente da plataforma local (S.O.)

– Componentes AWT

– Alguns componentes Swing

15


15

Observação

A forma de apresentação da interface definida por componentes GUI pesados a partir do pacote java.awt varia de acordo com a plataforma. Como componentes pesados são ligados a GUI da plataforma local, a forma de apresentação varia de plataforma para plataforma.

16


16

Superclasses dos componentes GUI leves do Swing

• Classe Component (pacote java.awt)– Subclasse de Object– Declara muitos comportamentos e atributos comuns aos componentes

GUI• Classe Container (pacote java.awt)

– Subclasse de Component– Organiza Components

• Classe JComponent (pacote javax.swing)– Subclasse de Container– Superclasse de todos os componentes Swing leves

17


17

Apresentação de Textos e Imagens em uma Janela

• Classe JFrame– Muitas janelas são instancias ou subclasse desta classe

– Oferece uma barra de título

– Oferece botões para minimizar, maximizar ou fechar a aplicação

18


18

Nomeando componentes GUI

• Label– Instruções ou informações textuais indicando o propósito

de cada componentes

– Criado com a classe JLabel

19


19

Especificando o Layout

• Containers de layout (Layout Containers)– Determina onde os componentes são colocados no

container

– Feito em Java com gerenciadores de layout (layout managers)

• Uma destas classes é FlowLayout

– Configurado com o método setLayout da classe JFrame

20


20

Resumo

LabelFrame.java

(1 de 2)

1 // Arquivo: LabelFrame.java

2 // Demonstrando a classe Jlabel.

3 import java.awt.FlowLayout; // especifica como componentes são arranjados

4 import javax.swing.JFrame; // prove as caracteristicas basicas da janela

5 import javax.swing.JLabel; // apresenta textos e imagens

6 import javax.swing.SwingConstants; // Constantes comuns usadas com Swing

7 import javax.swing.Icon; // interface usada para processar imagens

8 import javax.swing.ImageIcon; // carrega imagens

9

10 public class LabelFrame extends JFrame

11 {

12 private JLabel label1; // JLabel com apenas um texto

13 private JLabel label2; // JLabel construido com texto e icone

14 private JLabel label3; // JLabel com texto adicionado com icone

15

16 // construtor LabelFrame adiciona JLabels a JFrame

17 public LabelFrame()

18 {

19 super( "Testando JLabel" ); // construtor de JFrame passando o título

20 setLayout( new FlowLayout() ); // define o frame layout

21

22 // construtor JLabel com um argumento string

23 label1 = new JLabel( "Label com texto" );

24 label1.setToolTipText( "Este é o label1" );

25 add( label1 ); // adiciona label1 ao JFrame

26

21


21

Resumo

LabelFrame.java

(2 de 2)

27 // construtor JLabel com argumentos string, Icon e alinhamento

28 Icon bug = new ImageIcon( getClass().getResource( "bug1.gif" ) );

29 label2 = new JLabel( "Label com texto e icone", bug,

30 SwingConstants.LEFT );

31 label2.setToolTipText( "Este é label2" );


33

34 label3 = new JLabel(); // construtor JLabel sem argumentos

35 label3.setText( "Label com icone e texto no botão " );

36 label3.setIcon( bug ); // adiciona icone ao JLabel

37 label3.setHorizontalTextPosition( SwingConstants.CENTER );

38 label3.setVerticalTextPosition( SwingConstants.BOTTOM );

39 label3.setToolTipText( "Este é label3" );


41 } // fim do construtor LabelFrame

42 } // fim da classe LabelFrame

22


22

Resumo

TesteLabel.java

1 // Arquivo: TesteLabel.java

2 // Testando LabelFrame.

3 import javax.swing.JFrame;

4

5 public class TesteLabel

6 {


8 {

9 LabelFrame labelFrame = new LabelFrame(); // cria LabelFrame

10 labelFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 labelFrame.setSize( 275, 180 ); // define tamanho do frame

12 labelFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe TesteLabel

23


23

Criando e anexando label1

• Construtor tendo como argumento o texto

• Método setToolTipText da classe JComponent

– Especifica o texto de ajuda (tool tip)

• Método add da classe Container– Adiciona um componente em um container

label1 = new JLabel( "Label com texto" );

label1.setToolTipText( "Este é o label1" );

add( label1 ); // adiciona label1 ao JFrame

24


24

Observação

Use tool tips para adicionar um texto descritivo nos seus componentes gráficos. Este texto ajuda o usuário na determinação dos objetivos dos componentes da interface.

25


25

Erro comum de programação

Se você esquece de adicionar um componente no container, este componente não será apresentado quando o container aparecer na tela.

26


26

Criando e Anexando label2

• Texto, ícone e posicionamento são passados no construtor de JLabel

– Interface Icon:• Pequena imagem de tamanho fixo• IconImage é uma implementação da interface Icon que

apresenta ícones a partir de Images– Images são criadas a partir de URL, nome do arquivo

ou array de bytes pré-carregados com MediaTracker– No exemplo é passado o URL (getClass().getRessource())

Icon bug = new ImageIcon( getClass().getResource( "bug1.gif" ) );

label2 = new JLabel( "Label com texto e icone", bug,

SwingConstants.LEFT );

label2.setToolTipText( "Este é label2" );


27


27


• Construtor default e uso de métodos JLabel– getText e setText

• Para definir e recuperar o texto de um label

– getIcon e setIcon• Para definir e recuperar o ícone apresentado no label

– getHorizontalTextPosition e setHorizontalTextPosition

• Para definir e recuperar a posição horizontal do texto apresentado no label

label3 = new JLabel(); // construtor JLabel sem argumentos

label3.setText( "Label com icone e texto no botão " );

label3.setIcon( bug ); // adiciona icone ao JLabel

label3.setHorizontalTextPosition( SwingConstants.CENTER );

label3.setVerticalTextPosition( SwingConstants.BOTTOM );

label3.setToolTipText( "Este é label3" );


28


28


• Interface SwingConstants– Declara um conjunto de constantes inteiras comuns tal

como aquela usada para definir o alinhamento dos componentes

– Pode ser usada com métodos setHorizontalAlignment e setVerticalAlignment

29


29

Alguns componentes GUI básicos

Constante

Descrição

Constantes de posicionamento horizontal

SwingConstants.LEFT Coloca texto na esquerda. SwingConstants.CENTER Coloca texto no centro. SwingConstants.RIGHT Coloca texto na direita.

Constantes de posicionamento vertical

SwingConstants.TOP Coloca texto no topo. SwingConstants.CENTER Coloca texto no centro. SwingConstants.BOTTOM Coloca texto em baixo.

30


30

Criando e Apresentando a janela LabelFrame

• Outros métodos JFrame– setDefaultCloseOperation

• Indica como a aplicação reage quando o usuário clica no botão fechar

– setSize• Especifica a altura e largura da janela

– setVisible• Determina se a janela é apresentada (true) ou não (false)

public static void main( String args[] )

{

LabelFrame labelFrame = new LabelFrame(); // cria LabelFrame

labelFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

labelFrame.setSize( 275, 180 ); // define tamanho do frame

labelFrame.setVisible( true ); // apresenta frame

} // fim do main

31


31 Campos de texto e uma introdução a tratamento de eventos com classes aninhadas

• GUIs são orientadas a eventos– Uma interação do usuário cria um evento

• Eventos comuns são clicar um botão, digitar em um campo de texto, selecionar um item em um menu, fechar uma janela, mover o mouse, etc.

– O evento causa uma chamada a um método chamado de tratador de eventos (event handler)

32


32

Campos de texto e uma introdução a tratamento de eventos com classes aninhadas

• Classe JTextComponent– Superclasse de JTextField

• Superclasse de JPasswordField

– Adiciona o caractere echo para esconder a entrada de texto no componente

33


33

Resumo

FrameCampoDeTexto.java

(1 de 3)

1 // Arquivo: FrameCampoDeTexto.java

2 // Demonstrando a classe JTextField.

3 import java.awt.FlowLayout;

4 import java.awt.event.ActionListener;

5 import java.awt.event.ActionEvent;


7 import javax.swing.JTextField;

8 import javax.swing.JPasswordField;

9 import javax.swing.JOptionPane;

10

11 public class FrameCampoDeTexto extends JFrame

12 {

13 private JTextField campoDeTexto1; // campo de texto com tamanho definido

14 private JTextField campoDeTexto2; // campo de texto construido com texto

15 private JTextField campoDeTexto3; // campo de texto com texto e tamanho

16 private JPasswordField campoPassword; // campo password com texto

17

18 // Construtor FrameCampoDeTexto adiciona JTextFields a JFrame

19 public FrameCampoDeTexto ()

20 {

21 super( "Testando JTextField e JPasswordField" ); // título do JFrame

22 setLayout( new FlowLayout() ); // atribui frame layout

23

24 // Constroi textfield com 10 colunas

25 campoDeTexto1 = new JTextField( 10 );

26 add( campoDeTexto1 ); // adiciona campoDeTexto1 ao JFrame

27

Cria um novo JTextField

34


34

Resumo


(2 de 3)

28 // Constroi campo de texto com texto default

29 campoDeTexto2 = new JTextField( "Digite um texto aqui " );

30 add( campoDeTexto2 ); // adiciona campoDeTexto2 ao JFrame

31

32 // constroi campo de texto com texto default e 21 colunas

33 campoDeTexto3 = new JTextField( "Texto de campo não editavel", 21 );

34 campoDeTexto3.setEditable( false ); // desabilita edição

35 add( campoDeTexto3 ); // adiciona campoDeTexto ao JFrame

36

37 // constroi campoPassword com texto default

38 campoPassword = new JPasswordField( "Texto Escondido" );

39 add( campoPassword ); // adiciona campoPassword ao JFrame

40

41 // registra tratador de evento

42 TratadorCampoDeTexto tratador = new TratadorCampoDeTexto();

43 campoDeTexto1.addActionListener( tratador );



46 campoPassword.addActionListener( tratador );

47 } // fim do construtor FrameCampoDeTexto

48

49 // classe interna privada para tratamento de eventos

50 private class TratadorCampoDeTexto implements ActionListener

51 {

52 // processa eventos no campo de texto

53 public void actionPerformed( ActionEvent event )

54 {

55 String string = ""; // declara string a apresentar

56

Cria um novo JTextField

Cria um novo JTextField não editável

Cria um novo JPasswordField

Criar tratador de evento

Registra tratador de evento

Cria uma classe tratador de evento pela implementação da interface

ActionListener

Declara método actionPerformed

35


35

Outline


(3 de 3)

57 // usuario clicou Enter no JTextField campoDeTexto1

58 if ( event.getSource() == campoDeTexto1 )

59 string = String.format( "campoDeTexto1: %s",

60 event.getActionCommand() );

61


63 else if ( event.getSource() == campoDeTexto2 )

64 string = String.format( " campoDeTexto2: %s",


66


68 else if ( event.getSource() == campoDeTexto3 )

69 string = String.format( " campoDeTexto3: %s",


71

72 // usuario clicou Enter no JTextField campoPassword

73 else if ( event.getSource() == campoPassword )

74 string = String.format( "campoPassword: %s",

75 new String(campoPassword.getPassword() ) );

76

77 // apresenta conteudo do JtextField

78 JOptionPane.showMessageDialog( null, string );

79 } // fim do método actionPerformed

80 } // fim da classe interna privada TratadorCampoDeTexto

81 } // fim da classe FrameCampoDeTexto

Testa se a fonte do evento é o primeiro campo de texto

Obtém texto do campo de texto



Obtém password do campo password

Testa se a fonte do evento é o segundo campo de texto

Testa se a fonte do evento é o terceiro campo de texto

Testa se a fonte do evento é o campo password

36


36

Outline

TesteCampoDeTexto.java

(1 de 2)

1 // Arquivo: TesteCampoDeTexto.java

2 // Testando FrameCampoDeTexto.


4

5 public class TesteCampoDeTexto

6 {


8 {

9 FrameCampoDeTexto frameCampoDeTexto = new FrameCampoDeTexto ();

10 frameCampoDeTexto.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 frameCampoDeTexto.setSize( 325, 120 ); // define tamanho do frame

12 frameCampoDeTexto.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe TesteCampoDeTexto

37


37

Resumo

TesteCampoDeTexto.java

(2 de 2)

38


38

Passos necessários para configurar um tratador de eventos para um componente gráfico

• Vários passos são necessários para uma aplicação responder eventos

– Criar uma classe para um tratador de evento• Implementa uma interface event-listener apropriada

– Registrar o tratador de eventosTratadorCampoDeTexto tratador = new TratadorCampoDeTexto();

campoDeTexto1.addActionListener( tratador );

//...

private class TratadorCampoDeTexto implements ActionListener

{

// processa eventos no campo de texto

public void actionPerformed( ActionEvent event )

{

//...

}

}

39


39

Usando uma classe aninhada para implementar um tratador de eventos

• Classe de alto-nível (classe externa)– Não declarada dentro de outra classe

• Classes aninhada– Declarada dentro de outra classe

– Classes aninhadas não-static são chamadas classes internas

• Com freqüência usadas para tratamento de eventospublic class FrameCampoDeTexto extends JFrame

{

//...


{

//...

}

}

40


40

Observação

Um classe interna pode acessar diretamente os atributos e métodos da classe externa, mesmo se eles são private.

41


41

Usando uma classe aninhada para implementar um tratador de eventos

•JTextFields e JPasswordFields– Digitando “enter” dentro destes campos causa um ActionEvent

• Processado pelos objetos que implementam a interface ActionListener

42


42

Registrando o tratador de eventos para cada campo de texto

• Registrando um tratador de evento– Chamando método addActionListener para registrar

um objeto ActionListener

– ActionListener observa eventos no objeto

TratadorCampoDeTexto tratador = new TratadorCampoDeTexto();

campoDeTexto1.addActionListener( tratador );

43


43


Esquecer de registrar um objeto tratador de evento para tratar um evento particular de componente gráfico faz com que os eventos sejam ignorados.

44


44

Detalhes do método actionPerformed da classe TratadorCampoDeTexto

• Fonte do evento– Componente na qual o evento foi originado

– Pode ser determinada usando o método getSource

– Texto de um JTextField pode ser obtido usando getActionCommand

– Texto de um JPasswordField pode ser obtido usando getPassword (retorna um char[])


{

// processa eventos no campo de texto

public void actionPerformed( ActionEvent event )

{

String string = ""; // declara string a apresentar

// usuario clicou Enter no JTextField campoDeTexto1

if ( event.getSource() == campoDeTexto1 )

string = String.format( "campoDeTexto1: %s",

event.getActionCommand() );

45


45

Tipos de eventos gráficos comuns e interfaces Listener

• Tipos de eventos– Todos são subclasses de AWTEvent

– Alguns declarados no pacote java.awt.event

– Aqueles específicos dos componentes Swing são declarados em javax.swing.event

• Modelo de evento de delegação:

– A origem do evento é o componente com o qual o usuário interage.

– O objeto do evento é criado e contém as informações sobre o evento que aconteceu.

– O ouvinte de evento é notificado quando um evento acontece.

46


46

Algumas classes de evento do pacote java.awt.event.

47


47

Algumas interfaces comuns do pacote java.awt.event.

48


48

Invocação do tratamento de evento

• Eventos são notificados para apenas um tratador de evento que casa com o tipo de evento

– Eventos tem um único event ID especificando o tipo de evento

•ActionEvents são manipulados pelos ActionListeners

•MouseEvents são manipulados pelos MouseListeners e MouseMotionsListeners

•KeyEvents são manipulados por KeyListeners

49


Tratamento de evento

• Perguntas remanescentes:

– Como o handler de evento ficou registrado?

– Como o componente GUI sabe chamar actionPerformed em vez de algum outro método de tratamento de evento?

• Cada JComponent tem uma variável de instância listenerList:

– Objeto do tipo EventListenerList.

– Mantém referências a todos os seus ouvintes registrados.

50


Registro de evento para JTextField textField1

51


51

JButton

• Botão– Componente que o usuário clica para lançar uma ação

específica

– Pode ser botões de comando, caixas de marcação (check box), botões de alternância e botões de opção

– Tipos de botões são subclasses de AbstractButton

52


52

Hierarquia do Botão Swing.

53


53

JButton

• Botões de comando– Criado com a classe JButton

– Texto na face do botão é chamado de rótulo (label) do botão

– Gera um ActionEvent quando ele é clicado

54


54

Resumo

FrameBotao.java

(1 de 2)

1 // Arquivo: FrameBotao.java

2 // Cria JButtons.





7 import javax.swing.JButton;

8 import javax.swing.Icon;

9 import javax.swing.ImageIcon;


11

12 public class FrameBotao extends JFrame

13 {

14 private JButton plainJButton; // botão com um texto

15 private JButton fancyJButton; // botão com icones

16

17 // FrameBotao adiciona JButtons ao JFrame

18 public FrameBotao()

19 {

20 super( "Testando botões " );

21 setLayout( new FlowLayout() ); // define frame layout

22

23 plainJButton = new JButton( "Plain Button" ); // botão com texto

24 add( plainJButton ); // adiciona plainJButton ao JFrame

25

26 Icon bug1 = new ImageIcon( getClass().getResource( "bug1.gif" ) );

27 Icon bug2 = new ImageIcon( getClass().getResource( "bug2.gif" ) );

28 fancyJButton = new JButton( "Fancy Button", bug1 ); // set image

29 fancyJButton.setRolloverIcon( bug2 ); // set rollover image

30 add( fancyJButton ); // adiciona fancyJButton ao JFrame

Declara dois atributos JButton

Cria novo JButton

Cria dois ImageIcons

Cria novo JButton

Define rollover icon para JButton

55


55

Resumo

FrameBotao.java(2 de 2)

31

32 // cria novo ButtonHandler para tratar eventos do botão

33 TratadorBotao tratador = new TratadorBotao();

34 fancyJButton.addActionListener(tratador);

35 plainJButton.addActionListener(tratador);

36 } // fim do construtor FrameBotao

37

38 // classe interna para tratar eventos do botão

39 private class TratadorBotao implements ActionListener

40 {

41 // trata eventos do botão


43 {

44 JOptionPane.showMessageDialog( FrameBotao.this, String.format(

45 "Você clicou: %s", event.getActionCommand() ) );


47 } // fim da classe interna TratadorBotao

48 } // fim da classe FrameBotao

Cria tratador para botões

Registra tratador de eventos

Classe interna implementa ActionListener

Acesso a atributo da classe externa usando a referência this

Obtém texto do JButton clicado

56


56

Resumo

TesteBotao.java

(1 de 1)

1 // Arquivo: TesteBotao.java

2 // Testando FrameBotao.


4

5 public class TesteBotao

6 {


8 {

9 FrameBotao frameBotao = new FrameBotao (); // cria FrameBotao

10 frameBotao.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 frameBotao.setSize( 275, 110 ); // define o tamanho do frame

12 frameBotao.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe TesteBotao

57


57

JButton•JButtons pode ter um ícone de alternância

(rollover icon)– Aparece quando o mouse é posicionado sobre o botão– Adicionado ao JButton com o método setRolloverIcon

Icon bug1 = new ImageIcon( getClass().getResource( "bug1.gif" ) );

Icon bug2 = new ImageIcon( getClass().getResource( "bug2.gif" ) );

fancyJButton = new JButton( "Fancy Button", bug1 ); // set image

fancyJButton.setRolloverIcon( bug2 ); // set rollover image

add( fancyJButton ); // adiciona fancyJButton ao JFrame

58


58

Observação

Quando usado na classe interna, a palavra-chave this referencia o objeto da classe interna atualmente sendo manipulado. Um método da classe interna pode acessar o objeto da classe externa precedendo o this do nome da classe externa e um ponto, como em FrameBotao.this.

59


59

Botões que mantém um estado

• Botões com estado– Swing contém três tipos de botões com estado

– JToggleButton, JCheckBox and JRadioButton

– JCheckBox e JRadioButton são subclasses de JToggleButton

60


60

JCheckBox

•JCheckBox– Contém um rótulo que aparece na direita do check box por

default

– Gera um ItemEvent quando este é clicado• ItemEvents são tratados por ItemListener• Passado para o método itemStateChanged

– Método isSelected retorna se o check box é selecionado (true) ou não (false)

61


61

Outline

CheckBoxFrame.java

(1 de 3)

1 // Arquivo: CheckBoxFrame.java

2 // Criando botões JCheckBox.


4 import java.awt.Font;

5 import java.awt.event.ItemListener;

6 import java.awt.event.ItemEvent;



9 import javax.swing.JCheckBox;

10

11 public class CheckBoxFrame extends JFrame

12 {

13 private JTextField campoDeTexto; // apresenta texto com fonte definida

14 private JCheckBox boldJCheckBox; // para selecionar/não selecionar negrito

15 private JCheckBox italicJCheckBox; // para selecionar/não selecionar italic

16

17 // Construtor CheckBoxFrame adiciona JCheckBoxes ao JFrame

18 public CheckBoxFrame()

19 {

20 super( "Teste de JCheckBox" ); // define titulo


22

23 // Configura JTextField e define sua fonte

24 campoDeTexto = new JTextField( "Observe a troca do estilo da fonte", 20 );

25 campoDeTexto.setFont( new Font( "Serif", Font.PLAIN, 14 ) );

26 add( campoDeTexto ); // adiciona textField ao JFrame

27

Declara dois atributos JCheckBox

Define fonte do campo de texto

62


62

Outline

CheckBoxFrame.java

(2 de 3)

28 boldJCheckBox = new JCheckBox( "Bold" ); // cria bold checkbox

29 italicJCheckBox = new JCheckBox( "Italic" ); // cria italic

30 add( boldJCheckBox ); // adiciona bold checkbox ao JFrame

31 add( italicJCheckBox ); // adiciona italic checkbox ao JFrame

32

33 // registra listeners de JCheckBoxes

34 CheckBoxHandler handler = new CheckBoxHandler();

35 boldJCheckBox.addItemListener( handler );

36 italicJCheckBox.addItemListener( handler );

37 } // fim do construtor CheckBoxFrame

38

39 // classe interna privada implementando ItemListener

40 private class CheckBoxHandler implements ItemListener

41 {

42 private int valBold = Font.PLAIN; // controla fonte bold

43 private int valItalic = Font.PLAIN; // controla fonte italic

44

45 // responde a eventos de checkbox

46 public void itemStateChanged( ItemEvent event )

47 {

48 // processa eventos em bold checkbox

49 if ( event.getSource() == boldJCheckBox )

50 valBold =

51 boldJCheckBox.isSelected() ? Font.BOLD : Font.PLAIN;

52

Cria dois JCheckBoxes

Cria event handler

Registra event handler nos JCheckBoxes

Classe interna implementando ItemListener

Método itemStateChanged é chamado quando um JCheckBox

é clicado

Testa se JCheckBox é selecionado

63


63

Outline

CheckBoxFrame.java

(3 de 3)

53 // processa enventos em italic checkbox

54 if ( event.getSource() == italicJCheckBox )

55 valItalic =

56 italicJCheckBox.isSelected() ? Font.ITALIC : Font.PLAIN;

57

58 // define fonte do campo de texto

59 campoDeTexto.setFont(

60 new Font( "Serif", valBold + valItalic, 14 ) );

61 } // fim do método itemStateChanged

62 } // fim da classe privada interna CheckBoxHandler

63 } // fim da classe CheckBoxFrame

Testa fonte do evento

Método isSelected retorna se JCheckBox está selecionado

64


64

Outline

CheckBoxTest.java

1 // Arquivo: CheckBoxTest.java

2 // Testando CheckBoxFrame.


4

5 public class CheckBoxTest

6 {


8 {

9 CheckBoxFrame checkBoxFrame = new CheckBoxFrame();

10 checkBoxFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 checkBoxFrame.setSize( 275, 100 ); // configura tamanho do frame

12 checkBoxFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe CheckBoxTest

65


65

JRadioButton

•JRadioButton– Tem dois estados – selecionado e não-selecionado

– Normalmente aparece no grupo na qual apenas um botão pode ser selecionado por vez

• Grupo mantido por um objeto ButtonGroup

– Declara método add para adicionar um JRadioButton ao grupo

– Usualmente representa opções múltiplas exclusivas

66


66

Erro de programação comum

Adicionar um objeto ButtonGroup (ou um objeto de qualquer classe que não seja derivado de Component) ao container resulta em um erro de compilação.

67


67

Outline

RadioButtonFrame.java

(1 de 3)

1 // Arquivo: RadioButtonFrame.java

2 // Criando botões radio usando ButtonGroup e JRadioButton.







9 import javax.swing.JRadioButton;

10 import javax.swing.ButtonGroup;

11

12 public class RadioButtonFrame extends JFrame

13 {

14 private JTextField textField; // usado para apresentar a troca de fontes

15 private Font plainFont; // fonte para texto plane

16 private Font boldFont; // fonte para texto negrito

17 private Font italicFont; // fonte para texto itálico

18 private Font boldItalicFont; // fonte para texto negrito e itálico

19 private JRadioButton plainJRadioButton; // seleciona texto plano

20 private JRadioButton boldJRadioButton; // seleciona texto negrito

21 private JRadioButton italicJRadioButton; // seleciona texto itálico

22 private JRadioButton boldItalicJRadioButton; // negrito e itálico

23 private ButtonGroup radioGroup; // buttongroup para gerenciar botões

24

25 // Construtor RadioButtonFrame adiciona JRadioButtons ao JFrame

26 public RadioButtonFrame()

27 {

28 super( "Teste de RadioButton" );


30

Declara quatro JRadioButtons e um ButtonGroup para

gerenciar eles

68


68

Outline


(2 de 3)

31 textField = new JTextField( "Observe a mudança do estilo da fonte", 25 );

32 add( textField ); // adiciona textField ao JFrame

33

34 // cria radio buttons

35 plainJRadioButton = new JRadioButton( "Plain", true );

36 boldJRadioButton = new JRadioButton( "Bold", false );

37 italicJRadioButton = new JRadioButton( "Italic", false );

38 boldItalicJRadioButton = new JRadioButton( "Bold/Italic", false );

39 add( plainJRadioButton ); // adiciona plain button ao JFrame

40 add( boldJRadioButton ); // adiciona bold button ao JFrame

41 add( italicJRadioButton ); // adiciona italic button ao JFrame

42 add( boldItalicJRadioButton ); // adiciona bold e italic button

43

44 // cria relacionamento lógico entre JRadioButtons

45 radioGroup = new ButtonGroup(); // cria ButtonGroup

46 radioGroup.add( plainJRadioButton ); // adiciona plain ao grupo

47 radioGroup.add( boldJRadioButton ); // adiciona bold ao grupo

48 radioGroup.add( italicJRadioButton ); // adiciona italic ao grupo

49 radioGroup.add( boldItalicJRadioButton ); // adiciona bold and italic

50

51 // cria objetos font

52 plainFont = new Font( "Serif", Font.PLAIN, 14 );

53 boldFont = new Font( "Serif", Font.BOLD, 14 );

54 italicFont = new Font( "Serif", Font.ITALIC, 14 );

55 boldItalicFont = new Font( "Serif", Font.BOLD + Font.ITALIC, 14 );

56 textField.setFont( plainFont ); // define fonte inicial como plain Font

57

Cria quatro JRadioButtons

Cria o ButtonGroup

Adiciona cada JRadioButton ao ButtonGroup

69


69

Outline


(3 of 3)

58 // Registra observadores de eventos aos JRadioButtons

59 plainJRadioButton.addItemListener(

60 new RadioButtonHandler( plainFont ) );

61 boldJRadioButton.addItemListener(

62 new RadioButtonHandler( boldFont ) );

63 italicJRadioButton.addItemListener(

64 new RadioButtonHandler( italicFont ) );

65 boldItalicJRadioButton.addItemListener(

66 new RadioButtonHandler( boldItalicFont ) );

67 } // fim do construtor RadioButtonFrame

68

69 // classe interna privada que trata os eventos dos radio button

70 private class RadioButtonHandler implements ItemListener

71 {

72 private Font font; // fonte associada com este listener

73

74 public RadioButtonHandler( Font f )

75 {

76 font = f; // define o fonte deste listener

77 } // fim do construtor RadioButtonHandler

78

79 // trata eventos dos radio button


81 {

82 textField.setFont( font ); // define a fonte de textField


84 } // fim da classe interna privada RadioButtonHandler

85 } // fim da classe RadioButtonFrame

Registra um event handler a cada JRadioButton

Classe interna Event handler implementa ItemListener

Quando radio button é selecionado, a fonte do campo de texto será alterada para o valor passa text

field’s font will be set to the value passed to the constructor

70


70

Outline

RadioButtonTest.java

1 // Arquivo: RadioButtonTest.java

2 // Testando RadioButtonFrame.


4

5 public class RadioButtonTest

6 {


8 {

9 RadioButtonFrame radioButtonFrame = new RadioButtonFrame();

10 radioButtonFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 radioButtonFrame.setSize( 300, 100 ); // define tamanho do frame

12 radioButtonFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe RadioButtonTest

71


71

JComboBox e o uso de classe interna anônima para tratamento de eventos

• Combo box– Implementada pela classe JComboBox

– Cada item na lista tem um índice

– setMaximumRowCount define o número máximo de linhas mostrada por vez

– JComboBox oferece uma barra de rolagem e setas cima e baixo para se navegar na lista

72


72

Usando uma classe interna anônima para tratamento de eventos

• Classe interna anônima– Forma especial de classe interna

– Declarada sem um nome

– Normalmente aparece dentro de um método

– Tem um acesso limitado às variáveis locais

73


73

Outline

ComboBoxFrame.java

(1 of 2)

1 // Arquivo: ComboBoxFrame.java

2 // Usando um JComboBox para selecionar uma imagem a apresentar.





7 import javax.swing.JLabel;

8 import javax.swing.JComboBox;

9 import javax.swing.Icon;

10 import javax.swing.ImageIcon;

11

12 public class ComboBoxFrame extends JFrame

13 {

14 private JComboBox imagesJComboBox; // combobox para manter nomes dos ícones

15 private JLabel label; // label para apresentar o ícone selecionado

16

17 private String names[] =

18 { "bug1.gif", "bug2.gif", "travelbug.gif", "buganim.gif" };

19 private Icon icons[] = {

20 new ImageIcon( getClass().getResource( names[ 0 ] ) ),



23 new ImageIcon( getClass().getResource( names[ 3 ] ) ) };

24

25 // construtor do ComboBoxFrame adiciona JComboBox ao JFrame

26 public ComboBoxFrame()

27 {

28 super( "Testando JComboBox" );


30

Declara um atributo JComboBox

74


74

Outline

ComboBoxFrame.java

(2 of 2)

31 imagesJComboBox = new JComboBox( names ); // define o JComboBox

32 imagesJComboBox.setMaximumRowCount( 3 ); // apresenta três linhas

33

34 imagesJComboBox.addItemListener(

35 new ItemListener() // classe interna anônima

36 {

37 // trata eventos JComboBox


39 {

40 // determina se o check box é selecionado

41 if ( event.getStateChange() == ItemEvent.SELECTED )

42 label.setIcon( icons[

43 imagesJComboBox.getSelectedIndex() ] );


45 } // fim da classe interna anônima

46 ); // fim chamada ao addItemListener

47

48 add( imagesJComboBox ); // adiciona combobox ao JFrame

49 label = new JLabel( icons[ 0 ] ); // apresenta primeiro ícone

50 add( label ); // adiciona label ao JFrame

51 } // fim do construtor ComboBoxFrame

52 } // fim da classe ComboBoxFrame

Cria JComboBox e define número máximo de linhas

Cria classe interna anônima como event handler

Declara método itemStateChanged

Método getSelectedIndex localiza item selecionado

Testa alteração de estado do JComboBox

75


75

Outline

ComboBoxTest.java

1 // Arquivo: ComboBoxTest.java

2 // Testando ComboBoxFrame.


4

5 public class ComboBoxTest

6 {


8 {

9 ComboBoxFrame comboBoxFrame = new ComboBoxFrame();

10 comboBoxFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 comboBoxFrame.setSize( 350, 150 ); // define tamanho do frame 12 comboBoxFrame.setVisible( true ); // apresenta frame 13 } // fim do main

14 } // fim da classe ComboBoxTest

Barra de rolagem para visualizar itens na lista

Setas de rolagem

Caixa de rolagem

76


76

Observação

Uma classe interna anônima declarada em um método pode acessar atributos e métodos do objeto da classe externa que declara ela, tão bem quanto variáveis locais final do método, mas não podem acessar variáveis não-final do método.

77


77

JList

• Lista– Apresenta uma série de itens na qual pode-se selecionar um

ou mais itens

– Implementada pela classe JList

– Permite uma lista de seleção simples ou múltipla

– Um ListSelectionEvent ocorre quando um item é selecionado

• Tratado por um ListSelectionListener e passado ao método valueChanged

78


78

Outline

ListFrame.java

(1 of 2)

1 // Arquivo: ListFrame.java

2 // Selecionando cores de uma JList.


4 import java.awt.Color;


6 import javax.swing.JList;

7 import javax.swing.JScrollPane;

8 import javax.swing.event.ListSelectionListener;

9 import javax.swing.event.ListSelectionEvent;

10 import javax.swing.ListSelectionModel;

11

12 public class ListFrame extends JFrame

13 {

14 private JList colorJList; // lista apresentando as cores

15 private final String colorNames[] = { "Black", "Blue", "Cyan",

16 "Dark Gray", "Gray", "Green", "Light Gray", "Magenta",

17 "Orange", "Pink", "Red", "White", "Yellow" };

18 private final Color colors[] = { Color.BLACK, Color.BLUE, Color.CYAN,

19 Color.DARK_GRAY, Color.GRAY, Color.GREEN, Color.LIGHT_GRAY,

20 Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.WHITE,

21 Color.YELLOW };

22

23 // Construtor ListFrame adiciona JScrollPane contendo JList ao JFrame

24 public ListFrame()

25 {

26 super( "Teste de Lista" );


28

Declara um atributo JList

79


79

Outline

ListFrame.java

(2 de 2)

29 colorJList = new JList( colorNames ); // cria com colorNames

30 colorJList.setVisibleRowCount( 5 ); // apresenta 5 linhas de uma vez

31

32 // Impede seleções múltiplas

33 colorJList.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );

34

35 // adiciona um JScrollPane contendo o JList ao frame

36 add( new JScrollPane( colorJList ) );

37

38 colorJList.addListSelectionListener(

39 new ListSelectionListener() // classe interna anônima

40 {

41 // trata eventos de seleção na lista

42 public void valueChanged( ListSelectionEvent event )

43 {

44 getContentPane().setBackground(

45 colors[ colorJList.getSelectedIndex() ] );

46 } // fim do método valueChanged


48 ); // fim da chamada a addListSelectionListener

49 } // fim do construtor ListFrame

50 } // fim da classe ListFrame

Cria JList

Define modo de seleção do JList

Adiciona JList ao ScrollPane e o adiciona à aplicação

Obtém índice do item selecionado

80


80

Outline

ListTest.java

1 // Arqyuvi: ListTest.java

2 // Selecionando cores a partir de uma JList.


4

5 public class ListTest

6 {


8 {

9 ListFrame listFrame = new ListFrame(); // cria ListFrame

10 listFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 listFrame.setSize( 350, 150 ); // define tamanho do frame

12 listFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe ListTest

81


81

Lista de seleção múltipla

• Lista de seleção múltipla– Permite aos usuários selecionarem vários itens

– Seleção de intervalo simples permite apenas um faixa contínua de itens

– Seleção de intervalo múltiplos permite que qualquer conjunto seja selecionado

82


82

Outline

MultipleSelectionFrame.java

(1 de 3)

1 // Arquivo: MultipleSelectionFrame.java

2 // Copiando itens de uma lista para outra.





7 import javax.swing.JList;


9 import javax.swing.JScrollPane;

10 import javax.swing.ListSelectionModel;

11

12 public class MultipleSelectionFrame extends JFrame

13 {

14 private JList colorJList; // lista que mantém nome das cores

15 private JList copyJList; // lista que terá as cores transferidas

16 private JButton copyJButton; // botão para copiar os nomes selecionados

17 private final String colorNames[] = { "Black", "Blue", "Cyan",

18 "Dark Gray", "Gray", "Green", "Light Gray", "Magenta", "Orange",

19 "Pink", "Red", "White", "Yellow" };

20

21 // construtor MultipleSelectionFrame

22 public MultipleSelectionFrame()

23 {

24 super( "Multiple Selection Lists" );


26

83


83

Outline


(2 de 3)

27 colorJList = new JList( colorNames ); // mantém nome de todas as cores

28 colorJList.setVisibleRowCount( 5 ); // mostra cinco linhas

29 colorJList.setSelectionMode(

30 ListSelectionModel.MULTIPLE_INTERVAL_SELECTION );

31 add( new JScrollPane( colorJList ) ); // adiciona a lista com scrollpane

32

33 copyJButton = new JButton( "Copy >>>" ); // Cria o botão copy

34 copyJButton.addActionListener(

35

36 new ActionListener() // classe interna anônima

37 {

38 // manipula eventos do botão


40 {

41 // coloca valores selecionados na copyJList

42 copyJList.setListData( colorJList.getSelectedValues() );



45 ); // fim do addActionListener

46

Usa uma lista de seleção de intervalo múltiplo

Usa método setListData e getSelectedValues para

copiar de uma JList para a outra

84


84

Outline


(3 de 3)

47 add( copyJButton ); // adiciona botão copia ao JFrame

48

49 copyJList = new JList(); //cria lista que mantem nomes das cores copiadas

50 copyJList.setVisibleRowCount( 5 ); // mostra 5 linhas

51 copyJList.setFixedCellWidth( 100 ); // define largura

52 copyJList.setFixedCellHeight( 15 ); // define altura

53 copyJList.setSelectionMode(

54 ListSelectionModel.SINGLE_INTERVAL_SELECTION );

55 add( new JScrollPane( copyJList ) ); // adiciona lista com scrollpane

56 } // fim do construtor MultipleSelectionFrame

57 } // fim da classe MultipleSelectionFrame

Define largura

Define altura

Define modo de seleção para seleção de intervalo simples

85


85

Outline

MultipleSelectionTest.java

1 // Arquivo: MultipleSelectionTest.java

2 // Testando MultipleSelectionFrame.


4

5 public class MultipleSelectionTest

6 {


8 {

9 MultipleSelectionFrame multipleSelectionFrame =

10 new MultipleSelectionFrame();

11 multipleSelectionFrame.setDefaultCloseOperation(

12 JFrame.EXIT_ON_CLOSE );

13 multipleSelectionFrame.setSize( 350, 140 ); // define tamanho do frame

14 multipleSelectionFrame.setVisible( true ); // apresenta frame

15 } // fim do main

16 } // fim da classe MultipleSelectionTest

86

2005 by Pearson Education do Brasil

Tratamento de evento de mouse

• Eventos de mouse:– Cria um objeto MouseEvent.

– Tratado por MouseListeners e MouseMotionListeners.

– MouseInputListener combina as duas interfaces.

– A interface MouseWheelListener declara o método mouseWheelMoved para tratar MouseWheelEvents.

87


Métodos de interface MouseListener e MouseMotionListener. (Parte 1 de 2.)

Métodos de interface MouseListener e MouseMotionListener

Métodos de interface MouseListener

public void mousePressed( MouseEvent event )

Chamado quando um botão do mouse é pressionado enquanto o cursor de mouse estiver sobre um componente.

public void mouseClicked( MouseEvent event )

Chamado quando um botão do mouse é pressionado e liberado enquanto o cursor do mouse pairar sobre um componente. Esse evento é sempre precedido por uma chamada para mousePressed.

public void mouseReleased( MouseEvent event )

Chamado quando um botão do mouse é liberado depois de ser pressionado. Esse evento sempre é precedido por uma chamada para mousePressed e um ou mais chamadas para mouseDragged.

public void mouseEntered( MouseEvent event )

Chamado quando o cursor do mouse entra nos limites de um componente.

88


Métodos de interface MouseListener e MouseMotionListener. (Parte 2 de 2.)

Métodos de interface MouseListener e MouseMotionListener public void mouseExited( MouseEvent event )

Chamado quando o cursor do mouse deixa os limites de um componente.

Métodos de interface MouseMotionListener

public void mouseDragged( MouseEvent event )

Chamado quando o botão do mouse é pressionado enquanto o cursor de mouse estiver sobre um componente e o mouse é movido enquanto o botão do mouse permanecer pressionado. Esse evento é sempre precedido por uma chamada para mousePressed. Todos os eventos de arrastar são enviados para o componente em que o usuário começou a arrastar o mouse.

public void mouseMoved( MouseEvent event )

Chamado quando o mouse é movido quando o cursor de mouse estiver sobre um componente. Todos os eventos de movimento são enviados para o componente sobre o qual o mouse atualmente está posicionado.

89


Resumo

MouseTrackerFrame.java

(1 de 4)

1 // Fig. 11.28: MouseTrackerFrame.java

2 // Demonstrando eventos de mouse.


4 import java.awt.BorderLayout;

5 import java.awt.event.MouseListener;

6 import java.awt.event.MouseMotionListener;

7 import java.awt.event.MouseEvent;



10 import javax.swing.JPanel;

11

12 public class MouseTrackerFrame extends JFrame

13 {

14 private JPanel mousePanel; // painel em que eventos de mouse ocorrerão

15 private JLabel statusBar; // rótulo que exibe informações sobre evento

16

17 // construtor MouseTrackerFrame configura GUI e

18 // registra handlers de evento de mouse

19 public MouseTrackerFrame()

20 {

21 super( "Demonstrating Mouse Events" );

22

23 mousePanel = new JPanel(); // cria painel

24 mousePanel.setBackground( Color.WHITE ); // configura cor de fundo

25 add( mousePanel, BorderLayout.CENTER ); // adiciona painel ao JFrame

26

27 statusBar = new JLabel( "Mouse outside JPanel" );

28 add( statusBar, BorderLayout.SOUTH ); // adiciona rótulo ao JFrame

29

Cria JPanel para capturar eventos de mouse

Configura o fundo como branco

Cria JLabel e o adiciona à aplicação

90


Resumo


(2 de 4)

30 // cria e registra listener para mouse e eventos de movimento de mouse

31 MouseHandler handler = new MouseHandler();

32 mousePanel.addMouseListener( handler );

33 mousePanel.addMouseMotionListener( handler );

34 } // fim do construtor MouseTrackerFrame

35

36 private class MouseHandler implements MouseListener,

37 MouseMotionListener

38 {

39 // handlers de evento MouseListener

40 // trata evento quando o mouse é liberado logo depois de pressionado

41 public void mouseClicked( MouseEvent event )

42 {

43 statusBar.setText( String.format( "Clicked at [%d, %d]",

44 event.getX(), event.getY() ) );

45 } // fim do método mouseClicked

46

47 // trata evento quando mouse é pressionado

48 public void mousePressed( MouseEvent event )

49 {

50 statusBar.setText( String.format( "Pressed at [%d, %d]",


52 } // fim do método mousePressed

53

54 // trata evento quando mouse é liberado depois da operação de arrastar

55 public void mouseReleased( MouseEvent event )

56 {

57 statusBar.setText( String.format( "Released at [%d, %d]",


59 } // fim do método mouseReleased

Cria handler de evento para eventos de mouse

Registra um handler de evento

Implementa interfaces ouvintes de mouse

Determina a localização do clique de mouse

Declara o método mouseClicked

Declara o método mousePressed

Declara o método mouseReleased

91


Resumo


(3 de 4)

60

61 // trata evento quando mouse entra na área

62 public void mouseEntered( MouseEvent event )

63 {

64 statusBar.setText( String.format( "Mouse entered at [%d, %d]",


66 mousePanel.setBackground( Color.GREEN );

67 } // fim do método mouseEntered

68

69 // trata evento quando mouse sai da área

70 public void mouseExited( MouseEvent event )

71 {

72 statusBar.setText( "Mouse outside JPanel" );

73 mousePanel.setBackground( Color.WHITE );

74 } // fim do método mouseExited

75

Declara o método mouseEntered

Configura o segundo plano de JPanel

Declara o método mouseExited

Configura o segundo plano de JPanel

92


Resumo


(4 de 4)

76 // MouseMotionListener event handlers

77 // trata evento MouseMotionListener

78 public void mouseDragged( MouseEvent event )

79 {

80 statusBar.setText( String.format( "Dragged at [%d, %d]",


82 } // fim do método mouseDragged

83

84 // trata evento quanto usuário move o mouse

85 public void mouseMoved( MouseEvent event )

86 {

87 statusBar.setText( String.format( "Moved at [%d, %d]",


89 } // fim do método mouseMoved

90 } // fim da classe MouseHandler interna

91 } // fim da classe MouseTrackerFrame

Declara o método mouseDragged

Declara o método mouseMoved

93


Resumo


(1 de 2)

1 // Fig. 11.29: MouseTrackerFrame.java

2 // Testando MouseTrackerFrame.


4

5 public class MouseTracker

6 {


8 {

9 MouseTrackerFrame mouseTrackerFrame = new MouseTrackerFrame();

10 mouseTrackerFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 mouseTrackerFrame.setSize( 300, 100 ); // configura o tamanho do frame

12 mouseTrackerFrame.setVisible( true ); // exibe o frame

13 } // fim de main

14 } // fim da classe MouseTracker

94


Classes adaptadoras

• Classe adaptadora:– Implementa interface ouvinte de evento.

– Fornece implementação-padrão (corpo do método vazio) para todos os métodos de tratamento de eventos.

95


Observação de engenharia de software

Quando uma classe implementa uma interface, a classe tem um relacionamento ‘é um’ com essa interface. Todas as subclasses diretas e indiretas dessa classe herdam essa interface. Portanto, um objeto de uma classe que estende uma classe adaptadora de evento é um objeto do tipo ouvinte de eventos correspondente (por exemplo, um objeto de uma subclasse de MouseAdapter é um MouseListener).

96


Herdando MouseAdapter

• MouseAdapter:– Classe adaptadora para as interfaces MouseListener e MouseMotionListener.

– Estender a classe permite sobrescrever somente os métodos que você deseja utilizar.

97



Se você estender uma classe adaptadora e digitar incorretamente o nome do método que você está sobrescrevendo, o método simplesmente torna-se outro método na classe. Esse é um erro de lógica difícil de ser detectado, visto que o programa chamará a versão vazia do método herdado da classe adaptadora.

98


Classes adaptadoras de evento e as interfaces que elas implementam no pacote java.awt.event.

Classe adaptadora de evento em java.awt.event

Implementa interface

ComponentAdapter ComponentListener ContainerAdapter ContainerListener FocusAdapter FocusListener KeyAdapter KeyListener MouseAdapter MouseListener MouseMotionAdapter MouseMotionListener WindowAdapter WindowListener

99


Resumo

MouseDetailsFrame.java

(1 de 2)

1 // Fig. 11.31: MouseDetailsFrame.java

2 // Demonstrando cliques de mouse e distinguindo entre botões do mouse.


4 import java.awt.Graphics;

5 import java.awt.event.MouseAdapter;

6 import java.awt.event.MouseEvent;



9

10 public class MouseDetailsFrame extends JFrame

11 {

12 private String details; // representação String

13 private JLabel statusBar; // JLabel que aparece no botão de janela

14

15 // construtor configura barra de título String e registra o listener de mouse

16 public MouseDetailsFrame()

17 {

18 super( "Mouse clicks and buttons" );

19

20 statusBar = new JLabel( "Click the mouse" );

21 add( statusBar, BorderLayout.SOUTH );

22 addMouseListener( new MouseClickHandler() ); // adiciona handler

23 } // fim do construtor MouseDetailsFrame

24

Registra um handler de evento

100


Resumo

MouseDetailsFrame.java

(2 de 2)

25 // classe interna para tratar eventos de mouse

26 private class MouseClickHandler extends MouseAdapter

27 {

28 // trata evento de clique de mouse e determina qual botão foi pressionado

29 public void mouseClicked( MouseEvent event )

30 {

31 int xPos = event.getX(); // obtém posição x do mouse

32 int yPos = event.getY(); // obtém posição y do mouse

33

34 details = String.format( "Clicked %d time(s)",

35 event.getClickCount() );

36

37 if ( event.isMetaDown() ) // botão direito do mouse

38 details += " with right mouse button";

39 else if ( event.isAltDown() ) // botão do meio do mouse

40 details += " with center mouse button";

41 else // botão esquerdo do mouse

42 details += " with left mouse button";

43

44 statusBar.setText( details ); // exibe mensagem na statusBar

45 } // fim do método mouseClicked

46 } // fim da classe interna private MouseClickHandler

47 } // fim da classe MouseDetailsFrame

Obtém o número de vezes que o botão do mouse foi clicado

Testa se o botão direito do mouse foi clicado

Testa se o botão do meio do mouse foi clicado

101


Resumo

MouseDetails.java

(1 de 2)

1 // Fig. 11.32: MouseDetails.java

2 // Testando MouseDetailsFrame.


4

5 public class MouseDetails

6 {


8 {

9 MouseDetailsFrame mouseDetailsFrame = new MouseDetailsFrame();

10 mouseDetailsFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 mouseDetailsFrame.setSize( 400, 150 ); // configura o tamanho do frame

12 mouseDetailsFrame.setVisible( true ); // obtém o frame

13 } // fim de main

14 } // fim da classe MouseDetails

102

Tabela de Tratamento de Eventos Origem Evento Listener

JTextFieldJPasswordFieldJbutton

ActionEvent

ActionListener actionPerformed(ActionEvent e)

JCheckBoxJRadioButton

ItemEvent ItemListener itemStateChanged(ItemEvent e)

JList ListSectionEvent

ListSelectionListener valueChanged(ListSelectionEvent e)

Subclasses dejava.awt.Component

MouseEvent MouseListener mouseClicked(MouseEvent e) mousePressed(MouseEvent e) mouseReleased(MouseEvent e) mouseEntered(MouseEvent e) mouseExited(MouseEvent e)


MouseMotionEvent MouseMotionListener mouseDragged(MouseEvent e) mouseMoved(MouseEvent e)


KeyEvent KeyListener keyTyped(KeyEvent e) keyPressed(KeyEvent e) keyReleasead(KeyEvent e)

103

Origem Evento Listener

Subclasses de java.awt.window

WindowEvent WindowListener windowActivated(WindowEvent

e) windowClosed(WindowEvent e)

windowClosing(WindowEvent e)

windowDeactivated(WindowEvent

e) windowDeiconified(WindowEvent

e) windowIconified(WindowEvent

e) windowOpened(WindowEvent e)

Subclasses dejava.awt.Compon

ent

FocusEvent FocusListener focusGained(FocusEvent e)

focusLost(FocusEvent e)

JScrollBar AdjustmentEvent

AdjustmentListener adjustmentValueChanged(

AdjustmentEvent e)

JMenu MenuEvent MenuListener menuCanceled(MenuEvent e) menuDeselected(MenuEvent e)

menuSelected(MenuEvent e)

Tabela de Tratamento de Eventos

104


104

Gerenciadores de Layout

• Gerenciadores de Layout– É oferecida uma forma básica de organização dos

componentes gráficos no container

– Implementam a interface LayoutManager

105


105

Observação

Muitos ambientes de programação oferecem ferramentas de projeto de interfaces que ajudam o programador a graficamente definir sua interface; a ferramenta de projeto em seguida escreve o código java que implementa a interface. Tais ferramentas com freqüência oferecem um controle maior quanto ao tamanho, posição e alinhamento dos componentes gráficos que os gerenciadores de layout básicos.

106


106

Alguns Gerenciadores de Layout.

Gerenciador de layout

Descrição

FlowLayout Default para javax.swing.JPanel. Coloca componentes sequencialmente (da esquerda para a direita) na ordem em que são adicionados. Também é possível especificar a ordem dos componentes usando o método add do Container, que tem o Component e um índice inteiro (definindo a posição) como argumentos

BorderLayout Default para JFrames (e outras janelas). Arranja os componentes em cinco áreas: NORTH, SOUTH, EAST, WEST and CENTER.

GridLayout Arranja os componentes em linhas e colunas.

107


107

FlowLayout

•FlowLayout– Gerenciador de layout mais simples

– Componentes são colocados da esquerda para a direita na ordem em que são adicionados

– Componentes podem ser alinhados a esquerda, centrado ou a direita

108


108

Outline

FlowLayoutFrame.java

(1 de 3)

1 // Arquivo: FlowLayoutFrame.java

2 // Demonstração do alinhamento de FlowLayout.


4 import java.awt.Container;





9

10 public class FlowLayoutFrame extends JFrame

11 {

12 private JButton leftJButton; // botão para configurar alinhamento a esquerda

13 private JButton centerJButton; // botão para configurar alinhamento ao centro

14 private JButton rightJButton; // botão para configurar alinhamento a direita

15 private FlowLayout layout; // objeto layout

16 private Container container; // container a configurar layout

17

18 // Configurar interface e registrar tratamento de eventos

19 public FlowLayoutFrame()

20 {

21 super( "FlowLayout Demo" );

22

23 layout = new FlowLayout(); // cria FlowLayout

24 container = getContentPane(); // obtém container para layout

25 setLayout( layout ); // define frame layout

26

Cria FlowLayout

Define layout da aplicação

109


109

Outline


(2 of 3)

27 // configura leftJButton e registra listener

28 leftJButton = new JButton( "Left" ); // cria botão Left

29 add( leftJButton ); // adiciona botão Left button ao frame

30 leftJButton.addActionListener(

31


33 {

34 // processa evento em leftJButton


36 {

37 layout.setAlignment( FlowLayout.LEFT );

38

39 // realinha componentes anexados

40 layout.layoutContainer( container );



43 ); // fim de addActionListener

44

45 // configura centerJButton e registra listener

46 centerJButton = new JButton( "Center" ); // cria botão Center

47 add( centerJButton ); // adiciona botão Center ao frame

48 centerJButton.addActionListener(

49


51 {

52 // processa evento em centerJButton


54 {

55 layout.setAlignment( FlowLayout.CENTER );

56

Adiciona JButton; FlowLayout tratará

posicionametno

Define alinhamento a esquerda

Ajusta layout

Adiciona JButton; FlowLayout tratará o

posicionamento

Define alinhamento ao centro

110


110

Outline


(3 de 3)




60 } // fim da classe anônima interna


62

63 // configura botão rightJButton e registra listener

64 rightJButton = new JButton( "Right" ); // cria botão Right

65 add( rightJButton ); // adiciona botão Right ao frame

66 rightJButton.addActionListener(

67


69 {

70 // processa evento rightJButton


72 {

73 layout.setAlignment( FlowLayout.RIGHT );

74






80 } // fim do construtor FlowLayoutFrame

81 } // fim da classe FlowLayoutFrame

Reajusta alinhamento

Adiciona JButton; FlowLayout tratará

posicionamento

Define alinhamento a direita

Reajusta alinhamento

111


111

Outline

FlowLayoutDemo.java

1 // Arquivo: FlowLayoutDemo.java

2 // Testando FlowLayoutFrame.


4

5 public class FlowLayoutDemo

6 {


8 {

9 FlowLayoutFrame flowLayoutFrame = new FlowLayoutFrame();

10 flowLayoutFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 flowLayoutFrame.setSize( 300, 75 ); // configura tamanho do frame

12 flowLayoutFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe FlowLayoutDemo

112


112

BorderLayout

•BorderLayout– Organiza componentes em cinco regiões – north, south,

east, west e center

– Implementa a interface LayoutManager2

– Fornece espaçamento horizontal e vertical

113


113

Observação

Se nenhuma região é especificada durante a adição de um Component ao BorderLayout, o gerenciador posicionará este componente na região BorderLayout.CENTER.

114


114

Observação

Cada container pode ter apenas um gerenciador de layout. Containers separados na mesma aplicação podem usar diferentes gerenciadores de layout.

115


115

Erro de programação comum

Quando mais de um componente é adicionado em uma região no BorderLayout, apenas o último componente adicionado a esta região será apresentado. Nenhum erro indicará este problema.

116


116

Outline

BorderLayoutDemo.java

(1 de 2)

1 // Arquivo: BorderLayoutDemo.java

2 // Testando BorderLayoutFrame.


4

5 public class BorderLayoutDemo

6 {


8 {

9 BorderLayoutFrame borderLayoutFrame = new BorderLayoutFrame();

10 borderLayoutFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 borderLayoutFrame.setSize( 300, 200 ); // define tamanho do frame

12 borderLayoutFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe BorderLayoutDemo

Espaço horizontal Espaço vertical

117


117

Outline

BorderLayoutDemo.java

(2 of 2)

118


118

Outline

BorderLayoutFrame.java

(1 de 2)

1 // Arquivo: BorderLayoutFrame.java

2 // Demonstrando BorderLayout.






8

9 public class BorderLayoutFrame extends JFrame implements ActionListener

10 {

11 private JButton buttons[]; // array de botões para esconder porções

12 private final String names[] = { "Hide North", "Hide South",

13 "Hide East", "Hide West", "Hide Center" };

14 private BorderLayout layout; // objeto borderlayout

15

16 // configura GUI e tratametno de evento

17 public BorderLayoutFrame()

18 {

19 super( "BorderLayout Demo" );

20

21 layout = new BorderLayout( 5, 5 ); // espaço de 5 pixel

22 setLayout( layout ); // configura frame layout

23 buttons = new JButton[ names.length ]; // define tamanho do array

24

25 // cria JButtons e registra tratadores de eventos para eles

26 for ( int count = 0; count < names.length; count++ )

27 {

28 buttons[ count ] = new JButton( names[ count ] );

29 buttons[ count ].addActionListener( this );

30 } // fim do for

Declara atributo BorderLayout

Cria BorderLayout

Define layout

Registra tratador de evento

119


119

Outline

BorderLayoutFrame.java

(2 de 2)

31

32 add( buttons[ 0 ], BorderLayout.NORTH ); // adiciona botão no north

33 add( buttons[ 1 ], BorderLayout.SOUTH ); // adiciona botão no south

34 add( buttons[ 2 ], BorderLayout.EAST ); // adiciona botão no east

35 add( buttons[ 3 ], BorderLayout.WEST ); // adiciona botão no west

36 add( buttons[ 4 ], BorderLayout.CENTER ); // adiciona botão no center

37 } // fim do construtor BorderLayoutFrame

38

39 // trata eventos do botão


41 {

42 // Checa a fonte do evento e layout content pane correspondente

43 for ( JButton button : buttons )

44 {

45 if ( event.getSource() == button )

46 button.setVisible( false ); // esconde botão clicado

47 else

48 button.setVisible( true ); // mostra outros botões

49 } // end for

50

51 layout.layoutContainer( getContentPane() ); // organiza content pane


53 } // fim da classe BorderLayoutFrame

Adiciona botões à aplicação usando constantes do gerenciador de layout

Torna os botões invisíveis

Torna os botões visíveis

Atualiza layout

120


120

GridLayout

•GridLayout– Organização na forma de uma grade (linhas e colunas)

– Todo componente tem a mesma altura e largura

121


121

Outline

GridLayoutDemo.java

1 // Arquivo: GridLayoutDemo.java

2 // Testando GridLayoutFrame.


4

5 public class GridLayoutDemo

6 {


8 {

9 GridLayoutFrame gridLayoutFrame = new GridLayoutFrame();

10 gridLayoutFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 gridLayoutFrame.setSize( 300, 200 ); // configura tamanho do frame

12 gridLayoutFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe GridLayoutDemo

122


122

Outline

GridLayoutFrame.java

(1 de 2)

1 // Arquivo: GridLayoutFrame.java

2 // Demonstrando GridLayout.

3 import java.awt.GridLayout;

4 import java.awt.Container;





9

10 public class GridLayoutFrame extends JFrame implements ActionListener

11 {

12 private JButton buttons[]; // array de botões

13 private final String names[] =

14 { "one", "two", "three", "four", "five", "six" };

15 private boolean toggle = true; // inverter layouts

16 private Container container; // frame container

17 private GridLayout gridLayout1; // primeiro gridlayout

18 private GridLayout gridLayout2; // segundo gridlayout

19

20 // construtor sem argumentos

21 public GridLayoutFrame()

22 {

23 super( "GridLayout Demo" );

24 gridLayout1 = new GridLayout( 2, 3, 5, 5 ); // 2 por 3; espaço de 5

25 gridLayout2 = new GridLayout( 3, 2 ); // 3 por 2; sem espaços

26 container = getContentPane(); // obtém content pane

27 setLayout( gridLayout1 ); // define JFrame layout

28 buttons = new JButton[ names.length ]; // cria array de JButtons

29

Declara dois atributos GridLayout

Cria GridLayout

Configura layout

123


123

Outline

GridLayoutFrame.java

(2 de 2)

30 for ( int count = 0; count < names.length; count++ )

31 {

32 buttons[ count ] = new JButton( names[ count ] );

33 buttons[ count ].addActionListener( this ); // registra listener

34 add( buttons[ count ] ); // adiciona botão ao JFrame

35 } // fim do for

36 } // fim do construtor GridLayoutFrame

37

38 // trata eventos de botão alterando os layouts


40 {

41 if ( toggle )

42 container.setLayout( gridLayout2 ); // configura layout para o secondo

43 else

44 container.setLayout( gridLayout1 ); // configura layout para o primeiro

45

46 toggle = !toggle; // inverte valor de toggle

47 container.validate(); // re-layout do container


49 } // fim da classe GridLayoutFrame

Adiciona botões ao JFrame

Usa segundo layout

Usa primeiro layout

Atualiza layout

124


124

GridBagLayout

• Gerenciador do Layout GridBagLayout– É o mais poderoso dos gerenciadores de layout

– Semelhante a GridLayout • Mas permite que o tamanho de cada componente varie e que

estes possam ser definidos em qualquer ordem.

• Componentes podem ocupar múltiplas linhas e colunas

– Gerenciador mais utilizado e também o mais complexo• Dado que os demais não têm os facilidades para elaboração

de interfaces mais sofisticadas.

125


125

GridBagLayout (Cont.)

• Tela é dividida em linhas e colunas – representando as células que serão ocupadas pelos

componentes;

0 1 2 3

0

123

4

5

126



• Método importante da classe GridBagLayout– public void setConstraints(Component comp, GridBagConstraints constraints)

• Define as características de apresentação (restrições) do component comp no layout.

126

127


127


• Duas classes são importantes para definição do layout

– GridBagConstraints• GridBagConstraints()

• GridBagConstraints(int gridx, int gridy, int gridwidth, int gridheight, double weightx, double weighty, int anchor, int fill, Insets insets, int ipadx, int ipady)

– Insets• Ajustes extras

128


128


gridx especifica a coluna

gridy especifica a linha

gridwidth especifica o número de células ocupadas na linha pelo componente

gridheight especifica o número de células ocupadas na coluna pelo componente

weightx especifica como distribuir o espaço horizontal extra

weighty especifica como distribuir o espaço vertical extra

anchor determina o alinhamento do objeto. CENTER, NORTH, NORTHEAST, EAST,

SOUTHEAST, SOUTH, SOUTHWEST, WEST, e NORTHWEST. O padrão é CENTER

fill permite o redimensionamento do componente quando este é maior que célula. NONE, HORIZONTAL, VERTICAL, BOTH

insets permite realizar ajustes extras no posicionamento dos componentes

ipadx permite ajustes adicionais na linha

ipady permite ajustes adicionais na coluna

129


129


• Um método útil para simplificar o entendimento– Sendo constraints = new GridBagConstraints();

// Método para definir posicionamento e adição de componente

private void addComponent( Component component,

int linha, int coluna, int largura, int altura )

{

constraints.gridx = coluna; // set gridx

constraints.gridy = linha; // set gridy

constraints.gridwidth = largura; // set gridwidth

constraints.gridheight = altura; // set gridheight

layout.setConstraints( component, constraints ); // set constraints

add( component ); // adiciona componente

} // fim do método addComponent

130


130

GridBagLayout (Cont.)• Exemplo de construção da interface

private JLabel lblNome = new JLabel("Nome:"); private JLabel lblSobrenome = new JLabel("Sobrenome:"); private JLabel lblnumCarteiraTrabalho = new JLabel(“NCT:"); private JLabel lblSalario = new JLabel("Salario Mensal:");

//Campos de edição private JTextField edtNome = new JTextField(); private JTextField edtSobrenome = new JTextField(); private JTextField edtnumCarteiraTrabalho = new JTextField(); private JTextField edtSalario = new JTextField(); private JButton btnConfirmar = new JButton("Confirmar"); private JButton btnCancelar = new JButton("Cancelar");

131


131

GridBagLayout (Cont.)• Exemplo de construção da interface

layout = new GridBagLayout(); setLayout(layout); constraints = new GridBagConstraints(); constraints.fill = GridBagConstraints.BOTH;

constraints.insets = new Insets(10, 10, 0, 10); addComponent(lblNome, 0, 0, 1, 1);

addComponent(edtNome, 0, 1, 3, 1);addComponent(lblSobrenome, 1, 0, 1, 1);addComponent(lblnumCarteiraTrabalho, 2, 0, 1, 1);addComponent(lblSalario, 3, 0, 1, 1);addComponent(edtSobrenome, 1, 1, 3, 1);addComponent(edtnumCarteiraTrabalho, 2, 1, 3, 1);addComponent(edtSalario, 3, 1, 3, 1);addComponent(btnConfirmar, 4, 2, 1, 1);addComponent(btnCancelar, 4, 3, 1, 1);

132


132


• Insets(int top, int left, int bottom, int right)

top a distância em relação ao topo

left a distância em relação a esquerda

bottom a distância em relação a base

right a distância em relação a direita

top

left right

bottom

133


133


• Insets(int top, int left, int bottom, int right)– constraints.insets = new Insets(20, 12, 15, 25);

20

12

25

15

134


134

Usando Panels para gerenciar layouts mais complexos

• Interfaces gráficas complexas com freqüência requerem vários painéis para organizar seus componentes de modo apropriado

135


135

Outline

PanelFrame.java

(1 de 2)

1 // Arquivo: PanelFrame.java

2 // Usando um Jpanel para ajudar organizar componentes.

3 import java.awt.GridLayout;





8

9 public class PanelFrame extends JFrame

10 {

11 private JPanel buttonJPanel; // painél para apresentar botões

12 private JButton buttons[]; // array de botões

13

14 // construtor sem argumentos

15 public PanelFrame()

16 {

17 super( "Panel Demo" );

18 buttons = new JButton[ 5 ]; // cria o array de botões

19 buttonJPanel = new JPanel(); // configura painél

20 buttonJPanel.setLayout( new GridLayout( 1, buttons.length ) );

21

Declara um JPanel para apresentar botões

Cria JPanel

Configura layout

136


136

Outline

PanelFrame.java

(2 de 2)

22 // cria e adiciona botões

23 for ( int count = 0; count < buttons.length; count++ )

24 {

25 buttons[ count ] = new JButton( "Button " + ( count + 1 ) );

26 buttonJPanel.add( buttons[ count ] ); // adiciona botões ao JPanel

27 } // end for

28

29 add( buttonJPanel, BorderLayout.SOUTH ); // adicional Jpanel ao JFrame

30 } // fim do construtor PanelFrame

31 } // fim da classe PanelFrame

Adiciona o painel de botões

Adiciona painel à aplicação

137


137

Outline

PanelDemo.java

1 // Arquivo: PanelDemo.java

2 // Testando PanelFrame.


4

5 public class PanelDemo extends JFrame

6 {


8 {

9 PanelFrame panelFrame = new PanelFrame();

10 panelFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 panelFrame.setSize( 450, 200 ); // configura tamanho do frame

12 panelFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe PanelDemo

138


138

Usando Menus com Frames

• Menus– Permite ao usuário solicitar ações

– Pode ser anexado apenas a objetos da classe que têm o método setMenuBar, tal como JFrame e JApplet

– Classe MenuBar• Contém métodos necessários para gerenciar uma barra de

menu

– Classe JMenu• Contém os métodos necessário para gerenciar menus

– Classe JMenuItem• Contém os métodos necessários para gerenciar itens de menu

139


139

Usando Menus com Frames (Cont.)

– Classe JCheckBoxMenuItem• Contém os métodos necessários para gerenciar itens de

menus que pode ser colocados como on ou off

– Classe JRadioButtonMenuItem• Contém os métodos necessários para gerenciar itens de menu

que podem ser on ou off como em JCheckBoxMenuItems

• Quando vários JRadioButtonMenuItems são mantidos como parte de um ButtonGroup, apenas um item no grupo pode ser selecionado

– Mnemônicos• Caracteres especiais que podem oferecer acesso rápido ao

menu ou item do menu a partir do teclado

140


140

Outline

MenuTest.java

(1 de 2)

1 // Arquivo: MenuTest.java

2 // Testando MenuFrame.


4

5 public class MenuTest

6 {


8 {

9 MenuFrame menuFrame = new MenuFrame(); // cria MenuFrame

10 menuFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 menuFrame.setSize( 500, 200 ); // define tamanho do frame

12 menuFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe MenuTest

Menu

Caracteres mnemônicos

Barra de menu

141


141

Outline

MenuTest.java

(2 de 2)

Menu items

Submenu expandido

Linha separadora

142


142

Outline

MenuFrame.java

(1 de 8)

1 // Arquivo: MenuFrame.java

2 // Demonstrando menus.









11 import javax.swing.JRadioButtonMenuItem;

12 import javax.swing.JCheckBoxMenuItem;



15 import javax.swing.SwingConstants;

16 import javax.swing.ButtonGroup;

17 import javax.swing.JMenu;

18 import javax.swing.JMenuItem;

19 import javax.swing.JMenuBar;

20

143


143

Outline

MenuFrame.java

(2 de 8)

21 public class MenuFrame extends JFrame

22 {

23 private final Color colorValues[] =

24 { Color.BLACK, Color.BLUE, Color.RED, Color.GREEN };

25 private JRadioButtonMenuItem colorItems[]; // itens do menu: cores

26 private JRadioButtonMenuItem fonts[]; // itens de menu: fontes

27 private JCheckBoxMenuItem styleItems[]; // itens de menu: estilo da fonte

28 private JLabel displayJLabel; // apresenta texto de teste

29 private ButtonGroup fontButtonGroup; // gerencia itens do menu fonte

30 private ButtonGroup colorButtonGroup; // gerencia itens do menu cores

31 private int style; // usado para criar estilo para a fonte

32

33 // construtor sem argumentos que configura a interface

34 public MenuFrame()

35 {

36 super( "Using JMenus" );

37

38 JMenu fileMenu = new JMenu( "File" ); // cria menu file

39 fileMenu.setMnemonic( 'F' ); // configura mnemonico para F

40

41 // cria item do menu About...

42 JMenuItem aboutItem = new JMenuItem( "About..." );

43 aboutItem.setMnemonic( 'A' ); // configura mnemonico para A

44 fileMenu.add( aboutItem ); // adiciona item about ao menu file

45 aboutItem.addActionListener(

46

Cria um JMenu

Chama método JMenu setMnemonic

Adiciona the JMenuItem “About…” ao fileMenu

144


144

Outline

MenuFrame.java

(3 de 8)


48 {

49 // apresenta o caixa de mensagem quando o usuario seleciona About...


51 {

52 JOptionPane.showMessageDialog( MenuFrame.this,

53 "This is an example\nof using menus",

54 "About", JOptionPane.PLAIN_MESSAGE );




58

59 JMenuItem exitItem = new JMenuItem( "Exit" ); // Cria item exit

60 exitItem.setMnemonic( 'x' ); // configura mnemonico x

61 fileMenu.add( exitItem ); // adiciona item exit ao menu file

62 exitItem.addActionListener(

63


65 {

66 // termina aplicação quando o usuario clica em exitItem


68 {

69 System.exit( 0 ); // fim da aplicação


71 } // fim da classe anônima interna


73

Cria um ActionListener para processar eventos de ação em aboutItem

Apresenta uma caixa de mensagem de dialogo

Cria e adiciona o item de menu exitItem

Registra um ActionListener que encerra a aplicação

145


145

Outline

MenuFrame.java

(4 de 8)

74 JMenuBar bar = new JMenuBar(); // cria barra de menu

75 setJMenuBar( bar ); // adiciona barra de menu à aplicação

76 bar.add( fileMenu ); // adiciona menu file à barra de menu

77

78 JMenu formatMenu = new JMenu( "Format" ); // cria menu format

79 formatMenu.setMnemonic( 'r' ); // configura mnemonico r

80

81 // array dos nomes das cores

82 String colors[] = { "Black", "Blue", "Red", "Green" };

83

84 JMenu colorMenu = new JMenu( "Color" ); // cria menu color

85 colorMenu.setMnemonic( 'C' ); // configura mnemonico C

86

87 // cria menu de itens radiobutton para as cores

88 colorItems = new JRadioButtonMenuItem[ colors.length ];

89 colorButtonGroup = new ButtonGroup(); // gerencia cores

90 ItemHandler itemHandler = new ItemHandler(); // trata eventos para cores

91

92 // cria itens do menu color com botão radio

93 for ( int count = 0; count < colors.length; count++ )

94 {

95 colorItems[ count ] =

96 new JRadioButtonMenuItem( colors[ count ] ); // cria item

97 colorMenu.add( colorItems[ count ] ); // adiciona item ao menu color

98 colorButtonGroup.add( colorItems[ count ] ); // adiciona ao grupo

99 colorItems[ count ].addActionListener( itemHandler );

100 } // fim do for

101

Adiciona fileMenu ao JMenuBar e anexa o JMenuBar à janela da aplicação

Cria menu formatMenu

cria submenu colorMenu

Cria array JRadioButtonMenuItem colorItems

Cria um ButtonGroup para assegurar que apenas um dos itens de menu seja selecionado por vez

Adiciona JRadioButtonMenuItems ao colorMenu e registra ActionListeners

146


146

Outline

MenuFrame.java

(5 de 8)

102 colorItems[ 0 ].setSelected( true ); // seleciona primeiro item de Color

103

104 formatMenu.add( colorMenu ); // adiciona menu color ao menu format

105 formatMenu.addSeparator(); // adiciona separador no menu

106

107 // array com nomes das fontes

108 String fontNames[] = { "Serif", "Monospaced", "SansSerif" };

109 JMenu fontMenu = new JMenu( "Font" ); // cria menu font

110 fontMenu.setMnemonic( 'n' ); // define mnemonico n

111

112 // cria itens de menu radiobutton para nomes das fontes

113 fonts = new JRadioButtonMenuItem[ fontNames.length ];

114 fontButtonGroup = new ButtonGroup(); // gerencia nomes das fontes

115

116 // cria itens de menu Font radio button

117 for ( int count = 0; count < fonts.length; count++ )

118 {

119 fonts[ count ] = new JRadioButtonMenuItem( fontNames[ count ] );

120 fontMenu.add( fonts[ count ] ); // adiciona fonte ao menu font

121 fontButtonGroup.add( fonts[ count ] ); // adiciona ao button group

122 fonts[ count ].addActionListener( itemHandler ); // adiciona handler

123 } // end for

124

125 fonts[ 0 ].setSelected( true ); // seleciona primeiro item do menu Font

126 fontMenu.addSeparator(); // adiciona separador ao menu Font

127

Chama método AbstractButton setSelected

Adiciona colorMenu ao formatMenu e adiciona uma linha de separação horizontal

Cria array de JRadioButtonMenuItem fontsCria um ButtonGroup para

assegurar que apenas um dos itens do menu sejam selecionados por vez

Adiciona JRadioButtonMenuItems ao colorMenu e registra ActionListeners

Configura seleção default e adiciona separador horizontal

147


147

Outline

MenuFrame.java

(6 de 8)

128 String styleNames[] = { "Bold", "Italic" }; // nomes dos estilos

129 styleItems = new JCheckBoxMenuItem[ styleNames.length ];

130 StyleHandler styleHandler = new StyleHandler(); // handler para estilos

131

132 // cria itens do menu Style como checkbox

133 for ( int count = 0; count < styleNames.length; count++ )

134 {

135 styleItems[ count ] =

136 new JCheckBoxMenuItem( styleNames[ count ] ); // para estilo

137 fontMenu.add( styleItems[ count ] ); // adiciona ao menu font

138 styleItems[ count ].addItemListener( styleHandler ); // handler

139 } // fim do for

140

141 formatMenu.add( fontMenu ); // adiciona menu Font ao menu Format

142 bar.add( formatMenu ); // adiciona menu Format à barra de menu

143

144 // Configura label para apresentar o texto

145 displayJLabel = new JLabel( "Sample Text", SwingConstants.CENTER );

146 displayJLabel.setForeground( colorValues[ 0 ] );

147 displayJLabel.setFont( new Font( "Serif", Font.PLAIN, 72 ) );

148

149 getContentPane().setBackground( Color.CYAN ); // configura cor de fundo

150 add( displayJLabel, BorderLayout.CENTER ); // adiciona displayJLabel

151 } // fim do construtor de MenuFrame

152

Cria JCheckBoxMenuItems

Adiciona fontMenu ao formatMenu e formatMenu ao JMenuBar

148


148

Outline

MenuFrame.java

(7 de 8)

153 // classe interna tratando eventos action dos itens do menu

154 private class ItemHandler implements ActionListener

155 {

156 // processa seleção de fontes e cores


158 {

159 // processa seleção de cores

160 for ( int count = 0; count < colorItems.length; count++ )

161 {

162 if ( colorItems[ count ].isSelected() )

163 {

164 displayJLabel.setForeground( colorValues[ count ] );

165 break;

166 } // fim do if

167 } // fim do for

168

169 // processa seleção da fonte

170 for ( int count = 0; count < fonts.length; count++ )

171 {

172 if ( event.getSource() == fonts[ count ] )

173 {

174 displayJLabel.setFont(

175 new Font( fonts[ count ].getText(), style, 72 ) );

176 } // fim do if

177 } // fim do for

178

Determina o JRadioButtonMenuItem selecionado

Método getSource retorna uma referência ao JRadioButtonMenuItem que gerou o evento

149


149

Outline

MenuFrame.java

(8 de 8)

179 repaint(); // desenha novamente a aplicação


181 } // fim da classe ItemHandler

182

183 // classe interna para tratar item events dos itens do menu check box

184 private class StyleHandler implements ItemListener

185 {

186 // processa seleção de fonte e estilo

187 public void itemStateChanged( ItemEvent e )

188 {

189 style = 0; // inicializa style

190

191 // checa se bold é selecionado

192 if ( styleItems[ 0 ].isSelected() )

193 style += Font.BOLD; // adiciona bold ao style

194

195 // checa se italic é selecionado

196 if ( styleItems[ 1 ].isSelected() )

197 style += Font.ITALIC; // adiciona italic ao style

198

199 displayJLabel.setFont(

200 new Font( displayJLabel.getFont().getName(), style, 72 ) );

201 repaint(); // desenha novamente a aplicação


203 } // fim da classe StyleHandler

204 } // fim da classe MenuFrame

Chamado se o usuário seleciona um JCheckBoxMenuItem em fontMenu

Determina se um ou os dois JCheckBoxMenuItems estão selecionados

150


150

JTabbedPane

•JTabbedPane– Organiza componentes gráficos em camadas em que

apenas uma camada é visível por vez• Quando o usuário clica na guia, a camada apropriada é

apresentada

– As guias podem ser posicionados no topo (default), esquerda, direita ou embaixo

– Qualquer componente pode ser colocado em uma guia

– Se as guias não couberem em uma linha, eles serão colocados em linhas adicionais

151


151

Outline

JTabbedPaneDemo.java

1 // Arquivo: JTabbedPaneDemo.java

2 // Demonstrando JTabbedPane.


4

5 public class JTabbedPaneDemo

6 {


8 {

9 JTabbedPaneFrame tabbedPaneFrame = new JTabbedPaneFrame();

10 tabbedPaneFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11 tabbedPaneFrame.setSize( 250, 200 ); // define tamanho do frame

12 tabbedPaneFrame.setVisible( true ); // apresenta frame

13 } // fim do main

14 } // fim da classe JTabbedPaneDemo

152


152

Outline

JTabbedPaneFrame.java

(1 de 2)

1 // Arquivo: JTabbedPaneFrame.java

2 // Demonstrando JTabbedPane.




6 import javax.swing.JTabbedPane;




10 import javax.swing.SwingConstants;

11

12 public class JTabbedPaneFrame extends JFrame

13 {

14 // configura interface

15 public JTabbedPaneFrame()

16 {

17 super( "JTabbedPane Demo " );

18

19 JTabbedPane tabbedPane = new JTabbedPane(); // cria JTabbedPane

20

21 // configura pane11 e adiciona este ao JTabbedPane

22 JLabel label1 = new JLabel( "panel one", SwingConstants.CENTER );

23 JPanel panel1 = new JPanel(); // cria primeiro painel

24 panel1.add( label1 ); // adiciona label ao painel

25 tabbedPane.addTab( "Tab One", null, panel1, "First Panel" );

26

Cria um JTabbedPane vazio com as configurações default

Chama método JTabbedPane addTab com argumentos que especificam o título da guia, uma referência a interface Icon para apresentar na guia, o COMPONENT a apresentar quando o usuário clica na guia e a string tooltip da guia

153


153

Outline

JTabbedPaneFrame.java

(2 de 2)

27 // configura panel2 e o adiciona JTabbedPane

28 JLabel label2 = new JLabel( "panel two", SwingConstants.CENTER );

29 JPanel panel2 = new JPanel(); // cria segundo painel

30 panel2.setBackground( Color.YELLOW ); // configura fundo amarelo

31 panel2.add( label2 ); // adiciona label ao panel

32 tabbedPane.addTab( "Tab Two", null, panel2, "Second Panel" );

33

34 // configura panel3 e o adiciona ao JTabbedPane

35 JLabel label3 = new JLabel( "panel three" );

36 JPanel panel3 = new JPanel(); // cria terceiro painel

37 panel3.setLayout( new BorderLayout() ); // usa borderlayout

38 panel3.add( new JButton( "North" ), BorderLayout.NORTH );

39 panel3.add( new JButton( "West" ), BorderLayout.WEST );

40 panel3.add( new JButton( "East" ), BorderLayout.EAST );

41 panel3.add( new JButton( "South" ), BorderLayout.SOUTH );

42 panel3.add( label3, BorderLayout.CENTER );

43 tabbedPane.addTab( "Tab Three", null, panel3, "Third Panel" );

44

45 add( tabbedPane ); // adiciona JTabbedPane ao frame

46 } // fim do construtor JTabbedPaneFrame

47 } // fim da classe JTabbedPaneFrame

Adiciona panel2 ao tabbedPane

Adiciona panel3 ao tabbedPane

154


JMenu e CardLayout

•CardLayout– Gerenciador de layout que empilha os componentes de um

container de tal forma que apenas o componente que está no topo permanece visível

– Métodos de navegação first(), next(), previous() e last()

• Permitem "navegar" entre os componentes empilhados

– determinando qual item deve estar visível em um dado momento

– permitem realizar uma varredura seqüencial pelos componentes de container especificado

154

155


JMenu e CardLayout

•CardLayout– Método show()

• permite selecionar um componente para exposição diretamente através de uma string

– String especificada como uma restrição quando da adição do componente ao container

155

156


156

CardLayoutTest.java

// Arquivo: JTabbedPaneDemo.java// Demonstrando CardLayout.import javax.swing.JFrame;

public class CardLayoutTest{ public static void main( String args[] ) { CardLayoutDemo cardLayoutDemo = new CardLayoutDemo(); cardLayoutDemo.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); cardLayoutDemo.setSize( 300, 200 ); // define tamanho do frame cardLayoutDemo.setResizable(false); cardLayoutDemo.setVisible( true ); // apresenta frame } // fim do main} // fim da classe JGridLayoutBagDemo

157


157

CardLayoutTest.java

// Arquivo CardLayoutDemo// Demonstração do CardLayoutimport java.awt.*;import java.awt.event.*;import javax.swing.*;

public class CardLayoutDemo extends JFrame implements ActionListener { private JPanel cards; //um JPanel que usa CardLayout private JMenu menu; //menu principal Panel private JMenuItem buttonItem; //item do menu Panel private JMenuItem textItem; //item do menu Panel private JMenuBar bar; //barra de menu // Constantes usadas para identificar os JPanels (as Cards) final static String BUTTONPANEL = "Card with JButtons"; final static String TEXTPANEL = "Card with JTextField"; public CardLayoutDemo () { // Define o título do aplicativo super("Demo de CardLayout"); // Cria Menu Panel menu = new JMenu("Panel"); // Cria itens do menu Panel buttonItem = new JMenuItem(BUTTONPANEL); textItem = new JMenuItem(BUTTONPANEL); menu.add(buttonItem); menu.add(textItem); // Associa tratador de eventos aos itens do menu buttonItem.addActionListener(this); textItem.addActionListener(this); // Define a barra de menu com o menu Panel bar = new JMenuBar(); bar.add(menu); setJMenuBar( bar );

158


158

CardLayoutTest.java

// Cria card de botões JPanel card1 = new JPanel(); card1.add(new JButton("Button 1")); card1.add(new JButton("Button 2")); card1.add(new JButton("Button 3")); // Cria card com campo de texto JPanel card2 = new JPanel(); card2.add(new JTextField("TextField", 20)); // Cria JPanel com layout CardLayout que conterá as cards cards = new JPanel(new CardLayout()); cards.add(card1, BUTTONPANEL); cards.add(card2, TEXTPANEL); // adiciona cards ao JFrame add(cards, BorderLayout.CENTER); } // Trata os eventos de seleção no menu Panel public void actionPerformed( ActionEvent event ) { // Obtém o Layout CardLayout do JPanel CardLayout cl = (CardLayout)(cards.getLayout()); // Apresenta o JPanel apropriado de acordo com a seleção no menu if (event.getSource() == buttonItem) cl.show(cards, BUTTONPANEL); else cl.show(cards, TEXTPANEL); } }

COMPONENTES GUI (capítulo 11 Deitel)

Documents

Transcript of COMPONENTES GUI (capítulo 11 Deitel)