PowerPoint-presentatie

Hoofdstuk 13:
Graphical User Interface
Componenten: Deel 1
JAVA
1
1 Inleiding

Grafische Gebruikers Interface (GUI)



Geeft ieder programma een verschillend uiterlijk
en gedrag (“look- and - feel”)
Plaatst de gebruikers in een vertrouwde omgeving
Is opgebouwd uit GUI componenten
(schuifbalken, icoon, etc.)

Via de muis en het toetsenbord heeft de gebruiker
interactie met de GUI componenten, etc.
JAVA
2
Voorbeeld: Netscape Navigator
windows met GUI componenten.
button
menus
menu bar
combo box
scroll bars
JAVA
3
Enkele GUI componenten
Component
Beschrijving
JLabel
Een gebied waar niet-editeerbare tekst of iconen afgedrukt
worden.
JTextField
Een gebied waar de gebruiker de invoer via het toetsenbord
intypt. Het kan ook gegevens tonen.
JButton
Door het klikken op deze button wordt een event uitgevoerd.
JCheckBox
Een GUI component dat niet of wel aangekruist is.
JComboBox Een drop-down lijst waarbinnen de gebruiker een keuze kan
maken door op een item te klikken ofwel door het item in de
box in te typen
JList
Een gebied waar een lijst van items getoond wordt en waaruit
de gebruiker een keuze maakt door één keer te klikken op dat
element uit de lijst. Dubbelklikken op een element brengt een
actie event teweeg. Men kan meerdere elementen kiezen.
JPanel
Een container waain men componenten kan plaatsen.
JAVA
4
2 Overzicht Swing

Swing GUI componenten

package javax.swing
met oorsprong in AWT (package java.awt)

Geven een vertrouwd uiterlijk en gedrag



Uitzicht en manier van interactie tussen de gebruikers en
het programma
“Lightweight” componenten


Volledig in Java geschreven
Platform-onafhankelijk
JAVA
5
2 Overzicht Swing (2)

class Component


Bevat de methode paint die Component
op het scherm tekent
class Container


Verzameling van bij elkaar horende
componenten
Bevat de methode add voor het toevoegen
van componenten
JAVA
6
2 Overzicht Swing (3)

class JComponent



“Plugable look and feel” het uiterlijk en het
gedrag wijzigt mee met het gebruikte
platform
Shortcut keys (mnemonics)
Gemeenschappelijke events gelijkaardig
afhandelen
JAVA
7
Gemeenschappelijke superclasses
voor vele Swing componenten.
Object
Object
Component
Component
Container
Container
JComponent
JComponent
JAVA
8
3 JLabel

label

Stelt de tekst/informatie op een GUI voor
class JLabel definieert labels

Kan voorstellen:




Een lijntje read-only tekst
Een beeld
Tekst en beeld
JAVA
9
VB: Gebruik van de class JLabel
Demonstratie labels:
 Tekst
 Beeld links en tekst
rechts
 Tekst onder het
beeld
 Beweeg met cursor
