next up previous contents index
Next: 28 Dessiner sur une Up: Java: Programmation graphique Previous: 26 Les widgets

Subsections

27 Ranger les widgets

 

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

27.1 Gestion ``manuelle'' des placements

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:

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

 
setLayout(null);
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.

27.2 Généralités sur les Layouts

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:

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:

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.

27.3 FlowLayout

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);
  }
}

27.4 BorderLayout

 

   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));
  }
}

27.5 CardLayout

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));
  } 
} 


27.6 GridLayout

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));
  }
}

27.7 GridBagLayout

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
 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
 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));     
      }
   }


27.8 L'exemple du tutorail

 
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);
    }
}

27.9 Créer ses propres layouts

 

A TERMINER


next up previous contents index
Next: 28 Dessiner sur une Up: Java: Programmation graphique Previous: 26 Les widgets
Touraivane
6/12/1998