Java permet de dessiner des formes géométriques en 2D
sur une surface telle qu’un JPanel ou une JFrame.
Pour tracer une forme, il faut obtenir le contexte graphique du support :
Graphics g = maFenetre.getGraphics();
Ou bien
Graphics g = monJPanel.getGraphics();
Vous ne pouvez pas créer un objet Graphics vous-même.
Graphics g = new Graphics();
Vous devez le demander au support sur lequel vous voulez dessiner.
Différents supports sont susceptibles de fournir un contexte graphique :
La plupart des composants disposant d’un contexte graphique disposent d’une méthode Paint(Graphics g),
qu’ils appellent spontanément lorsqu’ils doivent se repeindre.
Par exemple, lorsqu’ils ont été recouverts par une autre fenêtre et sont découverts, ce qui laisse un blanc.
Lorsque vous élaborez un composant graphique,
vous lui surchargerez généralement sa méthode Paint. (@Overrride)
Le programmeur peut invoquer cette instruction pour forcer un composant à se repeindre, par exemple,
lorsqu’une de ses variables a été modifiée, et qu’il faut en actualiser l’affichage.
Il ne faut jamais appeler la méthode Paint du composant,
ce qui serait par ailleurs impossible puisque nous ne disposons pas de contexte Graphics g passé en paramètre.
Lorsqu’un composant reçoit un ordre repaint(), il déclenche lui-même sa méthode Paint (Graphics g)
Toutes ces instructions sont des méthodes de l’objet Graphics
Dessine une ligne qui relie le point (x1, y1) au point (x2, y2)
Dessine un rectangle dont le coin supérieur gauche est en (Haut, Gauche).
Sa largeur sera de Largeur
Sa hauteur sera de Hauteur.
Dessine une ellipse incluse dans le rectangle qui aurait été tracé avec drawRect
Si Largeur == Hauteur, alors l’ellipse est un cercle.
Dessine une portion d’ellipse de mêmes paramètres que la précédente,
qui commence à Début, et d’une amplitude de Amplitude exprimés en degrés.
Les angles sont exprimés en degrés, conformément aux conventions trigonométriques :
fillRect, fillOval et fillArc fonctionnent comme les trois précédentes.
Cependant, les figures sont dessinées pleines.
Affiche une chaîne de caractères
Les coordonnées (x, y) définissent le coin inférieur gauche
de la première lettre de la chaîne.
Modifie la couleur courante
g.setColor (Color.red);
A partir de cette instruction, les figures seront dessinées en rouge
g.setColor (new Color (r, g, b);
On peut définir soi-même les composantes Red, Green et Blue de la nouvelle couleur.
(Entre 0 et 255)
En principe, une figure écrase celle dessinée précédemment.
Le mode XOR permet d’effectuer un ou exclusif bit à bit entre les deux figures
L’intersection entre les deux figures reste encore visible.
Elle prend une couleur intermédiaire.
Annule le mode XOR et revient au mode où une nouvelle figure
écrase l’ancienne en-dessous.
Il s’agit d’une des plus puissantes instructions graphiques de Java.
Elle dessine une image directement là où l’utilisateur le souhaite.
Mais une image contient elle-même un contexte graphique,
sur lequel on peut dessiner des formes géométriques.
Elle peut également provenir d’un fichier ou d’une adresse web (URL)
L’image permet donc de faire du double-buffering,
c’est à dire de pré-dessiner un graphisme hors de la vue de l’utilisateur,
pour l’afficher ensuite lorsqu’il sera terminé.
Pour gérer une animation en Java,
on commence par dessiner un rectangle plein (fillRect) sur toute la surface du composant.
Ensuite, on dessine les différentes formes graphiques, en fonction de variables qu’il faut calculer pendant le dessin.
Sitôt le dessin terminé, on redessine un rectangle plein écraseur,
puis recommence le dessin selon les nouvelles variables.
L’utilisateur n’a donc pas le temps de voir le dessin terminé, qu’il est déjà écrasé.
Même s’il reste affiché quelques (milli)secondes, le temps écoulé
entre le rectangle écraseur et la fin du dessin provoque un scintillement très désagréable pour l’utilisateur.
C’est pourquoi on utilise généralement une image de double-buffering.
Le temps d’affichage de l’image est dérisoire à côté du temps de construction des composantes graphiques,
qui nécessitent un temps de calcul.
En outre, le double buffering permet d’éviter le scintillement, puisque l’image n’est affichée qu’une fois terminée.
La phase noire n’est plus révélée à l’écran.
Les coordonnées sont comptées à partir
du coin supérieur gauche du support :
Pour illustrer le double-buffering, nous avons construit une petite animation motorisée par un thread.
L’objectif n’est pas de voir les threads ici, mais d’en utiliser un comme moteur.
Retenons donc tout simplement qu’un thread est un objet qui nous sert ici à :
Voici le code source de l’animation construite ce 28 janvier 2013
| La classe main, une seule ligne pour créer la fenêtre | Source |
| La fenêtre, le cadre d’exécution du programme | Source |
| Le JPanel animé avec son thread, le cœur du programme. | Source |