Page d'accueilFindIt !ContactLes composants de l'interface utilisateurLa gestion de l'interface utilisateur

La bibliothèque JavaTM 1.0

Table des matièresHierarchie des classes

CJava

 Les containers
et la disposition des composants

Les containers
La disposition des composants : les layouts
Les menus

 

Les containers

L'architecture container/composant

Les containers sont des composants qui contiennent d'autres composants. Ce type d'architecture donne aux containers un ensemble de caractéristiques qui leur sont propres :

Il existe ainsi une relation entre un container et ses composants. Comme un composant peut être lui-même un container contenant d'autres composants, l'ensemble de ces relations parent-enfant peut se décrire sous forme d'un arbre, comme dans l'applet suivante, qui reproduit les commandes Couper / Copier / Coller / Effacer d'un traitement de texte :

Applet TraitementTexte

Voici le programme Java correspondant (à copier dans un fichier dénommé TraitementTexte.java et invoqué à partir d'un fichier HTML) :

import java.applet.Applet;
import java.awt.*;
import java.util.Date;
 
public class TraitementTexte extends Applet
{
  private TextArea texte      = new TextArea ();
  private String   texteCopie = "";
 
  public void init ()
  {
    // Choix d'un layout BorderLayout (FlowLayout par défaut)
    setLayout (new BorderLayout ());
    // Création d'une barre de boutons avec les commandes
    // Couper/Copier/Coller/Effacer (layout FlowLayout par défaut)
    Panel panel = new Panel ();
    panel.add (new Button ("Couper"));
    panel.add (new Button ("Copier"));
    panel.add (new Button ("Coller"));
    panel.add (new Button ("Effacer"));
    // Ajout en haut de la barre de boutons
    add ("North", panel);
    // Ajout au centre de la zone de saisie
    add ("Center", texte);
    // Ajout en bas d'un label
    add ("South", new Label (  "Du C/C++ a Java  "
                             + new Date ().toLocaleString ()));
  }
  
  // Méthode appelée par la machine virtuelle quand on clique sur un bouton
  public boolean action (Event event, Object eventArg)
  {
    if ("Couper".equals (eventArg))
    {
      // Simulation d'une action Copier/Effacer
      postEvent (new Event (this, Event.ACTION_EVENT, "Copier"));
      postEvent (new Event (this, Event.ACTION_EVENT, "Effacer"));
    }
    else if ("Copier".equals (eventArg))        
      // Récupération du texte sélectionné  
      texteCopie = texte.getSelectedText ();
    else if ("Coller".equals (eventArg))  
      // Remplacement de la sélection par texteCopie  
      texte.replaceText (texteCopie, texte.getSelectionStart (),
                                       texte.getSelectionEnd ());
    else if ("Effacer".equals (eventArg))    
      // Remplacement de la sélection par rien  
      texte.replaceText ("", texte.getSelectionStart (),
                               texte.getSelectionEnd ());
    return true;
  }
}
 

Les relations entre les composants de l'applet précédente décrivent l'arbre suivant :

Arbre des composants de l'applet TraitementTexte
figure 15. Arbre des composants de l'applet TraitementTexte

!

Ne mélangez pas les concepts de graphe d'héritage entre classes et de graphe de parenté entre composants !... Ces liens de parenté ne sont le résultat que de la composition entre classes : chaque composant mémorise dans un champ private, une référence sur son parent que l'on peut obtenir grâce à la méthode getParent () de la classe Component.

 

Chaque composant et par conséquent chaque container possède son propre système de coordonnées. L'origine de ce repère est situé en haut à gauche du composant, l'axe des x va vers la droite, et l'axe des y vers le bas. Ceci forme un repère indirect, ce qui n'est pas très pratique pour afficher des courbes mathématiques, mais comme presque tous les systèmes informatiques utilisent cette convention...
Chaque composant (container ou pas) est positionné dans le repère du container qui le contient, c'est-à-dire que dans l'exemple précédent, le bouton Copier est positionné par rapport au repère du container de classe Panel qui le contient, et ce container est positionné dans le repère de l'applet. La méthode location () de la classe Component invoquée sur ce bouton vous renverra donc les coordonnées du bouton dans son parent et non dans l'applet ; de même, si vous utilisez la méthode move (x, y) de la classe Component pour placer un composant comp, il faut fournir des coordonnées (x,y) relatives au container qui contient comp.

!

Les containers sont généralement utilisés pour y ajouter des composants mais vous pouvez aussi y afficher des dessins fabriqués avec les méthodes de la classe Graphics en outrepassant par exemple la méthode paint () de la classe Component. Mais évitez de mélanger ces deux styles, car les composants sont disposés par un layout à des positions qui ne sont pas toujours les mêmes suivant les systèmes, et vos dessins pourraient être recouverts par des composants.
Il vaut mieux dans ce cas créer une nouvelle classe de composant CanvasDessin dérivant de Canvas, où vous effectuez vos dessins, puis ajouter une instance de CanvasDessin au container.

La classe java.awt.Container

Cette classe abstract qui dérive de la classe Component, est la super classe de toutes les classes de container. Elle définit notamment un certains nombres de méthodes, qui permettent d'ajouter ou d'enlever des composants aux containers, ou qui disposent les composants dans un container grâce à son layout associé.

Méthodes
public Component add (Component comp)
public synchronized Component add (Component comp, int pos)
public synchronized Component add (String name, Component comp)

Ces méthodes permettent d'ajouter le composant comp à un container et de créer le lien parent-enfant. Le container garde une liste ordonnée des composants qui lui sont ajoutés, ce qui permet aux layouts de les disposer dans cet ordre si nécessaire. Par défaut, pos = -1, ce qui implique que le composant est ajouté à la fin de la liste des composants.
La troisième méthode, en plus d'ajouter le composant en fin de liste, appelle la méthode addLayoutComponent (name, comp) de l'interface LayoutManager, si le container a un layout. Certaines classes de layout comme BorderLayout, implémentent cette méthode pour utiliser les informations contenues dans name et placer le composant autrement qu'en utilisant uniquement son numéro d'ordre.
Si le peer du container existe déjà, ces méthodes appellent la méthode addNotify () du composant comp.

public synchronized void remove (Component comp)
public synchronized void removeAll ()

Ces méthodes permettent d'enlever le composant comp ou tous les composants d'un container.

!

Si vous ajoutez ou enlevez un composant d'un container qui est déjà à l'écran, n'oubliez pas d'appeler la méthode validate () sur le container, sinon votre container restera inchangé à l'écran (voir l'exemple de la classe BorderLayout).

