Sunteți pe pagina 1din 24

Disciplina: Metode avansate de programare

Cadru didactic: Ralf Fabian


Specializarea: Informatică, anul II.

Componente GUI

1. BARA DE MENIU
1.1 CREAREA UNUI MENIU
1.2. SUBMENIURI
1.3. PICTOGRAME ÎN MENIURI
1.4. MNEMONICE
1.5. ACCELERATORI DE TASTATURĂ
1.6. TRATAREA EVENIMENTELOR LA MENIURI
2. BARA DE INSTRUMENTE
3. DIALOGURI
3.1. JOPTIONPANE
3.1.1 Message Dialog
3.1.2 Confirmation Dialog
3.1.3 Input Dialog
3.1.4 Option Dialog
3.2. JFILECHOOSER
4. COMPONENTE TEXT
4.1 JTEXTFIELD ŞI JPASSWORDFIELD
4.2 JTEXTAREA
4.3 JTEXTPANE
5. JPROGRESSBAR
6. TABBEDPANES
CREAREA UNUI “TABBED PANE”
ADĂUGAREA ŞI INSERAREA DE PAGINI
ŞTERGEREA PAGINILOR
SELECTAREA PAGINILOR

1
1. Bara de meniu
Meniurile sunt elemente fundamentale în dezvoltare interfeţelor grafice. Rolul lor este de a pune la
dispoziţie un set de operaţii accesibile prin interfaţa grafică, fără a ocupa spaţiu permanent în zona
principală de lucru. Componentele din meniuri devin vizibile doar în momentul în care utilizatorul
le accesează prin selectarea meniului. Operaţiile pot fi grupate în meniuri, care la rândul lor pot
avea mai multe submeniuri, etc.
Crearea unei bare de meniu cu SWING implică utilizarea a cel puţin trei clase: JMenuBar, JMenu,
JMenuItem. Un meniu poate fi utilizat doar în clase care au metoda setMenuBar (cum ar fi JFrame
sau JApplet).

Clasa JMenuBar este o subclasă a clasei JComponent şi conţine metodele de gestionare a barei de
meniuri. Ea este folosite doar ca container pentru meniuri.
Componentelor de tip JMenu, JMenuItem, JCheckBoxMenuItem, şi JRadioButtonMenuItem li se
poate asociat o pictogramă (icon) şi o mnemonică.

1.1 Crearea unui meniu


Întregul proces de creare a unui meniu poate fi descris, în linii mari, prin următorii paşi:

1. Crearea şi adăugarea unei bare de meniu la o fereastră

Un meniu nou se creează prin apelul constructorului clasei JMenuBar fără nici un argument.
Ulterior acesta se adaugă la fereastră prin metoda setMenuBar având ca argument obiectul
JMenuBar.

JFrame frame = new JFrame();


frame.setSize(200, 200);
frame.setVisible(true);
JMenuBar mb = new JMenuBar(); // creează bara de meniu
frame.setJMenuBar(mb); // adaugă bara de meniu la fereastră

În acest moment, bara de meniu nu este vizibilă întrucât nu conţine nici un meniu.

2. Crearea şi adăugarea de meniuri

Un meniu se creează prin apelul constructorului clasei JMenu având ca argument un String cu
numele meniului.

JMenu mFile = new JMenu("File");


JMenu mView = new JMenu("View");
JMenu mHelp = new JMenu("Help");

Aceste meniuri nu sunt vizibile până ce nu se adaugă cu metoda add la instanţa clasei JMenuBar.

mb.add(mFile);
mb.add(mView);
mb.add(mHelp);

3. Crearea şi adăugarea unui elementelor de meniu (meniu items)

2
Un element de meniu este o componentă GUI care odată selectată produce o acţiune.
Comportamentul este aproape identic cu cel al unui buton. Pe lângă iniţierea unei acţiuni, elementul
de meniu poate fi folosit şi la creare de submeniuri. Principalele clase de acest tip sunt:

 JMenuItem – este o subclasă a clasei javax.swing.AbstractButton şi conţine toate


metodele pentru gestionarea unui element de meniu.
 JCheckBoxMenuItem – este o subclasă a clasei JMenuItem şi furnizează o componentă de
meniu gen CheckBox, care are 2 stări: activat sau dezactivat.
 JRadioButtonMenuItem – este o subclasă a clasei JMenuItem şi furnizează componentă
de meniu gen RadioButton, cu 2 stări: activat sau dezactivat.

Pentru excluderea mutuală a selecţilor la grupuri de elemente de tip JCheckBoxMenuItem şi


