# Programmation Java Swing/Types de données et constantes

* 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
* 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
[ Modifier le sommaire ]
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 :
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.
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 :
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.
Cette classe permet aussi quelques opérations :

## 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 :
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.

## Notes de bas de page

* ↑ Exemple d'un écran de 23 pouces en résolution 1980x1080 (diagonale approximative de 2229.12 pixels) : $2229.12/23\approx 96$ pixels par pouce.