Componentes gráficos GUI – Parte 2

Criando interfaces
com o usuário
Continuação

A diferença básica entre um objeto Window e um objeto
JFrame é que o JFrame representa a janela principal de
uma aplicação e o Window apenas uma janela a mais.
Antes de criar um objeto Window ou JDialog é preciso
criar um objeto JFrame.
JFrame => Um objeto desta classe possui uma barra de
título e características para receber menus e outros
componentes.
JDialog => Usada para definir janelas de diálogos para
entrada de dados. Normalmente usada em resposta a
uma opção de menu selecionada. Definida em função
de um objeto JFrame.
JApplet => Classe base para applets Java. É possível
desenhar e adicionar menus e outros componentes em
um JApplet.
JComponent => As subclasses de JComponent definem
um conjunto de componentes standard (menus, botões,
checkboxes, etc)

Vejamos alguns atributos comuns de
componentes:
posição(x,y): posição do objeto em relação ao seu
container;
Nome do componente
(myWindow.setName(“Nome”););
Tamanho: altura e largura
Cor do objeto e cor de fundo
Fonte
Aparência do cursor
Objeto habilitado ou não: (isEnabled(),
myWindow.setEnabled())
Objeto visível ou não: (isVisible(),
myWindow.setVisible())
Objeto válido ou não
Obs: Todos estes atributos são private.

Vejamos um exemplo
usando o componente
gráfico JPanel exibido
dentro de um JFrame.
Este componente será
extendido para exibir o
desenho de algumas
linhas.
Implemente a seguinte
classe:

Implemente esta
classe para testar a
anterior

A posição de um componente é definida por um par de
inteiros x,y ou por um objeto do tipo Point. Um objeto
Point possui dois argumentos public int (x e y).
Dimensões são definidas pelos inteiros width e height ou
por um objeto do tipo Dimension que possui dois
argumentos public inteiros (width e height).
Tamanho e posição também podem ser definidos juntos
por um objeto Rectangle (4 argumentos public int – x,y,
representando o topo a esquerda e width e height
representando o tamanho).
Outros componentes que podemos usar em nossas
aplicações são: Botão (JButton), Menu (JMenu), Caixa
de texto(JTextComponent), Lista (JList), Tabela(JTable),
Container, etc.

Entendendo Layouts:
Já foi visto que interfaces em Java são formadas
quando adicionamos componentes a containers. Os
containers são responsáveis por manter os
componentes visíveis, repassar os eventos, etc.
Como a filosofia da linguagem Java é que os
programas sejam extremamente portáveis, a filosofia
da interface também visa ser extremamente
adaptável. Por esta razão a disposição dos
componentes sobre o container não é indicada por
um par ordenado (x,y) como na maioria das outras
bibliotecas de construção de interface com o usuário.
A linguagem oferece um conjunto de Layouts básicos
que especificam como estes componentes devem ser
organizados(é claro que você também pode
especificar seu próprio layout, mas isto dará mais
trabalho).

Entendendo Layouts (continuação)
O arranjo dos componentes dentro do
container é gerenciado por um Layout
Manager.
A vantagem de se ter um Layout Manager é
que a apresentação dos componentes se
adapta quando redimensionamos a janela. A
desvantagem é o pouco domínio que o
programador tem da posição dos
componentes com alguns Layout Managers.

FlowLayout
Componentes distribuídos da esquerda para a
direita de cima pra baixo.
Panel c = new Panel();
c.add(new Button(“1”));
c.add(new TextField(“9”));
c.add(new Button(“2”));
c.add(new Button(“3”));
Respeita o tamanho preferido dos componentes mesmo quando não
houver espaço suficiente no container.

GridLayout
Similar ao FlowLayout só que cada componente é
alocado em uma célula de igual tamanho. Permite definir
um vetor ou uma matriz de células nas quais os
componentes são alocados.
Panel c = new Panel();
c.setLayout(new GridLayout(2,2));
c.add(new Button(“um”));
c.add(new TextField(“9”));
c.add(new Button(“dois”));
c.add(new Button(“três”));
Divide a área em uma grade
Dispõe os elementos da esquerda para a direita de cima
para baixo
Todos tem o mesmo tamanho

GridBagLayout
Semelhante ao GridLayout porém as
divisões podem ser de tamanhos
diferentes
É um layout flexível e complicado e só
deve ser usado quando nenhum dos
outros se aplica.
A classe GridBagConstraints é usada para
dimensionar e posicionar os
componentes.

CardLayout
Usado para exibir um componente de cada vez como
em uma pilha de cartas
Somente o objeto que estiver no topo será visível
Métodos:
first(container), last(container), next(container),
previous(container), show(container, string)

BorderLayout
É o layout default para a maioria das aplicações
gráficas. Um container é dividido em 5 regiões e
quando se adiciona um componentes é preciso
especificar em que área se quer adicioná-lo. Ex:
add(botao_ok, BorderLayout.WEST);
Cada região de BorderLayout só suporta a
inclusão de um único componente. Caso um
segundo componente seja incluído em uma das
regiões o componente anterior será apagado.

As regiões de BorderLayout são:
BorderLayout.CENTER
BorderLayout.NORTH
BorderLayout.EAST
BorderLayout.SOUTH
BorderLayout.WEST
Vejamos no próximo slide um exemplo da utilização
de BorderLayout:

import java.awt.BorderLayout;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JFrame;
public class LabelDemo
{
public static void main(String args[])
{
ImageIcon labelIcon = new ImageIcon("GUItip.gif");
JLabel norteLabel = new JLabel(labelIcon);
norteLabel.setText("Norte");
JLabel centroLabel = new JLabel(labelIcon);
centroLabel.setText("Centro");
centroLabel.setToolTipText(“Sou o elemento do centro");
JLabel sulLabel = new JLabel(labelIcon);
sulLabel.setText("Sul");
JLabel lesteLabel = new JLabel("Leste");
JLabel oesteLabel = new JLabel("Oeste");
}
JFrame aplicacao = new JFrame("Teste de labels");
aplicacao.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
aplicacao.add(norteLabel,BorderLayout.NORTH);
aplicacao.add(centroLabel,BorderLayout.CENTER);
aplicacao.add(sulLabel,BorderLayout.SOUTH);
aplicacao.add(lesteLabel,BorderLayout.EAST);
aplicacao.add(oesteLabel,BorderLayout.WEST);
aplicacao.setSize(300, 300);
aplicacao.setVisible(true);
}

Exercitando:
1)Redimensione a janela para 400 pontos de
largura e 200 pontos de altura.
2)Na parte norte da janela acrescente um
outro label de forma que os dois labels sejam
exibidos na parte norte simultaneamente. Se
o novo label for simplesmente acrescentado à
construção atual ambos (ele e o anterior)
serão exibidos ao mesmo tempo? Como
resolver esta questão?

BoxLayout
Respeita o tamanho preferido dos componentes
Coloca os componentes organizados em uma linha ou
coluna
BoxLayout.X_AXIS para componentes em linha
BoxLyout.Y_AXIS para componentes em coluna
Ex:
JPanel c = new JPanel();
c.setLayout(new BoxLayout(c,BoxLayout.X_AXIS));
c.add(new JButton(“um”));
c.add(new JButton(“dois”));
c.add(new JButton(“três”));
c.add(new JButton(“quatro”));

Compondo Layouts usando Panels
A classe Panel é um container pois é derivada
da classe Container. Assim sendo podemos
agrupar vários componentes dentro de um
Panel e passar a considerá-lo um único
componente para efeito de layout.
Por ser um container um Panel pode ter seu
layout próprio.
Esta é uma maneira muito usada para criar
layouts compostos.
Vejamos um exemplo de layout composto
usando swing:

Vejamos uma implementação para este código com 2 botões
import javax.swing.*;
import java.awt.event.*;
//import java.awt.*;
public class TestaEventos3 extends JFrame
{
JButton botao, botao2;
JLabel texto;
JPanel painel;
int cont;
public TestaEventos3()
{
super("Aplicacao de testar eventos");
cont = 0;
painel = new JPanel();
botao = new JButton("Botao");
botao2 = new JButton("Botao2");
painel.setLayout(new BoxLayout(painel, BoxLayout.Y_AXIS));
painel.add(botao);
painel.add(botao2);
MouseAdapter mouseGer =new MouseAdapter(){public void mouseClicked(MouseEvent e)
{if(e.getSource() == botao) System.out.println("Clicou b1");
else System.out.println("Clicou b2");
}
public void mouseReleased(MouseEvent e)
{if(e.getSource() == botao) System.out.println("Soltou b1");
else System.out.println("Soltou b2");
}
};
botao.addMouseListener(mouseGer);
botao2.addMouseListener(mouseGer);
getContentPane().add(painel);
}

continuação
public static void main(String args[])
{
TestaEventos3 aplicacao = new TestaEventos3();
aplicacao.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
aplicacao.setSize(200,100);
aplicacao.setVisible(true);
}
}

Um mesmo gerenciador pode receber os
eventos de mais de um componente como
veremos no próximo exemplo:

import javax.swing.*;
import java.awt.event.*;
//import java.awt.*;
public class TestaEventos2B extends JFrame implements ActionListener
{
JButton botao, botao2;
JLabel texto, texto2;
JPanel painel;
int cont;
public TestaEventos2B()
{
super("Janela de teste com dois botões");
cont = 0;
painel = new JPanel();
botao = new JButton("Botao");
botao2 = new JButton("Botão 2");
texto = new JLabel("Quantidade de clicks:");
texto2 = new JLabel("Último botão pressionado:");
painel.setLayout(new BoxLayout(painel, BoxLayout.Y_AXIS));
painel.add(botao);
painel.add(botao2);
painel.add(texto);
painel.add(texto2);
botao.addActionListener(this);
botao2.addActionListener(this);
getContentPane().add(painel);
}

public void actionPerformed(ActionEvent e)
{
cont++;
texto.setText("Quantidade de clicks = "+cont);
if (e.getSource() == botao) texto2.setText("Último botão pressionado:
Botão 1");
else if (e.getSource() == botao2) texto2.setText("Último botão
pressionado: Botão 2");
}
public static void main(String args[])
{
TestaEventos2B aplicacao = new TestaEventos2B();
aplicacao.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
aplicacao.setSize(300,200);
aplicacao.setVisible(true);
}
}