Comme vous avez pu le voir, l'objet Graphics permet, entre autres, de tracer des ronds... Mais cet objet possède tout un tas de méthodes plus pratiques et amusantes les unes que les autres...
Nous ne les verrons pas toutes mais vous aurez déjà de quoi faire...
Pour commencer, reprenons la méthode que j'ai utilisée précédemment :
g.fillOval(20, 20, 75, 75);.
Si nous avions à traduire cette instruction en français, ça donnerait :
"
Trace un rond plein en commençant à dessiner sur l'axe x à 20 pixels, sur l'axe y à 20 pixels, et fais en sorte que mon rond fasse 75 pixels de large et 75 pixels de haut."
C'est simple à comprendre, n'est-ce pas ?
Oui, mais si je veux que mon rond soit centré et qu'il y reste ?
C'est dans ce genre de cas qu'il est intéressant d'avoir une classe héritée !
Vu que nous sommes dans notre objet
JPanel, nous avons accès à ses données et j'ajouterais, pile au bon moment : lorsque nous allons le dessiner !
En effet, il y a des méthodes dans les objets composants qui nous retournent sa largeur (
getWidth()) et sa hauteur (
getHeight()) !
Par contre, réussir à centrer un rond dans un
JPanel en toute circonstance demande un peu de calcul mathématique de base, une pincée de connaissances et un soupçon de logique !
Reprenons notre fenêtre telle qu'elle est en ce moment. Vous pourrez constater que les coordonnées de départ ne correspondent pas au départ du cercle en lui-même, mais au point de départ du carré qui entoure ce cercle !
Ceci signifie que, si nous voulons que notre cercle soit centré à tout moment, il faut que notre carré soit centré et donc, que le centre de celui-ci corresponde au centre de notre fenêtre ! J'ai essayé de faire un schéma représentant ce que nous devons obtenir.
Ainsi, le principe est de prendre la largeur et la longueur de notre composant ainsi que la largeur et la longueur du carré qui englobe notre rond ! Facile, jusqu'à présent...
Maintenant, pour trouver où se situe le point où doit commencer le dessin, il faut prendre la moitié de la largeur de notre composant, moins la moitié de la largeur de notre rond, tout ceci pour l'axe x et y.
Pour que notre rond soit le plus optimisé, nous allons prendre pour taille de notre carré la moitié de notre fenêtre !
Donc, pour simplifier le tout, nous nous retrouvons à calculer la moitié de la moitié de la largeur et de la hauteur... Ce qui revient, au final, à diviser la largeur et la hauteur par 4...
Voici le code qui fait ceci :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 | import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
int x1 = this.getWidth()/4;
int y1 = this.getHeight()/4;
System.out.println("largeur = " + this.getWidth() + ", longueur = " + this.getHeight());
System.out.println(" coordonnée de début d'affichage x1 = " + x1 + " y1 = " + y1);
g.fillOval(x1, y1, this.getWidth()/2, this.getHeight()/2);
}
}
|
Ce qui nous donne :
Bon, l'objet
Graphics sait plein d'autres choses : peindre des ronds vides, par exemple.
Sans rire... Maintenant que vous avez vu un peu comment fonctionne cet objet, nous allons utiliser ses méthodes...
La méthode
drawOval(int x1, int y1, int width, int height)
Il s'agit de la méthode qui permet de dessiner un rond vide. Celle-ci fonctionne exactement de la même manière que la méthode
fillOval.
Voici un code mettant en oeuvre cette méthode :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13 | import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
int x1 = this.getWidth()/4;
int y1 = this.getHeight()/4;
g.drawOval(x1, y1, this.getWidth()/2, this.getHeight()/2);
}
}
|
Résultat :
Si vous spécifiez une largeur différente de la hauteur, ces méthodes dessineront une forme ovale !
La méthode
drawRect(int x1, int y1, int width, int height)
Cette méthode permet de dessiner des rectangles vides. Bien sûr, son homologue
fillRect existe. Ces deux méthodes fonctionnent aussi comme les précédentes, voyez plutôt ce code :
Code : Java 1
2
3
4
5
6
7
8
9
10
11 | import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
g.drawRect(10, 10, 50, 60);
g.fillRect(65, 65, 30, 40);
}
}
|
Et le résultat :
La méthode
drawRoundRect(int x1, int y1, int width, int height, int arcWidth, int arcHeight)
Il s'agit de la même chose que précédemment, mis à part que le rectangle sera arrondi. Arrondi défini par les valeurs passées dans les deux derniers paramètres.
Code : Java 1
2
3
4
5
6
7
8
9
10
11 | import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
g.drawRoundRect(10, 10, 30, 50, 10, 10);
g.fillRoundRect(55, 65, 55, 30, 5, 5);
}
}
|
Résultat :
La méthode
drawLine(int x1, int y1, int x2, int y2)
Celle-ci vous permet de tracer des lignes droites ! Il vous suffit de lui spécifier les coordonnées de départ et d'arrivée de la ligne... Simple aussi, n'est-ce pas ?
Dans ce code, je trace les diagonales de notre conteneur :
Code : Java 1
2
3
4
5
6
7
8
9
10
11 | import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
g.drawLine(0, 0, this.getWidth(), this.getHeight());
g.drawLine(0, this.getHeight(), this.getWidth(), 0);
}
}
|
Résultat :
La méthode
drawPolygon(int[] x, int[] y, int nbrePoints)
Avec cette méthode, vous pourrez dessiner des polygones de votre composition. Eh oui... C'est à vous de définir les coordonnées de tous les points qui forment votre polygone !
Le dernier paramètre de cette méthode est le nombre de points formant votre polygone. Ainsi, vous ne serez pas obligés de créer deux fois le point d'origine pour boucler votre figure. Java fermera celle-ci automatiquement en reliant le dernier point de votre tableau au premier...
Je vous conseille vivement de faire un schéma pour vous aider... Cette méthode a aussi son homologue pour dessiner les polygones remplis :
fillPolygon.
Code :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
int x[] = {20, 30, 50, 60, 60, 50, 30, 20};
int y[] = {30, 20, 20, 30, 50, 60, 60, 50};
g.drawPolygon(x, y, 8);
int x2[] = {50, 60, 80, 90, 90, 80, 60, 50};
int y2[] = {60, 50, 50, 60, 80, 90, 90, 80};
g.fillPolygon(x2, y2, 8);
}
}
|
Résultat :
Vous avez aussi une méthode qui prend exactement les mêmes arguments et qui, elle, trace plusieurs lignes ! Cette méthode s'appelle :
drawPolyline(int[] x, int[]y, int nbrePoints).
Cette méthode va dessiner les lignes correspondant aux coordonnées que vous lui passerez dans les tableaux, sachant que lorsque vous passez à l'indice supérieur dans vos tableaux, la méthode prend automatiquement les valeurs de l'indice précédent comme point d'origine.
Cette dernière ne fait pas le lien entre la première et la dernière valeur de vos tableaux... Vous pouvez essayer le code précédent, en remplaçant
drawPolygon par cette méthode et vous verrez...
La méthode
drawString(String str, int x, int y)
Voici la méthode qui vous permet d'écrire du texte... Elle est très simple à comprendre puisqu'il vous suffit de lui passer la phrase à écrire et de lui spécifier à quelles coordonnées commencer !
Code :
Code : Java 1
2
3
4
5
6
7
8
9
10
11 | import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
g.drawString("Tiens ! le Site du Zér0 ! ! !", 10, 20);
}
}
|
Résultat :
Vous pouvez modifier la couleur (et ça s'applique aussi pour les autres méthodes) et la police d'écriture... Pour redéfinir la police d'écriture, vous devez créer un objet
Font. Regardez comment faire :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
Font font = new Font("Courier", Font.BOLD, 20);
g.setFont(font);
g.setColor(Color.red);
g.drawString("Tiens ! le Site du Zér0 ! ! !", 10, 20);
}
}
|
Et le résultat :
La méthode
drawImage(Image img,int x, int y, Observer obs);
Ici, vous devrez charger votre image grâce à trois objets :
- un objet Image
- un objet ImageIO
- un objet File.
Vous allez voir que l'utilisation de ces objets est très simple... Nous déclarons un objet de type
Image, nous allons l'initialiser en utilisant une méthode statique de l'objet
ImageIO, qui, elle, prend un objet
File en paramètre. Ça paraît compliqué comme ça, mais vous allez voir...
Par contre, notre image sera stockée à la racine de notre projet !
Et en ce qui concerne le dernier paramètre de notre méthode
drawImage, il s'agit de l'objet qui est censé observer l'image. Ici, nous allons mettre notre objet
Panneau, donc
this.
Avec cette méthode, l'image sera dessinée avec ses propres dimensions... Si vous voulez que l'image prenne l'intégralité de votre container, il faut utiliser le constructeur suivant : drawImage(Image img, int x, int y, int width, int height, Observer obs).
Code :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | import java.awt.Graphics;
import java.awt.Image;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JPanel;
public class Panneau extends JPanel {
public void paintComponent(Graphics g){
try {
Image img = ImageIO.read(new File("images.jpg"));
g.drawImage(img, 0, 0, this);
//Pour une image de fond
//g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
|
Voici les résultats selon ce que vous avez choisi :
Maintenant, je pense qu'il est temps de vous présenter le petit cousin de notre objet
Graphics !
Une histoire de conteneur
marcel_07
Trouvez une formation
Suggestions
Twitter
Facebook
Google+