JAVA
10
// Fig. 13.4: LabelTest.java
2
// Demonstrating the JLabel class.
3
import java.awt.*;
4
import java.awt.event.*;
5
import javax.swing.*;
6
7
public class LabelTest extends JFrame {
8
private JLabel label1, label2, label3;
9
10
// set up GUI
11
public LabelTest()
12
{
13
super( "Testing JLabel" );
14
15
// get content pane and set its layout
16
Container container = getContentPane();
17
container.setLayout( new FlowLayout() );
18
19
// JLabel constructor with a string
argument
20
label1 = new JLabel( "Label with text" );
21
label1.setToolTipText( "This is label1" );
22
container.add( label1 );
23
Declareer drie JLabels
Maak het eerste JLabel
met tekst “Label with
text”
Tool tip is tekst die verschijnt
wanneer de gebruiker de cursor
beweegt over JLabel
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// JLabel constructor with string, Icon and alignment
arguments
Icon bug = new ImageIcon( "bug1.gif" );
label2 = new JLabel( "Label with text and icon", bug,
SwingConstants.LEFT );
label2.setToolTipText( "This is label2" );
container.add( label2 );
// JLabel constructor no arguments
label3 = new JLabel();
label3.setText( "Label with icon and text at bottom" );
label3.setIcon( bug );
label3.setHorizontalTextPosition( SwingConstants.CENTER );
label3.setVerticalTextPosition( SwingConstants.BOTTOM );
label3.setToolTipText( "This is label3" );
container.add( label3 );
setSize( 275, 170 );
setVisible( true );
} // end constructor
public static void main( String args[] )
{
LabelTest application = new LabelTest();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
} // end class LabelTest
Maak het tweede JLabel
met tekst langs de linkerkant
van het beeld
Maak het derde
JLabel met tekst
onder het beeld
4 Event-Handling Model

GUI’s zijn event driven

genereert events op het ogenblik dat de
gebruiker met GUI interactief is


de muis bewegen, op een knop klikken, tekst
intypen in een tekst field, etc.
class java.awt.AWTEvent
JAVA
14
Enkele event classes van de
package java.awt.event
Object
Object
ActionEvent
ActionEvent
EventObject
EventObject
AdjustmentEvent
AdjustmentEvent
AWTEvent
AWTEvent
ContainerEvent
ContainerEvent
ItemEvent
ItemEvent
FocusEvent
FocusEvent
TextEvent
TextEvent
PaintEvent
PaintEvent
ComponentEvent
ComponentEvent
WindowEvent
WindowEvent
InputEvent
InputEvent
KeyEvent
KeyEvent
MouseEvent
MouseEvent
MouseWheelEvent
MouseWheelEvent
JAVA
15
4 Event-Handling Model (2)

Drie delen

Event source


Event object


GUI component waarop de gebruiker inwerkt
Bevat de informatie over het event dat optrad
Event listener

Ontvangt een event object bij het optreden,
geeft dan een antwoord via het object
JAVA
16
4 Event-Handling Model (3)

Programmeur moet twee taken
uitvoeren


Registreer de “event listener” voor de
“event source”
Implementeer een event-handling methode
(event handler)
JAVA
17
Event-listener interfaces van
package java.awt.event
interface
«interface»
ActionListener
ActionListener
interface
«interface»
AdjustmentListener
AdjustmentListener
interface
«interface»
ComponentListener
ComponentListener
interface
«interface»
ContainerListener
ContainerListener
interface
«interface»
FocusListener
FocusListener
interface
«interface»
EventListener
EventListener
interface
«interface»
ItemListener
ItemListener
interface
«interface»
KeyListener
KeyListener
interface
«interface»
MouseListener
MouseListener
interface
«interface»
MouseMotionListener
MouseMotionListener
interface
«interface»
TextListener
TextListener
interface
«interface»
WindowListener
TextListener
JAVA
18
5 JTextField en JPasswordField

JTextField


Is een gebied waarin een gebruiker één
lijntje tekst kan inbrengen
JPasswordField


extends JTextField
Verbergt de karakters die de gebruiker
intypt
JAVA
19
VB: Het gebruik van de
class JTextField
Demonstratie invoervelden:
 Lege velden
 Velden met opschrift
 Niet-editeerbare velden
 Velden met paswoorden
De interactie wordt
weergegeven
JAVA
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Fig. 13.7: TextFieldTest.java
// Demonstrating the JTextField class.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class TextFieldTest extends JFrame {
private JTextField textField1, textField2, textField3;
private JPasswordField passwordField;
// set up GUI
public TextFieldTest()
{
super( "Testing JTextField and JPasswordField" );
Declareer drie
JTextField’s en een
JPasswordField
Container container = getContentPane();
container.setLayout( new FlowLayout() );
// construct textfield with default sizing
textField1 = new JTextField( 10 );
container.add( textField1 );
// construct textfield with default text
textField2 = new JTextField( "Enter text here" );
container.add( textField2 );
Het eerste
JTextField bevat
een lege string
Het tweede JTextField bevat
de tekst “Enter text here”
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// construct textfield with default text,
// 20 visible elements and no event handler
textField3 = new JTextField( "Uneditable text field", 20 );
textField3.setEditable( false );
container.add( textField3 );
// construct passwordfield with default text
passwordField = new JPasswordField( "Hidden text" );
container.add( passwordField );
// register event handlers
TextFieldHandler handler = new TextFieldHandler();
textField1.addActionListener( handler );
textField2.addActionListener( handler );
textField3.addActionListener( handler );
passwordField.addActionListener( handler );
setSize( 325, 100 );
setVisible( true );
Het derde
JTextField bevat
niet-editeerbare tekst
JPasswordField bevat tekst
“Hidden text,” maar
verschijnt als een rij sterren (*)
Registreer GUI componenten
met TextFieldHandler
(registreer voor
ActionEvent’s)
} // end constructor TextFieldTest
public static void main( String args[] )
{
TextFieldTest application = new TextFieldTest();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
// private inner class for event handling
private class TextFieldHandler implements ActionListener {
// process textfield events
public void actionPerformed( ActionEvent event )
{
String string = "";
// user pressed Enter in JTextField textField1
if ( event.getSource() == textField1 )
string = "textField1: " + event.getActionCommand();
// user pressed Enter in JTextField textField2
else if ( event.getSource() == textField2 )
string = "textField2: " + event.getActionCommand();
// user pressed Enter in JTextField textField3
else if ( event.getSource() == textField3 )
string = "textField3: " + event.getActionCommand();
// user pressed Enter in JTextField passwordField
else if ( event.getSource() == passwordField ) {
string = "passwordField: " +
new String( passwordField.getPassword() );
}
Elk object van
TextFieldHandler is een
ActionListener
Methode actionPerformed
wordt aangeroepen wanneer de
gebruiker Enter drukt in het
GUI veld
80
81
82
83
84
85
86
87
JOptionPane.showMessageDialog( null, string );
} // end method actionPerformed
} // end private inner class TextFieldHandler
} // end class TextFieldTest
5.1 Hoe werkt Event Handling

Twee open vragen uit het vorige deel 4

(1) Hoe wordt de event handler
geregistreerd?

Via de methode addActionListener van de
component

Lijnen 43-46 van TextFieldTest.java
JAVA
25
5.1 Hoe werkt Event Handling (2)

Twee open vragen uit het vorige deel 4

(2) Wanneer moet de component
actionPerformed aanroepen?


Event wordt alleen naar de listeners van het
gepaste type verzonden
Elk event type heeft een corresponderende
event-listener interface

De event ID specificeert het event type dat zich
voordeed
JAVA
26
Event registratie voor
JTextField textField1.
textField1
handler
listenerList
JTextField
object
public void actionPerformed(
ActionEvent event )
{
// event handled here
}
TextFieldHandler
object
...
This reference is created by the statement
textField1.addActionListener( handler );
JAVA
27
6 JButton


De gebruiker klikt op deze component om een
bepaalde actie teweeg te brengen
Verschillende types





Command buttons
Check boxes
Toggle buttons
Radio buttons
javax.swing.AbstractButton subclasses

Command buttons worden gecreëerd met class JButton

ActionEvent’s worden gegenereerd wanneer de gebruiker
op de button klikt
JAVA
28
De hiërarchie van de button.
JComponent
JComponent
AbstractButton
AbstractButton
JButton
JToggleButton
JButton
JToggleButton
JCheckBox
JCheckBox
JAVA
JRadioButton
JRadioButton
29
VB: Het maken van JButton’s
Demonstratie van
button’s
JAVA
30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Fig. 13.10: ButtonTest.java
// Creating JButtons.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class ButtonTest extends JFrame {
private JButton plainButton, fancyButton;
// set up GUI
public ButtonTest()
{
super( "Testing Buttons" );
Maak twee referenties
naar JButton
instanties
// get content pane and set its layout
Container container = getContentPane();
container.setLayout( new FlowLayout() );
// create buttons
plainButton = new JButton( "Plain Button" );
container.add( plainButton );
Icon bug1 = new ImageIcon( "bug1.gif" );
Icon bug2 = new ImageIcon( "bug2.gif" );
fancyButton = new JButton( "Fancy Button", bug1 );
fancyButton.setRolloverIcon( bug2 );
container.add( fancyButton );
Maak Jbutton object met
tekst
Maak JButton object
met beeld en rollover
beeld
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// create an instance of inner class ButtonHandler
// to use for button event handling
ButtonHandler handler = new ButtonHandler();
fancyButton.addActionListener( handler );
plainButton.addActionListener( handler );
setSize( 275, 100 );
setVisible( true );
Maak ButtonHandler
object voor JButton event
handling
Registreer Jbutton’s om
events te ontvangen van
ButtonHandler
} // end ButtonTest constructor
public static void main( String args[] )
{
ButtonTest application = new ButtonTest();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
// inner class for button event handling
private class ButtonHandler implements ActionListener {
}
// handle button event
public void actionPerformed( ActionEvent event )
{
JOptionPane.showMessageDialog( ButtonTest.this,
"You pressed: " + event.getActionCommand() );
} // end private inner class ButtonHandler
} // end class ButtonTest
Wanneer de gebruiker op
Jbutton klikt, start
ButtonHandler de
methode
actionPerformed van alle
geregistreerde listeners
Oefening 1

Schrijf een applicatie die een temperatuur in
Fahrenheit omzet in een temperatuur in Celsius.
De temperatuur in Fahrenheit wordt via het
toetsenbord ingevoerd (JTextField).
Via een JLabel wordt de geconverteerde temperatuur
afgedrukt.
JAVA
34
// Convert.java
// Java core packages
import java.awt.*;
import java.awt.event.*;
// Java extension packages
import javax.swing.*;
public class Convert extends JFrame
{
private JLabel label1, label2;
private JTextField temperatureF, temperatureC;
// constructer sets up GUI
public Convert()
{
super( "Temperature converter" );
//get content pane and set its layout
Container container= getContentPane();
container.setLayout (new FlowLayout() );
label1 = new JLabel( "Enter Fahrenheit temperature:" );
temperatureF = new JTextField( 10 );
label2 = new JLabel( "Temperature in Celcius is:" );
temperatureC = new JTextField( 10 );
temperatureC.setEditable( false );
container.add( label1);
container.add( temperatureF);
container.add( label2);
container.add( temperatureC);
// register event handlers
TextFieldHandler handler = new TextFieldHandler();
temperatureF.addActionListener( handler );
setSize( 200, 150 );
show();
}
// execute application
public static void main ( String args[] )
{
Convert app = new Convert();
app.setDefaultCloseOperation( EXIT_ON_CLOSE );
}
// private inner class for event handling
private class TextFieldHandler implements ActionListener
{
public void actionPerformed( ActionEvent event )
{
int temp = Integer.parseInt( temperatureF.getText() );
int celcius = ( int ) ( 5.0f / 9.0f * ( temp - 32 ) );
temperatureC.setText( String.valueOf(celcius ) );
}
}
} // end class Convert
7 JCheckBox en JRadioButton

State buttons

On/Off of true/false waarden

Java voorziet drie types



JToggleButton
JCheckBox
JRadioButton
JAVA
38
VB: Het maken van
Checkbox button’s
Bij het aanklikken van
bijvoorbeeld bold
wordt de tekst in het
invoerveld
opgemaakt
JAVA
39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Fig. 13.11: CheckBoxTest.java
// Creating JCheckBox buttons.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class CheckBoxTest extends JFrame {
private JTextField field;
private JCheckBox bold, italic;
// set up GUI
public CheckBoxTest()
{
super( "JCheckBox Test" );
Declareer twee JCheckBox
instanties
// get content pane and set its layout
Container container = getContentPane();
container.setLayout( new FlowLayout() );
// set up JTextField and set its font
field = new JTextField( "Watch the font style change", 20 );
field.setFont( new Font( "Serif", Font.PLAIN, 14 ) );
container.add( field );
Zet JTextField
lettertypetype op Serif,
14-pt vol
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// create checkbox objects
bold = new JCheckBox( "Bold" );
container.add( bold );
Maak JCheckBox’s voor respectievelijk
vet- en cursief JTextField tekst
italic = new JCheckBox( "Italic" );
container.add( italic );
// register listeners for JCheckBoxes
CheckBoxHandler handler = new CheckBoxHandler();
bold.addItemListener( handler );
italic.addItemListener( handler );
setSize( 275, 100 );
setVisible( true );
Registreer JCheckBox’s om
events te ontvangen van
CheckBoxHandler
} // end CheckBoxText constructor
public static void main( String args[] )
{
CheckBoxTest application = new CheckBoxTest();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// private inner class for ItemListener event handling
private class CheckBoxHandler implements ItemListener {
private int valBold = Font.PLAIN;
private int valItalic = Font.PLAIN;
// respond to checkbox events
public void itemStateChanged( ItemEvent event )
{
// process bold checkbox events
if ( event.getSource() == bold )
valBold = bold.isSelected() ? Font.BOLD : Font.PLAIN;
Wanneer de gebruiker
JCheckBox selecteert, roept
CheckBoxHandler de methode
itemStateChanged aan van
alle geregistreerde listeners
// process italic checkbox events
Wijzig JTextField lettertype,
if ( event.getSource() == italic )
afhankelijk van de JCheckBox die
valItalic = italic.isSelected() ? Font.ITALIC : Font.PLAIN;
// set text field font
field.setFont( new Font( "Serif", valBold + valItalic, 14 ) );
} // end method itemStateChanged
} // end private inner class CheckBoxHandler
} // end class CheckBoxTest
geselecteerd was
VB: Het maken van radio button’s
via ButtonGroup en JRadioButton
Bij het aanklikken van
bijvoorbeeld bold
wordt de tekst in het
invoerveld
opgemaakt
JAVA
44
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Fig. 13.12: RadioButtonTest.java
// Creating radio buttons using ButtonGroup and JRadioButton.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class RadioButtonTest extends JFrame {
private JTextField field;
private Font plainFont, boldFont, italicFont, boldItalicFont;
private JRadioButton plainButton, boldButton, italicButton,
boldItalicButton;
private ButtonGroup radioGroup;
Declareer vier JRadioButton
instanties
// create GUI and fonts
public RadioButtonTest()
{
super( "RadioButton Test" );
// get content pane and set its layout
Container container = getContentPane();
container.setLayout( new FlowLayout() );
// set up JTextField
field = new JTextField( "Watch the font style change", 25 );
container.add( field );
JRadioButton’s
verschijnen algemeen als een
ButtonGroup
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// create radio buttons
plainButton = new JRadioButton( "Plain", true );
container.add( plainButton );
boldButton = new JRadioButton( "Bold", false );
container.add( boldButton );
italicButton = new JRadioButton( "Italic", false );
container.add( italicButton );
maak JRadioButton’s om het
JTextField tekst lettertype te
manipuleren
boldItalicButton = new JRadioButton( "Bold/Italic", false );
container.add( boldItalicButton );
// create logical relationship between JRadioButtons
radioGroup = new ButtonGroup();
radioGroup.add( plainButton );
radioGroup.add( boldButton );
radioGroup.add( italicButton );
radioGroup.add( boldItalicButton );
// create font objects
plainFont = new Font( "Serif", Font.PLAIN, 14 );
boldFont = new Font( "Serif", Font.BOLD, 14 );
italicFont = new Font( "Serif", Font.ITALIC, 14 );
boldItalicFont = new Font( "Serif", Font.BOLD + Font.ITALIC, 14 );
field.setFont( plainFont ); // set initial font
JRadioButton’s
behoren tot de
ButtonGroup
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
// register events for JRadioButtons
plainButton.addItemListener( new RadioButtonHandler( plainFont ) );
boldButton.addItemListener( new RadioButtonHandler( boldFont ) );
italicButton.addItemListener(
Registreeer
new RadioButtonHandler( italicFont ) );
JRadioButton’s
boldItalicButton.addItemListener(
events van de
new RadioButtonHandler( boldItalicFont ) );
setSize( 300, 100 );
setVisible( true );
} // end RadioButtonTest constructor
public static void main( String args[] )
{
RadioButtonTest application = new RadioButtonTest();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
// private inner class to handle radio button events
private class RadioButtonHandler implements ItemListener {
private Font font;
public RadioButtonHandler( Font f )
{
font = f;
}
om
RadioButtonHandler
te ontvangen
81
82
83
84
85
86
87
88
89
90
// handle radio button events
public void itemStateChanged( ItemEvent event )
{
field.setFont( font );
}
} // end private inner class RadioButtonHandler
} // end class RadioButtonTest
Als een gebruiker JRadioButton
selecteert, zal
RadioButtonHandler de
methode itemStateChanged van
al de geregistreede listeners
aanroepen
Stel het lettertype in
afhankelijk van de
geselecteerde
JRadioButton
Oefening 2

Maak de volgende GUI, zonder
functionaliteit. (Denk na over de
schikking)
JAVA
49
//LineTest_View1.java
//Java core packages
import java.awt.*;
import java.awt.event.*;
//Java extension packages
import javax.swing.*;
public class LineTest_View1 extends JFrame
{
private JRadioButton redButton, greenButton, blueButton, yellowButton;
private ButtonGroup radioGroup;
private JCheckBox dashed, thick, rounded;
private JButton defaults, ok, cancel;
//create GUI
public LineTest_View1()
{
super ("LineTest View1");
//get content pane and set its layout
Container container= getContentPane();
container.setLayout (new FlowLayout() );
//create radio buttons
redButton = new JRadioButton("RED",false);
container.add(redButton);
greenButton = new JRadioButton("GREEN",false);
container.add(greenButton);
blueButton = new JRadioButton("BLUE",true);
container.add(blueButton);
yellowButton = new JRadioButton("YELLOW",false);
container.add(yellowButton);
//create logical relationship between JRadioButtons
radioGroup = new ButtonGroup();
radioGroup.add(redButton);
radioGroup.add(greenButton);
radioGroup.add(blueButton);
radioGroup.add(yellowButton);
//create checkboxobjects
dashed = new JCheckBox("DASHED");
container.add(dashed);
thick = new JCheckBox("THICK");
container.add(thick);
rounded = new JCheckBox("ROUNDED");
container.add(rounded);
//create buttons
defaults = new JButton("Defaults");
container.add(defaults);
ok = new JButton("OK");
container.add(ok);
cancel = new JButton("Cancel");
container.add(cancel);
setSize(300,150);
setVisible(true);
}
//execute application
public static void main(String args[])
{
LineTest_View1 application = new LineTest_View1();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
}
8 JComboBox

JComboBox


Een lijst van items waaruit de gebruiker
kan kiezen
Ook een drop-down lijst genoemd
JAVA
54
VB: Via een JComboBox een voor
te stellen icoon kiezen
JAVA
55
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Fig. 13.13: ComboBoxTest.java
// Using a JComboBox to select an image to display.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class ComboBoxTest extends JFrame {
private JComboBox imagesComboBox;
private JLabel label;
private String names[] =
{ "bug1.gif", "bug2.gif", "travelbug.gif", "buganim.gif" };
private Icon icons[] = { new ImageIcon( names[ 0 ] ),
new ImageIcon( names[ 1 ] ), new ImageIcon( names[ 2 ] ),
new ImageIcon( names[ 3 ] ) };
// set up GUI
public ComboBoxTest()
{
super( "Testing JComboBox" );
// get content pane and set its layout
Container container = getContentPane();
container.setLayout( new FlowLayout() );
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// set up JComboBox and register its event handler
imagesComboBox = new JComboBox( names );
imagesComboBox.setMaximumRowCount( 3 );
imagesComboBox.addItemListener(
new ItemListener() { // anonymous inner class
Maak JComboBox om drie
String’s uit array
names samen te tonen
Registreer JComboBox om events van
de anonieme ItemListener te
ontvangen
// handle JComboBox event
public void itemStateChanged( ItemEvent event )
{
// determine whether check box selected
if ( event.getStateChange() == ItemEvent.SELECTED )
label.setIcon( icons[
imagesComboBox.getSelectedIndex() ] );
}
} // end anonymous inner class
); // end call to addItemListener
container.add( imagesComboBox );
// set up JLabel to display ImageIcons
label = new JLabel( icons[ 0 ] );
container.add( label );
Wanneer de gebruiker een item uit de
JComboBox selecteert, roept ItemListener
de methode itemStateChanged aan van alle
geregistreede listeners
Zet afhankelijk van de keuze
van de gebruiker het gepaste
Icon
52
53
54
55
56
57
58
59
60
61
62
63
setSize( 350, 100 );
setVisible( true );
} // end ComboBoxTest constructor
pAublic static void main( String args[] )
{
ComboBoxTest application = new ComboBoxTest();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class ComboBoxTest
9 JList

List




Verzameling van items
De gebruiker kan één of meerdere items
selecteren
Single-selectie vs. multiple-selectie
JList
JAVA
59
VB: Achtergrondkleur kiezen uit
een JList
JAVA
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Fig. 13.14: ListTest.java
// Selecting colors from a JList.
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
public class ListTest extends JFrame {
private JList colorList;
private Container container;
private final String colorNames[] = { "Black", "Blue", "Cyan",
"Dark Gray", "Gray", "Green", "Light Gray", "Magenta",
"Orange", "Pink", "Red", "White", "Yellow" };
private final Color colors[] = { Color.BLACK, Color.BLUE, Color.CYAN,
Color.DARK_GRAY, Color.GRAY, Color.GREEN, Color.LIGHT_GRAY,
Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.WHITE,
Color.YELLOW };
// set up GUI
public ListTest()
{
super( "List Test" );
// get content pane and set its layout
container = getContentPane();
container.setLayout( new FlowLayout() );
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// create a list with items in colorNames array
colorList = new JList( colorNames );
colorList.setVisibleRowCount( 5 );
De array colorNames
wordt gebruikt om Jlist
te vullen
// do not allow multiple selections
colorList.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
// add a JScrollPane containing JList to content pane
container.add( new JScrollPane( colorList ) );
colorList.addListSelectionListener(
JList laat een single selectie
toe
new ListSelectionListener() { // anonymous inner class
Registreer JList om events van de
// handle list selection events
anonieme ListSelectionListener
public void valueChanged( ListSelectionEvent event )
te ontvangen
{
}
container.setBackground(
colors[ colorList.getSelectedIndex() ] );
} // end anonymous inner class
); // end call to addListSelectionListener
Wanneer de gebruiker een item
selecteert in JList, roept
ListSelectionListener de
methode valueChanged aan van
alle geregistreerde listeners
Afhankelijk van de keuze
van de gebruiker wordt de
achtergrond aangepast
53
54
55
56
57
58
59
60
61
62
63
64
setSize( 350, 150 );
setVisible( true );
} // end ListTest constructor
public static void main( String args[] )
{
ListTest application = new ListTest();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class ListTest
10 Multiple-Selection Lijsten

Multiple-selection list


Meerdere items kunnen uit JList gekozen
worden
Laat een aaneengesloten selectie toe
JAVA
64
VB: Items van de ene naar de
andere JList kopiëren
JAVA
65
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Fig. 13.15: MultipleSelectionTest.java
// Copying items from one List to another.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MultipleSelectionTest extends JFrame {
private JList colorList, copyList;
private JButton copyButton;
private final String colorNames[] = { "Black", "Blue", "Cyan",
"Dark Gray", "Gray", "Green", "Light Gray", "Magenta", "Orange",
"Pink", "Red", "White", "Yellow" };
// set up GUI
public MultipleSelectionTest()
{
super( "Multiple Selection Lists" );
// get content pane and set its layout
Container container = getContentPane();
container.setLayout( new FlowLayout() );
De array colorNames
wordt gebruikt om Jlist
te vullen
// set up JList colorList
colorList = new JList( colorNames );
colorList.setVisibleRowCount( 5 );
colorList.setSelectionMode(
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION );
container.add( new JScrollPane( colorList ) );
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
// create copy button and register its listener
copyButton = new JButton( "Copy >>>" );
copyButton.addActionListener(
new ActionListener() { // anonymous inner class
// handle button event
Wanneer de gebruiker de Jbutton
public void actionPerformed( ActionEvent event )
{
indrukt, zal JList copyList de
// place selected values in copyList
items gekozen door de gebruiker uit de
copyList.setListData( colorList.getSelectedValues() );
JList colorList toevoegen
}
} // end anonymous inner class
); // end call to addActionListener
container.add( copyButton );
// set up JList copyList
copyList = new JList( );
copyList.setVisibleRowCount( 5 );
copyList.setFixedCellWidth( 100 );
copyList.setFixedCellHeight( 15 );
copyList.setSelectionMode(
ListSelectionModel.SINGLE_INTERVAL_SELECTION );
container.add( new JScrollPane( copyList ) );
JList colorList
laat single selectie toe
57
58
59
60
61
62
63
64
65
66
67
68
69
setSize( 300, 130 );
setVisible( true );
} // end constructor MultipleSelectionTest
public static void main( String args[] )
{
MultipleSelectionTest application = new MultipleSelectionTest();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class MultipleSelectionTest
11 Mouse Event Handling

De Event-listener interfaces



MouseListener
MouseMotionListener
Listen for MouseEvents
JAVA
69
MouseListener en MouseMotionListener
interface methoden
MouseListener en MouseMotionListener interface methodes
Methodes van de interface MouseListener
public void mousePressed( MouseEvent event )
Wordt opgeroepen bij het indrukken van de muisknop
wanneer de muiscursor zich op een component bevindt.
Wordt opgeroepen bij het klikken van de muisknop als
deze zich op een component bevindt zonder de
muiscursor te bewegen.
Wordt opgereoepen wanneer de muisknop losgelaten
wordt nadat hij ingedrukt werd. Deze event wordt
steeds voorafgegaan door een mousePressed event.
Wordt opgeroepen wanneer de muiscursor het gebied
van de component betreedt.
Wordt opgeroepen wanneer de muiscursor het gebied
van de component verlaat.
public void mouseClicked( MouseEvent event )
public void mouseReleased( MouseEvent event )
public void mouseEntered( MouseEvent event )
public void mouseExited( MouseEvent event )
Methodes van de interface MouseMotionListener
public void mouseDragged( MouseEvent event )
Wordt opgeroepen wanneer de muisknop wordt
ingedrukt terwijl de muiscursor zich op een component
bevindt en wordt versleept. Deze event wordt steeds
voorafgegaan door een aanroep van mousePressed.
Wordt opgeroepen wanneer de muis verplaatst wordt
terwijl de muiscursor zich op een component bevindt.
public void mouseMoved( MouseEvent event )
.
JAVA
70
VB: Voorstelling van “mouse
events”
JAVA
71
// Fig. 13.17: MouseTracker.java
2
// Demonstrating mouse events.
3
import java.awt.*;
4
import java.awt.event.*;
5
import javax.swing.*;
6
7
public class MouseTracker extends JFrame
8
implements MouseListener, MouseMotionListener {
9
10
private JLabel statusBar;
11
12
// set up GUI and register mouse event handlers
13
public MouseTracker()
14
{
15
super( "Demonstrating Mouse Events" );
16
17
statusBar = new JLabel();
18
getContentPane().add( statusBar, BorderLayout.SOUTH );
19
20
addMouseListener( this );
// listens for own mouse and
21
addMouseMotionListener( this ); // mouse-motion events
22
23
setSize( 275, 100 );
24
setVisible( true );
25
}
26
Registreer JFrame
om mouse events te
ontvangen
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// MouseListener event handlers
// handle event when mouse released immediately after press
public void mouseClicked( MouseEvent event )
{
statusBar.setText( "Clicked at [" + event.getX() +
", " + event.getY() + "]" );
}
// handle event when mouse pressed
public void mousePressed( MouseEvent event )
{
statusBar.setText( "Pressed at [" + event.getX() +
", " + event.getY() + "]" );
}
// handle event when mouse released after dragging
public void mouseReleased( MouseEvent event )
{
statusBar.setText( "Released at [" + event.getX() +
", " + event.getY() + "]" );
}
// handle event when mouse enters area
public void mouseEntered( MouseEvent event )
{
Wordt uitgevoerd wanneer
de gebruiker de muisknop
indrukt en loslaat
Wordt uitgevoerd
wanneer de gebruiker
de muisknop indrukt
Wordt uitgevoerd wanneer
gebruiker de muisknop loslaat na
het verslepen
Wordt uitgevoerd
wanneer de muiscursor
Jframe binnengaat
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
}
statusBar.setText( "Mouse entered at [" + event.getX() +
", " + event.getY() + "]" );
getContentPane().setBackground( Color.GREEN );
// handle event when mouse exits area
public void mouseExited( MouseEvent event )
{
statusBar.setText( "Mouse outside window" );
getContentPane().setBackground( Color.WHITE );
}
// MouseMotionListener event handlers
// handle event when user drags mouse with button pressed
public void mouseDragged( MouseEvent event )
{
statusBar.setText( "Dragged at [" + event.getX() +
", " + event.getY() + "]" );
}
// handle event when user moves mouse
public void mouseMoved( MouseEvent event )
{
statusBar.setText( "Moved at [" + event.getX() +
", " + event.getY() + "]" );
}
Wordt uitgevoerd
wanneer de muiscursor
Jframe verlaat
Wordt uitgevoerd wanneer
de gebruiker de
muiscursor versleept
Wordt uitgevoerd
wanneer de
gebruiker de
muiscursor beweegt
79
80
81
82
);
83
84
85
public static void main( String args[] )
{
MouseTracker application = new MouseTracker();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE
}
} // end class MouseTracker
12 Adapter Classes

Adapter class



Implementeert een interface
Voorziet in een default implementatie voor
elke methode van de interface
Wordt gebruikt als superclass wanneer
niet alle methoden uit de overeenkomstige
interface nodig zijn
JAVA
76
Event adapter classes en de
interfaces die ze implementeren.
Event adapter class
ComponentAdapter
ContainerAdapter
FocusAdapter
KeyAdapter
MouseAdapter
MouseMotionAdapter
WindowAdapter
implements interface
ComponentListener
ContainerListener
FocusListener
KeyListener
MouseListener
MouseMotionListener
WindowListener
JAVA
77
VB: Gebruik van
de class MouseMotionAdapter
JAVA
78
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Fig. 13.19: Painter.java
// Using class MouseMotionAdapter.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Painter extends JFrame {
private int pointCount = 0;
// array of 1000 java.awt.Point references
private Point points[] = new Point[ 1000 ];
// set up GUI and register mouse event handler
public Painter()
{
super( "A simple paint program" );
// create a label and place it in SOUTH of BorderLayout
getContentPane().add( new JLabel( "Drag the mouse to draw" ),
BorderLayout.SOUTH );
Registreer MouseMotionListener
om de window’s ”mouse-motion events”
new MouseMotionAdapter() { // anonymous inner class
te horen
addMouseMotionListener(
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// store drag coordinates and repaint
public void mouseDragged( MouseEvent event )
{
if ( pointCount < points.length ) {
points[ pointCount ] = event.getPoint();
++pointCount;
repaint();
}
}
Overschrijf alleen de methode
mouseDragged, niet de methode
mouseMoved
Sla de plaatscoördinaten op waar de
muis versleept was, herteken daarna
JFrame
} // end anonymous inner class
); // end call to addMouseMotionListener
setSize( 300, 150 );
setVisible( true );
} // end Painter constructor
// draw oval in a 4-by-4 bounding box at specified location on window
public void paint( Graphics g )
{
super.paint( g ); // clears drawing area
}
for ( int i = 0; i < points.length && points[ i ] != null; i++ )
g.fillOval( points[ i ].x, points[ i ].y, 4, 4 );
Teken een cirkel met
diameter 4 waarnaar de
gebruiker de cursor
versleept heeft
53
54
55
56
57
58
59
60
public static void main( String args[] )
{
Painter application = new Painter();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class Painter
VB: Het gebruik van “mouse clicks”
en het onderscheid tussen “mouse
buttons”
JAVA
82
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Fig. 13.20: MouseDetails.java
// Demonstrating mouse clicks and distinguishing between mouse buttons.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MouseDetails extends JFrame {
private int xPos, yPos;
// set title bar String; register mouse listener; size and show window
public MouseDetails()
{
super( "Mouse clicks and buttons" );
addMouseListener( new MouseClickHandler() );
}
setSize( 350, 150 );
setVisible( true );
// draw String at location where mouse was clicked
public void paint( Graphics g )
{
// call superclass paint method
super.paint( g );
Registreer de muis
listener
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
}
g.drawString( "Clicked @ [" + xPos + ", " + yPos + "]",
xPos, yPos );
public static void main( String args[] )
{
MouseDetails application = new MouseDetails();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
De methode mouseClicked
wordt uitgevoerd wanneer de
gebruiker op de muis klikt
// handle mouse click event and determine which button was pressed
Onthoud de muis-cursor
public void mouseClicked( MouseEvent event )
coördinaten waar men op de
{
muis geklikt heeft
// inner class to handle mouse events
private class MouseClickHandler extends MouseAdapter {
xPos = event.getX();
yPos = event.getY();
String title = "Clicked " + event.getClickCount() + " time(s)";
if ( event.isMetaDown() ) // right mouse button
title += " with right mouse button";
else if ( event.isAltDown() ) // middle mouse button
title += " with center mouse button";
Bepaal het aantal keer dat
de gebruiker op de muis
geklikt heeft
Zoek uit of de gebruiker
op de rechter muisknop
heeft geklikt
Zoek uit of de gebruiker
op de middelste
muisknop heeft geklikt
53
54
55
56
57
58
59
60
61
62
63
64
else // left mouse button
title += " with left mouse button";
setTitle( title ); // set title bar of window
repaint();
} // end method mouseClicked
} // end private inner class MouseClickHandler
} // end class MouseDetails
InputEvent methoden voor mousebutton clicks
InputEvent methode
isMetaDown()
isAltDown()
Beschrijving
Deze methode retourneert true wanneer de
gebruiker de rechter muisknop van een twweof drieknopsmuis aanklikt. Om een rechter
muisknop klik te simuleren met een één-knops
muis, kan de gebruiker de Meta key op het
toetsenbord indrukken en op de muisknop
klikken.
Deze methode retourneert true wanneer de
gebruiker op de middelste muisknop klikt van
een drie-knops-muis met drie knoppen Om een
middelste muisknop klik te simuleren met een
één-of twee-knops muis, kan de gebruiker de
Alt key op het toetsenbord indrukken en op de
muisknop klikken.
JAVA
86
12 Event Handling voor het
toetsenbord

interface KeyListener

Behandelt key events


Treedt in werking wanneer de toetsen op het
toetsenbord ingedrukt en losgelaten worden
KeyEvent

Bevat virtual key code die de toets voorstelt
JAVA
87
VB: Voorstelling van de events
van het toetsenbord
JAVA
88
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Fig. 13.22: KeyDemo.java
// Demonstrating keystroke events.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class KeyDemo extends JFrame implements KeyListener {
private String line1 = "", line2 = "", line3 = "";
private JTextArea textArea;
// set up GUI
public KeyDemo()
{
super( "Demonstrating Keystroke Events" );
// set up JTextArea
textArea = new JTextArea( 10, 15 );
textArea.setText( "Press any key on the keyboard..." );
textArea.setEnabled( false );
textArea.setDisabledTextColor( Color.BLACK );
getContentPane().add( textArea );
JFrame voor de
toets events
addKeyListener( this ); // allow frame to process KeyRegistreer
events
setSize( 350, 100 );
setVisible( true );
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
} // end KeyDemo constructor
// handle press of any key
public void keyPressed( KeyEvent event )
Wordt aangeroepen wanneer
{
de gebruiker een toets indrukt
line1 = "Key pressed: " + event.getKeyText( event.getKeyCode() );
setLines2and3( event );
}
// handle release of any key
Wordt aangeroepen wanneer
public void keyReleased( KeyEvent event )
de gebruiker de toets loslaat
{
line1 = "Key released: " + event.getKeyText( event.getKeyCode() );
Geef de virtual key
setLines2and3( event );
terug
}
// handle press of an action key
public void keyTyped( KeyEvent event )
{
line1 = "Key typed: " + event.getKeyChar();
setLines2and3( event );
}
// set second and third lines of output
private void setLines2and3( KeyEvent event )
{
Wordt aangeroepen
wanneer de gebruiker de
toets intypt
code
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
line2 = "This key is " + ( event.isActionKey() ? "" : "not " ) Zoekt
+
"an action key";
uit of modifier keys (zoals Alt,
Ctrl, Meta en Shift) gebruikt werden
String temp = event.getKeyModifiersText( event.getModifiers() );
line3 = "Modifier keys pressed: " +
( temp.equals( "" ) ? "none" : temp );
}
textArea.setText( line1 + "\n" + line2 + "\n" + line3 + "\n" );
public static void main( String args[] )
{
KeyDemo application = new KeyDemo();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class KeyDemo
14 Layout Managers

Layout managers





Voorzien een ordening voor de GUI
componenten
Voorzien eenvoudige layout mogelijkheden
Verwerken layout details
De programmeur concentreert zich op de
“look and feel”
interface LayoutManager
JAVA
93
Layout managers
Layout
manager
FlowLayout
BorderLayout
GridLayout
Beschrijving
Default voor java.awt.Applet, java.awt.Panel en
javax.swing.JPanel. Plaatst de componenten in de volgorde
dat ze toegevoegd werden na elkaar (van links naar rechts).
Het is ook mogelijk de volgorde van de componenten te
specifieren door gebruik te maken maken van de Container
methode add waar men de Component en de index plaats (
een integer) als argumenten meegeeft.
Default voor de content panes of Jframe’s (en andere
vensters) en Japplet’s. Ordent de componenten binnen vijf
gebieden: North, South, East, West en Center.
Ordent de componenten in rijen en kolommen.
JAVA
94
14.1 FlowLayout

FlowLayout


De meest eenvoudige layout manager
De GUI componenten worden in de
container van links naar rechts geplaatst
JAVA
95
VB: Het gebruik van FlowLayout
JAVA
96
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Fig. 13.24: FlowLayoutDemo.java
// Demonstrating FlowLayout alignments.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class FlowLayoutDemo extends JFrame {
private JButton leftButton, centerButton, rightButton;
private Container container;
private FlowLayout layout;
// set up GUI and register button listeners
public FlowLayoutDemo()
{
super( "FlowLayout Demo" );
layout = new FlowLayout();
// get content pane and set its layout
container = getContentPane();
container.setLayout( layout );
// set up leftButton and register listener
leftButton = new JButton( "Left" );
container.add( leftButton );
FlowLayout wordt
ingesteld
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
leftButton.addActionListener(
new ActionListener() { // anonymous inner class
// process leftButton event
public void actionPerformed( ActionEvent event )
{
layout.setAlignment( FlowLayout.LEFT );
}
// realign attached components
layout.layoutContainer( container );
} // end anonymous inner class
); // end call to addActionListener
// set up centerButton and register listener
centerButton = new JButton( "Center" );
container.add( centerButton );
centerButton.addActionListener(
Wanneer de
gebruiker de
Jbutton
leftButton
indrukt, worden de
componenten links
gealigneerd
new ActionListener() { // anonymous inner class
// process centerButton event
public void actionPerformed( ActionEvent event )
{
layout.setAlignment( FlowLayout.CENTER );
Wanneer de gebruiker de JButton
centerButton indrukt, worden
de componenten gecentreerd
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
);
}
}
// realign attached components
layout.layoutContainer( container );
// set up rightButton and register listener
rightButton = new JButton( "Right" );
container.add( rightButton );
rightButton.addActionListener(
new ActionListener() { // anonymous inner class
// process rightButton event
public void actionPerformed( ActionEvent event )
{
layout.setAlignment( FlowLayout.RIGHT );
);
}
}
// realign attached components
layout.layoutContainer( container );
setSize( 300, 75 );
setVisible( true );
Wanneer de
gebruiker de
JButton
rightButton
indrukt, worden de
componenten
rechts gealigneerd
81
82
83
84
85
86
87
88
89
90
} // end constructor FlowLayoutDemo
public static void main( String args[] )
{
FlowLayoutDemo application = new FlowLayoutDemo();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class FlowLayoutDemo
14.2 BorderLayout

BorderLayout

Ordent de componenten binnen vijf
gebieden





NORTH
SOUTH
EAST
WEST
CENTER
(bovenaan de container)
(onderaan de container)
(links in de container)
(rechts in de container)
(midden van de container)
JAVA
101
VB: Het gebruik van
BorderLayout
JAVA
102
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Fig. 13.25: BorderLayoutDemo.java
// Demonstrating BorderLayout.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class BorderLayoutDemo extends JFrame implements ActionListener {
private JButton buttons[];
private final String names[] = { "Hide North", "Hide South",
"Hide East", "Hide West", "Hide Center" };
private BorderLayout layout;
// set up GUI and event handling
public BorderLayoutDemo()
{
super( "BorderLayout Demo" );
layout = new BorderLayout( 5, 5 ); // 5 pixel gaps
// get content pane and set its layout
Container container = getContentPane();
container.setLayout( layout );
// instantiate button objects
buttons = new JButton[ names.length ];
BorderLayout wordt ingesteld
met horizontale en verticale 5-pixel
afstanden
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
for ( int count = 0; count < names.length; count++ ) {
buttons[ count ] = new JButton( names[ count ] );
buttons[ count ].addActionListener( this );
}
// place buttons in BorderLayout; order not important
container.add( buttons[ 0 ], BorderLayout.NORTH );
container.add( buttons[ 1 ], BorderLayout.SOUTH );
container.add( buttons[ 2 ], BorderLayout.EAST );
container.add( buttons[ 3 ], BorderLayout.WEST );
container.add( buttons[ 4 ], BorderLayout.CENTER );
De JButtons worden in de
resp.gebieden gezet aangeduidt
door de BorderLayout
setSize( 300, 200 );
setVisible( true );
} // end constructor BorderLayoutDemo
// handle button events
public void actionPerformed( ActionEvent event )
{
for ( int count = 0; count < buttons.length; count++ )
if ( event.getSource() == buttons[ count ] )
buttons[ count ].setVisible( false );
else
buttons[ count ].setVisible( true );
Wanneer Jbutton’s
“onzichtbaar ” zijn worden ze
niet op het scherm getoond, en
zal de BorderLayout ze
herschikken
53
54
55
56
57
58
59
60
61
62
63
64
}
// re-layout the content pane
layout.layoutContainer( getContentPane() );
public static void main( String args[] )
{
BorderLayoutDemo application = new BorderLayoutDemo();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class BorderLayoutDemo
14.3 GridLayout

GridLayout


De container wordt verdeeld in een raster
(grid) met een gegeven aantal rijen en
kolommen
Componenten worden toegevoegd vanaf
de linkerbovencel

Van links naar rechts tot het einde van de rij en
dan de volgende rij
JAVA
107
VB: Het gebruik van GridLayout
JAVA
108
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Fig. 13.26: GridLayoutDemo.java
// Demonstrating GridLayout.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class GridLayoutDemo extends JFrame implements ActionListener {
private JButton buttons[];
private final String names[] =
{ "one", "two", "three", "four", "five", "six" };
private boolean toggle = true;
private Container container;
private GridLayout grid1, grid2;
// set up GUI
public GridLayoutDemo()
{
super( "GridLayout Demo" );
// set up layouts
grid1 = new GridLayout( 2, 3, 5, 5 );
grid2 = new GridLayout( 3, 2 );
// get content pane and set its layout
container = getContentPane();
container.setLayout( grid1 );
Maak GridLayout grid1
met 2 rijen en 3 kolommen
Maak GridLayout grid2
met 3 rijen en 2 kolommen
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// create and add buttons
buttons = new JButton[ names.length ];
for ( int count = 0; count < names.length; count++ ) {
buttons[ count ] = new JButton( names[ count ] );
buttons[ count ].addActionListener( this );
container.add( buttons[ count ] );
}
setSize( 300, 150 );
setVisible( true );
} // end constructor GridLayoutDemo
// handle button events by toggling between layouts
public void actionPerformed( ActionEvent event )
{
if ( toggle )
container.setLayout( grid2 );
else
container.setLayout( grid1 );
}
toggle = !toggle; // set toggle to opposite value
container.validate();
Wanneer de gebruiker
Jbutton indrukt wijzigt de
huidige GridLayout
53
54
55
56
57
58
59
60
public static void main( String args[] )
{
GridLayoutDemo application = new GridLayoutDemo();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class GridLayoutDemo
15 Panels

Panel



Helpt om de componenten te organiseren
class JPanel is een subclass van
JComponent
Kan componenten en andere panels
bevatten
JAVA
112
VB: Gebruik van JPanel
JAVA
113
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Fig. 13.27: PanelDemo.java
// Using a JPanel to help lay out components.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class PanelDemo extends JFrame {
private JPanel buttonPanel;
private JButton buttons[];
// set up GUI
public PanelDemo()
{
super( "Panel Demo" );
// get content pane
Container container = getContentPane();
// create buttons array
buttons = new JButton[ 5 ];
// set up panel and set its layout
buttonPanel = new JPanel();
Maak
buttonPanel.setLayout( new GridLayout( 1, buttons.length ) );
JPanel buttonPanel
om JButton’s bij te houden
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// create and add buttons
for ( int count = 0; count < buttons.length; count++ ) {
buttons[ count ] = new JButton( "Button " + ( count + 1 ) );
buttonPanel.add( buttons[ count ] );
}
Voeg JButton’s toe aan
JPanel buttonPanel
container.add( buttonPanel, BorderLayout.SOUTH );
setSize( 425, 150 );
setVisible( true );
} // end constructor PanelDemo
Voeg JPanel
buttonPanel toe aan
het gebied “SOUTH”
van Container
container
public static void main( String args[] )
{
PanelDemo application = new PanelDemo();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class PanelDemo
Oefening 3

Haal oefening 2 terug en wijzig tot een
meer georganiseerde GUI, weer zonder
functionaliteit.
JAVA
116
//LineTest_View2.java
//Java core packages
import java.awt.*;
import java.awt.event.*;
//Java extension packages
import javax.swing.*;
import javax.swing.border.*;
public class LineTest_View2 extends JFrame
{
private JPanel leftPanel, rightPanel, middenPanel,buttonPanel;
private JRadioButton redButton, greenButton, blueButton, yellowButton;
private ButtonGroup radioGroup;
private JCheckBox dashed, thick, rounded;
private JButton defaults, ok, cancel;
//create GUI
public LineTest_View2()
{
super ("LineTest View2");
//get content pane and set its layout
Container container= getContentPane();
//set up leftpanel and set its layout
leftPanel = new JPanel(new GridLayout(4,1));
leftPanel.setBorder(
new TitledBorder(
new EtchedBorder(), "Line Color"));
//create radio buttons in leftPanel
redButton = new JRadioButton("RED",false);
leftPanel.add(redButton);
greenButton = new JRadioButton("GREEN",false);
leftPanel.add(greenButton);
blueButton = new JRadioButton("BLUE",true);
leftPanel.add(blueButton);
yellowButton = new JRadioButton("YELLOW",false);
leftPanel.add(yellowButton);
//create logical relationship between JRadioButtons
radioGroup = new ButtonGroup();
radioGroup.add(redButton);
radioGroup.add(greenButton);
radioGroup.add(blueButton);
radioGroup.add(yellowButton);
//set up rightPanel and set its layout
rightPanel = new JPanel(new GridLayout(4,1));
rightPanel.setBorder(
new TitledBorder(new EtchedBorder(), "Line Properties"));
//create checkboxobjects
dashed = new JCheckBox("DASHED");
rightPanel.add(dashed);
thick = new JCheckBox("THICK");
rightPanel.add(thick);
rounded = new JCheckBox("ROUNDED");
rightPanel.add(rounded);
//set up middenPanel (left + right)
middenPanel= new JPanel(new GridLayout(1,2));
middenPanel.add(leftPanel);
middenPanel.add(rightPanel);
container.add(middenPanel);
//set up buttonpanel and set its layout
buttonPanel = new JPanel();
buttonPanel.setBorder(new TitledBorder(new EtchedBorder(),""));
//create buttons
defaults = new JButton("Defaults");
buttonPanel.add(defaults);
ok = new JButton("OK");
buttonPanel.add(ok);
cancel = new JButton("Cancel");
buttonPanel.add(cancel);
container.add(buttonPanel, BorderLayout.SOUTH);
setSize(300,350);
setVisible(true);
}
//execute application
public static void main(String args[])
{
LineTest_View2 application = new LineTest_View2();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
}