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 dehttp://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette faq ne garantit en aucun cas que les informationsqu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur esthumaine. 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

http://www.developpez.com


http://club.developpez.com/redaction/#L3

Ont contribué à cette FAQ :

bazinou - iubito - Clément Cunin - Johann Heymes - RonanLe 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 -


http://www.developpez.net/forums/profile.php?mode=viewprofile&u=83412









http://www.jext.org






















http://www.developpez.net/forums/member.php?u=38277














http://www.developpez.net/forums/u140600/gifffftane/

FAQ Java GUI

- 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 oeuvreintellectuelle 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éede 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 tantque cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 - 2009 Developpez LLC : Tous droits réservés DeveloppezLLC. 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 etjusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.

http://java.developpez.com/faq/gui/

1. Informations générales (5) .........................................................................................................................................................42. Fenêtres et positionnement des composants (22) ......................................................................................................................73. La souris et le clavier (9) ........................................................................................................................................................244. Le dessin (12) .......................................................................................................................................................................... 285. Les images (18) ....................................................................................................................................................................... 366. AWT et Swing (60) .................................................................................................................................................................45

6.1. Généralités (21) ...............................................................................................................................................................466.2. JFileChooser (5) ..............................................................................................................................................................586.3. JColorChooser (2) ...........................................................................................................................................................636.4. Composants textuels (8) ................................................................................................................................................. 646.5. Tableaux et arbres (JTable et JTree) (14) ......................................................................................................................696.6. Les listeners (10) ............................................................................................................................................................ 74

7. Applets (8) ............................................................................................................................................................................... 848. Divers et astuces (4) ................................................................................................................................................................87



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 etcomplè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 questionporte 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échargercontenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il soit aisé delocaliser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses, vers ladocumentation 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 modificationsapporté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 toutescollaborations 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 :





FAQ Java GUI



Malgré nos efforts, des fautes d'orthographe ou de grammaire peuvent subsister. Merci de contacter les administrateurssi 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 lereste, 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 traduiteen français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin etJohann 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. Permissionvous 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 selonla 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, SebastienAndreo, 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 :




http://www.gnu.org/copyleft/fdl.html

http://c.developpez.com/faq/cpp/GFDL.html

http://www.gnu.org/copyleft/fdl.html

http://c.developpez.com/faq/cpp/GFDL.html


http://java.developpez.com/cours/

http://www.developpez.net/forums/forumdisplay.php?f=6

http://java.developpez.com/faq/struts/

http://java.sun.com/j2se/1.4/docs/api/index.html

http://java.sun.com/docs/books/tutorial/index.html

http://www.jguru.com/faq/









http://www.jext.org
















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é à laperfectionner.

Et pour finir, un merci tout spécial à Clément Cunin, qui est à l'origine de cette FAQ, à cyberzoide pour notre logo etses conseils avisés et à tous les membres de l'équipe qui nous ont fourni outils et logiciels nécessaires pour la réalisationde ce document.










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éthodesetLocationRelativeTo(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 centrageest 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 del'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.






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

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 peuplus 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 formeJava propose un certain nombre gestionnaires de mise en forme, ou layout managers, qui permettent de placer lescomposants 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éesIl est possible de se passer des gestionnaires de mise en forme pour le placement des composants. Pour cela, on définitle gestionnaire de mise en forme du contenant à null, on ajoute le composant au contenant et on spécifie la positionabsolue 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 plusde 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 composantssont réorganisés automatiquement. FlowLayout est le gestionnaire de mise en forme par défaut des JPanel.

class FlowLayoutFrame extends JFrame





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")); panel.add(new JButton("Bouton 2")); panel.add(new JButton("Bouton 3")); 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 enbordure 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 deredimensionnement, 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"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

Container c = getContentPane();

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




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);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }

private JLabel makeLabel(String text) { JLabel label = new JLabel(text,JLabel.CENTER); Border borderLine = BorderFactory.createLineBorder(Color.BLACK); label.setBorder(borderLine); return label; } static final int DEFAULT_WIDTH = 200; static final int DEFAULT_HEIGHT = 150;}

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 sontajoutés ligne par ligne à partir de la cellule du coin supérieur gauche.