JRadioButtonMenuItem poate fi folosită clasa ButtonGroup.

Codul pentru crearea şi adăugarea de intrări dintr-un meniu este de forma:

JMenuItem miNew = new JMenuItem("New");


JMenuItem miOpen = new JMenuItem("Open…");
mFile.add(miNew);
mFile.add(miOpen);

sau mai scurt

mFile.add(new JMenuItem("New"));
mFile.add(new JMenuItem("Open…"));

Vizuală, separarea logică a elementelor cu scopuri apropiate dintr-un meniu, se poate face prin
inserarea unui separator sub formă de line orizontală. Metoda addSeparator() adaugă bara de
separare în meniu.

mFile.add(miNew);
mFile.add(miOpen);
mFile.addSeparator();
mFile.add(miSave);
mFile.add(miSaveAs);
mFile.addSeparator();
mFile.add(miExit);

Rezultatul poate fi văzut în figura de mai jos.

3
1.2. Submeniuri
Un meniu poate fi integrat într-un alt meniu obţinându-se astfel un submeniu. Submeniurile sunt
utile la grupare elementelor de meniu care au scopuri apropiate. De exemplu, următorul cod
construieşte submeniul Font Color cu trei elemente în meniul principal View.

mView=new JMenu("View");
JMenu submViewFontColor=new JMenu("Font Color");
submViewFontColor.add(new JCheckBoxMenuItem("Red"));
submViewFontColor.add(new JCheckBoxMenuItem("Black"));
submViewFontColor.add(new JCheckBoxMenuItem("Green"));
mView.add(submViewFontColor);

1.3. Pictograme în meniuri


La componentele de tip JMenu, JMenuItem, JCheckBoxMenuItem, şi JRadioButtonMenuItem
se poate adăuga o pictogramă. În acest scop se foloseşte metoda

public void setIcon(Icon defaultIcon)

Ca argument nu se poate folosi direct un obiect de tip Icon întrucât Icon este o interfaţă. O clasă
care implementează interfaţa Icon este ImageIcon. Constructorii clasei ImageIcon permit mai
multe variante de construire, printre care

public ImageIcon(String filename)

construieşte un obiect nou pe baza numelui unui fişier de imagine. Clasa ImageIcon poate să
lucreze cu fişiere de tip .png, .jpg şi .gif. Imaginile construire cu ImageIcon se încarcă direct în
memorie spre deosebire de modul de lucru a clasei Image.

Un apel care adaugă în acest mod o pictogramă la un element de meniu arată astfel:

miNew.setIcon(new ImageIcon("images/file.png"));

Alternativ, pictograma poate fi adăugată şi imediat la crearea unui MenuItem:

JMenuItem miNew = new JMenuItem("New", new ImageIcon("images/file.png"));

Implicit, pictogramele sunt poziţionate în partea stângă a textului din meniuri. Pentru a inversa
această ordine se apelează

miNew.setHorizontalTextPosition(SwingConstants.LEFT);

4
1.4. Mnemonice
Mnemonica la nivel de componenta grafică, reprezintă cheia care în combinaţie cu tasta Alt va
activa butonul sau elementul de meniu asociat, dacă focusul este deţinut de containerul care le
conţine. Ea trebuie să corespundă unei singure chei de tastatură şi poate fi specificată prin codurile
tastelor virtuale definite în clasa KeyEvent (de exemplu pentru tasta „S‟ codul este VK_S accesat
prin KeyEvent.VK_S). Mnemonicele sunt case-insensitiv, ceea ce înseamnă că nu sunt
condiţionate de apăsarea tastei Shift. Prima apariţie a cheii specificate în textul etichetă de pe
buton sau MenuItem, va fi subliniat şi reprezintă mnemonica.

Metodele pentru setarea mnemonicii sunt:


 public void setMnemonic(int mnemonic) – argumentul fiind constanta de tip întreg
a unei chei de tasta, definită în clasa KeyEvent.
 public void setMnemonic(char mnemonic) – aici argumentul poate fi un caracter
între „a‟ şi ‟z‟ sau între ‟A‟ şi ‟Z‟.

În cod, un apel este atunci de forma:

JMenuItem miSave = new JMenuItem("Save");


miSave. setMnemonic(java.awt.event.KeyEvent.VK_S);

sau

miSave. setMnemonic(„S‟);

În cazul elementelor de tip JMenuItem, mnemonica poate fi specificată şi direct la instanţiere ca


argument al constructorului, astfel:

JMenuItem miSave = new JMenuItem("Save", java.awt.event.KeyEvent.VK_S);

1.5. Acceleratori de tastatură


Spre deosebire de mnemonice, acceleratorii permit selectarea directă a unui element de meniu prin
apăsarea tastei CTRL + o tastă accelerator. De exemplu, pentru deschidere unui fişier nou, o
variantă des utilizată de shortcut este CTRL+O. Ca metodă avem:

public void setAccelerator(KeyStroke keyStroke)

5
Argumentul de tip KeyStroke reprezintă o combinaţie de taste care deserveşte drept accelerator.
Obiectul se obţine prin apelul metodei statică getKeyStroke din clasa KeyStroke în felul
următor:

KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK)

Combinând acest apel cu metoda setAccelerator putem specifica acceleratorul pentru un item
de meniu pe o singură line:

miOpen.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,
ActionEvent.CTRL_MASK));

Acceleratorii funcţionează indiferent dacă elementul din meniu este vizibil sau nu la momentul
apelării. O dată setat, combinaţia de taste va fi vizibilă şi în dreptul itemului de meniu respectiv.

1.6. Tratarea evenimentelor la meniuri


Elementele de meniu generează evenimente de tip ActionEvent, ca urmare trebuie implementat
un ActionListener cu handlerul actionPerformed pentru a răspunde la alegerea comenzii din
meniu.

OBS: De regulă o bară de meniu se adaugă cu ajutorul metodei setMenuBar la o fereastra, dar
întrucât ea este şi de tip JComponent, poate fi plasată şi utilizată ca orice altă componentă grafică.

OBS: Teoretic, orice componentă GUI, adică orice obiect care moşteneşte clasa JComponent,
poate fi adăugat la un JMenu sau JMenuBar.

2. Bara de instrumente
În interfeţe grafice, bara de instrumente este folosită pentru a permite acces mai rapid la
comenzile des utilizate din meniurile unei aplicaţii.
Clasa JToolBar este containerul Swing care gestionează componentele unei bare de
instrumente. De regulă, ea conţine pictograme amplasate pe o componentă de tip buton, dar poate
cuprinde teoretic şi orice obiect de tip Component.
Adăugarea la o fereastră se face ca pentru orice altă componentă, specificând în
BorderLayout-ul ferestrei zona în care să apară.

// construirea barei de instrumente


btNew=new JButton(new ImageIcon("images/file.png"));
btOpen=new JButton(new ImageIcon("images/open.png"));
btSave=new JButton(new ImageIcon("images/save.png"));

JToolBar toolBar=new JToolBar();


toolBar.setFloatable(true);

toolBar.add(btNew);
toolBar.add(btOpen);
toolBar.add(btSave);

btNew.setToolTipText("New");
btOpen.setToolTipText("Open");
btSave.setToolTipText("Save");

btNew.setBorderPainted(false);
btOpen.setBorderPainted(false);

6
btSave.setBorderPainted(false);

getContentPane().add(toolBar,BorderLayout.NORTH);

7
3. Dialoguri
O fereastră de dialog este o fereastră folosită temporar pentru a cere un input suplimentar de la
utilizator sau pentru a afişa o informaţie despre un eveniment petrecut. Din clasa de bază a
dialogurilor, JDialog, pot fi construite prin moştenire ferestre de dialog particularizate. Un set de
dialoguri standard sunt implementate de clasa JOptionPane. Alte 2 clase de dialoguri importante
sunt JFileChooser – pentru selecţie de fişier şi JColorChooser – pentru selecţie de culoare.

3.1. JOptionPane
Această clasă pune la dispoziţie 5 tipuri de dialoguri standard, care pot fi utilizate prin apelul
metodelor statice de forma showNumeDialog. Toate dialogurile din această clasă sunt modale, asta
înseamnă că nici o altă fereastră a aplicaţiei poate fi accesată atâta tip cât este afişat dialogul.

 Message Dialog – afişează un mesaj cu buton de OK pentru terminarea dialogului.


 Confirmation Dialog – afişează o întrebare şi permite confinarea prin butoane gen OK şi
CANCEL.
 Input Dialog – afişează o întrebare şi aşteaptă răspunsul utilizatorului printr-un control de
tip JTextField, JComboBox sau JList.
 Option Dialog – afişează o întrebare şi aşteaptă răspunsul utilizatorului dintr-un set de
opţiuni.

3.1.1 Message Dialog

Metodele de crearea a acestui tip de dialog sunt:

public static void showMessageDialog(Component parentComponent,


Object message)
public static void showMessageDialog(Component parentComponent,
Object message,
String title,
int messageType)
public static void showMessageDialog(Component parentComponent,
Object message,
String title,
int messageType,
Icon icon)
Parametrii care pot fi folosiţi au următoarele semnificaţii:
 parentContent – poate fi orice obiect sau null.
 message – este mesajul care va fi afişat şi poate fi un obiect de orice tip. De regulă se
foloseşte un şir de text (String). Dacă este un obiect cu reprezentare grafica, atunci fa fi
afişat ca atare, altfel se foloseşte reprezentarea lui textuală (adică ceea ce returnează metoda
toString a obiectului).
 title – şirul de text afişat în bara de titlu a dialogului.
 messageType – o constantă care indică tipul mesajului. Ea poate fi:
- JOptionPane.ERROR_MESSAGE
- JOptionPane.INFORMATION_MESSAGE
- JOptionPane.PLAIN_MESSAGE
- JOptionPane.WARNING_MESSAGE
- JOptionPane.QUESTION_MESSAGE

8
Pentru crearea unui MessageDialog folosim un ape de forma:

JOptionPane.showMessageDialog(null, "File not found",


"Important Information", JOptionPane.INFORMATION_MESSAGE);

3.1.2 Confirmation Dialog

Spre deosebire de dialogul de mesaj, la dialogul de confirmare se returnează o valoare în funcţie de


butonul apăsat din dialog. Metodele de crearea a mesajelor de confirmare sunt:

public static int showConfirmDialog(Component parentComponent,


Object message)
public static int showConfirmDialog(Component parentComponent,
Object message,
String title,
int optionType)
public static int showConfirmDialog(Component parentComponent,
Object message,
String title,
int optionType,
int messageType)
public static int showConfirmDialog(Component parentComponent,
Object message,
String title,
int optionType,
int messageType,
Icon icon)

Înţelesul parametrilor este acelaşi ca la dialogul de mesaj, doar unul este în plus:
 optionType – specifică ce butoane sunt afişate în dialog şi poate avea ca valori:
- JOptionPane.YES_NO_OPTION
- JOptionPane.YES_NO_CANCEL_OPTION
- JOptionPane.OK_CANCEL_OPTION

Valoarea returnată în urma închiderii este de tip int şi poate avea una din următoarele valori
constante predefinite:

9
JOptionPane.YES_OPTION
JOptionPane.NO_OPTION
JOptionPane.CANCEL_OPTION
JOptionPane.OK_OPTION
JOptionPane.CLOSED_OPTION

3.1.3 Input Dialog


Acest tip de dialog permite utilizatorului introducerea unui input printr-un control de tip câmp text,
combobox sau listă. Implicit este considerat un câmp text ca control de input. La un număr mai mic
de 20 de opţiuni se afişează un combobox, altfel o listă. Ca butoane pot fi folosite doar OK şi
CANCEL.

Metodele de creare sunt:


public static String showInputDialog(Object message)
public static String showInputDialog(Component parentComponent,
Object message)
public static String showInputDialog(Component parentComponent,
Object message,
String title,
int messageType)
public static Object showInputDialog(Component parentComponent,
Object message,
int messageType,
Icon icon,
Object[] selectionValues,
Object initialSelectionValue)

Primele 3 variante folosesc drept control de input numai câmpul text, iar valoarea returnată este un
String care conţine textul introdus de utilizator în acest câmp din dialog.
Ultima variantă returnează obiectul selectat din combobox sau listă.
 selectionValues – este un vector de tip Object care conţine variantele de răspunsuri
posibile din dialog.
 initialSelectionValue – este varianta de răspuns selectată iniţial din vectorul
selectionValues.

10
3.1.4 Option Dialog
Acest tip de dialog permite introducere de controale proprii, cum ar fi butoane.
Metoda de creare este:

public static int showOptionDialog(Component parentComponent,


Object message,
String title,
int optionType,
int messageType,
Icon icon,
Object[] options,
Object initialValue)

options – este un vector de tip Object pentru controale, de exemplu butoane.


initialValue – elementul curent selectat din vectorul options.

Valoarea returnată de această metodă este un int care indică butonul care a fost activat. De exemplu:

int value = JOptionPane.showOptionDialog(null, "Select a button",


"Option Dialog", JOptionPane.DEFAULT_OPTION,
JOptionPane.PLAIN_MESSAGE, null,
new Object[]{"Button 0", "Button 1", "Button 2"}, "Button 1");

