Java Swing

Lição 1 - Visão Geral

Visão Geral

Introdução

Swing é uma das 5 APIs que formam a JFC (Java Foundation Classes), que abrangem um grupo das características para construir Interfaces Gráficas com o Usuários (GUIs) e adição de ricas funcionalidades e interatividade

com aplicações Java. O Swing veio como uma extensão do AWT(Abstract Window Toolkit) que dependia de componentes específicos de cada

plataforma, o que não acontece com Swing, pois este contém apenas códigos java , o que permite rodar em qualquer plataforma(Run

Everywhere), entretanto estes componentes são sensivelmente mais lentos que componentes nativos de qualquer plataforma. Apesar da criação da

Swing, o AWT ainda é suportado. Para um bom rendimento neste curso o aluno deve ter um conhecimento básico em Java e ser capaz de criar e

compilar um aplicativo básico nesta linguagem.

API Swing

A API Swing é poderosa, flexível e imensa, que possui pacotes públicos, cada um com sua própria finalidade distinta:

javax.swing

Pacote swing de alto nível, consiste primariamente de componentes, adaptadores, modelos padrão de componentes e interface.

javax.swing.border

O pacote border declara a interface Border e classes, que define específico estilo de borda.

javax.swing.colorchooser

O pacote colorchooser contém classes de suporte para componentes color chooser .

javax.swing.event

O pacote de event é para eventos e listeners específicos Swing. Adiciona ao java.awt.event types, componentes Swing podem gerar seus próprios tipos de eventos.

javax.swing.filechooser

O pacote filechooser contém classes de suporte para componentes de

seleção de arquivos.

javax.swing.plaf

Plug-in look-and-feel (PLAF) pacote que contém Interfaces com usuário(UI) classes (delegadas) que implementam diferentes look-and-feel aspects para componentes Swing. Há também alguns pacotes de PLAF sob a hierarquia.

javax.swing.table

O pacote table contém suporte para interfaces e classes para o componente Swing table.

javax.swing.text

O pacote text contém classes de suporte para o framework do Swing de documento.

javax.swing.text.html

O pacote text.html contém classes de suporte para HTML versão 3.2 interpretador e analisador.

javax.swing.text.rtf

O pacote text.rtf contém classes de suporte para um básico interpretados Rich Text Format (RTF).

javax.swing.tree

O pacote tree contém interface e classes para o componente tree do Swing.

javax.swing.undo

O pacote undo provê classes de suporte para implementar a capacidade de fazer/desfazer nos GUI.

javax.accessibility

O pacote de acessibilidade da JFC é incluido nas classes Swing. Entretanto, seu uso não será discutido aqui.

Componentes Swing

O widget é um termo sem tradução que designa componentes de interface gráfica com o usuário (GUI). Qualquer item de uma interface gráfica é chamada de widget, por exemplo: janelas, botões, menus ítens de menus,

ícones, barras de rolagem, etc.

O pacote de acessibilidade da JFC é incluído nas classes Swing. Entretanto, seu uso não será discutido aqui.

Figura1 -Hierarquia de componentes similares ao AWT.

Figura 2 - Hierarquia de componentes novos do Swing.

Lição 1 - Visão Geral

Galeria de componentes

JApplet JBorders JButton JCheckBox

JCheckBoxMenuItem JColorChooser JComboBox ImageIcon

JDialog JFileChooser JInternalFrame JLabel

JList JMenu JMenuBar JOptionPane

JPopupMenu JRadioButton JRadioButtonMenuItem JScrollBar

JScrollPane JSlider JSplitPane JTabbedPane

JTable JTextArea JTextField JToggleButton

JToolBar JToolTip JTree

Lição 2 - Containers e Componentes

Containers

Containers

Quase todas as interfaces gráficas são compostas de uma janela principal ou de alto-nível, onde são montados os outros componentes. Na Swing essas janelas são geralmente uma instância das classes JFrame ou JWindow. A diferença entre essas duas classes está na simplicidade, JWindow não tem a barra de título e não coloca botões na barra de tarefas, portanto utilizaremos a JFrame.

JFrame é a versão Swing do Frame(AWT) , porém ela é descendente direta da classe Frame, por isso ao adicionarmos componentes ao JFrame teremos que utilizar o JPanel para gerenciar estes componentes .