class GridLayoutFrame extends JFrame{ public GridLayoutFrame () { setTitle("GridLayout Test"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

setLayout(new GridLayout(2,3)); Container c = getContentPane();




FAQ Java GUI



c.add(new JButton("(1,1)")); c.add(new JButton("(1,2)")); c.add(new JButton("(1,3)")); c.add(new JButton("(2,1)")); c.add(new JButton("(2,2)")); c.add(new JButton("(2,3)")); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } static final int DEFAULT_WIDTH = 200; static final int DEFAULT_HEIGHT = 150; }

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 lescomposants. 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 autrescomposants à 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 correspondpas à 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.




FAQ Java GUI



- stratégie analogue pour le BoxLayout vertical.

class BoxLayoutFrame extends JFrame{ public BoxLayoutFrame () { setTitle("BoxLayout Test"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

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());

Box hBox2 = Box.createHorizontalBox(); hBox2.add(prenomLabel); hBox2.add(Box.createHorizontalStrut(5)); hBox2.add(prenomText); Box hBox3 = Box.createHorizontalBox(); 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);

Container c = getContentPane(); c.add(vBox,BorderLayout.CENTER);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }

static final int DEFAULT_WIDTH = 200; static final int DEFAULT_HEIGHT = 150; }



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, maisavec 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 redimenssionnementde 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 donnealors à la largeur de sa zone d'affichage (gridwidth) la valeur GridBagConstraints.REMAINDER. On donne cette mêmevaleur à 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 composantsqui restent toujours à leur taille par défaut.




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"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

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);

GridBagConstraints c2 = new GridBagConstraints(); 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);



FAQ Java GUI



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

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

GridBagConstraints c5 = new GridBagConstraints(); 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);

GridBagConstraints c6 = new GridBagConstraints(); 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);

GridBagConstraints c7 = new GridBagConstraints(); 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(); } }}



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é pourun 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"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

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!");




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 ponctuelpour 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 classejava.awt.GraphicsEnvironment permet de connaître la liste des écrans. Il est fortement recommandée de vérifier quele 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'apas l'exclusivité de l'affichage.

