Faq Java Gui

FAQ Java GUI
Date de publication : 15/11/2008
Dernière mise à jour : 17/05/2009
Cette faq a été réalisée à partir des questions fréquemment posées sur les forums de
http://www.developpez.com et de l'expérience personnelle des auteurs.
Nous tenons à souligner que cette faq ne garantit en aucun cas que les informations
qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est
humaine. Cette faq ne prétend pas non plus être complète. Si vous trouvez une erreur,
ou que vous souhaitez nous aider en devenant rédacteur, lisez Comment participer à
cette faq ?.
Sur ce, nous vous souhaitons une bonne lecture.
L'équipe Java
Ont contribué à cette FAQ :
bazinou - iubito - Clément Cunin - Johann Heymes - Ronan

Le Gallo - Christophe Ludet - Jean-Baptiste Bugeaud
- Grégory Danelon - Sébastien Meric - Romain Guy -
Pierre-Yves Varoux - Ioan Calapodescu - bahamouth - duj
- braim - bulbo - Ricky81 - L'équipe Java - Debernad -
jcarre - Seigne David - cyberzoide - xavlours - christopheJ
- willowII - Nourdine Falola - laffreuxthomas - adiGuba
- vasilov - schniouf - TheSeb - strab - Zedros - Baptiste
Wicht - JMLLB - Janitrix - d-jo - fxjtarga - Pill_S - Orian -
le y@m's - Jack Huser - seiryujay - morph41 - gifffftane -
FAQ Java GUI
1. Informations générales (5) .........................................................................................................................................................4

2. Fenêtres et positionnement des composants (22) ......................................................................................................................7
3. La souris et le clavier (9) ........................................................................................................................................................ 24
4. Le dessin (12) .......................................................................................................................................................................... 28
5. Les images (18) ....................................................................................................................................................................... 36
6. AWT et Swing (60) .................................................................................................................................................................45
6.1. Généralités (21) ...............................................................................................................................................................46
6.2. JFileChooser (5) ..............................................................................................................................................................58
6.3. JColorChooser (2) ...........................................................................................................................................................63
6.4. Composants textuels (8) ................................................................................................................................................. 64
6.5. Tableaux et arbres (JTable et JTree) (14) ...................................................................................................................... 69
6.6. Les listeners (10) ............................................................................................................................................................ 74
7. Applets (8) ............................................................................................................................................................................... 84
8. Divers et astuces (4) ................................................................................................................................................................87
-3-
Les codes sources présentés sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page tant
que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 - 2009 Developpez LLC : Tous droits réservés Developpez
FAQ Java GUI
Sommaire > Informations générales

Comment bien utiliser cette faq ?
Auteurs : L'équipe Java ,
Le but :
Cette faq a été conçue pour être la plus simple possible d'utilisation. Elle tente d'apporter des réponses simples et
complètes aux questions auxquelles sont confrontés tous les débutants (et les autres).
L'organisation :
Les questions sont organisées par thème, les thèmes pouvant eux-même contenir des sous-thèmes. Lorsqu'une question
porte sur plusieurs thèmes, celle-ci est insérée dans chacun des thèmes rendant la recherche plus facile.
Les réponses :
Les réponses contiennent des explications et des codes sources. Certaines sont complétées de fichier à télécharger
contenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il soit aisé de
localiser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses, vers la
documentation en ligne de Sun ou vers un autre site en rapport.
Nouveautés et mises à jour :

Lors de l'ajout ou de la modification d'une question/réponse, un indicateur est placé à coté du titre de la question.
Cet indicateur reste visible pour une durée de 15 jours afin de vous permettre de voir rapidement les modifications
apportées.
J'espère que cette faq pourra répondre à vos questions. N'hésitez pas à nous faire part de tous commentaires/remarques/
critiques.
lien : Comment participer à cette faq ?
Comment participer à cette faq ?

Cette faq est ouverte à toute collaboration. Pour éviter la multiplication des versions, il serait préférable que toutes
collaborations soient transmises aux administrateurs de la faq.
Plusieurs compétences sont actuellement recherchées pour améliorer cette faq :
Rédacteur :
Bien évidemment, toute nouvelle question/réponse est la bienvenue.
Web designer :
Toute personne capable de faire une meilleur mise en page, une feuille de style ou de belles images...
Correcteur :
-4-
FAQ Java GUI
Malgré nos efforts, des fautes d'orthographe ou de grammaire peuvent subsister. Merci de contacter les administrateurs
si vous en débusquez une... Idem pour les liens erronés.
lien : Quels sont les droits de reproduction de cette FAQ ?
Quels sont les droits de reproduction de cette FAQ ?

Les codes sources présentés sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Pour le
reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs :
- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la licence GNU FDL traduite
en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et
Johann Heymes tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission
vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".
- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
Aucune reproduction ne peut en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon
la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
Où trouver d'autres sources d'information ?

•
Les cours et didacticiels de www.developpez.com
•
Les forums de la section Java de www.developpez.com
•
La FAQ Struts
•
La Javadoc : toutes les informations utiles sur les classes, leurs méthodes ... à toujours avoir sous la main.
•
Les didacticiels de Sun
•
La FAQ de JGuru, beaucoup plus complète que celle-ci ...
Remerciements
Un grand merci à tous ceux qui ont pris de leur temps pour la réalisation de cette FAQ.
Aux rédacteurs :
Remerciements tout d'abord à tous ceux qui ont rédigé les questions et les réponses.
Clément Cunin, Johann Heymes, Nicolas Cuny, Ronan Le Gallo, Christophe Ludet, Jean-Baptiste Bugeaud, Sebastien
Andreo, Grégory Danelon, Sébastien Meric, Romain Guy, Pierre-Yves Varoux, Ioan, bahamouth, duj, Braim, bulbo,
Ricky81, Debernad, jcarre, David Seigne, xavlours, christopheJ, willowII, Nourdine Falola, laffreuxthomas.
Aux correcteurs :
-5-
FAQ Java GUI
Remerciements également aux personnes qui ont relu les textes pour supprimer un maximum de fautes de français.
Nicolas Cuny, Jonathan Muller, Etienne Bar, Bestiol, Ukyuu.
Aux visiteurs :
Remerciements enfin à tous ceux qui ont consulté cette FAQ, et qui, par leurs remarques, nous ont aidé à la
perfectionner.
Et pour finir, un merci tout spécial à Clément Cunin, qui est à l'origine de cette FAQ, à cyberzoide pour notre logo et
ses conseils avisés et à tous les membres de l'équipe qui nous ont fourni outils et logiciels nécessaires pour la réalisation
de ce document.
-6-
FAQ Java GUI
Sommaire > Fenêtres et positionnement des composants

Comment connaître la taille de l'écran ?
Auteurs : Clément Cunin ,
La taille de l'écran est disponible grâce à la classe java.awt.Toolkit.
Dimension tailleEcran = java.awt.Toolkit.getDefaultToolkit().getScreenSize();

int hauteur = (int)tailleEcran.getHeight();
int largeur = (int)tailleEcran.getWidth();
Comment centrer une fenêtre à l'écran ?

A partir du JDK 1.4 :
Le JDK 1.4 offre une méthode de centrage automatique des fenêtres, plus besoin de faire cela à la main... La méthode
setLocationRelativeTo(java.awt.Component) de la classe java.awt.Window permets de faire un centrage par rapport
à un composant ou à l'écran.
Le centrage doit être effectué par rapport à un composant affiché au moment où l'on veut centrer notre fenêtre...
Généralement juste avant de la rendre visible. (si le paramètre est null ou que le composant n'est pas affiché, le centrage
est fait par rapport à l'écran.)
/** Centrage de la fenêtre par rapport à la fenêtre parente.

* S'il n'y a pas de fenêtre parente, on centre par rapport à l'écran
*/
maFenetre.setLocationRelativeTo(maFenetre.getParent());
/** ...puis on l'affiche */
maFrame.show();
JDK 1.3 et antérieurs :

Aucune méthode ne fait cela automatiquement, mais il est très facile de positionner soit-même la fenêtre lors de
l'initialisation.
/** Lecture de la taille de l'écran */

java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
frame.pack();
/* la fenêtre prend sa taille... */
frame.setLocation(
(screenSize.width-frame.getWidth())/2,
(screenSize.height-frame.getHeight())/2
);
lien : Comment connaître la taille de l'écran ?
Comment centrer verticalement et horizontalement un composant ?

Auteurs : Johann Heymes ,
Centré autour de ses quatres composants voisins
Réponse toute simple : en utilisant le LayoutManager approprié à ce cas de figure, à savoir java.awt.BorderLayout.
-7-
FAQ Java GUI
JPanel panel = new JPanel (new BorderLayout ());

panel.add (monComposant, BorderLayout.CENTER);
/** le deuxième paramètre de la méthode add n'est pas obligatoire,
* car il s'agit de la valeur par défaut
*/
N'oubliez pas que la caractéristique principale du BorderLayout est d'ajuster la dimension du composant à la place
disponible.
Centré sur son conteneur (JPanel )

Là aussi c'est le choix du LayoutManager qui résout le problème, mais il est nécessaire d'en prendre un quelque peu
plus compliqué : java.awt.GridBagLayout.
JPanel p = new JPanel (new GridBagLayout ());

p.add (composant,
new GridBagConstraints (0, 0, 1, 1, 0, 0,
GridBagConstraints.CENTER,
GridBagConstraints.CENTER,
new Insets (0,0,0,0), 0, 0));
Comment positionner les composants dans un conteneur ?

Auteurs : Nourdine Falola ,
A l'aide des gestionnaires de mise en forme
Java propose un certain nombre gestionnaires de mise en forme, ou layout managers, qui permettent de placer les
composants sans en indiquer la position précise (les coordonnées), mais la disposition souhaitée.
Les principaux gestionnaires sont :
• Comment utiliser le FlowLayout ?
• Comment utiliser le BorderLayout ?
• Comment utiliser le GridLayout ?
• Comment utiliser le BoxLayout ?
• Comment utiliser le GridBagLayout ?
Si l'on a besoin d'une mise en forme particulière, il est possible de créer des gestionnaires de mise en forme personnalisés.
En spécifiant les coordonnées
Il est possible de se passer des gestionnaires de mise en forme pour le placement des composants. Pour cela, on définit
le gestionnaire de mise en forme du contenant à null, on ajoute le composant au contenant et on spécifie la position
absolue et la taille voulue du composant :
setLayout(null);
JButton ok = new JButton("OK");
ok.setBounds(x,y,width,height); // param int
Comment utiliser le FlowLayout ?

Ce gestionnaire aligne horizontalement les composants, en préservant la taille de ceux-ci, jusqu'à ce qu'il n'y ait plus
de place. Lorsque la ligne est remplie, les composants suivant sont placés à la ligne suivante et ainsi de suite.
Par défaut les composants sont centrés horizontalement. Lorsque la taille du conteneur est modifiée, les composants
sont réorganisés automatiquement. FlowLayout est le gestionnaire de mise en forme par défaut des JPanel.
class FlowLayoutFrame extends JFrame
-8-
FAQ Java GUI
{
public FlowLayoutFrame ()
{
setTitle("FlowLayout Test");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
JPanel panel = new JPanel();
// ------------ par défaut pour le JPanel ------------

// panel.setLayout(new FlowLayout());
// panel.setLayout(new FlowLayout(FlowLayout.CENTER));
getContentPane().add(panel);
panel.add(new JButton("Bouton 1"));

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
static final int DEFAULT_WIDTH = 200;

static final int DEFAULT_HEIGHT = 150;
}
Comment utiliser le BorderLayout ?

Ce gestionnaire décompose le conteneur en 5 zones : Centre, Nord, Sud, Est, Ouest.
Si on ne précise pas la zone dans laquelle on veut placer le composant, celui-ci est placé au centre. Les composants en
bordure sont placés en premier, puis l'espace restant est occupé par le composant central.
Ce gestionnaire modifie la taille des composants afin qu'ils prennent tout l'espace disponible. En cas de
redimensionnement, seul le centre est redimensionné en hauteur ET en largeur.
BorderLayout est le gestionnaire de mise en forme par défaut des JFrame.
class BorderLayoutFrame extends JFrame

{
public BorderLayoutFrame ()
{
setTitle("BorderLayout Test");
Container c = getContentPane();
// ------------ par défaut pour le JFrame ------------
-9-
FAQ Java GUI
// setLayout(new BorderLayout());
c.add(makeLabel(" NORD "),BorderLayout.NORTH);

c.add(makeLabel(" SUD "),BorderLayout.SOUTH);
c.add(makeLabel(" EST "),BorderLayout.EAST);
c.add(makeLabel(" OUEST "),BorderLayout.WEST);
c.add(makeLabel(" CENTRE "),BorderLayout.CENTER);
}
private JLabel makeLabel(String text)

{
JLabel label = new JLabel(text,JLabel.CENTER);
Border borderLine = BorderFactory.createLineBorder(Color.BLACK);
label.setBorder(borderLine);
return label;
}

}
Comment utiliser le GridLayout ?

Ce gestionnaire arrange les composants sur une grille dont on spécifie le nombre de cases horizontales et verticales.
Un composant est redimensionné afin de prendre tout l'espace de la cellule, et chaque cellule est de taille identique.
Lorsque la fenêtre est redimensionnée, les cellules se partagent équitablement l'espace disponible. Les composants sont
ajoutés ligne par ligne à partir de la cellule du coin supérieur gauche.
class GridLayoutFrame extends JFrame

{
public GridLayoutFrame ()
{
setTitle("GridLayout Test");
setLayout(new GridLayout(2,3));
- 10 -
FAQ Java GUI
c.add(new JButton("(1,1)"));
}

}
Comment utiliser le BoxLayout ?

Ce gestionnaire permet de placer les composants sur une même ligne ou une même colonne.
Comme pour les autres gestionnaires, on peut l'assigner comme gestionnaire du conteneur (JFrame, JPanel...).
Cependant, il existe un conteneur "dédié", le Box, dont le gestionnaire par défaut est un BoxLayout.
Utiliser des Box nous permet d'avoir plusieurs BoxLayout dans un même conteneur (dans le JFrame par exemple).
Les composants sont insérés :
• de gauche à droite pour le BoxLayout horizontal
• de haut en bas pour le BoxLayout vertical
Par défaut, les composants sont collés les uns aux autres. Pour les espacer, il faut insérer des réserves entre les
composants. Il en existe 3 types :
• le Strut, qui ajoute un espace mesuré en nombre de pixels. Le Strut est unidimensionnel : il existe un Strut
horizontal et un Strut vertical
• le RigidArea, qui est équivalent à un couple de Strut horizontal/vertical
• le Glue, qui repousse les 2 composants voisins aussi loin que possible l'un de l'autre.
Stratégie de mise en forme :

- Le BoxLayout horizontal calcul la taille maximale du plus haut composant et tente d'agrandir tous les autres
composants à la même hauteur. Les composants qui n'ont pu atteindre cette hauteur sont alignés (appel à
getAlignementY()). Les largeurs préférées des composants sont additionnées. Si la largeur du BoxLayout ne correspond
pas à cette somme, la taille des composants est ajustée dans les limites des tailles min et max. Si le Box est trop petit,
des composants ne seront pas affichés.
- 11 -
FAQ Java GUI
- stratégie analogue pour le BoxLayout vertical.
class BoxLayoutFrame extends JFrame

{
public BoxLayoutFrame ()
{
setTitle("BoxLayout Test");
JLabel nomLabel = new JLabel("Nom : ");

JTextField nomText = new JTextField(10);
nomText.setMaximumSize(nomText.getPreferredSize());
Box hBox1 = Box.createHorizontalBox();

hBox1.add(nomLabel);
hBox1.add(Box.createHorizontalStrut(5));
hBox1.add(nomText);
JLabel prenomLabel = new JLabel("Prénom : ");

JTextField prenomText = new JTextField(10);
prenomText.setMaximumSize(prenomText.getPreferredSize());

hBox2.add(prenomLabel);
hBox2.add(Box.createHorizontalStrut(5));
hBox2.add(prenomText);

hBox3.add(new JButton("OK"));
hBox3.add(Box.createGlue());
hBox3.add(new JButton("Annuler"));
Box vBox = Box.createVerticalBox();

vBox.add(hBox1);
vBox.add(hBox2);
vBox.add(Box.createGlue());
vBox.add(hBox3);
c.add(vBox,BorderLayout.CENTER);
}

}
- 12 -
FAQ Java GUI
Comment utiliser le GridBagLayout ?

La terreur du débutant ! Comme le GridLayout, ce gestionnaire permet de placer les composants sur une grille, mais
avec plus de flexibilité.
Le GridBagLayout fonctionne comme un tableau dont les cellules peuvent être fusionnées.
Pour placer les composants, il faut :
• instancier un GridBagLayout et le passer comme gestionnaire du conteneur
• définir un GridBagConstraints pourr chaque composant
• ajouter chaque paire composant/GridBagConstraints au conteneur
Ce sont les contraintes qui détermineront la position des composants et le comportement en cas de redimenssionnement
de la fenêtre. Les paramètres d'un GridBagConstraints sont :
• gridx, gridy (int) : numéros de ligne et de colonne du coin supérieur gauche de la zone d'affichage du composant.
• gridwidth, gridheight (int) : largeur et hauteur du composant en nombre de cellule.
• fill (int) : comportement du composant lors du redimensionnement si sa taille et celle de la zone d'affichage ne
correspondent pas.
• anchor (int) : alignement du composant dans la zone d'affichage.
• weigthx, weigthy (double) : comportement de la zone d'affichage en cas de redimenssionnement du tableau.
• ipadx, ipady (int) : valeurs ajoutées à la taille minimale du composant (par 2 fois : ipadx à gauche et à droite,
ipady en haut et en bas)
• insets (Insets) : définit les marges autour du composant.
La documentation AWT recommande de remplacer la définition des paramètres gridx et gridy en valeurs absolues,
par la constante GridBagConstraints.RELATIVE. Pour indiquer qu'un composant est le dernier d'une ligne, on donne
alors à la largeur de sa zone d'affichage (gridwidth) la valeur GridBagConstraints.REMAINDER. On donne cette même
valeur à la hauteur de la zone d'affichage des composants de la dernière ligne.
Etapes pour utiliser un GridBagLayout:
[1] Mettre en forme le composant sur papier.
[2] Etablir la grille avec une cellule pour les petits composants, plusieurs pour les plus gros.
[3] Libeller les lignes et les colonnes. Ces libellés donneront les valeurs de gridx, gridy, gridwidth, gridheight.
[4] Définir le dimensionnement (fill) et l'alignement (anchor) des composants.
[5] Mettre tous les poids (weightx et weigthy) à 100, on ajoustera les poids ensuite. Mettre 0 pour les composants
qui restent toujours à leur taille par défaut.
- 13 -
FAQ Java GUI
[6] Ecrire le code.

[7] Compiler, exécuter et éventuellement ajuster les poids.
Exemple d'utilisation du GridBagLayout:
class FontDialogFrame extends JFrame

{
public FontDialogFrame()
{
setTitle("FontDialog");
GridBagLayout layout = new GridBagLayout();

getContentPane().setLayout(layout);
ActionListener listener = new FontAction();
// construction des composants
JLabel faceLabel = new JLabel("Face: ");
face = new JComboBox(new String[]

{
"Serif", "SansSerif", "Monospaced",
"Dialog", "DialogInput"
});
face.addActionListener(listener);
JLabel sizeLabel = new JLabel("Size: ");
size = new JComboBox(new String[]

{
"8", "10", "12", "15", "18", "24", "36", "48"
});
size.addActionListener(listener);
bold = new JCheckBox("Bold");

bold.addActionListener(listener);
italic = new JCheckBox("Italic");

italic.addActionListener(listener);
sample = new JTextArea();

sample.setText("Tout ça pour ça ! Y'a pas à dire, mais faut en taper du code...");
sample.setEditable(false);
sample.setLineWrap(true);
sample.setBorder(BorderFactory.createEtchedBorder());
// construction des contraintes et ajout des couples composant/contraintes
GridBagConstraints c1 = new GridBagConstraints();

c1.gridx = 0;
c1.gridy = 0;
c1.anchor = GridBagConstraints.EAST;
getContentPane().add(faceLabel,c1);

c2.gridx = 1;
c2.gridy = 0;
c2.fill = GridBagConstraints.HORIZONTAL;
c2.weightx = 100;
c2.weighty = 0;
c2.insets = new Insets(1,0,0,0);
getContentPane().add(face,c2);
- 14 -
FAQ Java GUI

c3.gridx = 0;
c3.gridy = 1;
c3.anchor = GridBagConstraints.EAST;
add(sizeLabel,c3);

c4.gridx = 1;
c4.gridy = 1;
c4.weightx = 100;
c4.weighty = 0;
c4.insets = new Insets(1,0,0,0);
getContentPane().add(size,c4);

c5.gridx = 0;
c5.gridy = 2;
c5.gridwidth = 2;
c5.gridheight = 1;
c5.anchor = GridBagConstraints.CENTER;
c5.weightx = 100;
c5.weighty = 100;
getContentPane().add(bold,c5);

c6.gridx = 0;
c6.gridy = 3;
c6.gridwidth = 2;
c6.gridheight = 1;
c6.anchor = GridBagConstraints.CENTER;
c6.weightx = 100;
c6.weighty = 100;
getContentPane().add(italic,c6);

c7.gridx = 2;
c7.gridy = 0;
c7.gridwidth = 1;
c7.gridheight = 4;
c7.fill = GridBagConstraints.BOTH;
c7.weightx = 100;
c7.weighty = 100;
getContentPane().add(sample,c7);
}
public static final int DEFAULT_WIDTH = 300;

public static final int DEFAULT_HEIGHT = 200;
private JComboBox face;

private JComboBox size;
private JCheckBox bold;
private JCheckBox italic;
private JTextArea sample;
private class FontAction implements ActionListener

{
public void actionPerformed(ActionEvent event)
{
String fontFace = (String) face.getSelectedItem();
int fontStyle = (bold.isSelected() ? Font.BOLD : 0)
+ (italic.isSelected() ? Font.ITALIC : 0);
int fontSize = Integer.parseInt((String) size.getSelectedItem());
Font font = new Font(fontFace, fontStyle, fontSize);
sample.setFont(font);
sample.repaint();
}
}
}
- 15 -
FAQ Java GUI
NOTE: Le didactiel de Sun suggère d'utiliser le même objet GriBagConstraints pour tous les composants. Cependant,
le code devient difficile à lire et est sujet aux erreurs (oublie de modification d'un paramètre qui avait été modifié pour
un précédent composant). Aussi est-il préférable d'utiliser un nouveau GriBagConstraints pour chaque composant.
Comment simplifier l'utilisation du GridBagLayout ?

Le plus complexe avec le GridBagLayout, c'est l'écriture des contraintes. Les auteurs du livre "Au coeur de Java2 :
Notions fondamentales" proposent une classe qui simplifie énormément l'écriture des contraintes et la lecture du code :
la classe GBC.
En voici les avantages :

Dans 'Au coeur de Java2 : Notions fondamentales', il y a écrit :
L'exemple de la question Comment utiliser le GridBagLayout ?,réarrangé en employant la classe GBC, devient :
class FontDialogFrame extends JFrame

{
public FontDialogFrame()
{
setTitle("FontDialog");
GridBagLayout layout = new GridBagLayout();

getContentPane().setLayout(layout);
ActionListener listener = new FontAction();
// construct components
JLabel faceLabel = new JLabel("Face: ");
face = new JComboBox(new String[]

{
"Serif", "SansSerif", "Monospaced",
"Dialog", "DialogInput"
});
face.addActionListener(listener);
JLabel sizeLabel = new JLabel("Size: ");
size = new JComboBox(new String[]

{
"8", "10", "12", "15", "18", "24", "36", "48"
});
size.addActionListener(listener);
bold = new JCheckBox("Bold");

bold.addActionListener(listener);
italic = new JCheckBox("Italic");

italic.addActionListener(listener);
sample = new JTextArea();

sample.setText("La classe GBC nous facilite grandement la vie.\n"+
"La quarantaine de lignes nécessaire précédemment pour définir les contraintes a disparue!");
- 16 -
FAQ Java GUI
sample.setEditable(false);
sample.setLineWrap(true);
sample.setBorder(BorderFactory.createEtchedBorder());
// add components to grid, using GBC convenience class
Container cp = getContentPane();
cp.add(faceLabel, new GBC(0, 0).setAnchor(GBC.EAST));
cp.add(face, new GBC(1, 0).setFill(GBC.HORIZONTAL).setWeight(100, 0).setInsets(1));
cp.add(sizeLabel, new GBC(0, 1).setAnchor(GBC.EAST));
cp.add(size, new GBC(1, 1).setFill(GBC.HORIZONTAL).setWeight(100, 0).setInsets(1));
cp.add(bold, new GBC(0, 2, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));
cp.add(italic, new GBC(0, 3, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));
cp.add(sample, new GBC(2, 0, 1, 4).setFill(GBC.BOTH).setWeight(100, 100));
}
public static final int DEFAULT_WIDTH = 300;

public static final int DEFAULT_HEIGHT = 200;
private JComboBox face;

private JComboBox size;
private JCheckBox bold;
private JCheckBox italic;
private JTextArea sample;
private class FontAction implements ActionListener

{
public void actionPerformed(ActionEvent event)
{
String fontFace = (String) face.getSelectedItem();
int fontStyle = (bold.isSelected() ? Font.BOLD : 0)
+ (italic.isSelected() ? Font.ITALIC : 0);
int fontSize = Integer.parseInt((String) size.getSelectedItem());
Font font = new Font(fontFace, fontStyle, fontSize);
sample.setFont(font);
sample.repaint();
}
}
}
La classe GBC est téléchargeable ici.
Comment faire une application ou un jeu en plein écran ?

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
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.
GraphicsDevice myDevice = java.awt.GraphicsEnvironment.

getLocalGraphicsEnvironment().getDefaultScreenDevice();
Window myWindow;
if( myDevice.isFullScreenSupported() ) {
try {
myDevice.setFullScreenWindow(myWindow);
/** ... */
- 17 -
FAQ Java GUI
} finally {
myDevice.setFullScreenWindow(null);
}
} else {
System.err.println("Plein écran non supporté");
}
Changement de résolution :
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 java.awt.DisplayMode. Exemple de code :
myDevice.setDisplayMode(new DisplayMode(
800,
600,
DisplayMode.BIT_DEPTH_MULTI,
DisplayMode.REFRESH_RATE_UNKNOWN
));
Avant de commencer :
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.
lien : http://java.sun.com/docs/books/tutorial/extra/fullscreen/
lien : Comment accélérer le rendu graphique de mon dessin ?
lien : Comment utiliser le double-buffering software ?
Comment changer l'icone de la fenêtre de mon application ?

Auteurs : Clément Cunin , bulbo ,
L'icone d'une application apparaît à divers endroits en fonction du système d'exploitation. Sous windows, on la retrouve
en haut à gauche de la fenêtre, et dans la barre des taches. Par défaut, il s'agit de la tasse de café de Java. Il est très
facile de la personnaliser en utilisant la méthode setIconImage(java.awt.Image) des classes javax.swing.JFrame.
Cette méthode n'est pas disponible pour la classe JDialog, les dialogues utilisent automatiquement l'icone de la frame
parente.
Image icone = Toolkit.getDefaultToolkit().getImage("./monImage.jpg");

maFenetre.setIconImage(icone);
Si l'image n'apparaît pas, c'est certainement que le paramètre image a une valeur 'null'.
Une autre raison pour laquelle cette image n'apparaitrait serait un problème au niveau de la transparence avec les
images PNG qui ne sont pas gérés par tous les OS, certains OS vont l'afficher mais supprimmer la transparence et
d'autres ne pas l'afficher.
- 18 -
FAQ Java GUI
De plus, certains OS ne supportent simplement pas les images de type PNG, transparence ou non.
lien : Comment accéder à une image ?
Quelle différence entre cacher et détruire une fenêtre ?

Lorsque l'on affiche une fenêtre à l'écran, la machine virtuelle alloue la mémoire et les ressources systèmes nécessaires à
la création de l'image de cette fenêtre à l'écran. Les méthodes hide() et dispose() font tous les deux disparaître la fenêtre
de l'écran ; en revanche, elles diffèrent par leur action sur la mémoire.
Cacher une fenêtre avec hide() :

La méthode hide() se contente de masquer la fenêtre, les ressources nécessaires à son affichage sont conservées. La
fenêtre est donc prête à être réaffichée. C'est une bonne idée de cacher les fenêtres qui sont utilisées régulièrement par
l'application, leur réaffichage est plus rapide.
Détruire une fenêtre avec dispose() :

La méthode dispose() restitue les ressources au système. Les ressources libérées ne concernent que les objets utilisés pour
la construction de l'image, les différents composants que vous avez placés dans la fenêtre restent en mémoire comme
n'importe quel autre objet. Même après avoir été détruit, on peut toujours utiliser la méthode show() pour réafficher
la fenêtre (de nouvelles ressources seront alors allouées). C'est donc une très bonne idée de détruire les fenêtres lorsque
vous n'en avez plus besoin.
Note :
Tant qu'une fenêtre n'est pas détruite, elle ne peut pas être collectée par le ramasse miettes.
lien : Comment fermer une fenêtre lors d'un clic sur la croix en haut à droite ?
Comment fermer une fenêtre lors d'un clic sur la croix en haut à droite ?
AWT :
Lorsque l'on créer une fenêtre avec AWT, aucune action n'est associée à la commande de fermeture de cette fenêtre.
Nous allons donc en associer une.
maFenetre.addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
hide();
}
} );
SWING :
Par défaut, les fenêtres Swing sont cachées lorsque l'utilisateur clic sur la croix. Cette action par défaut peut facilement
être remplacée avec setDefaultCloseOperation(int).
maFenetre.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Liste des opérations définies par défaut:

• DO_NOTHING_ON_CLOSE - Ne fait aucune action par défaut.
• HIDE_ON_CLOSE - Cache la fenêtre.
• DISPOSE_ON_CLOSE - Détruit la fenêtre.
- 19 -
FAQ Java GUI
• EXIT_ON_CLOSE - Quitte l'application.
Note : La solution utilisée avec AWT reste valable avec Swing, elle permet d'effectuer des traitements plus complexes
en parallèle du traitement par défaut.
lien : Quelle différence entre cacher et détruire une fenêtre ?
Comment faire une fenêtre sans barre des titres ?

Frame & JFrame (JDK1.3 et précédants)
Les classes java.awt.Frame et javax.swing.JFrame correspondent aux fenêtres du système d'exploitation, il n'est pas
possible de changer l'apparence de la barre des titres ni des boutons de fermeture et d'agrandissement.
Window & JWindow

Contrairement aux 2 classes précédentes, java.awt.Window et javax.swing.JWindow définissent une fenêtre sans aucun
cadre ni barre de titre. Elles sont donc idéales pour faire des écrans de démarrage ou des interfaces personnalisées.
A partir du JDK1.4
Le jdk1.4 définit une nouvelle méthode setUndecorated(boolean) pour les classes java.awt.Frame et java.awt.Dialog.
Attention : cette méthode doit être appelée avant le premier affichage de la fenêtre à l'écran.
Comment iconifier ou maximiser ma fenêtre ?

Auteurs : Ioan Calapodescu ,
Depuis J2SE 1.4
Pour maximiser ou iconifier votre fenêtre, vous pouvez utiliser la méthode setExtendedState de la classe Frame. Par
exemple, pour maximiser de tous les côtés votre fenêtre, vous pouvez faire comme ceci :
JFrame frame = ... ;

frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
Les options possibles sont :

• NORMAL : aucun état spécial
• ICONIFIED : la fenêtre est iconifiée
• MAXIMIZED_HORIZ : la fenêtre occupe le maximum de place horizontalement
• MAXIMIZED_VERT : la fenêtre occupe le maximum de place verticalement
• MAXIMIZED_BOTH : la fenêtre est maximisée de tous côtés
Avant J2SE 1.4

Vous pouvez utiliser la méthode setState de la classe Frame. Son utilisation est la même que pour setExtendedState, à
la différence qu'il n'existe pas de paramètre permettant de maximiser. Si vous voulez tout de même avoir l'impression
que votre fenêtre est maximisée, c'est à dire qu'elle prenne toute la place disponible à l'écran, tout en gardant visible
la barre d'outils, vous pouvez faire comme ceci :
public void maximiser(Frame frame){

Toolkit kit = Toolkit.getDefaultToolkit();
- 20 -
FAQ Java GUI
//récupération de la taille de l'écran et des rebords

Insets insets = kit.getScreenInsets(frame.getGraphicsConfiguration());
Dimension screen = kit.getScreenSize();
//calcul des longueurs nécessaires et de la position

int w = (int)(screen.getWidth()-insets.left-insets.right);
int h = (int)(screen.getHeight()-insets.top-insets.bottom);
int x = (int)(insets.left);
int y = (int)(insets.top);
Dimension dimension = new Dimension(w,h);
//placement et redimension
frame.setSize(dimension);
frame.setLocation(x,y);
}
Comment garder ma fenêtre toujours au premier plan ?

Pour garder une fenêtre toujours au premier plan, il faut utiliser la méthode setAlwaysOnTop de la classe Window.
JFrame frame = new JFrame("Titre");

frame.setSize(200,200);
frame.setAlwaysOnTop(true);
frame.setVisible(true);
Si il existe plusieurs fenêtres ayant cette propriété à true, le comportement sera défini par le système. De plus, cette
méthode est susceptible de lever une SecurityException.
Attention : Cette fonctionnalité n'est disponible dans l'API standard que depuis la version 1.5 de J2SE. Pour les versions
précédentes, la seule possibilité est de passer par JNI et des API natives.
Comment ouvrir une fenêtre sur un écran particulier ?

Auteurs : adiGuba ,
Afin d'ouvrir une fenêtre (ou une boite de dialogue) sur un écran particulier, il faut utiliser un des constructeurs
comportant un paramètre du type java.awt.GraphicsConfiguration (présent dans les classes Frame et Dialog d'AWT
ainsi que JFrame et JDialog pour Swing).
L'instance de GraphicsConfiguration s'obtient depuis le GraphicsDevice associé à l'écran. Ainsi, pour afficher une
JFrame sur le second écran (si il est présent), on utilisera le code suivant :
Ouvrir une JFrame sur le second écran

// On récupére la liste des écrans :
GraphicsEnvironment gEnv = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] devices = gEnv.getScreenDevices();
// On récupère la configuration du second écran (s'il existe) :

GraphicsConfiguration gConfig = null;
if (devices.length>1) {
gConfig = devices[1].getDefaultConfiguration();
}
// On crée et on affiche la JFrame :
- 21 -
FAQ Java GUI
Ouvrir une JFrame sur le second écran

JFrame frame = new JFrame(gConfig);
frame.setSize(400,400);
Si le GraphicsConfiguration vaut null, c'est celui de l'écran principal qui sera utilisé...
lien : Comment obtenir la liste des écrans ?
Comment obtenir la liste des écrans ?

Auteurs : adiGuba ,
Les informations sur les écrans sont disponibles grâce à la classe java.awt.GraphicsEnvironment. Il suffit dès lors
d'utiliser la méthode getScreenDevices() pour obtenir un tableau de java.awt.GraphicsDevice représentant les différents
écrans du système :
Afficher la liste des écrans :

GraphicsDevice[] devices = gEnv.getScreenDevices();
for (int i=0; i<devices.length; i++) {

System.out.println("Identifiant de l'écran : " + devices[i].getIDstring() );
}
La méthode getDefaultScreenDevice() permettant d'accéder simplement à l'écran principal :
Afficher l'identifiant de l'écran principal :

GraphicsDevice defaultDevice = gEnv.getDefaultScreenDevice();
System.out.println("Identifiant de l'écran principal : " + defaultDevice.getIDstring() );
La classe GraphicsDevice permet également d'obtenir d'autres informations sur l'écran, tel que la résolution actuelle
et la liste des résolutions supportées...
lien : Comment ouvrir une fenêtre sur un écran particulier ?
Comment connaître la fenêtre active de l'application ?

Auteurs : bazinou ,
Le code suivant retourne l'objet Window actif:
KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow()
Comment connaître la mémoire utilisable de la carte graphique ?

Auteurs : Seigne David ,
Connaître la mémoire utilisable de la carte graphique:
- 22 -
FAQ Java GUI
Connaître la mémoire utilisable de la carte graphique:

// obtenir le type d'environnement graphique sous lequel tourne la JVM
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
// optenir le périphérique d'affichage (carte graphique)
GraphicsDevice gs = ge.getDefaultScreenDevice();
// stocke le nombre d'octets libres dans la mémoire de la carte graphique(VRAM)

int bytes = gs.getAvailableAcceleratedMemory();
// calcule le nombre de Kilo Octets libres dans la carte graphique
int kbytes = bytes /1024;
// calcule le nombre de Méga Octets libres dans la carte graphique
int mbytes = bytes /1048576;
Comment connaitre la taille du bureau ?

Auteurs : adiGuba ,
Le "bureau" des systèmes d'exploitations peut posséder une ou plusieurs barres qui diminue l'espace d'affichage des
fenêtres, mais lorsque l'on souhaite positionner précisément une fenêtre il est intéressant de déterminer cet espace afin
de ne pas cacher (ou être cacher) par une de ces barres, et ainsi respecter l'interface de l'utilisateur.
Pour obtenir cette espace, il faut dans un premier temps récupérer la taille de l'écran. Il suffit ensuite de récupérer les
marges de l'écran, de la manière suivante :
Toolkit toolkit = Toolkit.getDefaultToolkit();
// On récupère la taille de l'écran par défaut :

Dimension dim = toolkit.getScreenSize();
System.out.println(dim);
// On récupère la configuration par défaut de l'écran par défaut :

GraphicsConfiguration gconf = GraphicsEnvironment.getLocalGraphicsEnvironment()
.getDefaultScreenDevice().getDefaultConfiguration();
// On récupère les 'marges' de l'écran :

Insets insets = toolkit.getScreenInsets(gconf);
System.out.println(insets);
Ces marges correspondent à l'espace occupé par les différentes barres d'outils du système. Il est ainsi possible de
déterminer l'espace utile du bureau graphique de l'utilisateur.
- 23 -
FAQ Java GUI
Sommaire > La souris et le clavier