Características da JFrame: Janela com título, bordas, barra de menu (opcional) e componentes especificados pelo usuário. Esta pode ser movida , ter o tamanho ajustado e permitir a adição de ícones. Veremos a seguir um exemplo de um JFrame.

import javax.swing.*;

public class ExemploJFrame {

private JFrame f;

public ExemploJFrame(){f = new JFrame("Exemplo de JFrame");

}

public void CriaFrame(){f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

f.setSize(300,300);f.setVisible(true);

}

public static void main(String args[]){

ExemploJFrame janela = new ExemploJFrame();janela.CriaFrame();

}

}

Copie o código e salve um um arquivo chamado "ExemploJFrame.java" compile com o comando javac "nome_do_arquivo.java" (sem aspas) e rode com o comando java "nome_do_arquivo" (sem aspas e sem o .java). o resultado esperado é este:

Figura 3 - Exemplo JFrame.Vamos ver o código: para usar os elementos do java swing temos que utilizar o "import javax.swing.*" , em seguida declaramos a classe ExemploJFrame e instanciamos um JFrame chamado de f com o parâmetro que define o título da janela("Exemplo JFrame"), em seguida temos o método construtor da classe, o CriaFrame(), neste método utilizamos 3 setings importantes . O primeiro será utilizado em todos os exemplos do curso e serve para encerrar o programa ou a interface, ao clicarmos no botão fechar da janela. Sem esta linha nada aconteceria ao tentarmos fechar a janela, esta só fecharia ao encerrarmos o programa. O segundo set define o tamanho da tela, neste caso 300 x 300 pixels, mais à frente no curso veremos que em alguns casos não será necessário definir o tamanho da tela, vamos utilizar gerênciadores de layout que ajustam a tela de forma que todos os componentes estejam visíveis. Finalmente o último "set" mostra a janela na tela.

Em Java, a classe Container é a classe abstrata que define as funcionalidades básicas associadas a um container, tais como adicionar e remover componentes, o que é possível através dos métodos add() e remove(), respectivamente. É possível também estabelecer qual a estratégia de disposição de componentes no container, ou seja, qual o método de gerência de layout, através do método setLayout(). Estudaremos layouts na próxima lição.

Agora vamos adicionar um botão ao exemplo anterior, para isso vamos adicionar um botão JButton ao JPanel e o JPanel ao JFrame . Veja o código:


public class Exemplo2fb {

public JFrame f;

public JButton botao;

public JPanel p;

public Exemplo2fb(){

f = new JFrame("Exemplo2 frame com botao ");

botao = new JButton("pressione");

p = new JPanel();

}

public void CriaFrame(){

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

f.setSize(300,300); // tamanho do frame

p.add(botao); // adiciona botao ao JPanel

f.add(p); // adiciona o painel com botão ao frame

f.setVisible(true);

}


Exemplo2fb janela = new Exemplo2fb();

janela.CriaFrame();

}

}

Lembrando que para salvar o arquivo devemos utilizar o mesmo nome da

classe ,ou seja, neste caso seria "Exemplo2fb.java". O resultado do código é:

Figura 4 - JFrame com JPanel e botão.

Agora o aluno deve modificar o código e adicionar o botão diretamente ao frame, retirando as linhas de código relativas ao JPanel. Ao fazer isto podemos verificar que o botão ocupou todo o espaço da janela. Em nenhum momento foi definido o tamanho do botão, então porque ele se comporta de forma diferente quando é adicionado ao JFrame e ao JPanel? A resposta para esta pergunta pode ser encontrada na lição 3 - Gerenciadores de Layout.

Figura 5 - JFrame com Botão

Podemos ver os containers como o cimento das aplicações em Swing eles agrupam os componentes que seriam os tijolos, ou seja para a maioria dos programas é necessario utilizar um container onde serão inseridos os tipos de objetos desejados ou componentes, botões , campos de texto , etc. Por definição, Containers são componentes que podem conter outros componentes. Como exemplo de containers temos JWindow , JFrame e JPanel, porém o JPanel deve ser adicionado a um dos dois anteriores.

Lição 2 - Containers e Componentes

Componentes

Componentes

