Next: 28 Dessiner sur une
Up: Java: Programmation graphique
Previous: 26 Les widgets
Subsections
Nous avons, volontairement, jusqu'ici négligé le problème
de la gestion de la disposition des composants dans un container.
Comme vous avez pu le constater, dans tous les exemples
que nous avons vus jusqu'ici, nous nous sommes contenté
d'ajouter des composants dans un container sans préciser
quoi ce soit, quant à la position de ce composant dans
le container.
Comme nous l'avons déjà signalé rapidement, certains
containers disposent par défaut une gestion de placement
(Layout Manager ) qui se charge de placer les composants ``correctement''.
Qu'entend-t-on pas correctement ?
Le problème essentiel que doit résoudre un gestionnaire
de placement est de déterminer la position et la taille
des composants les uns par rapport aux autres et ce quelle
que soit la taille de la fenêtre dans laquelle ils s'inscrivent.
Cour ce faire, il n'existe pas une seule manière de
gérer le placement des composants; il existe plusieurs
politiques de placement des composants dans un container.
Aussi Java propose plusieurs type de gestionnaires.
Par exemple, le gestionnaire
- FlowLayout est associée aux Panel.
- BorderLayout est associée aux Window.
Avant d'entrer dans la description et l'utilisation
des divers gestionnaires de placement, remarquons
qu'il est tout à fait possible de se passer d'un
gestionnaire. En effet, si l'on est très courageux,
il suffira de placer ``à la main''les différents
composants : en donnant la taille et la position
que chaque composant doit avoir dans un container.
Cette manière de faire présente deux défauts majeurs:
- elle oblige de déterminer de manière précise
la configuration des différents composants; tâche
souvent très fastidieuse.
- la taille par défaut des composants peut varier
d'un système à l'autre et la belle configuration sur
un système peut avoir une allure catastrophique sur
un autre système.
Aussi, il est toujours conseillé d'utiliser un gestionnaire de placement.
Si malgré tout, on veut se passer de gestionnaire
de placement, il suffira de préciser qu'un container
ne possède pas de gestionnaire de placement en invoquant la
méthode
Avec cet appel, le programmeur prendre la responsabilité
de placer correctement les composants. Il lui appartient
de définir précisément où les composant s'inscrivent
dans un container en précisant avec la méthode setBounds.
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Null extends Applet {
Panel p1, p2, p3;
public void init() {
setLayout(null);
add(p1 = new Panel());
add(p2 = new Panel());
add(p3 = new Panel());
p1.setBackground(Color.red);
p2.setBackground(Color.green);
p3.setBackground(Color.blue);
p1.setBounds(10, 10, 60, 60);
p2.setBounds(80, 10, 60, 60);
p3.setBounds(150, 10, 60, 60);
}
public void paint(Graphics g) {
Dimension d = getSize();
g.drawRect(1,1, d.width-2, d.height-2);
}
public static void main(String[] args) {
Frame f = new Frame("Position et Dimensions");
Null p = new Null();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) { System.exit(0); }
});
p.init();
f.add(p);
f.pack();
f.setSize(250, 120);
f.show();
}
}
|
Reprenons l'exemple précédemment vu et
supprimons le gestionnaire de placement que nous
avons utilisé. Rappelons que ce gestionnaire se
chargeait et du placement des boutons et la gestion
de la taille de ces dernier en fonction de la
modification de leur étiquette.
En supprimant ce gestionnaire, il appartient au
programmeur d'effectuer toutes ses taches.
public class TroisBoutons extends Applet implements ActionListener {
...
public void init() {
...
setLayout(null);
}
public void paint(Graphics g) {
int p0, p1, p2;
int x0, x1, x2;
p0 = 5*(b[0].getLabel().length()+4); x0 = 10;
p1 = 5*(b[1].getLabel().length()+4); x1 = x0 + 10 + p0 + 10;
p2 = 5*(b[2].getLabel().length()+4); x2 = x1 + 10 + p1 + 10;
b[0].setBounds(x0, 10, p0, 30);
b[1].setBounds(x1, 10, p1, 30);
b[2].setBounds(x2, 10, p2, 30);
}
public void actionPerformed(ActionEvent e) {
...
repaint();
}
...
}
|
Vous aurez compris que cette façon de faire est évidemment fastidieuse:
il faut
calculer ``à la main'' la taille des widgets ,
leur position, leur
redimensionnement, etc. Cette programmation peut
s'avérer relativement délicate si l'on tient compte
des problèmes de redimentionnement de la fenêtre,
de la tailles des fontes, etc.
Pour simplifier cette programmation, Java offre la possibilité de spécifier la disposition
globale que l'on
désire obtenir et laisser le soin au gestionnaire
de placement le soin
de gérer leur position et leur
redimensionnement.
Un gestionnaire de placement est une instance d'une
classe qui implante l'un des deux interfaces
LayoutManager ou LayoutManager2.
public interface LayoutManager {
public void addLayoutComponent(String name, Component comp)
public void removeLayoutComponent(Component comp)
public Dimension preferredLayoutSize(Container parent)
public Dimension minimumLayoutSize(Container parent)
public void layoutContainer(Container parent)
}
|
public interface LayoutManager2 extends LayoutManager {
public void addLayoutComponent(Component comp, Object constraints)
public Dimension maximumLayoutSize(Container target)
public float getLayoutAlignmentX(Container target)
public float getLayoutAlignmentY(Container target)
public void invalidateLayout(Container target)
}
|
Sauf contre indication, lors de la création d'un container,
il lui est automatiquement associé un LayoutManger
par défaut.
Java fournit plusieurs type de gestionnaires:
- FlowLayout
- BorderLayout
- CardLayout
- GridLayout
- GridBagLayout
Si l'on veut associer un LayoutManager particulier à un container,
on invoque la méthode setLayout.
FlowLayout gestionnaire = new FlowLayout();
unContainer.setLayout(gestionnaire);
|
Chaque container dispose d'une ou de plusieurs méthodes
add pour ajouter un composant dans un container.
Cette méthode fait appel au LayoutMagener associé
au container pour la gestion de la configuration des composants.
De même, les méthodes remove et removeAll
permettent de supprimer des composants d'un container.
Les méthodes getPreferredSize et getMinimumSize retournent
la taille idéale et la taille minimale d'un composant. Lorsqu'on choisit de
donner à un composant une taille non standard, il faut préciser,
en rédéfinissant ces méthodes, la taille idéale et celle minimale
que l'on veut voir attribuer à notre composant.
class Bouton extends Button {
Dimension d;
public Bouton(String s, int x, int y) { super(s); d = new Dimension(x, y); }
public Dimension getMinimumSize() { return d; }
public Dimension getPreferredSize() { return getMinimumSize(); }
}
|
La configuration choisie par un LayoutManager
peut devenir obsolète dans les situations suivantes:
- Modification de la taille du container
- Modification de la taille ou de la position d'un
des composants d'un container
- Ajout, suppression, affichage ou masquage d'un des
composants d'un container
Il convient alors de demander au LayoutManager
de trouver une nouvelle configuration; ce qui se fait en
invoquant la méthode validate (ou doLayout)
du container. La méthode validate (ou doLayout)
se charge de disposer ``correctement'' tous les composants
contenus dans le container.
Le gestionnaire FlowLayout dispose les composants
de gauche à droite dans l'ordre de leur insertion dans le
container. Lorsque la taille du container est trop petite
pour contenir tous les composants sur une même ligne, le
gestionnaire passe à la ligne suivante; chaque ligne est centrée.
public class FlowLayout extends Object implements LayoutManager, Serializable {
public static final int LEFT
public static final int CENTER
public static final int RIGHT
public FlowLayout()
public FlowLayout(int align)
public FlowLayout(int align, int hgap, int vgap)
public int getAlignment()
public void setAlignment(int align)
public int getHgap()
public void setHgap(int hgap)
public int getVgap()
public void setVgap(int vgap)
public void addLayoutComponent(String name, Component comp)
public void removeLayoutComponent(Component comp)
public Dimension preferredLayoutSize(Container target)
public Dimension minimumLayoutSize(Container target)
public void layoutContainer(Container target)
public String toString()
}
|
Redimensionner la fenêtre contenant les divers panels pour
voir les composants se placer ``correctement''.
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class LFlow extends Applet implements ActionListener {
Button b;
FenetreFlow fenetre;
public void init() {
b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new FenetreFlow("FlowLayout Manager");
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
public static void main(String[] args) {
Frame f = new Frame("Position et Dimensions");
LFlow p = new LFlow();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) { System.exit(0); }
});
p.init();
f.add(p);
f.pack();
f.show();
}
}
class FenetreFlow extends Frame {
static Color [] couleurs = {Color.black, Color.blue, Color.cyan,
Color.darkGray, Color.gray, Color.green,
Color.lightGray, Color.magenta, Color.orange,
Color.pink, Color.red, Color.white, Color.yellow};
static Dimension [] dim = {new Dimension(20, 30), new Dimension(30, 20),
new Dimension(40, 40), new Dimension(40, 30),
new Dimension(30, 40), new Dimension(40, 50),
new Dimension(20, 50), new Dimension(50, 20),
new Dimension(20, 40), new Dimension(30, 50),
new Dimension(50, 50), new Dimension(30, 20),
new Dimension(30, 40)};
public FenetreFlow(String s) {
super(s);
setLayout(new FlowLayout());
for (int i = 0; i<couleurs.length; i++) add(new MonPanel(couleurs[i], dim[i]));
setSize(250, 200);
}
}
class MonPanel extends Panel {
Dimension d;
public MonPanel(Color c, Dimension dim) { setBackground(c); d = dim; }
public Dimension getMinimumSize() { return d; }
public Dimension getPreferredSize() { return getMinimumSize(); }
public void paint(Graphics g) {
Dimension d = getSize(); g.drawRect(0,0, d.width-1, d.height-1);
}
}
|
public class BorderLayout extends Object implements LayoutManager2, Serializable {
public static final String NORTH
public static final String SOUTH
public static final String EAST
public static final String WEST
public static final String CENTER
public BorderLayout()
public BorderLayout(int hgap, int vgap)
public int getHgap()
public void setHgap(int hgap)
public int getVgap()
public void setVgap(int vgap)
public void addLayoutComponent(Component comp, Object constraints)
public void addLayoutComponent(String name, Component comp)
public void removeLayoutComponent(Component comp)
public Dimension minimumLayoutSize(Container target)
public Dimension preferredLayoutSize(Container target)
public Dimension maximumLayoutSize(Container target)
public float getLayoutAlignmentX(Container parent)
public float getLayoutAlignmentY(Container parent)
public void invalidateLayout(Container target)
public void layoutContainer(Container target)
public String toString()
}
|
Redimentionner la fenêtre contenant les divers ``panels'' pour voir les composants se placer ``correctement''.
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class LBorder extends Applet implements ActionListener {
Button b;
FenetreBorder fenetre;
public void init() {
b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new FenetreBorder("BorderLayout Manager");
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
public static void main(String[] args) {
Frame f = new Frame("Position et Dimensions");
LBorder p = new LBorder();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) { System.exit(0); }
});
p.init();
f.add(p);
f.pack();
f.show();
}
}
class FenetreBorder extends Frame {
public FenetreBorder(String s) {
super(s);
setSize(200, 150);
setLayout(new BorderLayout());
add(new MonPanel("1/5", Color.blue), "North");
add(new MonPanel("2/5", Color.red), "East");
add(new MonPanel("3/5", Color.pink), "South");
add(new MonPanel("4/5", Color.magenta), "West");
add(new MonPanel("5/5", Color.yellow), "Center");
}
}
class MonPanel extends Panel {
public MonPanel(String s, Color c) {
super(new BorderLayout());
setBackground(c);
add("Center", new Label(s, Label.CENTER));
}
}
|
Le gestionnaire CardLayout range les composants
comme on pourrait le faire avec un paquet de
cartes. Un seul composant est visible à la fois.
public class CardLayout extends Object implements LayoutManager2, Serializable {
public CardLayout()
public CardLayout(int hgap, int vgap)
public int getHgap()
public void setHgap(int hgap)
public int getVgap()
public void setVgap(int vgap)
public void addLayoutComponent(Component comp, Object constraints)
public void addLayoutComponent(String name, Component comp)
public void removeLayoutComponent(Component comp)
public Dimension preferredLayoutSize(Container parent)
public Dimension minimumLayoutSize(Container parent)
public Dimension maximumLayoutSize(Container target)
public float getLayoutAlignmentX(Container parent)
public float getLayoutAlignmentY(Container parent)
public void invalidateLayout(Container target)
public void layoutContainer(Container parent)
public void first(Container parent)
public void next(Container parent)
public void previous(Container parent)
public void last(Container parent)
public void show(Container parent, String name)
public String toString()
}
|
Cliquez sur les boutons pour voir rendre visible le
composant souhaité.
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class LCard extends Applet implements ActionListener {
Button b;
FenetreCard fenetre;
public void init() {
b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new FenetreCard("CardLayout Manager");
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
public static void main(String[] args) {
Frame f = new Frame("Position et Dimensions");
LCard p = new LCard();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) { System.exit(0); }
});
p.init();
f.add(p);
f.pack();
f.show();
}
}
class FenetreCard extends Frame implements ActionListener {
CardLayout card;
FenetreCard1 f;
Button b1, b2, b3, b4;
public FenetreCard(String s) {
super(s);
card = new CardLayout();
setLayout(new BorderLayout());
add("Center", f = new FenetreCard1(card));
add("North", b1 = new Button("Premier"));
add("East", b2 = new Button("Dernier"));
add("South", b3 = new Button("Suivant"));
add("West", b4 = new Button("Precedant"));
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
setSize(250, 200);
}
public void actionPerformed(ActionEvent e) {
System.out.println(e.getActionCommand());
if ("Premier".equals(e.getActionCommand())) card.first(f);
else if ("Dernier".equals(e.getActionCommand())) card.last(f);
else if ("Suivant".equals(e.getActionCommand())) card.next(f);
else card.previous(f);
}
}
class FenetreCard1 extends Panel {
public FenetreCard1(CardLayout c) {
setLayout(c);
Panel p0=new Panel(), p1=new Panel(), p2=new Panel(), p3=new Panel(), p4=new Panel();
add("1", p0); p0.setBackground(Color.blue); p0.add(new Label("1/5", Label.CENTER));
add("2", p1); p1.setBackground(Color.red); p1.add(new Label("2/5", Label.CENTER));
add("3", p2); p2.setBackground(Color.pink); p2.add(new Label("3/5", Label.CENTER));
add("4", p3); p3.setBackground(Color.magenta); p3.add(new Label("4/5", Label.CENTER));
add("5", p4); p4.setBackground(Color.yellow); p4.add(new Label("5/5", Label.CENTER));
}
}
|
Le gestionnaire GridLayout dispose les composants
à l'intérieure d'une grille dont chaque case est
de taille égale et
de telle sorte que chaque composant occupe la plus
grande place possible
dans une case de la grille.
public class GridBagLayout extends Object implements LayoutManager2, Serializable {
protected static final int MAXGRIDSIZE
protected static final int MINSIZE
protected static final int PREFERREDSIZE
protected Hashtable comptable
protected GridBagConstraints defaultConstraints
protected GridBagLayoutInfo layoutInfo
public int[] columnWidths
public int[] rowHeights
public double[] columnWeights
public double[] rowWeights
public GridBagLayout()
public void setConstraints(Component comp, GridBagConstraints constraints)
public GridBagConstraints getConstraints(Component comp)
protected GridBagConstraints lookupConstraints(Component comp)
public Point getLayoutOrigin()
public int[][] getLayoutDimensions()
public double[][] getLayoutWeights()
public Point location(int x, int y)
public void addLayoutComponent(String name, Component comp)
public void addLayoutComponent(Component comp, Object constraints)
public void removeLayoutComponent(Component comp)
public Dimension preferredLayoutSize(Container parent)
public Dimension minimumLayoutSize(Container parent)
public Dimension maximumLayoutSize(Container target)
public float getLayoutAlignmentX(Container parent)
public float getLayoutAlignmentY(Container parent)
public void invalidateLayout(Container target)
public void layoutContainer(Container parent)
public String toString()
protected GridBagLayoutInfo GetLayoutInfo(Container parent, int sizeflag)
protected void AdjustForGravity(GridBagConstraints constraints, Rectangle r)
protected Dimension GetMinSize(Container parent, GridBagLayoutInfo info)
protected void ArrangeGrid(Container parent)
}
|
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class LGrid extends Applet implements ActionListener {
Button b;
FenetreGrid fenetre;
public void init() {
b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new FenetreGrid("GridLayout Manager");
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
public static void main(String[] args) {
Frame f = new Frame("Position et Dimensions");
LGrid p = new LGrid();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) { System.exit(0); }
});
p.init();
f.add(p);
f.pack();
f.show();
}
}
class FenetreGrid extends Frame {
public FenetreGrid(String s) {
super(s);
setLayout(new GridLayout(0,2));
add(new MonPanel("1/5", Color.blue));
add(new MonPanel("2/5", Color.red));
add(new MonPanel("3/5", Color.pink));
add(new MonPanel("4/5", Color.magenta));
add(new MonPanel("5/5", Color.yellow));
setSize(250, 200);
}
}
class MonPanel extends Panel {
public MonPanel(String s, Color c) {
super(new BorderLayout());
setBackground(c);
add("Center", new Label(s, Label.CENTER));
}
}
|
Le gestionnaire GridBagLayout permet une gestion plus
fine du placement des composants. Il permet d'aligner les
composants à l'intérieure d'une grille sans imposer que chaque
case de la grille soit de même taille et où une composant peut
éventuellement occuper plusieurs cases.
A chaque composant géré par le GridBagLayout est associé
un ensemble de contraintes d'occupation sur la grille. La
spécification des contraintes associées à un composant
sont données par une instance de la classe
GridBagConstraints.
...
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
setLayout(gridbag);
...
|
La disposition des composants par un
GridBagLayout dépend des contraintes données par le
GridBagConstraints et par les tailles minimales
(getMinimumSize) et préférées (getPreferredSize).
...
gridbag.setConstraints(unComposant, c);
add(unComposant);
...
|
La classe GridBagConstraints définit un ensemble de
variables d'instance qui permettent de spécifier les contraintes
de placement des composants.
public class GridBagConstraints implements Cloneable, Serializable {
public static final int RELATIVE
public static final int REMAINDER
public static final int NONE
public static final int BOTH
public static final int HORIZONTAL
public static final int VERTICAL
public static final int CENTER
public static final int NORTH
public static final int NORTHEAST
public static final int EAST
public static final int SOUTHEAST
public static final int SOUTH
public static final int SOUTHWEST
public static final int WEST
public static final int NORTHWEST
public int gridx
public int gridy
public int gridwidth
public int gridheight
public double weightx
public double weighty
public int fill
public Insets insets
public int anchor
public int ipadx
public int ipady
public GridBagConstraints()
public Object clone()
}
|
public int gridx, gridy
Définit la ligne et la colonne de la case supérieure gauche
occupé par le composant (numérotaion de 0 à n-1).
On pourra utiliser la valeur GridBagContraints.RELATIVE
pour gridx (resp. gridy) pour placer un composant à droite
(resp. en bas) du composant précédemment ajouté.
public int gridwidth, gridheight
Définit le nombre de colonnes et de lignes occupé par le
composant. Par défaut, gridwidth et gridheight valent 1.
On pourra utiliser la valeur
- GridBagContraints.REMAINDER
pour gridwidth
(resp. gridheight) pour que le composant soit le dernier
la ligne (resp. de la colonne).
- GridBagContraints.RELATIVE
pour gridwidth
(resp. gridheight) pour que le composant soit le suivant du dernier
la ligne (resp. de la colonne).
public int fill
La varibale d'instance fill précise ce qu'il faut faire lorsque
l'espace associé à un composant est plus grand que le composant.
Les valeurs permises pour cette variable sont
- GridBagConstraints.NONE (valeur par défaut)
- GridBagConstraints.HORIZONTAL: le composant occupe
toute la largeur de l'espace réservé.
- GridBagConstraints.VERTICAL: le composant occupe
toute la hauteur de l'espace réservé.
- GridBagConstraints.BOTH: le composant occupe
tout l'espace réservé.
public Insets insets
Définit l'espace entre le composant et le bord des cases de la grille
public int anchor
Définit, lorsque le composant est plus petit que la case de la grille
qui le contient, la position du composant dans l'espace qui est
associé. Les valeurs permises sont:
| GridBagConstraints.CENTER (valeur par défaut),
GridBagConstraints.NORTH,GridBagConstraints.NORTHEAST, GridBagConstraints.EAST,GridBagConstraints.SOUTHEAST, GridBagConstraints.SOUTH, GridBagConstraints.SOUTHWEST, GridBagConstraints.WEST, GridBagConstraints.NORTHWEST |
Les identificateurs sont assez parlants pour se passer
d'explication.
public int ipadx, ipady
Les valeurs de ipadx et ipady définissent l'espace, autour d'un composant,
à ajouter à la taille minimale du composant.
public int weightx, weighty
Les valeurs de weightx et weighty permettent
de spécifier la manière de disposer
l'espace libre autour d'un composant dans une case de la grille.
Voici, pour finir, un exemple pour illustrer ce gestionnaire.
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class BagLayout extends Applet implements ActionListener {
MonFrame fenetre;
public void init() {
Button b = new Button("Cliquez ici pour ouvrir/fermer une fenetre");
add(b);
b.addActionListener(this);
fenetre = new MonFrame("Une fenetre");
fenetre.setSize(300, 100);
fenetre.setVisible(false);
fenetre.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
fenetre.setVisible(false); }
});
}
public void actionPerformed(ActionEvent e) {
if (! fenetre.isShowing()) fenetre.setVisible(true);
else fenetre.setVisible(false);
}
}
class UnComposant extends Label {
public UnComposant(String s, GridBagLayout gridbag, GridBagConstraints cstr, Color c) {
super(s); gridbag.setConstraints(this, cstr); setBackground(c);
setAlignment(Label.CENTER);
}
}
class MonFrame extends Frame {
public MonFrame(String s) {
super("GridBagLayout");
setLayout(new GridBagLayout());
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
setLayout(gridbag);
c.fill = GridBagConstraints.BOTH;
c.weightx = 1;
add(new UnComposant("Button1", gridbag, c, Color.red));
add(new UnComposant("Button2", gridbag, c, Color.blue));
add(new UnComposant("Button3", gridbag, c, Color.green));
c.gridx = 0;
c.gridy = 1;
c.fill = GridBagConstraints.NONE;
add(new UnComposant("Button4", gridbag, c, Color.cyan));
c.gridx = 1;
c.gridwidth = 2;
c.gridheight = 2;
c.fill = GridBagConstraints.HORIZONTAL;
add(new UnComposant("Button5", gridbag, c, Color.magenta));
// c.gridx = GridBagConstraints.RELATIVE;
c.gridwidth = 1;
c.gridheight = 1;
c.gridy = GridBagConstraints.RELATIVE;
add(new UnComposant("Button6", gridbag, c, Color.yellow));
}
}
import java.awt.*;
import java.awt.event.*;
public class GridBagWindow extends Frame {
boolean inAnApplet = true;
protected void makebutton(String name,
GridBagLayout gridbag,
GridBagConstraints c) {
Button button = new Button(name);
gridbag.setConstraints(button, c);
add(button);
}
public GridBagWindow() {
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
setFont(new Font("SansSerif", Font.PLAIN, 14));
setLayout(gridbag);
c.fill = GridBagConstraints.BOTH;
c.weightx = 1.0;
makebutton("Button1", gridbag, c);
makebutton("Button2", gridbag, c);
makebutton("Button3", gridbag, c);
c.gridwidth = GridBagConstraints.REMAINDER; //end of row
makebutton("Button4", gridbag, c);
c.weightx = 0.0; //reset to the default
makebutton("Button5", gridbag, c); //another row
c.gridwidth = GridBagConstraints.RELATIVE; //next-to-last
makebutton("Button6", gridbag, c);
c.gridwidth = GridBagConstraints.REMAINDER; //end of row
makebutton("Button7", gridbag, c);
c.gridwidth = 1; //reset to the default
c.gridheight = 2;
c.weighty = 1.0;
makebutton("Button8", gridbag, c);
c.weighty = 0.0; //reset to the default
c.gridwidth = GridBagConstraints.REMAINDER; //end of row
c.gridheight = 1; //reset to the default
makebutton("Button9", gridbag, c);
makebutton("Button10", gridbag, c);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
if (inAnApplet) {
dispose();
} else {
System.exit(0);
}
}
});
}
public static void main(String args[]) {
GridBagWindow window = new GridBagWindow();
window.inAnApplet = false;
window.setTitle("GridBagWindow Application");
window.pack();
window.setVisible(true);
}
}
|
A TERMINER
Next: 28 Dessiner sur une
Up: Java: Programmation graphique
Previous: 26 Les widgets
Touraivane
6/12/1998