LECON 302


Une histoire de conteneur
Dans cette partie, nous allons aborder la notion de conteneur, et plus particulièrement le JPanel (pour l'instant...)
Vous verrez pas mal de choses qui vous seront très utiles plus tard, enfin j'espère.
Mais surtout, à la fin de cette partie, nous pourrons presque commencer à mettre des composants sur nos fenêtres...

Allez, je vous sens impatients...
Sommaire du chapitre :

  • Créez un conteneur pour votre fenêtre
  • L'objet Graphics
  • Plus loin dans le Graphics
  • Le cousin caché : l'objet Graphics2D
  • Ce qu'il faut retenir

Créez un conteneur pour votre fenêtre

Comme je vous l'ai dit auparavant, nous allons utiliser un JPanel, composant de type container, dont la vocation est d'accueillir d'autres objets de même type, ou des objets de type composant (bouton, case à cocher...).
Mais dans l'absolu, n'importe quel composant peut accueillir un autre composant ! Nous verrons ça...

Voici la marche à suivre


  • Nous allons importer la classe javax.swing.JPanel dans notre classe héritée de JFrame.
  • Nous allons instancier un JPanel, lui spécifier une couleur de fond pour pouvoir mieux le voir !
  • Dire à notre JFrame que ce sera notre JPanel qui sera son contentPane.

Rien de bien sorcier en somme. Qu'attendons-nous ?

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
import java.awt.Color;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame {
 
        public Fenetre(){
                
                this.setTitle("Ma première fenêtre java");
                this.setSize(400, 500);
                this.setLocationRelativeTo(null);               
 
                //Instanciation d'un objet JPanel
                JPanel pan = new JPanel();
                //Définition de sa couleur de fond
                pan.setBackground(Color.ORANGE);        
                //On prévient notre JFrame que ce sera notre JPanel qui sera son contentPane
                this.setContentPane(pan);
                
                this.setVisible(true);
        }       
}


Et voici le résultat :


C'est un bon début, mais je vois que vous êtes frustrés car il n'y a pas beaucoup de changement par rapport à la dernière fois...
Eh bien c'est maintenant que les choses deviennent intéressantes !
Avant de vous faire utiliser des composants comme des boutons ou autre chose, nous allons nous amuser avec notre panneau. Plus particulièrement avec un objet qui a pour rôle de dessiner et de peindre notre composant... Ça vous tente ? Alors, Go !

L'objet Graphics

Cet objet a une particularité de taille ! Vous ne pouvez l'utiliser que si, et seulement si le système vous l'a donné !
Et pour bien comprendre le mode de fonctionnement de vos futurs containers (ou composants), nous allons faire une classe héritée de JPanel : appelons-la Panneau ; nous allons faire petit tour d'horizon du fonctionnement de celle-ci !

Voici le code de cette classe :

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){
              //Vous pourrez voir cette phrase à chaque fois que la méthode est invoquée !
               System.out.println("Je suis exécutée ! ! !"); 
               g.fillOval(20, 20, 75, 75);
        }               
}

Hop là ! Qu'est-ce que c'est que cette méthode ?

Cette méthode est celle que l'objet appelle pour se peindre sur notre fenêtre, et si vous réduisez cette dernière et que vous l'affichez de nouveau, c'est encore cette méthode qui est appelée pour afficher notre composant ! Idem si vous redimensionnez votre fenêtre... En plus, on n'a même pas à redéfinir de constructeur, cette méthode est appelée automatiquement !

Pour personnaliser des composants, ceci est très pratique car vous n'aurez JAMAIS à l'appeler de vous-mêmes, ceci est automatique ! Tout ce que vous pourrez faire, c'est forcer l'objet à se repeindre, mais ce n'est pas cette méthode que vous invoquerez... Nous y reviendrons !

Vous aurez constaté que cette méthode possède un argument et qu'il s'agit du fameux objet Graphics tant convoité. Nous reviendrons sur l'instruction g.fillOval(20, 20, 75, 75); mais vous verrez ce qu'elle fait lorsque vous exécuterez votre programme...

Et maintenant, dans notre classe Fenetre :
Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
 
import java.awt.Color;
import java.awt.Graphics;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame {
 
        public Fenetre(){
                
                this.setTitle("Ma première fenêtre java");
                this.setSize(100, 150);
                this.setLocationRelativeTo(null);               
                this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                this.setContentPane(new Panneau());
                
                this.setVisible(true);
        }
        
}