Os componentes são como tijolos nas aplicações Swing, estes podem ser agrupados em containers para construir uma interface gráfica. Temos uma infinidade de componentes e a maioria deles pode ser configurada de diversas formas o que oferece uma grande flexibilidade no desenvolvimento de interfaces gráficas.

Neste curso veremos apenas os componentes mais básicos, porém conhecendo estes será muito mais fácil utilizar qualquer outro. Os principais componentes são :

JLabel - JLabel é um componente utilizado principalmente para mostrar textos e nomear outros componentes. Se comparado ao Label do AWT, o JLabel tem 3 vantagens importantes: a primeira é que este pode ser utilizado também para mostrar imagens, a segunda é a possibilidade de usar bordas delimitando campos em uma janela. E a terceira é a possibilidade de utilizar HTML para formatar o label, isto é feito adicionando <html> ao início da string do label, assim ele é interpretado como HTML possibilitando mudar fontes, cores dentre outros efeitos. O JLabel pode ter fonte, tamanho e cor configurados, porém se for utilizado o HTML os controles padrões do JLabel serão ignorados.

Vejamos alguns exemplos:


public class ExemploJLabel {public JFrame f;

public JLabel texto;public JLabel texto2;

public JPanel p;

public ExemploJLabel(){

f = new JFrame("Exemplo4 JLabel ");texto = new JLabel("Este texto é um JLabel");

texto2 = new JLabel("ESTE TEXTO TAMBÉM É UM JLABEL");p = new JPanel();

}public void CriaFrame(){

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);f.setSize(300,300);

p.add(texto); p.add(texto2);

f.add(p); f.setVisible(true);

}

public static void main(String args[]){ExemploJLabel janela = new ExemploJLabel();

janela.CriaFrame();}}

Resultado:

Figura 6 - ExemploJLabel

Agora usando HTML, veremos ícones mais a frente em JButons.


import java.awt.*;

public class ExemploJLabel2{

public JFrame f;

public JLabel label;

public JLabel label2;

public JPanel p;

public ExemploJLabel2(){

f = new JFrame("Exemplo5 JLabel ");

label = new JLabel("<html><FONT COLOR=RED><B>JLabel colorido com

HTML</B></FONT></html>");

label.setBorder(BorderFactory.createTitledBorder("JLabel com borda"));

label2 = new JLabel("JLabel comum ");

p = new JPanel();

}

public void CriaFrame(){

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

f.setSize(300,300);

p.setLayout(new BorderLayout());

p.add(label, BorderLayout.NORTH);

p.add(label2, BorderLayout.CENTER);

f.add(p);

f.setVisible(true);

}


ExemploJLabel2 janela = new ExemploJLabel2();

janela.CriaFrame();

}

}

Note que neste caso foi necessário importar o "java.awt" devido ao uso de Layouts. O resultado do exemplo é:

Figura 7 - Exemplo JLabel com HTML

JButton - Botão que pode conter um texto ou um ícone, suas funcionalidades são controladas pelo actionlistener, existem muitas fucionalidades que podem ser atribuídas a um botão, neste curso abordaremos apenas princípios básicos, assim fica a cargo do aluno pesquisar uma funcionalidade específica na documentação da Sun ou nos vários sites sobre Swing na Internet. Uma grande vantagem do swing é que você pode redimensionar e arrastar a janela sem configurar nada e os componentes são reorganizados também de acordo com o layout escolhido.

Exemplo JButton com imagem:

import java.awt.*;import javax.swing.*;