Quel bouton de la souris a été utilisé ?
Cas général :
Lorsque l'on reçoit une action d'un bouton de la souris, il y a deux solutions pour identifier le bouton concerné :
la première consiste à utiliser la méthode getButton() et de comparer le résultat avec les constantes BUTTON1,
BUTTON2 et BUTTON3. Cette solution n'est pas pleinement satisfaisante car la documentation ne précise pas lequel
est effectivement le bouton gauche. On préférera donc utiliser la classe javax.swing.SwingUtilities qui commente plus
généreusement son fonctionnement :
void mousePressed(MouseEvent mouseEvent) {

if ( SwingUtilities.isLeftMouseButton(mouseEvent) ) {
/** Bouton GAUCHE */
} else if(SwingUtilities.isMiddleMouseButton(mouseEvent) ) {
/** Bouton du MILIEU */
} else if(SwingUtilities.isRightMouseButton(mouseEvent)) {
/** Bouton DROIT */
}
}
Gardez toujours à l'esprit que certains systèmes n'ont pas de 2ème et/ou 3ème bouton, les traitements doivent donc être
accessibles par un autre moyen.
Ouvrir le menu contextuel :

Il est tentant d'ouvrir le menu contextuel lorsque l'on détecte l'utilisation du bouton droit, mais cette implémentation
ne serait pas portable, certains systèmes n'ont qu'un bouton de souris (Mac) d'autres n'utilisent pas le droit
pour ouvrir le menu contextuel (linux permet de configurer les choses les plus folles). Pour cela, on utilisera la
méthode isPopupTrigger() et on prendra soin de la tester dans mousePressed(java.awt.event.MouseEvent) et dans
mouseReleased(java.awt.event.MouseEvent). Le faire dans les deux cas est très important pour que le programme
fonctionne correctement sur tous les systèmes.
Comment changer la forme du curseur de la souris ?

JDK 1.0 :
Dans la classe java.awt.Frame des variables de classe (variable statique) définissent des curseurs, en choisir un et faire :
setCursor(Frame.celui_desire);
// par exemple : DEFAULT_CURSOR, WAIT_CURSOR ...
JDK 1.1 et +:
myComponent.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
Sachant que la classe Cursor définit un certain nombre de curseurs par défaut ( DEFAULT_CURSOR,
WAIT_CURSOR... ) on peut ainsi changer le curseur dans un Dialog ce qui n'était pas possible précédemment. Le
- 24 -
FAQ Java GUI
changement de curseur est automatiquement hérité par tous les fils, sauf si ceux-çi précisent explicitement un autre
curseur.
Comment traiter les "double clic" dans un MouseListener ?

Sur un événement de type java.awt.event.MouseEvent, la méthode getClickCount() permet de connaître le nombre de
clics et donc de gérer les doubles.
lien : Comment traiter les "simple clic" et les "double clic" de manière exclusive ?
Comment traiter les "simple clic" et les "double clic" de manière exclusive ?
De manière générale, ce cas ne devrait pas se produire. Le double clic ayant souvent une fonction complémentaire du
simple clic.
La seule solution est l'utilisation de 'timer' qui sera lancé lors d'un simple clic et arrêté lors d'un 2ème clic. Si le temps
est écoulé sans que le timer n'ait été arrêté par le 2ème clic, alors on exécute l'action associée au simple clic !
lien : Comment faire un minuteur (timer) facilement ?
Comment déplacer automatiquement la souris ?

La classe java.awt.Robot permet entre autres de déplacer automatiquement la souris via la méthode
mouseMove(int,int). La classe Robot permet également d'actionner les boutons de la souris ou d'entrer des touches au
clavier.
Attention :
Le déplacement automatique de la souris a le don d'énerver certains utilisateurs, il est donc conseillé de l'utiliser
prudemment et/ou de permettre à l'utilisateur de désactiver cette fonction.
Comment charger un curseur '.cur' ou '.ani' ?

Les formats de fichiers '.cur' et '.ani' ne sont pas supportés en standard par l'API de Java. La meilleure solution
consiste donc à utiliser un programme extérieur pour convertir ces fichiers dans un format reconnu par la JVM ('.png'
ou '.gif' sont parfaitement adaptés pour ça). Les plus courageux peuvent se mettre à la recherche d'une bibliothèque
additionnelle...
Comment connaître la position de la souris à l'écran ?

A partir d'un composant avec MouseEvent
- 25 -
FAQ Java GUI
En enregistrant un MouseEvent auprès de votre composant graphique, vous pouvez avoir accès à la position de la souris
relativement à ce composant. Il vous suffira ensuite d'utiliser la méthode getLocationOnScreen() de Component pour
calculer la position de la souris par rapport à l'écran.
int x = (int)(mouseEvent.getPoint().getX() + monComposant.getLocationOnScreen().getX());

int y = (int)(mouseEvent.getPoint().getY() + monComposant.getLocationOnScreen().getY());
Vous pouvez aussi utiliser la méthode convertPointToScreen() de la classe javax.swing.SwingUtilities. Par exemple :
MouseEvent event = ...;

Component composant = ...;
Point locationComposant = event.getPoint();
Point locationEcran = SwingUtilities.convertPointToScreen(locationComposant, composant);
Sans composant graphique
A partir de Java 5.0 (Tiger), si vous voulez connaître la position de la souris (même en dehors d'une fenêtre) vous pouvez
utiliser l'objet MouseInfo du package java.awt. Par exemple :
PointerInfo pointer = MouseInfo.getPointerInfo();

Point location = pointer.getLocation();
System.out.println("La souris se trouve en "+location);
Attention, l'instance de PointerInfo n'est pas mise à jour automatiquement. Vous devrez en récupérer une nouvelle
instance à chaque fois.
Avant Java 5.0, la seule solution possible est de passer par JNI (Java Native Interface). Vous pourrez ainsi avoir accès
grâce à des langages plus proches du système aux cooordonnées de la souris à l'écran. Attention tout de même, vous
risquez de perdre la portabilité de votre application.
[Java 5.0] Comment connaître le nombre de boutons de la souris ?

Auteurs : adiGuba ,
Depuis Java 5.0, il est possible de connaître le nombre de boutons de la souris grâce à la méthode statique
MouseInfo.getNumberOfButtons() :
Afficher le nombre de bouton de la souris :

System.out.println("La souris possède " + MouseInfo.getNumberOfButtons() + " bouton(s).");
Comment simuler la pression d'une touche?

Auteurs : vasilov ,
Il vous faudra pour cela employer la classe Robot.
Voici un petit exemple avec la touche A :
Robot robot = new Robot(); /** création du robot */
- 26 -
FAQ Java GUI
robot.keyPress(KeyEvent.VK_A); /** pression de la touche A */

robot.keyRelease(KeyEvent.VK_A); /** relachement de la touche A*/
Bien sur il est possible de combiner plusieurs touches, par exemple pour faire un A majuscule, il faut combiner le A
avec la touche shift.
- 27 -
FAQ Java GUI
Sommaire > Le dessin

Comment dessiner en Java ?
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 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 java.awt.Image,
puis on utilise la méthode 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();
Dessiner dans une image ne pose pas de problèmes majeurs mais la personnalisation de composants graphiques nécessite
de bien comprendre Pourquoi mon composant s'efface quand je redimensionne la fenêtre ?
lien : Pourquoi mon composant s'efface quand je redimensionne la fenêtre ?
Pourquoi mon composant s'efface quand je redimensionne la fenêtre ?

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 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 Comment utiliser le double-buffering software ? pour optimiser
son affichage.
Comment écrire du texte dans une image ?

Version simple :
La méthode drawString(java.lang.String,int,int) de la classe java.awt.Graphics2D correspond parfaitement à ce que
l'on cherche.
- 28 -
FAQ Java GUI
/** Ecriture dans une image 'img' */

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

g2d.setFont(new Font("Serif",Font.PLAIN,12));
g2d.setColor(Color.RED);
g2d.drawString("HelloWord",x,y);
A quoi correspond (x,y) ? :

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écisément, 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. ;-) )
lien : Comment dessiner en Java ?

lien : Comment connaître la taille de l'image d'un texte ?
Comment connaître la taille de l'image d'un texte ?

Lorsque l'on Comment écrire du texte dans une image ? 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 java.awt.FontMetrics du graphique dans lequel on souhaite écrire.
Graphics2D g2d = ...;

FontMetrics fontMetrics = g2d.getFontMetrics();
int longueur = fontMetrics.stringWidth("MonTexte");
int hauteur = fontMetrics.getHeight();
lien : Comment écrire du texte dans une image ?
Comment activer le lissage des textes et/ou des graphiques ?

Pas besoin de grandes phrases, un exemple suffit :

/** Lissage du texte uniquement : */
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
/** Lissage du texte et des dessins */

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
- 29 -
FAQ Java GUI
Comment dessiner ou écrire avec un effet de transparence ?

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 :

/** 80 % de transparence */
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f ));
g2d.drawXXX(...);

Comment faire une ligne épaisse ou en pointillés ?

Définir la taille du pinceau :
Comme toujours avec l'objet 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(...).

/** Défini une épaisseur de 5 pixels */
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 Comment
activer le lissage des textes et/ou des graphiques ?.
Définir le type de la ligne :

La classe 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 documentation. Un petit exemple quand même :

float epaisseur=3; /** taille de la ligne */
float[] style = {10,5}; /** les pointillés seront 2 fois plus long que les blancs */
g2d.setStroke( new BasicStroke(
epaisseur,
BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER,
10.0f,
style,
0
- 30 -
FAQ Java GUI
));
Comment remplir une forme avec un dégradé ou une texture ?

Les fonctions de remplissage de zone sont gérées par 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.