J'ai réduit la taille de ma fenêtre car mes screenshots devenaient vraiment encombrants...

Exécutez votre main, et vous devriez avoir ceci :

Une fois votre fenêtre affichée, étirez-la, réduisez-la...
À présent, vous pouvez voir ce qu'il se passe lorsque vous interagissez avec votre fenêtre ! Celle-ci met à jour ses composants à chaque changement d'état ou de statut ! Et l'intérêt d'avoir une classe héritée d'un container ou d'un composant, c'est que nous pouvons redéfinir la façon dont est peint ce composant sur la fenêtre !

Donc, après cette mise en bouche... Si nous explorions un peu plus les capacités de notre objet Graphics ?

Plus loin dans le Graphics

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();
                }
                
        }               
}

Pour bien vous montrer la différence, j'ai ajouté une couleur de fond rouge. Et, si vous vous demandez comment j'ai fait... j'ai mis un rectangle de couleur rouge de la taille de mon composant...

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 !

Le cousin caché : l'objet Graphics2D

Voici une amélioration de l'objet Graphics, et vous allez vite comprendre pourquoi...

Pour utiliser cet objet, il nous suffit de caster l'objet Graphics en Graphics2D, et surtout de ne pas oublier d'importer sa classe !
Celle-ci se trouve dans le package java.awt.

Voilà notre début de code :

Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
 
import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
public class Panneau extends JPanel{
  
     public void paintComponent(Graphics g){
        
        Graphics2D g2d = (Graphics2D) g;
     }
}


L'une des possibilités qu'offre cet objet n'est autre que la possibilité de peindre des objets avec des dégradés de couleurs...
Cette opération n'est pas du tout difficile à effectuer. Pour ce faire, il vous suffit d'utiliser un objet GradientPaint et une méthode de l'objet Graphics2D.

Nous n'allons pas reprendre tous les cas que nous avons vus jusqu'à présent... Juste deux ou trois pour que vous voyez bien la différence.

Commençons par notre objet GradientPaint, voici comme l'initialiser :

Code : Java - 
1
 
GradientPaint gp = new GradientPaint(0, 0, Color.RED, 30, 30, Color.cyan, true);

Vous devrez mettre à jour vos imports... Vous devez ajouter ici : import java.awt.GradientPaint;


Alors, que veut dire tout ceci ? Voici le détail du constructeur utilisé ici :
  • paramètre 1 : la coordonnée x où doit commencer la couleur 1 ;
  • paramètre 2 : la coordonnée y où doit commencer la couleur 1 ;
  • paramètre 3 : couleur 1 ;
  • paramètre 4 : la coordonnée x2 où doit commencer la couleur 2 ;
  • paramètre 5 : la coordonnée y2 où doit commencer la couleur 2 ;
  • paramètre 6 : couleur 2 ;
  • paramètre 7 : booléen pour définir si le dégradé doit se répéter.

Entre ces deux points se créera le dégradé des deux couleurs spécifiées !

Ensuite, pour utiliser ce dégradé dans une forme, il suffit de mettre à jour votre objet Graphics2D, comme ceci :
Code : Java - 
1
2
 
GradientPaint gp = new GradientPaint(0, 0, Color.RED, 30, 30, Color.cyan, true);
g2d.setPaint(gp);


Le code entier de cet exemple est :
Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
import java.awt.Color;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
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){
                
                Graphics2D g2d = (Graphics2D)g;         
                GradientPaint gp = new GradientPaint(0, 0, Color.RED, 30, 30, Color.cyan, true);                
                g2d.setPaint(gp);
                g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
                
        }               
}


Voici les résultats obtenus, l'un avec le booléen à true, et l'autre à false :


