Utilisation de la classe Graphics

Divers facteurs incitent les gens à écrire des programmes logiciels. Je crois que pour beaucoup, la motivation naît du désir de créer des graphiques, de manipuler des images ou d’animer. Qu'ils souhaitent créer des jeux d'arcade, des simulateurs de vol ou des packages CAO, les développeurs commencent souvent par apprendre à dessiner.

La boîte à outils graphique de la boîte à outils Abstract Windowing (ou AWT) permet à un programmeur Java de dessiner des formes géométriques simples, d'imprimer du texte et de positionner des images dans les bordures d'un composant, comme un cadre, un panneau ou une toile.

Cette chronique est ma première sur le thème des graphiques. Il se concentrera sur la Graphicsclasse et ses méthodes pour dessiner des formes géométriques simples, et présentera le processus par lequel la peinture (et la repeinture) se produit.

Commençons par le devant de la scène - la Graphicsclasse.

La classe Graphics

Il est essentiel que les programmeurs comprennent la Graphicsclasse avant d'essayer de dessiner des images via Java. La Graphicsclasse fournit le cadre pour toutes les opérations graphiques dans AWT. Il joue deux rôles différents, mais liés. Tout d'abord, c'est le contexte graphique. Le contexte graphique est une information qui affectera les opérations de dessin. Cela inclut les couleurs d'arrière-plan et de premier plan, la police, ainsi que l'emplacement et les dimensions du rectangle de détourage (la région d'un composant dans laquelle les graphiques peuvent être dessinés). Il comprend même des informations sur la destination éventuelle des opérations graphiques elles-mêmes (écran ou image). Deuxièmement, leGraphicsLa classe fournit des méthodes pour dessiner des formes géométriques simples, du texte et des images vers la destination graphique. Toute sortie vers la destination graphique se produit via un appel de l'une de ces méthodes.

Pour dessiner, un programme nécessite un contexte graphique valide (représenté par une instance de la Graphicsclasse). Étant donné que la Graphicsclasse est une classe de base abstraite, elle ne peut pas être instanciée directement. Une instance est généralement créée par un composant et transmise au programme en tant qu'argument des méthodes update () et paint () d'un composant . Ces deux méthodes, ainsi que la méthode repaint () , sont décrites dans la section suivante.

Les méthodes

Les trois méthodes suivantes sont impliquées dans l'affichage des graphiques. Les versions par défaut de chacun sont fournies par classe Component. Les méthodes update () et paint () doivent être redéfinies pour effectuer les opérations graphiques souhaitées.

repeindre()

public void repaint () public void repaint (long tm) public void repaint (int x, int y, int w, int h) public void repaint (long tm, int x, int y, int w, int h)

La méthode repaint () demande qu'un composant soit repeint. L'appelant peut demander que le repeinture se produise dès que possible, ou peut spécifier une période en millisecondes. Si une période de temps est spécifiée, l'opération de peinture aura lieu avant que la période de temps ne s'écoule. L'appelant peut également spécifier que seule une partie d'un composant doit être repeinte. Cette technique est utile si l'opération de peinture prend du temps et que seule une partie de l'écran doit être repeinte. Le code du Listing 1 illustre comment la méthode repaint () peut être utilisée dans un programme.

booléen mouseDown (Event e, int x, int y) {selected_object.move (x, y); repeindre(); }

Listing 1: Gestionnaire d'événements avec la souris

Le code du gestionnaire d'événements mouseDown () recalcule la position d'un objet dans un affichage en fonction de la position de la souris et appelle la méthode repaint () pour indiquer que l'affichage doit être repeint dès que possible.

mettre à jour()

mise à jour publique void (graphique g)