g2d.setPaint(new GradientPaint(xDebut,yDebut,colDebut,xFin,yFin,colFin,cyclique);
g2d.fillXXX(...);
Le booléen 'cyclique' permet de définir comment gérer les points au-delà des bornes.
Avec une texture :

g2d.setPaint(new TexturePaint(bufferedImage, new Rectangle(x,y,largeur,hauteur));
g2d.fillXXX(...);

lien : Texture personalisée en Java2D
Comment accélérer le rendu graphique de mon dessin ?

Quelques paramètres intéressants :
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 :
/** Désactivation de l'anti-aliasing */

g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
g2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
/** Demande de rendu rapide */
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 :
- 31 -
FAQ Java GUI
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 software ?
Comment utiliser le double-buffering software ?

L'affichage par défaut sur un composant awt, swing, ... de Java se fait à l'aide d'un simple buffer (on voit l'image se
tracer). Si on commence à faire des animations un peu complexes, il apparait dès lors des problèmes de scintillements
de l'image appelés clipping. Pour résoudre ce problème, on peut utiliser la méthode du double-buffering software (c'est
une couche de la JVM qui s'en charge). Le double-buffering est le fait d'avoir un buffer où l'on dessine en mémoire
et un buffer qui s'occupe de l'affichage. Les problèmes de rafraichissement, saut d'image et autres bugs visuels sont
ainsi éliminés.
Voici un programme très simple se servant du double-buffering software.
public class DoubleBufferingSoftware extends Frame{

// boucle d'affichage
RenderingThread renderingThread = new RenderingThread();
// buffer mémoire (2eme buffer)
Graphics buffer;
// image mémoire correspondante au buffer
Image image;
int x = 0; // coordonnée x de l'affichage du texte
public DoubleBufferingSoftware(){
//affichage
setSize( 400, 400 );
setVisible( true );
// on démarre la bouche d'affichage

renderingThread.start();
}
public void update(Graphics g){
paint(g);
}
public void paint( Graphics g ){
//création du buffer si il n'existe pas
if(buffer==null){
image = createImage(400,400);
buffer = image.getGraphics();
}
//on dessine sur le buffer mémoire
buffer.setColor( Color.white );
buffer.fillRect( 0, 0, 400, 400 );
buffer.setColor( Color.black );
buffer.drawString( "affichage d'une ligne de texte", x, 200 );
x++;
if(x>400) x = 0;
// finalement, le buffer mémoire est dessiné dans le buffer d'affichage
g.drawImage(image, 0, 0, this);
}
class RenderingThread extends Thread {
/**
* Ce thread appelle le rafraichissement de notre fenêtre
* toutes les 10 milli-secondes
*/
public void run(){
while(true){
try {
- 32 -
FAQ Java GUI
repaint();
sleep( 10 );
} catch ( Exception e ) {}
}
}
}
public static void main(String[] args){new DoubleBufferingSoftware();}
}
lien : Tutorial de Sun sur l'utilisation d'un double 'buffer'

lien : http://www.dgp.utoronto.ca/~mjmcguff/learn/java/07-backbuffer/
lien : Comment utiliser le double-buffering hardware ?
DoubleBufferingSoftware.java
Comment utiliser le double-buffering hardware ?

Les développeurs de Sun se sont rapidement rendu compte que le double-buffering software ne suffisait pas parfois,
notamment pour faire des jeux et d'autres applications graphiques très lourdes. Ils ont donc décider d'implémenter
l'utilisation de la carte graphique (VRAM au lieu de la RAM) afin de diminuer une grande partie des calculs. Le Page-
flipping, plus communément appelé double-buffering hardware est le fait d'utiliser un pointeur vidéo pour décider quel
buffer sert de mémoire et quel buffer sert d'affichage.
Principe : On créé un buffer qui va servir de buffer mémoire (celui où l'on dessine dessus), puis on créé un buffer
qui va servir de buffer graphique (celui qui s'occupe d'afficher ce qu'il contient à l'écran). On dessine sur le buffer
mémoire, des images, des textes, des dessins, ... pendant que le buffer graphique affiche ce qu'il contient. Puis, on swap
les buffers(en clair, on les inverse), le buffer mémoire devient le buffer graphique et le buffer graphique devient le buffer
mémoire. On les appelle habituellement: BackBuffer (buffer mémoire) et FrontBuffer (buffer graphique).
Voici la méthode qui permet d'utiliser la mémoire vidéo de votre carte graphique (VRAM) :
public class DoubleBufferingHardware extends Frame{

// boucle d'affichage
RenderingThread renderingThread = new RenderingThread();
// variable permettant d'utiliser la mémoire VRAM
BufferStrategy strategy;
// buffer mémoire où les images et les textes sont appliqués
Graphics buffer;
int x = 0; // coordonnée x de l'affichage du texte
public DoubleBufferingHardware(){
setSize( 400, 400 );
setVisible( true );
// inhibe la méthode courante d'affichage du composant

setIgnoreRepaint( true );
// on créé 2 buffers dans la VRAM donc c'est du double-buffering

createBufferStrategy( 2 );
// récupère les buffers graphiques dans la mémoire VRAM

strategy = getBufferStrategy();
buffer = strategy.getDrawGraphics();
renderingThread.start();
}
public void graphicalRender(){

buffer.setColor( Color.black );
- 33 -
FAQ Java GUI
buffer.fillRect( 0, 0, 400, 400 );

buffer.setColor( Color.white );
buffer.drawString( "affichage d'une ligne de texte", x, 200 );
x++;
if ( x > 400 ) x = 0;
//on envoie toutes les données du buffer mémoire vers le buffer d'affichage
strategy.show();
}
class RenderingThread extends Thread{

/**
* Ce thread appelle le rafraichissement de notre fenêtre
* toutes les 10 milli-secondes
*/
public void run(){
while( true ){
try {
// on appelle notre propre méthode de rafraichissement
graphicalRender();
sleep( 5 );
} catch ( Exception e ) {}
}
}
}
public static void main(String[] args){new DoubleBufferingHardware();}
}
lien : Tutorial de Sun sur l'utilisation d'un double 'buffer'

lien : http://www.dgp.utoronto.ca/~mjmcguff/learn/java/07-backbuffer/
DoubleBufferingHardware.java
Comment faire du triple-buffering hardware ?

La technique pour faire du triple-buffering hardware est très simple, il suffit de reprendre l'architecture pour le double-
buffering hardware et de changer ceci :
pour ceci:
Peut-on faire mieux que du triple-buffering en mettant plus que le chiffre 3 ?
La reponse est non car les cartes graphiques ne le gèrent pas, si vous le tentez, soit votre carte le supporte et tournera
en fait en triple-buffering, soit vous ferez planter votre programme ou aurez de gros bugs à l'affichage.
Inconvénients du triple-buffering ?
Et bien, les cartes actuelles tournent moins bien avec le triple que le double, résultat des courses, vous allez perdre en
images par seconde lors de l'affichage. Cette diminution en performance est de l'ordre de 3 ce qui n'est pas négligeable.
Avantages du triple-buffering ?
- 34 -
FAQ Java GUI
• Si le double-buffering ne suffisait pas à nettoyer tous les bugs d'affichage, le triple-buffering peut finir de les
nettoyer. Cependant, il est vraiment très rare que le double-buffering ne suffise pas à nettoyer les bugs graphiques.
• Dans le cas où vous faites du plein écran avec votre programme et que vous faites du double-buffering, vous avez
dû remarquer que le compteur d'images par secondes est de 70-85 (bizarrement comme votre rafraichissement
d'écran sur windows), ceci est dû au fait que le double-buffering se synchronise avec le rafraichissement de votre
écran. La solution pour passer outre cette synchronisation est le triple-buffering, celui-ci permet de casser la V-
sync (synchronisation des FPS avec le rafraichissement vertical de l'écran).

- 35 -
FAQ Java GUI
Sommaire > Les images

Comment faire une capture d'écran ?
La classe java.awt.Robot permet de faire facilement des captures d'écran.
Capture d'une zone :
Robot robot = new Robot();

BufferedImage image = robot.createScreenCapture(new Rectangle( 15, 15, 150, 150));
Capture de tout l'écran :

BufferedImage image = robot.createScreenCapture(
new Rectangle(java.awt.Toolkit.getDefaultToolkit().getScreenSize()) );
Capture d'une fenêtre :

BufferedImage image = robot.createScreenCapture(
new Rectangle( frame.getX(), frame.getY(), frame.getWidth(), frame.getHeight() )
);
Comment accéder à une image ?

Type de fichier supporté :
GIF, JPEG, PNG, BMP et WBMP. Pour lire des images encodées dans d'autres formats, vous devez utiliser une
bibliothèque externe.
Dans un applet :
La classe Applet fournit tout le nécessaire pour la lecture d'image :
Image java.applet.Applet.getImage(URL url);

Image java.applet.Applet.getImage(URL url, String name);
Dans une application :

Pour une application (Awt ou Swing), il faut utiliser les méthodes de la classe java.awt.Toolkit
/** Accès au toolkit : */

java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();
/** lecture de l'image : */
Image image = toolkit.getImage("fichier");
Image image = toolkit.getImage(url);
BufferedImage image = ImageIO.read( /* File, URL ou InputStream */ );
A noter qu'avec ImageIO, les images sont complètement chargées lors du retour de la méthode read(), alors que les
images renvoyées par le Toolkit sont chargées en arrière plan.
- 36 -
FAQ Java GUI
Dans un Jar :
Si l'image se trouve dans une archive, le plus simple est de laisser le ClassLoader trouver le fichier. Cette solution est
valable que l'image se trouve ou non dans une archive, il est donc préférable de toujours utiliser le ClassLoader afin de
limiter les problèmes lors du déploiement de l'application/applet.
java.net.URL url = getClass().getResource("chemin/nom.gif");
Comment enregistrer une image ?

Auteurs : Jean-Baptiste Bugeaud ,
JDK 1.4 :
Le JDK1.4 introduit le "imaging I/O framework" qui permet d'écrire des images dans la majorité des formats courants :
http://java.sun.com/j2se/1.4/docs/guide/imageio/index.html
JDK antérieur :
Java ne permettait pas d'enregistrer une image au format GIF, PNG ou JPEG. Il va falloir faire appel à des classes
extérieures permettant le codage de l'image.
• En Java 2, un 'package' est fourni pour enregistrer en JPEG (mais ne fait pas partie des librairies standard) :
http://java.sun.com/products/jdk/1.2/docs/guide/2d/api-jpeg/overview-summary.html
•
Pour le GIF : http://www.acme.com/java/software/Acme.JPM.Encoders.GifEncoder.html
•
Pour le PNG, un encodeur est disponible dans le code source de Batik : http://xml.apache.org/batik
lien : Une page très intéressante sur les différentes librairies disponibles pour la lecture et l'écriture des images.
Comment connaître les types d'images que l'on peut lire ou écrire ?
La classe ImageIO du package javax.imageio permet l'accès à ces informations. On peut ainsi connaître les types
d'images que l'on peut lire ou écrire en fonction du nom du format, du type MIME ou du suffixe d'un fichier. Voici
un exemple :
import javax.imageio.*;
public class FormatsImages{
public static boolean canRead(String format){
boolean type = ImageIO.getImageReadersByFormatName(format).hasNext();
boolean mime = ImageIO.getImageReadersByMIMEType(format).hasNext();
boolean suffixe = ImageIO.getImageReadersBySuffix(format).hasNext();
String infos = "Informations lecture "+format+" : ";
infos+="Format image = "+type+", ";
infos+="MIME = "+mime+", ";
infos+="Suffixe fichier = "+suffixe;
System.out.println(infos);
return type||mime||suffixe;
}
public static boolean canWrite(String format){
boolean type = ImageIO.getImageWritersByFormatName(format).hasNext();
boolean mime = ImageIO.getImageWritersByMIMEType(format).hasNext();
boolean suffixe = ImageIO.getImageWritersBySuffix(format).hasNext();
String infos = "Informations écriture "+format+" : ";
infos+="Format image = "+type+", ";
infos+="MIME = "+mime+", ";
infos+="Suffixe fichier = "+suffixe;
System.out.println(infos);
- 37 -
FAQ Java GUI
return type||mime||suffixe;
}
}
Vous pouvez utiliser ces deux méthodes statiques pour vérifier n'importe quel format.
canRead("gif");
canRead("jpg");
canRead("bmp");
canRead("image/jpeg");
//quelques vérifications sur les possibilités de lecture
canWrite("gif");
canWrite("jpg");
canWrite("bmp");
canWrite("image/jpeg");
//quelques vérifications sur les possibilités d'écriture
Vous pouvez avoir accès à tous les types d'images que vous pouvez lire ou écrire grâce aux méthodes
getReaderFormatNames et getWriterFormatNames. les mêmes méthodes sont disponibles pour les types MIME.
String[] formatsLecture = ImageIO.getReaderFormatNames();

String[] formatsEcriture = ImageIO.getWriterFormatNames();
//affichage des formats d'images lisibles
System.out.println("Formats d'images disponibles en lecture");
for(int i=0;i<formatsLecture.length;i++){
System.out.println(formatsLecture[i]);
}
System.out.println("Formats d'images disponibles en écriture");
for(int i=0;i<formatsEcriture.length;i++){
System.out.println(formatsEcriture[i]);
}

lien : Comment enregistrer une image ?
Comment mettre une image en fond de JFrame ?

L'ajout d'image en fond de composant n'est pas possible avec les classes de base de Swing. Heureusement, la réalisation
d'une telle classe n'est pas compliquée, il suffit de créer un nouveau composant héritant de JComponent et de surcharger
la méthode paintComponent.
La méthode paintComponent(Graphique g) est chargée de dessiner le composant ; les composants fils seront dessinés
par dessus plus tard.
Exemple (Swing):
public class MonPanel extends JComponent {
/** variable de classe contenant l'image à afficher en fond */

private Image bg;
/** Surcharge de la fonction paintComponent() pour afficher notre image */

public void paintComponent(Graphics g) {
g.drawImage(bg,0,0,null);
}
}
- 38 -
FAQ Java GUI
Exemple (AWT):
public class MonPanel {
/** variable de classe contenant l'image à afficher en fond */

private Image bg;
/** Surcharge de la fonction paint() pour afficher notre image */

public void paint(Graphics g) {
g.drawImage(bg,0,0,null);
}
}
Note :
Vous pouvez placer le composant dans la JFrame en utilisant la méthode setContentPane(moncomposant).
Fichier joint :
Vous trouvez, dans les liens ci-dessous, un exemple complet d'implémentation d'un tel objet, permettant d'afficher
l'image en mosaïque ou centrée.
Extension de JPanel pour afficher des images en arrière-plan. Exemple d'utilisation de la classe.
Comment convertir une image en une instance de BufferedImage ?

Beaucoup d'opérations de manipulation d'image ne travaillent que sur des java.awt.image.BufferedImage. La vie étant
parfois mal faite, il est courant de trouver dans l'API des méthodes nous retournant des images, mais assez rarement
des bufferedImages, il nous faut donc convertir ces images... Voici une méthode qui s'occupe de tout :
BufferedImage toBufferedImage(Image image) {

/** On test si l'image n'est pas déja une instance de BufferedImage */
if( image instanceof BufferedImage ) {
return( (BufferedImage)image );
} else {
/** On s'assure que l'image est complètement chargée */
image = new ImageIcon(image).getImage();
/** On crée la nouvelle image */

BufferedImage bufferedImage = new BufferedImage(
image.getWidth(null),
image.getHeight(null),
BufferedImage.TYPE_INT_RGB );
Graphics g = bufferedImage.createGraphics();
g.drawImage(image,0,0,null);
g.dispose();
return( bufferedImage );
}
}
Cette façon ne préserve pas la transparence de l'image de base.
- 39 -
FAQ Java GUI
Comment créer un objet de type Image depuis une BufferedImage ?

Comme BufferedImage étend image, on peut tout simplement employer une BufferImage en tant qu'Image.
BufferedImage buf = ...;

Image image = buf;
Comment convertir une image couleurs en niveaux de gris ?

Les modifications de couleur d'une image sont assurées par la classe java.awt.image.ColorConvertOp qui travaille à
partir de java.awt.image.BufferedImage.
ColorConvertOp op = new ColorConvertOp(

ColorSpace.getInstance(ColorSpace.CS_GRAY),
null);
BufferedImage imageGrise = op.filter(bufferedImage,null);
lien : Comment convertir une image en une instance de BufferedImage ?
Comment rendre floue une image ?

L'algorithme permettant de rendre une image floue travaille très simplement : la couleur d'un pixel est calculée en
faisant la moyenne pondérée de sa couleur et de celles de ses voisins. Il suffit de modifier les coefficients et le nombre
de voisins pour intervenir sur le résultat, plus le poids des voisins est important, plus l'image sera floue. De plus, on
peut choisir le poids d'un voisin en fonction de sa position, ce qui permet d'attribuer des poids différents et d'obtenir
des résultats surprenants...
float[ ] matrice = {
0.1f, 0.1f, 0.1f,
0.1f, 0.2f, 0.1f,
0.1f, 0.1f, 0.1f
};
BufferedImageOp op = new ConvolveOp(new Kernel(3,3,matrice));
BufferedImage nouvelleImage = op.filter(bufferedImage, null);
lien : Comment convertir une image en une instance de BufferedImage ?
Comment effectuer des transformations sur une image en mémoire ?

Il n'est pas possible d'effectuer de transformation directement sur une image mémoire, il faut créer un nouvelle image
et dessiner la version transformée dans cette nouvelle image.
/** Création d'une nouvelle image */

BufferedImage nouvelleImage = new BufferedImage(
- 40 -
FAQ Java GUI
imageSource.getWidth(),
imageSource.getHeight(),
imageSource.getType());
Graphics2D g2d = nouvelleImage.createGraphics();
/** préparation de la transformation */
AffineTransform at = new AffineTransform();
at.rotate(angle,x,y);
g2d.drawImage(imageSource,at,null);
g2d.dispose();
Comment manipuler directement les pixels de mon image ?

C'est à mon avis une assez mauvaise idée. Les méthodes de la classe java.awt.Graphics sont généralement des appels
directs des fonctions de la carte vidéo ou d'une bibliotheque graphique (DirectX ou autre), bref.
Lecture d'un pixel :
/** Lecture d'un seul pixel : */

int rgb = bufferedImage.getRGB(x,y);
/** Lecture de tous les pixels : */

int w = bufferedImage.getWidth();
int h = bufferedImage.getHeight();
int[] rgbs = new int[w*h]; /** on crée l'espace neccessaire */
bufferedImage.getRGB(0,0,w,h,rgbs,0,w);
Ecriture d'un pixel :
/** Ecriture d'un seul pixel : */

bufferedImage.setRGB(x,y,rgb);
/** Ecriture de tous les pixels : */

int w = bufferedImage.getWidth();
int h = bufferedImage.getHeight();
int[] rgbs = new int[w*h];
bufferedImage.setRGB(0,0,w,h,rgbs,0,w);
lien : Qu'est-ce que l'encodage entier RGBA des couleurs d'une image ?
Qu'est-ce que l'encodage entier RGBA des couleurs d'une image ?

Pour des raisons de performance on utilise un seul entier pour coder les trois couleurs primaires (rouge, vert, bleu) et
la composante alpha (le niveau de transparence). Chaque composante est codée sur 8 bits (bleu 0-7, vert 8-15, rouge
16-23, alpha 24-31).
/** Lecture manuelle des composantes : */

int rgb = bufferedImage.getRGB(x,y);
int alpha = (rgb >>24 ) & 0xFF;
int rouge = (rgb >>16 ) & 0xFF;
int vert = (rgb >> 8 ) & 0xFF;
int bleu = rgb & 0xFF;
/** Construction d'un pixel : */

int rgb = (alpha<<24)+(rouge<<16)+(vert<<8)+bleu;
- 41 -
FAQ Java GUI
/** Les composantes doivent obligatoirement être comprises dans l'intervalle 0-255 */
lien : Comment manipuler directement les pixels de mon image ?
Comment redimensionner une image ?

Auteurs : Pierre-Yves Varoux ,
Redimensionnemant d'une image :
/**
* Redimensionne une image.
*
* @param source Image à redimensionner.
* @param width Largeur de l'image cible.
* @param height Hauteur de l'image cible.
* @return Image redimensionnée.
*/
public static Image scale(Image source, int width, int height) {
/* On crée une nouvelle image aux bonnes dimensions. */
BufferedImage buf = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
/* On dessine sur le Graphics de l'image bufferisée. */

Graphics2D g = buf.createGraphics();
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g.drawImage(source, 0, 0, width, height, null);
g.dispose();
/* On retourne l'image bufferisée, qui est une image. */

return buf;
}
Redimensionnemant d'une BufferedImage :
/** Effectue une homothétie de l'image.

*
* @param bi l'image.
* @param scaleValue la valeur de l'homothétie.
* @return une image réduite ou agrandie.
*
*/public static BufferedImage scale(BufferedImage bi, double scaleValue) {
AffineTransform tx = new AffineTransform();
tx.scale(scaleValue, scaleValue);
AffineTransformOp op = new AffineTransformOp(tx,
AffineTransformOp.TYPE_BILINEAR);
BufferedImage biNew = new BufferedImage( (int) (bi.getWidth() * scaleValue),
(int) (bi.getHeight() * scaleValue),
bi.getType());
return op.filter(bi, biNew);
Note :
- 42 -
FAQ Java GUI
Un coefficient supérieur à 1 correspond à un agrandissement, un coefficient inférieur à 1 correspond à une réduction.
Comment changer l'icone de la fenêtre de mon application ?

Auteurs : Clément Cunin , bulbo ,
L'icone d'une application apparaît à divers endroits en fonction du système d'exploitation. Sous windows, on la retrouve
en haut à gauche de la fenêtre, et dans la barre des taches. Par défaut, il s'agit de la tasse de café de Java. Il est très
facile de la personnaliser en utilisant la méthode setIconImage(java.awt.Image) des classes javax.swing.JFrame.
Cette méthode n'est pas disponible pour la classe JDialog, les dialogues utilisent automatiquement l'icone de la frame
parente.
Image icone = Toolkit.getDefaultToolkit().getImage("./monImage.jpg");

maFenetre.setIconImage(icone);
Si l'image n'apparaît pas, c'est certainement que le paramètre image a une valeur 'null'.
Une autre raison pour laquelle cette image n'apparaitrait serait un problème au niveau de la transparence avec les
images PNG qui ne sont pas gérés par tous les OS, certains OS vont l'afficher mais supprimmer la transparence et
d'autres ne pas l'afficher.
De plus, certains OS ne supportent simplement pas les images de type PNG, transparence ou non.
Comment obtenir une Image de mon composant graphique ?

La classe Component a la capacité de peindre l'intégralité de son contenu dans un Graphics, grâce à la méthode paintAll.
Voici une méthode permettant de récuperer l'Image d'un Component quelconque :
public Image getImage(Component component){

if(component==null){return null;}
int width = component.getWidth();
int height = component.getHeight();
BufferedImage image = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
component.paintAll(g);
g.dispose();
return image;
}
Comment savoir si une image a des pixels transparents ?

Cette information est relativement simple à obtenir si l'on travaille avec une instance de BufferedImage. Si c'est le cas,
on peut directement demander au ColorModel de l'image de nous donner l'information. Dans le cas contraire, on est
obligé de passer par un PixelGrabber.
Voici une méthode permettant de récuperer cette information quelque soit le type de l'image :
- 43 -
FAQ Java GUI
public boolean alphaLayer(Image image){

ColorModel modele = null;
if(image instanceof BufferedImage){
// si on a affaire à une BufferedImage on regarde son ColorModel
BufferedImage bi = (BufferedImage)image;
modele = bi.getColorModel();
}else {
// on traite l'image pixel par pixel afin de récuperer un ColorModel
PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
try{
// on découpe donc l'image pixel par pixel
pg.grabPixels();
}catch (InterruptedException e) {
e.printStackTrace();
}
modele = pg.getColorModel();
}
return modele.hasAlpha();
}
Comment dessiner et écrire sur une BufferedImage ?

// on crée auparavant la BufferedImage avec le nom bi
Graphics2D g2d = bi.createGraphics(); // on récupère le contexte graphique de la BufferedImage

g2d.setColor( Color.red ); // on met l'état de couleur rouge à la BufferedImage
g2d.fillOval( 30, 30, 100, 100 ); // on dessine un cercle de centre x=30 y=30 et de rayon=100
g2d.dispose(); //on libère la mémoire utilisée pour le contexte graphique
Si vous ne faites pas de dispose() sur le contexte graphique et que vous rafraichissiez beaucoup celui-ci durant
l'utilisation du programme, votre programme sera de plus en plus gourmant en mémoire.
Comment combiner deux images ?

Auteurs : Zedros , Baptiste Wicht ,
Pour combiner 2 images, il suffit de dessinner la deuxième image sur la première image. Pour cela, il faut récupérer
le Graphics2D de la première image et ensuite configurer l'anti-aliasing et la interpolation sur le Graphics2D. On peut
ensuite tout simplement dessinner la deuxième image sur la première à l'endroit voulu.
Voilà donc ce que ça donne :
public static BufferedImage addImage(BufferedImage image1, BufferedImage image2){

Graphics2D g2d = image1.createGraphics();
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
g2d.drawImage(image2, 0, 0, null);
g2d.dispose();
return image1 ;
}
- 44 -
FAQ Java GUI
Sommaire > AWT et Swing
- 45 -
FAQ Java GUI
Sommaire > AWT et Swing > Généralités

Quel sont les différences entre Awt et Swing ?
Tout d'abord, il faut rappeler que la librairie AWT a été développée pour la première sortie de Java version 1.0 du jdk
alors que Swing n'est apparue qu'à la version 1.2 du jdk (soit Java 2). Il en résulte donc des différences fondamentales
de conception entre les deux librairies.
Composant AWT :
Un composant AWT lors de sa création est associé à une fenêtre distincte (un homologue, peer en anglais) gérée par
le système d'exploitation sous-jacent. Et c'est cet homologue qui est responsable de son apparence. Cette "manière"
de faire, bien qu'elle ait fait ses preuves et qu'elle ait permis au langage Java de s'imposer, est très lourde (perte de
performance, et consommation excessive de mémoire). C'est pour cette raison que l'on qualifie les composants AWT
par heavyweight (littéralement, poids lourds)
Composant Swing :
Par opposition, les composants Swing sont simplement dessinés à l'intérieur de leur conteneur comme s'il s'agissait d'une
image, et aucun homologue du système sous jacent ne leur est affecté. C'est pourquoi ils sont qualifiés de lightweight
(composants allégés).
Nous noterons également que lors du développement avec AWT il suffit d'ajouter les composants directement au Top-
level Container (Conteneur de Haut Niveau) tel que Frame, Applet, ..., alors que sous Swing il est nécéssaire de les
ajouter à un volet de contenu (Cf : javax.swing.JRootPane). De manière plus parlante je veux parler du :
jframe.getContentPane().add(monComposant);
Voila, ces quelques différences ne sont bien sûr pas exhaustives, Swing posséde bien d'autres avantages, je ne citerai
que : la gestion de bordure, les info-bulles, le défilement, les Look And Feel, de nouveaux LayoutManager, ainsi que
l'architecture MVC (Model-View-Control). Maintenant que l'on a conscience de ces différences, une question reste tout
de meme en suspens... Peut-on mélanger Awt et Swing ?
Peut-on mélanger Awt et Swing ?

NON
Il est impossible d'obtenir un rendu graphique correct dans une application qui mélange AWT et SWING. Des
problèmes de superposition empêchent toute collaboration.
Explication :
Avant toute chose, il faut bien comprendre les différence entre Awt et Swing : Quel sont les différences entre Awt et
Swing ?.
Le composant JFrame comprend un objet fils qui prend en charge tout ce qui concerne le graphique, il s'agit d'une
instance de JRootPane. Le composant JRootPane est lui même structuré. Il contient un volet structuré en couche
(instance de JLayeredPane) et un volet structuré en pellicule (GlassPane).
- 46 -
FAQ Java GUI
• Le composant LayeredPane permet d'insérer une barre de menu ainsi que tout autre composant (cela fait
référence au fameux contentPane de jframe.getContentPane ()). il est également chargé du Z-ordering (algorithme
permettant de ne dessiner que les parties non cachées, suite aux superpositions de composant).
• Le composant GlassPane représente une pellicule qui recouvre tout et qui par exemple peut intercepter tous les
événements souris de l'interface graphique.
Démonstration :
import javax.swing.*;
import java.awt.*;
public class AWTSwing {

private JComboBox combo; // Composant Swing
private Button bouton; // Composant AWT
public AWTSwing () {
JFrame frame = new JFrame ("Peut-on melanger Awt & Swing ?");
frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
frame.setBounds (300, 300, 200, 300);
String [] a = {"oui", "non", "peut etre"};

combo = new JComboBox (a);
frame.getContentPane ().add (combo, BorderLayout.NORTH);
bouton = new Button ("Coucou");
frame.getContentPane ().add (bouton, BorderLayout.CENTER);
frame.setVisible (true);
}
public static void main (String argv []) {

new AWTSwing ();
}
}
Lorsque l'on ouvre le menu contextuel du JComboBox, ce dernier est caché par le composant bouton de type
java.awt.Button.
• Le rendu graphique du composant "bouton" issu de la librairie AWT est délégué à son homologue (peer), par
conséquent la position Z est la même que celle de la Frame (soit de haut niveau)
• Alors que le composant "combo" de type JComcoBox (Swing) n'est que "dessiné" comme une image sur le
conteneur (soit de bas niveau)
- 47 -
FAQ Java GUI
La seule solution envisageable est d'uniformiser le code sur la librairie graphique utilisée, soit tout AWT, soit tout
Swing !
Comment faire un minuteur (timer) facilement ?

On peut utiliser la classe java.lang.Thread ou implémenter l'interface java.lang.Runnable, mais suivant les cas de
figure cela représente beaucoup de code et de contraintes. En effet, les instructions qui affectent ou dépendent d'un
composant graphique Swing doivent être effectuées par le processus d'évènement (the event-dispatching thread).
Par conséquent si l'on utilise la classe Thread ou l'interface Runnable il est nécessaire d'utiliser les méthodes :
invokeLater(java.lang.Runnable) ou invokeAndWait(java.lang.Runnable)" javax.swing.SwingUtilities.
La classe Timer :
La classe javax.swing.Timer remplace avantageusement l'utilisation directe de thread. Elle génère un évènement à
intervalles réguliers (à la milli-seconde). C'est le "event-dispatching thread" qui exécute l'évènement, donc on peut
directement modifier des objets graphiques.
Méthodes importantes :
le constructeur de javax.swing.Timer :
public Timer (int delay, ActionListener listener);

/** delay = l'intervalle de temps entre chaque évènement.
* listener = l'objetécouteur de ces evènements.
*/
méthode permettant de lancer le processus :
public void start();
méthode permettant de stopper le processus :
public void stop();
Note :
Cette méthode est à utiliser uniquement si le traitement à faire est court en temps d'exécution sinon on aura une interface
non réactive pendant le traitement ....
Exemple d'utilisation pour faire un compteur.
Mon menu contextuel s'affiche hors de l'écran, que faire ?

JDK 1.3 et inférieur :
Lorsque l'on utilise la méthode show(java.awt.Component, int, int) pour afficher un javax.swing.JPopupMenu, les
coordonnées correspondent au coin haut-gauche du menu. Si ces coordonnées sont trop près du bord de l'écran, une
partie du menu est alors cachée. Nous allons donc surcharger la méthode show() pour que les coordonnées soient
corrigées si le message est trop proche du bord de l'écran.
class MonPopupMenu extends JPopupMenu {
- 48 -
FAQ Java GUI
public void show(Component invoker, int x, int y) {

/**Dimension de l'écran */
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
/** Dimension du Menu popup */
Dimension popupSize = this.getPreferredSize();
/** Position en x,y du popup à l'écran (pour le .show) */
double xPopupEcran = invoker.getLocationOnScreen().getX() + x;
double yPopupEcran = invoker.getLocationOnScreen().getY() + y;
/** Si le popup déborde de l'écran sur la droite on décale sur x */

if ((xPopupEcran + popupSize.getWidth()) > screenSize.getWidth()) {
x = x - (int)popupSize.getWidth();
}
/** Si le popup déborde de l'écran sur le bas on décale sur y */

if ((yPopupEcran + popupSize.getHeight()) > screenSize.getHeight()) {
y = y - (int)popupSize.getHeight();
}
/** On affiche le popup à l'endroit judicieusement calculé :) */

super.show(invoker, x, y);
}
}
JDK 1.4 :
Ce bug a été résolu dans la version 1.4 de l'API. Le correctif n'est pas nécessaire.
Comment mettre une image dans un bouton (AWT) ?

Ce n'est pas directement possible en AWT, il faut créer sa propre classe MyButton permettant de le faire en dérivant
par exemple Component pour faire un lightweigth component.
Comment mettre une image dans un bouton (Swing) ?

Auteurs : strab ,
Il y a un constructeur de JButton et une méthode qui permettent d'avoir le résultat voulu en donnant l'image en
argument sous forme de Icon
JButton bouton = new JButton(new ImageIcon("images/bouton.gif"));
ou
bouton.setIcon(new ImageIcon("images/bouton.gif"));
Comment rendre un JButton transparent ?

Auteurs : bulbo ,
La classe AbstractButton définit un ensemble de méthodes permettant d'indiquer comment doit se dessiner le bouton.
Ainsi, on peut indiquer, par exemple, si on désire dessiner les rebords ou le contenu. Voici un exemple.
Le code ci-dessous dessine un bouton transparent, seul le texte sera affiché en rouge.
- 49 -
FAQ Java GUI
JButton printButton = new JButton("Imprimer");

printButton.setForeground(Color.red);
printButton.setFocusPainted(false);
printButton.setBorderPainted(false);
printButton.setContentAreaFilled(false);
Comment imprimer l'ensemble d'un Container (JDK 1.1.x) ?

Voilà un début de code permettant d'imprimer un Container 'cont'.
/** Récupère le travail et affiche la boite de dialogue d'impression */

PrintJob job = getToolkit().getPrintJob(frame_parent_pour_le_dialogue,"essai", null);
if (job != null) {
/** Recupere le Graphics dans lequel on va ecrire */
Graphics g = job.getGraphics();
if (g != null) {
/** Sur le Container imprime l'ensemble de ses Components */
cont.printAll(g);
g.dispose();
}
/** Finit le travail */
job.end();
}
Comment enregistrer un Component en tant qu'image ?

Auteurs : fxjtarga , Baptiste Wicht ,
Pour enregistrer un object de type Component en tant qu'image, il faut commencer par dessinner ce composant dans
une BufferedImage puis on va écrire cette image dans un fichier.
Voici un exemple qui permet d'enregistrer un composant sous forme d'image JPeg :
public void saveImage(Component component, File destination){

BufferedImage image = new BufferedImage(component.getWidth(), component.getHeight(),
BufferedImage.TYPE_INT_RGB);
Graphics2D g2d = image.createGraphics();
if(!component.isOpaque()){
Color bg = component.getBackground();
bg = (bg.getAlpha() < 255) ? new Color(bg.getRed(), bg.getGreen(), bg.getBlue()) : bg;
Color color = g2d.getColor();

g2d.setColor(bg);
g2d.fillRect(0, 0, component.getWidth(), component.getHeight());
g2d.setColor(color);
}
component.paint(g2d);
g2d.dispose();
try {
ImageIO.write(image, "jpeg", destination);
} catch (IOException e) {
e.printStackTrace();
}
- 50 -
FAQ Java GUI
Lors d'un traitement long, l'affichage se fige, que faire ?

Quand et pourquoi ?
Ce problème est très classique lors d'un long traitement dans une application graphique. En Java, un processus est
chargé de toutes les opérations liées à l'affichage et à la gestion des évènements, le processus "the event dispatching
thread". Si une application utilise ce processus pour faire un traitement de plusieurs minutes, c'est autant de temps où
l'application ne sera plus réactive aux actions de l'utilisateur, ni aux mise à jour graphiques (d'une barre de progression
par exemple).
Solution :
La solution est assez simple à comprendre : tout traitement long doit être effectué par un autre processus.
Pourquoi ma barre de progression se remplit d'un coup ?

Pour mieux comprendre le problème : Lors d'un traitement long, l'affichage se fige, que faire ?
Voici deux codes sources Java commentés.

JProgress : la mauvaise méthode (la vôtre ?)
JProgress2 = une solution
lien : Didacticiel de Sun sur les JProgressMonitor et les JProgressBars

JProgress.java JProgress2.java
Comment changer le Look & Feel de mon aplication ?

Pour faire cela, il faut utiliser la classe UIManager. Par exemple :
try {
UIManager.setLookAndFeel("mon.look.and.Feel");
//on passe au UIManager le nom complet de la classe du Look and Feel
//naturellement, celle-ci doit être disponible dans le CLASSPATH
} catch (InstantiationException e) {
} catch (ClassNotFoundException e) {
} catch (UnsupportedLookAndFeelException e) {
} catch (IllegalAccessException e) {}
Si vous changez le look and feel de votre application en cours d'exécution, vous devez la rafraîchir en utilisant
SwingUtilities.updateComponentTreeUI. Voici un exemple changeant le look and feel de l'application pour le look and
feel natif (celui naturellement utilisé par le système).
JFrame frame = new JFrame();

// etc.
- 51 -
FAQ Java GUI
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
SwingUtilities.updateComponentTreeUI(frame);
//force chaque composant de la fenêtre à appeler sa méthode updateUI
} catch (InstantiationException e) {
} catch (ClassNotFoundException e) {
} catch (UnsupportedLookAndFeelException e) {
} catch (IllegalAccessException e) {}
lien : Comment lister les Look & Feel disponibles ?
Comment lister les Look & Feel disponibles ?

Les look and feels enregistrés sont disponibles avec la méthode getInstalledLookAndFeels de la classe UIManager. Voici
un exemple récupérant l'ensemble des look and feels sous forme de Map, dont les clefs sont les noms des L&F et les
valeurs les noms des classes correspondantes.
public Map getLookAndFeelsMap(){

UIManager.LookAndFeelInfo[] info = UIManager.getInstalledLookAndFeels();
Map map = new TreeMap();
for(int i=0; i<info.length;i++){
String nomLF = info[i].getName();
String nomClasse = info[i].getClassName();
map.put(nomLF,nomClasse);
}
return map;
}
Pour un exemple utilisant cette méthode regardez le fichier ci-dessous.
lien : Comment changer le Look & Feel de mon aplication ?

Menu Look and Feel
Comment modifier un élément du LookAndFeel ?

Auteurs : morph41 ,
Avant tout affichage, il faut appeler la méthode put(Object, Object) de la classe UIManager. Le 1er paramètre
correspond à l'objet à modifier, et le second est la valeur à lui donner.
Par exemple, pour mettre en blanc le fond de tous les JPanel :
UIManager.put("Panel.background", new ColorUIResource(Color.WHITE));
lien : Liste d'éléments modifiables d'un Look And Feel
Comment enlever le style gras du LookAndFeel par défaut ?

Auteurs : adiGuba ,
Metal, Le LookAndFeel par défaut, utilise du texte en gras dans la plupart des composants Swing. Le résultat n'est pas
forcément des plus esthétiques.
- 52 -
FAQ Java GUI
Heureusement il est possible de rémédier à cela en modifiant la propriété swing.boldMetal, soit directement via la classe
UIManager :
// Ne pas utiliser de texte en gras (LnF Metal) :

UIManager.put("swing.boldMetal", Boolean.FALSE);
Soit en passant par les variables systèmes si l'on n'a pas accès au code source :
java -Dswing.boldMetal=false ... (les autres paramètres standards)
lien : Les look and Feel

lien : Comment modifier un élément du LookAndFeel ?
Comment définir les touches par défaut ENTER et ESCAPE ?

Auteurs : laffreuxthomas ,
Vous souhaitez associer des boutons de votre interface graphique aux touches ENTER et ESCAPE, et ceci quel que soit
le composant qui ai le focus lors de l'appui sur ces touches ?
Pour la touche ENTER c'est très simple parce que c'est fait pour :
// - pour une JFrame

maFrame.getRootPane().setDefaultButton(monBouton)
// - pour une JDialog
monDialog.getRootPane().setDefaultButton(monBouton)
Pour la touche ESCAPE c'est plus compliqué, une solution est d'associer du code à l'évènement (et non pas un bouton) :
private void configureRootPane(JRootPane rootPane) {

InputMap inputMap = rootPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "escPressed");
rootPane.getActionMap().put(
"escPressed",
new AbstractAction("escPressed") {
public void actionPerformed(ActionEvent actionEvent) {
onKeyEscape();
}
});
}
...
// - pour une JFrame

configureRootPane(maFrame.getRootPane());
// - pour une JDialog
configureRootPane(monDialog.getRootPane());
- 53 -
FAQ Java GUI
La méthode "configureRootPane" ne devrait être appelée qu'une fois, par exemple juste après l'instanciation de votre
conteneur. Il vous reste à implémenter la méthode "onKeyEscape", qui sera appelée lors de chaque appui sur ESCAPE.
Comment ajouter un KeyListener à un objet JComboBox éditable ?

Auteurs : schniouf ,
Il faut en fait ajouter le KeyListener au composant permettant l'édition du combo box, en l'occurrence un JTextField :
Component c = comboBox.getEditor().getEditorComponent() ;
JTextField textField = (JTextField) c ;
textField.addKeyListener( new KeyListener() ) ;
Comment changer la langue d'un JComponent sans changer la langue de tout le programme ?
Auteurs : Jack Huser ,
Il suffit d'utiliser la méthode setDefaultLocale de la classe JComponent.
Exemple, si j'ai un programme en français mais que je veux avoir tous mes JFileChooser en anglais :
JFileChooser.setDefaultLocale(new Locale("en","US"));
// ou JFileChooser.setDefaultLocale(Locale.US)
Comment changer le background de certaines lignes d'une JList ?

Auteurs : seiryujay , Baptiste Wicht ,
Pour changer le background de certaines lignes d'une Jlist, il faut utiliser un ListCellRenderer personnalisé :
class MyCellRenderer extends JLabel implements ListCellRenderer {
public Component getListCellRendererComponent(

JList list,
Object value, // value to display
int index, // cell index
boolean isSelected, // is the cell selected
boolean cellHasFocus) // the list and the cell have the focus
{
setText(value.toString());
if (isSelected) {
setBackground(list.getSelectionBackground());
setForeground(list.getSelectionForeground());
}
else {
setBackground(list.getBackground());
setForeground(list.getForeground());
}
// Ici, il faut tester si on veut changer la couleur et changer par la

// couleur de notre choix
if (taCondition == true){
setBackground(couleur);
}
- 54 -
FAQ Java GUI
setEnabled(list.isEnabled());
setFont(list.getFont());
setOpaque(true);
return this;
}
}
Après, il suffit d'appliquer ce renderer à la JList :
JList list = new JList();

list.setCellRenderer(new MyCellRenderer());
et le tour est joué.
Comment changer la langue de mon appllication et toutes les conversions qui vont avec ?
Auteurs : Jack Huser ,
Il suffit de changer le Locale de la JVM au démarrage.
Locale.setDefault(Locale.US);// par exemple si on est en français et que l'on veut l'anglais (USA)
ou
Locale.setDefault(new
Locale("en", "US"));// par exemple si on est en français et que l'on veut de l'anglais (USA)
En général:
Locale loc = new Locale(String langue, String pays)
Dans cet exemple, on aura donc les chiffre décimaux avec des points et non des virgules.
lien : Classe java.util.Locale
Comment disposer les composants en couche ou en niveaux ?

Auteurs : gifffftane ,
Il y 2 manières de faire pour disposer ses composants en couche ou en niveaux :
• En utilisant un JLayeredPane. Cette solution est utilisable avec Swing.

• En utilisant le principe du ZOrder. Cette solution est valable pour AWT et Swing, pour toutes les classes
descendant de Container.
Nous allons prendre comme exemple la disposition de deux JLabels l'un au dessus de l'autre.
Premièrement, avec un JLayeredPane :
import javax.swing.JLabel;
import javax.swing.JLayeredPane;
- 55 -
FAQ Java GUI
public class CouchesAvecJLayer extends javax.swing.JFrame {

public CouchesAvecJLayer() {
initComponents();
}
private void placeLesCouches(){

JLayeredPane layered;
JLabel dessous;
JLabel dessus;
layered = new JLayeredPane();

// Comme il n'y a pas vraiment de layout avec un JLayeredPane
// il faut gérer soi même les tailles et positions.
layered.setPreferredSize(new java.awt.Dimension(400, 200));
// (pour simplifier on ne gère pas les positions, tout ira les
// uns sur les autres).
dessous = new JLabel("en dessous ! (et en partie masqué)");

dessous.setSize(dessous.getPreferredSize());
layered.add(dessous, new Integer(0));
dessus = new JLabel("au dessus !");
// Inutile, pour jouer avec l'opacité de façon à mieux faire

// apparaitre ce qui est dessus/dessous
dessus.setOpaque(true);
layered.add(dessus, new Integer(1));

add(layered);
pack();
}
@SuppressWarnings("unchecked")
private void initComponents() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
pack();
}
public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
CouchesAvecJLayer couches;
couches = new CouchesAvecJLayer();

couches.placeLesCouches();
couches.setVisible(true);
}
});
}
}
Puis en jouant avec le ZOrder des composants :
import javax.swing.JLabel;
import javax.swing.JPanel;
public class CouchesAvecZOrder extends javax.swing.JFrame {

public CouchesAvecZOrder() {
initComponents();
}
private void placeLesCouches(){

JPanel zpanel;
JLabel dessous;
JLabel dessus;
- 56 -
FAQ Java GUI
zpanel = new JPanel();
// Le réglage du layout est particulier avec le ZOrder.

// Pour simplifier on le supprime.
zpanel.setLayout(null);
zpanel.setPreferredSize(new java.awt.Dimension(400, 200));

dessus = new JLabel("au dessus !");
// Comme il n'y a plus de layout on doit gérer les tailles.

dessus.setSize(dessus.getPreferredSize());
// Inutile, pour jouer avec l'opacité de façon à mieux faire

// apparaitre ce qui est dessus/dessous
dessus.setOpaque(true);
zpanel.setComponentZOrder(dessus, 0);
dessous = new JLabel("en dessous ! (et en partie masqué)");
dessous.setSize(dessous.getPreferredSize());
zpanel.setComponentZOrder(dessous, 1);
add(zpanel);
pack();
}
@SuppressWarnings("unchecked")
private void initComponents() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
pack();
}
public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
CouchesAvecZOrder couches;
couches = new CouchesAvecZOrder();