3.2. JFileChooser
Acest tip de dialog afişează o fereastră în care utilizatorul poate naviga prin sistemul de fişiere şi
selecta fişiere cu care doreşte să lucreze.
Clasa JFileChooser este derivată din JComponent şi poate fi folosită în orice container. Cea mai des
utilizată variantă este însă cea ca dialog separat.
Există 2 variante implicite, una pentru deschidere de fişier şi una pentru salvare de fişier. Ele se
folosesc cu metodele:

public int showOpenDialog(Component parent)


public int showSaveDialog(Component parent)

Valoarea returnată este de tip int şi reprezintă una din constantele


JFileChooser.APPROVE_OPTION sau JFileChooser.CANCEL_OPTION, ceea ce indică apăsarea
butonului OK respectiv CANCEL.

11
Folosirea unui JFileChooser implică următorii trei paşi:

1. Construirea

JFileChooser jFileChooser1 = new JFileChooser(new File("."));

2. Afişarea

jFileChooser1.showOpenDialog(this);

3. Aflarea fişierelor selectate de utilizator.

if (jFileChooser1.showOpenDialog(this) == JFileChooser.APPROVE_OPTION)
File openFile = jFileChooser1.getSelectedFile();

4. Componente text
JTextComponent suportă manipulări clipboard de genul “cut”, “copy” şi “paste”. Metodele pentru
acestea sunt:
textComponent.copy();
textComponent.cut();
textComponent.paste();
Aceste operaţii lucrează cu orice componentă text Swing, fie că este TextField, TextArea, sau o
componentă text definită de către programator ce suportă un format specific.
JTextComponent poate salva sau încărca orice tip de flux (un URL, de exemplu):
textComponent.read( yReadStream, “http://www.mysite.com” );
textComponent.read( yStreamStream );
În Swing, pentru manipularea modificărilor şi formatărilor textului se utilizează o clasă numită
Document. Clasa Document serveşte drept model. Nu conţine nici o capabilitatea pentru interfaţă
utilizator. Clasa Document este un container Swing utilizat pentru a stoca text şi pentru a furniza
notificări ale modificărilor textului. Implementează, de asemenea, suport pentru selectarea textului
(mark-up).

4.1 JTextField şi JPasswordField


Un obiect de tip JTextField definește un control de editare a textului pe o singură linie.
JPasswordField este identic cu JTextField doar că afișează textul nelizibil cu scopul de a putea fi
folosit ca câmp de introducere pentru parole.

12
Exemplu. Aplicația ilustrează modul de utilizare a câmpurilor text de o linie și tratarea
evenimentelor pe Document.

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

class CompText extends JFrame implements DocumentListener, ActionListener {


private JTextField field1;
private JTextField field2;
private JButton button1;
private JLabel label1;
private JLabel label2;
private JLabel label3;
private JPasswordField password;

public CompText() {
setTitle("TextHandling Application");
setSize(300, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setBackground(Color.gray);
JPanel topPanel = new JPanel();
topPanel.setLayout(null);
getContentPane().add(topPanel);
field1 = new JTextField();
field1.setBounds(20, 40, 260, 25);
field1.setFocusAccelerator('v');
topPanel.add(field1);
label1 = new JLabel("Value 1:");
label1.setBounds(20, 15, 260, 20);
label1.setLabelFor(field1);
label1.setDisplayedMnemonic('V');
topPanel.add(label1);
field2 = new JTextField();
field2.setBounds(20, 90, 260, 25);
field2.setFocusAccelerator('a');
topPanel.add(field2);
label2 = new JLabel("Value 2:");
label2.setDisplayedMnemonic('a');

13
label2.setBounds(20, 65, 260, 20);
label2.setLabelFor(field2);
topPanel.add(label2);
password = new JPasswordField();
password.setBounds(20, 140, 260, 25);
password.setFocusAccelerator('p');
topPanel.add(password);
label3 = new JLabel("Password:");
label3.setDisplayedMnemonic('P');
label3.setBounds(20, 115, 260, 20);
label3.setLabelFor(password);
topPanel.add(label3);
button1 = new JButton("OK");
button1.setBounds(100, 180, 100, 25);
button1.setEnabled(false);
topPanel.add(button1);
// adauga un document listener la primul camp de editare
Document document = field1.getDocument();
document.addDocumentListener(this);
}

// manipuleaza acceleratorii
public void actionPerformed(ActionEvent e) {
// obtine sursa care a generat evenimentul
JLabel label = (JLabel) e.getSource();
// ofera componentei associate focus-ul
Component fieldComponent = label.getLabelFor();
fieldComponent.requestFocus();
}

// manipuleaza inserarile in campul de editare


public void insertUpdate(DocumentEvent event) {
String sString = field1.getText();
try {
int iValue = Integer.parseInt(sString);
button1.setEnabled(true);
} catch (NumberFormatException e) {
button1.setEnabled(false);
}
}

// manipuleaza stergerile din campul de editare


public void removeUpdate(DocumentEvent event) {
// nu permite utilizatorului sa introduca un camp vid
if (field1.getText().length() == 0)
button1.setEnabled(false);
else {
// efectueaza aceeasi verificare a erorilor ca si insertUpdate()
insertUpdate(event);
}
}

// manipuleaza modificarile in campul de editare


public void changedUpdate(DocumentEvent event) {
}

public static void main(String args[]) {


CompText mainFrame = new CompText();
mainFrame.setVisible(true);
}
}

14
4.2 JTextArea
Este o componentă care permite afișarea de text simplu pe mai multe linii. Ea nu are facilități de
derulare și ca urmare trebuie să fie asociată cu un JScrollPane.

Exemplu. O componentă JTextArea este folosită pentru afișarea codului sursă a aplicației. Citirea
se face simplu prin flux de fișier și metoda read a componentei JTextArea.

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.io.*;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class TextAreaExample extends JFrame {

public TextAreaExample() {

JTextArea area = new JTextArea();


JScrollPane spane = new JScrollPane();

JPanel panel = new JPanel();


panel.setLayout(new BorderLayout());

area.setLineWrap(true);
area.setWrapStyleWord(true);

// Incarca un fisier in TextArea, trateaza eventualele exceptii


try {
FileReader fileStream = new
FileReader("src/TextAreaExample.java");
area.read(fileStream, "Source code");
} catch (FileNotFoundException e) {
System.out.println("File not found");
} catch (IOException e) {
System.out.println("IOException occurred");
}

spane.getViewport().add(area);
panel.add(spane);
add(panel);

setTitle("JTextArea");
setSize(new Dimension(800, 300));

15
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
}

public static void main(String[] args) {


TextAreaExample ex = new TextAreaExample();

}
}

4.3 JTextPane
Această componentă permite formatări complexe ale textului și interpretează cod HTML. Dar,
JTextPane permite în plus afişarea unui număr infinit de stiluri configurabile de text. De
asemenea, JTextPane suportă şi conţinut grafic.

Exemplu. Aplicația folosește un obiect de tip JTextPane pentru a afișa și interpreta un document
html specificat ca argument la metoda setPage.

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.io.File;
import java.io.IOException;
import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextPane;
import javax.swing.SwingUtilities;

public class TextPaneExample extends JFrame {

public TextPaneExample() {

JPanel panel = new JPanel();


panel.setLayout(new BorderLayout());

JScrollPane pane = new JScrollPane();


JTextPane textpane = new JTextPane();

textpane.setContentType("text/html");
textpane.setEditable(false);

16
String cd = System.getProperty("user.dir") + "/";
System.out.print(cd);

try {
textpane.setPage("File:///" + cd + "/test.html");
} catch (IOException e) {
System.out.println("Exception: " + e);
}

pane.getViewport().add(textpane);
panel.add(pane);

add(panel);

setTitle("JTextPane");
setSize(new Dimension(300, 250));
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
}

public static void main(String[] args) {

TextPaneExample ex = new TextPaneExample();

}
}

Fișierul HTML:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">


<html>
<head>
<title>Un simplu document html</title>
</head>
<body>

<h2>Document HTML</h2>

<p>
<b>JTextPane</b> suporta HTML. Codul necesar arata astfel:
</p>

<br>

<pre>
JScrollPane pane = new JScrollPane();
JTextPane textpane = new JTextPane();

textpane.setContentType("text/html");
textpane.setEditable(false);
</pre>

<br>
<small>2012</small>

</body>
</html>

17
5. JProgressBar
Este un element de interfață folosit pentru indicarea grafică a progresului unei acțiuni în declanșare.
Reprezentarea poate fi orizontală cât și verticală.

Exemplu. Acest program folosește clasa Timer pentru a genera cate un ActionEvent la un interval
fixat de timp. Tratarea evenimentului va incrementa starea curentă a barei de progresare.

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.Timer;

public class ProgressBarTest extends JFrame {

ActionListener updateProBar;
Timer timer;
JProgressBar progressBar;
JButton button;

public ProgressBarTest() {

setTitle("JProgressBar");

JPanel panel = new JPanel();


panel.setBorder(BorderFactory.createEmptyBorder(40, 40, 40, 40));
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));

progressBar = new JProgressBar();

progressBar.setMaximumSize(new Dimension(150, 20));


progressBar.setMinimumSize(new Dimension(150, 20));
progressBar.setPreferredSize(new Dimension(150, 20));

progressBar.setAlignmentX(0f);

panel.add(progressBar);
panel.add(Box.createRigidArea(new Dimension(0, 20)));

button = new JButton("Start");

18
button.setFocusable(false);
button.setMaximumSize(button.getPreferredSize());

updateProBar = new ActionListener() {


public void actionPerformed(ActionEvent actionEvent) {
int val = progressBar.getValue();
if (val >= 100) {
timer.stop();
button.setText("End");
return;
}

progressBar.setValue(++val);
}
};

timer = new Timer(50, updateProBar);

button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (timer.isRunning()) {
timer.stop();
button.setText("Start");

} else if (button.getText() != "End") {


timer.start();
button.setText("Stop");
}
}
});