public class Botoes extends JFrame {public static void main(String[] args) {new Botoes();}

public Botoes() {super("Exemplo JButton");JFrame frame= new JFrame();Container content = getContentPane();setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);content.setLayout(new FlowLayout());JButton botao1 = new JButton("Botao normal");content.add(botao1);ImageIcon cdtc = new ImageIcon("f1.png");JButton botao2 = new JButton(cdtc);botao2.setBackground(Color.yellow); // Define a cor de fundo do botão

content.add(botao2); pack(); // monta a janela ajustando o tamanho de acordo com os componentessetVisible(true);}}

Resultado:

Figura 8 - Exemplo JButton

JTextField - JtextField é uma área para texto que pode ser muito útil para formulários. Este componente geralmente é usado combinado com o JLabel que adciona um nome ao campo.

JRadioButton - similar ao JButton, porém esse é usado para marcar 1 ou mais opções dentre as disponíveis.

Exemplo JTextField e JRadioButton :

import java.awt.*;import javax.swing.*;

public class Textfield extends JFrame {public static void main(String[] args) {new Textfield();}

public Textfield() {super("Exemplo JTextField");JFrame frame= new JFrame(); // instancia JFrameContainer content = getContentPane(); // Cria o containersetDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// finaliza programa ao fechar setSize(500,120); // determina o tamanho da janelacontent.setLayout(new BorderLayout());// define o layout do containerJPanel painel1 = new JPanel(); // cria o painel que conterá o label nome e o campo textoFlowLayout layout = new FlowLayout();//instancia o flowlayout para alinhar componenteslayout.setAlignment(FlowLayout.LEFT);// define alinhamento à esquerdapainel1.setLayout(layout); // define o layout do painel1 flowlayout à esquerda.JPanel painel2 = new JPanel();//cria o painel que conterá o label endereço e o textopainel2.setLayout(layout); //define o layout do painel3 flowlayout à esquerdaJPanel painel3 = new JPanel(); //painel3 contem o label sexo e os botoes do tipo radiopainel3.setLayout(layout);

JLabel nome = new JLabel("Nome");//cria um labelpainel1.add(nome); //adiciona o label ao painel 1JTextField nomef = new JTextField(10);painel1.add(nomef); JLabel endereco = new JLabel("Endereço");painel2.add(endereco);JTextField endf = new JTextField(30);painel2.add(endf);JLabel sexo = new JLabel("Sexo:");painel3.add(sexo);JRadioButton masculino = new JRadioButton("Masculino");painel3.add(masculino);JRadioButton fem = new JRadioButton("Feminino");painel3.add(fem);

content.add(painel1, BorderLayout.NORTH); // define o painel1 como parte norte do containercontent.add(painel2, BorderLayout.CENTER);// define o painel2 como parte centro do containercontent.add(painel3, BorderLayout.SOUTH); // define o painel3 como parte sul do containersetVisible(true);}}Resultado:

Figura 9 - JTextField com JRadioButton

JPasswordField - este é o campo utilizado para senhas, sua utilização é idêntica ao do JTextField e o texto digitado aparece como "*" (o caractere que aparece no JPasswordField também pode ser configurado).

JPanel- é container intermediário, pois deve ser adicionado a um outro container(JFrame ou JWindow). É a forma mais simples de se construir uma interface, basta instanciá-lo adicionar os componentes a ele e então adiconar o JPanel a algum container. No exemplo acima utilizamos 3 instâncias do JPanel e adicionamos a cada uma um JLabel e um Componente e em seguida adicionamos cada JPanel a uma área do JFrame.

Uma das razões de se utilizar o JPanel é que Componentes em um JPanel dentro do frame não são reajustados, ou seja, podemos aumentar a janela e o tamanho dos componentes permanecerá o mesmo, o que observamos que não acontece se adicionarmos direto ao JFrame(como visto na primeira página desta lição) .

Lição 3 - Gerenciadores de Layout

Gerenciadores de Layout

Os gerenciadores de Layout são responsáveis por organizar os componentes em um container, não só ao adicionarmos mas também quando redimensionamos as janelas. É possível usar diversos tipos de gerenciadores em uma mesma interface, assim como é possível "desligar" o gerenciador de layout para um dado container e definir manualmente a posição , o tamanho e outras configurações de cada componente adicionando ao container. Cada tipo de container tem um layout padrão, porém freqüentemente temos que mudar o layout do container para obter a disposição dos componentes desejados. Veremos agora as principais características de alguns gerenciadores de layout.

FlowLayout

O gerenciador de layout de “fluxo” apenas posiciona os componentes em fila, um após o outro, cada qual com suas dimensões mínimas. O FlowLayout imita o fluxo de textos e pode alinhar os componentes à direita, à esquerda, ou centraliza-los dentro do container. O uso mais comum deste layout é para preencher uma linha com maior quantidade possível de componentes, por exemplo em barras de ferramentas ou de status.

Figura 10 - Exemplo FlowLayout

Figura 11 - Exemplo FlowLayout redimensionado

BorderLayout

O BorderLayout posiciona os componentes nas “bordas” do container, deixando a maior parte de sua área disponível para o componente inserido no centro. Cada borda é identificada por um ponto cardeal (NORTH,SOUTH, EAST, WEST). Apenas um componente será visível em cada borda, expandindo-se na altura ou largura para ocupar toda a borda do container, porém assumindo o valor mínimo na outra dimensão. O

BorderLayout é o layout padrão do JFrame, por isso, na lição 2 quando adicionamos um botão ao JFrame ele automaticamente ocupou a posição central, como os outros pontos (norte, sul, etc.) não foram utilizados o botão ocupa todo espaço da janela mesmo que ela seja redimensionada. Os pontos norte e sul podem ser reajustados horizontalmente. Os pontos leste e oeste podem ser reajustados verticalmente e o central em todas as direções ( Obs: Experimente adicionar um botão a cada um deles e reajustar a janela). Note que esta disposição reflete o padrão na maioria das aplicações desktop, como processadores de texto ou programas de desenho: uma barra de ferramentas ao norte, uma barra de status ao sul, opcionalmente outras barras de ferramentas ao leste e oeste e uma área de edição ao centro.

import java.awt.BorderLayout;import java.awt.Container;import java.awt.Dimension;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;

public class DemoBorderLayout {public static boolean RIGHT_TO_LEFT = false;

public static void addComponentsToPane(Container pane) {if (!(pane.getLayout() instanceof BorderLayout)) {

pane.add(new JLabel("O Container nÃ£o usa BorderLayout!"));return;

}

if (RIGHT_TO_LEFT) {pane.setComponentOrientation(

java.awt.ComponentOrientation.RIGHT_TO_LEFT);}

JButton button = new JButton("Boatao 1 (PAGINA_INICIAR)");pane.add(button, BorderLayout.PAGE_START);

//Faz a centralização de um grande componente, deste que//tipico do uso de BorderLayout.

button = new JButton("Boatao 2 (CENTRO)");button.setPreferredSize(new Dimension(200, 100));

pane.add(button, BorderLayout.CENTER);

button = new JButton("Boatao 3 (INICIAR_LINHA)");pane.add(button, BorderLayout.LINE_START);

button = new JButton("NOME-LONGO Boatao 4 (FIM_PAGINA)");pane.add(button, BorderLayout.PAGE_END);

button = new JButton("5 (FIM_LINHA)");pane.add(button, BorderLayout.LINE_END);

}/**

* Cria um GUI e o exibe. Para thread safety,* este metodo podera invocar para uma thread

* de disparo de evento(event-dispatching thread).*/

private static void createAndShowGUI() {//Faz com que tenha uma decoracao de janela.JFrame.setDefaultLookAndFeelDecorated(true);

//Cria e organiza a janela.JFrame frame = new JFrame("DemoBorderLayout");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Organiza o conteudo no painel.addComponentsToPane(frame.getContentPane());

//Uso do conteudo do painel por padrÃ£o o BorderLayout. Não é necessario definir

//setLayout(new BorderLayout());

//Exibe janela.frame.pack();

frame.setVisible(true);}

public static void main(String[] args) {//Agenda um trabalho para o event-dispatching thread:

//cria e exibe uma aplicacao GUI.javax.swing.SwingUtilities.invokeLater(new Runnable() {

public void run() {createAndShowGUI();

}});}}

Resultado:

Figura 12 - Exemplo BorderLayout

GridLayout

O GridLayout organiza os componentes em uma “grade” ou tabela com número de linhas e colunas pré-fixado no momento da sua criação. Todas as células possuem o mesmo tamanho e são expandidas igualmente para ocupar a área total disponível no container. Caso haja menos componentes do que células, o espaço das células vazias é distribuído entre os componentes; mas podem ficar células vazias nas últimas colunas da última linha.O GridLayout é adequado quando se deseja que um grupo de componentes (ex: Um grupo de botões) tenha dimensões uniformes, como na caixa de ferramentas de um programa de desenho ou par de botões “OK” e “Cancelar” de um diálogo.

import java.awt.*;


public class DemoGridLayout {

public final static boolean RIGHT_TO_LEFT = false;

public static void addComponentsToPane(Container pane) {

if (RIGHT_TO_LEFT) {

pane.setComponentOrientation(

ComponentOrientation.RIGHT_TO_LEFT);

}

pane.setLayout(new GridLayout(0,2));

pane.add(new JButton("Botoao 1"));



pane.add(new JButton("Botao Nome-Longo 4"));

pane.add(new JButton("5"));

}

/**

* Cria um GUI e o exibe. Para thread safety,

* este metodo podera invocar para uma thread

* de disparo de evento(event-dispatching thread).

*/

private static void createAndShowGUI() {

//Faz com que tenha uma decoracao de janela.

JFrame.setDefaultLookAndFeelDecorated(true);

//Cria e organiza a janela.

JFrame frame = new JFrame("DemoGridLayout");


//Organiza o conteudo no painel.

addComponentsToPane(frame.getContentPane());

//Exibe janela.

frame.pack();

frame.setVisible(true);

}

public static void main(String[] args) {

//Agenda um trabalho para o event-dispatching thread:

//cria e exibe uma aplicacao GUI.

javax.swing.SwingUtilities.invokeLater(new Runnable() {

public void run() {

createAndShowGUI();

}

});

}

}

Resultado:

Figura 13 - Exemplo GridLayout

GridBagLayout

Com nome estranho(“saco de grades”), o GridBagLayout é o mais poderoso e o mais flexível dos gerenciadores fornecidos com o J2EE. Ele imita em linhas gerais o funcionamento de uma tabela HTML, em que um componente pode ocupar várias células, ou seja, se estender por várias colunas e linhas.Os componentes podem ser expandidos para ocupar toda a área das suas células, ou serem alinhados em qualquer posição do conjunto de células. Linhas e colunas assumem as dimensões do maior componente, mas é necessário que tenham todas o mesmo tamanho. E algumas células podem ser configuradas para ocuparem toda a área disponível no container.

Este layout tem como base a utilização de um GridBagConstraints para cada componente inserido. É este objeto que proporcionará a liberdade que queremos com o layout. A GridBagConstraints é uma classe que não possui métodos, ela servirá simplesmente para armazenar as informações para cada componente adicionado. Vamos dar uma olhada nas propriedades da classe:

anchor: Essa propriedade é utilizada somente quando o tamanho do componente é menor que a área que lhe foi concedida. Normalmente, queremos que nosso componente ocupe toda a área disponível, mas em casos especiais, não podemos redimensionar os componentes. Sendo assim, o layout precisa saber em que posição da célula deixará o componente. Os valores para esse campo são de dois tipos: Absolutos (CENTER, NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, e NORTHWEST) e Relativos (PAGE_START, PAGE_END, LINE_START, LINE_END, FIRST_LINE_START, FIRST_LINE_END, LAST_LINE_START and LAST_LINE_END). O valor padrão é CENTER.

fill: Determina como redimensionar o componente. Valores possíveis para esta propriedade são:NONE: Não redimensiona o componente;HORIZONTAL: Redimensiona horizontalmente, fazendo com que o mesmo ocupe toda a área horizontal na célula;VERTICAL: Redimensiona verticalmente, fazendo com que o mesmo ocupe toda a área vertical na célula;BOTH: Redimensiona para ambas as direções.Valor padrão é NONE

gridx e gridy

Especificam a posição X,Y para adicionar o componente. Não é necessário alterar seus valores, pois seu valor padrão é a constante RELATIVE e portanto o layout adicionará após o último componente que foi colocado.

- gridx: Permite especificar qual a posição absoluta horizontalmente que o componente será adicionado;

- gridy: Permite especificar qual a posição absoluta verticalmente que o componente será adicionado.

gridheight e gridwidth

Especificam o tamanho do componente baseado em células. É com essa propriedade que você indicará que um componente seu ocupará duas células ou ocupurá tantas quanto forem necessárias para ir até o final da tela. Lembrem-se é células e não pixels.

Nestes valores podem ser utilizadas duas constantes: REMAINDER e RELATIVE. REMAINER fará com que o componente se estique até a última célula. Já o RELATIVE fará com que o componente ocupe todas as casas com excessão da última.- gridheight: Especifica o número de células que o componente ocupará verticalmente. Valor padrão é 1;- gridwidth: Especifica o número de células que o componente ocupará horizontalmente. Valor padrão é 1.

insets

Indica as distâncias entre os componentes do layout. Um Insets possui valores para as 4 direções, cima, baixo, direita e esquerda. Permitindo com isso muita flexibilidade no gerenciador. Valor padrão é new Insets(0, 0, 0, 0).

weight

Essas propriedades especificam um percentual de crescimento da célula, não do componente, quando a mesma precisa ser redimensionada. É dito isso, porque se o componente não pode se redimensionar, pois a propriedade fill do constraint afirma isso, o componente não vai sofrer as alterações, mas a célula irá aumentar.Com este layout é possível informar que uma célula redimensionará 75% e o outra 25%, portanto, o primeiro componente receberá 3 vezes mais tamanho do que o segundo.

O valor padrão é 0 e os valores percentuais são dados em casas decimais, por exemplo: 0.03 é igual a 3%, 1.00 é igual a 100% e por aí vai.- weightx: Peso em x. Especifica um peso no redimensionamento. Este peso será utilizado para um cálculo que o layout faz para determinar quais as células irão redimensionar horizontalmente, quais não irão e quais aumentarão mais que as outras.

- weighty: Peso em y. Especifica um peso no redimensionamento. Este peso será utilizado para um cálculo que o layout faz para determinar quais as células irão redimensionar verticalmente, quais não irão e quais aumentarão mais que as outras.

ipadx e ipady

Determina um adicional nas bordas internas do componenete. Essa propriedade modifica o tamanho mínimo de cada componente. O tamanho mínimo será o ipad + o valor mínimo do componente.- ipadx: Valor para ser adicionado horizontalmente.- ipady: Valor para ser adicionado verticalmente.

Podemos afirmar com segurança que qualquer disposição de componentes pode ser configurada em um GridBagLayout. Por outro lado, a quantidade de constraints(propriedades e restrições de layout) possível para cada componente também deu a este gerenciador a fama de ser difícil de programar.

import java.awt.*;import javax.swing.JButton;import javax.swing.JFrame;

public class DemoGridBagLayout {final static boolean shouldFill = true;

final static boolean shouldWeightX = true;final static boolean RIGHT_TO_LEFT = false;

public static void addComponentsToPane(Container pane) {if (RIGHT_TO_LEFT) {

pane.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);

}

JButton button;pane.setLayout(new GridBagLayout());

GridBagConstraints c = new GridBagConstraints();if (shouldFill) {

//altura natural, largura maxima.c.fill = GridBagConstraints.HORIZONTAL;

}

button = new JButton("Botao 1");if (shouldWeightX) {c.weightx = 0.5;

}c.gridx = 0;c.gridy = 0;

pane.add(button, c);

button = new JButton("Botao 2");c.gridx = 1;c.gridy = 0;


button = new JButton("Botao 3");c.gridx = 2;c.gridy = 0;


button = new JButton("Botao 4 - Nome-Longo");c.ipady = 40; //faz o componente no alto.

c.weightx = 0.0;c.gridwidth = 3;c.gridx = 0;c.gridy = 1;


button = new JButton("5");c.ipady = 0; //esvazia por padrao

c.weighty = 1.0; //requisita um espaco vertical extra.c.anchor = GridBagConstraints.PAGE_END; //espaco em

baixo.c.insets = new Insets(10,0,0,0); //top padding

c.gridx = 1; //alinhamento do botao 2.c.gridwidth = 2; //2 colunas largas.

c.gridy = 2; //terceira linha.pane.add(button, c);

}

/*** Cria um GUI e o exibe. Para thread safety,* este metodo podera invocar para uma thread

* de disparo de evento(event-dispatching thread).*/

private static void createAndShowGUI() {//Faz com que tenha uma decoracao de janela.JFrame.setDefaultLookAndFeelDecorated(true);

//Cria e organiza a janela.JFrame frame = new JFrame("DemoGridBagLayout");


//Organiza o conteudo no painel.addComponentsToPane(frame.getContentPane());

//Exibe janela.frame.pack();

frame.setVisible(true);

}

public static void main(String[] args) {//Agenda um trabalho para o event-dispatching thread:

//cria e exibe uma aplicacao GUI.javax.swing.SwingUtilities.invokeLater(new Runnable() {

public void run() {createAndShowGUI();

}});}}