public int countComponents ()

Renvoie le nombre de composants que contient un container.

public synchronized Component getComponent (int n)
                         throws ArrayIndexOutOfBoundsException
public synchronized Component [ ] getComponents ()

Ces méthodes renvoient le nième composant ou tous les composants d'un container.

public LayoutManager getLayout ()
public void setLayout (LayoutManager manager)

Ces méthodes permettent d'interroger ou de modifier le layout utilisé par un container. Toutes les classes dérivées de container ont un layout par défaut.

public synchronized void layout ()

Méthode de la classe Component, outrepassée pour disposer les composants d'un container.

public synchronized void validate ()

Méthode de la classe Component, outrepassée pour mettre à jour tous les composants d'un container invalide.

public Insets insets ()

Renvoie la largeur des bordures du container en haut, en bas, à gauche et à droite. Comme cette méthode interroge le peer du container, les valeurs renvoyées ne sont valides que si son peer existe déjà.

public synchronized Dimension preferredSize ()
public synchronized Dimension minimumSize ()

Ces méthodes renvoient la taille préférée et la taille minimum d'un container. Si le container a un layout, ces méthodes renvoient les dimensions respectivement données par les méthodes preferredLayoutSize () et minimumLayoutSize () de l'interface LayoutManager.

public void paintComponents (Graphics g)
public void printComponents (Graphics g)

Ces méthodes redessine ou imprime tous les composants d'un container.

public void deliverEvent (Event e)

Cette méthode qui outrepasse celle de la classe Component est utilisée pour la gestion événementielle (voir le chapitre suivant).

public Component locate (int x, int y)

Méthode de la classe Component outrepassée pour rechercher le composant situé au point de coordonnées (x,y) d'un container.

public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Component pour appeler la méthode addNotify () sur chacun des composants du container.

public synchronized void removeNotify ()

Cette méthode outrepasse la méthode removeNotify () de la classe Component pour appeler la méthode removeNotify () sur chacun des composants du container.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant le container.

public void list (PrintStream out, int indent)

Méthode de la classe Component, outrepassée pour imprimer sur out la chaîne de caractères décrivant le container et tous composants.

La classe java.awt.Panel

Cette classe qui dérive des classes Container et Component, permet de créer un container utilisé comme zone d'affichage pour y ajouter des composants ou pour y dessiner directement avec les méthodes de classe Graphics. Le layout utilisé par défaut par la classe Panel est la classe FlowLayout. Cette classe est la super classe Applet.

Constructeur
public Panel ()
Méthode
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Container pour créer le peer d'un panel puis appeler la méthode addNotify () de la classe Container.

Exemples

Applets TraitementTexte, DrawIt, ListePolices et Nuancier.

La classe java.awt.Window

Cette classe qui dérive des classes Container et Component, permet de créer une fenêtre sans bord, ni titre, ni menu. Contrairement à ses classes dérivées Dialog et Frame, elle est peu utile mais peut servir par exemple comme bannière au lancement d'un programme, pour afficher une image. Le layout utilisé par défaut par la classe Window est la classe BorderLayout.

!

N'oubliez pas d'appeler la méthode show () pour afficher une fenêtre et de la dimensionner à la taille correcte avec les méthodes pack () ou les méthodes resize () ou reshape () de la classe Component.

Constructeur
public Window (Frame parent)

Ce constructeur construit une fenêtre invisible dont le parent parent doit être de classe Frame ou ses dérivées.

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Container pour créer le peer d'une fenêtre puis appeler la méthode addNotify () de la classe Container.

public synchronized void pack ()

Cette méthode permet de dimensionner la fenêtre à la taille donnée par la méthode preferredSize () de la classe Container. Si les peers de la fenêtre et des composants qu'elle contient n'existent pas encore, ceux-ci sont créés pour que la taille renvoyée soit correcte.

public void show ()

Méthode de la classe Component, outrepassée pour afficher la fenêtre et les composants qu'elle contient. Si la fenêtre est déjà visible, la fenêtre est ramenée devant toutes les autres.
Cette méthode appelle la méthode addNotify (), ce qui a pour conséquence de créer à l'écran la fenêtre et tous les composants qui lui ont été ajoutés.
Vous devez appeler au moins une fois cette méthode par fenêtre car elles sont créées invisibles.
Le parent de la fenêtre n'a pas forcément besoin d'être visible pour que cette méthode fonctionne.

public synchronized void dispose ()

Détruit une fenêtre. Vous devez appeler cette méthode pour que la fenêtre à l'écran soit effectivement détruite.

public void toFront ()
public void toBack ()

Ces méthodes ramène une fenêtre devant ou derrière toutes les autres.

public Toolkit getToolkit ()

Méthode de la classe Component, outrepassée pour renvoyer le kit d'outils (Toolkit) par défaut utilisé pour la création du peer d'un composant.

public final String getWarningString ()

Renvoie le warning d'une fenêtre. Ce type de message est affiché dans les fenêtres créées dans un navigateur.

La classe java.awt.Frame

Cette classe qui dérive des classes Window, Container et Component et implémente l'interface MenuContainer permet de créer une fenêtre indépendante avec un cadre, un titre, et éventuellement un menu et un pointeur de souris propre.

Champs
public final static int DEFAULT_CURSOR
public final static int CROSSHAIR_CURSOR
public final static int TEXT_CURSOR
public final static int WAIT_CURSOR
public final static int SW_RESIZE_CURSOR
public final static int SE_RESIZE_CURSOR
public final static int NW_RESIZE_CURSOR
public final static int NE_RESIZE_CURSOR
public final static int N_RESIZE_CURSOR
public final static int S_RESIZE_CURSOR
public final static int W_RESIZE_CURSOR
public final static int E_RESIZE_CURSOR
public final static int HAND_CURSOR
public final static int MOVE_CURSOR

Ces constantes représentent les pointeurs de souris prédéfinis que vous pouvez choisir dans une fenêtre avec la méthode setCursor ().

Constructeurs
public Frame ()
public Frame (String title)

Ces constructeurs créent une fenêtre avec ou sans titre title.

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Window pour créer le peer d'une fenêtre et son éventuel menu, puis appeler la méthode addNotify () de la classe Window.

public String getTitle ()
public void setTitle (String title)