panel.add(button);
add(panel);

pack();
setDefaultCloseOperation(EXIT_ON_CLOSE);
setResizable(false);
setLocationRelativeTo(null);
setVisible(true);

public static void main(String[] args) {

new ProgressBarTest();
}
}

6. TabbedPanes
O componentă de tipul ”tabbed pane” permite gruparea mai multor pagini de informaţie într-un
singur punct de referinţă. Se comportă ca orice altă componentă Swing: putem să îi adăugăm un panou
(panel), să îi adăugăm componente de obicei sub formă de pagini. Fiecărei pagini îi putem asocia alte
componente Java UI.

Crearea unui “tabbed pane”


import javax.swing.*;
{
. . .

19
tabbedPanel = new JTabbedPane();
topPanel.add( tabbedPanel, BorderLayout.CENTER );
. . .
}

Adăugarea şi inserarea de pagini


O pagină constă de obicei dintr-o instanţă JPanel conţinând componente fiu.
import javax.swing.*;
{
. . .
// Creeaza pagina (un “panel”)
pagePanel = new JPanel();
pagePanel.setLayout( new BorderLayout() );
pagePanel.add( new JLabel( "Sample Label" ),BorderLayout.NORTH );
pagePanel.add( new JTextArea( "" ),BorderLayout.CENTER );
pagePanel.add( new JButton( "Button 1" ),BorderLayout.SOUTH );
// Adauga pagina la “tabbed pane”
tabbedPanel.addTab( "Page 1", pagePanel );
. . .
}
Se va utiliza cod similar pentru crearea fiecărei pagini. Dar o astfel de secvenţă de cod adaugă
paginile secvenţial. Pentru a insera pagini oriunde într-o ierarhie de pagini se utilizează:
// Insereaza pagina in “tabbed pane”
tabbedPanel.insertTab( "Inserted Page",
new ImageIcon( "image.gif" ),
pagePanel,"My tooltip text",iLocation );
Variabila iLocation reprezintă index-ul (poziţia) paginii. Se observă de asemenea cum se
ataşează o imagine.

