Page d'accueilFindIt !ContactLes containers et la disposition des composantsLes images

La bibliothèque JavaTM 1.0
Table des matièresHierarchie des classes

CJava

 La gestion de l'interface utilisateur

La gestion événementielle
La classe Graphics : tout pour dessiner
Les polices de caractères
La couleur
Les classes manipulant des dimensions
La création de nouveaux composants

 

La gestion événementielle

Maintenant que vous avez vu comment créer et disposer un ensemble de composants à l'écran, il reste à aborder comment gérer l'interactivité de ces composants avec votre programme pour que vous puissiez réagir aux actions d'un utilisateur, quand il utilise tel ou tel composant.

Les événements

La classe Component déclare tout un ensemble de méthodes qui permettent de réagir aux différents événements que peut recevoir un composant. Dans les différents exemples déjà cités, l'une de ces méthodes, action () a été souvent outrepassée pour traiter les actions d'un utilisateur sur un composant, mais en fait il existe tout un ensemble de méthodes traitant chacune des événements qui peuvent survenir lors de l'utilisation de l'ordinateur. On regroupe sous le terme générique événement tout type d'entrée qu'un programme peut s'attendre à recevoir.
Les événements peuvent se regrouper en plusieurs catégories :

Avant l'avènement des systèmes utilisant une interface graphique, les programmes attendaient que l'utilisateur appuie sur une touche de clavier pour effectuer telle ou telle action suivant la touche enfoncée. Similairement, un programme utilisant les fonctionnalités d'une interface graphique utilise une boucle pour attendre un événement quelconque qui permettra de déclencher telle ou telle action d'un programme.
Quand un programme Java reçoit un événement, il exécute toujours le même scénario qu'il faut bien comprendre pour programmer correctement. La Machine Virtuelle Java utilise l'arbre des composants que vous avez créé (comme celui de l'applet TraitementTexte du chapitre précédent) pour déterminer les différents composants auxquels peut se destiner un nouvel événement. Quand un événement est reçu par un composant comp d'un programme Java, la méthode handleEvent () de la classe Component est appelée par la Machine Virtuelle Java. handleEvent () renvoie false par défaut ce qui provoque l'appel de la méthode handleEvent () du composant parent du composant comp, ainsi de suite jusqu'à ce que le composant n'est pas de parent. Si la classe d'un des composants sur lequel handleEvent () est invoqué outrepasse cette méthode, c'est cette méthode qui sera appelée, ce qui vous permet de modifier le comportement par défaut d'un composant qui dérive de Component. Quand vous outrepassez cette méthode, vous pouvez terminer votre méthode de trois manières suivant ce que vous voulez faire :

L'enchaînement des appels aux méthodes handleEvent () sur chacun des parents d'un composant est très pratique car il évite de traiter les événements au niveau de chacun des composants où ils surviennent. Vous pouvez ainsi traiter le clic d'un bouton dans la classe de son container, ce qui évite de créer une nouvelle classe pour ce bouton.
Pour vous le montrer, voici une applet simple qui affiche l'heure courante dans un label quand vous cliquez sur le bouton Mise à l'heure :

Applet MiseAJourHorloge

Cette applet peut être réalisée de deux manières différentes comme suit (à copier dans un fichier dénommé MiseAJourHorloge.java et invoqué à partir d'un fichier HTML) : 

import java.applet.Applet;
import java.awt.*;
import java.util.Date;
 
public class MiseAJourHorloge
                 extends Applet
{
  private Label  heure = new Label (
           new Date ().toLocaleString ());
  private Button miseAHeure =
    new BoutonMiseAJour ("Mise \u00e0 l'heure",
                         heure);
 
  public void init ()
  {
    // Ajout des deux composants
    add (miseAHeure);
    add (heure);
  }
}
 
class BoutonMiseAJour extends Button
{
  private Label heure;
  
  // Constructeur
  public BoutonMiseAJour (String label,
                          Label heure)
  {
    super (label);
    this.heure = heure;
  }
  
  // Méthode appelée par la Machine
  // Virtuelle quand un événement survient
  public boolean handleEvent (Event event)
  {
    // Si l'événement est un clic sur le
    // bouton, mise à jour de l'horloge
    if (event.id == Event.ACTION_EVENT)
    {
      heure.setText (
             new Date ().toLocaleString ());
      return true;
    }
    return super.handleEvent (event);
  }
}
 
import java.applet.Applet;
import java.awt.*;
import java.util.Date;
 
public class MiseAJourHorloge 
                 extends Applet
{
  private Label  heure = new Label (
           new Date ().toLocaleString ());
  private Button miseAHeure =
    new Button ("Mise \u00e0 l'heure");
 
 
  public void init ()
  {
    // Ajout des deux composants
    add (miseAHeure);
    add (heure);
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  // Méthode appelée par la Machine
  // Virtuelle quand un événement survient
  public boolean handleEvent (Event event)
  {
    // Si l'événement est un clic sur le
    // bouton, mise à jour de l'horloge
    if (   event.target == miseAHeure
        && event.id == Event.ACTION_EVENT)
    {
      heure.setText (
             new Date ().toLocaleString ());
      return true;
    }
    return super.handleEvent (event);
  }
}

La première méthode respecte plus le style de programmation orientée objet : on y modifie le comportement par défaut d'un bouton en créant une nouvelle classe dérivée de Button. La seconde méthode est plus pratique : on modifie le comportement du container qui a créé tous les composants en lui indiquant comment gérer ses composants.
Un container contenant généralement plusieurs composants qui interagissent entre eux (comme l'applet TraitementTexte), on utilise plus souvent le second style de programmation en décrivant dans une seule méthode le traitement des événements que reçoivent les différents composants gérés par le container.

Pour faciliter la clarté du traitement de certains types d'événements, la méthode handleEvent () de la classe Component appelle certaines méthodes suivant le type d'événement reçu. Ces méthodes, comme la méthode action (), peuvent être outrepassées dans vos classes à la place (ou en plus) de la méthode handleEvent (). Elles doivent toutes renvoyer une valeur booléenne indiquant comme pour handleEvent () si l'événement doit être renvoyé au parent du composant (return false;) ou non (return true;). En voici la liste :

EVENEMENT

METHODE

DESCRIPTION

Event.MOUSE_ENTER

public boolean mouseEnter (Event evt, int x, int y)

Méthode appelée quand le pointeur de la souris entre dans un composant (utilisé par exemple pour changer l'aspect du pointeur).

Event.MOUSE_EXIT

public boolean mouseExit (Event evt, int x, int y)

Méthode appelée quand le pointeur de la souris sort d'un composant.

Event.MOUSE_DOWN

public boolean mouseDown (Event evt, int x, int y)

Méthode appelée le bouton de la souris est enfoncé.

Event.MOUSE_UP

public boolean mouseUp (Event evt, int x, int y)

Méthode appelée le bouton de la souris est relâché.

Event.MOUSE_MOVE

public boolean mouseMove (Event evt, int x, int y)

Méthode appelée quand le pointeur de la souris est déplacé.

Event.MOUSE_DRAG

public boolean mouseDrag (Event evt, int x, int y)

Méthode appelée quand le pointeur de la souris est déplacé, avec le bouton de la souris enfoncé.

Event.KEY_PRESS
Event.KEY_ACTION

public boolean keyDown (Event evt, int key)

Méthode appelée quand une touche du clavier est enfoncée.

Event.KEY_RELEASE
Event.KEY_ACTION_RELEASE

public boolean keyUp (Event evt, int key)

Méthode appelée quand une touche du clavier est relâchée.

Event.GOT_FOCUS

public boolean gotFocus (Event evt, Object arg)

Méthode appelée quand un composant obtient le focus. Un composant qui a le focus est celui qui reçoit les entrées du clavier.

Event.LOST_FOCUS

public boolean lostFocus (Event evt, Object arg)

Méthode appelée quand un composant perd le focus.

Event.ACTION_EVENT

public boolean action (Event evt, Object arg)

Méthode appelée quand l'utilisateur effectue une action dans un composant : Suivant la classe du composant, ceci peut prendre un sens différent.


Nota : La liste de tous les événements reconnus en Java est donnée dans la classe Event décrite ci-après.

 

Pour les événements MOUSE_..., x et y représentent les coordonnées du pointeur de la souris relatives au repère du composant où vous recevez l'événement.
Pour les événements KEY_..., key représente le code UNICODE de la touche enfoncée ou l'une des valeurs Event.HOME à Event.F12 pour les touches spéciales du clavier.
Pour l'événement ACTION_EVENT, arg peut prendre une valeur différente suivant la classe du composant où est survenu l'événement :

Finalement, l'applet MiseAJourHorloge peut être programmée comme ceci : 

import java.applet.Applet;
import java.awt.*;
import java.util.Date;
 
public class MiseAJourHorloge extends Applet
{
  private Label  heure = new Label (new Date ().toLocaleString ());
  private Button miseAHeure = new Button ("Mise \u00e0 l'heure");
 
  public void init ()
  {
    // Ajout des deux composants
    add (miseAHeure);
    add (heure);
  }
  
  // Méthode appelée par la machine virtuelle à la suite d'une action
  public boolean action (Event event, Object arg)
  {
    // Si l'événement est un clic sur le bouton, mise à jour de l'horloge
    if ("Mise \u00e0 l'heure".equals (arg))
      heure.setText (new Date ().toLocaleString ());
    return true;
  }
}
 

!

Si vous outrepassez handleEvent () ET une des méthodes précédentes dans la même classe, n'oubliez pas l'appel super.handleEvent (event); pour les événements que vous ne traitez pas dans handleEvent (). Sinon ces méthodes ne seront pas appelées.

 

Les applets DrawIt et PaperBoardClient sont des exemples d'utilisation des méthodes mouseDown (), mouseDrag () et mouseUp ().
L'applet PaperBoardClient est un exemple d'utilisation des méthodes mouseDown (), mouseUp (), mouseEnter () et mouseExit ().
L'applet EchoClient est un exemple d'utilisation de la méthode keyDown ().

La classe java.awt.Event

La classe Event est la classe qui regroupe tous les événements qui peuvent survenir dans un programme. Les méthodes de gestion événementielle (handleEvent () ou autre) que vous outrepassez dans vos classes reçoivent un événement de cette classe créé par la Machine Virtuelle Java.
Vous pouvez aussi créer vous-même des événements que vous envoyez à un composant par la méthode postEvent () de la classe Component. Le principal avantage d'envoyer un événement à un composant de classe Comp1 à partir d'une autre classe CompEmetteur plutôt que d'appeler une méthode que vous créez dans la classe Comp1, est que vous rendez indépendantes ces deux classes l'une de l'autre.

Contrairement à la plupart des classes de la librairie Java, les champs de la classe Event sont public, et vous pouvez consulter directement les caractéristiques d'un événement par ces champs.

Champs
public Object target

Désigne l'objet cible de l'événement (généralement le composant où est survenu l'événement). 

public long when

Représente le moment où est survenu l'événement. 

public int id

Caractérise le type d'événement qui est survenu (égal aux valeurs WINDOW_DESTROY à LOST_FOCUS décrites ci-après). 

public int x
public int y

Pour les événements souris, x et y sont les coordonnées du pointeur de la souris. Ces coordonnées sont relatives au repère du composant où vous consultez l'événement. 

public int key

Pour les événements clavier, key représente le code UNICODE de la touche enfoncée ou l'une des valeurs HOME à F12 décrites ci-après pour les touches spéciales du clavier. 

public int modifiers

Représente la combinaison des valeurs SHIFT_MASK à ALT_MASK, représentant l'état enfoncé ou non des touches Shift, Control, Meta et Alt. Si par exemple les touches Shift et Control sont enfoncées modifiers sera égal à SHIFT_MASK | CTRL_MASK. 

public int clickCount

Pour les événements MOUSE_DOWN, représente le nombre de clics consécutifs (égal à 2 pour un double clic,...). 

public Object arg

arg peut prendre n'importe quelle valeur. Il est utilisé comme argument utilisateur pour fournir éventuellement des renseignements supplémentaires au composant récepteur de l'événement courant. Par exemple, l'événement ACTION_EVENT émis par la plupart des composants Java l'utilise pour communiquer le label du composant. 

public Event evt

Désigne l'événement suivant quand les événements sont mis dans une liste chaînée. 

 
public final static int SHIFT_MASK
public final static int CTRL_MASK
public final static int ALT_MASK

Ces constantes représentent la combinaison de l'état enfoncé ou non des touches Shift (Majuscule), Control et Alt. 

public final static int META_MASK

Cette constante représente la combinaison de l'état enfoncé ou non de la touche Pomme sous Mac OS ou du bouton droit de la souris sur les autres systèmes. 

public final static int HOME
public final static int END
public final static int PGUP
public final static int PGDN
public final static int UP
public final static int DOWN
public final static int LEFT
public final static int RIGHT
public final static int F1
public final static int F2
public final static int F3
public final static int F4
public final static int F5
public final static int F6
public final static int F7
public final static int F8
public final static int F9
public final static int F10
public final static int F11
public final static int F12

Ces constantes représentent les touches spéciales du clavier. 

public final static int WINDOW_DESTROY
public final static int WINDOW_EXPOSE
public final static int WINDOW_ICONIFY
public final static int WINDOW_DEICONIFY
public final static int WINDOW_MOVED
public final static int KEY_PRESS
public final static int KEY_RELEASE
public final static int KEY_ACTION
public final static int KEY_ACTION_RELEASE
public final static int MOUSE_DOWN
public final static int MOUSE_UP
public final static int MOUSE_MOVE
public final static int MOUSE_ENTER
public final static int MOUSE_EXIT
public final static int MOUSE_DRAG
public final static int SCROLL_LINE_UP
public final static int SCROLL_LINE_DOWN
public final static int SCROLL_PAGE_UP
public final static int SCROLL_PAGE_DOWN
public final static int SCROLL_ABSOLUTE
public final static int LIST_SELECT
public final static int LIST_DESELECT
public final static int ACTION_EVENT
public final static int LOAD_FILE
public final static int SAVE_FILE
public final static int GOT_FOCUS
public final static int LOST_FOCUS

Ces constantes représentent tous les événements qui peuvent survenir dans un programme Java. Pour certains de ces événements, la méthode handleEvent () de la classe Component appelle des méthodes que vous pouvez outrepasser.

Constructeurs
public Event (Object target, long when, int id,
              int x, int y, int key, int modifiers,
              Object arg)
public Event (Object target, long when, int id,
              int x, int y, int key, int modifiers)
public Event (Object target, int id, Object arg)

Ces constructeurs permettent de créer un événement. Les paramètres correspondent aux champs de la classe Event.

Méthodes
public void translate (int x, int y)

Effectue une translation de (x,y) sur les coordonnées de l'événement. 

public boolean shiftDown ()
public boolean controlDown ()
public boolean metaDown ()

Ces méthodes permettent de savoir si lors d'un événement les touches Shift, Control et Meta sont enfoncées (true) ou non. 

protected String paramString ()
public String toString ()

Ces méthodes sont utilisées pour fabriquer une chaîne de caractères décrivant le composant (toString () outrepasse la méthode de la classe Object et appelle la méthode paramString ()).

Pour essayer le traitement des événements, vous pouvez par exemple améliorer l'applet du piano du chapitre sur les applets, en ajoutant des raccourcis clavier aux différentes notes (ceci vous permettra de tester le mixage des sons en jouant des accords).

!

A partir de la version de Java 1.1 un traitement des événements différents de Java 1.0 a été mis en place. Ce sujet sera traité dans une version ultérieure de ce manuel.

Exemples

Applets Piano, PaperBoardClient, TraitementTexte, BorderBuilder, MiseAJourHorloge , ListePolices, Nuancier et BoutonsNavigation. Voir aussi ci-dessus.

La classe Graphics : tout pour dessiner

La classe java.awt.Graphics

La classe Graphics qui est abstract représente un contexte graphique et regroupe toutes les méthodes permettant de dessiner (ligne, rectangle, arc de cercle, polygone, texte et image), quelque soit le support final (écran, imprimante, image en mémoire). Il n'est pas possible de créer directement d'objet de cette classe grâce à l'opérateur new, mais vous pouvez récupérer une instance de cette classe en paramètre des méthodes paint () et update () ou par la méthode getGraphics () de la classe Component.

Constructeur

protected Graphics ()

Méthodes

public abstract Graphics create ()

Crée une copie d'un contexte graphique. 

public Graphics create (int x, int y, int width, int height)

Crée une copie d'un contexte graphique, en effectuant en plus une translation (x,y) sur le repère courant et en créant une zone de clipping de largeur width et hauteur height. Seuls les dessins effectués à l'intérieur de cette zone de clipping seront affichés. 

public abstract void translate (int x, int y)

Cette méthode effectue une translation (x,y) sur le repère courant. Tous les ordres graphiques seront ensuite calculés par rapport à ce nouveau repère. 

public abstract Rectangle getClipRect ()
public abstract void clipRect (int x, int y, int width, int height)

Ces méthodes permettent d'interroger ou de modifier la zone de clipping courante. Seuls les dessins effectués à l'intérieur de cette zone de clipping seront affichés. S'il existe déjà un rectangle de clipping, le rectangle de clipping résultant de l'appel à la méthode clipRect () est l'intersection entre le rectangle courant et celui passé en paramètre. 

public abstract Color getColor ()
public abstract void setColor (Color c)

Ces méthodes permettent d'interroger ou de modifier la couleur courante utilisée pour dessiner. 

public abstract void setPaintMode ()
public abstract void setXORMode (Color c1)

Ces méthodes permettent de choisir le mode d'utilisation de la couleur au cours d'un dessin. setPaintMode () positionne le mode le plus usuel où tout dessin est effectué avec la couleur courante. setXORMode () positionne le mode XOR : Dans ce mode, tout ordre graphique effectué deux fois aux mêmes coordonnées s'annule ; si la couleur d'un pixel (ou d'un point) à dessiner est égale à la couleur courante, il prend la couleur c1, les pixels d'une autre couleur prennent une couleur non prévisible. Ce mode est surtout utilisé pour dessiner des rectangles élastiques quand l'utilisateur doit désigner un ensemble d'objets ou dessiner un rectangle élastique. A chaque déplacement du pointeur de la souris, avant de dessiner un rectangle aux nouvelles coordonnées, vous annulez le rectangle précédent en le redessinant à la même position. 

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

Ces méthodes permettent d'interroger ou de modifier la police de caractère courante utilisée pour dessiner les textes. 

public FontMetrics getFontMetrics ()
public abstract FontMetrics getFontMetrics (Font font)

Ces méthodes permettent d'interroger les tailles de la police de caractère courante ou de la police de caractère font. 

public abstract void drawLine (int x1, int y1, int x2, int y2)

Permet de dessiner une ligne reliant les points de coordonnées (x1,y1) et (x2,y2). 

public void drawRect (int x, int y, int width, int height)

Permet de dessiner le contour du rectangle au point de coordonnées (x,y), de largeur (vers la droite) width et de hauteur (vers le bas) height.
Ce rectangle s'étend en fait du pixel de coordonnées (x,y) à celui de coordonnées (x + width,y + height), ce qui donne une largeur de width + 1 pixels et une hauteur de height + 1 pixels. 

public abstract void fillRect (int x, int y, int width, int height)
public abstract void clearRect (int x, int y, int width, int height)

Ces méthodes permettent de remplir le rectangle au point de coordonnées (x,y), de largeur width et de hauteur height. fillRect () utilise la couleur courante comme couleur de remplissage et clearRect () utilise la couleur de fond.
Contrairement à la méthode drawRect (), ce rectangle s'étend du pixel de coordonnées (x,y) à celui de coordonnées (x + width - 1,y + height - 1), ce qui donne une largeur de width pixels et une hauteur de height pixels. 

public abstract void drawRoundRect (int x, int y, int width int height,
                                     int arcWidth, int arcHeight)
public abstract void fillRoundRect (int x, int y, int width, int height,
                                     int arcWidth, int arcHeight)

Ces méthodes permettent de dessiner ou de remplir un rectangle dont les bords sont arrondis. 

public void draw3DRect (int x, int y, int width, int height, boolean raised)
public void fill3DRect (int x, int y, int width, int height, boolean raised)

Ces méthodes permettent de dessiner ou de remplir un rectangle avec effet 3D. Si raised est égal à true, le rectangle sera en relief, sinon il sera en creux. 

public abstract void drawOval (int x, int y, int width, int height)
public abstract void fillOval (int x, int y, int width, int height)

Ces méthodes permettent de dessiner le contour d'un oval ou de remplir un ovale (ou une ellipse) contenu dans le rectangle de coordonnées (x,y), de largeur width et de hauteur height.
Pour les deux méhodes, ce rectangle s'étend en fait du pixel de coordonnées (x,y) à celui de coordonnées (x + width,y + height), ce qui donne une largeur de width + 1 pixels et une hauteur de height + 1 pixels. 

public abstract void drawArc (int x, int y, int width, int height,
                               int startAngle, int arcAngle)
public abstract void fillArc (int x, int y, int width, int height,
                               int startAngle, int arcAngle)

Ces méthodes permettent de dessiner le contour d'un arc ou de remplir un arc d'ellipse contenu dans le rectangle de coordonnées (x,y), de largeur width et de hauteur height. L'arc est dessiné à partir de l'angle startAngle degrés (correspondant à l'angle de 3 heures), et s'étend sur arcAngle degrés dans le sens trigonométrique, si arcAngle est positif.
Le rectangle englobant s'étend du pixel de coordonnées (x,y) à celui de coordonnées (x + width,y + height), ce qui donne une largeur de width + 1 pixels et une hauteur de height + 1 pixels. 

public abstract void drawPolygon (int xPoints [ ], int yPoints [ ],
                                   int nPoints)
public void drawPolygon (Polygon p)
public abstract void fillPolygon (int xPoints [ ], int yPoints [ ],
                                   int nPoints)
public void fillPolygon (Polygon p)

Ces méthodes permettent de dessiner ou de remplir un polygone. Les points du polygone peuvent être donnés soit dans les tableaux xPoints et yPoints représentant les coordonnées (x,y) de chaque point, soit par uns instance de la classe Polygon. 

public abstract void drawString (String str, int x, int y)
public void drawChars (char data [ ], int offset,
                        int length, int x, int y)
public void drawBytes (byte data [ ], int offset,
                        int length, int x, int y)

Ces méthodes permettent de dessiner une chaîne de caractères avec la police de caractère courante au point de coordonnées (x,y) : l'ordonnée y de ce point est la ligne de base sur laquelle sera dessinée la chaîne. La chaîne de caractères peut être donnée soit par une instance de String, soit par les length premiers caractères à partir de l'indice offset du tableau data. 

public abstract void copyArea (int x, int y, int width, int height,
                                int dx, int dy)

Permet de copier au point de coordonnées (x + dx,y + dy) la partie du composant contenue dans le rectangle au point de coordonnées (x,y), de largeur width et de hauteur height. 

public abstract boolean drawImage (Image img, int x, int y,
                                    ImageObserver observer)
public abstract boolean drawImage (Image img, int x, int y,
                                    int width, int height,
                                    ImageObserver observer)
public abstract boolean drawImage (Image img, int x, int y,
                                    Color bgcolor,
                                    ImageObserver observer)
public abstract boolean drawImage (Image img, int x, int y,
                                    int width, int height,
                                    Color bgcolor,
                                    ImageObserver observer)

Ces méthodes permettent de dessiner l'image img, au point de coordonnées (x,y). La largeur et la hauteur width et height permettent éventuellement de d'agrandir ou de diminuer la taille de l'image. Si vous voulez ne dessiner qu'une partie d'une image, utiliser la méthode clipRect (). Voir aussi le chapitre sur les images. 

public abstract void dispose ()

Permet de détruire le contexte graphique. Une fois détruit, le contexte graphique n'est plus utilisable et la translation et la zone de clipping éventuellement actives sur ce contexte graphique sont annulées. 

public void finalize ()

Détruit le contexte graphique (appel de dispose ()). Cette méthode outrepasse celle de la classe Object. 

public String toString ()

Renvoie une chaîne de caractère représentant le contexte graphique. Cette méthode outrepasse celle de la classe Object.

 

!

Les méthodes de dessin (comme drawRect (), drawOval ()) prenant en paramètre une largeur et une hauteur (width et height), n'acceptent que des valeurs positives pour ces paramètres.

 

Voici l'applet DrawIt, vous permettant de dessiner interactivement des formes en désignant un rectangle englobant avec la souris. Les boutons radios à droite vous permettent de choisir le type de dessin que vous voulez réaliser. Cette applet permet de tester le mode XOR, la plupart des méthodes de dessins de la classe Graphics et l'utilisation des méthodes mouseDown (), mouseDrag () et mouseUp () de la classe Component :

Applet DrawIt

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

import java.applet.Applet;
import java.awt.*;
import java.util.Random;
 
public class DrawIt extends Applet
{
  private CheckboxGroup choixDessin = new CheckboxGroup ();
  private Panel         zoneDessin  = new DrawItComponent (choixDessin);
 
  public void init ()
  {
    // Choix d'un layout BorderLayout (FlowLayout par défaut)
    setLayout (new BorderLayout ());
    // Création de boutons radios permettant de choisir
    // la fonction de dessin à utiliser
    Panel panel = new Panel ();
    panel.setLayout (new GridLayout (7, 1));
    panel.add (new Checkbox ("Ligne", choixDessin, true));
    panel.add (new Checkbox ("Rectangle", choixDessin, false));
    panel.add (new Checkbox ("Rectangle 3D", choixDessin, false));
    panel.add (new Checkbox ("Polygone", choixDessin, false));
    panel.add (new Checkbox ("Ovale", choixDessin, false));
    panel.add (new Checkbox ("Arc de cercle", choixDessin, false));
    panel.add (new Checkbox ("Texte", choixDessin, false));
    // Ajout à droite des boutons radios
    add ("East", panel);
    // Ajout au centre de la zone de saisie
    add ("Center", zoneDessin);
  }
}
 
// Classe DrawItComponent
class DrawItComponent extends Panel
{
  private int xDebut,  yDebut,
              xFin,    yFin;
  private CheckboxGroup choixDessin;
  private Color         couleurDessin;
  private int           angleDebut, angle;
  private String        typeDessin = "";
              
  // Constructeur
  DrawItComponent (CheckboxGroup choixDessin)
  {
    this.choixDessin = choixDessin;
  }
  
  // Méthodes mouseDown (), mouseDrag (), mouseUp ()
  // appelées à l'enfoncement du bouton de la souris,
  // au déplacement du pointeur, et au relâchement du bouton
  public boolean mouseDown (Event evt, int x, int y)
  {
    xDebut = x;
    yDebut = y;
    dessinerElastique (x , y);
    return true;
  }
 
  public boolean mouseDrag (Event evt, int x, int y)
  {
    // Effacement du rectangle aux anciennes coordonnées
    // puis dessin d'un nouveau rectangle aux coordonnées courantes
    dessinerElastique (xFin, yFin);
    dessinerElastique (x, y);
    return true;
  }
 
  public boolean mouseUp (Event evt, int x, int y)
  {
    // Effacement du dernier rectangle dessiné 
    dessinerElastique (xFin, yFin);
    // Récupération du type de dessin demandé, d'une couleur et deux angles
    // et redessin du composant
    typeDessin = choixDessin.getCurrent ().getLabel ();
    Random generateur = new Random ();
    couleurDessin = new Color (generateur.nextFloat (),
                               generateur.nextFloat (),
                               generateur.nextFloat ());
    angleDebut = generateur.nextInt () % 360;
    angle      = generateur.nextInt () % 360;
    repaint ();
    return true;
  }
 
  // Méthode dessinerElastique () : mémorise les coordonnées
  // courantes, puis trace un rectangle en mode XOR
  private void dessinerElastique (int xFin, int yFin)
  {
    this.xFin = xFin;
    this.yFin = yFin;
    Graphics gc = getGraphics ();
    gc.setXORMode (getBackground ());
    gc.drawRect (Math.min (xDebut, xFin), Math.min (yDebut, yFin),
                  Math.abs (xFin - xDebut), Math.abs (yFin - yDebut));
  }
  
  // Méthode appelée à la mise à jour du composant
  public void paint (Graphics gc)
  {
    // Sélection de la couleur
    gc.setColor (couleurDessin);
    // Appel de la méthode de dessin suivant le type de dessin choisi
    int x = Math.min (xDebut, xFin);
    int y =  Math.min (yDebut, yFin);
    int largeur = Math.abs (xFin - xDebut);
    int hauteur = Math.abs (yFin - yDebut);
    if (typeDessin.equals ("Ligne"))
      gc.drawLine (x, y, x + largeur, y + hauteur);
    else if (typeDessin.equals ("Rectangle"))
      gc.fillRect (x, y, largeur, hauteur);
    else if (typeDessin.equals ("Rectangle 3D"))
      gc.fill3DRect (x, y, largeur, hauteur, true);
    else if (typeDessin.equals ("Polygone"))
    {
      int xPoints [ ] = {x, x , x  + largeur, x + largeur};
      int yPoints [ ] = {y, y + hauteur, y, y + hauteur};
      gc.fillPolygon (xPoints, yPoints, xPoints.length);
    }
    else if (typeDessin.equals ("Ovale"))
      gc.fillOval (x, y, largeur, hauteur);
    else if (typeDessin.equals ("Arc de cercle"))
    {
      gc.drawOval (x, y, largeur, hauteur);
      gc.fillArc (x, y, largeur, hauteur, angleDebut, angle);
    }
    else if (typeDessin.equals ("Texte"))
    {
      gc.setFont (new Font ("Helvetica", Font.PLAIN, hauteur));
      FontMetrics tailles = gc.getFontMetrics ();
      gc.drawString ("Texte", x, y + tailles.getAscent ()
                                     + tailles.getLeading ());
    }
  }
}
 
Autres exemples

Les applets Chrono, EchoClient, PaperBoardClient, ListePolices et ScrollText sont des exemples d'utilisation de la méthode drawString ().
Les applets AfficheurDeCalcul, ObservateurCalcul, PaperBoardClient, Piano, ListePolices et Horloge sont des exemples de tracés de lignes et de polygones.
Les applets BoutonsNavigation, MultiImages, ImageSimple, ChargementImage, ImageTableau, ImageNoirEtBlanc, NegatifImage, AnimationFleche et Horloge sont des exemples d'utilisation de la méthode drawImage ().

 

Le package java.awt définit aussi un ensemble de classes utiles pour la classe Graphics décrites ci-après, qui permettent de manipuler les polices de caractères, les couleurs et les objets représentant des dimensions (point, rectangle, polygone,...) :

Les polices de caractères

La classe java.awt.Font

Cette classe permet de manipuler les polices de caractères. Une police de caractères se caractérise par un nom, un style (normal, gras, italique) et une taille exprimée en points (voir aussi la classe FontMetrics).

!

Toutes les polices de caractères du système ne sont pas disponibles en Java. Vous pouvez en obtenir la liste (généralement, Courier, TimesRoman et Helvetica) grâce à la méthode getFontList () de la classe Toolkit, utilisé dans l'applet ListePolices.

Champs
public final static int PLAIN
public final static int BOLD
public final static int ITALIC

Ces constantes permettent de spécifier le style de la police de caractères à sa création (normal, gras ou italique). Il est possible de combiner les styles avec l'opérateur | (par exemple, Font.BOLD | Font.ITALIC). 

protected String name
protected int style
protected int size

Ces champs protected permettent d'accéder aux caractéristiques d'une police de caractères, dans les classes dérivées de Font.

Constructeur
public Font (String name, int style, int size)

Construit une police de caractères de nom name, de style style et de taille size.

Méthodes
public String getName ()
public int getStyle ()
public int getSize ()

Ces méthodes permettent d'interroger le nom, le style et la taille d'une police de caractères`. 

public boolean isPlain ()
public boolean isBold ()
public boolean isItalic ()

Ces méthodes renvoient true si une police de caractères a un style normal, gras ou italique. 

public String getFamily ()

Renvoie le nom de la famille à laquelle appartient une police de caractères. La famille d'une police dépend du système sur lequel fonctionne la Machine Virtuelle Java, tandis que le nom d'une police est un nom logique qui est toujours le même quelque soit le système pour rendre un programme Java portable. 

public static Font getFont (String prop)
public static Font getFont (String prop, Font font)

Ces méthodes renvoient la police de caractère mémorisée par la propriété prop du système (voir la classe System). Si cette propriété n'existe pas, la seconde méthode renvoie la valeur par défaut font. 

public int hashCode ()
public boolean equals (Object obj)
public String toString ()

Ces méthodes outrepassent celles de la classe Object, pour renvoyer un code de hash, comparer une police de caractères à un objet ou renvoyer une chaîne de caractères décrivant une police.

Exemples

Applets DrawIt, ListePolices. et ScrollText.

La classe java.awt.FontMetrics

Cette classe décrit les différentes tailles (hauteurs par rapport à la ligne de base, largeurs diverses) d'une police de caractères (de classe Font).

Champ
protected Font font

Mémorise la police de caractères décrite.

Constructeur
protected FontMetrics (Font font)

Ce constructeur est protected ce qui empêche de créer directement une instance de la classe FontMetrics. Les méthodes getFontMetrics () des classes Graphics et Toolkit vous permettent d'interroger les tailles d'une police de caractères.

Méthodes
public Font getFont ()

Renvoie la police de caractères décrite par une instance de la classe FontMetrics. 

public int getHeight ()
public int getLeading ()
public int getAscent ()
public int getDescent ()

Ces méthodes revoient la hauteur, l'interligne, la hauteur au-dessus de la ligne de base et le jambage d'une police de caractères. La hauteur, différente de la taille de la police donnée à sa création, est égale à la somme des trois autres dimensions. 

public int getMaxAscent ()
public int getMaxDescent ()

Ces méthodes revoient la hauteur maximum au-dessus de la ligne de base et le jambage maximum de tous les caractères d'une police. 

public int getMaxAdvance ()

Renvoie la largeur du plus large des caractères d'une police. 

public int charWidth (int ch)
public int charWidth (char ch)

Ces méthodes renvoient la largeur du caractère ch d'une police. 

public int stringWidth (String str)
public int charsWidth (char data [ ], int offset, int length)
public int bytesWidth (byte data [ ], int offset, int length)

Ces méthodes renvoient la largeur d'une chaîne de caractères. La chaîne de caractères peut être donnée soit par une instance de String, soit par les length premiers caractères à partir de l'indice offset du tableau data. 

public int [ ] getWidths ()

Renvoie un tableau décrivant la taille des 256 premiers caractères d'une police. 

public String toString ()

Cette méthode outrepasse la méthode toString () de la classe Object, pour renvoyer une chaîne de caractères décrivant les principales tailles d'une police de caractères.

L'applet suivante décrit la liste de l'ensemble des polices de caractères disponibles avec Java. Cliquez sur un élément de la liste ou saisissez une taille de police de caractères dans le champ Size, pour afficher un exemple de texte et les caractéristiques de la police choisie :

Applet ListePolices

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

import java.awt.*;
import java.applet.*;
 
public class ListePolices extends Applet
{
  AfficheurTexte  exemple   = new AfficheurTexte ();
  List      listePolices    = new List ();
  TextField taillePolice    = new TextField ("24");
  Label     labelHeight     = new Label ();
  Label     labelLeading    = new Label ();
  Label     labelAscent     = new Label ();
  Label     labelDescent    = new Label ();
  Label     labelMaxAdvance = new Label ();
 
  public void init ()
  {
    // Choix d'un layout BorderLayout (FlowLayout par défaut)
    setLayout (new BorderLayout (5, 0));
    
    // Création d'un panel contenant la liste des polices
    // et la zone de saisie de la taille
    Panel panelSaisie = new Panel ();
    panelSaisie.setLayout (new BorderLayout ());
    
    // Récupération de la liste des polices disponibles
    String [ ] ensemblePolices = getToolkit ().getFontList ();
    for (int i = 0; i < ensemblePolices.length; i++)
      listePolices.addItem (ensemblePolices [i]);
 
    panelSaisie.add ("Center", listePolices);
    Panel panelTaille = new Panel ();
 
    panelTaille.add (new Label ("Size :"));
    panelTaille.add (taillePolice);
    panelSaisie.add ("South", panelTaille);    
    // Ajout du panel de saisie
    add ("West", panelSaisie);
    
    // Ajout du composant affichant une chaîne d'exemple
    add ("Center", exemple);
    
    // Création d'un panel utilisant un layout de grille
    // et affichant un ensemble de labels qui permettent
    // de décrire les caractéristiques de la police sélectionnée
    Panel panelResultat = new Panel ();
    panelResultat.setLayout (new GridLayout (5, 2));
    panelResultat.add (new Label ("Height :"));
    panelResultat.add (labelHeight);
    panelResultat.add (new Label ("Leading :"));
    panelResultat.add (labelLeading);
    panelResultat.add (new Label ("Ascent :"));
    panelResultat.add (labelAscent);
    panelResultat.add (new Label ("Descent :"));
    panelResultat.add (labelDescent);
    panelResultat.add (new Label ("MaxAdvance :"));
    panelResultat.add (labelMaxAdvance);
    // Ajout du panel de résultat
    add ("East", panelResultat);
  }
  
  // Gestion des événements sur la liste et la zone de saisie
  public boolean handleEvent (Event event)
  {
    // Si un événement de sélection de la liste ou un
    // événement de changement de texte survient,
    // mise à jour des labels décrivant la police et de l'exemple
    if (   event.id == Event.LIST_SELECT
        || (   event.id == Event.ACTION_EVENT
            && event.target == taillePolice))
    {
      Font police = new Font (listePolices.getSelectedItem (),
                              Font.PLAIN,
                              Integer.parseInt (taillePolice.getText ()));
      FontMetrics metrics = getToolkit ().getFontMetrics (police);
 
      labelHeight.setText (String.valueOf (metrics.getHeight ()));
      labelLeading.setText (String.valueOf (metrics.getLeading ()));
      labelAscent.setText (String.valueOf (metrics.getAscent ()));
      labelDescent.setText (String.valueOf (metrics.getDescent ()));
      labelMaxAdvance.setText (String.valueOf (metrics.getMaxAdvance ()));
      exemple.modifierTexte (police, "Bonjour");
      return true;
    }
    return super.handleEvent (event);
  }
}
 
// Classe AfficheurTexte affiche un texte avec une police de caractères
class AfficheurTexte extends Panel
{
  Font   police;
  String texte;
   
  // La méthode modifierTexte () permet de modifier
  // la police de caractères et le texte du composant
  public void modifierTexte (Font police, String texte)
  {
    this.police = police;
    this.texte  = texte;
    repaint ();
  }
 
  public void paint (Graphics gc)
  {
    if (texte != null)
    {
      // Dessin d'un cadre autour du composant
      gc.drawRect (0, 0, size ().width - 1, size ().height - 1);
      
      // Dessin des rectangles représentant les tailles
      FontMetrics metrics = gc.getFontMetrics (police);
      int   y = (size ().height - metrics.getHeight ()) / 2;
      int   largeurTexte = metrics.stringWidth (texte);
      gc.setColor (Color.blue.darker ());
      gc.drawRect (5, y, largeurTexte, metrics.getHeight ());
      gc.drawRect (5, y + metrics.getLeading (), largeurTexte,
                                       metrics.getAscent ());
                   
      // Dessin du texte dans les rectangles
      gc.setColor (Color.black);
      gc.setFont (police);
      gc.drawString (texte, 5, y + metrics.getAscent ()
                                   + metrics.getLeading ());
    }
  }
}
Autres exemples

Applets DrawIt et ScrollText.

La couleur

La classe java.awt.Color

Cette classe permet de manipuler une couleur. Elle déclare un ensemble de constantes décrivant les couleurs les plus communément utilisées. Ses constructeurs permettent de créer des couleurs à partir de leurs composantes RGB (Red Green Blue : Rouge Vert Bleu), mais les méthodes brighter () et darker () sont aussi très pratiques pour créer des couleurs plus claire ou plus foncée à partir d'une couleur existante.

Champs
public final static Color white
public final static Color lightGray
public final static Color gray
public final static Color darkGray
public final static Color black
public final static Color red
public final static Color pink
public final static Color orange
public final static Color yellow
public final static Color green
public final static Color magenta
public final static Color cyan
public final static Color blue

Ces constantes permettent de récupérer directement des couleurs prédéfinies (blanc, gris clair, gris, gris foncé, noir, rouge, rose, orange, jaune, vert, magenta, cyan et bleu).

Constructeurs
public Color (int r, int g, int b)

Construit une couleur à partir de ses composantes entières rouge r, vert g et bleu b comprises entre 0 et 255. 

public Color (int rgb)

Construit une couleur à partir de l'entier rgb combinaison des composantes rouge (bits 16 à 23), vert (bits 8 à 15) et bleu (bits 0 à 7). 

public Color (float r, float g, float b)

Construit une couleur à partir de ses composantes décimales rouge r, vert g et bleu b comprises entre 0.0 et 1.0.

Méthodes
public int getRed ()
public int getGreen ()
public int getBlue ()

Ces méthodes renvoient les composantes rouge, vert ou bleu d'une couleur comprises entre 0 et 255. 

public int getRGB ()

Renvoie un entier combinaison des composantes rouge (bits 16 à 23), vert (bits 8 à 15) et bleu (bits 0 à 7) d'une couleur. 

public Color brighter ()
public Color darker ()

Ces méthodes renvoient une couleur plus claire ou plus foncée d'une couleur. 

public static Color getColor (String name)
public static Color getColor (String name, Color v)
public static Color getColor (String name, int v)
 
public static int HSBtoRGB (float hue, float saturation,
                              float brightness)

Renvoie un entier combinaison des composantes rouge, vert et bleu d'une couleur exprimée par sa teinte hue, sa saturation saturation et sa luminosité brightness comprises entre 0.0 et 1.0. 

public static float [ ] RGBtoHSB (int r, int g, int b,
                                    float hsbvals [ ])

Renvoie un tableau décrivant la teinte, la saturation et la luminosité (aux indices 0, 1 et 2) d'une couleur à partir de ses composantes rouge, vert et bleu comprises entre 0 et 255. Les valeurs sont stockées dans hsbvals s'il est différent de null, sinon un nouveau tableau est créé. 

public static Color getHSBColor (float hue, float saturation,
                                    float brightness)

Crée une couleur à partir de sa teinte hue, sa saturation saturation et sa luminosité brightness comprises entre 0.0 et 1.0. 

public int hashCode ()
public boolean equals (Object obj)
public String toString ()

Ces méthodes outrepassent celles de la classe Object, pour renvoyer un code de hash, comparer une une couleur à un objet ou renvoyer une chaîne de caractères décrivant la couleur.

L'applet suivante dessine un nuancier. Les couleurs utilisent le mode HSB (Teinte, Saturation, Luminosité) pour avoir plus simplement les couleurs de toute la palette à partir d'une teinte. Quand vous cliquez sur une couleur, le label en dessous du nuancier indique la couleur choisie. Cette applet vous permet de tester la palette des couleurs disponibles sur une Machine Virtuelle :

Applet Nuancier

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

import java.awt.*;
import java.applet.*;
 
public class Nuancier extends Applet
{
  // Label bidon utilisé pour afficher en couleur de fond la couleur choisie
  Label labelColorise = new Label ("   ");
  Label labelCouleur  = new Label ("Cliquez sur une couleur...");
 
  public void init ()
  {
    // Choix d'un layout BorderLayout (FlowLayout par défaut)
    setLayout (new BorderLayout ());
    // Ajout d'un composant affichant le nuancier
    add ("Center", new ComposantNuancier ());
    
    // Création et ajout d'un panel de deux labels d'information
    Panel panelInfo = new Panel ();
    panelInfo.setLayout (new BorderLayout (5, 0));
    panelInfo.add ("West", labelColorise);
    panelInfo.add ("Center", labelCouleur);
    add ("South", panelInfo);
  }
 
  public boolean action (Event event, Object arg)
  { 
    // Si une action est reçue du composant nuancier
    // modifier la couleur de fond du label sans texte
    // et afficher les composantes RGB de la couleur choisie
    if (event.target instanceof ComposantNuancier)
    {
      Color couleur = (Color)arg;
      labelColorise.setBackground (couleur);
      labelColorise.repaint ();
      labelCouleur.setText ("Couleur : Rouge " + couleur.getRed ()
                                   + ", Vert "  + couleur.getGreen ()
                                   + ", Bleu "  + couleur.getBlue ());
    }
 
    return true;
  }
}
 
// Classe ComposantNuancier
class ComposantNuancier extends Panel
{
  private static final int TAILLE = 40;
  private Rectangle [ ] carreaux  = new Rectangle [TAILLE * TAILLE];
  private Color     [ ] couleurCarreaux = new Color [TAILLE * TAILLE];
 
  // Constructeur : crée l'ensemble des couleurs des carreaux
  ComposantNuancier ()
  {
    for (int i = 0; i < TAILLE; i++)
    {      
      // Première boucle réalisant un fondu du noir vers la teinte (moitié supérieure)
      int j;
      for (j = 0; j < TAILLE / 2; j++)
        couleurCarreaux [i * TAILLE + j] =
            Color.getHSBColor ((float)i / TAILLE,                    // Teinte
                                 1,                                    // Saturation
                                 (float)j / TAILLE * 2);               // Luminosité
      
      // Seconde boucle diminuant la saturation de la couleur (moitié inférieure)
      for ( ; j < TAILLE; j++)
        couleurCarreaux [i * TAILLE + j] =
            Color.getHSBColor ((float)i / TAILLE,                    // Teinte
                                 (float)(TAILLE - 1 - j) / TAILLE * 2, // Saturation
                                 1);                                   // Luminosité
    }
  }
  
  // Méthode appelée quand le composant change de taille
  public void reshape (int x, int y, int width, int height)
  {
    super.reshape (x, y, width, height);
    // Calcul de la largeur et de la hauteur des carreaux
    int largeur = size ().width  / TAILLE;
    int hauteur = size ().height / TAILLE;
    // Création des rectangles représentant les carreaux de couleur
    for (int i = 0; i < TAILLE; i++)
      for (int j = 0; j < TAILLE; j++)
        carreaux [i * TAILLE + j] =
            new Rectangle (largeur * i, hauteur * j, largeur, hauteur);
  }
 
  public void paint (Graphics gc)
  {
    for (int i = 0; i < carreaux.length; i++)
    {
      // Sélection d'une couleur et dessin du carreau
      gc.setColor (couleurCarreaux [i]);
      gc.fillRect (carreaux [i].x, carreaux [i].y,
                    carreaux [i].width, carreaux [i].height);
    }
  }
 
  public boolean mouseDown (Event evt, int x, int y)
  {
    // Recherche du carreau dans lequel l'utilisateur à cliquer
    // et envoi d'un événement d'action
    for (int i = 0; i < carreaux.length; i++)
      if (carreaux [i].inside (x, y))
        postEvent (new Event (this, Event.ACTION_EVENT, couleurCarreaux [i]));
    return true;
  }
}
Autres exemples

Applets ObservateurCalcul, DrawIt, ListePolices, MultiImages et ScrollText.

Les classes manipulant des dimensions

La classe java.awt.Dimension

Cette classe permet de manipuler les dimensions d'un objet (largeur et hauteur) grâce à ses deux champs public width et height.

Champs
public int width
public int height
Constructeurs
public Dimension ()
public Dimension (Dimension d)
public Dimension (int width, int height)
Méthode
public String toString ()

Cette méthode outrepasse la méthode toString () de la classe Object, pour renvoyer une chaîne de caractères décrivant les dimensions.

Exemples

Applets BoutonsNavigation, MultiImages, ImageTableau, ImageNoirEtBlanc, ScrollText et Horloge.

La classe java.awt.Insets

Cette classe qui implémente l'interface Cloneable, permet de manipuler les bordures d'un container, qui délimitent une zone dans laquelle il n'est pas possible de dessiner.

Champs
public int top
public int left
public int bottom
public int right

Ces champs public désignent les bordures en haut, à gauche, en bas et à droite.

Constructeur
public Insets (int top, int left, int bottom, int right)
Méthodes
public String toString ()
public Object clone ()

Ces méthodes outrepassent celles de la classe Object, pour renvoyer une chaîne de caractères décrivant les valeurs des bordures ou un clone d'une instance de la classe Insets.

La classe java.awt.Point

Cette classe permet de manipuler des points de coordonnées (x,y).

Champs
public int x
public int y
Constructeur
public Point (int x, int y)
Méthodes
public void move (int x, int y)

Déplace le point en (x,y). 

public void translate (int x, int y)

Effectue une translation (x,y) sur un point. 

public int hashCode ()
public boolean equals (Object obj)
public String toString ()

Ces méthodes outrepassent celles de la classe Object, pour renvoyer un code de hash, comparer un point à un objet ou renvoyer une chaîne de caractères décrivant le point.

La classe java.awt.Polygon

Cette classe permet de manipuler des polygones, ensemble de npoints points dont les coordonnées sont enregistrées dans les tableaux xpoints et ypoints.

Champs
public int npoints
public int xpoints [ ]
public int ypoints [ ]
Constructeurs
public Polygon ()
public Polygon (int xpoints [ ], int ypoints [ ], int npoints)
Méthodes
public void addPoint (int x, int y)

Ajoute le point de coordonnées (x,y) à la fin de l'ensemble des points. 

public Rectangle getBoundingBox ()

Renvoie le rectangle englobant tous les points du polygone. 

public boolean inside (int x, int y)

Renvoie true si le point de coordonnées (x,y) est à l'intérieur du polygone.

Exemple

AppletPaperBoardClient.

La classe java.awt.Rectangle

Cette classe permet de manipuler des rectangles, mémorisés sous forme d'un point origine de coordonnées (x,y) représentant le coin supérieur gauche, de sa largeur width et de sa hauteur height.

Champs
public int x
public int y
public int width
public int height
Constructeurs
public Rectangle ()
public Rectangle (int x, int y, int width, int height)
public Rectangle (int width, int height)
public Rectangle (Point p, Dimension d)
public Rectangle (Point p)
public Rectangle (Dimension d)
Méthodes
public void reshape (int x, int y, int width, int height)

Permet de changer l'origine, la largeur et la hauteur d'un rectangle. 

public void move (int x, int y)

Déplace l'origine du rectangle en (x,y). 

public void translate (int x, int y)

Effectue une translation (x,y) sur l'origine du rectangle. 

public void resize (int width, int height)

Modifie la largeur et la hauteur d'un rectangle. 

public boolean inside (int x, int y)

Renvoie true si le point de coordonnées (x,y) est à l'intérieur d'un rectangle. 

public boolean intersects (Rectangle r)

Renvoie true si le rectangle r et le rectangle sur lequel la méthode est invoquée ont une intersection. 

public Rectangle intersection (Rectangle r)
public Rectangle union (Rectangle r)

Ces méthodes renvoie un rectangle résultat de l'intersection ou de l'union entre deux rectangles. 

public void add (int newx, int newy)
public void add (Point pt)

Ces méthodes ajoutent un point à un rectangle qui est agrandit si nécessaire pour contenir le point passé en paramètre. 

public void add (Rectangle r)

Ajoute le rectangle r au rectangle sur lequel la méthode est invoquée. Le résultat est l'union des deux rectangles. 

public void grow (int horiz, int vert)

Agrandit un rectangle de horiz points à gauche et à droite, et de vert points en haut et en bas. 

public boolean isEmpty ()

Renvoie true si la largeur ou la hauteur d'un rectangle est négative ou nulle. 

public int hashCode ()
public boolean equals (Object obj)
public String toString ()

Ces méthodes outrepassent celles de la classe Object, pour renvoyer un code de hash, comparer un rectangle à un objet ou renvoyer une chaîne de caractères décrivant le rectangle.

La création de nouveaux composants

Dans les trois exemples précédents, les classes DrawItComponent, AfficheurTexte et ComposantNuancier dérivent de la classe Panel. Bien que ces applets fonctionnent correctement, Panel est une classe de container donc prévue pour contenir d'autres composants.
Pour créer de nouveaux composants, il est plutôt recommandé de dériver de nouvelles classes à partir de la classe Canvas.

La classe java.awt.Canvas

Cette classe qui dérive de la classe Component, est la classe du package java.awt dont vous devez dériver pour créer vos propres classes de composants.

Constructeur
public Canvas ()
Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'une instance de Canvas. 

public void paint (Graphics gc)

Cette méthode outrepasse la méthode paint () de la classe Component, pour remplir le composant de la couleur de fond.


L'applet suivante utilise une nouvelle classe de composant BoutonImage. Ce composant est un bouton utilisant deux images de même taille, pour représenter l'état relâché et l'état enfoncé du bouton :

Applet BoutonsNavigation

Le programme Java correspondant a été divisé en deux fichiers. Comme la classe BoutonImage (à copier dans un fichier dénommé BoutonImage.java) peut être appelée à être réutilisée, elle est rangée dans un package tools : 

// Les classes de ce fichier appartiennent au package tools
package tools;
 
import java.awt.*;
import java.net.*;
 
public class BoutonImage extends Canvas
{
  private boolean boutonEnfonce       = false;
  private boolean boutonSourisEnfonce = false;
 
  private Object  argAction;
  private Image   imageRelache;
  private Image   imageEnfonce;
  
  // Constructeur
  public BoutonImage (Object argAction, URL urlImageRelache,
                                          URL urlImageEnfonce)
  {
    try
    {
      this.argAction = argAction;
      // Création des images enfoncé/relâché du bouton
      imageRelache = getToolkit ().getImage (urlImageRelache);
      imageEnfonce = getToolkit ().getImage (urlImageEnfonce);
      // Création d'un MediaTracker pour charger les images
      // afin que leur taille soit disponible pour le layout
      MediaTracker imageTracker = new MediaTracker (this);
      imageTracker.addImage (imageRelache, 0);
      imageTracker.addImage (imageEnfonce, 0);
      imageTracker.waitForAll ();
      // En cas d'erreur, déclenchement d'une exception
      if (imageTracker.isErrorAny ())
        throw new IllegalArgumentException ("Images introuvables");
    }
    catch (InterruptedException e)
    { }
  }
  
  // Il est conseillé d'outrepasser les méthodes preferredSize ()
  // et minimumSize () pour que les layouts utilisant ces méthodes
  // puissent dimensionner ce composant correctement
  public Dimension preferredSize ()
  {
    return new Dimension (imageRelache.getWidth (this),
                          imageRelache.getHeight (this));
  }
 
  public Dimension minimumSize ()
  {
    return preferredSize ();
  }
 
  // La méthode paint () dessine l'image suivant l'état du bouton
  public void paint (Graphics gc)
  {
    if (boutonEnfonce)
      gc.drawImage (imageEnfonce, 0, 0, this);
    else
      gc.drawImage (imageRelache, 0, 0, this);
  }
 
  // Les méthodes mouseDown () et mouseUp () modifient l'image du
  // bouton à l'enfoncement/relâchement du bouton de la souris
  public boolean mouseDown (Event event, int x, int y)
  {
    modifierEnfoncementBouton (true);
    boutonSourisEnfonce = true;
    return true;
  }
 
  public boolean mouseUp (Event event, int x, int y)
  {
    boolean boutonEnfonce = this.boutonEnfonce;
    modifierEnfoncementBouton (false);
    boutonSourisEnfonce = false;
    // Si le bouton est resté enfoncé, envoi d'un événement d'action
    if (boutonEnfonce)
      postEvent (new Event (this, Event.ACTION_EVENT, argAction));
    return true;
  }
  
  // Les méthodes mouseEnter () et mouseExit () modifient
  // l'image du bouton si le bouton de la souris est enfoncé
  public boolean mouseEnter (Event event, int x, int y)
  {
    if (boutonSourisEnfonce)
      modifierEnfoncementBouton (true);
    return true;
  }
 
  public boolean mouseExit (Event event, int x, int y)
  {
    if (boutonSourisEnfonce)
      modifierEnfoncementBouton (false);
    return true;
  }
 
  private void modifierEnfoncementBouton (boolean nouvelEtat)
  {
    // Si l'état enfoncé/relâché du bouton a changé
    // mettre à jour le dessin du bouton
    if (boutonEnfonce != nouvelEtat)
    {
      boutonEnfonce = nouvelEtat;
      paint (getGraphics ());
    }
  }
}

L'autre fichier décrit l'applet (à copier dans un fichier dénommé BoutonsNavigation.java et invoqué à partir d'un fichier HTML) : 

import java.applet.Applet;
import java.awt.*;
import java.net.*;
// Importation de la classe BoutonImage du package tools
import tools.BoutonImage;
 
public class BoutonsNavigation extends Applet
{
  public void init ()
  {
    try
    {
      // Création et ajout des deux boutons à l'applet
      add (new BoutonImage (new URL (getDocumentBase (), "awtlayouts10.html"),
                            new URL (getCodeBase (), "prevup.gif"),
                            new URL (getCodeBase (), "prevdown.gif")));
      add (new BoutonImage (new URL (getDocumentBase (), "image10.html"),
                            new URL (getCodeBase (), "nextup.gif"),
                            new URL (getCodeBase (), "nextdown.gif")));
    }
    catch (MalformedURLException e)
    { }
  } 
 
  // Les boutons de classe BoutonImage émettent des événements ACTION_EVENT
  public boolean action (Event evt, Object arg)
  {
    // Chargement d'un document HTML suivant le bouton enfoncé
    if (arg instanceof URL)
      getAppletContext ().showDocument ((URL)arg);
 
    return true;
  }
}

En récupérant les valeurs de paramètres utilisant la balise PARAM, cette applet pourrait être généralisée pour qu'elle configure les images et les actions des boutons, sans avoir à modifier son code source à chaque utilisation différente dans un fichier HTML.

Page d'accueilFindIt !ContactLes containers et la disposition des composantsLes imagesDébut de la page
© Copyrights 1997-2023 Emmanuel PUYBARET / eTeks
- Tous droits réservés -
Table des matièresHiérarchie des classes