Ces méthodes permettent d'interroger ou de modifier le titre d'une fenêtre.

public Image getIconImage ()
public void setIconImage (Image image)

Ces méthodes permettent d'interroger ou de modifier l'image utilisée quand une fenêtre est icônifiée, mais tous les systèmes n'utilisent pas cette caractéristique.

public MenuBar getMenuBar ()
public synchronized void setMenuBar (MenuBar menubar)

Ces méthodes permettent d'interroger ou de modifier la barre de menu utilisée pour une fenêtre.

public synchronized void remove (MenuComponent menu)

Enlève le menu menu de la fenêtre.

public synchronized void dispose ()

Méthode de la classe Window, outrepassée pour détruire une fenêtre. Vous devez appeler cette méthode pour que la fenêtre à l'écran soit effectivement détruite.

public boolean isResizable ()

Renvoie true si la fenêtre est redimensionnable interactivement.

public void setResizable (boolean resizable)

Permet de spécifier si une fenêtre est redimensionnable interactivement ou non.

public int getCursorType ()
public void setCursor (int cursorType)

Ces méthodes permettent d'interroger ou de modifier le curseur de souris utilisé dans une fenêtre. cursorType doit être une des constantes dont la liste est donnée avec les champs.

protected String paramString ()

Méthode de la classe Container, outrepassée pour renvoyer une chaîne de caractères décrivant la fenêtre.

Exemples

Applets BorderBuilder et ShowMenu.
Application TraitementTexte.

Transformer une applet en application isolée

La classe d'une applet héritant de la classe Panel, il est possible d'ajouter une applet à une fenêtre de classe Frame. Grâce à cette caractéristique, vous pouvez ajouter à la plupart de vos applets la faculté d'être utilisées comme applications isolées, en leur ajoutant une méthode main () qui crée une instance de Frame pour y ajouter une instance de votre applet (les limitations de ce système sont décrites au chapitre sur les applets).
Voici par exemple comment transformer l'applet de classe TraitementTexte définie au début de ce chapitre pour en faire une application isolée :

public class TraitementTexte extends Applet
{
  // Code précédemment défini...
 
  public static void main (String [ ] args)
  {
    // Création d'une fenêtre et d'une instance de l'applet
    Frame  fenetreApplet = new Frame ("TraitementTexte");
    Applet applet = new TraitementTexte ();
 
    // Ajout de l'applet à la fenêtre puis affichage de la fenêtre
    fenetreApplet.add ("Center", applet);
    fenetreApplet.show ();
    fenetreApplet.resize (300, 200);
    
    // Démarrage de l'applet
    applet.init ();
    fenetreApplet.validate ();
  }
}

La classe java.awt.Dialog

Cette classe qui dérive des classes Window, Container et Component permet de créer une boite de dialogue avec un cadre et un titre. Les boites de dialogues ont un parent de classe Frame, et peuvent être modale ou non. Une boite de dialogue qui est modale bloque toute entrée dans les autres fenêtres tant qu'elle est ouverte.

!

Quand une boite de dialogue est modale, l'utilisateur ne peut plus manipuler que cette boite de dialogue et plus les autres fenêtres créées par la Machine Virtuelle Java. A l'appel de la méthode show () sur une boite de dialogue modale dialog1, la boite de dialogue est affichée et les instructions qui suivent show () ne sont exécutées qu'une fois que dialog1 est détruite. N'oubliez donc pas de détruire avec la méthode dispose () vos boites de dialogues modales une fois son traitement terminé.

Constructeurs
public Dialog (Frame parent, boolean modal)
public Dialog (Frame parent, String title, boolean modal)

Ce constructeur construit une boite de dialogue invisible avec ou sans titre title, dont le parent parent doit être de classe Frame ou ses dérivées. Cette boite de dialogue peut être modale ou non.

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Window pour créer le peer d'une boite de dialogue, puis appeler la méthode addNotify () de la classe Window.

public boolean isModal ()

Renvoie true si la boite de dialogue est modale.

public String getTitle ()
public void setTitle (String title)

Ces méthodes permettent d'interroger ou de modifier le titre d'une boite de dialogue.

public boolean isResizable ()

Renvoie true si la boite de dialogue est redimensionnable interactivement.

public void setResizable (boolean resizable)

Permet de spécifier si une boite de dialogue est redimensionnable interactivement ou non.

protected String paramString ()

Méthode de la classe Container, outrepassée pour renvoyer une chaîne de caractères décrivant la boite de dialogue.

La bibliothèque Java ne fournissant pas en standard une boite de dialogue affichant simplement un message, voilà l'applet MessageBoxApplet qui peut vous servir de base pour en réaliser une :

Applet MessageBoxApplet

en cliquant sur le bouton, on obtient le résultat suivant :

MessageBox dialog