Ştergerea paginilor
tabbedPanel.removeTabAt( iLocation );
unde iLocation este index-ul paginii ce se va înlătura. Pentru a se şterge toate paginile, trebuie să se ţină
evidenţa numărului de pagini rămase, altfel Java VM va genera o excepţie.
while( tabbedPanel.getTabCount() > 0 )
tabbedPanel.removeTabAt( 0 );
Metoda getTabCount() returnează numărul total de pagini din panel.

Selectarea paginilor
Există 2 mecanisme pentru selectarea unei pagini. Cel mai simplu, utilizatorul va selecta cu un
click pagina dorită, iar instanţa JTabbedPane va muta automat pagina selectată în faţă. Dar se poate
scrie şi cod pentru aceasta. Se apelează metoda setSelectedIndex() cu indexul paginii care se doreşte să
apară în faţă.
tabbedPanel.setSelectedIndex( iLocation );
O a doua metodă utilizează instanţa panel-ului care a fost referenţiat atunci când pagina a fost
adăugată.
tabbedPanel.setSelectedComponent( pagePanel );

20
Exemplu. Aplicația construiește 3 panouri cu componente grafice și le organizează pe taburi.

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

class TabbedPaneExample extends JFrame {


private JTabbedPane tabbedPane;
private JPanel panel1;
private JPanel panel2;
private JPanel panel3;

public TabbedPaneExample() {
setTitle("Tabbed Pane Application");
setSize(300, 200);
setBackground(Color.gray);
JPanel topPanel = new JPanel();
topPanel.setLayout(new BorderLayout());
getContentPane().add(topPanel);
// Creeaza paginile
createPage1();
createPage2();
createPage3();
// Creeaza un “tabbed pane”
tabbedPane = new JTabbedPane();
tabbedPane.addTab("Page 1", panel1);
tabbedPane.addTab("Page 2", panel2);
tabbedPane.addTab("Page 3", panel3);
topPanel.add(tabbedPane, BorderLayout.CENTER);
}

public void createPage1() {


panel1 = new JPanel();
panel1.setLayout(null);
JLabel label1 = new JLabel("Username:");
label1.setBounds(10, 15, 150, 20);
panel1.add(label1);
JTextField field = new JTextField();
field.setBounds(10, 35, 150, 20);
panel1.add(field);
JLabel label2 = new JLabel("Password:");
label2.setBounds(10, 60, 150, 20);
panel1.add(label2);
JPasswordField fieldPass = new JPasswordField();
fieldPass.setBounds(10, 80, 150, 20);
panel1.add(fieldPass);
}

21
public void createPage2() {
panel2 = new JPanel();
panel2.setLayout(new BorderLayout());
panel2.add(new JButton("North"), BorderLayout.NORTH);
panel2.add(new JButton("South"), BorderLayout.SOUTH);
panel2.add(new JButton("East"), BorderLayout.EAST);
panel2.add(new JButton("West"), BorderLayout.WEST);
panel2.add(new JButton("Center"), BorderLayout.CENTER);
}

public void createPage3() {


panel3 = new JPanel();
panel3.setLayout(new GridLayout(3, 2));
panel3.add(new JLabel("Field 1:"));
panel3.add(new TextArea());
panel3.add(new JLabel("Field 2:"));
panel3.add(new TextArea());
panel3.add(new JLabel("Field 3:"));
panel3.add(new TextArea());
}

public static void main(String args[]) {


TabbedPaneExample mainFrame = new TabbedPaneExample();
mainFrame.setVisible(true);
}
}

