Programmation Java Swing/Types de données et constantes

Programmation Java Swing

• Introduction
• Composants
  • Arbre
• Fenêtres
• Menus
• Actions
• Types de données et constantes
• Gestion de la disposition des composants
• Gestion des évènements
• Gestion des actions asynchrones
• Apparence de l'interface
• Contenu en HTML
• Créer un composant
  • Une case à cocher à trois états
  • Dessin d'un composant
  • Dessin d'une étoile
  • Dessin de texte et effets
• Créer une image

Les interfaces graphiques en Swing utilisent les mêmes types de données qu'en AWT. Ces types sont utilisés abondamment dans l'API pour définir des informations graphiques :

• Couleur
• Dimensions
• Police de caractères
• Position
• Orientation
• Curseur de souris

Couleurs

Un objet de classe java.awt.Color représente une couleur au format RVBA (Rouge, Vert, Bleu et Alpha) à quatre composantes dont la valeur est entre 0 et 255. La composante alpha définit l'opacité de la couleur : 0 = transparente, 255 = opaque (valeur par défaut).

Le constructeur de la classe java.awt.Color permet de spécifier la couleur avec les trois composantes et éventuellement la valeur alpha pour la transparence, de type int entre 0 et 255 ou de type float entre 0.0 et 1.0.

Exemples :

public static final Color
	C_BLEU_GRIS = new Color(150,150,180), // alpha=255 pour 100% d'opacité par défaut
	C_BLEU_VERT = new Color(0,170,220, 192); // alpha=192 pour 75% d'opacité

La classe java.awt.Color définit quelques couleurs utilisées fréquemment :

BLUE(0,0,255)	GREEN(0,255,0)	RED(255,0,0)	ORANGE(255,200,0)
YELLOW(255,255,0)	MAGENTA(255,0,255)	CYAN(0,255,255)	PINK(255,175,175)
BLACK(0,0,0)	DARK_GRAY(64,64,64)	GRAY(128,128,128)	LIGHT_GRAY(192,192,192)	WHITE(255,255,255)

Police de caractères

Un objet de classe java.awt.Font représente la police de caractère utilisée pour dessiner le texte. La classe possède deux constructeurs :

Font(String name, int style, int size)

Les attributs sont définis par les arguments suivants :

• name : Nom de la police de caractères. Il peut aussi s'agir d'un nom symbolique défini par Java disponible sur toutes les plateformes : Dialog, DialogInput, Monospaced, ...
• style : Style de police, parmi les constantes définies par la classe : PLAIN, BOLD, ITALIC, BOLD_ITALIC.
• size : Taille de la police de caractères en points.

Font(Map<? extends Attributes, ?> attributes)

Les attributs sont définis par un dictionnaire (Map) dont les clés doivent être celles définies par la classe java.awt.font.TextAttribute. Ce constructeur permet de définir davantage d'attributs.

La taille des polices de caractères en Java est en points pour 72 DPI (Dot Per Inch), quel que soit le DPI du système.

S'il est configuré convenablement au niveau système, le nombre de pixels par pouce (DPI) permet d'avoir un affichage de taille physique constant quel que soit le moyen d'affichage utilisé. Sachant qu'un point (pt) vaut 1/72 pouce (1/72 in), une police de caractère de 16pt devrait donc être affichée sur une hauteur de 21.333 pixels environ sur un écran à 96 DPI :

$taille\_en\_pixels={\frac {taille\_en\_points}{72}}\times dpi={\frac {16}{72}}\times 96\approx 21.333$

Cependant, Java utilise 72 DPI, ce qui signifie que la taille donnée en point sera la même en pixels : 16pt affiché sur 16 pixels. Les polices de caractères apparaissent donc plus petites dans les applications Java par rapport aux autres applications (traitement de texte, logiciel de dessin, navigateur...) sur les écrans ayant un DPI supérieur et plus grandes sur les écrans avec un DPI inférieur à 72.