Votre dégradé est oblique (rien ne m'échappe, à moi...). Ce sont les coordonnées choisies qui influent sur la direction du dégradé. Dans notre exemple, nous partons du point de coordonnées (0, 0) vers le point de coordonnées (30, 30). Si vous vouliez un dégradé vertical, il faut juste mettre la valeur de x2 à 0 et voilà :


Un petit cadeau :
Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
 
        public void paintComponent(Graphics g){
                
                Graphics2D g2d = (Graphics2D)g;
                
                GradientPaint gp = new GradientPaint(0, 0, Color.RED, 20, 0, Color.magenta, true);
                GradientPaint gp2 = new GradientPaint(20, 0, Color.magenta, 40, 0, Color.blue, true);
                GradientPaint gp3 = new GradientPaint(40, 0, Color.blue, 60, 0, Color.green, true);
                GradientPaint gp4 = new GradientPaint(60, 0, Color.green, 80, 0, Color.yellow, true);
                GradientPaint gp5 = new GradientPaint(80, 0, Color.yellow, 100, 0, Color.orange, true);
                GradientPaint gp6 = new GradientPaint(100, 0, Color.orange, 120, 0, Color.red, true);
                                                
                g2d.setPaint(gp);
                g2d.fillRect(0, 0, 20, this.getHeight());               
                g2d.setPaint(gp2);
                g2d.fillRect(20, 0, 20, this.getHeight());
                g2d.setPaint(gp3);
                g2d.fillRect(40, 0, 20, this.getHeight());
                g2d.setPaint(gp4);
                g2d.fillRect(60, 0, 20, this.getHeight());
                g2d.setPaint(gp5);
                g2d.fillRect(80, 0, 20, this.getHeight());
                g2d.setPaint(gp6);
                g2d.fillRect(100, 0, 40, this.getHeight());
                
        }               
}



Quelques exemples de dégradés avec d'autre formes :

Avec un cercle



Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
 
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
 
        public void paintComponent(Graphics g){
                
                Graphics2D g2d = (Graphics2D)g;
                
                GradientPaint gp = new GradientPaint(20, 20, Color.yellow, 95, 95, Color.blue, true);
                g2d.setPaint(gp);
                g2d.fillOval(this.getWidth()/4, this.getHeight()/4, this.getWidth()/2, this.getHeight()/2);
                
        }               
}


Avec un rectangle arrondi



Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
 
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
 
        public void paintComponent(Graphics g){
                
                Graphics2D g2d = (Graphics2D)g;
                
                GradientPaint gp = new GradientPaint(20, 20, Color.green, 55, 75, Color.orange, true);
                g2d.setPaint(gp);
                g2d.fillRoundRect(30, 30, 75, 75, 10, 10);
                
        }               
}


Un peu de texte pour finir



Code : Java - 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
import java.awt.Color;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
 
        public void paintComponent(Graphics g){
                g.setColor(Color.BLACK);
                g.fillRect(0, 0, this.getWidth(), this.getHeight());
                
                Graphics2D g2d = (Graphics2D)g;         
                GradientPaint gp = new GradientPaint(0, 0, Color.cyan, 30, 30, Color.pink, true);
                g2d.setPaint(gp);
                
                Font font = new Font("Comics Sans MS", Font.BOLD, 14);
                g2d.setFont(font);
                g2d.drawString("On s'amuse les ZérOs !", 10, 15);
                
                gp = new GradientPaint(-40, -40, Color.red, 100, 100, Color.white, false);
                g2d.setPaint(gp);
                
                font = new Font("Arial Black", Font.PLAIN, 16);
                g2d.setFont(font);
                g2d.drawString("Moi j'aime bien...", 10, 65);
        }               
}




Nous avons fait un bon petit tour, là...
Pour les curieux, je vous conseille d'aller voir la page des tutos de Sun Microsystems sur l'objet Graphics2D.

Bon, je pense qu'un topo serait le bienvenu...

Ce qu'il faut retenir

  • L'objet JPanel se trouve dans le package javax.swing.
  • Un JPanel peux contenir des composants ou d'autres containers ! !
  • Lorsque vous ajoutez un JPanel principal à votre fenêtre, n'oubliez pas de dire à votre fenêtre que ce dernier sera son contentPane.
  • Pour redéfinir la façon dont l'objet est dessiné sur notre fenêtre, nous devons utiliser la méthode paintComponent en créant une classe héritée.
  • Cette méthode prend un paramètre, un objet Graphics.
  • Cet objet doit nous être fourni par le système !
  • C'est lui que nous allons utiliser pour dessiner dans notre container.
  • Pour des dessins plus évolués, vous devrez utiliser l'objet Graphics2D qui s'obtient en faisant un cast sur l'objet Graphics.
Et voilà, encore une partie rondement menée.
Maintenant que nous savons comment ajouter un conteneur sur notre fenêtre, nous allons voir comment positionner des composants !

Eh oui : si vous ne dites pas à vos composants où ils doivent aller, ils se mettront à la queue-leu-leu !
Bon : on y va ?

C'est parti pour : Faire une animation simple.

// // 0 comments //

0 comments to "LECON 302"

Post a Comment

Powered by Blogger.

About This Blog

Aller au debut de la page