Exemplu. Aplicația construiește un panou cu o reprezentare arborescentă a structurii de directoare.

import javax.swing.*;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.*;
import java.io.File;
import java.util.Collections;
import java.util.Vector;

public class FileTree extends JPanel {

public FileTree(File dir) {


setLayout(new BorderLayout());

JTree tree = new JTree(addNodes(null, dir));

22
tree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) e
.getPath().getLastPathComponent();
System.out.println("You selected " + node);
}
});

JScrollPane scrollpane = new JScrollPane();


scrollpane.getViewport().add(tree);
add(BorderLayout.CENTER, scrollpane);
}

DefaultMutableTreeNode addNodes(DefaultMutableTreeNode curTop, File dir) {


String curPath = dir.getPath();
DefaultMutableTreeNode curDir = new DefaultMutableTreeNode(curPath);
if (curTop != null) {
curTop.add(curDir);
}
Vector ol = new Vector();
String[] tmp = dir.list();
//// rezolvare simpla
if(tmp!=null)
////
for (String aTmp : tmp)
ol.addElement(aTmp);
Collections.sort(ol, String.CASE_INSENSITIVE_ORDER);
File f;
Vector files = new Vector();

for (int i = 0; i < ol.size(); i++) {


String thisObject = (String) ol.elementAt(i);
String newPath;
if (curPath.equals("."))
newPath = thisObject;
else
newPath = curPath + File.separator + thisObject;
if ((f = new File(newPath)).isDirectory()){
//System.out.println(newPath);
addNodes(curDir, f);
}
else
files.addElement(thisObject);
}

for (int fnum = 0; fnum < files.size(); fnum++)


curDir.add(new DefaultMutableTreeNode(files.elementAt(fnum)));
return curDir;
}

public Dimension getMinimumSize() {


return new Dimension(200, 400);
}

public Dimension getPreferredSize() {


return new Dimension(200, 400);
}

public static void main(String[] av) {

JFrame frame = new JFrame("FileTree");


frame.setForeground(Color.black);

23
frame.setBackground(Color.lightGray);
Container cp = frame.getContentPane();

if (av.length == 0) {
cp.add(new FileTree(new File("."))); // current dir
} else {
cp.setLayout(new BoxLayout(cp, BoxLayout.X_AXIS));
for (String anAv : av)
cp.add(new FileTree(new File(anAv)));
}

frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

24