couches.placeLesCouches();
couches.setVisible(true);
}
});
}
}
- 57 -
FAQ Java GUI
Sommaire > AWT et Swing > JFileChooser

Comment traduire le JFileChooser ou le JColorChooser en français ?
Ces boîtes de dialogue ne suivent pas la locale de votre système. En fait chaque texte affiché dans ces boîtes de dialogue
correspond à une ressource du UIManager. Il va donc falloir changer ces ressources.
Par exemple pour le JFileChooser vous pouvez dans votre code faire :
UIManager.put("FileChooser.saveButtonText","Enregistrer");
UIManager.put("FileChooser.openButtonText","Ouvrir");
UIManager.put("FileChooser.cancelButtonText","Annuler");
UIManager.put("FileChooser.updateButtonText","Actualiser");
UIManager.put("FileChooser.helpButtonText","Aide");
UIManager.put("FileChooser.saveButtonToolTipText","Enregistre le fichier");
Comment visualiser avec un JFileChooser le poste de travail, le bureau, etc. ?

Auteurs : bulbo ,
La classe FileSystemView, du package javax.swing.filechooser, permet de récupérer notamment le home directory et
le répertoire par défaut. Sous windows, ces deux répertoires correspondent au bureau et à "Mes documents". Vous
pouvez donc facilement positionner le JFileChooser. Par exemple :
FileSystemView vueSysteme = FileSystemView.getFileSystemView();

//récupération des répertoires
File defaut = vueSysteme.getDefaultDirectory();
File home = vueSysteme.getHomeDirectory();
//création et affichage des JFileChooser
JFileChooser defautChooser = new JFileChooser(defaut);
defautChooser.showOpenDialog(null);
JFileChooser homeChooser = new JFileChooser(home);
homeChooser.showOpenDialog(null);
Par contre, il n'existe pas de méthode toute faite pour se positionner de manière à voir tous les disques. Vous devrez
faire comme ceci :
JFileChooser chooser = new JFileChooser();

chooser.setCurrentDirectory(new File("/"));
chooser.changeToParentDirectory();
chooser.showOpenDialog(null);
Comment filtrer les fichiers acceptés par un JFileChooser ?