GraphicsDevice myDevice = java.awt.GraphicsEnvironment. getLocalGraphicsEnvironment().getDefaultScreenDevice();Window myWindow;if( myDevice.isFullScreenSupported() ) { try { myDevice.setFullScreenWindow(myWindow); /** ... */



http://java.developpez.com/faq/java/fichiers/GBC.java


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 ya 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 unminimum 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 permissionfullScreenExclusive.

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 retrouveen 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èsfacile 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 frameparente.

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 lesimages PNG qui ne sont pas gérés par tous les OS, certains OS vont l'afficher mais supprimmer la transparence etd'autres ne pas l'afficher.



http://java.sun.com/docs/books/tutorial/extra/fullscreen/



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êtrede 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. Lafenê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 parl'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 pourla construction de l'image, les différents composants que vous avez placés dans la fenêtre restent en mémoire commen'importe quel autre objet. Même après avoir été détruit, on peut toujours utiliser la méthode show() pour réafficherla fenêtre (de nouvelles ressources seront alors allouées). C'est donc une très bonne idée de détruire les fenêtres lorsquevous 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.





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 complexesen 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 paspossible 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 aucuncadre 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. Parexemple, 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'impressionque votre fenêtre est maximisée, c'est à dire qu'elle prenne toute la place disponible à l'écran, tout en gardant visiblela barre d'outils, vous pouvez faire comme ceci :

public void maximiser(Frame frame){ Toolkit kit = Toolkit.getDefaultToolkit();





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, cettemé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 versionspré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 constructeurscomportant un paramètre du type java.awt.GraphicsConfiguration (présent dans les classes Frame et Dialog d'AWTainsi que JFrame et JDialog pour Swing).

L'instance de GraphicsConfiguration s'obtient depuis le GraphicsDevice associé à l'écran. Ainsi, pour afficher uneJFrame 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 :





FAQ Java GUI



Ouvrir une JFrame sur le second écranJFrame frame = new JFrame(gConfig);frame.setSize(400,400);frame.setVisible(true);

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 lorsd'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 :

GraphicsEnvironment gEnv = GraphicsEnvironment.getLocalGraphicsEnvironment();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 :

GraphicsEnvironment gEnv = GraphicsEnvironment.getLocalGraphicsEnvironment();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 actuelleet 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:






FAQ Java GUI



Connaître la mémoire utilisable de la carte graphique:// obtenir le type d'environnement graphique sous lequel tourne la JVMGraphicsEnvironment 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 graphiqueint kbytes = bytes /1024;// calcule le nombre de Méga Octets libres dans la carte graphiqueint 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 desfenêtres, mais lorsque l'on souhaite positionner précisément une fenêtre il est intéressant de déterminer cet espace afinde 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 lesmarges 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 dedéterminer l'espace utile du bureau graphique de l'utilisateur.





http://java.developpez.com/faq/gui/?page=graphique_fenetres_composants#GRAPHIQUE_taille_ecran

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 lequelest effectivement le bouton gauche. On préférera donc utiliser la classe javax.swing.SwingUtilities qui commente plusgé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 êtreaccessibles 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émentationne serait pas portable, certains systèmes n'ont qu'un bouton de souris (Mac) d'autres n'utilisent pas le droitpour ouvrir le menu contextuel (linux permet de configurer les choses les plus folles). Pour cela, on utilisera laméthode isPopupTrigger() et on prendra soin de la tester dans mousePressed(java.awt.event.MouseEvent) et dansmouseReleased(java.awt.event.MouseEvent). Le faire dans les deux cas est très important pour que le programmefonctionne 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





FAQ Java GUI



changement de curseur est automatiquement hérité par tous les fils, sauf si ceux-çi précisent explicitement un autrecurseur.

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 declics 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 dusimple 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 tempsest é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éthodemouseMove(int,int). La classe Robot permet également d'actionner les boutons de la souris ou d'entrer des touches auclavier.

Attention :

Le déplacement automatique de la souris a le don d'énerver certains utilisateurs, il est donc conseillé de l'utiliserprudemment 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 solutionconsiste 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èqueadditionnelle...


Comment connaître la position de la souris à l'écran ?


A partir d'un composant avec MouseEvent








FAQ Java GUI



En enregistrant un MouseEvent auprès de votre composant graphique, vous pouvez avoir accès à la position de la sourisrelativement à ce composant. Il vous suffira ensuite d'utiliser la méthode getLocationOnScreen() de Component pourcalculer 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 pouvezutiliser 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 nouvelleinstance à chaque fois.

Avant Java 5.0, la seule solution possible est de passer par JNI (Java Native Interface). Vous pourrez ainsi avoir accèsgrâce à des langages plus proches du système aux cooordonnées de la souris à l'écran. Attention tout de même, vousrisquez 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 statiqueMouseInfo.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 */





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 Aavec la touche shift.



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 construireune instance de cette classe. Pour dessiner dans un composant graphique, l'instance vous est donnée en paramètre de lamé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écessitede 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 nombred'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 raisonest une requête du système, soit suite au redimensionnement de la fenêtre, soit suite au masquage du composant parune 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êmeespace mémoire et cet espace n'est jamais nettoyé (pour des raisons de performance). Le programmeur du composanta donc la charge de nettoyer l'espace et de redessiner son composant. Si le composant est complexe et que son dessinest long, il est recommandé d'utiliser la technique de Comment utiliser le double-buffering software ? pour optimiserson affichage.

lien : Comment utiliser le double-buffering software ?

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 quel'on cherche.






FAQ Java GUI



/** Ecriture dans une image 'img' */Graphics2D g2d = (Graphics2D)img.getGraphics();g2d.drawString("HelloWord",x,y);

Avec quelques raffinements :

On peut améliorer un peu le procédé et choisir la police et la couleur de notre texte. En fait, la classe java.awt.Graphics2Dgarde un certain nombre d'attributs qui sont appliqués à toutes les opérations de dessin ; la couleur principale, la couleursecondaire (de fond), la police, la déformation. Il suffit de changer ces valeurs en utilisant la méthode appropriée.

Graphics2D g2d = (Graphics2D)img.getGraphics();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èrelettre du texte. Plus précisément, la valeur y correspond à la ligne 'de base' du texte. Pour les langues comme l'Arabequi s'écrivent de droite à gauche, cette position correspond à la position du dernier caractère de la chaine, donc de celuiqui 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 pourl'affichage de ce texte, pour le centrer ou continuer à écrire à la ligne suivante. Il suffit pour cela de récupérer l'instancede 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 :

Graphics2D g2d = ...;/** 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);

lien : Comment dessiner en Java ?





FAQ Java GUI



lien : Comment écrire du texte dans une image ?

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, lagestion de la transparence se résume à spécifier à notre graphique le pourcentage d'opacité que l'on souhaite appliquerà ce que l'on va dessiner (graphique ou texte). Une composante alpha de 0 correspond à une complète transparence,alors qu'une valeur de 1 correspond à une complète opacité.

Juste une méthode à appliquer à notre graphique :

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

lien : Comment dessiner en Java ?lien : Comment écrire du texte dans une image ?

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

Graphics2D g2d = ...;/** 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 lignede 2.5 pixels. Pour comprendre, il suffit de s'imaginer le cas d'une ligne oblique, ou le cas d'un tracé avec Commentactiver 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 tailledu pinceau, elle permet la définition de lignes en pointillés avec éventuellement plusieurs longueurs, elle permet ausside définir comment sont gérées les intersections des lignes d'une multi-ligne (shape), et plein d'autres choses encore. Jene rentrerai donc pas dans les détails, tout est expliqué dans la documentation. Un petit exemple quand même :

Graphics2D g2d = ...;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





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 avantd'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 pointssitués entre les 2 est un dégradé linéaire.

Graphics2D g2d = ...;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 :

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

lien : Comment dessiner en Java ?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 :




http://java.developpez.com/articles/Paint/


FAQ Java GUI



L'utilisation d'un double buffer est particulièrement recommandée pour l'affichage d'animations complexes ou decomposants de grande taille. Voir Comment utiliser le double-buffering software ?

lien : 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 setracer). Si on commence à faire des animations un peu complexes, il apparait dès lors des problèmes de scintillementsde l'image appelés clipping. Pour résoudre ce problème, on peut utiliser la méthode du double-buffering software (c'estune couche de la JVM qui s'en charge). Le double-buffering est le fait d'avoir un buffer où l'on dessine en mémoireet un buffer qui s'occupe de l'affichage. Les problèmes de rafraichissement, saut d'image et autres bugs visuels sontainsi é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 {




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 accélérer le rendu graphique de mon dessin ?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émenterl'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 quelbuffer 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 bufferqui va servir de buffer graphique (celui qui s'occupe d'afficher ce qu'il contient à l'écran). On dessine sur le buffermémoire, des images, des textes, des dessins, ... pendant que le buffer graphique affiche ce qu'il contient. Puis, on swaples buffers(en clair, on les inverse), le buffer mémoire devient le buffer graphique et le buffer graphique devient le buffermé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 );



http://java.sun.com/docs/books/tutorial/extra/fullscreen/doublebuf.html

http://www.dgp.utoronto.ca/~mjmcguff/learn/java/07-backbuffer/


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/lien : Comment accélérer le rendu graphique de mon dessin ?lien : Comment utiliser le double-buffering software ?lien : Comment utiliser le double-buffering hardware ?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 :

createBufferStrategy( 2 );

pour ceci:

createBufferStrategy( 3 );

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 tourneraen 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 enimages 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 ?



http://java.sun.com/docs/books/tutorial/extra/fullscreen/doublebuf.html

http://www.dgp.utoronto.ca/~mjmcguff/learn/java/07-backbuffer/


FAQ Java GUI



• Si le double-buffering ne suffisait pas à nettoyer tous les bugs d'affichage, le triple-buffering peut finir de lesnettoyer. 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 avezdû remarquer que le compteur d'images par secondes est de 70-85 (bizarrement comme votre rafraichissementd'é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).

lien : Comment accélérer le rendu graphique de mon dessin ?lien : Comment utiliser le double-buffering software ?lien : Comment utiliser le double-buffering hardware ?



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 :

Robot robot = new Robot();BufferedImage image = robot.createScreenCapture( new Rectangle(java.awt.Toolkit.getDefaultToolkit().getScreenSize()) );

Capture d'une fenêtre :

Robot robot = new Robot();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 unebibliothè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 lesimages renvoyées par le Toolkit sont chargées en arrière plan.





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 estvalable que l'image se trouve ou non dans une archive, il est donc préférable de toujours utiliser le ClassLoader afin delimiter 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 classesexté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 typesd'images que l'on peut lire ou écrire en fonction du nom du format, du type MIME ou du suffixe d'un fichier. Voiciun 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);



http://java.sun.com/j2se/1.4/docs/guide/imageio/index.html

http://java.sun.com/products/jdk/1.2/docs/guide/2d/api-jpeg/overview-summary.html

http://www.acme.com/java/software/Acme.JPM.Encoders.GifEncoder.html

http://xml.apache.org/batik

http://www.geocities.com/marcoschmidt.geo/java-image-coding.html


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 lecturecanWrite("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éthodesgetReaderFormatNames 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 lisiblesSystem.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 accéder à une image ?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éalisationd'une telle classe n'est pas compliquée, il suffit de créer un nouveau composant héritant de JComponent et de surchargerla méthode paintComponent.

La méthode paintComponent(Graphique g) est chargée de dessiner le composant ; les composants fils seront dessinéspar 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); } }




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'afficherl'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 étantparfois mal faite, il est courant de trouver dans l'API des méthodes nous retournant des images, mais assez rarementdes 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.




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 enfaisant la moyenne pondérée de sa couleur et de celles de ses voisins. Il suffit de modifier les coefficients et le nombrede voisins pour intervenir sur le résultat, plus le poids des voisins est important, plus l'image sera floue. De plus, onpeut choisir le poids d'un voisin en fonction de sa position, ce qui permet d'attribuer des poids différents et d'obtenirdes 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 imageet dessiner la version transformée dans cette nouvelle image.

/** Création d'une nouvelle image */BufferedImage nouvelleImage = new BufferedImage(







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 appelsdirects 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) etla composante alpha (le niveau de transparence). Chaque composante est codée sur 8 bits (bleu 0-7, vert 8-15, rouge16-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;





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 :




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 retrouveen 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èsfacile 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 frameparente.

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 lesimages PNG qui ne sont pas gérés par tous les OS, certains OS vont l'afficher mais supprimmer la transparence etd'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 estobligé de passer par un PixelGrabber.

Voici une méthode permettant de récuperer cette information quelque soit le type de l'image :







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 BufferedImageg2d.fillOval( 30, 30, 100, 100 ); // on dessine un cercle de centre x=30 y=30 et de rayon=100g2d.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 durantl'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érerle Graphics2D de la première image et ensuite configurer l'anti-aliasing et la interpolation sur le Graphics2D. On peutensuite 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 ;}






FAQ Java GUI



Sommaire > AWT et Swing



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 jdkalors que Swing n'est apparue qu'à la version 1.2 du jdk (soit Java 2). Il en résulte donc des différences fondamentalesde 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 parle 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 deperformance, et consommation excessive de mémoire). C'est pour cette raison que l'on qualifie les composants AWTpar 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'uneimage, 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 lesajouter à 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 citeraique : la gestion de bordure, les info-bulles, le défilement, les Look And Feel, de nouveaux LayoutManager, ainsi quel'architecture MVC (Model-View-Control). Maintenant que l'on a conscience de ces différences, une question reste toutde 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. Desproblè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 etSwing ?.

Le composant JFrame comprend un objet fils qui prend en charge tout ce qui concerne le graphique, il s'agit d'uneinstance 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).





FAQ Java GUI



• Le composant LayeredPane permet d'insérer une barre de menu ainsi que tout autre composant (cela faitréférence au fameux contentPane de jframe.getContentPane ()). il est également chargé du Z-ordering (algorithmepermettant 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 typejava.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)



FAQ Java GUI



La seule solution envisageable est d'uniformiser le code sur la librairie graphique utilisée, soit tout AWT, soit toutSwing !

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 defigure cela représente beaucoup de code et de contraintes. En effet, les instructions qui affectent ou dépendent d'uncomposant 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 peutdirectement 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 interfacenon 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, lescoordonnées correspondent au coin haut-gauche du menu. Si ces coordonnées sont trop près du bord de l'écran, unepartie du menu est alors cachée. Nous allons donc surcharger la méthode show() pour que les coordonnées soientcorrigées si le message est trop proche du bord de l'écran.

class MonPopupMenu extends JPopupMenu {





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érivantpar 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 enargument 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.






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 dansune 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(); }






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 estchargé de toutes les opérations liées à l'affichage et à la gestion des évènements, le processus "the event dispatchingthread". 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 progressionpar 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 JProgressBarsJProgress.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 utilisantSwingUtilities.updateComponentTreeUI. Voici un exemple changeant le look and feel de l'application pour le look andfeel natif (celui naturellement utilisé par le système).

JFrame frame = new JFrame();frame.setVisible(true);// etc.





http://java.sun.com/docs/books/tutorial/uiswing/components/progress.html


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. Voiciun exemple récupérant l'ensemble des look and feels sous forme de Map, dont les clefs sont les noms des L&F et lesvaleurs 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ètrecorrespond à 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 pasforcément des plus esthétiques.





http://home.tiscali.nl/~bmc88/java/sbook/061.html


FAQ Java GUI



Heureusement il est possible de rémédier à cela en modifiant la propriété swing.boldMetal, soit directement via la classeUIManager :

// 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 Feellien : 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 soitle 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());



http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/plaf/metal/MetalLookAndFeel.html


FAQ Java GUI



La méthode "configureRootPane" ne devrait être appelée qu'une fois, par exemple juste après l'instanciation de votreconteneur. 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); }







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;




http://java.sun.com/j2se/1.4.2/docs/api/java/util/Locale.html

http://www.developpez.net/forums/u140600/gifffftane/

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;



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); } }); }}



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 dialoguecorrespond à 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 etle répertoire par défaut. Sous windows, ces deux répertoires correspondent au bureau et à "Mes documents". Vouspouvez donc facilement positionner le JFileChooser. Par exemple :