Voici le programme Java correspondant (à copier dans un fichier dénommé MessageBoxApplet.java et invoqué à partir d'un fichier HTML) :

import java.applet.Applet;
import java.awt.*;
 
public class MessageBoxApplet extends Applet
{
  public void init ()
  {
    add (new Button ("Afficher message"));
  }
  
  // Méthode appelée par la machine virtuelle quand on clique sur le bouton
  public boolean action (Event event, Object eventArg)
  {
    MessageBox.showMessageBox(this, "Message", "Ceci est un message...");
    return true;
  }
}
 
class MessageBox extends Dialog
{
  private MessageBox (Frame  frame, String titre)
  {
    // Appel du constructeur de la classe Dialog en mode modal
    super (frame, titre, true);
  }
 
  static public void showMessageBox (Component   parent,
                                      String      titre,
                                      String      message)
  {               
    // Recherche du parent qui est un Frame
    Component frame = parent;
    while (   frame != null
           && !(frame instanceof Frame))
      frame = frame.getParent ();
 
    // Création d'une instance de MessageBox
    MessageBox boite = new MessageBox ((Frame)frame, titre);
    
    // Ajout du message et d'un bouton Ok
    boite.add ("Center", new Label (message));
    boite.add ("East",   new Button ("Ok"));      
 
    // Affichage de la boite de message
    // show () ne rend la main que quand la boite est détruite
    boite.setResizable (false);
    boite.pack ();
    boite.show ();
  }   
 
  // Méthode appelée quand on clique sur Ok
  public boolean action (Event event, Object eventArg)
  {
    // Destruction de la boite de message
    dispose ();
    return true;
  }
}
 

La classe java.awt.FileDialog

Cette classe qui dérive des classes Dialog, Window, Container et Component permet de créer une boite de dialogue modale de saisie de fichier. Comme pour tous les composants du package java.awt, cette boite de dialogue est celle communément utilisée avec le système sur lequel fonctionne la Machine Virtuelle Java. Comme cette classe donne accès au système de fichiers, certains navigateurs interdisent tout simplement de s'en servir.

Champs
public final static int LOAD
public final static int SAVE

Ces constantes sont utilisées pour choisir le mode de saisie du fichier de la boite de dialogue (Ouvrir ou Enregistrer).

Constructeurs
public FileDialog (Frame parent, String title)
public FileDialog (Frame parent, String title, int mode)

Ce constructeur construit une boite de dialogue invisible de saisie de fichier avec ou sans titre title, dont le parent parent doit être de classe Frame ou ses dérivées. Par défaut, le mode saisie est LOAD.

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Dialog pour créer le peer d'une boite de dialogue de saisie de fichier, puis appeler la méthode addNotify () de la classe Dialog.

public int getMode ()

Ces méthodes permettent d'interroger le mode saisie du fichier (LOAD ou SAVE).

public void setDirectory (String dir)
public void setFile (String file)

Ces méthodes permettent de modifier le répertoire et le fichier à utiliser à l'ouverture de la boite de dialogue.

public String getDirectory ()
public String getFile ()

Ces méthodes permettent d'interroger le répertoire et le fichier saisis dans la boite de dialogue. Si l'utilisateur a annulé la saisie, ces méthodes renvoient null.

public FilenameFilter getFilenameFilter ()
public void setFilenameFilter (FilenameFilter filter)

Ces méthodes permettent d'interroger ou de modifier le filtre utilisé pour la saisie du fichier, par exemple pour n'accepter que les fichiers se terminant par .java (ce qui correspondrait à *.java).

protected String paramString ()

Méthode de la classe Container, outrepassée pour renvoyer une chaîne de caractères décrivant la boite de dialogue de saisie de fichier.

La disposition des composants : les layouts

Associé à chaque container, existe un gestionnaire qui permet de disposer les éventuels composants que contient le container : ce sont les layouts. Il est conseillé d'utiliser ce type de gestionnaire pour indiquer la position des composants plutôt que les coordonnées pixel qui ne garantissent pas le même rendu sur chacune des plateformes où peuvent fonctionner une applet (par exemple, un bouton n'a pas le même aspect ni la même taille sous tous les systèmes).
Globalement, il existe trois solutions pour donner une position à un composant :

Le choix d'un layout se fait grâce à la méthode setLayout () de la classe Container.
Les composants d'un container container1 sont positionnés à l'appel de la méthode layout () de la classe Container sur container1. Cette méthode appelle le gestionnaire qui dispose les composants dans le container. Elle est appelée par la méthode validate () de la classe Component si le container ou un de ses composants ne sont pas valides (à leur première visualisation, quand ils changent de taille,...).
Quand le container est déjà visualisé, l'ajout (ou la suppression) d'un composant à ce container n'appelle pas validate () automatiquement : il vous faut donc appeler cette méthode dans ce cas de figure pour mettre à jour la disposition des composants dans le container (voir l'exemple de la classe BorderLayout).

Les classes de Java dérivant de la classe container utilisent un layout par défaut : Les classes Panel et Applet utilisent la classe FlowLayout, et les classes Window, Dialog et Frame la classe BorderLayout.

!

Si dans certains cas, les classes de layout fournies avec Java ne semblent pas vous convenir, n'oubliez pas avant d'envisager de créer un layout de toute pièce que vous pouvez très bien combiner les layouts existants. Chaque container étant lui-même un composant, vous pouvez agencer une partie de vos composants en les incluant dans un sous-container (de classe Panel par exemple) qui disposera ces composants de manière différente que le layout du container principal. Donc, étudiez bien l'effet de chacun des layouts suivants et soyez imaginatifs ! Toutes les combinaisons sont possibles...
L'exemple du paragraphe sur les containers combine deux layouts, l'un de classe BorderLayout et l'autre de classe FlowLayout.

!

Si vous voulez n'utiliser aucun layout pour un container, il est très fortement conseillé d'outrepasser la méthode layout () de la classe Container pour y disposer vos composants. En effet, pour pouvoir placer sans problème vos composants leur peer doit exister. Le peer d'un container et de ses composants est créé à l'appel de la méthode addNotify () de la classe Container. Cette méthode n'est pas appelée au même moment pour une applet et une fenêtre indépendante, mais elle est toujours suivie d'un appel à validate () et donc d'un appel à la méthode layout () :

  • Pour une applet, addNotify () est appelée juste avant que le navigateur n'appelle les méthodes validate () et init () de la classe Applet (voir l'exemple décrivant l'ensemble des méthodes appelées à la création d'une applet).
  • Pour une fenêtre indépendante (de classe Frame ou Dialog par exemple), addNotify () est invoquée par la méthode show () de la classe Window, qui appelle ensuite la méthode validate ().

L'interface java.awt.LayoutManager

L'interface LayoutManager déclare cinq méthodes que doit définir toute classe qui l'implémente (même si ces méthodes ne font rien).

Méthodes
public void addLayoutComponent (String name, Component component)

Méthode appelée quand le composant component est ajouté à un container par la méthode add (name, component) de la classe Container. Utiliser cette méthode si vous voulez mémoriser les informations supplémentaires décrites dans name et associées au composant component pour le placer. Cette méthode est utilisée par exemple par la classe BorderLayout. Rappelez-vous qu'il n'est pas obligatoire de mémoriser la liste de tous les composants d'un container, car la classe Container fournit la méthode getComponents () qui renvoient la liste de tous les composants ajoutés à un container.

public void removeLayoutComponent (Component component)

Méthode appelée quand le composant component est enlevé d'un container par la méthode remove (component) de la classe Container.

public Dimension preferredLayoutSize (Container parent)

Doit renvoyer les dimensions préférées du container parent auquel ont été ajoutés des composants.

public Dimension minimumLayoutSize (Container parent)

Doit renvoyer les dimensions minimum du container parent auquel ont été ajoutés des composants.

public void layoutContainer (Container parent)