Pour filtrer les fichiers affichés par un JFileChooser vous devez utiliser un FileFilter (package javax.swing.filechooser).
Cette classe abstraite définit deux méthodes :
• accept(File) : Cette méthode retourne un booléen indiquant si le fichier passé en paramètre est acceptable.
• getDescription() : Cette méthode retourne un String décrivant le filtre. C'est cette description qui sera affichée
dans le JFileChooser.
- 58 -
FAQ Java GUI
Voici un exemple simple d'implémentation.
public class FiltreSimple extends FileFilter{

//Description et extension acceptée par le filtre
private String description;
private String extension;
//Constructeur à partir de la description et de l'extension acceptée
public FiltreSimple(String description, String extension){
if(description == null || extension ==null){
throw new NullPointerException("La description (ou extension) ne peut être null.");
}
this.description = description;
this.extension = extension;
}
//Implémentation de FileFilter
public boolean accept(File file){
if(file.isDirectory()) {
return true;
}
String nomFichier = file.getName().toLowerCase();
return nomFichier.endsWith(extension);
}
public String getDescription(){
return description;
}
}
L'utilisation se fait comme ceci :
FileFilter java = new FiltreSimple("Fichiers Java",".java");

FileFilter classes = new FiltreSimple("Fichiers Class",".class");
FileFilter jar = new FiltreSimple("Fichiers JAR",".jar");
JFileChooser chooser = new JFileChooser(".");

chooser.addChoosableFileFilter(java);
chooser.addChoosableFileFilter(classes);
chooser.addChoosableFileFilter(jar);
Vous pouvez télécharger cet exemple ci-dessous.
Ce filtre simple ne prend en compte qu'une seule extension. Vous pouvez regarder les liens ci-dessous pour un exemple
de filtre "extensible" (capable de prendre en compte plusieurs extensions de fichiers).
Une dernière remarque : le filtrage ne se fait pas nécessairement sur une extension de fichier. Pour l'exemple on a choisi
cette possibilité car c'est ce qui est le plus couramment rencontré. Vous pouvez tout à fait faire des filtres sur les tailles
des fichiers, leurs dates de dernière modification, etc.
FiltreSimple.java
Comment faire un filtre de fichiers avec plusieurs extensions ?

Auteurs : Ioan Calapodescu , Pill_S ,
Voici un exemple d'implémentation de FileFilter (package javax.swing.filechooser) qui prend en compte plusieurs
extensions. Quelques méthodes supplémentaires sont définies pour des facilités d'utilisation.
- 59 -
FAQ Java GUI
public class FiltreExtensible extends FileFilter{

//Description et extensions acceptées par le filtre
private String description;
private List<String> extensions;
//Constructeur à partir de la description
public FiltreExtensible(String description){
if(description == null){
throw new NullPointerException("La description ne peut être null.");
}
this.extensions = new ArrayList<String>();
}
//Implémentation de FileFilter
public boolean accept(File file){
if(file.isDirectory() || extensions.size()==0) {
return true;
}
String nomFichier = file.getName().toLowerCase();
for(String extension : extensions){
if(nomFichier.endsWith(extension)){
return true;
}
}
return false;
}
public String getDescription(){
StringBuffer buffer = new StringBuffer(description);
buffer.append(" (");
for(String extension : extensions){
buffer.append(extension).append(" ");
}
return buffer.append(")").toString();
}
//Quelques méthodes utilitaires
public void setDescription(String description){
if(description == null){
throw new NullPointerException("La description ne peut être null.");
}
}
public void addExtension(String extension){
if(extension == null){
throw new NullPointerException("Une extension ne peut être null.");
}
extensions.add(extension);
}
public void removeExtension(String extension){
extensions.remove(extension);
}
public void clearExtensions(){
extensions.clear();
}
public List<String> getExtensions(){
return extensions;
}
}
Ce filtre peut s'utiliser comme ceci :
FiltreExtensible filtre = new FiltreExtensible("Fichiers Java");

filtre.addExtension(".java");
JFileChooser chooser = new JFileChooser(".");

chooser.addChoosableFileFilter(filtre);
- 60 -
FAQ Java GUI
filtre.addExtension(".class");
filtre.setDescription("Fichiers class");
filtre.removeExtension(".java");
filtre.setDescription("Tous les fichiers");

filtre.clearExtensions();
Vous pouvez télécharger cet exemple ci-dessous.
A noter que depuis Java 6.0, vous pouvez faire ceci de manière standard en utilisant la classe FileNameExtensionFilter,
qui permet de faire un filtre avec plusieurs extensions. Elle se crée de la manière suivante :
FileFilter imagesFilter = new

FileNameExtensionFilter("Images", "bmp", "gif", "jpg", "jpeg", "png", ...);
Ensuite, vous pouvez l'utiliser comme n'importe quel FileFilter.
FiltreExtensible.java
Comment "prévisualiser" les fichiers sélectionnés par un JFileChooser ?

La classe JFileChooser permet au développeur de définir, avec la méthode setAccessory(Component) un composant
accessoire. Ce composant peut se mettre à l'écoute des événements relatifs au JFileChooser grâce à un
PropertyChangeListener.
Vous pouvez donc utiliser cet accessoire pour par exemple prévisualiser des images ou simplement pour avoir des
informations détaillées sur le fichier sélectionné. Voici un exemple de rendu (vous pouvez télécharger l'implémentation
ci-dessous) :
- 61 -
FAQ Java GUI
FilePreview.java
- 62 -
FAQ Java GUI
Sommaire > AWT et Swing > JColorChooser

Comment supprimer le panel de prévisualisation d'un JColorChooser ?
Auteurs : JMLLB ,
Il suffit d'initialiser le panel de prévisualisation avec un JPanel trivial. C'est une utilisation détournée de la méthode
de personalisation du panel de prévisualisation.
JColorChooser myJCC = new JColorChooser(Color.BLACK);

myJCC.setPreviewPanel(new JPanel());
A noter que l'instruction :
myJCC.setPreviewPanel(null);
repositionne le panel de prévisualisation par défault
Comment supprimer un color chooser d'un JColorChooser ?

Auteurs : JMLLB ,
Mettons que je souhaite supprimer le color chooser HSB.
JColorChooser myJCC = new JColorChooser(Color.BLACK);

AbstractColorChooserPanel[] panels = myJCC.getChooserPanels();
for (int i=0; i<panels.length; i++) {

String tmpString = panels[i].getClass().getName();
if (tmpString.equals("javax.swing.colorchooser.DefaultHSBChooserPanel")) {
myJCC.removeChooserPanel(panels[i]);
}
}
à noter qu'il n'est pas possible de faire:
if (panels[i] instanceof javax.swing.colorchooser.DefaultHSBChooserPanel) {

myJCC.removeChooserPanel(panels[i]);
}
car DefaultHSBChooserPanel n'est accessible uniquement que depuis son package.
- 63 -
FAQ Java GUI
Sommaire > AWT et Swing > Composants textuels

Comment faire un JLabel de plusieurs lignes ?
Le HTML :
La plus simple des méthodes pour avoir un texte sur plusieurs lignes est d'utiliser l'interpréteur HTML du JLabel.
Pour cela il faut que le texte soit entouré des balises '<html>' et '</html>'. Ensuite il faut remplacer les "\n" par des
balises '<br>', et le tour est joué !
new JLabel("<html>ligne 1<br>ligne 2<br>etc...</html>");
Le composant texte :
Il est également possible d'utiliser un javax.swing.JTextArea plus pratique à mettre en place que la version Html si le
texte n'est pas fixé dans le code... Cette solution est néanmoins plus contraignante sur la mise en page et sur la gestion
de l'apparence (par défaut le JTextArea n'a pas les mêmes couleurs qu'un JLabel).
(Un exemple est disponible en téléchargement)
JTextArea label = new JTextArea();

label.setText(text);
label.setEnabled(false);
La solution de la brute :
Empiler 2 ou 3 JLabel les uns au dessus des autres devrait faire l'affaire :-).
Exemple de texte multi-ligne en utilisant un JTextArea.
Comment faire un JTextArea avec un retour à la ligne automatique ?

Tout simplement en utilisant les méthodes setLineWrap(boolean) et setWrapStyleWord(boolean) de la classe
javax.swing.JTextArea.
/** On souhaite un retour à ligne automatique : */

monTextArea.setLineWrap(true);
/** On souhaite que les mots ne soient pas coupés : */

monTextArea.setWrapStyleWord(true);
Comment permettre la saisie de mot de passe ? (texte saisi avec des étoiles)
Awt
TextField txt = new TextField ();

txt.setEchoChar ('*');
Swing
JPasswordField txt = new JPasswordField ();
- 64 -
FAQ Java GUI
txt.setEchoChar ('*')
Comment contraindre la saisie dans un composant texte ?

Auteurs : Johann Heymes , Baptiste Wicht , d-jo ,
Exemple :
Comment autoriser l'utilisateur à ne saisir que des entiers dans un champ texte. Trois solutions s'offrent à vous :
• écouter les évènements ;
• modifier le modèle du composant texte ;
• utiliser la classe javax.swing.JFormattedTextField (dispo seulement depuis le JDK 1.4).
Solution 1, les écouteurs (listener) :

Il s'agit sûrement des premières solutions auxquelles on pense mais ce ne sont pas les plus simples à mettre en place ni les
plus jolies. Je parle ici évidemment de java.awt.event.KeyListener ou javax.swing.event.DocumentListener et autres du
même genre. Pour moi, ces solutions sont des solutions de rattrapage car techniquement elles permettent uniquement
de nous informer d'un changement. Or si le changement est fait cela veux donc dire que le « mal » est déjà fait. Ce
qui signifie que le composant texte à un moment donné est dans une situation non cohérente. Je m'arrêterai donc là
sur ce sujet.
Solution 2, modification du modèle :
La notion de modèle provient du design pattern MVC, Model-View-Controller Architecture, le but ici est donc de
modifier directement ce que peut contenir un composant texte en ignorant tout le reste. Pour se faire il suffit de créer
une classe qui dérive du modèle auquel le composant texte est associé. Pour information nous avons :
• JTextField et JTextArea : PlainDocument ;
• JEditorPane et JTextPane : DefaultStyledDocument.
Ces deux classes implémentent toutes deux l'interface javax.swing.text.Document qui définit entre autres la méthode
insertString(int, java.lang.String, javax.swing.text.AttributeSet) et remove(int, int). Il suffit donc de créer une classe
qui dérive de la classe modèle apropriée et de rédéfinir la ou les méthodes nécessaires. Notons que ces deux méthodes
insertString et remove seront appelées automatiquement par les classes de Sun à chaque ajout ou suppression de chaîne.
Notre redéfinition doit donc avoir pour but de valider ou non l'action. Par conséquent on notera que l'intégrité du
composant texte n'est jamais bafouée (voir démo ci-dessous.)
Solution 3, la classe JFormattedTextField

Une toute nouvelle classe fait son apparition dans la version 1.4 du JDK. L'exemple ici est très réducteur de ses capacités
mais la prise en main est peut-être moins évidente. En tout cas le résultat est là et il est même largement meilleur...
regardez l'exemple :-)
A noter qu'on peut aussi utiliser un MaskFormatter à un JFormattedTextField. Pour cela, il vous suffit de créer un
nouveau MaskFormatter avec le masque de votre choix puis d'installer ce mask sur votre JFormattedTextField via la
méthode install de MaskFormatter. Cela permet encore plus de fonctionnalités à ce composant.
lien : Model-View-Controller Architecture

Exemple d'implémentation de la solution 2 Exemple d'implémentation de la solution 3
Comment utiliser un JFormattedTextField

JFormattedTextField et formats standards (depuis le JDK 1.4)
- 65 -
FAQ Java GUI
La classe JFormattedTextField possède un constructeur prenant en paramètre un Format. Cela permet de spécifer un
format au champ de saisie.
Classes dérivées de Format :

• DateFormat
• MessageFormat
• NumberFormat
// champ de saisie depourcentages

JFormattedTextField champPourcentage = new JFormattedTextField(NumberFormat.getPercentInstance());
// champ de saisie de dates

JFormattedTextField champDate = new
JFormattedTextField(DateFormat.getDateInstance()); // Dec 31, 2000
JFormattedTextField(DateFormat.getDateInstance(DateFormat.SHORT)); // 12/31/2000
JFormattedTextField et MaskFormatter (depuis le JDK 1.4)
Un MaskFormatter convient aux motifs à taille fixe (n° de téléphone, n° de sécurité social, n° de série...).
// pour un n° de téléphone en France

new MaskFormatter("## ## ## ## ##");
// pour un n° de sécurité social

new MaskFormatter("#-##-##-##-###-###-##");
Liste des symboles :

• # => Un chiffre
• ' => Un caractère d'échappement pour include un symbole dans le motif
• U => Une lettre (les minuscules sont changées en majuscules)
• L => Une lettre (les majuscules sont changées en minuscules)
• A => Un chiffre ou une lettre
• ? => Une lettre
• * => Tout caractère
• H => Tout caractère hexadécimal (0-9, a-f ou A-F)
On peut limiter les caractères valides en appelant l'une des méthodes suivantes : setValidCharacters(),
setInvalidCharacters().
// Champ de saisie d'une case d'un échiquier (A1 à H8)

try
{
MaskFormatter mask = new MaskFormatter("U#");
mask.setValidCharacters("ABCDEFGH12345678");
JFormattedTextField noteField = new JFormattedTextField(mask);
}
catch (ParseException e)
{
}
Formatteurs personnalisés
Pour personnaliser un formatteur, il faut créer une classe dérivée de DefaultFormatter et redéfinir les méthodes
• String valueToString (Object value) throws ParseException
- 66 -
FAQ Java GUI
• Object StringToValue (String text) throws ParseException
La 1ere méthode transforme la valeur du champ en chaîne qui s'affiche.

La 2ème méthode analyse le texte tapé et le transforme en objet.
Comment avoir un éditeur de texte avec plusieurs styles de mise en page ?

Quel composant choisir ?
Vous avez le choix entre JTextPane et JEditorPane. En effet, ce sont les seuls à utiliser comme "Model" (Cf Model-View-
Controller Architecture) un composant dérivant de AbstractDocument et implémentant l'interface StyledDocument.
Mise en page à la création :

Si la mise en page est fixée lors de la création du document, il suffit de récupérer le Model du composant texte.
JTextPane monComposantTexte = new JTextPane ();

DefaultStyledDocument doc = (DefaultStyledDocument) monComposantTexte.getDocument ();
doc.insertString (offset, "texte à ajouter", /** [un style d'écriture] */);
Style déterminé a l'insertion :

Si le style est connu lors de l'insertion, il faut créer une classe qui hérite de DefaultStyledDecument et redéfinir la méthode
insertString(). Exemple pour écrire tout le texte avec le style nomme styleNormal sauf si l'on insert le mot 'HELP' :
/** Redéfini pour choisir l'effet de style à utiliser */

public void insertString(int offs, String str, AttributeSet a) throws BadLocationException {
try {
/** si le texte inséré est égal à HELP le texte s'écrit
* avec le style "styleOp"
*/
if ( str.equals ("HELP") ) {
super.insertString (offs, str, getStyle ("styleOp"));
} else {
/** Sinon le texte est écrit avec le style "styleNormal" */
super.insertString (offs, str, getStyle ("styleNormal"));
}
} catch (BadLocationException e) {
System.out.println ("Tuuuttt erreur Insere");
}
}
(Voir l'exemple fourni.)
Modifier le Style après l'insertion :

Pour cela il faut soit récupérer le Model du composant Texte, soit créer sa propre classe dérivant de
DefaultStyledDocument.
JTextPane monComposantTexte = new JTextPane ();

DefaultStyledDocument doc = (DefaultStyledDocument) monComposantTexte.getDocument ();
doc.setCharacterAttributes (positionDeDepart, longueur, style, true);
- 67 -
FAQ Java GUI
Voir l'exemple fourni.)
Editeur de texte simple, avec changement d'attribut d'une portion de texte
Comment rendre visible le dernier ajout de texte dans un JTextComponent ?

Deux solutions possibles :
On peut déplacer le "caret" :
monTextArea.setCaretPosition(monTextArea.getDocument().getLength ());
On demande au JTextComponent de transmettre à son parent les coordonnées d'un point qui doit être visible.
try {
int longueur = monTextArea.getDocument().getLength();
Rectangle rectangle = monTextArea.modelToView(longueur);
monTextArea.scrollRectToVisible(rectangle);
} catch (javax.swing.text.BadLocationException err) {
Comment obtenir la liste des polices de caractères ?

Avant d'utiliser une police de caractères, il est fortement recommandé de vérifier qu'elle est présente sur le système.
Les systèmes alternatifs disposent rarement des mêmes polices que Windows.
GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();

/** Liste de toutes les polices : */
Font[ ] polices = environment.getAllFonts();
/** Liste des noms de toutes les polices : */
String[ ] nomPolices = environment.getAvailableFontFamilyNames();
- 68 -
FAQ Java GUI
Sommaire > AWT et Swing > Tableaux et arbres (JTable et JTree)

Comment rendre certaines cellules de ma JTable non éditables ?
Pour que certaines cellules d'une JTable ne soient pas éditables, il faut créer sa propre classe dérivant de
javax.swing.table.DefaultTableModel et redéfinir la méthode isCellEditable(int,int) afin que cette dernière retourne
faux pour ces cellules.
public boolean isCellEditable (int row, int column) {

if ( celluleEstEditable ) {
return ( true );
} else {
return ( false );
}
}
Comment faire des colonnes fixes dans une JTable ?

On préférera un petit exemple à un long discours ;-)
Pourquoi les en-têtes de ma JTable ne s'affichent-ils pas ?

Les javax.swing.JTable sont prévus pour être affichés dans un JScrollPane, si ce n'est pas le cas l'en-tête n'est pas
affiché. Pour l'afficher, vous pouvez récupérer l'en-tête en utilisant getTableHeader() et l'afficher séparément.
Un exemple est disponible ci-dessous.
Exemple d'implémentation.
Quelle cellule de ma JTable a été cliquée ?

Il suffit d'utiliser les méthodes columnAtPoint(java.awt.Point) et rowAtPoint(java.awt.Point) en lui passant le
paramètre récupéré sur l'évènement java.awt.event.MouseEvent
int colonne, ligne;

Point p = e.getPoint ();
colonne = jtable.columnAtPoint (p);
- 69 -
FAQ Java GUI
ligne = jtable.rowAtPoint (p);
Exemple d'implémentation.
Comment ancrer les colonnes d'une JTable ?

Il est parfois peu souhaitable que l'utilisateur puisse permuter les colonnes d'une javax.swing.JTable. Contre tout
attente, la méthode permettant d'intervenir sur cette propriété n'est pas dans la classe JTable, mais dans la classe
javax.swing.table.JTableHeader. Le code suivant permet d'annuler cette fonctionnalité.
maJTable.getTableHeader().setReorderingAllowed(false);
Comment sélectionner par programmation des lignes d'une JTable?

Auteurs : JMLLB ,
Il faut utiliser le SelectionModel de la JTable pour travailler sur la séléction de la JTable. Par exemple, pour selectionner
les lignes 2,4 et 5 de la JTable myJTable:
myJTable.getSelectionModel().addSelectionInterval(2,2);
myJTable.getSelectionModel().addSelectionInterval(4,5);
Pour ce qui est de sélectionner des cellules ou des zones de cellules de la JTable, la méthode changeSelection est plus
appropriée:
public void changeSelection(

int rowIndex,
int columnIndex,
boolean toggle,
boolean extend)
Comment définir l'alignement (gauche, centre, droite, ...) du contenu des colonnes d'une JTable ?
Auteurs : le y@m's ,
Il faut utiliser les méthodes setHorizontalAlignment() et setVerticalAlignment() de la classe DefaultTableCellRenderer
(ces méthodes sont en fait héritées de la classe JLabel).
Exemple : création d'un DefaultTableCellRenderer qui centre le contenu des colonnes :
public class CenterTableCellRenderer extends DefaultTableCellRenderer {

public CenterTableCellRenderer() {
setHorizontalAlignment(CENTER);
setVerticalAlignment(CENTER);
}
}
Il faut ensuite appliquer le renderer aux colonnes de la JTable :
- Soit à toutes les colonnes de la table :
JTable table = new JTable();
- 70 -
FAQ Java GUI
// on applique le renderer à la table

table.setDefaultRenderer(Object.class, new CenterTableCellRenderer());
- Soit à une colonne en particulier :
// on applique le renderer à la colonne d'indice 0

table.getColumnModel().getColumn(0).setCellRenderer(new CenterTableCellRenderer());
On peut aussi faire de même pour les headers, cependant il vaut mieux récupérer le renderer par défaut et le modifier :
- Tous les headers :
// on applique le renderer sur tous les headers de la table

TableCellRenderer headerRenderer = table.getTableHeader().getDefaultRenderer());
((DefaultTableCellRenderer) headerRenderer).setHorizontalAlignment(DefaultTableCellRenderer.CENTER);
- Un header en particulier :
// on applique le renderer sur le header de la colonne d'indice 0