FileSystemView vueSysteme = FileSystemView.getFileSystemView(); //récupération des répertoiresFile defaut = vueSysteme.getDefaultDirectory(); File home = vueSysteme.getHomeDirectory(); //création et affichage des JFileChooserJFileChooser 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 devrezfaire 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.






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);chooser.showOpenDialog(null);

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 exemplede 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 choisicette possibilité car c'est ce qui est le plus couramment rencontré. Vous pouvez tout à fait faire des filtres sur les taillesdes 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 plusieursextensions. Quelques méthodes supplémentaires sont définies pour des facilités d'utilisation.





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.description = description; 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."); } this.description = description; } 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);chooser.showOpenDialog(null);



FAQ Java GUI



filtre.addExtension(".class");chooser.showOpenDialog(null);

filtre.setDescription("Fichiers class");filtre.removeExtension(".java");chooser.showOpenDialog(null);

filtre.setDescription("Tous les fichiers");filtre.clearExtensions();chooser.showOpenDialog(null);

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 composantaccessoire. Ce composant peut se mettre à l'écoute des événements relatifs au JFileChooser grâce à unPropertyChangeListener.

Vous pouvez donc utiliser cet accessoire pour par exemple prévisualiser des images ou simplement pour avoir desinformations détaillées sur le fichier sélectionné. Voici un exemple de rendu (vous pouvez télécharger l'implémentationci-dessous) :




FAQ Java GUI



FilePreview.java



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





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 desbalises '<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 letexte n'est pas fixé dans le code... Cette solution est néanmoins plus contraignante sur la mise en page et sur la gestionde 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 classejavax.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 ();






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 lesplus jolies. Je parle ici évidemment de java.awt.event.KeyListener ou javax.swing.event.DocumentListener et autres dumême genre. Pour moi, ces solutions sont des solutions de rattrapage car techniquement elles permettent uniquementde nous informer d'un changement. Or si le changement est fait cela veux donc dire que le « mal » est déjà fait. Cequi 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 demodifier directement ce que peut contenir un composant texte en ignorant tout le reste. Pour se faire il suffit de créerune 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éthodeinsertString(int, java.lang.String, javax.swing.text.AttributeSet) et remove(int, int). Il suffit donc de créer une classequi 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éthodesinsertString 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é ducomposant 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ésmais 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 unnouveau MaskFormatter avec le masque de votre choix puis d'installer ce mask sur votre JFormattedTextField via laméthode install de MaskFormatter. Cela permet encore plus de fonctionnalités à ce composant.

lien : Model-View-Controller ArchitectureExemple 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)