Doit positionner les composants du container parent. Cette méthode est appelée par la méthode layout () de la classe Container si le container parent utilise un layout. C'est donc cette méthode qui place les composants dans le container parent, en utilisant les méthodes move (), resize () ou reshape () de la classe Component et en prenant en compte la largeur des bordures du container renvoyées par la méthode insets () de la classe Container.

La classe java.awt.FlowLayout

Cette classe qui implémente l'interface LayoutManager, est le type de layout le plus simple. Les composants d'un container container1 géré par un FlowLayout sont positionnés les uns derrière les autres, en partant du coin en haut à gauche de container1, puis en occupant horizontalement au maximum la largeur de container1, avant de passer à une ligne suivante.
Chaque composant prend les dimensions que renvoie sa méthode preferredSize ().

Champs
public final static int LEFT
public final static int CENTER
public final static int RIGHT

Constantes utilisées pour l'alignement des composants dans le container (sur le bord gauche, au centre, ou sur le bord droit). Par défaut, l'alignement est CENTER.

Constructeurs
public FlowLayout ()
public FlowLayout (int align)
public FlowLayout (int align, int horizontalgap, int verticalgap)

Ces constructeurs permettent de créer un layout FlowLayout avec un alignement align (LEFT, CENTER ou RIGHT) et un espacement horizontal et vertical entre les composants de horizontalgap et verticalgap pixels (par défaut égal à 5).

Méthodes
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)

Implémentation des méthodes de l'interface LayoutManager. addLayoutComponent () et removeLayoutComponent () ne font rien.

public String toString ()
Exemples

Les applets BorderBuilder , MiseAJourHorloge et BoutonsNavigation affichent leurs composants avec leur layout par défaut de classe FlowLayout.
L'applet TraitementTexte utilise une barre de boutons qui sont ajoutés à un sous-container de classe Panel utilisant son layout par défaut de classe FlowLayout.

La classe java.awt.BorderLayout

Cette classe qui implémente l'interface LayoutManager, est un type de layout qui permet de gérer la position d'au plus cinq composants : La position d'un composant component est déterminée grâce la chaîne de caractères name passée en argument à la méthode add (name, component) de la classe Container. Cette chaîne de caractères peut être égal à "North", "South", "East", "West" ou "Center".
Les cinq composants (ou moins) sont redimensionnés pour occuper l'espace du container en respectant dans l'ordre, les règles suivantes :

Cette classe de layout peut servir dans de nombreux types d'interfaces utilisateurs : Le composant "Center" peut représenter par exemple une zone de dessin ou d'édition de texte, les composants "North" et "West" être utilisés pour afficher des barres d'outils et les composants "East" et "South" pour des ascenseurs (composant Scrollbar).

Constructeurs
public BorderLayout ()
public BorderLayout (int horizontalgap, int verticalgap)

Ces constructeurs permettent de créer un layout BorderLayout avec un espacement horizontal et vertical entre les composants de horizontalgap et verticalgap pixels (par défaut égal à 0).

Méthodes
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)

Implémentation des méthodes de l'interface LayoutManager. L'implémentation de la méthode addLayoutComponent () mémorise pour chacune des cinq directions le composant qui lui est associé.

public String toString ()

Pour illustrer l'utilisation de la classe BorderLayout, voici un exemple d'applet permettant d'ajouter à une fenêtre indépendante des boutons aux cinq positions possibles (La fenêtre s'affiche quand vous cliquez sur un des boutons et est indépendante pour que vous puissiez la redimensionner et observer les effets de la classe BorderLayout) :

Applet BorderBuilder

donne le résultat suivant :

BorderBuilder window

et le programme Java correspondant (à copier dans un fichier dénommé BorderBuilder.java et invoqué à partir d'un fichier HTML) :

import java.applet.Applet;
import java.awt.*;
 
public class BorderBuilder extends Applet
{
  // Création des boutons de l'applet et du Frame
  Button []  appletButtons = {new Button ("Add North"),
                              new Button ("Add South"),
                              new Button ("Add West"),
                              new Button ("Add East"),
                              new Button ("Add Center")};
  Button []  frameButtons = {new Button ("North"),
                             new Button ("South"),
                             new Button ("West"),
                             new Button ("East"),
                             new Button ("Center")};
  Frame      buttonsFrame;
 
  public void init ()
  {
    // Ajout des boutons à l'applet (par défaut utilise FlowLayout)
    for (int i = 0; i < appletButtons.length; i++)
      add (appletButtons [i]);
   
    // Création d'une fenêtre (par défaut utilise BorderLayout)
    buttonsFrame = new Frame ("BorderLayout window");
    buttonsFrame.resize (200, 200);
  }
 
  public void stop ()
  {
    // A la fin de l'applet, destruction de la fenêtre
    buttonsFrame.dispose ();
  }
 
  // Méthode appelée par la machine virtuelle quand on clique sur un bouton
  public boolean action (Event event, Object eventArg)
  {
    // Affichage de la fenêtre
    buttonsFrame.show ();
 
    for (int i = 0; i < appletButtons.length; i++)
      if (event.target == appletButtons [i])
      {
        // Si le label du bouton commence par Add, 
        if (appletButtons [i].getLabel ().startsWith ("Add"))
        {
          // Ajouter le bouton correspondant à buttonsFrame
          buttonsFrame.add (frameButtons [i].getLabel (), frameButtons [i]);
          // Changer le nom du bouton de l'applet
          appletButtons [i].setLabel ("Remove " + frameButtons [i].getLabel ());
        }
        else
        {
          // Sinon enlever le bouton correspondant de buttonsFrame
          buttonsFrame.remove (frameButtons [i]);
          // Changer le nom du bouton de l'applet
          appletButtons [i].setLabel ("Add " + frameButtons [i].getLabel ());
        }
     
        // Mettre à jour les composants de l'applet et de la fenêtre
        appletButtons [i].invalidate ();
        validate ();
        buttonsFrame.validate ();
        return true;
      }
 
     return super.action (event, eventArg);
  }
}
    

!

La classe BorderLayout vous oblige à vous servir de la méthode add (String name, Component component) de la classe Container pour ajouter les composants à un container.

Autres exemples

Applets TraitementTexte, MessageBoxApplet, DrawIt, ListePolices et Nuancier.

La classe java.awt.GridLayout

Cette classe qui implémente l'interface LayoutManager, est un layout permettant d'afficher les composants que contient un container sur une grille régulière. Le nombre de lignes et de colonnes étant passés en argument au constructeur d'un layout GridLayout, la hauteur et la largeur d'un container container1 géré par un GridLayout sont divisées par le nombre de lignes et de colonnes pour connaître la dimension de chaque cellule. Les composants de container1 sont ensuite positionnés dans les cellules, en partant du coin en haut à gauche de container1, puis colonne après colonne et ligne par ligne.
Chaque composant prend les dimensions de la cellule qu'il occupe.

Constructeurs
public GridLayout (int rows, int cols)
public GridLayout (int rows, int cols, int horizontalgap, int verticalgap)

Ces constructeurs permettent de créer un layout GridLayout avec une grille de rows lignes par cols colonnes, et un espacement horizontal et vertical entre les composants de horizontalgap et verticalgap pixels (par défaut égal à 0). Il n'est pas obligatoire de remplir entièrement la grille d'un layout GridLayout, mais attention les lignes inoccupées restent vides ; donc évitez de créer un layout GridLayout avec de grandes dimensions en prévision de son remplissage, sinon les cellules seront toutes petites !

Méthodes
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)

