Voor het maken van applets en toepassingen met een grafische omgeving (GUI: Graphical User Interface) maak je best gebruik van Swing-componenten.
Swing is een set pakketten die voortbouwen op de vroegere AWT (Abstract Windowing Toolkit). In AWT bestonden dus reeds heel wat componenten die nu een parallelle tegenhanger hebben in Swing.
Daar Swing gebaseerd is op AWT kunnen we er voor de cursus niet omheen, en zullen dus ook heel wat AWT-begrippen aan bod komen.
Swing maakt zelf deel uit van de JFC (Java Foundation Classes), deze omvatten:
Swing: maken van een User Interface
Klembordondersteuning (knippen en plakken)
Toegankelijkheidsvoorzieningen
Desktop-Colors-elementen
Java-2D (verbeterde ondersteuning voor kleur, afbeelding, tekst)
Afdrukken
Voor het maken van GUI-toepassingen met Java zijn volgende begrippen van heel groot belang:
Begrip
Beschrijving
Component
De elementen die dienen voor de gebruikersinterface: drukknoppen, keuzelijsten, selectierondjes, tekstvakken, labels, ...
Container
Vensters (JFrame, JApplet) of panelen (JPanel) die componenten kunnen bevatten.
Layout
Bepalen de schikking van componenten in een container
Listener
Worden aan componenten gekoppeld om gebeurtenissen te kunnen afhandelen, met behulp van listeners kan je code schrijven die moet worden uitgevoerd als een knop wordt ingedrukt, een keuze in een lijst wordt gemaakt, ...
Swing componenten
Daar Swing deel uitmaakt van de JFC beginnen de namen van Swing-componenten met een J:
component
beschrijving
JApplet
Uitgebreide versie van java.applet.Applet met ondersteuning voor panelen
JFrame
Uitgebreide versie van java.awt.Frame met ondersteuning voor panelen
JLabel
Label
JButton
Opdrachtknop
JList
Keuzelijst
en nog veel meer...
De klassen die de basis vormen voor applets en toepassingen JApplet en JFrame hebben een kind-object dat al het grafische werk verricht, en dit object is van de klasse JRootPane. In vroegere AWT-toepassingen kon je componenten rechtstreeks aan appplets of frame-vensters toevoegen.
Met Swing ligt het iets complexer:
Het JRootPane bestaat in principe uit twee andere panelen: een glassPane en een layeredPane. Het glassPane is verantwoordelijk voor het opvangen van muisgebeurtenissen. Het layeredpane bevat een contentPane (inhoud) en een menubalk.
Concreet betekent dit dat wanneer we straks componenten teovoegen aan een applet of frame-toepassing deze elementen aan de contentPane van JRootPane worden toegevoegd.
De eigenlijke componenten die dan aan het paneel toevoegt zijn afgeleid van de klasse JComponent.
Applets en Frames (venstertoepassingen)
De gebruikte Java-editor noteert in de automatisch gegenereerde code de volledige naam van een klasse, met namespace en pakket-aanduiding. Dit kan manueel natuurlijk een stuk korter met de nodige import-statements bovenaan de code.
Swing applet
Je kan Swing-applets maken op basis van de JApplet-klasse. Deze klasse wordt een zwaargewicht-klasse genoemd daar deze een uitbreiding vormt op de AWT-klasse Applet.
Het tekenen van inhoud gebeurt in de JRootPane-klasse die een veld is van de JApplet-klasse.
Voor het maken van de voorbeelden maak ik gebruik van de editor NetBeans IDE. Door een editor te gebruiken hoef je vele stukken code niet in te tikken.
De code die voor de voorbeelden irrelevant is (zoals automatisch gegenereede commentaar) is hier veelal weggelaten.
public class Alabel extends javax.swing.JApplet {
public void init() {
initComponents();
}
private void initComponents() {
jLabel1 = new javax.swing.JLabel();
getContentPane().setLayout(new java.awt.FlowLayout());
jLabel1.setText(""Groeten van Swing"");
getContentPane().add(jLabel1);
}
// Variables declaration - do not modify
private javax.swing.JLabel jLabel1;
// End of variables declaration
}
De klasse die we maakten is afgeleid van de javax.swing.JApplet-klasse: we maken een applet met Swing-functionaliteiten.
De init-methode bevat voor een Applet de code die eerst moet worden uitgevoerd.
In de methode init roepen we onmiddellijk de methode initComponents op: deze bevat de code voor het plaatsen van de componenten op de Applet (gemakkelijk doordat deze code door NetBeans IDE wordt gegenereerd wanneer je de form-editor gebruikt).
Binnen de methode initComponents maken we een nieuwe instantie van de klasse JLabel aan: een label.
De methode getContentPane van de klasse JApplet laat je toe het inhoudspaneel (container) te benaderen.
We zorgen ervoor dat dit paneel de FlowLayout gebruikt, alle componenten zullen gewoon naast elkaar worden getoond. Meer over layouts verderop in de cursus.
De setText-methode van een JLabel wordt toegepast om de tekst die in het JLabel moet worden geplaatst in te stellen.
Het label wordt toegevoegd aan het contentPane met de methode add.
Swing frame-applicatie
public class Flabel extends javax.swing.JFrame {
public Flabel() {
initComponents();
}
private void initComponents() {
jLabel1 = new javax.swing.JLabel();
getContentPane().setLayout(new java.awt.FlowLayout());
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jLabel1.setText("Groeten van Swing");
getContentPane().add(jLabel1);
pack();
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
public static void main(String args[]) {
new Flabel().show();
}
private javax.swing.JLabel jLabel1;
}
De eerste routine die wordt opgestart in een vensterapplicatie is de main-methode. Hier maken we met het sleutelwoord new een instantie van de klasse Flabel en tonen die op het scherm met de methode show.
public static void main(String args[]) {
new Flabel().show();
}
Bij het maken van de instantie van onze klasse wordt de constructor van de klasse uitgevoerd:
public Flabel() {
initComponents();
}
De constructor laat de methode initComponents uitvoeren: de plaats waar we ervoor zorgen dat de juiste componenten op het formulier geplaatst worden.
private void initComponents() {
jLabel1 = new javax.swing.JLabel();
getContentPane().setLayout(new java.awt.FlowLayout());
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jLabel1.setText("Groeten van Swing");
getContentPane().add(jLabel1);
pack();
}
De pack-methode van de klasse Window zorgt ervoor dat het venster zich aanpast aan de grootte van de componenten.
Er werd ook een routine voorzien voor het correct aflsluiten van het programma bij het sluiten van het venster:
Met de methode addWindowListener van de klasse Window kan je ervoor zorgen dat je gebeurtenissen zoals sluiten, openen, activeren, deactiveren van het venster kan opvangen.
Aan de methode addWindowListener moet je een object van het type WindowListener doorgeven
WindowListener is een interface: een klasse waarin enkel methoden gedeclareerd zijn maar niet uitgewerkt, we moeten zelf de code hiervoor schrijven.
Als je de WindowListener-interface implementeert (met het sleutelwoord implements na een klassenaam) ben je verplicht alle methoden van die klasse te implementeren en bezorg je jezelf heel wat werk (de interface WindowListener heeft 7 methoden).
Wij zijn enkel geïnteresseerd in de methode windowClosing van de interface WindowListener.
Gelukkig bestaan er in Java Adapterklassen: deze klassen implenteren een (of meerdere) interfaces, en implementeren alle methodes ervan, maar zonder opvulling: allen lege methodes !
Het leuke is nu dat wanneer we een instantie van die adapterklasse maken we alle methoden van de interface reeds geïmplementeerd hebben (in de adapterklasse) en dat we nu de methoden die we zelf wensen te gebruiken kunnen overriden.
In het bovenstaande voorbeeld gebruiken we hiervoor een anonieme binnenklasse die als supertype WindowAdapter heeft. Deze klasse implementeert onder meer de interface WindowListener die wij nodig hebben. In onze klasse overriden we de methode windowClosing van de adapterklasse met onze eigen opvulling.
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
We geven de methode een opvulling zondanig dat onze methode exitForm wordt uitgevoerd. We geven het WindowEvent - het object dat de gegevens van de gebeurtenis bevat, in ons geval het sluiten van het formulier - mee onder de naam evt. In de methode exitForm staat de opdracht om het programma af te sluiten:
Het label jLabel1 is overal in deze klasse steeds bereikbaar:
private javax.swing.JLabel jLabel1;
Dit stuk code staat in het voorbeeld onderaan (gegenereerd door NetBeans IDE) maar kan gerust onmiddellijk na de klassedeclaratie komen.
Concrete voorbeelden
We maken een aantal toepassingen om het werken met Swing te leren kennen.
Je kan voor de toepassingen een zip-bestand downloaden, dit bestand bevat de java- en .class-bestanden. Er zijn ook eventuele andere bestanden aanwezig (figuren) en .form-bestanden voor de NetBeans IDE. Op deze manier kan je deze voorbeelden gemakkelijk in een nieuw NetBeans project gebruiken met form-editor.
Aantal keer klikken tellen
import javax.swing.*;
public class Fknop extends javax.swing.JFrame {
public static int aantalklik = 0;private static String labelPrefix = "Aantal klikken: ";
public Fknop() {
initComponents();
}
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jButton1 = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
setTitle("Kliken op een knop");
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jPanel1.setLayout(new javax.swing.BoxLayout(jPanel1, javax.swing.BoxLayout.Y_AXIS));jPanel1.setBorder(new javax.swing.border.EmptyBorder(new java.awt.Insets(10, 10, 10, 10)));jPanel1.setPreferredSize(new java.awt.Dimension(200, 100));
jButton1.setText("Klik me");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
jPanel1.add(jButton1);
jLabel1.setPreferredSize(new java.awt.Dimension(0, 50));
jPanel1.add(jLabel1);
getContentPane().add(jPanel1, java.awt.BorderLayout.CENTER);
pack();
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
aantalklik++;
jLabel1.setText(labelPrefix + aantalklik);
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
public static void main(String args[]) {
new Fknop().show();
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
// End of variables declaration
}
We geven het JFame een titel:
setTitle("Kliken op een knop");
JPanel1 gebruikt een BoxLayout, zie verderop JPanel1 krijgt een EmptyBorder - lege rand (afstand tot de rand): aan de vier zijden 10px - afmetingen worden geregeld met Insets. JPanel1 krijgt een voorkeursafmeting van 200 bij 100px.
Het hoofdpaneel (ContentPane) krijgt een BorderLayout, zie verderop.
We gebruiken een ActionListener om het klikken op de knop te kunnen afhandelen.
We doen dit opnieuw door gebruik te maken van een anonieme binnenklasse die als supertype de interface ActionListener heeft (uit het java.awt.event-pakket).
Deze keer hoeven we geen Adapterklasse (zie hierboven) te gebruiken die reeds alle methoden van de interface implementeert, want de interface ActionListener heeft slechts 1 methode: actionPerformed. Deze methode wordt dus geïmplementeerd in onze anonieme binnenklasse.
In de implementatie van de methode roepen we de eigen methode jButton1ActionPerformed waaraan we het ActionEvent-object onder de naam evt doorgeven.
In de methode verhogen we de variabele aantalklik met 1 en stellen we de tekst van het label opnieuw in.
Implementeren van de interface ActionListener, ander methode:
Je kan in de klasse FKnop de interface ActionListener implementeren en in de klasse een methode actionPerformed(ActionEvent evt) voorzien.
...
public class Fknop extends JFrame implements ActionListener{
...
public void actionPerformed(ActionEvent evt){
...
}
...
}
Wanneer je nu echter met meerdere componenten te maken hebt die de ActionListener gebruiken, moet je binnen de methode actionPerformed de bron van de gebeurtenis kunnen vaststellen (op welke knop werd er geklikt?). Dit kan je met de getSource-methode van het ActionEvent-object:
...
if(evt.getSource()=jButton2){...}
...
Temperatuursconversie Celsius - Fahrenheit
public class Ftempconversie extends javax.swing.JFrame {
public Ftempconversie() {
initComponents();
}
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
tempCelsius = new javax.swing.JTextField();
jLabel1 = new javax.swing.JLabel();
jButton1 = new javax.swing.JButton();
fahrenheitlabel = new javax.swing.JLabel();
setTitle("Temperatuur omzetten C - F");
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jPanel1.setLayout(new java.awt.GridLayout(2, 2, 10, 10));
tempCelsius.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
actie(evt);
}
});
jPanel1.add(tempCelsius);
jLabel1.setText("Celsius");
jLabel1.setBorder(new javax.swing.border.EmptyBorder(new java.awt.Insets(5, 5, 5, 5)));
jPanel1.add(jLabel1);
jButton1.setText("Converteer");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
actie(evt);
}
});
jPanel1.add(jButton1);
fahrenheitlabel.setText("Fahrenheit");
fahrenheitlabel.setBorder(new javax.swing.border.EmptyBorder(new java.awt.Insets(5, 5, 5, 5)));
jPanel1.add(fahrenheitlabel);
getContentPane().add(jPanel1, java.awt.BorderLayout.CENTER);
pack();
}
private void actie(java.awt.event.ActionEvent evt) {
int tempFahr = (int)((Double.parseDouble(tempCelsius.getText()))
* 1.8 + 32);
fahrenheitlabel.setText(tempFahr + " Fahrenheit");
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
public static void main(String args[]) {
new Ftempconversie().show();
}
// Variables declaration - do not modify
private javax.swing.JLabel fahrenheitlabel;
private javax.swing.JButton jButton1;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JTextField tempCelsius;
// End of variables declaration
}
In deze toepassing kan de gebruiker een waarde ingeven in een tekstvak. Wanneer de gebruiker op enter drukt in het tekstvak tempCelsius of op de knop jButton1 drukt berekenen we de temperatuur in Fahrenheit en zetten het resultaat in het label fahrenheitlabel.
Deze keer zullen dus twee acties hetzelfde resultaat hebben: drukken op enter in het tekstvak en klikken op de knop.
We zorgen er dus voor dat beide componenten de ActionListener-interface implementeren en de methode actionPerformed bevatten. We zorgen er dan voor dat beide acties dezelfde methode actie uitvoeren: we gaan het omzetten van de temperatuur toch geen twee keer programmeren.
Het eigenlijke omzetten van de temperatuur gebeurt dus in de methode actie:
Met de methode getText lezen we de inhoud van het tekstvak tempCelsius. We zetten de waarde om in een Double met behulp van de methode parseDouble van de Double-klasse. De methode getText levert een String-waarde, hiermee kunnen we niet rekenen! We voeren daarna de berekening uit ( *1.8 +32) en typecasten het resultaat tot een int (geheel getal).
Swing-componenten: hoofdniveau containers
In dit en volgende onderdelen krijg je een overzicht van de componenten die je kan gebruiken met Swing.
De aangegeven methoden zijn beschikbaar voor de component maar kunnen overgeërfd zijn uit een superklasse. Er zijn voor deze componenten nog heel wat meer methoden beschikbaar, bekijk indien nodig de Sun API door op de naam van de component te klikken.
Deze componenten vormen het hoofdniveau van een Swing-toepassing
wordt 1 keer uitgevoerd wanneer de Applet geladen is
start
wordt uitgevoerd na init en telkens wanneer de Applet opnieuw op het scherm verschijnt (wanneer de gebruiker bv. naar een andere pagina surft en terugkeert)
stop
wordt wanneer de browser naar een andere pagina gaat
destroy
wanneer de applet op het punt staat uit het geheugen te worden verwijderd
Een paneel met scrollmogelijkheid, waarin je een andere component (client) zoals een JList, JTextArea kan laten scrollen.
Een veelgebruikte methode is setViewportView(Component) Hiermee geef je aan welke component scrollmogelijkheid moet hebben als je dat niet hebt gedaan in de constructor van de JScrollPane.
Maak een tekstvak met een breedte (ongeveer) gelijk aan k, deze breedte is niet exact doordat niet alle letters in verschillende lettertypes evenveel plaats innemen
JTextField tf = new JTextField(String t);
Een tekstvak waarin een stuk tekst t staat
JTextField tf = new JTextField(String t, int k);
Tekstvak met de tekst t en (ongeveer) een breedte voor k tekens
addActionListener
Routine uitgevoerd wanneer op enter wordt gedrukt in het tekstvak. Interface ActionListener, te implementeren: actionPerfomed
setText(tekst)
De tekst in het tekstvak instellen
setEditable(bool)
Kan de tekst bewerkt worden?
setFont(f)
Stel het lettertype in voor het tekstvak
setHorizontalAlignment(align)
Stel de horizontale uitlijning in voor het tekstvak Mogelijke waarden zijn JTextField.LEFT (standaard), JTextField.CENTER, or JTextField.RIGHT.
requestFocus()
Geef het element de focus
Meer over JTextField maar ook JFormattedTextField en JPasswordField bij Sun
Je kan ook een array van Stringwaarden meegeven om de combobox initieel te vullen.
addActionListener
Routine uitgevoerd wanneer een keuze uit de lijst wordt gemaakt of op enter wordt gedrukt in het ivoervak bij een keuzelijst met invoervak. Interface ActionListener, te implementeren: actionPerfomed
setSelectedIndex(index)
Selecteer het element op positie index in de lijst
setSelectedItem(object)
Selecteer het aangegeven object in de lijst
addItem(item)
Voeg een item toe aan de lijst
insert(item,index)
Voeg een element in de lijst toe na index
remove(item)
Verwijdert item uit de lijst
remove(index)
Verwijdert item op positie index uit de lijst
getSelectedIndex()
Retourneert de index van het geselecteerde item uit de lijst
getSelectedItem()
Retourneert het geselecteerde item uit de lijst
setEditable(bool)
Als bool true is wordt de keuzelijst een keuzelijst met invoervak
Een keuzelijst waarbij meerdere items op het scherm zichtbaar zijn
Wens je te kunnen scrollen in de lijst, dan plaats je de Jlist in een JScrollPane
Standaard is een JList statisch: je kan geen elementen toevoegen en verwijderen. Wens je een dynamische lijst te maken, dan koppel je een de Jlist aan een lijstmodel zoals DefaultListModel.
JList lijst = new JList()
Je kan ook een array van Stringwaarden of een Vector meegeven om de listbox initieel te vullen.
addListSelectionListener
Actie ondernemen wanneer een waarde wordt geselecteerd. Interface ListSelectionListener met de methode valueChanged
setSelectionMode
Kan je slechts 1 waarde selecteren, meerdere aaneengesloten waarden of ook los van elkaar gelegen items? ListSelectionModel.SINGLE_SELECTION ListSelectionModel.SINGLE_INTERVAL_SELECTION ListSelectionModel.MULTIPLE_INTERVAL_SELECTION
setModel
Stelt een lijstmodel in om een dynamische lijst te maken:
DefaultListModel model = new DefaultListModel();
lijst = new JList();
lijst.setModel(model);
setSelectedIndex(index)
Selecteer het object met aangegeven index
ensureIndexIsVisible(index)
Zorg ervoor dat het item met aangegeven index zeker zichtbaar is
insert(item,index)
Voeg een element in de lijst toe na index
getSelectedIndex()
Retourneert de index van het geselecteerde item uit de lijst, -1 indien geen selectie
getSelectedIndices()
Retourneert een array met de indices van de geselecteerde items
getSelectedValue()
Retourneert de eerste geselecteerde waarde of null als er geen item geselecteerd is
getSelectedValues()
Retourneert een array met de waarden van de geselecteerde items
Een JSpinner wordt gebruikt als een JList of JCombobox, wanneer slechts 1 waarde zichtbaar moet zijn. Een JSpinner bestaat standaard uit drie subcomponenten: een editor en twee kleine knoppen. De editor is standaard een JPanel met een JFormattedTextField. De waarden van een JSpinner worden gemanipuleerd via het model van de JSpinner.
JSpinner spinner = new JSpinner();
Maakt een JSpinner met een integer SpinnerNumberModel met initiële waarde 0 en geen minimum of maximumlimiet.
JSpinner spinner = new JSpinner(SpinnerModel);
Maakt een JSpinner met het aangegeven SpinnerModel
Standaard beschik je over drie SpinnerModels:
SpinnerListModel: de waarden worden bepaald door een Array van objecten of een Lijst.
SpinnerNumberModel: numerieke waarden van het type double, int of Number. Je kan minimum- en maximumwaarde aangeven en de stapgrootte.
SpinnerDateModel: gebruikt datumgegevens
Wanneer je één van bovenstaande modellen gebruikt wordt de editor van de JSpinner automatisch ingesteld: er wordt gezorgd dat je geen onmogelijke waarden kan ingeven. De klassen JSpinner.ListEditor, JSpinner.NumberEditor, en JSpinner.DateEditor - allen subklassen van JSpinner.DefaultEditor - worden hiervoor gebruikt.
addChangeListener
Actie ondernemen wanneer de waarde van de JSpinner wordt veranderd. Interface ChangeListener met de methode stateChanged
Bovenstaande componenten kan je gebruiken in JFrame of JApplet toepassing. Je zal wellicht bij het maken van je eerste Java GUI-toepassingen merken dat het plaatsen van de verschillende componenten, en de positionering van de componenten ten opzichte van elkaar niet vanzelfsprekend is.
De positionering van componenten kan je instellen via de LayOut van een container-component zoals een JFrame, JApplet of JPanel.
Java beschikt standaard over een aantal Lay-out managers die de schikking van de componenten bepalen en waarbij je als gebruiker een aantal instellingen kan doen. De layout-manager klassen maken deel uit van het pakket java.awt.
Het is steeds een goed idee om componenten in JPanels te stoppen en niet rechtstreeks op een JFrame of JApplet te plaatsen. Een JPanel heeft standaard een FlowLayout.
Je kan de layout van bijvoorbeeld een JPanel codematig instellen met de methode setLayout
FlowLayout
De eenvoudigste layout is FlowLayout: alle componenten worden in een rij geplaatst, er wordt een nieuwe rij gestart wanneer de container niet breed genoeg is.
Je kan een uitlijning en/of een horizontale en vertikale afstand meegeven in de constructor.
Na aanpassing van het vensterformaat wordt dit bvb. :
BoxLayout
Bij een BoxLayout worden componenten geplaatst in een rij of een kolom.
Vaak kan je met een aantal JPanels met een BoxLayout componenten mooi schikken zonder ingewikkeldere layouts te gebruiken.
BoxLayout houdt rekening met de ingestelde minimum, maximum en preferred size van de componenten.
Bij een boxlayout volgens Y-axis (BoxLayout.Y-AXIS) -met de componenten onder elkaar- kan je de horizontale uitlijning beïnvloeden met de methode setAlignmentX:
Bij een boxlayout volgens X-axis (BoxLayout.X-AXIS) -met de componenten naast elkaar- kan je de vertikale uitlijning beïnvloeden met de methode setAlignmentY:
1.0 (Component.BOTTOM_ALIGNMENT): uitlijning onder
BoxLayout waarbij de componenten een AlignmentX van 0.5 hebben:
Ruimte tussen componenten kan worden gemaakt met mehoden uit de klasse Box:
rigid area: een leeg gebied met vaste dimensie - createRigidArea
glue: een ruimte met variabele dimensie die als opvulling dient - createHorizontealGlue, createVerticalGlue
custom filler: lege component met minimum-, voorkeurs- en maximumafmetingen.
Een voorbeeld van het gebruik van BoxLayout:
Het JLabel en de JList (in een JScrollPane) zijn vervat in een JPanel met BoxLayout volgens Y-axis. Tussen het label en de list is een rigid area aangebracht.
De twee knoppen zijn vervat in een JPanel met een BoxLayout volgens X-axis. Voor de eerste knop is horizontal glue opgenomen, tussen de twee knoppen een rigid area. Wanneer je de afmetingen van het venster aanpast zullen de twee knoppen even ver van elkaar blijven staan, maar ze zullen door de horizontal glue aan de linkerkant van de knoppen steeds mooi onder de rechterbenedenhoek van de JList blijven.
Het JFrame heeft ook een BoxLayout met twee JPanels volgens Y-axis.
Toon /verberg
import java.awt.*;
import java.util.*;
import javax.swing.*;
public class FBox extends javax.swing.JFrame {
private String[] namen = {"Peter","Pol","Els","Sofie","Johan","Linda","Edith","Koen","Willem" };
public FBox() {
Arrays.sort(namen);
initComponents();
}
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
jScrollPane1 = new javax.swing.JScrollPane();
jList1 = new JList(namen);
jPanel2 = new javax.swing.JPanel();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
getContentPane().setLayout(new javax.swing.BoxLayout(getContentPane(), javax.swing.BoxLayout.Y_AXIS));
setTitle("Werken met BoxLayout");
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jPanel1.setLayout(new javax.swing.BoxLayout(jPanel1, javax.swing.BoxLayout.Y_AXIS));
jPanel1.setBorder(new javax.swing.border.EmptyBorder(new java.awt.Insets(20, 20, 20, 20)));
jLabel1.setText("Kies een naam");
jPanel1.add(jLabel1);
jPanel1.add(Box.createRigidArea(new Dimension(0,10)));jScrollPane1.setAlignmentX(0.0F);
jScrollPane1.setPreferredSize(new java.awt.Dimension(200, 100));
jScrollPane1.setViewportView(jList1);
jPanel1.add(jScrollPane1);
getContentPane().add(jPanel1);
jPanel2.setLayout(new javax.swing.BoxLayout(jPanel2, javax.swing.BoxLayout.X_AXIS));
jPanel2.setBorder(new javax.swing.border.EmptyBorder(new java.awt.Insets(0, 20, 20, 20)));
jPanel2.setAlignmentX(0.0F);jPanel2.add(Box.createHorizontalGlue());
jButton1.setText("actie");
jPanel2.add(jButton1);
jPanel2.add(Box.createRigidArea(new Dimension(10, 0)));
jButton2.setText("stop");
jPanel2.add(jButton2);
getContentPane().add(jPanel2);
pack();
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
public static void main(String args[]) {
new FBox().show();
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JLabel jLabel1;
private javax.swing.JList jList1;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JScrollPane jScrollPane1;
// End of variables declaration
}
Met NetBeans IDE plaats ik de rigid area of glue in de pre-init code (properties, onderdeel code) van de component die erna wordt getoond.
Een BorderLayout staat je toe componenten als volgt te schikken:
De notatie met de windrichtingen is de naamgeving van voor Java 1.4 maar kan nog steeds gebruikt worden.
Horizontale en verikale 'witruimte' kan je aangeven met horizontal en vertical gap, deze integer waarden kan je meegeven in de constructor van de BorderLayout of instellen met de methoden setHgap en setVgap.
Toon /verberg
public class FBorder extends javax.swing.JFrame {
public FBorder() {
initComponents();
}
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jButton1 = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
jButton2 = new javax.swing.JButton();
jTextField1 = new javax.swing.JTextField();
jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();
getContentPane().setLayout(new java.awt.FlowLayout(java.awt.FlowLayout.LEFT, 10, 10));
setTitle("Werken met BorderLayout");
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
getAccessibleContext().setAccessibleName("Werken met BorderLayout");
jPanel1.setLayout(new java.awt.BorderLayout(5, 10));
jButton1.setText("Een knop");
jPanel1.add(jButton1, java.awt.BorderLayout.CENTER);
jLabel1.setBackground(java.awt.Color.orange);
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel1.setText("NORTH / PAGE_START");
jLabel1.setOpaque(true);
jPanel1.add(jLabel1, java.awt.BorderLayout.NORTH);
jButton2.setText("SOUTH / PAGE_END");
jPanel1.add(jButton2, java.awt.BorderLayout.SOUTH);
jTextField1.setText("EAST / LINE_END");
jPanel1.add(jTextField1, java.awt.BorderLayout.EAST);
jButton3.setText("WEST / LINE_START");
jPanel1.add(jButton3, java.awt.BorderLayout.WEST);
jButton4.setText("CENTER");
jPanel1.add(jButton4, java.awt.BorderLayout.CENTER);
getContentPane().add(jPanel1);
pack();
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
public static void main(String args[]) {
new FBorder().show();
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JTextField jTextField1;
// End of variables declaration
}
Met een CardLayout kan je ervoor zorgend dat componenten een plaats 'delen' in de toepassing. Je kan de componenten op gepaste momenten in de toepassing zichtaar of onzichtbaar maken.
In de praktijk plaats je een JPanel op de toepassing met een CardLayout, in het voorbeeld heeft dit JPanel de naam kaarten.
In dit JPanel plaats je dan JPanels die elkaar bedekken. Je voegt ze toe met de methode add van het overkoepelende JPanel, hierbij ken je de deelpanels een 'kaartnaam' toe (String).
De keuze voor het betreffende JPanel kan in de voorbeeldtoepassing worden aangegeven met een JComboBox.
Via de CardLayout kan je met de methode show meegeven welke de container is (hier het JPanel kaarten) en welke kaart moet worden getoond (String).
Toon /verberg
import java.awt.*;
import javax.swing.*;
public class FCard extends javax.swing.JFrame {
private String[] items = {"knoppen","tekstvak" };
public FCard() {
initComponents();
}
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jComboBox1 = new JComboBox(items);
kaarten = new javax.swing.JPanel();
jPanel3 = new javax.swing.JPanel();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();
jPanel4 = new javax.swing.JPanel();
jTextField1 = new javax.swing.JTextField();
getContentPane().setLayout(new java.awt.FlowLayout());
setTitle("Werken met CardLayout");
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jPanel1.setLayout(new java.awt.BorderLayout());
jComboBox1.addItemListener(new java.awt.event.ItemListener() {
public void itemStateChanged(java.awt.event.ItemEvent evt) {
jComboBox1ItemStateChanged(evt);
}
});
jPanel1.add(jComboBox1, java.awt.BorderLayout.NORTH);
kaarten.setLayout(new java.awt.CardLayout());
jButton1.setText("knop");
jPanel3.add(jButton1);
jButton2.setText("knop2");
jPanel3.add(jButton2);
jButton3.setText("knop3");
jPanel3.add(jButton3);
kaarten.add(jPanel3, "knoppen");
jTextField1.setText("tekst");
jPanel4.add(jTextField1);
kaarten.add(jPanel4, "tekstvak");
jPanel1.add(kaarten, java.awt.BorderLayout.SOUTH);
getContentPane().add(jPanel1);
pack();
}
private void jComboBox1ItemStateChanged(java.awt.event.ItemEvent evt) {
CardLayout cl = (CardLayout)(kaarten.getLayout());
cl.show(kaarten, (String)evt.getItem());
}
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
}
public static void main(String args[]) {
new FCard().show();
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JComboBox jComboBox1;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel3;
private javax.swing.JPanel jPanel4;
private javax.swing.JTextField jTextField1;
private javax.swing.JPanel kaarten;
// End of variables declaration
}
Met een JTabbePane kan je een vergelijkbare opmaak maken zonder gebruik te maken van een CardLayout.
Toon /verberg