Resultado:

Figura 14 - Exemplo GridBagLayout

Lição 4 - Manipulando Ações Básicas

Manipulando Ações Básicas

Agora que você já aprendeu como colocar componentes na tela, você vai saber como responder as ações do usuário com os componentes. O

principal mecanismo para isso é o padrão Observer, implementado em Swing com os "event listeners"(ou observadores de eventos). Os

componentes emitem notificações sobre eventos e o event listener recebe essas notificações. Por exemplo, para executar um código quando o usuário

aperta um botão, você deve definir um listener para o evento "pressionar botão" e ligar o evento a esse botão.

import java.awt .*;import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;import javax.swing .*;

public class MainFrame extends JFrame

{

public static void main(String[] args) {new MainFrame();

}

public MainFrame ()

{

super ( "Exemplo ActionListener");

setSize (300,300);

setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);

Container content = getContentPane ();

content.setLayout (new BorderLayout ());

JPanel painel = new JPanel (new FlowLayout ());

JButton botao1 = new JButton ( "Botao 1");

painel.add (botao1);

botao1.addActionListener (new MyButtonListener (this));

painel.add (new JButton ( "Botao 2"));

painel.add (new JButton ( "Botao 3"));

content.add (painel, BorderLayout.SOUTH);

content.add (new JScrollPane (new JTextArea ()), BorderLayout.CENTER);

painel = new JPanel (new FlowLayout ());

painel.add (new JLabel ( "Digite seu nome"));

painel.add (new JTextField (10));

String opcoes[] = new String[]{ "Opção 1", "Opção 2", "Opção 3"};

painel.add(new JComboBox (opcoes));

content.add (painel, BorderLayout.NORTH);

pack();

setVisible(true);

}

