Il y a principalement deux cas où un programmeur est amené à dessiner : la réalisation d'un composant graphique non-standard tel qu'un diagramme, ou la création automatique d'une image à partir de données.
Dans les 2 cas, le dessin sera assuré par la classe <javaClass class="java.awt.Graphics2D"/>. Vous ne devez en aucun cas essayer de construire une instance de cette classe. Pour dessiner dans un composant graphique, l'instance vous est donnée en paramètre de la méthode paint(AWT) ou paintComponent(SWING). Pour le dessin dans une image, on crée un objet <javaClass class="java.awt.Image" />, puis on utilise la méthode <javaMethode class="java.awt.Image" methode="getGraphics()"/> pour récupérer l'objet Graphics et dessiner dans l'image.
Image img = new BufferedImage(150,52,BufferedImage.TYPE_INT_RGB);Graphics2D g2d = (Graphics2D)img.getGraphics();
Les solutions adoptées par SUN pour le dessin des composants sont assez complexes et un certain nombre d'optimisations sont propices à induire les débutants en erreur.
Quand un composant est-il dessiné ?
Le plus important est de bien comprendre quand et pourquoi les méthodes paint(AWT) et paintComponant(SWING) sont exécutées. La première raison est une requête explicite du composant via la méthode <javaMethode class="java.awt.Component" methode="repaint()"/>. La deuxième raison est une requête du système, soit suite au redimensionnement de la fenêtre, soit suite au masquage du composant par une autre fenêtre du système.
La règle à toujours respecter :
Tout programmeur qui redéfinit la méthode paint(AWT) ou paintComponent(Swing) s'engage à redessiner l'intégralité de la surface du composant. En effet, l'objet Graphics qui est transmis au composant dessine toujours dans le même espace mémoire et cet espace n'est jamais nettoyé (pour des raisons de performance). Le programmeur du composant a donc la charge de nettoyer l'espace et de redessiner son composant. Si le composant est complexe et que son dessin est long, il est recommandé d'utiliser la technique de double-buffering pour optimiser son affichage.
La méthode <javaMethode class="java.awt.Graphics2D" methode="drawString(java.lang.String,int,int)"/> de la classe <javaClass class="java.awt.Graphics2D"/> correspond parfaitement à ce que l'on cherche.
<comment>Ecriture dans une image 'img'</comment>Graphics2D g2d = (Graphics2D)img.getGraphics();g2d.drawString("HelloWord",x,y);
Avec quelques raffinements :
On peut améliorer un peu le procédé et choisir la police et la couleur de notre texte. En fait, la classe <javaClass class="java.awt.Graphics2D"/> garde un certain nombre d'attributs qui sont appliqués à toutes les opérations de dessin ; la couleur principale, la couleur secondaire (de fond), la police, la déformation. Il suffit de changer ces valeurs en utilisant la méthode appropriée.
Les coordonnées (x,y) que l'on donne à la méthode drawString correspondent au coin inférieur gauche de la première lettre du texte. Plus précisement, la valeur y correspond à la ligne 'de base' du texte. Pour les langues comme l'Arabe qui s'écrivent de droite à gauche, cette position correspond à la position du dernier caractère de la chaine, donc de celui qui sera affiché le plus a gauche. (Si vous n'avez pas tout compris, faite le test. ;-) )
Lorsque l'on dessine du texte il est souvent utile de connaître la taille nécessaire pour l'affichage de ce texte, pour le centrer ou continuer à écrire à la ligne suivante. Il suffit pour cela de récupérer l'instance de la classe <javaClass class="java.awt.FontMetrics"/> du graphique dans lequel on souhaite écrire.
Pas besoin de grandes phrases, un exemple suffit :
Graphics2D g2d = ...;<comment>Lissage du texte uniquement :</comment>g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALOAS_ON);<comment>Lissage du texte et des dessins</comment>g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALOAS_ON);
La gestion de la transparence passe par l'utilisation du 'canal alpha', notion bien connue des graphistes. Pour nous, la gestion de la transparence se résume à spécifier à notre graphique le pourcentage d'opacité que l'on souhaite appliquer à ce que l'on va dessiner (graphique ou texte). Une composante alpha de 0 correspond à une complète transparence, alors qu'une valeur de 1 correspond à une complète opacité.
Juste une méthode à appliquer à notre graphique :
Graphics2D g2d = ...;<comment>80 % de transparence</comment>g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f ));g2d.drawXXX(...);
Comme toujours avec l'objet <javaClass class="java.awt.Graphics2D"/>, nous allons définir une nouvelle taille de pinceau qui s'appliquera à tous les traits qui seront tracés par la suite, aussi bien via la méthode drawLine(..) que drawRect(...) ou drawShape(...).
Graphics2D g2d = ...;<comment>Défini une épaisseur de 5 pixels</comment>g2d.setStroke(new BasicStroke( 5.0f ));g2d.drawXXX(...);
Le fait que la taille du pinceau soit précisée par un nombre réel peut surprendre, difficile en effet d'imaginer une ligne de 2.5 pixels. Pour comprendre, il suffit de s'imaginer le cas d'une ligne oblique, ou le cas d'un tracé avec l'anti-aliasing actif.
Définir le type de la ligne :
La classe <javaClass class="java.awt.BasicStroke" /> contrairement à ce que laisse penser son nom n'est pas si basique que ca. Outre la taille du pinceau, elle permet la définition de lignes en pointillés avec éventuellement plusieurs longueurs, elle permet aussi de définir comment sont gérées les intersections des lignes d'une multi-ligne (shape), et plein d'autres choses encore. Je ne rentrerai donc pas dans les détails, tout est expliqué dans la <javaClass class="java.awt.BasicStroke">documentation</javaClass>. Un petit exemple quand même :
Graphics2D g2d = ...;float epaisseur=3; <comment>taille de la ligne</comment>float style = {10,5};<comment>les pointillés seront 2 fois plus long que les blancs</comment>gd2.setStroke( new BasicStroke( <br_l/>epaisseur,<br_l/>BasicStroke.CAP_BUTT,<br_l/>BasicStroke.JOIN_MITTER,<br_l/>10,0f,<br_l/>style,<br_l/>0<br_l/>));
Les fonctions de remplissage de zone sont gérées par <javaClass class="java.awt.Graphics2D"/> en précisant comment colorier avant d'utilisant les méthodes fillXXX(...).
Avec un dégradé de couleur :
Un dégradé de couleur est calculé en fonction de deux points de référence dont on fixe la couleur, la couleur des points situés entre les 2 est un dégradé linéaire.
Un certain nombre de propriétés peuvent être initialisées pour indiquer vos préférences d'affichage. Voici les valeurs à mettre pour gagner en vitesse :
<comment>Désactivation de l'anti-aliasing</comment>g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);g2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);<comment>Demande de rendu rapide</comment>g2D.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);g2D.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);g2D.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);g2D.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
Le double buffering :
L'utilisation d'un double buffer est particulièrement recommandée pour l'affichage d'animations complexes ou de composants de grande taille. Voir Comment utiliser le double-buffering ?
Le passage en plein écran est très utile pour la programmation de jeu, mais aussi dans les applications à titre ponctuel pour faire une prévisualisation d'impression, d'image, pour faire un diaporama ou autres ...
Passage en plein écran :
Le passage de l'affichage en plein écran est une nouvelle fonctionnalité de j2se 1.4. La classe <javaClass class="java.awt.GraphicsEnvironment"/> permet de connaître la liste des écrans. Il est fortement recommandée de vérifier que le plein écran est supporté ; si ce n'est pas le cas la fenêtre est redimensionnée pour prendre tout l'écran mais elle n'a pas l'exclusivité de l'affichage.
La diminution de la résolution est particulièrement conseillée pour augmenter la performance d'affichage ( moins il y a de pixels, mieux c'est ). Une configuration est définie par une instance de <javaClass class="java.awt.DisplayMode" />. Exemple de code :
Avant de vous embarquer dans la réalisation d'un super jeu en plein écran, je vous conseille de vous renseigner un minimum sur les techniques d'optimisation et d'accélération de l'affichage (vois lien ci-dessous).
Et les applets ?
Les applets sont autorisées à passer en affichage plein écran seulement si l'utilisateur a la permission fullScreenExclusive.
Le principe du double-buffering est d'utiliser une image pour faire les modifications d'affichage du composant. Lors de l'affichage proprement dit, on se contente de réafficher l'image... Je vous laisse consulter le lien ci-dessous pour mieux comprendre comment coder la chose.
Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduit en français ici.
Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement.