TableCellRenderer headerRenderer = table.getColumnModel().getColumn(0).getHeaderRenderer();
((DefaultTableCellRenderer) headerRenderer).setHorizontalAlignment(DefaultTableCellRenderer.CENTER);
lien : La classe DefaultCellRenderer
Qu'est ce qu'un JTree ?

Auteurs : TheSeb ,
Un JTree est un composant Swing permettant d'afficher un arbre (une structure de donnée hiérarchique). Ce composant
ne contient pas de données mais plutôt une vue de données contenues dans son modèle.
lien : JTree
Comment construire un JTree ?

Auteurs : TheSeb ,
- Pour construire un JTree, il faut spécifier le modèle de l'arbre dans le constructeur.
- Il est posssible de créer son propre modèle en implémentant l'interface TreeModel ou bien en utilisant le modèle par
défaut DefaultTreeModel.
DefaultTreeModel myModel = ...;JTree myTree = new JTree(myModel);
- Pour construire un modèle d'arbre par défaut, il est nécessaire de passer le noeud racine (root).
- Il est possible d'y passer tout objet implémentant l'interface TreeNode. Vous pouvez aussi utiliser la classe par défaut
DefaultMutableTreeNode.
DefaultMutableTreeNode myRoot = ...;

DefaultTreeModel myModel = new DefaultTreeModel(myRoot);
- Pour créer un noeud, il faut indiquer un objet utilisateur. L'arbre utilisera le résultat de la méthode toString pour
afficher une représentation de l'objet à un noeud donné. Pour un arbre représentant un système de fichiers, des objets
File pourront être utilisés.
- 71 -
FAQ Java GUI
Voici un exemple simple et complet:
// Construction du noeud racine.

DefaultMutableTreeNode myRoot = new DefaultMutableTreeNode("Manuel");
// Construction des différents noeuds de l'arbre.

DefaultMutableTreeNode chap = new DefaultMutableTreeNode("Chapitre1");
myRoot.add(chap);
DefaultMutableTreeNode page = new DefaultMutableTreeNode("Page1");
chap.add(page);
page = new DefaultMutableTreeNode("Page2");
chap.add(page);
chap = new DefaultMutableTreeNode("Chapitre2");
myRoot.add(chap);
page = new DefaultMutableTreeNode("Page3");
chap.add(page);
// Construction du modèle de l'arbre.

DefaultTreeModel myModel = new DefaultTreeModel(myRoot);
// Construction de l'arbre.
JTree myTree = new JTree(myModel);
Comment afficher la poignée du noeud racine ?

Auteurs : TheSeb ,
Par défaut, la poignée du noeud racine n'existe pas. Pour l'afficher, il faut ajouter la ligne suivante :
myTree.setShowsRootHandles(true);
Comment cacher le noeud racine ?

Auteurs : TheSeb ,
Pour cacher le noeud racine, utile lorsque vous souhaitez afficher une forêt (un ensemble d'arbres), utilisez l'instruction
suivante:
myTree.setRootVisible(false);
Comment modifier les icônes d'un JTree ?

Auteurs : TheSeb ,
La méthode la plus simple consiste à construire un objet DefaultTreeCellRender puis de modifier les icônes et de
l'appliquer à l'arbre.
// Construction d'un afficheur par défaut.

DefaultTreeCellRenderer myRenderer = new DefaultTreeCellRenderer();
// Changement de l'icône pour les feuilles de l'arbre.

myRenderer.setLeafIcon(new ImageIcon("pageIcon.png"));
// Changement de l'icône pour les noeuds fermés.
myRenderer.setClosedIcon(new ImageIcon("closedBookIcon.png"));
// Changement de l'icône pour les noeuds ouverts.
myRenderer.setOpenIcon(new ImageIcon("openBookIcon.png"));
- 72 -
FAQ Java GUI
// Application de l'afficheur à l'arbre.

myTree.setCellRenderer(myRenderer);
Deux autres solutions consistent à implémenter l'interface TreeCellRenderer ou bien à étendre la classe
DefaultTreeCellRenderer, permettant ainsi de modifier les icônes, la police et la couleur de fond des différents noeuds
de l'arbre.
Comment écouter les événements d'un JTree ?

Auteurs : TheSeb ,
De manière générale, le composant JTree ne s'utilise pas tout seul, un autre composant est utilisé pour afficher des
informations relatives à l'objet utilisateur. Pour réaliser ce comportement, il est nécessaire de mettre en place un
écouteur dit de sélection implémentant l'interface TreeSelectionListener sur l'arbre.
// Ajoute un événement de sélection à l'arbre.

myTree.addTreeSelectionListener(new TreeSelectionListener()
{
// Appelé lorsque la valeur de la sélection change.
public void valueChanged(TreeSelectionEvent event)
{
// Récupère le chemin dans l'arbre.
TreePath myPath = myTree.getSelectionPath();
if(myPath == null) return;
// Récupère l'objet utilisateur correspondant.
DefaultMutableTreeNode myNode = (DefaultMutableTreeNode) myPath.getLastPathComponent();
Page myPage = (Page) myNode.getUserObject();
myEditorPane().setPage(myPage.getUrl());
}
});
La méthode valueChanged de l'interface TreeSelectionListener est appelée lorsque l'utilisateur sélectionne ou

désélectionne un des noeuds de l'arbre.
Comment modifier la méthode de séléction des noeuds d'un JTree ?

Auteurs : TheSeb ,
Il est possible de changer la méthode de sélection des noeuds de l'arbre avec la méthode setSelectionMode. Les différentes
valeurs sont : SINGLE_TREE_SELECTION (sélection d'un seul noeud), CONTIGUOUS_TREE_SELECTION
(sélection d'un ensemble contigus de noeuds), DISCONTIGUOUS_TREE_SELECTION (sélection d'un ensemble de
noeuds). Exemple :
myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
- 73 -
FAQ Java GUI
Sommaire > AWT et Swing > Les listeners

Que sont les listeners ?
Auteurs : Janitrix ,
Dans le contexte d'une interface graphique (Swing, AWT, etc), les listeners permettent au programmeur de réagir suite
aux actions de l'utilisateur (clic de souris, touche du clavier enfoncée, etc).
Les « listeners » sont des interface. Ces interfaces fournissent une ou plusieurs méthodes qui peuvent donc être
implémentées différemment selon les cas et les besoins, pour répondre aux événements.
Les interfaces « listener » sont présentes principalement dans le package java.awt.event, mais également dans le package
javax.swing.event.
Chaque listener dispose d'une classe Event associée. Cette classe étend java.awt.event.EventObject et fournit une
description de l'évènement capturé. Par exemple, la classe ActionEvent décrit les évènements capturés par un
ActionListener.
Il y a plusieurs manières d'utiliser les listeners, vous trouverez ces méthodes dans les Q/Rs suivantes.
Comment utiliser les listeners (Méthode 1) ?

Voici la présentation et quelques explications sur la première possibilité concernant l'utilisation des listeners.
1ère possibilité : implémentation de l'interface dans la classe principale.
import java.awt.event.ActionListener;
// Étape 1 : déclaration de la classe

public class MaClasse implements ActionListener {
// Étape 3 : Création de deux boutons
JButton monBouton = new JButton("Mon Bouton");
JButton monBouton2 = new JButton("Mon Bouton2");
public MaClasse() {
// Étape 4 : On ajoute « l'écouteur » sur le bouton « monBouton ».
monBouton.addActionListener(this);
// Puis sur monBouton2
monBouton2.addActionListener(this);
}
/
* Étape 2 :Cette méthode est déclarée dans l'interface ActionListener. Il nous faut l'implémenter. */
public void actionPerformed(ActionEvent e) {
// Étape 2bis
if(e.getSource() == monBouton) {
// Bouton 1 a été cliqué
}else {
}
}
}
- 74 -
FAQ Java GUI
Tout d'abord, à l'étape 1, nous déclarons une classe « MaClasse » qui implémente l'interface ActionListener (nous
l'étudierons plus en détail dans une autre Q/R). Puisque nous implémentons l'interface, nous devons également
implémenter toutes les méthodes définies dans l'interface.
Le cas de l'interface ActionListener est simple puisqu'elle ne contient qu'une méthode.
Méthode que nous implémentons à l'étape 2 justement.
Nous créons un bouton SWING à l'étape 3.
À l'étape 4, nous ajoutons un « listener » sur les boutons précédemment créés. La méthode addActionListener est définie
dans la classe AbstractButton, classe parente de JButton. Cette méthode attend un paramètre de type ActionListener.
La classe MaClasse implémente cette interface, elle peut être justement considérée comme du type ActionListener. Nous
pouvons donc fournir l'opérateur 'this' en paramètre, qui représente l'instance en cours de la classe MaClasse.
Concrètement, qu'avons nous fait ? Nous avons demandé aux boutons monBouton et monBouton2 qu'ils nous
préviennent lorsqu'un utilisateur les actionne (c'est le rôle du « listener » ActionListener en particulier). Et comment ?
En utilisant la méthode actionPerformed, définie dans l'interface ActionListener et surchargée dans la classe MaClasse.
Nous avons deux boutons, mais une seule méthode actionPerformed. Nous devons donc différencier (étape 2bis) la
source de l'évenement, monBouton ou monBouton2.
La boucle est bouclée.
Question : Comment utiliser les listeners (Méthode 2) ?

2ème méthode : Utilisation des classes anonymes
Une deuxième possibilité est d'utiliser les classes anonymes. Voici quelques explications, toujours avec un code pour
l'exemple.

public class MaClasse {
// Étape 2 : création de deux boutons.
JButton monBouton = new JButton("Mon Bouton");
JButton monBouton2 = new JButton("Mon Bouton 2");
/* Étape 3 : création de la classe anonyme */

monBouton.addActionListener(new ActionListener() {
// Cette méthode ne sera appelée que pour les évènements sur le bouton monBouton.
}
});
/* On refait la même chose pour le deuxième bouton */

monBouton2.addActionListener(new ActionListener() {
// Cette méthode ne sera appelée que pour les évènements sur le bouton monBouton2.
}
});
}
- 75 -
FAQ Java GUI
Dès le début nous pouvons remarquer quelques différences avec la première méthode d'utilisation traitée
précédemment.
Tout d'abord notre classe MaClasse n'implémente pas l'interface ActionListener. Aucune instance de la classe MaClasse
ne pourra donc être utilisée dans la méthode addActionListener.
Nous créons deux boutons à l'étape 2. L'étape 3 est la plus intéressante. Nous définissons une instance de l'interface
ActionListener dans une classe anonyme, sans garder de référence vers cette classe anonyme. Dans ce cas, nous devons
le faire deux fois, une fois pour chaque bouton (il faut une classe anonyme pour chaque composant déclenchant un
évènement).
Un avantage de cette méthode est un code plus léger au niveau de l'implémentation des évènements. En effet, nous
n'avons pas à dissocier les composants « source » (les composants écoutés par le listener), comme nous le faisons dans
la première possibilité.
En contrepartie, nous devons créer une classe anonyme à chaque fois. Une autre possibilité qui est une simple variante
de celle présentée ici est la suivante :

public class MaClasse {
// Étape 2 : création de deux boutons.
JButton monBouton = new JButton("Mon Bouton...");
JButton monBouton2 = new JButton("Mon Bouton 2...");
/* Étape 3 : création de la classe anonyme */

ActionListener listener = new ActionListener() {
if(e.getSource() == monBouton) {
}else {
}
}
};
monBouton.addActionListener(listener);
monBouton2.addActionListener(listener);
}
Ce code est fortement similaire au précédent et mérite donc peu d'explication. La seule subtilité est que nous «
sauvegardons » l'instance de la classe anonyme dans une variable, et que nous pouvons donc la réutiliser autant de fois
que nécessaire. Cependant, cette façon de faire nous oblige à différencier les composants « source » pour implémenter
un comportement différent selon la source.
Question : Comment utiliser les listeners (Méthode 3) ?

3eme méthode : création d'une classe dédiée.
// Fichier : MonListener.java
public class MonListener implements ActionListener {
}
}
- 76 -
FAQ Java GUI
Et dans votre classe principale :
monButton.addActionListener(new MonListener());
Cette possibilité est très simple, il vous suffit d'implémenter le comportement voulu dans la classe qui implémente le
listener, puis, vous créez une instance de cette classe que vous passez en paramètre de la méthode addXXXListener
située dans votre classe où sont déclarés les composants (boutons, listes, etc).
Qu'est ce qu'est et comment utiliser ActionListener ?

ActionListener est, comme son nom l'indique, un listener utilisé pour réagir aux actions utilisateurs. Celles-ci sont
multiples, la principale étant l'activation d'un bouton (par un clic ou par appui de la touche Entrée lorsque le bouton
est sélectionné).
Une seule méthode est déclarée dans cette interface : public void actionPerformed(java.awt.event.ActionEvent e).
La classe ActionEvent étend la classe java.util.EventObject, et hérite donc de ses méthodes. Parmi elles, getSource() est
particulièrement intéressante. Elle renvoie l'objet concerné par l'événement (par exemple le bouton qui a été cliqué).
Cela nous permettra de différencier les composants sources dans l'implémentation de la méthode actionPerformed.
La classe ActionEvent fournit quant à elle quelques méthodes spécifiques aux évènements d'action. Les plus utilisées
sont getWhen() et getActionCommand().
getWhen() récupère le timestamp Unix marquant le déclenchement de l'évènement, tandis que getActionCommand()
retourne le nom de la commande associée à l'évènement (par exemple, le texte du bouton à l'origine de l'action).
Voici une simple implémentation d'un ActionListener, utilisant la première méthode d'implémentation proposée :
[...]
import java.awt.event.*;

public class MaClasse implements ActionListener {
// Étape 2 : créations des boutons
JButton monBouton = new JButton("Un bouton vivant");
JButton monBouton2 = new JButton("Un bouton vivant2");
public MaClasse() {
// Étape 3 : on ajoute le listener aux boutons
}
// Étape 4 : l'implémentation de l'ActionListener

System.out.println("Un bouton a été cliqué, timestamp : " + e.getWhen());
// Étape 5 : différenciation de la source d'évènement

if(e.getSource() == monBouton || e.getActionCommand() == monBouton.getText()) {
System.out.println("C'est le bouton 1 !");
}else if(e.getSource() == monBouton2 || e.getActionCommand() == monBouton2.getText()) {
System.out.println("C'est le bouton 2 !");
}
- 77 -
FAQ Java GUI
}
}
Rien de nouveau aux étapes 1, 2, 3, et 4. Vous aurez compris que lorsque l'un des deux boutons est appuyé, la méthode
actionPerformed est invoquée.
Cependant, nous avons deux boutons, et un clic sur chacun d'eux invoquera la même implémentation de
l'ActionListener. Nous devons donc différencier le bouton source de l'action. Cela peut se réaliser de deux façons : soit on
compare le libellé du bouton avec celui de l'action capturée, soit on compare le bouton et l'objet source de l'évènement.
Les deux méthodes sont présentées à l'étape 5. Notez que mettre ces deux tests (comparaison de libellés et comparaison
de sources) dans une même condition est superflu, un seul des deux tests est nécessaire pour savoir quel bouton a été
actionné.
Qu'est ce qu'est et comment utiliser KeyListener ?

Le KeyListener est utilisé pour réagir aux évènements du clavier, et est donc utilisable sur des composants permettant
la saisi de texte (JTextField, JTextArea, etc).
Trois méthodes sont déclarées dans l'interface du KeyListener : keyTyped(KeyEvent e), keyPressed(KeyEvent e) et
keyReleased(KeyEvent e). Elle permettent respectivement de réagir lorsqu'une touche a été : tapé (pressé puis relâché),
pressé, relâché.
La classe KeyEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cette classe (notamment
getSource() ), mais fournit également une dizaine d'autres méthodes spécifiques aux évènements relatifs au clavier.
Parmi elles : getKeyChar() retourne le caractère associé à la touche appuyée, getKeyCode() récupère le code de la touche
pressée, isActionKey() retourne true si la touche appuyée est une touche d'action (CAPS LOCK, Verr Num, etc), et
getKeyText(int keyCode) retourne le texte associée à la touche (par ex. F1, A, etc).
La dernière méthode, getKeyText, est statique, et ne s'utilise donc pas avec l'instance de KeyEvent fournie.
Les codes retournés par la méthode getKeyCode() sont utiles pour déterminer la touche pressée.
Tous les codes et leur correspondance sont disponible ici : http://java.sun.com/javase/6/docs/ap.../KeyEvent.html
Voici une simple implémentation d'un KeyListener, utilisant la première méthode d'implémentation proposée :
import java.awt.event.*;
// Étape 1 : on crée la classe et on implémente KeyListener.