La méthode update () est appelée en réponse à une requête repaint () , ou en réponse à une partie du composant découverte ou affichée pour la première fois. Le seul argument de la méthode est une instance de la Graphicsclasse. L' Graphicsinstance n'est valide que dans le contexte de la méthode update () (et de toutes les méthodes qu'elle appelle), mais est supprimée peu après le retour de la méthode update () . L'implémentation par défaut fournie par la Componentclasse efface l'arrière-plan et appelle la méthode paint () (ci-dessous).

peindre()

peinture vide public (Graphique g)
La méthode paint () est appelée à partir d'une méthode update () et est responsable du dessin des graphiques. Le seul argument de la méthode est une instance de la Graphicsclasse. L'implémentation par défaut fournie par class Componentne fait rien.

Comment les composants sont repeints

Pour réduire le temps nécessaire pour repeindre l'écran, l'AWT prend deux raccourcis:

  • Premièrement, l'AWT ne repeint que les composants qui doivent être repeints, soit parce qu'ils ont été découverts, soit parce qu'ils ont demandé à être repeints.


    
  • Deuxièmement, si un composant a été couvert et est découvert, l'AWT ne repeint que la partie du composant qui était précédemment couverte.

L'applet de la figure 1 vous permet d'observer ce processus tel qu'il se produit. Ignorez la zone de texte en haut de l'applet pendant un moment et ne regardez que la partie colorée de l'écran. À l'aide d'une autre fenêtre, couvrez momentanément puis découvrez une partie de l'applet. Notez que seule la partie de l'applet qui était couverte est repeinte. De plus, seuls les composants couverts sont repeints, quelle que soit leur position dans la hiérarchie des composants. En utilisant délibérément différentes couleurs, l'applet rend cet effet subtil perceptible. Le code source de cette figure est disponible ici.

Figure 1: Navigateur Repeindre

Le système de coordonnées graphiques

Les méthodes décrites dans la section suivante prennent, comme paramètres, des valeurs qui spécifient comment une forme doit être dessinée. Par exemple, la méthode drawLine () attend quatre paramètres. Les deux premiers paramètres spécifient l'emplacement du début de la ligne et les deux derniers paramètres spécifient l'emplacement de la fin de la ligne. Les valeurs exactes à transmettre à la méthode drawLine () sont déterminées par le système de coordonnées en vigueur.

Un système de coordonnées est une méthode permettant de spécifier sans ambiguïté l'emplacement des points dans l'espace. Dans le cas de l'AWT, cet espace est une surface bidimensionnelle appelée plan. Chaque emplacement dans un plan peut être spécifié par deux entiers, appelés coordonnées x et y . Les valeurs des coordonnées x et y sont calculées en termes de déplacement horizontal et vertical respectif du point par rapport à l'origine. Dans le cas de l'AWT, l'origine est toujours le point dans le coin supérieur gauche du plan. Il a les valeurs de coordonnées 0 (pour x ) et 0 (pour y). L'illustration de la figure 2 montre deux points - l'un situé à l'origine, et l'autre situé à une position sept en travers et cinq en bas de l'origine.

Figure 2: Le plan de coordonnées

Les primitives graphiques

Cette section présente des méthodes pour dessiner des lignes, des rectangles, des ovales et des arcs et des polygones. Comme ces méthodes ne fonctionnent que lorsqu'elles sont appelées sur une Graphicsinstance valide , elles ne peuvent être utilisées que dans le cadre des méthodes update () et paint () d'un composant . La plupart des méthodes qui suivent se présentent par paires. Une méthode (la méthode drawX () ) dessine uniquement le contour de la forme spécifiée et l'autre méthode (la méthode fillX () ) dessine une version remplie de la forme spécifiée.

lignes

void drawLine (int xBegin, int yBegin, int xEnd, int yEnd)

C'est la plus simple de toutes les méthodes graphiques. Il trace une ligne droite, d'un seul pixel de large, entre les points de début et de fin spécifiés. La ligne résultante sera découpée pour s'adapter aux limites de la région de découpage actuelle. La ligne sera dessinée dans la couleur de premier plan actuelle.

L'applet de la figure 3 illustre la méthode drawLine () en action. Le code source est disponible ici. Cette applet et les applets des figures 4, 6 et 7 nécessitent les services de deux classes de support: la classe NewCanvas et l'interface Figure. La classe NewCanvas étend la classe Canvas et fournit une surface de dessin spécialisée pour les figures. Le code source de la classe NewCanvas est disponible ici. L'interface Figure définit les méthodes qu'une figure doit fournir pour être utilisée avec NewCanvas. Le code source de l'interface Figure est disponible ici.

Figure 3: démonstration de dessin de ligne

rectangles
void drawRect (int x, int y, int w, int h) void fillRect (int x, int y, int w, int h) void drawRoundRect (int x, int y, int w, int h, int arcWidth, int arcHeight ) void fillRoundRect (int x, int y, int w, int h, int arcWidth, int arcHeight) void draw3DRect (int x, int y, int w, int h, boolean soulevé) void fill3DRect (int x, int y, int w, int h, booléen élevé)

Chacune de ces méthodes graphiques nécessite, comme paramètres, les coordonnées x et y auxquelles commencer le rectangle, ainsi que la largeur et la hauteur du rectangle. La largeur et la hauteur doivent être des entiers positifs. Le rectangle résultant sera découpé pour s'adapter aux limites de la région de découpage actuelle. Le rectangle sera dessiné dans la couleur de premier plan actuelle. Les rectangles se déclinent en trois styles différents: unis, avec des coins arrondis et avec un léger effet tridimensionnel (mais souvent difficile à voir).

Les méthodes graphiques en rectangle arrondi nécessitent deux paramètres supplémentaires, une largeur d'arc et une hauteur d'arc, qui contrôlent tous deux l'arrondi des coins. Les méthodes de rectangle en trois dimensions nécessitent un paramètre supplémentaire qui indique si le rectangle doit être enfoncé ou surélevé.

The applet in Figure 4 demonstrates these methods in action. The source code is available here.

Figure 4: Rectangle drawing demonstration

ovals and arcs

void drawOval(int x, int y, int w, int h) void fillOval(int x, int y, int w, int h) void drawArc(int x, int y, int w, int h, int startAngle, int arcAngle) void fillArc(int x, int y, int w, int h, int startAngle, int arcAngle)

Each of these graphics methods require, as parameters, the x and y coordinates of the center of the oval or arc, and the width and height of the oval or arc. Both the width and the height must be positive integers. The resulting shape will be clipped to fit within the boundaries of the current clipping region. The shape will be drawn in the current foreground color.

The arc graphics methods require two additional parameters, a start angle and an arc angle, to specify the beginning of the arc and the size of the arc in degrees (not radians). Figure 5 illustrates how angles are specified.

Figure 5: Angle specification

The applet in Figure 6 demonstrates these methods in action. The source code is available here.

Figure 6: Oval and arc drawing demonstration

polygons

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

Polygons are shapes formed from a sequence of line segments. Each of the polygon graphics methods require, as parameters, the coordinates of the endpoints of the line segments that make up the polygon. These endpoints can be specified in either one of two ways: as two parallel arrays of integers, one representing the successive x coordinates and the other representing the successive y coordinates; or with an instance of the Polygon class. The Polygon class provides the method addPoint(), which allows a polygon definition to be assembled point by point. The resulting shape will be clipped to fit within the boundaries of the current clipping region.

The applet in Figure 7 demonstrates these methods in action. The source code is available here.

Figure 7: démonstration de dessin de polygone

Conclusion

Croyez-le ou non, ces quelques primitives graphiques simples, combinées à tout ce que nous avons couvert ces derniers mois (AWT, gestion des événements, observateurs, etc.) sont tout ce dont vous avez besoin pour écrire un tas d'applications utiles, allant de jeux aux systèmes de CAO. Le mois prochain, je vais rassembler tous ces éléments et vous montrer ce que je veux dire.

Restez à l'écoute.

Todd Sundsted a écrit des programmes depuis que les ordinateurs sont devenus disponibles dans les modèles de bureau. Bien qu'à l'origine intéressé par la création d'applications d'objets distribués en C ++, Todd est passé au langage de programmation Java lorsque Java est devenu le choix évident pour ce genre de choses. En plus de l'écriture, Todd fournit des services de consultation Internet et Web aux entreprises du sud-est des États-Unis. : END_BIO

En savoir plus sur ce sujet

  • L' GraphicsAPI de classe Java

    //java.sun.com/products/JDK/CurrentRelease/api/java.awt.Graphics.html

  • Observateur et observable //www.sun.com/javaworld/jw-10-1996/jw-10-howto.html
  • L'interface utilisateur efficace //www.sun.com/javaworld/jw-09-1996/jw-09-userint.html
  • Java et gestion des événements //www.sun.com/javaworld/jw-08-1996/jw-08-event.html
  • Présentation de l'AWT //www.sun.com/javaworld/jw-07-1996/jw-07-awt.html

Cette histoire, "Utilisation de la classe Graphics" a été publiée à l'origine par JavaWorld.