http://java.sun.com/blueprints/patterns/j2ee_patterns/model_view_controller/

http://java.sun.com/blueprints/patterns/j2ee_patterns/model_view_controller/


FAQ Java GUI



La classe JFormattedTextField possède un constructeur prenant en paramètre un Format. Cela permet de spécifer unformat au champ de saisie.

Classes dérivées de Format :• DateFormat• MessageFormat• NumberFormat

// champ de saisie depourcentagesJFormattedTextField champPourcentage = new JFormattedTextField(NumberFormat.getPercentInstance()); // champ de saisie de datesJFormattedTextField champDate = new JFormattedTextField(DateFormat.getDateInstance()); // Dec 31, 2000JFormattedTextField(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 Francenew MaskFormatter("## ## ## ## ##"); // pour un n° de sécurité socialnew 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



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éthodeinsertString(). 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 deDefaultStyledDocument.

JTextPane monComposantTexte = new JTextPane ();DefaultStyledDocument doc = (DefaultStyledDocument) monComposantTexte.getDocument ();doc.setCharacterAttributes (positionDeDepart, longueur, style, true);




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();






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 dejavax.swing.table.DefaultTableModel et redéfinir la méthode isCellEditable(int,int) afin que cette dernière retournefaux 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 pasaffiché. 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 leparamètre récupéré sur l'évènement java.awt.event.MouseEvent