Implémentation des méthodes de l'interface LayoutManager. addLayoutComponent () et removeLayoutComponent () ne font rien.

public String toString ()
Exemples

Applets Unicode, DrawIt, ListePolices.
L'applet GridBagBuilder de la classe GridBagLayout contient aussi un sous-container de classe Panel qui affiche les composants des 17 premières lignes et des 2 colonnes avec un layout de classe GridLayout.

La classe java.awt.GridBagLayout

Cette classe qui implémente l'interface LayoutManager, est le layout le plus complet et le plus complexe à utiliser des layouts fournis avec Java.
A chaque composant ajouté à un container géré par un layout GridBagLayout, sont associées des contraintes (constraints en anglais) décrivant comment placer ce composant dans le container. Ces contraintes sont décrites par une instance de la classe GridBagConstraint et positionnées sur le composant grâce à la méthode setConstraints () de la classe GridBagLayout.

Vu le nombre de paramètres utilisés par les contraintes, le placement des composants gérés par un layout GridBagLayout est complexe et c'est pourquoi cette classe définit de nombreux champs et méthodes protected, vous permettant de modifier le comportement de cette classe dans une classe dérivée.

Champs
public int    columnWidths [ ]
public int    rowHeights [ ]
public double columnWeights [ ]
public double rowWeights [ ]
 
protected final static int MAXGRIDSIZE
protected final static int MINSIZE
protected final static int PREFERREDSIZE
 
protected Hashtable comptable
protected GridBagConstraints defaultConstraints
protected GridBagLayoutInfo layoutInfo
Constructeur
public GridBagLayout ()
Méthodes
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)

Implémentation des méthodes de l'interface LayoutManager. addLayoutComponent () et removeLayoutComponent () ne font rien.

public void setConstraints (Component comp, GridBagConstraints constraints)

Positionne les contraintes sur un composant comp géré par un layout GridBagLayout.

public GridBagConstraints getConstraints (Component component)

Renvoie une copie des contraintes positionnées sur un composant géré par un layout GridBagLayout.

public Point getLayoutOrigin ()
public int [ ][ ] getLayoutDimensions ()
public double [ ][ ] getLayoutWeights ()
public Point location (int x, int y)
 
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)
 

Pour illustrer l'utilisation de la classe GridBagLayout, voici l'applet GridBagBuilder permettant d'ajouter à une fenêtre indépendante le composant de votre choix et de positionner sur chacun des composants les contraintes proposées par la classe GridBagConstraints. La fenêtre s'affiche à la première utilisation d'un des composants de l'applet.

Mode d'emploi

Une fois la classe de votre composant choisie avec le champ Type de composant, vous pouvez saisir dans le champ Label, text ou item le label (pour les classes Button, Checkbox et Label), le texte (pour les classes TextArea et TextField) ou le premier item (pour les classe Choice et List) des nouveaux composants.Vous pouvez aussi positionner une ou plusieurs contraintes (gridx à weighty) sur un composant avant de l'ajouter à la fenêtre Composants avec le bouton Ajouter.
Le champ Champ permet de saisir un nom de champ pour chacun des composants que vous ajoutez ; ce nom est celui utilisé pour intituler chacune des champs du programme généré dans le champ Programme à copier : Vous pouvez sélectionner le code Java écrit dans ce champ, le copier puis le coller dans la déclaration d'une classe dérivant de la classe Container (par exemple, une applet), pour créer les mêmes composants que ceux de la fenêtre Composants.
Le champ Composant courant permet de choisir un des composants créés pour le supprimer avec le bouton Supprimer ou le modifier avec le bouton Modifier après avoir positionner une ou plusieurs contraintes (gridx à weighty) sur ce composant.

Applet GridBagBuilder

N'hésitez pas à utiliser cet exemple pour bien comprendre (et utiliser dans vos programmes) le fonctionnement des classes GridBagLayout et GridBagConstraints.

La classe java.awt.GridBagConstraints

Cette classe qui implémente l'interface Cloneable, est utilisée pour décrire les contraintes sur le positionnement d'un composant inclus dans à un container géré par un layout GridBagLayout Les différentes contraintes étant plutôt complexes à gérer, il vous est conseillé d'essayer l'applet GridBagBuilder pour essayer les différentes combinaisons possibles et comprendre leur effet. Cette applet génère le code correspondant aux différentes contraintes choisies dans le champ Programme à copier.

Champs
public final static int RELATIVE
public final static int REMAINDER
 
public final static int NONE
public final static int BOTH
public final static int HORIZONTAL
public final static int VERTICAL
 
public final static int CENTER
public final static int NORTH
public final static int NORTHEAST
public final static int EAST
public final static int SOUTHEAST
public final static int SOUTH
public final static int SOUTHWEST
public final static int WEST
public final static int NORTHWEST
 
public int gridx
public int gridy

Permet de donner la position en x et y de la cellule que doit occuper un composant, relativement au coin supérieur gauche du container (dont la position est (0, 0)). Si gridx (ou respectivement gridy) est égal à RELATIVE, le composant sera placé à droite (ou respectivement en dessous) du composant précédemment ajouté au container par la méthode add () de la classe Container.

public int gridwidth
public int gridheight

Permet de donner le nombre de cellules en largeur et en hauteur qu'un composant occupe. Si gridwith (ou respectivement gridheight) est égal à REMAINDER, le composant sera le dernier sur une ligne (ou respectivement sur une colonne). Si gridwith (ou respectivement gridheight) est égal à RELATIVE, le composant sera placé à gauche (ou respectivement au dessus) du composant suivant.