private class MyButtonListener implements

ActionListener

{

private JFrame parentComponent;

MyButtonListener (JFrame parentComponent)

{

this.parentComponent = parentComponent;

}

public void actionPerformed (ActionEvent e)

{

JOptionPane.showMessageDialog (parentComponent, "BOTÃO 1 PRESSIONADO!");

}

}

}

Resultado:

Figura 15 - Exemplo ActionListener

Figura 16 - Exemplo botão pressionado Neste exemplo, nós criamos um ActionListener e ligamos apenas ao botão1. A interface do ActionListener tem apenas um método: actionPerformed. Esse método é chamado quando uma ação ocorre. O evento ActionEvent é o tipo mais comum em Swing - a maioria dos componentes produzem um ActionEvent. Componentes podem também produzir outros eventos - como a mudança da seleção atual, texto ou

tamanho. Por enquanto, o nosso foco é no ActionEvent. Em todo o caso, procure ,em uma IDE que exibe métodos de uma classe, por métodos que começam com add e terminam com Listener (por exemplo, addFocusListener) para ver que tipos de event/Listener um componente suporta.

Mais uma coisa interessante neste exemplo é a utilização da classe JOptionPane. Essa classe contém muitos métodos úteis que ajudam na exibição padronizada de diálogos entradas e diálogos de mensagem.

O exemplo acima não está escrito no estilo usual para Swing. Já que a única fução do listener é chamar um método, ele é freqüentemente escrito como uma classe interna anónima (inner class).

Botao1.addActionListener (

new ActionListener ()

{

Público void actionPerformed (ActionEvent e)

{

JOptionPane.showMessageDialog(MainFrame.this,"BOTÃOPRESSIONADO!");

}

});

Podemos observar que existem também outras formas de receber notificações eventos e, em seguida, instalar um listener para cada objeto na tela. Por exemplo, o código abaixo instala um listener global para pressionar

a tecla F1:

KeyStroke ks=KeyStroke.getKeyStroke(KeyEvent.VK_F1,0);

topComponent.getInputMap ( JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ks,

"HELP");

topComponent.getActionMap().put("HELP",new AbstractAction()

{public void actionPerformed(ActionEvent evt)

{// coloque um diálogo ou mensagem aqui

}});

Este curso abordou apenas alguns tópicos do Java Swing já que qualquer abordagem profunda de qualquer tópico da linguagem Java se torna muito

extensa.

Parte deste curso foi retirada do site www.javanoroeste.com.br/2006/tutoriais/swing_basico.html (tutorial escrito por Marli Esprega Gonçalves)

Documents

Java Swing