Pour obtenir un affichage identique aux autres applications, en ajoutant un paramètre dans l'application pour configurer le nombre de points par pouce, il faut ajuster la taille de la police. Pour l'exemple d'une police de caractères de 16 points sur un écran de 96 DPI, il faut utiliser une taille de 21,333. Cependant, le constructeur acceptant un nombre à virgule flottante pour la taille au lieu d'un entier est privé, mais la méthode deriveFont autorise un nombre à virgule flottante pour la taille.

int dpi = 96;
static final int dpi_java = 72;
// La taille initiale (entier) passée au constructeur n'a pas d'importance.
Font f_16_points = new Font("Arial", Font.PLAIN, 16).deriveFont(16f*dpi/dpi_java);

Cependant, au lieu d'utiliser une valeur fixe, il est préférable d'utiliser la valeur retournée par la méthode getScreenResolution() de la classe java.awt.Toolkit :

int dpi = java.awt.Toolkit.getDefaultToolkit().getScreenResolution();
static final int dpi_java = 72;
Font f_16_points = new Font("Arial", Font.PLAIN, 16).deriveFont(16f*dpi/dpi_java);

Le nombre de points par pouce n'est toutefois pas toujours bien configuré. La solution est de prévoir un paramètre de configuration pour changer la valeur de densité, en utilisant la valeur retournée par la méthode getScreenResolution() comme valeur par défaut.

Dimensions

Un objet de classe java.awt.Dimension définit la taille d'un composant avec deux attributs publics, qui peuvent être initialisés en passant leur valeur en argument du constructeur :

int width

Largeur en pixels (0 par défaut).

int height

Hauteur en pixels (0 par défaut).

Position

Un objet de classe java.awt.Point définit la position d'un composant avec deux attributs publics, qui peuvent être initialisés en passant leur valeur en argument du constructeur :

int x

Position horizontale en pixels (0 par défaut), relative au bord gauche du conteneur.

int y

Position vertical en pixels (0 par défaut), relative au bord supérieur du conteneur.

Rectangle

Un objet de classe java.awt.Rectangle définit à la fois la la position d'un composant et sa taille avec quatre attributs publics, qui peuvent être initialisés en passant leur valeur en argument du constructeur :

int x

Position horizontale en pixels (0 par défaut), relative au bord gauche du conteneur.

int y

Position vertical en pixels (0 par défaut), relative au bord supérieur du conteneur.

int width

Largeur en pixels (0 par défaut).

int height

Hauteur en pixels (0 par défaut).

La classe Rectangle a aussi des constructeurs acceptant une position (java.awt.Point) ou une taille (java.awt.Dimension) ou les deux.

Rectangle zone = new Rectangle(20, 10, 300, 200); // position x=20, y=10 ; taille width=300, height=200

Point position = new Point(20, 10);
Dimension taille = new Dimension(300, 200);
Rectangle zone = new Rectangle(position, taille);

Cette classe permet aussi quelques opérations :

Rectangle zone1 = new Rectangle(20, 10, 300, 200); // position x=20, y=10 ; taille width=300, height=200
Rectangle zone2 = new Rectangle(40, 50, 320, 250); // position x=40, y=50 ; taille width=320, height=250

Rectangle zone_englobante = zone1.union(zone2);
Rectangle zone_commune = zone1.intersection(zone2);

Constantes de position et orientation

L'interface javax.swing.SwingConstants est une collection de constantes relatives à la position et l'orientation. Les tableaux ci-dessous montrent leur valeur et ce qu'elle représente.

Le centre a la valeur nulle, et les autres constantes de positionnement sont distribuées ensuite dans le sens trigonométrique (anti-horaire) en partant du haut.

	TOP = 1
LEFT = 2	CENTER = 0	RIGHT = 4
	BOTTOM = 3

Le centre a la valeur nulle, et les autres constantes de direction sont distribuées ensuite dans le sens horaire (anti-trigonométrique) en partant du haut.

NORTH_WEST = 8	NORTH = 1	NORTH_EAST = 2
WEST = 7	CENTER = 0	EAST = 3
SOUTH_WEST = 6	SOUTH = 5	SOUTH_EAST = 4