int colonne, ligne;Point p = e.getPoint ();colonne = jtable.columnAtPoint (p);







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 toutattente, la méthode permettant d'intervenir sur cette propriété n'est pas dans la classe JTable, mais dans la classejavax.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 selectionnerles 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 plusapproprié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();






FAQ Java GUI



// on applique le renderer à la tabletable.setDefaultRenderer(Object.class, new CenterTableCellRenderer());

- Soit à une colonne en particulier :

// on applique le renderer à la colonne d'indice 0table.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 tableTableCellRenderer 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 0TableCellRenderer 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 composantne 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 pardé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éfautDefaultMutableTreeNode.

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 pourafficher une représentation de l'objet à un noeud donné. Pour un arbre représentant un système de fichiers, des objetsFile pourront être utilisés.



http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/table/DefaultTableCellRenderer.html


http://javasearch.developpez.com/j2se/1.5.0/docs/api/javax/swing/JTree.html


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'instructionsuivante:

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 del'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"));






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 classeDefaultTreeCellRenderer, permettant ainsi de modifier les icônes, la police et la couleur de fond des différents noeudsde 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 desinformations 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 oudé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érentesvaleurs 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 denoeuds). Exemple :

myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);





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 suiteaux 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 êtreimplé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 packagejavax.swing.event.

