AWT

Le paquet java.awt regroupe les classes de l'Abstract Window Toolkit :

• Component et ses classes dérivées
• les classes de placement : FlowLayout, BorderLayout, CardLayout, GridLayout, GridBagLayout, et GridBagConstraints
• Event
• Dimension,
• Font et FontMetrics,
• les classes graphiques

Composantes d'interface

Une interface graphique peut contenir les composantes AWT suivantes :

• bouton : Button
• case : Checkbox
• ligne de texte : TextField
• zone textuelle éditable : TextArea
• étiquette : Label
• liste : List
• liste de choix : Choice
• barre de défilement : Scrollbar
• zone graphique éditable : Canvas
• menus : Menu, MenuItem, CheckboxMenuItem, PopupMenu
• conteneurs : Panel, Window et ses sous-classes Dialog, FileDialog et Frame, ScrollPane

À l'exception des menus qui dérivent de MenuComponent, toutes ces composantes dérivent de la classe Component.

Conteneurs

Un conteneur AWT est un objet qui peut contenir des composantes AWT. Les classes de conteneurs dérivent de la classe Container qui est elle-même dérivée de Component ; ainsi, tout conteneur est une composante.

La classe dérivée Panel définit des conteneurs génériques, dont l'intérêt est de regrouper plusieurs composantes pour qu'elles partagent certains attributs et soient placées ensemble.

L'autre classe dérivée est Window, qui définit des fenêtres indépendantes, sans bord et sans barre de menu ; on utilise plus souvent la classe dérivée Frame, qui définit des fenêtres avec un titre, ou les classes dérivées plus spécialisées Dialog et FileDialog pour des fenêtres de dialogue. La classe Applet est aussi dérivée de Container.

Enfin, la classe ScrollPane est destinée à ne contenir qu'une seule composante, de dimensions éventuellement plus grandes, dont une partie seulement sera visualisée, partie qui peut être sélectionnée à l'aide d'ascenseurs.

La classe Container dispose de méthodes permettant d'ajouter des composantes à l'objet conteneur, de les supprimer et de les positionner :

• add(Component) ajoute une composante au conteneur
• remove(Component) supprime une composante
• setLayout(LayoutManager) adjoint au conteneur un objet de type LayoutManager qui se charge du positionnement des composantes du conteneur

Liste à choix unique

Voici un conteneur (représenté par une zone de couleur ivoire), auquel est ajouté une liste à choix unique composée de trois items :

Panel p = new Panel();
Choice c = new Choice();
c.addItem("Item 1");
c.addItem("Item 2");
c.addItem("Item 3");
p.add(c);

Pour le moment, aucune action n'est associée au fait de sélectionner l'un des items de cette liste ; il en sera de même des autres exemples de cette page.

Liste à choix multiple

Voici un conteneur (représenté par une zone de couleur ivoire), auquel est ajouté une liste à choix multiple, elle-même composée de cinq items, dont trois sont affichés  :

Panel p = new Panel();
List l = new List(3, true);
l.addItem("Item 1");
l.addItem("Item 2");
l.addItem("Item 3");
l.addItem("Item 4");
l.addItem("Item 5");
p.add(c);

Cases à cocher

La classe Checkbox définit les cases, qui sont des objets à deux états : sélectionné ou non-sélectionné. On les groupe souvent à l'aide de la classe CheckboxGroup, de sorte qu'une seule case soit sélectionnée, la sélection de l'une déselectionnant la précédente.