Les autres constantes définies sont les constantes d'orientation :

• HORIZONTAL = 0
• VERTICAL = 1

les constantes de position selon l'orientation de lecture de la langue courante :

• LEADING = 10 avant dans le sens de lecture.

Cela correspond à gauche (respectivement droite) si la langue courante se lit de gauche à droite (respectivement de droite à gauche),

• TRAILING = 11 après dans le sens de lecture.

Cela correspond à droite (respectivement gauche) si la langue courante se lit de gauche à droite (respectivement de droite à gauche).

et les constantes de direction dans une séquence :

• NEXT = 12
• PREVIOUS = 13

Curseur de souris

Un objet de classe java.awt.Cursor définit le curseur utilisé quand la souris survole un composant. Le curseur par défaut est défini en fonction du composant : une flèche par défaut, une ligne verticale pour un champ textuel, ... La méthode setCursor(Cursor c) est définie pour toutes les classes de composants et fenêtres.

Afin de conserver une cohérence avec les autres applications, le changement de curseur n'est conseillé que pour certains cas exceptionnels et la création de nouveaux composants.

Plusieurs méthodes statiques permettent d'utiliser un curseur prédéfini :

Cursor.getPredefinedCursor(int type)

Retourne un curseur typique (disponible sur toutes les plateformes Java) parmi ceux-ci :

• Cursor.DEFAULT_CURSOR Curseur par défaut (flèche),
• Cursor.CROSSHAIR_CURSOR Curseur en croix (ligne verticale + ligne horizontale),
• Cursor.TEXT_CURSOR Curseur pour les champs de texte,
• Cursor.WAIT_CURSOR Curseur d'attente durant une action en cours (sablier, ...), peut être animé selon la plateforme,
• Cursor.direction_RESIZE_CURSOR Groupe de curseurs de la souris de type flèche directionnelle ou bidirectionnelle utilisé généralement pour le redimensionnement des fenêtres, quand la souris approche du bord : (N=North (nord), S=South (sud), E=East (est), W=West (ouest)) SW_RESIZE_CURSOR, SE_RESIZE_CURSOR, NW_RESIZE_CURSOR, NE_RESIZE_CURSOR, S_RESIZE_CURSOR, N_RESIZE_CURSOR, W_RESIZE_CURSOR, E_RESIZE_CURSOR,
• Cursor.MOVE_CURSOR Curseur de type flèche dans les 4 directions cardinales, généralement utilisé lors du déplacement d'un élément,
• Cursor.HAND_CURSOR Curseur de type main, généralement utilisé pour les actions ouvrant une fenêtre ou une page (lien) ;

Cursor.getDefaultCursor()

Retourne le curseur par défaut (flèche) ;

Équivaut à : Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)

Cursor.getSystemCustomCursor(String name)

Retourne un curseur spécifique au système, à partir d'un nom (par exemple "Invalid.32x32").

Ces curseurs sont définis dans le fichier de configuration cursors.properties du JRE (ou le sous-répertoire "jre" du JDK) localisé dans le répertoire lib/images/cursors. Les fichiers images référencés sont situés dans le même répertoire.

Exemple pour JDK 1.8 sous Windows, extrait du fichier C:\Program Files\Java\jdk1.8.0_05\jre\lib\images\cursors\cursors.properties :

#
Cursor.LinkNoDrop.32x32.File=win32_LinkNoDrop32x32.gif
Cursor.LinkNoDrop.32x32.HotSpot=6,2
Cursor.LinkNoDrop.32x32.Name=LinkNoDrop32x32
#
Cursor.Invalid.32x32.File=invalid32x32.gif
Cursor.Invalid.32x32.HotSpot=6,2
Cursor.Invalid.32x32.Name=Invalid32x32

Il est également possible de créer un curseur personnalisé à partir d'une image et d'un point dans l'image. Ce point détermine quel pixel de l'image correspond à la position de la souris.

Toolkit toolkit = Toolkit.getDefaultToolkit();
Cursor c = toolkit.createCustomCursor(image, new Point(x,y), nom_du_curseur);