public int fill

Permet de spécifier si un composant est redimensionné ou non pour occuper la(ou les) cellules qu'il occupe. Si fill est égal à NONE, le composant prend la taille qu'il donne par la méthode preferredSize (). Si fill est égal BOTH, le composant est redimensionné pour occuper tout l'espace de la (ou des) cellules. Si fill est égal HORIZONTAL (ou respectivement VERTICAL) le composant prend la largeur (ou respectivement la hauteur) de la (ou les) cellules qu'il occupe.

public int ipadx
public int ipady

Permet de donner la largeur et la hauteur supplémentaire que doit prendre le composant par rapport à la taille qu'il donne par la méthode preferredSize ().

public Insets insets

Permet de donner l'espacement vide autour du composant.

public int anchor

Quand le composant est plus petit que la (ou les) cellules qu'il occupe, anchor permet de donner à quel coin ou à quel bord le composant est ancré (ou attaché). anchor peut être égal à CENTER ou aux 8 points cardinaux : NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST ou NORTHWEST.

public double weightx
public double weighty

Permet de donner un poids au composant par rapport aux autres pour répartir les composants horizontalement ou verticalement. Si tous les composants ont leurs contraintes weightx et weighty égales à 0, l'ensemble des composants d'un container géré par un layout GridBagLayout occupe le minimum d'espace au milieu du container.

Constructeur
public GridBagConstraints ()

Le constructeur affecte aux champs de contraintes les valeurs par défaut suivantes :

Méthode
public Object clone ()

!

A l'usage, vous vous rendrez compte que certaines contraintes ne se complètent pas toujours de manière très heureuse... Evitez notamment d'utiliser, le mélange du positionnement absolu de gridx et gridy, avec l'utilisation de REMAINDER pour gridwidth et gridheight.
Si l'utilisation des classes GridBagLayout et GridBagConstraints vous semble trop compliqué, n'hésitez pas à utiliser plutôt une combinaison de layouts.

La classe java.awt.CardLayout

Cette classe qui implémente l'interface LayoutManager, est un layout permettant d'ajouter à un container une liste de sous-containers ou de composants qui sont affichés un par un, de manière similaire aux boites de dialogues à onglets (mais sans les onglets).

Constructeurs
public CardLayout ()
public CardLayout (int horizontalgap, int verticalgap)

Ces constructeurs permettent de créer un layout CardLayout avec un espacement horizontal et vertical entre les composants de horizontalgap et verticalgap pixels (par défaut égal à 0).

Méthodes
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)

Implémentation des méthodes de l'interface LayoutManager. La méthode addLayoutComponent () utilise le paramètre name pour associer une chaîne de caractères au composant ou au container comp.

public void first (Container parent)
public void next (Container parent)
public void previous (Container parent)
public void last (Container parent)

Ces méthodes permettent d'afficher le premier, le suivant, le précédent ou le dernier de la liste des composants ou des sous-containers du layout. parent doit être égal au container auquel est associé ce layout.

public void show (Container parent, String name)

Affiche le composant ou le sous-container associé à la chaîne de caractères name. parent doit être égal au container auquel est associé ce layout. Si vous voulez utiliser cette méthode, il faut que le composant ait été ajouté au container avec la méthode add (String name, Component component) de la classe Container.

public String toString ()
 

Les menus

La création de menus se fait très simplement en Java, à l'aide de 4 classes différentes qui héritent toutes de la classe MenuComponent. Une barre de menu se compose d'une instance de la classe MenuBar auquel vous pouvez ajouter grâce à la méthode add () un ou plusieurs menus instances de la classe Menu. Finalement, vous pouvez ajouter à chaque menu grâce à la méthode add () de la classe Menu un ensemble d'éléments instances des classes MenuItem (pour créer des éléments simples), CheckboxMenuItem (pour créer des éléments à cocher) ou Menu (pour créer un sous-menu).

Les différents composants d'un menu
figure 16. Les différents composants d'un menu

La classe Frame est la seule classe de fenêtre pour laquelle vous pouvez spécifier une barre de menu, grâce à la méthode setMenuBar (). Par conséquent, vous ne pouvez pas donner de menu aux applets, puisque leur classe n'hérite pas de la classe Frame.

L'applet suivante permet de tester tous les différents types de menu décrit ci-dessus (cliquez sur le bouton Nouveau Menu pour afficher la fenêtre utilisant un menu) :

Applet ShowMenu