public class MaClasse implements KeyListener {
// Étape 2 : on crée un composant JTextField

private JTextField textField = new JTextField();
public MaClasse() {
// Étape 3 : on ajoute le listener au composant
textField.addKeyListener(this);
}
// Étape 4 : on implémente la méthode keyTyped définie dans l'interface KeyListener

public void keyTyped(KeyEvent e) {
- 78 -
FAQ Java GUI
/
* Cette méthode est appelée quand l'utilisateur appuie sur une touche Unicode (donc les caractères) et ne prend
System.out.println(e.getKeyChar());
}
// Étape 5: on implémente la méthode keyPressed définie dans l'interface KeyListener

public void keyPressed(KeyEvent e) {
/* Cette méthode est appelée quand l'utilisateur appuie sur une touche.
Il est conseillé de ne pas utiliser getKeyChar() mais getKeyCode(), car les touches spéciales comme F1 ou Echap
System.out.println(KeyEvent.getKeyText( e.getKeyCode() );
if(e.getKeyCode() == KeyEvent.VK_ESCAPE) {
System.out.println("L'utilisateur a appuyé sur Echap");
}
}
// Étape 6 : on implémente la méthode keyReleased définie dans l'interface KeyListener

public void keyReleased(KeyEvent e) {
// Le fonctionnement est le même que pour keyPressed, sauf que cette méthode est appelée quand la touche est re
}
Le code est assez explicite, et les commentaires précises quelques points obscures. Rien de nouveaux dans ce code, si ce
n'est la comparaison entre le code de la touche appuyé et le code de la touche Echap.
Enfin, sachez que si vous trouvez trop lourd de devoir implémenter les 3 méthodes alors qu'une seule vous suffit, il
existe la classe abstraite java.awt.event.KeyAdapter.
Vous pouvez soit créer une classe qui étendra KeyAdapter, soit faire une classe anonyme.
Exemple :
monTextField.addKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent e) {
}
});
lien : La documentation officielle sur le KeyListener

lien : La documentation officielle sur le KeyEvent
Qu'est ce qu'est et comment utiliser MouseListener ?

Le MouseListener est utilisé pour les événements relatifs à la souris (clics, déplacements).
5 méthodes sont déclarées dans l'interface MouseListener : mouseClicked(MouseEvent e) prévient des clics (la
souris a été pressée puis relâchée), mousePressed(MouseEvent e) pour les pressions sur la souris (donc on enfonce
le bouton sans le relâcher), mouseReleased(MouseEvent e) prévient du relâchement d'un bouton de la souris,
mouseEntered(MouseEvent e) indique que la souris est entrée dans l'espace d'un composant, mouseExited(MouseEvent
e) indique que la souris est sortie de l'espace d'un composant.
La classe MouseEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cette classe (notamment
getSource() ), mais fournit également 12 autres méthodes spécifiques aux événements relatifs à la souris, notamment
getButton() retourne le bouton qui a été cliqué, getClickCount() retourne le nombre de clics (utile pour gérer le double
clic), getLocationOnScreen() retourne un objet Point représentant la position de la souris à l'écran, et enfin
- 79 -
FAQ Java GUI
isPopupTrigger() précise si le bouton cliqué est celui habituellement utilisé pour afficher la liste déroulante (bouton
droit sur le bureau Windows par exemple).
Voici un exemple d'implémentation d'un MouseListener :
public class MaClasse implements MouseListener {
public void mousePressed(MouseEvent e) {

// Cette méthode est appelée quand l'utilisateur appuie le bouton sur le composant écouté
}
public void mouseReleased(MouseEvent e) {

// Cette méthode est appelée quand l'utilisateur relâche le bouton sur le composant écouté
}
public void mouseClicked(MouseEvent e) {

// Cette méthode est appelée quand l'utilisateur a cliqué (appuyé puis relâché) sur le composant écouté
if(e.getClickCount() == 2) {
System.out.println("Il y a eu un double clic");
}
Point p = e.getLocationOnScreen();
System.out.println("La souris est aux coordonnées : x=" + p.getX() + ";y=" +

p.getY() + " de l'écran.");
}
public void mouseEntered(MouseEvent e) {

// Cette méthode est appelée quand la souris entre dans la zone du composant écouté
System.out.println("La souris vient d'entrer...");
}
public void mouseExited(MouseEvent e) {

// Cette méthode est appelée quand la souris sort de la zone du composant écouté
System.out.println("La souris vient de sortir... rattrapez là :)");
}
}
Il est fort probable que seules quelques unes de ces méthodes vous intéressent, il vous semblera donc lourd
d'implémenter chacune des méthodes..
Il existe donc une classe abstraite MouseAdapter qui vous permet d'implémenter seulement les méthodes qui vous
intéressent.
Exemple :
monPanel.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
}
}
Qu'est-ce qu'est et comment utiliser WindowListener ?

Le WindowListener est utilisé pour les événements relatifs aux fenêtres (activation, fermeture, ouverture, etc).
Cette interface déclare 7 méthodes : windowActivated(WindowEvent e) indique que la fenêtre a été activé,
windowDeactivated(WindowEvent e) indique que la fenêtre n'est plus la fenêtre active,windowClosed(WindowEvent
- 80 -
FAQ Java GUI
e) indique que la fenêtre a été fermé, windowClosing(WindowEvent e) indique que l'utilisateur a demandé
la fermeture de la fenêtre, windowOpened(WindowEvent e) est appelé la première fois que la fenêtre est
rendue visible, windowIconified(WindowEvent e) indique que la fenêtre a été réduite dans la barre de tâche,
windowDeiconified(WindowEvent e) indique que la fenêtre a été restauré depuis la barre de tâche.
La classe WindowEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cette classe
(notamment getSource() ), mais fournit également 5 autres méthodes spécifiques aux événements relatifs aux fenêtres,
notamment getNewState() et getOldState() qui fournissent respectivement le nouvel état et l'ancien état de la fenêtre,
mais aussi getWindow(), qui retourne la fenêtre source de l'événement.
Afin d'ajouter un WindowListener sur une fenêtre, vous disposez de la méthode addWindowListener(WindowListener)
de la classe Window (étendue par la classe JFrame notamment).
Voici un exemple d'implémentation d'un WindowListener :
public class MaClasse implements WindowListener {
// [...]
public MaClass() {
maFenetre.addWindowListener(this);
}
public void windowOpened(WindowEvent e) {

System.out.println("On vient de m'ouvrir !");
}
public void windowClosed(WindowEvent e) {

System.out.println("On m'a fermé !")
}
public void windowClosing(WindowEvent e) {
System.out.println("On veut me fermer !");
}
public void windowIconified(WindowEvent e) {

System.out.println("Je suis réduite à une icône !");
}
public void windowDeiconified(WindowEvent e) {

System.out.println("Je suis restaurée !");
}
public void windowActivated(WindowEvent e) {

System.out.println("Je suis activée");
}
public void windowDeactivated(WindowEvent e) {

System.out.println("Je suis désactivée");
}
Les méthodes sont nombreuses mais bien spécifiques. Il existe encore une fois une classe Adapter qui vous permet de
n'implémenter que les méthodes qui vous intéressent : WindowAdapter.
Qu'est-ce qu'est et comment utiliser FocusListener ?

Le FocusListener est utilisé pour les événements relatifs au focus clavier.
- 81 -
FAQ Java GUI
Cette interface déclare 2 méthodes : focusGained(FocusEvent e) indique que le composant a gagné le focus clavier tandis
que focusLost(FocusEvent e) indique que le composant a perdu le focus clavier.
La classe FocusEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cette classe (notamment
getSource() ), mais fournit également 3 autres méthodes spécifiques aux événements relatifs aux fenêtres, notamment
isTemporary() qui indique si le composant n'a le focus que temporairement, et getOppositeComponent() qui retourne
l'autre composant impliqué dans le changement de focus.
Afin d'ajouter un FocusListener, vous disposez de la méthode addFocusListener(FocusListener) de la classe Component.
Voici un exemple d'implémentation d'un FocusListener :
public class MaClasse implements FocusListener {

public MaClasse() {
monComposant.addFocusListener(this);
}
public void focusGained(FocusEvent e) {

System.out.println("On a gagné le focus");
}
public void focusLost(FocusEvent e) {

System.out.println("On a perdu le focus");
}
}
Qu'est-ce qu'est et comment utiliser ItemListener

Le ItemListener est utilisé pour les évènements relatifs aux éléments (liste, checkbox, etc).
Cette interface déclare une seule méthode : itemStateChanged(ItemEvent e) qui indique que l'élément a changé d'état.
La classe ItemEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cette classe (notamment
getSource() ), mais fournit également 4 autres méthodes spécifiques aux événements relatifs aux fenêtres, notamment
getItem() qui retourne l'élément affecté par l'évènement, getStateChange() retourne le nouvel état de l'élément
(sélectionné ou désélectionné), et getItemSelectable() qui retourne le composant originaire de l'évènement.
Afin d'ajouter un ItemListener sur les composants qui le permettent (les boutons, JcomboxBox, les listes, etc), vous
disposez de la méthode addItemListener(ItemListener).
Voici un exemple d'implémentation d'un ItemListener :
public class MaFrame extends JFrame implements ItemListener {

private JComboBox choix;
// [...]
public MaFrame() {
choix = new JComboBox();
choix.addItemListener(this);
}
public void itemStateChanged(ItemEvent e) {
- 82 -
FAQ Java GUI
if(e.getStateChange() == ItemEvent.SELECTED) {
System.out.println("Un nouveau choix est sélectionné*: " + e.getItem().toString());
}else if(e.getStateChange() == ItemEvent.DESELECTED) {
System.out.println("*Un choix est désélectionné*: " + e.getItem().toString());
}
}
}
Nous effectuons un test afin de savoir l'état de l'élément affecté par l'évènement. En effet, deux états sont
possibles : ItemEvent.ITEM_SELECTED et ItemEvent.DESELECTED. Il faut bien comprendre que la méthode
itemStateChanged est invoquée deux fois : une fois pour l'élément qui vient d'être désélectionné et une fois pour celui
qui vient d'être sélectionné (ceci est vrai dans le cas d'une JComboBox par exemple). Il est donc important de faire la
différence, sous peine de voir son code exécuté deux fois.
- 83 -
FAQ Java GUI
Sommaire > Applets

Certaines méthodes du JDK me demandent une Frame, Applet ne dérive pas de Frame, que faire ?
Principe :
Une solution semble exister au moins avec Netscape Navigator et Appletviewer, en effet ils placent les applets dans une
Frame. Il suffit donc d'utiliser getParent() sur l'Applet pour récupérer cette Frame et s'en servir ( éventuellement de
manière récursive jusqu'à récupérer la Frame ).
Exemple :
public java.awt.Frame getFrame() {

Container container = this.getParent();
while( container != null ) {
if( container instanceof Frame ) {
return( (Frame)container );
}
container = container.getParent();
}
return(null); /** Ou une erreur */
}
Cet exemple retourne null si le parent n'est pas une java.awt.Frame.
Comment ouvrir une nouvelle page HTML ?

Il faut, dans l'applet, récupérer la page puis l'afficher, ceci pouvant être effectué suite à la pression d'un bouton.
URL recup;
try {
/** récupère l'URL à partir du document courant et "page.html" */
recup = new URL(getDocumentBase(), "page.html");
/** Affiche le document après avoir recupérer le contexte courant */
getAppletContext().showDocument(recup, option_frame);
repaint();
} catch (MalformedURLException e) {
/** un traitement quelconque si la page n'est pas correcte */
}
Option_frame peut-être :
• "_self" -> la frame courant
• "_parent" -> la frame parente
• "_top" -> la frame de base
• "_blank" -> nouvelle fenetre
• "un_nom" -> nouvelle fenêtre nommée.
Comment récupérer des arguments d'une page HTML dans une applet ?
Code HTML :
- 84 -
FAQ Java GUI
On initialise les différents paramètres lors de l'appel de l'applet:
<applet code=mon_code><param name=param1 value="xxx"><param name=param2 value="yyy"></applet>
Code Java :
Dans l'applet on récupère les résultats ainsi :
String param1 = getParameter("param1");

String param2 = getParameter("param2");
Comment afficher quelque chose dans la barre de statut d'un navigateur ?

Il faut utiliser la méthode showStatus(java.lang.String) sur un objet de type java.applet.AppletContext.
Comment faire communiquer deux applets ?

Les applets se trouvent dans la même frame HTML :
Il faut que l'applet ait été déclarée dans le code HTML de la sorte :
<applet code=.... name="tagname"></applet>
Alors il suffit de récupérer une applet à partir d'une autre de cette manière :
CType autre_applet = (CType)(getAppletContext().getApplet("tagname");
Si les applets sont déclarées dans des frames HTML différentes :

Comme le navigateur utilise généralement une seule JVM, l'espace mémoire est partagé. Une astuce est donc alors de
créer une classe ne contenant que des membres statiques et permettant l'enregistrement et la récupération d'applet.
Ces membres statiques seront uniques en mémoire et donc partagés entre les applets.
Un début de structure serait :
class AppletDataBase {
/** Une structure de données permettant d'enregistrer les données */
static Hashtable data;
/** Une méthode permettant de récuperer une applet grâce à son tag */
public static Applet getApplet(String tag);
/** Une méthode chargée d'enregistrer une applet marquée par un tag */
public static void addApplet(Applet applet, String tag);
}
Dans les applets on peut ainsi faire l'équivalent de ce qui est fait avec l'AppletContext :
- 85 -
FAQ Java GUI
Applet autre_applet = AppletDataBase.getApplet("tagname");
Mon applet ne marche pas avec un plugin Java, que faire ?

En fait pour faire marcher votre applet avec un plugin, il va falloir modifier le contenu de votre page HTML. La
marche à suivre dépend de votre navigateur. Vous trouverez plus d'informations à l'adresse suivante : http://
www.javasoft.com/products/plugin/1.3/docs/tags.html
Comment signer une applet ?

lien : http://www.suitable.com/docs/signing.html
Comment jouer un son dans une applet ?

Même si les sons ont plutôt tendance à m'énerver quand je navigue sur la toile, voila un un bout de code pour faire
faire du son à votre applet.
try {
URL url = new URL("http://serveur.fr/monSon.au");
AudioClip ac = Applet.newAudioClip(url);
ac.play();
} catch( MalformedURLException e ) {
- 86 -
FAQ Java GUI
Sommaire > Divers et astuces

Comment ouvrir la fenêtre d'édition de courriel par défaut ?
Auteurs : Orian , Baptiste Wicht ,
Depuis Java 6, il y a une solution toute simple pour ouvrir la fenêtre d'édition de courrier du programme par défaut.
Il vous faut employer la classe java.awt.Desktop pour cela.
Pour ouvrir simplement la fenêtre pour un nouveau mail :
if(Desktop.isDesktopSupported(){
if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.MAIL){
try {
java.awt.Desktop.getDesktop().mail();
} catch (IOException ex) {
//Traitement de l'exception
}
} else {
//La fonction de mail n'est pas supportée par votre système d'exploitation
}
}else {
//Desktop pas supportée par votre système d'exploitation
}
Comme cette classe utilise des appels systèmes, il n'est pas possible de le faire sur tous les systèmes d'exploitations.
C'est pourquoi, il faut veiller à tester d'abord si les fonctions sont supportées par votre système d'exploitation avant
d'éviter des exceptions.
Vous pouvez aussi spécifier une adresse de destination :
if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.MAIL){
try {
java.awt.Desktop.getDesktop().mail(new java.net.URI("mailto:nom@fai.ext"));
}
} else {
//La fonction de mail n'est pas supportée par votre système d'exploitation
}
}else {
}
Vous pouvez aussi spécifier les autres éléments du mailto selon la RFC 2368 (voir plus bas).
lien : Classe Desktop

lien : The mailto URL scheme (RFC 2368)
Comment ouvrir l'explorateur par défaut pour visualiser une page Web ?
Auteurs : Baptiste Wicht ,
Depuis Java 6, il y a une solution toute simple pour ouvrir l'explorateur par défaut à une page quelconque. Il vous faut
employer la classe java.awt.Desktop pour cela.
Par exemple, pour ouvrir l'explorateur par défaut sur le site Java de Developpez.com :
- 87 -
FAQ Java GUI
if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.BROWSE){
try {
java.awt.Desktop.getDesktop().browse(new URI("http://java.developpez.com"));
} catch (URISyntaxException uri) {
}
} else {
//La fonction n'est pas supportée par votre système d'exploitation
}
}else {
}
Comment ouvrir un fichier avec le programme par défaut ?

Depuis Java 6, il y a une solution toute simple pour ouvrir un fichier avec le programme par défaut pour ce type de
fichier. Il vous faut employer la classe java.awt.Desktop pour cela.
Par exemple, pour ouvrir un fichier (C:\\Test.pdf) avec le programme par défaut pour les PDF :
if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.OPEN){
try {
java.awt.Desktop.getDesktop().open(new File("C:\\Test.pdf"));
}
} else {
}
}else {
}
Comment imprimer un fichier avec le programme par défaut ?

Depuis Java 6, il y a une solution toute simple pour imprimer un fichier avec le programme par défaut pour ce type de
fichier. Il vous faut employer la classe java.awt.Desktop pour cela.
- 88 -
FAQ Java GUI
Par exemple, pour imprimer un fichier (C:\\Test.pdf) avec le programme par défaut pour les PDF :
if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.PRINT){
try {
java.awt.Desktop.getDesktop().print(new File("C:\\Test.pdf"));
}
} else {
}
}else {
}
- 89 -

Faq Java Gui

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Faq Java Gui

Загружено:

Авторское право:

Доступные форматы

FAQ Java GUI

Date de publication : 15/11/2008

Dernière mise à jour : 17/05/2009

Sur ce, nous vous souhaitons une bonne lecture.

bazinou - iubito - Clément Cunin - Johann Heymes - Ronan

1. Informations générales (5) .........................................................................................................................................................4

Sommaire > Informations générales

Nouveautés et mises à jour :

lien : Comment participer à cette faq ?

Comment participer à cette faq ?

lien : Quels sont les droits de reproduction de cette FAQ ?

Quels sont les droits de reproduction de cette FAQ ?

Où trouver d'autres sources d'information ?

Sommaire > Fenêtres et positionnement des composants

Dimension tailleEcran = java.awt.Toolkit.getDefaultToolkit().getScreenSize();

Comment centrer une fenêtre à l'écran ?

/** Centrage de la fenêtre par rapport à la fenêtre parente.

JDK 1.3 et antérieurs :

/** Lecture de la taille de l'écran */

lien : Comment connaître la taille de l'écran ?

Comment centrer verticalement et horizontalement un composant ?

JPanel panel = new JPanel (new BorderLayout ());

Centré sur son conteneur (JPanel )

JPanel p = new JPanel (new GridBagLayout ());

Comment positionner les composants dans un conteneur ?

Comment utiliser le FlowLayout ?

class FlowLayoutFrame extends JFrame

JPanel panel = new JPanel();

// ------------ par défaut pour le JPanel ------------

panel.add(new JButton("Bouton 1"));

static final int DEFAULT_WIDTH = 200;

Comment utiliser le BorderLayout ?

class BorderLayoutFrame extends JFrame

// ------------ par défaut pour le JFrame ------------

c.add(makeLabel(" NORD "),BorderLayout.NORTH);

private JLabel makeLabel(String text)

static final int DEFAULT_WIDTH = 200;

Comment utiliser le GridLayout ?

class GridLayoutFrame extends JFrame

static final int DEFAULT_WIDTH = 200;

Comment utiliser le BoxLayout ?

Stratégie de mise en forme :

- stratégie analogue pour le BoxLayout vertical.

class BoxLayoutFrame extends JFrame

JLabel nomLabel = new JLabel("Nom : ");

Box hBox1 = Box.createHorizontalBox();

JLabel prenomLabel = new JLabel("Prénom : ");

Box hBox2 = Box.createHorizontalBox();

Box hBox3 = Box.createHorizontalBox();

Box vBox = Box.createVerticalBox();

static final int DEFAULT_WIDTH = 200;

Comment utiliser le GridBagLayout ?

[6] Ecrire le code.

class FontDialogFrame extends JFrame

GridBagLayout layout = new GridBagLayout();

ActionListener listener = new FontAction();

// construction des composants

JLabel faceLabel = new JLabel("Face: ");

face = new JComboBox(new String[]

JLabel sizeLabel = new JLabel("Size: ");

size = new JComboBox(new String[]

bold = new JCheckBox("Bold");

italic = new JCheckBox("Italic");

sample = new JTextArea();