Chaque listener dispose d'une classe Event associée. Cette classe étend java.awt.event.EventObject et fournit unedescription de l'évènement capturé. Par exemple, la classe ActionEvent décrit les évènements capturés par unActionListener.

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 { // Bouton 2 a été cliqué } } }





FAQ Java GUI



Tout d'abord, à l'étape 1, nous déclarons une classe « MaClasse » qui implémente l'interface ActionListener (nousl'étudierons plus en détail dans une autre Q/R). Puisque nous implémentons l'interface, nous devons égalementimplé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éfiniedans 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. Nouspouvons 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 nouspré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) lasource 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 pourl'exemple.

// Étape 1 : déclaration de la classepublic 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() { public void actionPerformed(ActionEvent e) { // 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() { public void actionPerformed(ActionEvent e) { // Cette méthode ne sera appelée que pour les évènements sur le bouton monBouton2. } }); }




FAQ Java GUI



Dès le début nous pouvons remarquer quelques différences avec la première méthode d'utilisation traitéeprécédemment.

Tout d'abord notre classe MaClasse n'implémente pas l'interface ActionListener. Aucune instance de la classe MaClassene 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'interfaceActionListener dans une classe anonyme, sans garder de référence vers cette classe anonyme. Dans ce cas, nous devonsle 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, nousn'avons pas à dissocier les composants « source » (les composants écoutés par le listener), comme nous le faisons dansla première possibilité.

En contrepartie, nous devons créer une classe anonyme à chaque fois. Une autre possibilité qui est une simple variantede celle présentée ici est la suivante :

// Étape 1 : déclaration de la classepublic 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() { public void actionPerformed(ActionEvent e) { if(e.getSource() == monBouton) { // Bouton 1 a été cliqué }else { // Bouton 2 a été cliqué } } }; 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 foisque nécessaire. Cependant, cette façon de faire nous oblige à différencier les composants « source » pour implémenterun 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.javapublic class MonListener implements ActionListener { public void actionPerformed(ActionEvent e) { } }




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 lelistener, puis, vous créez une instance de cette classe que vous passez en paramètre de la méthode addXXXListenersitué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 sontmultiples, la principale étant l'activation d'un bouton (par un clic ou par appui de la touche Entrée lorsque le boutonest 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() estparticuliè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éessont 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.*; // Étape 1 : déclaration de la classe 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 monBouton.addActionListener(this); monBouton.addActionListener(this); } // Étape 4 : l'implémentation de l'ActionListener public void actionPerformed(ActionEvent e) { 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 !"); }




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éthodeactionPerformed est invoquée.

Cependant, nous avons deux boutons, et un clic sur chacun d'eux invoquera la même implémentation del'ActionListener. Nous devons donc différencier le bouton source de l'action. Cela peut se réaliser de deux façons : soit oncompare 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 comparaisonde 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 permettantla saisi de texte (JTextField, JTextArea, etc).

Trois méthodes sont déclarées dans l'interface du KeyListener : keyTyped(KeyEvent e), keyPressed(KeyEvent e) etkeyReleased(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 (notammentgetSource() ), 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 touchepressée, isActionKey() retourne true si la touche appuyée est une touche d'action (CAPS LOCK, Verr Num, etc), etgetKeyText(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) {




FAQ Java GUI



/* Cette méthode est appelée quand l'utilisateur appuie sur une touche Unicode (donc les caractères) et ne prend pas en compte les touches comme F1, Echap, ALT, etc. */ System.out.println(e.getKeyChar()); }

// Étape 5: on implémente la méthode keyPressed définie dans l'interface KeyListenerpublic 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 ne disposent pas d'un équivalent en Unicode, et donc ne peuvent être représentées en char. */ 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 KeyListenerpublic 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 relâchée.}

}

Le code est assez explicite, et les commentaires précises quelques points obscures. Rien de nouveaux dans ce code, si cen'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, ilexiste 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 KeyListenerlien : 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 (lasouris a été pressée puis relâchée), mousePressed(MouseEvent e) pour les pressions sur la souris (donc on enfoncele 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(MouseEvente) 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 (notammentgetSource() ), mais fournit également 12 autres méthodes spécifiques aux événements relatifs à la souris, notammentgetButton() retourne le bouton qui a été cliqué, getClickCount() retourne le nombre de clics (utile pour gérer le doubleclic), getLocationOnScreen() retourne un objet Point représentant la position de la souris à l'écran, et enfin