Panel p = new Panel();
CheckboxGroup g = new CheckboxGroup();
p.add(new Checkbox("un", g, true);
p.add(new Checkbox("deux", g, false);
p.add(new Checkbox("trois", g, false);

Étiquettes

Panel p = new Panel();
p.add(new Label("à gauche"));
p.add(new Label("à droite". Label.RIGHT));

Boutons

Le conteneur suivant contient deux boutons :

Panel p = new Panel();
p.add(new Button("Bouton 1"));
p.add(new Button("Bouton 2"));

Texte

Il existe deux classes pour les composants textuels.

Panel p = new Panel();
TextField tf = new TextField("TextField", 10);
tf.setBackground(Color.red);
tf.setForeground(Color.blue);  
p.add(tf);

crée une ligne textuelle de 10 colonnes, de fond rouge, de texte bleu. On obtient une zone de 3 lignes et 15 colonnes, avec deux barres de défilement, et la fonte du texte spécifiée ainsi :

Panel p = new Panel();
TextArea ta = new TextArea("TextArea", 3, 15);
ta.setFont(new Font("TimesRoman", Font.BOLD, 12));
p.add(ta);

Fenêtres

La classe Frame permet de créer des fenêtres (au sens du gestionnaire de fenêtres), avec titre et menus.

    Frame f = new Frame("ça, c'est un frame");
    add(f);
    f.setSize(400,400);
    f.setBackground(Color.yellow);
    f.setVisible(true);

Il faut donner la taille de la fenêtre avec setSize(int, int). L'invocation de la méthode setVisible(boolean) avec true pour argument est nécessaire pour faire apparaître la fenêtre ; on la fait disparaître avec setVisible(false). Grâce aux classes MenuBar, Menu et MenuItem, on peut lui adjoindre une barre de menu avec setMenuBar(MenuBar), adjoindre à cette barre plusieurs menus avec add(Menu), et à chaque menu des items avec add(MenuItem) :

    MenuBar mb = new MenuBar();
    Menu m1 = new Menu("m1");
    m1.add(new MenuItem("m11"));
    m1.add(new MenuItem("m12"));
    m1.add(new MenuItem("m13"));
    Menu m2 = new Menu("m2");
    m2.add(new MenuItem("m21"));
    m2.add(new MenuItem("m22"));
    mb.add(m1);
    mb.add(m2);
    f.setMenuBar(mb);

Par défaut, le placement des composantes d'une fenêtre est réalisé par la classe BorderLayout.

Menu popup

    Panel p;
    popup = new PopupMenu("un menu");
    popup.add(new MenuItem("item 1"));
    popup.add(new MenuItem("item 2"));
    p.add(popup);
    ...
    popup.show(p, 10, 15);

Placement

Les composantes rassemblées dans un conteneur sont placées dans celui-ci grâce à un objet d'une classe implémentant l'interface LayoutManager.

FlowLayout

C'est le placement par défaut des conteneurs de la classe Panel (donc des applettes qui en sont dérivées) : les composantes sont placées comme du texte, de gauche à droite, puis de haut en bas, dans l'ordre où elles sont ajoutées. On choisit cette méthode de placement ainsi :

setLayout(new FlowLayout());

On peut spécifier l'alignement par une constante en argument du constructeur :

setLayout(new FlowLayout(FlowLayout.LEFT));

BorderLayout

C'est le placement par défaut des fenêtres. Cinq positions sont définies : "North", "East", "South", "West", "Center" :

    f.add("Center", ta);

Si plusieurs composantes doivent être placées à une même position ("North", ...), il faut créer comme conteneur intermédiaire un Panel et choisir un placement pour ce conteneur.

GridLayout

La classe GridLayout permet le placement selon un tableau régulier (toutes les cases du tableau ont la même taille). Son constructeur GridLayout(int, int) spécifie le nombre de lignes et de colonnes souhaité ; un 0 signifie un nombre quelconque. Deux arguments entiers supplémentaires peuvent spécifier l'espace entre les colonnes et l'espace entre les lignes.

setLayout(new GridLayout(3,2));

GridBagLayout et GridBagConstraints

La classe GridBagLayout permet de spécifier un placement des composantes selon un tableau, chaque composante pouvant occuper une ou plusieurs cellules de ce tableau. A chaque composante est associée un objet de la classe GridBagConstraints, dont les champs spécifient des contraintes de placement. Cette méthode compliquée sera prochainement obsolète.

CardLayout

La classe CardLayout permet un placement alternatif, c'est-à-dire un choix entre plusieurs conteneurs. L'exemple suivant montre trois placements alternatifs C1 du Panel p1, C2 de p2 et C3 de p3 dans un Panel p.

   Panel p, p1, p2, p3;
   p.setLayout(alt = new CardLayout());
   p.add("C1", p1);
   p.add("C2", p2);
   p.add("C3", p3);

La méthode show(Container parent, String name) de la classe CardLayout affiche le placement spécifié par name :

  alt.show(p,"C2");

Les méthodes first, next, previous et last permettent de passer d'un placement à l'autre :

  alt.next(p)

Contextes graphiques

La classe Graphics définit des objets sur lesquels des opérations de tracé graphique peuvent être effectuées ; voici quelques unes de ces fonctions :

• drawLine(int, int, int, int)
• drawPolygon(int[], int[], int)
• drawRect(int, int, int, int)
• drawString(String, int, int)
• fillRect(int, int, int, int)
• copyArea(int, int, int, int, int, int)
• drawImage(Image, int, int, ImageObserver)

Les coordonnées, spécifiées par des int, ont pour origine le sommet supérieur gauche du rectangle graphique.

A toute composante est associée un objet de classe Graphics, son contexte graphique, retourné par la méthode getGraphics(). L'argument de type ImageObserver passé aux méthodes est souvent this (il doit être d'une classe qui implémente l'interface ImageObserver, par exemple Component).

Les tracés sur une composante sont spécifiés en redéfinissant la méthode paint (qui par défaut, ne dessine rien) de la classe Component. Tout tracé est fait avec la couleur courante et la fonte courante du contexte graphique ; elles sont sélectionnées par setColor(Color) et setFont(Font).

  public void paint(Graphics g) {
    g.drawLine(2, 2, 18, 18);
    g.setFont(new Font("SansSerif", Font.ITALIC, 12));
    g.drawString("un message", 20, 25);
    g.setColor(Color.blue);
    g.fillRect(20, 35, 30, 2);
}

Les fonds graphiques

La classe Canvas est une classe générique dont doit être dérivée une classe pour être utilisée ; elle sert notamment à créer de nouvelles composantes d'interface.

class C extends Canvas 
{
  public void paint(Graphics g) 
    {
      int w = getSize().width;
      int h = getSize().height;
      g.drawRect(0,0,w-1,h-1);
      g.drawString("Canvas",
                   (w-g.getFontMetrics().stringWidth("Canvas"))/2, 
                   10);
      g.drawLine(10,10,100,100);
      g.fillRect(9,9,3,3);
    }
}