Você está na página 1de 17

AULA TEÓRICA 10

Tema 9. Gestão de eventos (continuação)


Ø  Paineis

Tema 10. Menus e Tabelas


Ø  Menus com frames
Ø  Criação de tabela

1
Painéis

As GUIs complexas (por exemplo, um janela de Internet Explorer) exigem que


cada componente seja colocado numa posição exacta.
Elas consistem, com frequência, em múltiplos painéis com os componentes de
cada painel organizados num layout específico.
Os painéis são criados com a classe JPanel – uma subclasse de
JComponent. A classe JComponent herda da classe
java.awt.Container, de modo que cada JPanel é um Container.
Assim, JPanel podem ter componentes, incluindo outros painéis, adicionando
a eles.
O programa a seguir demonstra como se pode utilizar um JPanel para criar
um layout mais complexo para Component.
import java.awt.*; //sem eventos
import javax.swing.*;
public class ExemploPanel extends JFrame
{ private JPanel buttonPanel;
private JButton buttons[];
private Container c;
public ExemploPanel ()
{ super("Panel Demo");
c = getContentPane();
buttons = new JButton[5];
buttonPanel = new JPanel();
buttonPanel.setLayout(new GridLayout(1, buttons.length));
// cria e adiciona botoes
for (int count = 0; count < buttons.length; count++)
{ buttons[count] = new JButton("Button "+(count+1));
buttonPanel.add(buttons[count]);
}
c.add(buttonPanel, BorderLayout.SOUTH);
setSize(425,150);
setVisible(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String args[])
{ ExemploPanel x = new ExemploPanel(); }
}
Depois que JPanel buttonPanel é criado, configura se o layout do
buttonPanel como um GridLayout de 1 linha e 5 colunas (há 5
JButtons no array). Os 5 JButtons são adicionados ao JPanel através
do ciclo for.

Repare que os botões são adicionados directamente ao JPanel – a classe


JPanel não tem um painel de conteúdo, BorderLayout, para adicionar
buttonPanel à região SOUTH. Observe que a região SOUTH é tão alta
quanto os botões no buttonPanel. O JPanel é dimensionado de acordo
com os componentes que ele contém.

À medida que mais componentes são adicionados, o JPanel cresce (de


acordo com as restrições de seu gestor de layout) para acomodar os
componentes. Redimensione a janela para ver como o gestor de layout
afecta o tamanho dos JButton.

JPanel não suportam eventos convencionais como botões, campos de


texto e janelas, mas suportam eventos de mouse e teclado.
Menus com frames
Os menus são uma parte integrante das GUIs e permitem ao utilizador realizar
acções sem “poluir” desnecessariamente uma interface gráfica com
componentes GUI em excesso. Em GUIs do Swing, os menus podem ser
anexados somente aos objectos das classes que fornecem o método
setMenuBar. Duas dessas classes são JFrame e JApplet. As classes
utilizadas para definir menus são JMenuBar, JMenuItem, JMenu,
JCheckBoxMenuItem e JRadioButtonMenuItem.

O exemplo a seguir demonstra vários tipos de itens de menu. As mnemónicas


podem ser utilizados com objectos de todas as classes que sejam subclasses
de javax.swing.AbstractButton.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MenuTest extends JFrame
{ private Color colorValues[]={Color.black,Color.blue,Color.red,
Color.green};
private JRadioButtonMenuItem colorItems[],fonts[];
private JCheckBoxMenuItem styleItems[];
private JLabel displayLabel;
private ButtonGroup fontGroup, colorGroup;
private int style;
public MenuTest()
{ super("Usando JMenu");
// define File menu e itens do menu
JMenu fileMenu = new JMenu("File");
fileMenu.setMnemonic('F');
// define About... menu item
JMenuItem aboutItem = new JMenuItem("About..." );
aboutItem.setMnemonic('A');
aboutItem.addActionListener(
//classe interna anonima para tratar evento de item About...
new ActionListener()
// visualiza message dialog quando o utilizador selecciona
item About...
{ public void actionPerformed(ActionEvent event)
{ JOptionPane.showMessageDialog(MenuTest.this,
"Isso é um exemplo\nde uso de menu","About",
JOptionPane.PLAIN_MESSAGE);
}
} // fim da classe interna anonima
); // fim da chamada de addActionListener
fileMenu.add(aboutItem);

// define Exit menu item


JMenuItem exitItem = new JMenuItem("Exit");
exitItem.setMnemonic('x');
exitItem.addActionListener(
// classe interna anonima para tratar evento de item exitItem
new ActionListener()
{ public void actionPerformed(ActionEvent event)
{ System.exit( 0 ); }
} // fim da classe interna anonima
); // fim da chamada de addActionListener
fileMenu.add(exitItem);
// cria bara de menu e anexa a janela MenuTest
JMenuBar bar = new JMenuBar();
setJMenuBar(bar);
bar.add(fileMenu);
// cria Format menu, com submenus e itens do menu
JMenu formatMenu = new JMenu("Format");
formatMenu.setMnemonic('r');

// cria Color submenu


String colors[] = {"Black", "Blue", "Red", "Green"};
JMenu colorMenu = new JMenu("Color");
colorMenu.setMnemonic('C');
colorItems = new JRadioButtonMenuItem[colors.length];
colorGroup = new ButtonGroup();
TrataEv tr = new TrataEv();
// cria radio button do menu Color
for (int count = 0; count < colors.length; count++)
{ colorItems[count]= new JRadioButtonMenuItem(colors[count]);
colorMenu.add(colorItems[count]);
colorGroup.add(colorItems[count]);
colorItems[count].addActionListener(tr);
}
// activa 1-o item do menu Color
colorItems[0].setSelected(true);

// adiciona format menu à bara de menu


formatMenu.add(colorMenu);
formatMenu.addSeparator();
// cria Font submenu
String fontNames[] = {"Serif","Monospaced","SansSerif"};
JMenu fontMenu = new JMenu("Font");
fontMenu.setMnemonic('n');
fonts = new JRadioButtonMenuItem[fontNames.length];
fontGroup = new ButtonGroup();
// cria Font radio button menu itens
for (int count = 0; count < fonts.length; count++)
{ fonts[count]=new JRadioButtonMenuItem(fontNames[count]);
fontMenu.add(fonts[count]);
fontGroup.add(fonts[count]);
fonts[count].addActionListener(tr);
}
fonts[0].setSelected(true); //seleciona 1-o item do menu Font
fontMenu.addSeparator();
String styleNames[] = {"Bold", "Italic"};
styleItems = new JCheckBoxMenuItem[styleNames.length];
StyleHandler styleHandler = new StyleHandler();
// cria itens de estilos com checkbox menu
for ( int cnt = 0; cnt < styleNames.length; cnt++ )
{ styleItems[cnt]= new JCheckBoxMenuItem(styleNames[cnt]);
fontMenu.add(styleItems[cnt]);
styleItems[cnt].addItemListener(styleHandler);
}
formatMenu.add(fontMenu);
// adiciona Format menu à bara de menu
bar.add(formatMenu);

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


displayLabel.setForeground(colorValues[0]);
displayLabel.setFont(new Font("TimesRoman",Font.PLAIN,72));
getContentPane().setBackground(Color.cyan);
getContentPane().add(displayLabel,BorderLayout.CENTER);
setSize(500, 200);
setVisible(true);
}

//classe interna para cores


private class TrataEv implements ActionListener
{ public void actionPerformed(ActionEvent event)
{ // process color selection
for (int count = 0; count < colorItems.length; count++ )
if (colorItems[count].isSelected())
{ displayLabel.setForeground( colorValues[count]);
break;
}
// processa selecção da fonte
for (int k = 0; k < fonts.length; k++ )
if (event.getSource() == fonts[k])
{ displayLabel.setFont(new Font(fonts[k].getText(),
style,72)); break; }
repaint();
}
}
// classe interna para fontes
private class StyleHandler implements ItemListener
{ public void itemStateChanged(ItemEvent e)
{ style = 0;
if (styleItems[0].isSelected())
style += Font.BOLD;
if (styleItems[1].isSelected())
style += Font.ITALIC;
displayLabel.setFont(new Font(displayLabel.
getFont().getName(),style,72));
repaint();
}
}
public static void main( String args[])
{ MenuTest ap = new MenuTest();
ap.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}}
Muitos aplicativos actuais utilizam interface de múltiplos documentos (MDI –
multiple document interface) para gerir vários documentos abertos que estão
sendo processados em paralelo. As classes JDesktopPane e
JInternalFrame do Swing fornecem suporte para criar interfaces de
documentos múltiplos.
Criação de Tabela
O exemplo a seguir apresenta a criação e preenchimento de tabela com dados
do Vector criado a partir de leitura de ficheiro do tipo texto.

public class UmProd


{ private String artigo;
private float preco;
private int quant;
public UmProd(String artigo,int quant,float preco)
{ this.artigo = artigo;
this.quant = quant;
this.preco = preco;
}
public UmProd() {this("",0,0); }
public void setArtigo(String artigo) {this.artigo = artigo; }
public void setQuant(int quant) {this.quant = quant; }
public void setPreco(float preco) {this.preco=preco; }
public String getArtigo() {return artigo;}
public int getQuant() {return quant;}
public float getPreco() {return preco;}
}
==============================================================
import java.awt.*;
import javax.swing.*;
import java.io.*;
import java.util.*;
public class TabelaVector extends JFrame
{ private JTable tab;
private JScrollPane scrl;
private String titulos[] = {"Artigo","Preço","Quantidade",
"Total"};
private String[][] tabDados;
private UmProd pro;
private Container cont;
private Vector v;
//Construtor
public TabelaVector()
{ super("Preenchimento de tabela");
pro = new UmProd();
v = new Vector();
lerDoFichTxt();
tabDados = getDados(v.size());
tab = new JTable(tabDados,titulos);
cont = getContentPane();
scrl = new JScrollPane(tab);
cont.add(scrl, BorderLayout.CENTER);
setSize(300,120);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}

public void lerDoFichTxt()


{ StringTokenizer umaCadeia;
String umaLinha,art,nomeFich = "Dados.txt";
int qua; float prec;
try
{ FileReader fread = new FileReader (nomeFich);
BufferedReader inFile = new BufferedReader (fread);
umaLinha = inFile.readLine();
while (umaLinha != null)
{ umaCadeia = new StringTokenizer (umaLinha,";");
art = umaCadeia.nextToken();
qua = Integer.parseInt(umaCadeia.nextToken());
prec = Float.parseFloat(umaCadeia.nextToken());
pro = new UmProd();
pro.setArtigo(art);
pro.setQuant(qua);
pro.setPreco(prec);
v.addElement(pro); //adiciona um objecto no vector
umaLinha = inFile.readLine();
} //fim do ciclo while
inFile.close();
}
catch (FileNotFoundException exception)
{ System.out.println("Ficheiro "+nomeFich+
" nao encontrado!"); }
catch (IOException exception)
{ System.out.println(exception.getMessage()); }
}
//Método que preenche a tabela com os dados do vector
public String[][] getDados(int linhas)
{ String[][] x = new String[linhas][titulos.length];
for(int i=0; i<linhas; i++)
{ pro = (UmProd)v.elementAt(i);
x[i][0]= pro.getArtigo();
x[i][1]= pro.getQuant()+"";
x[i][2]= pro.getPreco()+"";
x[i][3]= pro.getQuant()*pro.getPreco()+"";
}
return x;
}
public static void main(String[] args)
{ TabelaVector tb = new TabelaVector(); }
}
Referência bibliográfica:
António José Mendes; Maria José Marcelino.
“Fundamentos de programação em Java 2”. FCA. 2002.
Elliot Koffman; Ursula Wolz.
“Problem Solving with Java”. 1999.
F. Mário Martins;
“Programação Orientada aos objectos em Java 2”, FCA, 2000,
John Lewis, William Loftus;
“Java Software Solutions: foundation of program design”, 2nd edition, Addision-Wesley

John R. Hubbard.
“Theory and problems of programming with Java”. Schaum’s Outline series. McGraw-Hill.
H. Deitel; P. Deitel.
“Java, como programar”. 4 edição. 2003. Bookman.
Rui Rossi dos Santos.
“Programando em Java 2– Teoria e aplicações”. Axcel Books. 2004

17