http://java.sun.com/j2se/1.4.2/docs/api/java/awt/event/KeyListener.html

http://java.sun.com/j2se/1.4.2/docs/api/java/awt/event/KeyEvent.html


FAQ Java GUI



isPopupTrigger() précise si le bouton cliqué est celui habituellement utilisé pour afficher la liste déroulante (boutondroit 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 lourdd'implémenter chacune des méthodes..Il existe donc une classe abstraite MouseAdapter qui vous permet d'implémenter seulement les méthodes qui vousinté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




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 estrendue 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 den'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.




FAQ Java GUI



Cette interface déclare 2 méthodes : focusGained(FocusEvent e) indique que le composant a gagné le focus clavier tandisque 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 (notammentgetSource() ), mais fournit également 3 autres méthodes spécifiques aux événements relatifs aux fenêtres, notammentisTemporary() qui indique si le composant n'a le focus que temporairement, et getOppositeComponent() qui retournel'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 (notammentgetSource() ), mais fournit également 4 autres méthodes spécifiques aux événements relatifs aux fenêtres, notammentgetItem() 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), vousdisposez 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) {




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 sontpossibles : ItemEvent.ITEM_SELECTED et ItemEvent.DESELECTED. Il faut bien comprendre que la méthodeitemStateChanged est invoquée deux fois : une fois pour l'élément qui vient d'être désélectionné et une fois pour celuiqui vient d'être sélectionné (ceci est vrai dans le cas d'une JComboBox par exemple). Il est donc important de faire ladifférence, sous peine de voir son code exécuté deux fois.



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 uneFrame. Il suffit donc d'utiliser getParent() sur l'Applet pour récupérer cette Frame et s'en servir ( éventuellement demaniè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 :






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 decré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 :





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 fairefaire du son à votre applet.

try { URL url = new URL("http://serveur.fr/monSon.au"); AudioClip ac = Applet.newAudioClip(url); ac.play();} catch( MalformedURLException e ) { }




http://www.javasoft.com/products/plugin/1.3/docs/tags.html

http://www.javasoft.com/products/plugin/1.3/docs/tags.html


http://www.suitable.com/docs/signing.html


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 avantd'éviter des exceptions.

Vous pouvez aussi spécifier une adresse de destination :

if(Desktop.isDesktopSupported(){ if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.MAIL){ try { java.awt.Desktop.getDesktop().mail(new java.net.URI("mailto:[email protected]")); } 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}

Vous pouvez aussi spécifier les autres éléments du mailto selon la RFC 2368 (voir plus bas).

lien : Classe Desktoplien : 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 fautemployer la classe java.awt.Desktop pour cela.

Par exemple, pour ouvrir l'explorateur par défaut sur le site Java de Developpez.com :





http://java.sun.com/javase/6/docs/api/java/awt/Desktop.html

http://www.ietf.org/rfc/rfc2368.txt


FAQ Java GUI



if(Desktop.isDesktopSupported(){ if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.BROWSE){ try { java.awt.Desktop.getDesktop().browse(new URI("http://java.developpez.com")); } catch (IOException ex) { //Traitement de l'exception } catch (URISyntaxException uri) { //Traitement de l'exception } } else { //La fonction n'est pas supportée par votre système d'exploitation }}else { //Desktop pas supportée par votre système d'exploitation}


lien : Classe Desktop

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 defichier. 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.isDesktopSupported(){ if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.OPEN){ try { java.awt.Desktop.getDesktop().open(new File("C:\\Test.pdf")); } catch (IOException ex) { //Traitement de l'exception } } else { //La fonction n'est pas supportée par votre système d'exploitation }}else { //Desktop pas supportée par votre système d'exploitation}



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 defichier. Il vous faut employer la classe java.awt.Desktop pour cela.







FAQ Java GUI



Par exemple, pour imprimer un fichier (C:\\Test.pdf) avec le programme par défaut pour les PDF :

if(Desktop.isDesktopSupported(){ if(Desktop.getDesktop().isSupported(java.awt.Desktop.Action.PRINT){ try { java.awt.Desktop.getDesktop().print(new File("C:\\Test.pdf")); } catch (IOException ex) { //Traitement de l'exception } } else { //La fonction n'est pas supportée par votre système d'exploitation }}else { //Desktop pas supportée par votre système d'exploitation}






Faq Java Gui

Documents

Transcript of Faq Java Gui