Voici le programme Java correspondant (à copier dans un fichier dénommé ShowMenu.java et invoqué à partir d'un fichier HTML) :

import java.applet.Applet;
import java.awt.*;
 
public class ShowMenu extends Applet
{
  // Création d'une instance de MenuFrame
  Frame fenetreMenu = new MenuFrame ();
 
  public void init ()
  {
    // Ajout d'un bouton pour ouvrir une fenêtre
    add (new Button ("Nouveau Menu"));
  }
 
  public void stop ()
  {
    // A la fin de l'applet, destruction de la fenêtre
    fenetreMenu.dispose ();
  }
 
  // Méthode appelée par la machine virtuelle quand on clique sur un bouton
  public boolean action (Event event, Object eventArg)
  {
    // Affichage de la fenêtre 
    if ("Nouveau Menu".equals (eventArg))
      fenetreMenu.show ();
    return true;
  }
}  
 
// Classe MenuFrame utilisant un menu
class MenuFrame extends Frame
{
  public MenuFrame ()
  {
    // Création d'une barre de menu et de 3 menus
    MenuBar menuBar = new MenuBar ();
    Menu    menu1   = new Menu ("Menu 1");
    Menu    menu2   = new Menu ("Menu 2");
    Menu    menu3   = new Menu ("Sous menu");
    
    // Ajout au premier menu de 2 éléments et d'un séparateur
    menu1.add ("Choix 1");
    menu1.addSeparator ();
    menu1.add ("Choix 2");
 
    // Ajout au second menu d'un élément à cocher
    //                   et d'un sous-menu
    menu2.add (new CheckboxMenuItem ("Choix"));
    menu2.add (menu3);
 
    // Ajout au sous-menu de 2 éléments
    menu3.add (new MenuItem ("Sous choix 1"));
    menu3.add (new MenuItem ("Sous choix 2"));
 
    // Ajout à la barre de menu des 2 premiers menus
    menuBar.add (menu1);
    menuBar.add (menu2);
    
    // Choix de la barre de menu pour cette fenêtre
    setMenuBar (menuBar);
 
    resize (200, 50);
  }
}
 

L'interface java.awt.MenuContainer

Cette interface doit être implémentée par les classes de containers permettant l'utilisation des menus, comme c'est le cas pour la classe Frame.

Méthodes
public Font getFont ()
public boolean postEvent (Event evt)
public void remove (MenuComponent comp)

La classe java.awt.MenuComponent

La classe MenuComponent qui est abstract est la super classe de toutes les classes de composants utilisables dans un menu (MenuBar, MenuItem, Menu et CheckboxMenuItem). Elle ressemble dans le principe à la classe Component en plus simple.

Constructeur
public MenuComponent ()
Méthodes
public MenuContainer getParent ()
public MenuComponentPeer getPeer ()

Ces méthodes permettent d'obtenir le container auquel est rattaché un composant de menu et le peer d'un composant de menu.

public Font getFont ()
public void setFont (Font font)

Ces méthodes permettent d'interroger ou de modifier la police de caractère utilisée pour l'affichage d'un composant de menu.

public void removeNotify ()

Cette méthode est appelée pour supprimer le peer d'un composant de menu.

protected String paramString ()
public String toString ()

Ces méthodes sont utilisées pour fabriquer une chaîne de caractères décrivant le composant de menu (toString () outrepasse la méthode de la classe Object et appelle la méthode paramString () qui est outrepassée par les classes dérivées de MenuComponent).

public boolean postEvent (Event evt)

La classe java.awt.MenuBar

Cette classe qui dérive de la classe MenuComponent, est la classe du package java.awt qui permet de créer et de manipuler une barre de menu. Une fois que vous avez créez une barre de menu vous pouvez y ajouter un ou plusieurs menus. La méthode setMenuBar () de classe Frame permet de spécifier la barre de menu que doit utiliser une fenêtre.

Constructeur
public MenuBar ()
Méthodes
public synchronized void addNotify ()
public void removeNotify ()

Ces méthodes permettent de créer et de détruire le peer d'une barre de menu (removeNotify () outrepasse la méthode de la classe MenuComponent).

public synchronized Menu add (Menu menu)

Permet d'ajouter un menu à une barre de menu.

public synchronized void remove (int index)
public synchronized void remove (MenuComponent menu)

Ces méthodes permettent de supprimer un menu d'une barre de menu, soit en donnant son numéro d'ordre index, soit en donnant directement l'instance de menu à supprimer.

public int countMenus ()

Renvoie le nombre de menus courant d'une barre de menu.

public Menu getMenu (int index)

Renvoie le menu dont le numéro d'ordre est index.

public Menu getHelpMenu ()
public synchronized void setHelpMenu (Menu m)

Ces méthodes permettent d'interroger ou de modifier le menu d'aide.

Exemple

Applet ShowMenu.

La classe java.awt.MenuItem

Cette classe qui dérive de la classe MenuComponent, est la classe du package java.awt qui permet de créer et de manipuler un élément simple de menu. Un élément de menu a un label qui est le texte affiché dans le menu et peut être éventuellement grisé pour indiquer qu'il n'est pas utilisable à un moment donné.

Constructeur
public MenuItem (String label)

Ce constructeur permet de donner un label au nouveau menu créé.

Méthodes
public synchronized void addNotify ()

Permet de créer le peer d'un élément de menu.

public String getLabel ()
public void setLabel (String label)

Ces méthodes permettent d'interroger ou de modifier le label d'un menu.

public boolean isEnabled ()

Renvoie true si un élément de menu est utilisable.

public void enable ()
public void disable ()
public void enable (boolean cond)

Vous pouvez rendre utilisable ou inutilisable un composant grâce à ces méthodes. Un élément de menu inutilisable (disabled) est généralement grisé.

public String paramString ()

Méthode de la classe MenuComponent, outrepassée pour renvoyer une chaîne de caractères décrivant l'élément de menu.

Exemple

Applet ShowMenu.

La classe java.awt.Menu

Cette classe qui dérive des classes MenuItem et MenuComponent est la classe du package java.awt qui permet de créer et de manipuler un menu ou un sous-menu. Un menu a un label et peut contenir un ou plusieurs éléments ; les éléments qui sont eux-mêmes des instances de la classe Menu deviennent des sous-menus.

Constructeurs
public Menu (String label)
public Menu (String label, boolean tearOff)
Méthodes
public synchronized void addNotify ()
public synchronized void removeNotify ()

Ces méthodes permettent de créer et de détruire le peer d'un menu (removeNotify () outrepasse la méthode de la classe MenuComponent).

public boolean isTearOff ()
 
public int countItems ()

Renvoie le nombre d'éléments d'un menu.

public MenuItem getItem (int index)

Renvoie l'élément du menu de numéro d'ordre index.

public synchronized MenuItem add (MenuItem menuItem)
public void add (String label)

Ces méthodes permettent d'ajouter un élément à un menu.

public void addSeparator ()

Permet d'ajouter un séparateur à un menu. Equivalent à l'appel de la méthode add ("-").

public synchronized void remove (int index)
public synchronized void remove (MenuComponent item)

Ces méthodes permettent de retirer d'un menu l'élément de numéro d'ordre index ou l'élément item.

Exemple

Applet ShowMenu.

La classe java.awt.CheckboxMenuItem

Cette classe qui dérive des classes MenuItem et MenuComponent est la classe du package java.awt qui permet de créer et de manipuler un élément de menu à cocher. Comme un composant de classe Checkbox, ce type d'élément de menu a un état coché ou non.

Constructeur
public CheckboxMenuItem (String label)
Méthodes
public synchronized void addNotify ()

Permet de créer le peer d'un élément de menu à cocher.

public boolean getState ()
public void setState (boolean t)

Ces méthodes permettent d'interroger ou de modifier l'état coché ou non de l'élément de menu.

public String paramString ()

Méthode de la classe MenuComponent, outrepassée pour renvoyer une chaîne de caractères décrivant l'élément de menu à cocher.

Exemple

Applet ShowMenu.


Page d'accueilFindIt !ContactLes composants de l'interface utilisateurLes notions de baseDébut de la page
© Copyrights 1997-2015 Emmanuel PUYBARET / eTeks
- Tous droits réservés -
Table des matièresHiérarchie des classes