FAQ Java GUI - WordPress.com · La méthode setLocationRelativeTo(java.awt.Component) de la classe java.awt.Window permets de faire un centrage par rapport à un composant ou à l'écran

FAQ Java GUI

Date de publication : 15 novembre 2008

Dernière mise à jour : 21 décembre 2009

Cette faq a été réalisée à partir des questions fréquemment posées sur lesforums de http://www.developpez.com et de l'expérience personnelle desauteurs.

Nous tenons à souligner que cette faq ne garantit en aucun cas que lesinformations qu'elle propose sont correctes. Les auteurs font leur maximum,mais l'erreur est humaine. Cette faq ne prétend pas non plus être complète.Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenantré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 - BaptisteWicht - JMLLB - Janitrix - d-jo - fxjtarga - Pill_S - Orian -le y@m's - Jack Huser - seiryujay - morph41 - gifffftane -tchize_ - bouye - sinpay - sovo - ReunionIsland - if_zen -


http://www.developpez.net/forums/u72264/bazinou/

http://www.developpez.net/forums/u10854/iubito/

http://www.developpez.net/forums/u51/clement-cunin/

http://www.developpez.net/forums/u28/johann-heymes/

http://www.developpez.net/forums/u395/ronan-le-gallo/

http://www.developpez.net/forums/u395/ronan-le-gallo/

http://www.developpez.net/forums/u156/knotty/

http://www.developpez.net/forums/u2410/greg01/

http://www.developpez.net/forums/u5530/sebastien-meric/

http://www.jext.org

http://www.developpez.net/forums/u443/pierre-yves-varoux/

http://www.developpez.net/forums/u19368/ioan/

http://www.developpez.net/forums/u14756/bahamouth/

http://www.developpez.net/forums/u21919/duj/

http://www.developpez.net/forums/u12421/braim/

http://www.developpez.net/forums/u31376/bulbo/

http://www.developpez.net/forums/u24613/ricky81/


http://www.developpez.net/forums/u5776/debernad/

http://www.developpez.net/forums/u8396/jcarre/

http://www.developpez.net/forums/u36570/narkotik/

http://www.developpez.net/forums/u2929/cyberzoide/

http://www.developpez.net/forums/u31520/xavlours/

http://www.developpez.net/forums/u35163/christophej/

http://www.developpez.net/forums/u19457/willowii/

http://www.developpez.net/forums/u34797/bigboomshakala/

http://www.developpez.net/forums/u132/laffreuxthomas/

http://www.developpez.net/forums/u1195/adiguba/

http://www.developpez.net/forums/u19483/tsume/

http://www.developpez.net/forums/u24089/wammaster/

http://www.developpez.net/forums/u30643/lakestionkitue/

http://www.developpez.net/forums/u38277/strab/

http://www.developpez.net/forums/u51129/joseph_p/

http://www.developpez.net/forums/u75080/baptiste-wicht/


http://www.developpez.net/forums/u115462/jmllb/

http://www.developpez.net/forums/u75354/janitrix/

http://www.developpez.net/forums/u71516/d-jo/

http://www.developpez.net/forums/u12975/fxjtarga/

http://www.developpez.net/forums/u28773/pill_s/

http://www.developpez.net/forums/u110786/orian/

http://www.developpez.net/forums/u56035/le-y-m-s/

http://www.developpez.net/forums/u50398/jack-huser/

http://www.developpez.net/forums/u32070/seiryujay/

http://www.developpez.net/forums/u62963/cheryben/

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

http://www.developpez.net/forums/u188305/tchize_/

http://www.developpez.net/forums/u71025/bouye/

http://www.developpez.net/forums/u219543/sinpay/

http://www.developpez.net/forums/u32076/sovo/

http://www.developpez.net/forums/u74016/reunionisland/

http://www.developpez.net/forums/u40298/if_zen/

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 documentconstitue une oeuvre intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences,en fonction des contributeurs : - Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDLtraduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymestant que cette note apparaît clairement : "Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en françaisici. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement". - Pour ce qui est desautres contributions : Copyright © 2004 - 2009 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction ne peut en être faitesans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommageset 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 (23) ................................................................................................ 63. La souris et le clavier (9) .....................................................................................................................................244. Le dessin (12) ...................................................................................................................................................... 285. Les images (19) ................................................................................................................................................... 366. AWT et Swing (71) ...............................................................................................................................................47

6.1. Généralités (27) ........................................................................................................................................... 486.2. JFileChooser (5) .......................................................................................................................................... 636.3. JColorChooser (2) ........................................................................................................................................686.4. Composants textuels (9) ..............................................................................................................................696.5. Tableaux et arbres (JTable et JTree) (18) ................................................................................................... 756.6. Les listeners (10) ......................................................................................................................................... 81

7. Applets (8) ............................................................................................................................................................ 918. Divers et astuces (5) ............................................................................................................................................94



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 desréponses simples et complètes aux questions auxquelles sont confrontés tous les débutants (et les autres).

L'organisation :Les questions sont organisées par thème, les thèmes pouvant eux-même contenir des sous-thèmes. Lorsqu'une question porte sur plusieurs thèmes, celle-ci est insérée dans chacun des thèmesrendant la recherche plus facile.

Les réponses :Les réponses contiennent des explications et des codes sources. Certaines sont complétéesde fichier à télécharger contenant un programme de démonstration. Ces programmes sont volontairementtrès simples afin qu'il soit aisé de localiser le code intéressant. Les réponses peuvent également êtrecomplétées de liens vers d'autres réponses, vers la documentation en ligne de Sun ou vers un autre siteen rapport.

Nouveautés et mises à jour :Lors de l'ajout ou de la modification d'une question/réponse, un indicateur estplacé à coté du titre de la question. Cet indicateur reste visible pour une durée de 15 jours afin de vouspermettre de voir rapidement les modifications apportées.

J'espère que cette faq pourra répondre à vos questions. N'hésitez pas à nous faire part de touscommentaires/remarques/critiques.

lien : Comment participer à cette faq ?

Comment participer à cette faq ?Auteurs : L'équipe Java ,Cette faq est ouverte à toute collaboration. Pour éviter la multiplication des versions, il serait préférableque toutes collaborations soient transmises aux administrateurs de la faq.Plusieurs compétences sont actuellement recherchées pour améliorer cette faq :

Rédacteur :Bien évidemment, toute nouvelle question/réponse est la bienvenue.

Web designer :Toute personne capable de faire une meilleur mise en page, une feuille de style ou de bellesimages...

Correcteur :Malgré nos efforts, des fautes d'orthographe ou de grammaire peuvent subsister. Merci decontacter les administrateurs si vous en débusquez une... Idem pour les liens erronés.

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

Quels sont les droits de reproduction de cette FAQ ?Auteurs : L'équipe Java ,Les codes sources présentés sur cette page sont libres de droits et vous pouvez les utiliser à votreconvenance. Pour le reste, ce document constitue une oeuvre intellectuelle protégée par les droitsd'auteurs.






FAQ Java GUI



Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction descontributeurs :

- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la licence GNU FDLtraduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributionsde Clément Cunin et Johann Heymes tant que cette note apparaît clairement :"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici.Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaîtclairement".

- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservésDeveloppez LLC. Aucune reproduction ne peut en être faite sans l'autorisation expresse de DeveloppezLLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.Cette page est déposée à la SACD.

Où trouver d'autres sources d'information ?Auteurs : L'équipe Java ,• 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 ...

RemerciementsAuteurs : L'équipe Java ,Un grand merci à tous ceux qui ont pris de leur temps pour la réalisation de cette FAQ.

Aux rédacteurs :Remerciements tout d'abord à tous ceux qui ont rédigé les questions et les réponses.Clément Cunin, Johann Heymes, Nicolas Cuny, Ronan Le Gallo, Christophe Ludet, Jean-Baptiste Bugeaud,Sebastien Andreo, Grégory Danelon, Sébastien Meric, Romain Guy, Pierre-Yves Varoux, Ioan, bahamouth,duj, Braim, bulbo, Ricky81, Debernad, jcarre, David Seigne, xavlours, christopheJ, willowII, Nourdine Falola,laffreuxthomas.

Aux correcteurs :Remerciements également aux personnes qui ont relu les textes pour supprimer unmaximum de fautes de français.Nicolas Cuny, Jonathan Muller, Etienne Bar, Bestiol, Ukyuu.

Aux visiteurs :Remerciements enfin à tous ceux qui ont consulté cette FAQ, et qui, par leurs remarques,nous ont aidé à la perfectionner.

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



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/j2se/1.4/docs/api/index.html

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

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


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







http://www.jext.org























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 ?Auteurs : Clément Cunin ,A partir du JDK 1.4 :Le JDK 1.4 offre une méthode de centrage automatique des fenêtres, plus besoin defaire cela à la main... La méthode setLocationRelativeTo(java.awt.Component) de la classe java.awt.Windowpermets 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 notrefenêtre... Généralement juste avant de la rendre visible. (si le paramètre est null ou que le composant n'estpas affiché, le centrage est fait par rapport à l'écran.)

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

JDK 1.3 et antérieurs :Aucune méthode ne fait cela automatiquement, mais il est très facile de positionnersoit-même la fenêtre lors de l'initialisation.

/** Lecture de la taille de l'écran */java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize(); frame.pack();/* la fenêtre prend sa taille... */frame.setLocation( (screenSize.width-frame.getWidth())/2, (screenSize.height-frame.getHeight())/2 );

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

Comment centrer verticalement et horizontalement un composant ?Auteurs : Johann Heymes ,Centré autour de ses quatres composants voisins Réponse toute simple : en utilisant le LayoutManagerapproprié à ce cas de figure, à savoir java.awt.BorderLayout.

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,






FAQ Java GUI



* car il s'agit de la valeur par défaut */

N'oubliez pas que la caractéristique principale du BorderLayout est d'ajuster la dimension du composantà la place disponible.

Centré sur son conteneur (JPanel )Là aussi c'est le choix du LayoutManager qui résout le problème, maisil est nécessaire d'en prendre un quelque peu plus compliqué : java.awt.GridBagLayout.

JPanel p = new JPanel (new GridBagLayout ()); p.add (composant, new GridBagConstraints (0, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.CENTER, new Insets (0,0,0,0), 0, 0));

Comment positionner les composants dans un conteneur ?Auteurs : Nourdine Falola ,A l'aide des gestionnaires de mise en formeJava propose un certain nombre gestionnaires de mise en forme, ou layout managers, qui permettentde placer les composants sans en indiquer la position précise (les coordonnées), mais la dispositionsouhaité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 enforme personnalisés.En spécifiant les coordonnéesIl est possible de se passer des gestionnaires de mise en forme pour le placement des composants. Pourcela, on définit le gestionnaire de mise en forme du contenant à null, on ajoute le composant au contenantet on spécifie la position absolue et la taille voulue du composant :

setLayout(null);JButton ok = new JButton("OK");ok.setBounds(x,y,width,height); // param int

Comment utiliser le FlowLayout ?Auteurs : Nourdine Falola ,Ce gestionnaire aligne horizontalement les composants, en préservant la taille de ceux-ci, jusqu'à ce qu'iln'y ait plus de place. Lorsque la ligne est remplie, les composants suivant sont placés à la ligne suivanteet ainsi de suite.Par défaut les composants sont centrés horizontalement. Lorsque la taille du conteneur est modifiée, lescomposants sont réorganisés automatiquement. FlowLayout est le gestionnaire de mise en forme pardéfaut des JPanel.





FAQ Java GUI



class FlowLayoutFrame extends JFrame{ 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 ?Auteurs : Nourdine Falola ,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. Lescomposants en bordure sont placés en premier, puis l'espace restant est occupé par le composant central.Ce gestionnaire modifie la taille des composants afin qu'ils prennent tout l'espace disponible. En cas 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();




FAQ Java GUI



// ------------ par défaut pour le JFrame ------------ // 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 ?Auteurs : Nourdine Falola ,Ce gestionnaire arrange les composants sur une grille dont on spécifie le nombre de cases horizontaleset verticales.Un composant est redimensionné afin de prendre tout l'espace de la cellule, et chaque cellule est detaille identique. Lorsque la fenêtre est redimensionnée, les cellules se partagent équitablement l'espacedisponible. Les composants sont ajoutés ligne par ligne à partir de la cellule du coin supérieur gauche.

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




FAQ Java GUI



setLayout(new GridLayout(2,3)); Container c = getContentPane(); 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 ?Auteurs : Nourdine Falola ,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 unBoxLayout.Utiliser des Box nous permet d'avoir plusieurs BoxLayout dans un même conteneur (dans le JFrame parexemple).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éservesentre les composants. Il en existe 3 types :

• le Strut, qui ajoute un espace mesuré en nombre de pixels. Le Strut est unidimensionnel : il existeun 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.




FAQ Java GUI



Stratégie de mise en forme :- Le BoxLayout horizontal calcul la taille maximale du plus haut composant et tente d'agrandir tous lesautres composants à la même hauteur. Les composants qui n'ont pu atteindre cette hauteur sont alignés(appel à getAlignementY()). Les largeurs préférées des composants sont additionnées. Si la largeur duBoxLayout ne correspond pas à cette somme, la taille des composants est ajustée dans les limites destailles min et max. Si le Box est trop petit, des composants ne seront pas affichés.- 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 ?Auteurs : Nourdine Falola ,La terreur du débutant ! Comme le GridLayout, ce gestionnaire permet de placer les composants sur unegrille, mais avec plus de flexibilité.Le GridBagLayout fonctionne comme un tableau dont les cellules peuvent être fusionnées.Pour placer les composants, il faut :

• instancier un GridBagLayout et le passer comme gestionnaire du conteneur• définir un GridBagConstraints pourr chaque composant• ajouter chaque paire composant/GridBagConstraints au conteneur

Ce sont les contraintes qui détermineront la position des composants et le comportement en cas deredimenssionnement de la fenêtre. Les paramètres d'un GridBagConstraints sont :

• gridx, gridy (int) : numéros de ligne et de colonne du coin supérieur gauche de la zone d'affichagedu 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 envaleurs absolues, par la constante GridBagConstraints.RELATIVE. Pour indiquer qu'un composantest le dernier d'une ligne, on donne alors à la largeur de sa zone d'affichage (gridwidth) la valeurGridBagConstraints.REMAINDER. On donne cette même valeur à la hauteur de la zone d'affichage descomposants de la dernière ligne.Etapes pour utiliser un GridBagLayout: [1] Mettre en forme le composant sur papier.




FAQ Java GUI



[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 lescomposants qui restent toujours à leur taille par défaut. [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();



FAQ Java GUI



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



FAQ Java GUI



+ (italic.isSelected() ? Font.ITALIC : 0); int fontSize = Integer.parseInt((String) size.getSelectedItem()); Font font = new Font(fontFace, fontStyle, fontSize); sample.setFont(font); sample.repaint(); } }}

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ètrequi avait été modifié pour un précédent composant). Aussi est-il préférable d'utiliser un nouveauGriBagConstraints pour chaque composant.

Comment simplifier l'utilisation du GridBagLayout ?Auteurs : Nourdine Falola ,Le plus complexe avec le GridBagLayout, c'est l'écriture des contraintes. Les auteurs du livre "Au coeur deJava2 : Notions fondamentales" proposent une classe qui simplifie énormément l'écriture des contrainteset 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" });




FAQ Java GUI



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!"); 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 ?Auteurs : Clément Cunin ,Le passage en plein écran est très utile pour la programmation de jeu, mais aussi dans les applications àtitre ponctuel pour faire une prévisualisation d'impression, d'image, pour faire un diaporama ou autres ...

Passage en plein écran :Le passage de l'affichage en plein écran est une nouvelle fonctionnalité de j2se1.4. La classe java.awt.GraphicsEnvironment permet de connaître la liste des écrans. Il est fortement



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


FAQ Java GUI



recommandée de vérifier que le plein écran est supporté ; si ce n'est pas le cas la fenêtre est redimensionnéepour prendre tout l'écran mais elle n'a pas l'exclusivité de l'affichage.

GraphicsDevice myDevice = java.awt.GraphicsEnvironment. getLocalGraphicsEnvironment().getDefaultScreenDevice();Window myWindow;if( myDevice.isFullScreenSupported() ) { try { myDevice.setFullScreenWindow(myWindow); /** ... */ } 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 augmenterla performance d'affichage ( moins il y a de pixels, mieux c'est ). Une configuration est définie par uneinstance 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 vousconseille de vous renseigner un minimum sur les techniques d'optimisation et d'accélération de l'affichage(vois lien ci-dessous).

Et les applets ?Les applets sont autorisées à passer en affichage plein écran seulement si l'utilisateur ala permission fullScreenExclusive.

lien : http://java.sun.com/docs/books/tutorial/extra/fullscreen/lien : Comment accélérer le rendu graphique de mon dessin ?lien : Comment utiliser le double-buffering software ?

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

Image icone = Toolkit.getDefaultToolkit().getImage("./monImage.jpg");maFenetre.setIconImage(icone);

Si l'image n'apparaît pas, c'est certainement que le paramètre image a une valeur 'null'.



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



FAQ Java GUI



Une autre raison pour laquelle cette image n'apparaitrait serait un problème au niveau de la transparenceavec les images PNG qui ne sont pas gérés par tous les OS, certains OS vont l'afficher mais supprimmerla transparence et d'autres ne pas l'afficher.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 ?Auteurs : Clément Cunin ,Lorsque l'on affiche une fenêtre à l'écran, la machine virtuelle alloue la mémoire et les ressources systèmesnécessaires à la création de l'image de cette fenêtre à l'écran. Les méthodes hide() et dispose() font tousles deux disparaître la fenêtre de l'écran ; en revanche, elles diffèrent par leur action sur la mémoire.

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

Détruire une fenêtre avec dispose() :La méthode dispose() restitue les ressources au système. Lesressources libérées ne concernent que les objets utilisés pour la construction de l'image, les différentscomposants que vous avez placés dans la fenêtre restent en mémoire comme n'importe quel autre objet.Même après avoir été détruit, on peut toujours utiliser la méthode show() pour réafficher la fenêtre (denouvelles 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 ?Auteurs : Clément Cunin ,AWT :Lorsque l'on créer une fenêtre avec AWT, aucune action n'est associée à la commande de fermeturede 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 pardé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.• EXIT_ON_CLOSE - Quitte l'application.





FAQ Java GUI



Note : La solution utilisée avec AWT reste valable avec Swing, elle permet d'effectuer des traitements pluscomplexes en parallèle du traitement par défaut.

lien : Quelle différence entre cacher et détruire une fenêtre ?

Comment faire une fenêtre sans barre des titres ?Auteurs : Clément Cunin ,Frame & JFrame (JDK1.3 et précédants)Les classes java.awt.Frame et javax.swing.JFrame correspondentaux fenêtres du système d'exploitation, il n'est pas possible de changer l'apparence de la barre des titresni des boutons de fermeture et d'agrandissement.

Window & JWindowContrairement aux 2 classes précédentes, java.awt.Window et javax.swing.JWindowdéfinissent une fenêtre sans aucun cadre ni barre de titre. Elles sont donc idéales pour faire des écransde démarrage ou des interfaces personnalisées.

A partir du JDK1.4Le jdk1.4 définit une nouvelle méthode setUndecorated(boolean) pour les classesjava.awt.Frame et java.awt.Dialog. Attention : cette méthode doit être appelée avant le premier affichagede 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éthodesetExtendedState de la classe Frame. Par exemple, pour maximiser de tous les côtés votre fenêtre, vouspouvez 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êmeque pour setExtendedState, à la différence qu'il n'existe pas de paramètre permettant de maximiser. Si vousvoulez tout de même avoir l'impression que votre fenêtre est maximisée, c'est à dire qu'elle prenne toutela place disponible à l'écran, tout en gardant visible la barre d'outils, vous pouvez faire comme ceci :

public void maximiser(Frame frame){ Toolkit kit = Toolkit.getDefaultToolkit(); //récupération de la taille de l'écran et des rebords Insets insets = kit.getScreenInsets(frame.getGraphicsConfiguration()); Dimension screen = kit.getScreenSize();





FAQ Java GUI



//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 ?Auteurs : Ioan Calapodescu ,Pour garder une fenêtre toujours au premier plan, il faut utiliser la méthode setAlwaysOnTop de la classeWindow.

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. Deplus, cette méthode est susceptible de lever une SecurityException.

Attention : Cette fonctionnalité n'est disponible dans l'API standard que depuis la version 1.5 de J2SE. Pourles versions précédentes, la seule possibilité est de passer par JNI et des API natives.

Comment ouvrir une fenêtre sur un écran particulier ?Auteurs : adiGuba ,Afin d'ouvrir une fenêtre (ou une boite de dialogue) sur un écran particulier, il faut utiliser un desconstructeurs comportant un paramètre du type java.awt.GraphicsConfiguration (présent dans les classesFrame et Dialog d'AWT ainsi que JFrame et JDialog pour Swing).

L'instance de GraphicsConfiguration s'obtient depuis le GraphicsDevice associé à l'écran. Ainsi, pourafficher une JFrame sur le second écran (si il est présent), on utilisera le code suivant :

Ouvrir une JFrame sur le second écran

// On récupére la liste des écrans :GraphicsEnvironment gEnv = GraphicsEnvironment.getLocalGraphicsEnvironment();GraphicsDevice[] devices = gEnv.getScreenDevices(); // On récupère la configuration du second écran (s'il existe) :GraphicsConfiguration gConfig = null;if (devices.length>1) {gConfig = devices[1].getDefaultConfiguration();} // On crée et on affiche la JFrame :JFrame frame = new JFrame(gConfig);frame.setSize(400,400);





FAQ Java GUI



Ouvrir une JFrame sur le second écranframe.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 suffitdès lors d'utiliser la méthode getScreenDevices() pour obtenir un tableau de java.awt.GraphicsDevicerepré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ésolutionactuelle et la liste des résolutions supportées...

lien : Comment ouvrir une fenêtre sur un écran particulier ?

Comment connaître la fenêtre active de l'application ?Auteurs : bazinou ,Le code suivant retourne l'objet Window actif:

KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow()

Comment connaître la mémoire utilisable de la carte graphique ?Auteurs : Seigne David ,

Connaître la mémoire utilisable de la carte graphique:

// obtenir le type d'environnement graphique sous lequel tourne la JVM




http://www.developpez.net/forums/u72264/bazinou/


FAQ Java GUI



Connaître la mémoire utilisable de la carte graphique:GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();// optenir le périphérique d'affichage (carte graphique)GraphicsDevice gs = ge.getDefaultScreenDevice(); // stocke le nombre d'octets libres dans la mémoire de la carte graphique(VRAM)int bytes = gs.getAvailableAcceleratedMemory();// calcule le nombre de Kilo Octets libres dans la carte 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'espaced'affichage des fenêtres, mais lorsque l'on souhaite positionner précisément une fenêtre il est intéressantde déterminer cet espace afin de ne pas cacher (ou être cacher) par une de ces barres, et ainsi respecterl'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 derécupérer les marges de l'écran, de la manière suivante :

Toolkit toolkit = Toolkit.getDefaultToolkit(); // On récupère la taille de l'écran par défaut :Dimension dim = toolkit.getScreenSize();System.out.println(dim); // On récupère la configuration par défaut de l'écran par défaut :GraphicsConfiguration gconf = GraphicsEnvironment.getLocalGraphicsEnvironment() .getDefaultScreenDevice().getDefaultConfiguration(); // On récupère les 'marges' de l'écran :Insets insets = toolkit.getScreenInsets(gconf);System.out.println(insets);

Ces marges correspondent à l'espace occupé par les différentes barres d'outils du système. Il est ainsipossible de déterminer l'espace utile du bureau graphique de l'utilisateur.


Comment immobiliser une JInternalFrame?Auteurs : ReunionIsland , Baptiste Wicht ,Pour rendre une JInternalFrame immobile, il faut lui dédier un nouveau DesktopManager :

private JDesktopPane mainPanelView = new JDesktopPane();mainPanelView.setDesktopManager(new ImmobileDesktopManager());

public class ImmobileDesktopManager extends DefaultDesktopManager { @Override public void dragFrame(JComponent f, int newX, int newY) { if (f instanceof ImmobileJInternalFrame) { if (((ImmobileJInternalFrame)f).isLock()) { return; }




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

http://www.developpez.net/forums/u74016/reunionisland/


FAQ Java GUI



} super.dragFrame(f,newX,newY); } }

public interface ImmobileJInternalFrame { public boolean isLock();}

Ensuite de quoi, il suffit d'implémenter l'interface ImmobileJInternalFrame pour chacune de nosJInternalFrame qui doivent être immobiles.



FAQ Java GUI



Sommaire > La souris et le clavier

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

void mousePressed(MouseEvent mouseEvent) { if ( SwingUtilities.isLeftMouseButton(mouseEvent) ) { /** Bouton GAUCHE */ } else if(SwingUtilities.isMiddleMouseButton(mouseEvent) ) { /** Bouton du MILIEU */ } else if(SwingUtilities.isRightMouseButton(mouseEvent)) { /** Bouton DROIT */ } }

Gardez toujours à l'esprit que certains systèmes n'ont pas de 2ème et/ou 3ème bouton, les traitementsdoivent donc être accessibles par un autre moyen.

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

Comment changer la forme du curseur de la souris ?Auteurs : L'équipe Java ,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





FAQ Java GUI



précédemment. Le changement de curseur est automatiquement hérité par tous les fils, sauf si ceux-çiprécisent explicitement un autre curseur.

Comment traiter les "double clic" dans un MouseListener ?Auteurs : L'équipe Java ,Sur un événement de type java.awt.event.MouseEvent, la méthode getClickCount() permet de connaître lenombre de clics et donc de gérer les doubles.

lien : Comment traiter les "simple clic" et les "double clic" de manière exclusive ?

Comment traiter les "simple clic" et les "double clic" de manière exclusive ?Auteurs : Clément Cunin ,De manière générale, ce cas ne devrait pas se produire. Le double clic ayant souvent une fonctioncomplémentaire du simple clic.

La seule solution est l'utilisation de 'timer' qui sera lancé lors d'un simple clic et arrêté lors d'un 2ème clic.Si le temps est écoulé sans que le timer n'ait été arrêté par le 2ème clic, alors on exécute l'action associéeau simple clic !

lien : Comment faire un minuteur (timer) facilement ?

Comment déplacer automatiquement la souris ?Auteurs : Clément Cunin ,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'entrerdes touches au clavier.

Attention :Le déplacement automatique de la souris a le don d'énerver certains utilisateurs, il est doncconseillé de l'utiliser prudemment et/ou de permettre à l'utilisateur de désactiver cette fonction.

Comment charger un curseur '.cur' ou '.ani' ?Auteurs : Clément Cunin ,Les formats de fichiers '.cur' et '.ani' ne sont pas supportés en standard par l'API de Java. La meilleuresolution consiste donc à utiliser un programme extérieur pour convertir ces fichiers dans un format reconnupar la JVM ('.png' ou '.gif' sont parfaitement adaptés pour ça). Les plus courageux peuvent se mettre à larecherche d'une bibliothèque additionnelle...


Comment connaître la position de la souris à l'écran ?Auteurs : Ioan Calapodescu ,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 souris relativement à ce composant. Il vous suffira ensuite d'utiliser la méthodegetLocationOnScreen() de Component pour calculer la position de la souris par rapport à l'écran.

int x = (int)(mouseEvent.getPoint().getX() + monComposant.getLocationOnScreen().getX());int y = (int)(mouseEvent.getPoint().getY() + monComposant.getLocationOnScreen().getY());

Vous pouvez aussi utiliser la méthode convertPointToScreen() de la classe javax.swing.SwingUtilities. Parexemple :

MouseEvent event = ...; Component composant = ...;Point locationComposant = event.getPoint();Point locationEcran = SwingUtilities.convertPointToScreen(locationComposant, composant);

Sans composant graphique

A partir de Java 5.0 (Tiger), si vous voulez connaître la position de la souris (même en dehors d'une fenêtre)vous pouvez utiliser l'objet MouseInfo du package java.awt. Par exemple :

PointerInfo pointer = MouseInfo.getPointerInfo();Point location = pointer.getLocation(); System.out.println("La souris se trouve en "+location);

Attention, l'instance de PointerInfo n'est pas mise à jour automatiquement. Vous devrez en récupérer unenouvelle instance à chaque fois.

Avant Java 5.0, la seule solution possible est de passer par JNI (Java Native Interface). Vous pourrezainsi avoir accès grâce à des langages plus proches du système aux cooordonnées de la souris à l'écran.Attention tout de même, vous risquez de perdre la portabilité de votre application.

[Java 5.0] Comment connaître le nombre de boutons de la souris ?Auteurs : adiGuba ,Depuis Java 5.0, il est possible de connaître le nombre de boutons de la souris grâce à la méthode 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 :




http://www.developpez.net/forums/u19483/tsume/

FAQ Java GUI



Robot robot = new Robot(); /** création du robot */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 fautcombiner le A avec la touche shift.



FAQ Java GUI



Sommaire > Le dessin

Comment dessiner en Java ?Auteurs : Clément Cunin ,Il y a principalement deux cas où un programmeur est amené à dessiner : la réalisation d'un composantgraphique 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 casessayer de construire une instance de cette classe. Pour dessiner dans un composant graphique, l'instancevous est donnée en paramètre de la méthode paint(AWT) ou paintComponent(SWING). Pour le dessin dansune image, on crée un objet java.awt.Image, puis on utilise la méthode getGraphics() pour récupérer l'objetGraphics 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 composantsgraphiques nécessite de bien comprendre Pourquoi mon composant s'efface quand je redimensionne lafenêtre ?

lien : Pourquoi mon composant s'efface quand je redimensionne la fenêtre ?

Pourquoi mon composant s'efface quand je redimensionne la fenêtre ?Auteurs : Clément Cunin ,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 lesméthodes paint(AWT) et paintComponant(SWING) sont exécutées. La première raison est une requêteexplicite du composant via la méthode repaint(). La deuxième raison est une requête du système, soitsuite au redimensionnement de la fenêtre, soit suite au masquage du composant par une autre fenêtre dusystème.

La règle à toujours respecter :Tout programmeur qui redéfinit la méthode paint(AWT) oupaintComponent(Swing) s'engage à redessiner l'intégralité de la surface du composant. En effet, l'objetGraphics qui est transmis au composant dessine toujours dans le même espace mémoire et cet espacen'est jamais nettoyé (pour des raisons de performance). Le programmeur du composant a donc la chargede nettoyer l'espace et de redessiner son composant. Si le composant est complexe et que son dessin estlong, il est recommandé d'utiliser la technique de Comment utiliser le double-buffering software ? pouroptimiser son affichage.

lien : Comment utiliser le double-buffering software ?

Comment écrire du texte dans une image ?Auteurs : Clément Cunin ,Version simple :La méthode drawString(java.lang.String,int,int) de la classe java.awt.Graphics2Dcorrespond parfaitement à ce que l'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 notretexte. En fait, la classe java.awt.Graphics2D garde un certain nombre d'attributs qui sont appliqués à toutesles opérations de dessin ; la couleur principale, la couleur secondaire (de fond), la police, la déformation.Il suffit de changer ces valeurs en utilisant la méthode appropriée.

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 aucoin inférieur gauche de la première lettre du texte. Plus précisément, la valeur y correspond à la ligne 'debase' du texte. Pour les langues comme l'Arabe qui s'écrivent de droite à gauche, cette position correspondà la position du dernier caractère de la chaine, donc de celui qui sera affiché le plus a gauche. (Si vousn'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 ?Auteurs : Clément Cunin ,Lorsque l'on Comment écrire du texte dans une image ? il est souvent utile de connaître la taille nécessairepour l'affichage de ce texte, pour le centrer ou continuer à écrire à la ligne suivante. Il suffit pour cela derécupérer l'instance de la classe java.awt.FontMetrics du graphique dans lequel on souhaite écrire.

Graphics2D g2d = ...;FontMetrics fontMetrics = g2d.getFontMetrics();int longueur = fontMetrics.stringWidth("MonTexte");int hauteur = fontMetrics.getHeight();

lien : Comment écrire du texte dans une image ?

Comment activer le lissage des textes et/ou des graphiques ?Auteurs : Clément Cunin ,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 ?Auteurs : Clément Cunin ,La gestion de la transparence passe par l'utilisation du 'canal alpha', notion bien connue des graphistes.Pour nous, la gestion de la transparence se résume à spécifier à notre graphique le pourcentage d'opacitéque l'on souhaite appliquer à ce que l'on va dessiner (graphique ou texte). Une composante alpha de 0correspond à 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 ?Auteurs : Clément Cunin ,Définir la taille du pinceau :Comme toujours avec l'objet java.awt.Graphics2D, nous allons définir unenouvelle taille de pinceau qui s'appliquera à tous les traits qui seront tracés par la suite, aussi bien via lamé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'imaginerune ligne de 2.5 pixels. Pour comprendre, il suffit de s'imaginer le cas d'une ligne oblique, ou le cas d'untracé avec Comment activer le lissage des textes et/ou des graphiques ?.

Définir le type de la ligne :La classe java.awt.BasicStroke contrairement à ce que laisse penser son nomn'est pas si basique que ca. Outre la taille du pinceau, elle permet la définition de lignes en pointillés avecéventuellement plusieurs longueurs, elle permet aussi de définir comment sont gérées les intersectionsdes lignes d'une multi-ligne (shape), et plein d'autres choses encore. Je ne rentrerai donc pas dans lesdé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 ?Auteurs : Clément Cunin ,Les fonctions de remplissage de zone sont gérées par java.awt.Graphics2D en précisant comment colorieravant d'utilisant les méthodes fillXXX(...).

Avec un dégradé de couleur :Un dégradé de couleur est calculé en fonction de deux points de référencedont on fixe la couleur, la couleur des points situé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 ?Auteurs : Clément Cunin ,Quelques paramètres intéressants :Un certain nombre de propriétés peuvent être initialisées pour indiquervos 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);




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


FAQ Java GUI



Le double buffering :L'utilisation d'un double buffer est particulièrement recommandée pour l'affichaged'animations complexes ou de composants de grande taille. Voir Comment utiliser le double-bufferingsoftware ?

lien : Comment utiliser le double-buffering software ?

Comment utiliser le double-buffering software ?Auteurs : Seigne David ,L'affichage par défaut sur un composant awt, swing, ... de Java se fait à l'aide d'un simple buffer (on voitl'image se tracer). Si on commence à faire des animations un peu complexes, il apparait dès lors desproblèmes de scintillements de l'image appelés clipping. Pour résoudre ce problème, on peut utiliser laméthode du double-buffering software (c'est une couche de la JVM qui s'en charge). Le double-buffering estle fait d'avoir un buffer où l'on dessine en mémoire et un buffer qui s'occupe de l'affichage. Les problèmesde rafraichissement, saut d'image et autres bugs visuels sont ainsi éliminés.

Voici un programme très simple se servant du double-buffering software.

public class DoubleBufferingSoftware extends Frame{ // boucle d'affichage RenderingThread renderingThread = new RenderingThread(); // buffer mémoire (2eme buffer) Graphics buffer; // image mémoire correspondante au buffer Image image; int x = 0; // coordonnée x de l'affichage du texte public DoubleBufferingSoftware(){ //affichage setSize( 400, 400 ); setVisible( true ); // on démarre la bouche d'affichage renderingThread.start(); } public void update(Graphics g){ paint(g); } public void paint( Graphics g ){ //création du buffer si il n'existe pas if(buffer==null){ image = createImage(400,400); buffer = image.getGraphics(); } //on dessine sur le buffer mémoire buffer.setColor( Color.white ); buffer.fillRect( 0, 0, 400, 400 ); buffer.setColor( Color.black ); buffer.drawString( "affichage d'une ligne de texte", x, 200 ); x++; if(x>400) x = 0; // finalement, le buffer mémoire est dessiné dans le buffer d'affichage g.drawImage(image, 0, 0, this); } class RenderingThread extends Thread { /** * Ce thread appelle le rafraichissement de notre fenêtre * toutes les 10 milli-secondes */ public void run(){ while(true){




FAQ Java GUI



try { 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 ?Auteurs : Seigne David ,Les développeurs de Sun se sont rapidement rendu compte que le double-buffering software ne suffisaitpas parfois, notamment pour faire des jeux et d'autres applications graphiques très lourdes. Ils ont doncdécider d'implémenter l'utilisation de la carte graphique (VRAM au lieu de la RAM) afin de diminuer unegrande partie des calculs. Le Page-flipping, plus communément appelé double-buffering hardware est lefait d'utiliser un pointeur vidéo pour décider quel buffer sert de mémoire et quel buffer sert d'affichage.

Principe : On créé un buffer qui va servir de buffer mémoire (celui où l'on dessine dessus), puis on crééun buffer qui va servir de buffer graphique (celui qui s'occupe d'afficher ce qu'il contient à l'écran). Ondessine sur le buffer mémoire, des images, des textes, des dessins, ... pendant que le buffer graphiqueaffiche ce qu'il contient. Puis, on swap les buffers(en clair, on les inverse), le buffer mémoire devient lebuffer graphique et le buffer graphique devient le buffer mémoire. On les appelle habituellement: BackBuffer(buffer mémoire) et FrontBuffer (buffer graphique).

Voici la méthode qui permet d'utiliser la mémoire vidéo de votre carte graphique (VRAM) :

public class DoubleBufferingHardware extends Frame{ // boucle d'affichage RenderingThread renderingThread = new RenderingThread(); // variable permettant d'utiliser la mémoire VRAM BufferStrategy strategy; // buffer mémoire où les images et les textes sont appliqués Graphics buffer; int x = 0; // coordonnée x de l'affichage du texte public DoubleBufferingHardware(){ setSize( 400, 400 ); setVisible( true ); // inhibe la méthode courante d'affichage du composant setIgnoreRepaint( true ); // on créé 2 buffers dans la VRAM donc c'est du double-buffering createBufferStrategy( 2 ); // récupère les buffers graphiques dans la mémoire VRAM strategy = getBufferStrategy(); buffer = strategy.getDrawGraphics(); renderingThread.start(); } public void graphicalRender(){



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.setColor( Color.black ); 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 ?Auteurs : Seigne David ,La technique pour faire du triple-buffering hardware est très simple, il suffit de reprendre l'architecture pourle 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 supporteet tournera en fait en triple-buffering, soit vous ferez planter votre programme ou aurez de gros bugs àl'affichage.

Inconvénients du triple-buffering ?

Et bien, les cartes actuelles tournent moins bien avec le triple que le double, résultat des courses, vousallez perdre en images par seconde lors de l'affichage. Cette diminution en performance est de l'ordre de3 ce qui n'est pas négligeable.



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

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


FAQ Java GUI



Avantages du triple-buffering ?

• Si le double-buffering ne suffisait pas à nettoyer tous les bugs d'affichage, le triple-buffering peutfinir de les nettoyer. Cependant, il est vraiment très rare que le double-buffering ne suffise pas ànettoyer les bugs graphiques.

• Dans le cas où vous faites du plein écran avec votre programme et que vous faites du double-buffering, vous avez dû remarquer que le compteur d'images par secondes est de 70-85(bizarrement comme votre rafraichissement d'écran sur windows), ceci est dû au fait que le double-buffering se synchronise avec le rafraichissement de votre écran. La solution pour passer outrecette synchronisation est le triple-buffering, celui-ci permet de casser la V-sync (synchronisationdes 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 ?Auteurs : Clément Cunin ,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 ?Auteurs : Clément Cunin ,Type de fichier supporté :GIF, JPEG, PNG, BMP et WBMP. Pour lire des images encodées dans d'autres formats, vous devez utiliserune bibliothèque externe.

Dans un applet :La classe Applet fournit tout le nécessaire pour la lecture d'image :

Image java.applet.Applet.getImage(URL url);Image java.applet.Applet.getImage(URL url, String name);

Dans une application :Pour une application (Awt ou Swing), il faut utiliser les méthodes de la classe java.awt.Toolkit

/** Accès au toolkit : */java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();/** lecture de l'image : */Image image = toolkit.getImage("fichier");Image image = toolkit.getImage(url);

BufferedImage image = ImageIO.read( /* File, URL ou InputStream */ );

A noter qu'avec ImageIO, les images sont complètement chargées lors du retour de la méthode read(), alorsque les images 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. Cettesolution est valable que l'image se trouve ou non dans une archive, il est donc préférable de toujours utiliserle ClassLoader afin de limiter les problèmes lors du déploiement de l'application/applet.

java.net.URL url = getClass().getResource("chemin/nom.gif");

Comment enregistrer une image ?Auteurs : Jean-Baptiste Bugeaud ,JDK 1.4 :Le JDK1.4 introduit le "imaging I/O framework" qui permet d'écrire des images dans la majoritédes formats courants : http://java.sun.com/j2se/1.4/docs/guide/imageio/index.html

JDK antérieur :Java ne permettait pas d'enregistrer une image au format GIF, PNG ou JPEG. Il va falloir faireappel à des classes extérieures permettant le codage de l'image.

• En Java 2, un 'package' est fourni pour enregistrer en JPEG (mais ne fait pas partie des librairiesstandard) : 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 desimages.

Comment connaître les types d'images que l'on peut lire ou écrire ?Auteurs : Ioan Calapodescu ,La classe ImageIO du package javax.imageio permet l'accès à ces informations. On peut ainsi connaîtreles types d'images que l'on peut lire ou écrire en fonction du nom du format, du type MIME ou du suffixed'un fichier. Voici un exemple :

import javax.imageio.*; public class FormatsImages{public static boolean canRead(String format){ boolean type = ImageIO.getImageReadersByFormatName(format).hasNext(); boolean mime = ImageIO.getImageReadersByMIMEType(format).hasNext(); boolean suffixe = ImageIO.getImageReadersBySuffix(format).hasNext(); String infos = "Informations lecture "+format+" : "; infos+="Format image = "+type+", "; infos+="MIME = "+mime+", "; infos+="Suffixe fichier = "+suffixe; System.out.println(infos); return type||mime||suffixe;}public static boolean canWrite(String format){ boolean type = ImageIO.getImageWritersByFormatName(format).hasNext(); boolean mime = ImageIO.getImageWritersByMIMEType(format).hasNext(); boolean suffixe = ImageIO.getImageWritersBySuffix(format).hasNext(); String infos = "Informations écriture "+format+" : "; infos+="Format image = "+type+", "; infos+="MIME = "+mime+", "; infos+="Suffixe fichier = "+suffixe; System.out.println(infos); return type||mime||suffixe;



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://xml.apache.org/batik

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

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


FAQ Java GUI



}}

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

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 ?Auteurs : Clément Cunin ,L'ajout d'image en fond de composant n'est pas possible avec les classes de base de Swing. Heureusement,la réalisation d'une telle classe n'est pas compliquée, il suffit de créer un nouveau composant héritant deJComponent et de surcharger la méthode paintComponent.

La méthode paintComponent(Graphique g) est chargée de dessiner le composant ; les composants filsseront dessinés par dessus plus tard.

Exemple (Swing):

public class MonPanel extends JComponent { /** variable de classe contenant l'image à afficher en fond */ private Image bg; /** Surcharge de la fonction paintComponent() pour afficher notre image */ public void paintComponent(Graphics g) { g.drawImage(bg,0,0,null); } }




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éthodesetContentPane(moncomposant).

Fichier joint :Vous trouvez, dans les liens ci-dessous, un exemple complet d'implémentation d'un tel objet,permettant d'afficher l'image en mosaïque ou centrée.

Extension de JPanel pour afficher des images en arrière-plan. Exemple d'utilisation de la classe.

Comment convertir une image en une instance de BufferedImage ?Auteurs : Clément Cunin ,Beaucoup d'opérations de manipulation d'image ne travaillent que sur des java.awt.image.BufferedImage.La vie étant parfois mal faite, il est courant de trouver dans l'API des méthodes nous retournant des images,mais assez rarement des bufferedImages, il nous faut donc convertir ces images... Voici une méthode quis'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 ?Auteurs : Seigne David ,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 ?Auteurs : Clément Cunin ,Les modifications de couleur d'une image sont assurées par la classe java.awt.image.ColorConvertOp quitravaille à 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 ?Auteurs : Clément Cunin ,L'algorithme permettant de rendre une image floue travaille très simplement : la couleur d'un pixel estcalculée en faisant la moyenne pondérée de sa couleur et de celles de ses voisins. Il suffit de modifier lescoefficients et le nombre de voisins pour intervenir sur le résultat, plus le poids des voisins est important,plus l'image sera floue. De plus, on peut choisir le poids d'un voisin en fonction de sa position, ce quipermet d'attribuer des poids différents et d'obtenir des résultats surprenants...

float[ ] matrice = { 0.1f, 0.1f, 0.1f, 0.1f, 0.2f, 0.1f, 0.1f, 0.1f, 0.1f};BufferedImageOp op = new ConvolveOp(new Kernel(3,3,matrice));BufferedImage nouvelleImage = op.filter(bufferedImage, null);

lien : Comment convertir une image en une instance de BufferedImage ?

Comment effectuer des transformations sur une image en mémoire ?Auteurs : Clément Cunin ,Il n'est pas possible d'effectuer de transformation directement sur une image mémoire, il faut créer unnouvelle image et 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 ?Auteurs : Clément Cunin ,C'est à mon avis une assez mauvaise idée. Les méthodes de la classe java.awt.Graphics sont généralementdes appels directs des fonctions de la carte vidéo ou d'une bibliotheque graphique (DirectX ou autre), bref.

Lecture d'un pixel :

/** Lecture d'un seul pixel : */int rgb = bufferedImage.getRGB(x,y); /** Lecture de tous les pixels : */int w = bufferedImage.getWidth();int h = bufferedImage.getHeight();int[] rgbs = new int[w*h]; /** on crée l'espace neccessaire */bufferedImage.getRGB(0,0,w,h,rgbs,0,w);

Ecriture d'un pixel :

/** Ecriture d'un seul pixel : */bufferedImage.setRGB(x,y,rgb); /** Ecriture de tous les pixels : */int w = bufferedImage.getWidth();int h = bufferedImage.getHeight();int[] rgbs = new int[w*h];bufferedImage.setRGB(0,0,w,h,rgbs,0,w);

lien : Qu'est-ce que l'encodage entier RGBA des couleurs d'une image ?

Qu'est-ce que l'encodage entier RGBA des couleurs d'une image ?Auteurs : Clément Cunin ,Pour des raisons de performance on utilise un seul entier pour coder les trois couleurs primaires (rouge,vert, bleu) et la composante alpha (le niveau de transparence). Chaque composante est codée sur 8 bits(bleu 0-7, vert 8-15, rouge 16-23, alpha 24-31).

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





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



http://www.developpez.net/forums/u443/pierre-yves-varoux/

FAQ Java GUI



Note :Un coefficient supérieur à 1 correspond à un agrandissement, un coefficient inférieur à 1 correspondà une réduction.

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

Image icone = Toolkit.getDefaultToolkit().getImage("./monImage.jpg");maFenetre.setIconImage(icone);

Si l'image n'apparaît pas, c'est certainement que le paramètre image a une valeur 'null'.

Une autre raison pour laquelle cette image n'apparaitrait serait un problème au niveau de la transparenceavec les images PNG qui ne sont pas gérés par tous les OS, certains OS vont l'afficher mais supprimmerla transparence et d'autres ne pas l'afficher.De plus, certains OS ne supportent simplement pas les images de type PNG, transparence ou non.


Comment obtenir une Image de mon composant graphique ?Auteurs : Ioan Calapodescu ,La classe Component a la capacité de peindre l'intégralité de son contenu dans un Graphics, grâce à lamé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;






FAQ Java GUI



}

Comment savoir si une image a des pixels transparents ?Auteurs : Seigne David ,Cette information est relativement simple à obtenir si l'on travaille avec une instance de BufferedImage. Sic'est le cas, on peut directement demander au ColorModel de l'image de nous donner l'information. Dansle cas contraire, on est obligé de passer par un PixelGrabber.

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

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 ?Auteurs : Seigne David ,

// 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-cidurant l'utilisation du programme, votre programme sera de plus en plus gourmant en mémoire.

Comment combiner deux images ?Auteurs : Zedros , Baptiste Wicht ,Pour combiner 2 images, il suffit de dessinner la deuxième image sur la première image. Pour cela, il fautrécupérer le Graphics2D de la première image et ensuite configurer l'anti-aliasing et la interpolation sur leGraphics2D. On peut ensuite tout simplement dessinner la deuxième image sur la première à l'endroit voulu.

Voilà donc ce que ça donne :





http://www.developpez.net/forums/u51129/joseph_p/


FAQ Java GUI



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

Comment utiliser des images compatibles pour améliorer les performances et le rendu ?Auteurs : Baptiste Wicht ,Lorsque vous utilisez des BufferedImage, il est important d'utiliser ce qu'on nomme des imagescompatibles.

Qu'est-ce que c'est ?

Ce sont des images qui sont déja dans le bon format pour le périphérique d'affichage. Elles sont de typesBufferedImage et ont certains avantages au niveau de la performance.

Qu'est-ce que ça change ?

Ce type d'image étant directement adapté au rendu sur le périphérique d'affichage utilisé, elles nécessitentmoins de code Java2D pour être affichées.

Comment les utiliser ?

L'utilisation de telles images est très simples. Il faut passer par la classe GraphicsConfiguration pour enobtenir une. Voici une méthode permettant de créer une nouvelle image compatible vide :

Créer une nouvelle image compatible/** * Create a compatible image. * * @param width The width. * @param height The height. * @param type The type of the image. * @return A compatible image. */private static BufferedImage createCompatibleImage(int width, int height, int type) { GraphicsConfiguration gc = GraphicsEnvironment. getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration(); return gc.createCompatibleImage(width, height, type);}

Et voici une méthode permettant de convertir une image existante en image compatible :

Rendre une image existante compatible/** * Create a compatible image from an existing image.




FAQ Java GUI



Rendre une image existante compatible * * @param image The image to make compatible. * @return A compatible image filled with the base image. */public static BufferedImage createCompatibleImage(BufferedImage image) { GraphicsConfiguration gc = GraphicsEnvironment. getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration(); if (image.getColorModel().equals(gc.getColorModel())) { return image; } else { BufferedImage compatibleImage = gc.createCompatibleImage(image.getWidth(), image.getHeight(), image.getTransparency()); Graphics g = compatibleImage.getGraphics(); g.drawImage(image, 0, 0, null); g.dispose(); return compatibleImage; }}

On commence par tester si le modèle de couleur de l'image n'est pas déja le bon pour ne pas faire detravail dans le vide. Ensuite, on créer une nouvelle image compatible et on dessinne l'ancienne image surla nouvelle.



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 ?Auteurs : Johann Heymes ,Tout d'abord, il faut rappeler que la librairie AWT a été développée pour la première sortie de Java version1.0 du jdk alors que Swing n'est apparue qu'à la version 1.2 du jdk (soit Java 2). Il en résulte donc desdifférences fondamentales de conception entre les deux librairies.

Composant AWT :Un composant AWT lors de sa création est associé à une fenêtre distincte (un homologue,peer en anglais) gérée par le système d'exploitation sous-jacent. Et c'est cet homologue qui est responsablede son apparence. Cette "manière" de faire, bien qu'elle ait fait ses preuves et qu'elle ait permis au langageJava de s'imposer, est très lourde (perte de performance, et consommation excessive de mémoire). C'estpour cette raison que l'on qualifie les composants AWT par heavyweight (littéralement, poids lourds)

Composant Swing :Par opposition, les composants Swing sont simplement dessinés à l'intérieur de leurconteneur comme s'il s'agissait d'une image, et aucun homologue du système sous jacent ne leur estaffecté. 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 composantsdirectement au Top-level Container (Conteneur de Haut Niveau) tel que Frame, Applet, ..., alors que sousSwing il est nécéssaire de les ajouter à un volet de contenu (Cf : javax.swing.JRootPane). De manière plusparlante je veux parler du :

jframe.getContentPane().add(monComposant);

Voila, ces quelques différences ne sont bien sûr pas exhaustives, Swing posséde bien d'autres avantages,je ne citerai que : la gestion de bordure, les info-bulles, le défilement, les Look And Feel, de nouveauxLayoutManager, ainsi que l'architecture MVC (Model-View-Control). Maintenant que l'on a conscience deces différences, une question reste tout de meme en suspens... Peut-on mélanger Awt et Swing ?

Peut-on mélanger Awt et Swing ?Auteurs : Johann Heymes ,NONIl est impossible d'obtenir un rendu graphique correct dans une application qui mélange AWT etSWING. Des problèmes de superposition empêchent toute collaboration.

Explication :Avant toute chose, il faut bien comprendre les différence entre Awt et Swing : Quel sont lesdifférences entre Awt et Swing ?.

Le composant JFrame comprend un objet fils qui prend en charge tout ce qui concerne le graphique, ils'agit d'une instance de JRootPane. Le composant JRootPane est lui même structuré. Il contient un voletstructuré 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 fait référence au fameux contentPane de jframe.getContentPane ()). il est également chargédu Z-ordering (algorithme permettant de ne dessiner que les parties non cachées, suite auxsuperpositions de composant).

• Le composant GlassPane représente une pellicule qui recouvre tout et qui par exemple peutintercepter 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 detype java.awt.Button.

• Le rendu graphique du composant "bouton" issu de la librairie AWT est délégué à son homologue(peer), par conséquent la position Z est la même que celle de la Frame (soit de haut niveau)

• Alors que le composant "combo" de type JComcoBox (Swing) n'est que "dessiné" comme uneimage 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 tout Swing !

Comment faire un minuteur (timer) facilement ?Auteurs : Johann Heymes ,On peut utiliser la classe java.lang.Thread ou implémenter l'interface java.lang.Runnable, mais suivantles cas de figure cela représente beaucoup de code et de contraintes. En effet, les instructions quiaffectent ou dépendent d'un composant graphique Swing doivent être effectuées par le processusd'évènement (the event-dispatching thread). Par conséquent si l'on utilise la classe Thread oul'interface Runnable il est nécessaire d'utiliser les méthodes : invokeLater(java.lang.Runnable) ouinvokeAndWait(java.lang.Runnable)" javax.swing.SwingUtilities.

La classe Timer :La classe javax.swing.Timer remplace avantageusement l'utilisation directe de thread. Ellegénère un évènement à intervalles réguliers (à la milli-seconde). C'est le "event-dispatching thread" quiexécute l'évènement, donc on peut directement modifier des objets graphiques.

Méthodes importantes :le constructeur de javax.swing.Timer :

public Timer (int delay, ActionListener listener);/** delay = l'intervalle de temps entre chaque évènement. * listener = l'objetécouteur de ces evènements. */

méthode permettant de lancer le processus :

public void start();

méthode permettant de stopper le processus :

public void stop();

Note :Cette méthode est à utiliser uniquement si le traitement à faire est court en temps d'exécution sinonon aura une interface non réactive pendant le traitement ....

Exemple d'utilisation pour faire un compteur.

Mon menu contextuel s'affiche hors de l'écran, que faire ?Auteurs : Clément Cunin ,JDK 1.3 et inférieur :Lorsque l'on utilise la méthode show(java.awt.Component, int, int) pour afficherun javax.swing.JPopupMenu, les coordonnées correspondent au coin haut-gauche du menu. Si cescoordonnées sont trop près du bord de l'écran, une partie du menu est alors cachée. Nous allons doncsurcharger la méthode show() pour que les coordonnées soient corrigées si le message est trop prochedu bord de l'écran.

class MonPopupMenu extends JPopupMenu { public void show(Component invoker, int x, int y) { /**Dimension de l'écran */ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); /** Dimension du Menu popup */





FAQ Java GUI



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) ?Auteurs : L'équipe Java ,Ce n'est pas directement possible en AWT, il faut créer sa propre classe MyButton permettant de le faire endérivant par exemple Component pour faire un lightweigth component.

Comment mettre une image dans un bouton (Swing) ?Auteurs : strab ,Il y a un constructeur de JButton et une méthode qui permettent d'avoir le résultat voulu en donnant l'imageen argument sous forme de Icon

JButton bouton = new JButton(new ImageIcon("images/bouton.gif"));

ou

bouton.setIcon(new ImageIcon("images/bouton.gif"));

Comment rendre un JButton transparent ?Auteurs : bulbo ,La classe AbstractButton définit un ensemble de méthodes permettant d'indiquer comment doit se dessinerle bouton. Ainsi, on peut indiquer, par exemple, si on désire dessiner les rebords ou le contenu. Voici unexemple.

Le code ci-dessous dessine un bouton transparent, seul le texte sera affiché en rouge.

JButton printButton = new JButton("Imprimer");printButton.setForeground(Color.red);




http://www.developpez.net/forums/u38277/strab/


FAQ Java GUI



printButton.setFocusPainted(false);printButton.setBorderPainted(false);printButton.setContentAreaFilled(false);

Comment imprimer l'ensemble d'un Container (JDK 1.1.x) ?Auteurs : L'équipe Java ,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 cecomposant dans une BufferedImage puis on va écrire cette image dans un fichier.

Voici un exemple qui permet d'enregistrer un composant sous forme d'image JPeg :

public void saveImage(Component component, File destination){ BufferedImage image = new BufferedImage(component.getWidth(), component.getHeight(), BufferedImage.TYPE_INT_RGB); Graphics2D g2d = image.createGraphics(); if(!component.isOpaque()){ Color bg = component.getBackground(); bg = (bg.getAlpha() < 255) ? new Color(bg.getRed(), bg.getGreen(), bg.getBlue()) : bg; Color color = g2d.getColor(); g2d.setColor(bg); g2d.fillRect(0, 0, component.getWidth(), component.getHeight()); g2d.setColor(color); } component.paint(g2d); g2d.dispose(); try { ImageIO.write(image, "jpeg", destination); } catch (IOException e) { e.printStackTrace(); }




http://www.developpez.net/forums/u12975/fxjtarga/


FAQ Java GUI



}

Lors d'un traitement long, l'affichage se fige, que faire ?Auteurs : Clément Cunin , tchize_ ,Symptômes :La fenêtre est vide ou il est impossible de cliquer sur le moindre composant ou les autres fenêtres dusystème d'exploitation laissent des trainées grises qui ne se redessinne par sur vos fenêtres ou j'ail'impression que mon application met du temps à réagir.

Cause :Ce problème est très classique lors d'un long traitement dans une application graphique. En Java, unThread est chargé de toutes les opérations liées à l'affichage et à la gestion des évènements, le Thread"Event Dispatching Thread" (en abrégé EDT). Si une application utilise ce Thread pour faire un traitement deplusieurs minutes, c'est autant de temps où l'application ne sera plus réactive aux actions de l'utilisateur, niaux mises à jour graphiques (d'une barre de progression par exemple). Typiquement, vous avez du code liéau clic sur une button ou un menu (un ActionListener par exemple) et vous y effectuez de gros calculs oudes Thread.sleep(). Vous ne pouvez pas faire ça, les traitement de l'EDT doivent être le plus bref possible!

Solution :La solution est assez simple à comprendre : tout traitement long doit être effectué par un autre Thread. Enjava 5 et supérieur, la classe SwingWorker est très utile pour vous aider à faire ça.

Qu'est ce que l'Event Dispatch Thread (EDT) ?Auteurs : bouye ,L'Event Dispatch Thread, également appelée EDT, est la Thread dans laquelle l'AWT et Swing font à la foisleur affichage et leur propagation d'événements. Les composants AWT et Swing doivent uniquement êtreutilisés dans l'EDT. Si un composant est instancié, appelé et manipulé depuis une autre Thread, il peutpotentiellement provoquer une erreur dans le programme ou ne pas s'afficher correctement.

L'EDT alterne les cycles d'affichage et les cycles de propagation d'événements. Ainsi quand on gère unévénement clavier, souris ou de sélection dans un composant on est assuré que :

1 On est bien dans l'EDT.2 Le composant n'est pas en train de se redessiner. Il sera redessiné dans un cycle d'affichage

ultérieur (pas forcément le cycle suivant) si on appelle sa méthode repaint() après le traitementde l'évènement. Il existe cependant des manières d'avoir un rendu immédiat lorsque l'état d'uncomposant est modifié mais généralement vous ne devriez pas avoir besoin de les utiliser.

Comment vérifier que l'on est bien dans l'EDT ?Auteurs : bouye ,Les deux manières de vérifier que le traitement actuel se déroule bien dans l'EDT sont :

• pour l'AWT, d'invoquer la méthode statique isDispatchThread() de la classe java.awt.EventQueue.




http://www.developpez.net/forums/u188305/tchize_/



FAQ Java GUI



• Pour Swing, d'invoquer la méthode statique isEventDispatchThread() de la classejavax.swing.SwingUtilities

Comment exécuter un traitement plus tard dans l'EDT ?Auteurs : bouye ,Tout d'abord, il est bien important de comprendre que tout traitement d'événement, tels que des écouteurspour le clavier, la souris ou de sélections dans des composants, et implémentés de manière standard sedéroule déjà dans l'EDT.

Cependant il peut parfois être nécessaire d'effectuer un traitement "plus tard" de manière à essayerd'attendre un moment où le niveau de charge de l'EDT est moins élevé ou pour laisser le temps à l'interfacegraphique de faire un affichage préliminaire par exemple. Pour se faire il faut appeler la méthode statiqueinvokeLater() de la classe javax.swing.SwingUtilities. Cette méthode rend immédiatement la main aprèsavoir été invoquée.

Exécuter un traitement plus tard dans l'EDT// Cette méthode retourne immédiatement.SwingUtilities.invokeLater(new Runnable() { /** * {@inheritDoc} */ @Override public void run() { myButton.setText("Salut le monde !") ; }}) ;

Les traitements longs doivent, quant à eux êtres exécutés dans une autre Thread car ils sont susceptiblesde bloquer l'EDT et de rendre votre application lente, voir de faire que votre interface graphique ne seréaffiche plus.

Comment lancer un traitement long ?Auteurs : bouye ,Les traitements longs doivent être lancés hors de l'EDT, pour cela il est possible d'utiliser un autre Threadque l'on lance manuellement ou encore d'utiliser un java.util.Timer.

Attention cependant à penser à vérifier et au besoin à changer la priorité du nouveau Thread car cettedernière hérite automatiquement sa priorité de celle de son Thread parent dans laquelle elle a été créée (lenouveau Thread a la même priorité que l'EDT donc).

Pour Java 6 ou plus, il est recommandé d'utiliser la classe javax.swing.SwingWorker qui offre un frameworkpermettant d'exécuter une tache hors de l'EDT tout en récupérant ses résultats intermédiaires et finauxdans l'EDT. Une implémentation existe pour Java 5 qui est disponible chez SwingLabs.

Comment lancer un traitement dans l'EDT depuis une autre Thread ?Auteurs : bouye ,Il existe deux façons de faire :






FAQ Java GUI



• Utiliser la méthode statique invokeLater() de la classe javax.swing.SwingUtilities. Cette méthodeprend en paramètre une instance de la classe Runnable qui sera exécuté ultérieurement. Cetteméthode retourne immédiatement après avoir été invoquée.

// Cette méthode retourne immédiatement.SwingUtilities.invokeLater(new Runnable() {/** * {@inheritDoc} */@Override public void run() { myButton.setText("Salut le monde !") ;}}) ;

• Utiliser la méthode statique invokeAndWait() de la classe javax.swing.SwingUtilities. Cette méthodeprend en paramètre une instance de la classe Runnable qui sera exécuté. Cette méthode bloque tantque l'action n'a pas été effectuée ce qui permet, par exemple, de mettre à jour l'interface graphiquequand on effectue un traitement depuis une autre Thread et de bloquer jusqu'à ce que la GUI ait étémodifié. Cette méthode ne DOIT PAS être appelée de l'EDT même.

// Cette méthode bloque tant que le traitement EDT n'est pas effectué.SwingUtilities.invokeAndWait(new Runnable() {/** * {@inheritDoc} */@Override public void run() { myButton.setText("Salut le monde !") ; }}) ;

Attention cependant, si elle est mal utilisée, invokeAndWait() peut provoquer des deadlock ; il est doncrecommandé d'utiliser la classe javax.swing.SwingWorker à la place.

Pourquoi ma barre de progression se remplit d'un coup ?Auteurs : Johann Heymes ,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 ?Auteurs : Ioan Calapodescu ,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




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


FAQ Java GUI



//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îchiren utilisant SwingUtilities.updateComponentTreeUI. Voici un exemple changeant le look and feel del'application pour le look and feel natif (celui naturellement utilisé par le système).

JFrame frame = new JFrame();frame.setVisible(true);// etc.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 ?Auteurs : Ioan Calapodescu ,Les look and feels enregistrés sont disponibles avec la méthode getInstalledLookAndFeels de la classeUIManager. Voici un exemple récupérant l'ensemble des look and feels sous forme de Map, dont les clefssont les noms des L&F et les valeurs les noms des classes correspondantes.

public Map getLookAndFeelsMap(){ UIManager.LookAndFeelInfo[] info = UIManager.getInstalledLookAndFeels(); Map map = new TreeMap(); for(int i=0; i<info.length;i++){ String nomLF = info[i].getName(); String nomClasse = info[i].getClassName(); map.put(nomLF,nomClasse); } return map;}

Pour un exemple utilisant cette méthode regardez le fichier ci-dessous.

lien : Comment changer le Look & Feel de mon aplication ?Menu Look and Feel

Comment modifier un élément du LookAndFeel ?Auteurs : morph41 ,Avant tout affichage, il faut appeler la méthode put(Object, Object) de la classe UIManager. Le 1er paramètrecorrespond à l'objet à modifier, et le second est la valeur à lui donner.

Par exemple, pour mettre en blanc le fond de tous les JPanel :




http://www.developpez.net/forums/u62963/cheryben/

FAQ Java GUI



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ésultatn'est pas forcément des plus esthétiques.

Heureusement il est possible de rémédier à cela en modifiant la propriété swing.boldMetal, soit directementvia la classe UIManager :

// Ne pas utiliser de texte en gras (LnF Metal) :UIManager.put("swing.boldMetal", Boolean.FALSE);

Soit en passant par les variables systèmes si l'on n'a pas accès au code source :

java -Dswing.boldMetal=false ... (les autres paramètres standards)

lien : Les look and 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 ceciquel que soit le composant qui ai le focus lors de l'appui sur ces touches ?Pour la touche ENTER c'est très simple parce que c'est fait pour :

// - pour une JFrame maFrame.getRootPane().setDefaultButton(monBouton) // - pour une JDialog monDialog.getRootPane().setDefaultButton(monBouton)

Pour la touche ESCAPE c'est plus compliqué, une solution est d'associer du code à l'évènement (et nonpas 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



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


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

http://www.developpez.net/forums/u132/laffreuxthomas/

FAQ Java GUI



configureRootPane(maFrame.getRootPane()); // - pour une JDialog configureRootPane(monDialog.getRootPane());

La méthode "configureRootPane" ne devrait être appelée qu'une fois, par exemple juste aprèsl'instanciation de votre conteneur. Il vous reste à implémenter la méthode "onKeyEscape", qui sera appeléelors 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 unJTextField :

Component c = comboBox.getEditor().getEditorComponent() ;JTextField textField = (JTextField) c ;textField.addKeyListener( new KeyListener() ) ;

Comment changer la langue d'un JComponentsans 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());



http://www.developpez.net/forums/u24089/wammaster/


http://www.developpez.net/forums/u32070/seiryujay/


FAQ Java GUI



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




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


FAQ Java GUI



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



FAQ Java GUI



initComponents(); } private void placeLesCouches(){ JPanel zpanel; JLabel dessous; JLabel dessus; 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); } }); }}

Comment placer le même composant en plusieurs endroits simultanément ?Auteurs : gifffftane ,Ce n'est pas possible.

Pour obtenir un résultat similaire, il faut utiliser la notion de modèle, souvent attachée à un composantswing (JTable, JTree...). Le modèle Action est le plus simple, et permet de stipuler une même fonction àplusieurs boutons, ou autre composant. Il s'utilise simplement par l'AbstractAction.

Pour créer une AbstractAction :




FAQ Java GUI



class QuelleBelleAction extends javax.swing.AbstractAction { QuelleBelleAction() { putValue(NAME, "Merci, developpez.net"); } @Override public void actionPerformed(ActionEvent e) { System.out.println("BINGO ! "); } }

Pour l'utiliser sur plusieurs boutons :

QuelleBelleAction belle = new QuelleBelleAction();JButton but1 = new JButton(belle);JButton but2 = new JButton(belle);paneau.add(but1);panneau.add(but2);

... les deux boutons réagiront de la même manière, et auront tous les deux le même label. Et, si l'on fait :

belle.setEnabled(false);

... les deux boutons seront rendus indisponibles simultanément.

On peut de la même façon mettre plusieurs JTable (ou JTree, ou...) apparemment identiques, parce qu'ilsont le même modèle, et non parce que le composant graphique est le même.



FAQ Java GUI



Sommaire > AWT et Swing > JFileChooser

Comment traduire le JFileChooser ou le JColorChooser en français ?Auteurs : L'équipe Java ,Ces boîtes de dialogue ne suivent pas la locale de votre système. En fait chaque texte affiché dans cesboîtes de dialogue correspond à une ressource du UIManager. Il va donc falloir changer ces ressources.

Par exemple pour le JFileChooser vous pouvez dans votre code faire :

UIManager.put("FileChooser.saveButtonText","Enregistrer");UIManager.put("FileChooser.openButtonText","Ouvrir");UIManager.put("FileChooser.cancelButtonText","Annuler");UIManager.put("FileChooser.updateButtonText","Actualiser");UIManager.put("FileChooser.helpButtonText","Aide");UIManager.put("FileChooser.saveButtonToolTipText","Enregistre le fichier");

Comment visualiser avec un JFileChooser le poste de travail, le bureau, etc. ?Auteurs : bulbo ,La classe FileSystemView, du package javax.swing.filechooser, permet de récupérer notamment le homedirectory et le répertoire par défaut. Sous windows, ces deux répertoires correspondent au bureau et à"Mes documents". Vous pouvez donc facilement positionner le JFileChooser. Par exemple :

FileSystemView vueSysteme = FileSystemView.getFileSystemView(); //récupération des ré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 devrez faire comme ceci :

JFileChooser chooser = new JFileChooser();chooser.setCurrentDirectory(new File("/"));chooser.changeToParentDirectory();chooser.showOpenDialog(null);

Comment filtrer les fichiers acceptés par un JFileChooser ?Auteurs : Ioan Calapodescu ,Pour filtrer les fichiers affichés par un JFileChooser vous devez utiliser un FileFilter (packagejavax.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 estacceptable.






FAQ Java GUI



• getDescription() : Cette méthode retourne un String décrivant le filtre. C'est cette description quisera affichée dans le JFileChooser.

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-dessouspour un exemple de filtre "extensible" (capable de prendre en compte plusieurs extensions de fichiers).



FAQ Java GUI



Une dernière remarque : le filtrage ne se fait pas nécessairement sur une extension de fichier. Pourl'exemple on a choisi cette possibilité car c'est ce qui est le plus couramment rencontré. Vous pouvez toutà fait faire des filtres sur les tailles des fichiers, leurs dates de dernière modification, etc.

FiltreSimple.java

Comment faire un filtre de fichiers avec plusieurs extensions ?Auteurs : Ioan Calapodescu , Pill_S ,Voici un exemple d'implémentation de FileFilter (package javax.swing.filechooser) qui prend en compteplusieurs extensions. Quelques méthodes supplémentaires sont définies pour des facilités d'utilisation.

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




http://www.developpez.net/forums/u28773/pill_s/

FAQ Java GUI



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); 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 classeFileNameExtensionFilter, qui permet de faire un filtre avec plusieurs extensions. Elle se crée de la manièresuivante :

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 ?Auteurs : Ioan Calapodescu ,La classe JFileChooser permet au développeur de définir, avec la méthode setAccessory(Component) uncomposant accessoire. Ce composant peut se mettre à l'écoute des événements relatifs au JFileChoosergrâce à un PropertyChangeListener.

Vous pouvez donc utiliser cet accessoire pour par exemple prévisualiser des images ou simplementpour avoir des informations détaillées sur le fichier sélectionné. Voici un exemple de rendu (vous pouveztélécharger l'implémentation ci-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 laméthode de personalisation du panel de prévisualisation.

JColorChooser myJCC = new JColorChooser(Color.BLACK);myJCC.setPreviewPanel(new JPanel());

A noter que l'instruction :

myJCC.setPreviewPanel(null);

repositionne le panel de prévisualisation par défault

Comment supprimer un color chooser d'un JColorChooser ?Auteurs : JMLLB ,Mettons que je souhaite supprimer le color chooser HSB.

JColorChooser myJCC = new JColorChooser(Color.BLACK);AbstractColorChooserPanel[] panels = myJCC.getChooserPanels(); for (int i=0; i<panels.length; i++) { String tmpString = panels[i].getClass().getName(); if (tmpString.equals("javax.swing.colorchooser.DefaultHSBChooserPanel")) { myJCC.removeChooserPanel(panels[i]); }}

à noter qu'il n'est pas possible de faire:

if (panels[i] instanceof javax.swing.colorchooser.DefaultHSBChooserPanel) { myJCC.removeChooserPanel(panels[i]);}

car DefaultHSBChooserPanel n'est accessible uniquement que depuis son package.





FAQ Java GUI



Sommaire > AWT et Swing > Composants textuels

Comment faire un JLabel de plusieurs lignes ?Auteurs : Clément Cunin , Baptiste Wicht ,Le HTML :La plus simple des méthodes pour avoir un texte sur plusieurs lignes est d'utiliser l'interpréteurHTML du JLabel. Pour cela il faut que le texte soit entouré des balises '<html>' et '</html>'. Ensuite il fautremplacer les "\n" par des balises '<br>', et le tour est joué !

new JLabel("<html>ligne 1<br>ligne 2<br>etc...</html>");

Le composant texte :Il est également possible d'utiliser un javax.swing.JTextArea plus pratique à mettreen place que la version Html si le texte n'est pas fixé dans le code... Cette solution est néanmoins pluscontraignante sur la mise en page et sur la gestion de l'apparence (par défaut le JTextArea n'a pas lesmê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 :-).

A noter que la solution avec HTML marche également avec d'autres composants Swing tels que le JButton.

Exemple de texte multi-ligne en utilisant un JTextArea.

Comment faire un JTextArea avec un retour à la ligne automatique ?Auteurs : Clément Cunin ,Tout simplement en utilisant les méthodes setLineWrap(boolean) et setWrapStyleWord(boolean) de laclasse javax.swing.JTextArea.

/** On souhaite un retour à ligne automatique : */monTextArea.setLineWrap(true); /** On souhaite que les mots ne soient pas coupés : */monTextArea.setWrapStyleWord(true);

Comment permettre la saisie de mot de passe ? (texte saisi avec des étoiles)Auteurs : Johann Heymes ,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 solutionss'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 pensemais ce ne sont pas les plus simples à mettre en place ni les plus jolies. Je parle ici évidemment dejava.awt.event.KeyListener ou javax.swing.event.DocumentListener et autres du même genre. Pour moi,ces solutions sont des solutions de rattrapage car techniquement elles permettent uniquement de nousinformer 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êteraidonc là sur ce sujet.

Solution 2, modification du modèle :La notion de modèle provient du design pattern MVC, Model-View-Controller Architecture, le but ici est donc de modifier directement ce que peut contenir un composanttexte en ignorant tout le reste. Pour se faire il suffit de créer une classe qui dérive du modèle auquel lecomposant 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 autresla méthode insertString(int, java.lang.String, javax.swing.text.AttributeSet) et remove(int, int). Il suffit doncde créer une classe qui dérive de la classe modèle apropriée et de rédéfinir la ou les méthodes nécessaires.Notons que ces deux méthodes insertString et remove seront appelées automatiquement par les classesde Sun à chaque ajout ou suppression de chaîne. Notre redéfinition doit donc avoir pour but de validerou non l'action. Par conséquent on notera que l'intégrité du composant texte n'est jamais bafouée (voirdémo ci-dessous.)

Solution 3, la classe JFormattedTextField Une toute nouvelle classe fait son apparition dans la version1.4 du JDK. L'exemple ici est très réducteur de ses capacités mais la prise en main est peut-être moinsévidente. En tout cas le résultat est là et il est même largement meilleur... regardez l'exemple :-)A noter qu'on peut aussi utiliser un MaskFormatter à un JFormattedTextField. Pour cela, il vous suffitde créer un nouveau MaskFormatter avec le masque de votre choix puis d'installer ce mask sur votre





http://www.developpez.net/forums/u71516/d-jo/

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

FAQ Java GUI



JFormattedTextField via la mé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 JFormattedTextFieldAuteurs : Nourdine Falola ,JFormattedTextField et formats standards (depuis le JDK 1.4)

La classe JFormattedTextField possède un constructeur prenant en paramètre un Format. Cela permet despécifer un format 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().



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


FAQ Java GUI



// 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 lesméthodes

• String valueToString (Object value) throws ParseException• 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 ?Auteurs : Johann Heymes ,Quel composant choisir ?Vous avez le choix entre JTextPane et JEditorPane. En effet, ce sont lesseuls à utiliser comme "Model" (Cf Model-View-Controller Architecture) un composant dérivant deAbstractDocument 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érerle 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 deDefaultStyledDecument et redéfinir la méthode insertString(). Exemple pour écrire tout le texte avec le stylenomme 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) {




FAQ Java GUI



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éersa propre classe dérivant de DefaultStyledDocument.

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

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 ?Auteurs : Johann Heymes ,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 êtrevisible.

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 ?Auteurs : Clément Cunin ,Avant d'utiliser une police de caractères, il est fortement recommandé de vérifier qu'elle est présente surle 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 : */





FAQ Java GUI



String[ ] nomPolices = environment.getAvailableFontFamilyNames();


Comment aligner un texte dans un JSpinner ?Auteurs : sinpay , Baptiste Wicht ,Pour aligner un texte dans JSpinner il faut d'abord récupérer son textField. Ensuite de quoi, il faut modifierl'alignement de ce dernier. Voici un exemple avec tous les alignements possibles :

JSpinner spinner = new JSpinner(); JTextField textField = ((JSpinner.DefaultEditor)spinner.getEditor()).getTextField(); //Aligner texte à gauchetextField .setHorizontalAlignment(JTextField.LEFT);//Aligner texte à droite (Par défault)textField .setHorizontalAlignment(JTextField.RIGHT);//Aligner le texte au centretextField .setHorizontalAlignment(JTextField.CENTER);



http://www.developpez.net/forums/u219543/sinpay/


FAQ Java GUI



Sommaire > AWT et Swing > Tableaux et arbres (JTable et JTree)

Comment rendre certaines cellules de ma JTable non éditables ?Auteurs : Johann Heymes ,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èreretourne faux pour ces cellules.

public boolean isCellEditable (int row, int column) { if ( celluleEstEditable ) { return ( true ); } else { return ( false ); } }

Comment faire des colonnes fixes dans une JTable ?Auteurs : Johann Heymes ,On préférera un petit exemple à un long discours ;-)

Pourquoi les en-têtes de ma JTable ne s'affichent-ils pas ?Auteurs : Johann Heymes ,Les javax.swing.JTable sont prévus pour être affichés dans un JScrollPane, si ce n'est pas le cas l'en-têten'est pas affiché. Pour l'afficher, vous pouvez récupérer l'en-tête en utilisant getTableHeader() et l'afficherséparément.

Un exemple est disponible ci-dessous.

Exemple d'implémentation.

Quelle cellule de ma JTable a été cliquée ?Auteurs : Johann Heymes ,Il suffit d'utiliser les méthodes columnAtPoint(java.awt.Point) et rowAtPoint(java.awt.Point) en lui passantle paramè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 ?Auteurs : Clément Cunin ,Il est parfois peu souhaitable que l'utilisateur puisse permuter les colonnes d'une javax.swing.JTable.Contre tout attente, la méthode permettant d'intervenir sur cette propriété n'est pas dans la classe JTable,mais dans la classe javax.swing.table.JTableHeader. Le code suivant permet d'annuler cette fonctionnalité.

maJTable.getTableHeader().setReorderingAllowed(false);

Comment sélectionner par programmation des lignes d'une JTable?Auteurs : JMLLB ,Il faut utiliser le SelectionModel de la JTable pour travailler sur la séléction de la JTable. Par exemple, pourselectionner les lignes 2,4 et 5 de la JTable myJTable:

myJTable.getSelectionModel().addSelectionInterval(2,2); myJTable.getSelectionModel().addSelectionInterval(4,5);

Pour ce qui est de sélectionner des cellules ou des zones de cellules de la JTable, la méthodechangeSelection est plus appropriée:

public void changeSelection( int rowIndex, int columnIndex, boolean toggle, boolean extend)

Comment définir l'alignement (gauche, centre,droite, ...) du contenu des colonnes d'une JTable ?

Auteurs : le y@m's ,Il faut utiliser les méthodes setHorizontalAlignment() et setVerticalAlignment() de la classeDefaultTableCellRenderer (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 :





http://www.developpez.net/forums/u56035/le-y-m-s/

FAQ Java GUI



JTable table = new JTable(); // 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éfautet 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 composant ne contient pas de données mais plutôt une vue de données contenues dans son modèle.

lien : JTree

Comment construire un JTree ?Auteurs : TheSeb ,- Pour construire un JTree, il faut spécifier le modèle de l'arbre dans le constructeur.- Il est posssible de créer son propre modèle en implémentant l'interface TreeModel ou bien en utilisant lemodèle par défaut DefaultTreeModel.

DefaultTreeModel myModel = ...;JTree myTree = new JTree(myModel);

- Pour construire un modèle d'arbre par défaut, il est nécessaire de passer le noeud racine (root).- Il est possible d'y passer tout objet implémentant l'interface TreeNode. Vous pouvez aussi utiliser la classepar défaut DefaultMutableTreeNode.

DefaultMutableTreeNode myRoot = ...;DefaultTreeModel myModel = new DefaultTreeModel(myRoot);

- Pour créer un noeud, il faut indiquer un objet utilisateur. L'arbre utilisera le résultat de la méthode toStringpour afficher une représentation de l'objet à un noeud donné. Pour un arbre représentant un système defichiers, des objets File 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), utilisezl'instruction suivante:

myTree.setRootVisible(false);

Comment modifier les icônes d'un JTree ?Auteurs : TheSeb ,La méthode la plus simple consiste à construire un objet DefaultTreeCellRender puis de modifier les icôneset de l'appliquer à l'arbre.

// Construction d'un afficheur par défaut.DefaultTreeCellRenderer myRenderer = new DefaultTreeCellRenderer(); // Changement de l'icône pour les feuilles de l'arbre.myRenderer.setLeafIcon(new ImageIcon("pageIcon.png"));// Changement de l'icône pour les noeuds fermés.myRenderer.setClosedIcon(new ImageIcon("closedBookIcon.png"));// Changement de l'icône pour les noeuds ouverts.myRenderer.setOpenIcon(new ImageIcon("openBookIcon.png"));






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 desdifférents noeuds de l'arbre.

Comment écouter les événements d'un JTree ?Auteurs : TheSeb ,De manière générale, le composant JTree ne s'utilise pas tout seul, un autre composant est utilisé pourafficher des informations relatives à l'objet utilisateur. Pour réaliser ce comportement, il est nécessaire demettre 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électionneou désélectionne un des noeuds de l'arbre.

Comment modifier la méthode de séléction des noeuds d'un JTree ?Auteurs : TheSeb ,Il est possible de changer la méthode de sélection des noeuds de l'arbre avec la méthodesetSelectionMode. Les différentes valeurs sont : SINGLE_TREE_SELECTION (sélection d'unseul noeud), CONTIGUOUS_TREE_SELECTION (sélection d'un ensemble contigus de noeuds),DISCONTIGUOUS_TREE_SELECTION (sélection d'un ensemble de noeuds). Exemple :

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

Comment interdire de dérouler/enrouler un noeud ?Auteurs : if_zen ,On utilise l'écouteur adapté à cet effet et on renvoie une exception au comportement qu'on ne veut pasproduire :

jtree.addTreeWillExpandListener(new TreeWillExpandListener(){ @Override






FAQ Java GUI



public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException {} @Override public void treeWillCollapse(TreeExpansionEvent event) throws ExpandVetoException{ // On n'enroule pas le contenu du neoud quand on double-clique dessus throw new ExpandVetoException(event); }});

Ici on interdit donc d'enrouler des noeuds.

Comment supprimer/modifier les icônes des noeuds parents ?Auteurs : if_zen , Baptiste Wicht ,En modifiant l'UI de l'arbre, il est tout à fait possible de modifier les icônes des arbres parents (aussiappelées poignées) :

((BasicTreeUI) ihmArbre.getUI()).setExpandedIcon(null);((BasicTreeUI) ihmArbre.getUI()).setCollapsedIcon(null);

Ici, on les as supprimées, mais vous pouvez tout à fait les modifier.

Comment changer l'indentation entre les lignes ?Auteurs : if_zen ,Pour modifier l'indentation des éléments, on peut modifier l'UI de l'arbre :

((BasicTreeUI) jTree.getUI()).setRightChildIndent(0);((BasicTreeUI) jTree.getUI()).setLeftChildIndent(0);

Ici on place les children au même niveau que les parents.

Comment ne pas peindre les pointillés au début des lignes quand on utilise le L&F Windows ?Auteurs : if_zen ,Il faut créer un nouveau BasicTreeUI et redéfinir les méthodes paintHorizontalPartOfLeg() etpaintVerticalPartOfLeg pour indiquer qu'elles ne font rien :

jTree.setUI(new BasicTreeUI(){ protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, TreePath path, int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf) { } protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds, Insets insets, TreePath path) { }});







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 deréagir suite aux actions de l'utilisateur (clic de souris, touche du clavier enfoncée, etc).

Les « listeners » sont des interface. Ces interfaces fournissent une ou plusieurs méthodes qui peuventdonc être implémentées différemment selon les cas et les besoins, pour répondre aux événements.

Les interfaces « listener » sont présentes principalement dans le package java.awt.event, mais égalementdans le package javax.swing.event.

Chaque listener dispose d'une classe Event associée. Cette classe étend java.awt.event.EventObject etfournit une description de l'évènement capturé. Par exemple, la classe ActionEvent décrit les évènementscapturés par un ActionListener.

Il y a plusieurs manières d'utiliser les listeners, vous trouverez ces méthodes dans les Q/Rs suivantes.

Comment utiliser les listeners (Méthode 1) ?Auteurs : Janitrix ,Voici la présentation et quelques explications sur la première possibilité concernant l'utilisation deslisteners.

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(nous l'étudierons plus en détail dans une autre Q/R). Puisque nous implémentons l'interface, nous devonségalement implémenter toutes les méthodes définies dans l'interface.

Le cas de l'interface ActionListener est simple puisqu'elle ne contient qu'une méthode.

Méthode que nous implémentons à l'étape 2 justement.

Nous créons un bouton SWING à l'étape 3.

À l'étape 4, nous ajoutons un « listener » sur les boutons précédemment créés. La méthodeaddActionListener est définie dans la classe AbstractButton, classe parente de JButton. Cette méthodeattend un paramètre de type ActionListener.

La classe MaClasse implémente cette interface, elle peut être justement considérée comme du typeActionListener. Nous pouvons donc fournir l'opérateur 'this' en paramètre, qui représente l'instance encours de la classe MaClasse.

Concrètement, qu'avons nous fait ? Nous avons demandé aux boutons monBouton et monBouton2qu'ils nous préviennent lorsqu'un utilisateur les actionne (c'est le rôle du « listener » ActionListener enparticulier). Et comment ? En utilisant la méthode actionPerformed, définie dans l'interface ActionListeneret surchargée dans la classe MaClasse.

Nous avons deux boutons, mais une seule méthode actionPerformed. Nous devons donc différencier (étape2bis) la source de l'évenement, monBouton ou monBouton2.

La boucle est bouclée.

Comment utiliser les listeners (Méthode 2) ?Auteurs : Janitrix ,2ème méthode : Utilisation des classes anonymes

Une deuxième possibilité est d'utiliser les classes anonymes. Voici quelques explications, toujours avecun code pour l'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 laclasse MaClasse ne pourra donc être utilisée dans la méthode addActionListener.

Nous créons deux boutons à l'étape 2. L'étape 3 est la plus intéressante. Nous définissons une instance del'interface ActionListener dans une classe anonyme, sans garder de référence vers cette classe anonyme.Dans ce cas, nous devons le faire deux fois, une fois pour chaque bouton (il faut une classe anonyme pourchaque 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. Eneffet, nous n'avons pas à dissocier les composants « source » (les composants écoutés par le listener),comme nous le faisons dans la première possibilité.

En contrepartie, nous devons créer une classe anonyme à chaque fois. Une autre possibilité qui est unesimple variante de 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 quenous « sauvegardons » l'instance de la classe anonyme dans une variable, et que nous pouvons doncla réutiliser autant de fois que nécessaire. Cependant, cette façon de faire nous oblige à différencier lescomposants « source » pour implémenter un comportement différent selon la source.

Comment utiliser les listeners (Méthode 3) ?Auteurs : Janitrix ,3eme méthode : création d'une classe dédiée.

// Fichier : MonListener.java




FAQ Java GUI



public class MonListener implements ActionListener { public void actionPerformed(ActionEvent e) { } }

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 quiimplémente le listener, puis, vous créez une instance de cette classe que vous passez en paramètre de laméthode addXXXListener située dans votre classe où sont déclarés les composants (boutons, listes, etc).

Qu'est ce qu'est et comment utiliser ActionListener ?Auteurs : Janitrix ,ActionListener est, comme son nom l'indique, un listener utilisé pour réagir aux actions utilisateurs. Celles-ci sont multiples, la principale étant l'activation d'un bouton (par un clic ou par appui de la touche Entréelorsque le bouton est sélectionné).

Une seule méthode est déclarée dans cette interface : public voidactionPerformed(java.awt.event.ActionEvent e).

La classe ActionEvent étend la classe java.util.EventObject, et hérite donc de ses méthodes. Parmi elles,getSource() est particulièrement intéressante. Elle renvoie l'objet concerné par l'événement (par exemplele bouton qui a été cliqué).

Cela nous permettra de différencier les composants sources dans l'implémentation de la méthodeactionPerformed.

La classe ActionEvent fournit quant à elle quelques méthodes spécifiques aux évènements d'action. Lesplus utilisées sont getWhen() et getActionCommand().

getWhen() récupère le timestamp Unix marquant le déclenchement de l'évènement, tandis quegetActionCommand() retourne le nom de la commande associée à l'évènement (par exemple, le texte dubouton à l'origine de l'action).

Voici une simple implémentation d'un ActionListener, utilisant la première méthode d'implémentationproposé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);




FAQ Java GUI



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

Rien de nouveau aux étapes 1, 2, 3, et 4. Vous aurez compris que lorsque l'un des deux boutons est appuyé,la méthode actionPerformed est invoquée.

Cependant, nous avons deux boutons, et un clic sur chacun d'eux invoquera la même implémentation del'ActionListener. Nous devons donc différencier le bouton source de l'action. Cela peut se réaliser de deuxfaçons : soit on compare le libellé du bouton avec celui de l'action capturée, soit on compare le boutonet 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éset comparaison de sources) dans une même condition est superflu, un seul des deux tests est nécessairepour savoir quel bouton a été actionné.

Qu'est ce qu'est et comment utiliser KeyListener ?Auteurs : Janitrix ,Le KeyListener est utilisé pour réagir aux évènements du clavier, et est donc utilisable sur des composantspermettant la saisi de texte (JTextField, JTextArea, etc).

Trois méthodes sont déclarées dans l'interface du KeyListener : keyTyped(KeyEvent e),keyPressed(KeyEvent e) et keyReleased(KeyEvent e). Elle permettent respectivement de réagir lorsqu'unetouche 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 cetteclasse (notamment getSource() ), mais fournit également une dizaine d'autres méthodes spécifiques auxévènements relatifs au clavier. Parmi elles : getKeyChar() retourne le caractère associé à la touche appuyée,getKeyCode() récupère le code de la touche pressée, isActionKey() retourne true si la touche appuyée estune touche d'action (CAPS LOCK, Verr Num, etc), et getKeyText(int keyCode) retourne le texte associée àla touche (par ex. F1, A, etc).

La dernière méthode, getKeyText, est statique, et ne s'utilise donc pas avec l'instance de KeyEvent fournie.

Les codes retournés par la méthode getKeyCode() sont utiles pour déterminer la touche pressée.Tous les codes et leur correspondance sont disponible ici : http://java.sun.com/javase/6/docs/ap.../KeyEvent.html

Voici une simple implémentation d'un KeyListener, utilisant la première méthode d'implémentationproposée :




FAQ Java GUI



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) { /* 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 nouveauxdans ce code, si ce n'est la comparaison entre le code de la touche appuyé et le code de la touche Echap.

Enfin, sachez que si vous trouvez trop lourd de devoir implémenter les 3 méthodes alors qu'une seule voussuffit, il existe la classe abstraite java.awt.event.KeyAdapter.

Vous pouvez soit créer une classe qui étendra KeyAdapter, soit faire une classe anonyme.

Exemple :

monTextField.addKeyListener(new KeyAdapter() { public void keyTyped(KeyEvent e) { }});

lien : La documentation officielle sur le KeyListenerlien : La documentation officielle sur le KeyEvent

Qu'est ce qu'est et comment utiliser MouseListener ?Auteurs : Janitrix ,Le MouseListener est utilisé pour les événements relatifs à la souris (clics, déplacements).



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



5 méthodes sont déclarées dans l'interface MouseListener : mouseClicked(MouseEvent e) prévient desclics (la souris a été pressée puis relâchée), mousePressed(MouseEvent e) pour les pressions sur la souris(donc on enfonce le bouton sans le relâcher), mouseReleased(MouseEvent e) prévient du relâchement d'unbouton de la souris, mouseEntered(MouseEvent e) indique que la souris est entrée dans l'espace d'uncomposant, mouseExited(MouseEvent e) indique que la souris est sortie de l'espace d'un composant.

La classe MouseEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cetteclasse (notamment getSource() ), mais fournit également 12 autres méthodes spécifiques aux événementsrelatifs à la souris, notamment getButton() retourne le bouton qui a été cliqué, getClickCount() retournele nombre de clics (utile pour gérer le double clic), getLocationOnScreen() retourne un objet Pointreprésentant la position de la souris à l'écran, et enfinisPopupTrigger() précise si le bouton cliqué est celui habituellement utilisé pour afficher la liste déroulante(bouton droit sur le bureau Windows par exemple).

Voici un exemple d'implémentation d'un MouseListener :

<code langage="java">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 donclourd d'implémenter chacune des méthodes..

Il existe donc une classe abstraite MouseAdapter qui vous permet d'implémenter seulement les méthodesqui vous intéressent.

Exemple :

monPanel.addMouseListener(new MouseAdapter() { public void mouseClicked(MouseEvent e) {



FAQ Java GUI



}}

Qu'est-ce qu'est et comment utiliser WindowListener ?Auteurs : Janitrix ,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êtrea été activé, windowDeactivated(WindowEvent e) indique que la fenêtre n'est plus la fenêtreactive,windowClosed(WindowEvent e) indique que la fenêtre a été fermé, windowClosing(WindowEvent e)indique que l'utilisateur a demandé la fermeture de la fenêtre, windowOpened(WindowEvent e) est appeléla première fois que la fenêtre est rendue visible, windowIconified(WindowEvent e) indique que la fenêtre aété réduite dans la barre de tâche, windowDeiconified(WindowEvent e) indique que la fenêtre a été restaurédepuis la barre de tâche.

La classe WindowEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cetteclasse (notamment getSource() ), mais fournit également 5 autres méthodes spécifiques aux événementsrelatifs 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éthodeaddWindowListener(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"); }




FAQ Java GUI



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 quivous permet de n'implémenter que les méthodes qui vous intéressent : WindowAdapter.

Qu'est-ce qu'est et comment utiliser FocusListener ?Auteurs : Janitrix ,Le FocusListener est utilisé pour les événements relatifs au focus clavier.

Cette interface déclare 2 méthodes : focusGained(FocusEvent e) indique que le composant a gagné le focusclavier tandis que focusLost(FocusEvent e) indique que le composant a perdu le focus clavier.

La classe FocusEvent étend java.util.EventObject et dispose donc des méthodes déclarées danscette classe (notamment getSource() ), mais fournit également 3 autres méthodes spécifiques auxévénements relatifs aux fenêtres, notamment isTemporary() qui indique si le composant n'a le focus quetemporairement, et getOppositeComponent() qui retourne l'autre composant impliqué dans le changementde focus.

Afin d'ajouter un FocusListener, vous disposez de la méthode addFocusListener(FocusListener) de laclasse 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 ItemListenerAuteurs : Janitrix ,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 achangé d'état.

La classe ItemEvent étend java.util.EventObject et dispose donc des méthodes déclarées dans cetteclasse (notamment getSource() ), mais fournit également 4 autres méthodes spécifiques aux événements





FAQ Java GUI



relatifs aux fenêtres, notamment getItem() qui retourne l'élément affecté par l'évènement, getStateChange()retourne le nouvel état de l'élément (sélectionné ou désélectionné), et getItemSelectable() qui retourne lecomposant originaire de l'évènement.

Afin d'ajouter un ItemListener sur les composants qui le permettent (les boutons, JcomboxBox, les listes,etc), vous disposez de la méthode addItemListener(ItemListener).

Voici un exemple d'implémentation d'un ItemListener :

public class MaFrame extends JFrame implements ItemListener { private JComboBox choix; // [...] public MaFrame() { choix = new JComboBox(); choix.addItemListener(this); } public void itemStateChanged(ItemEvent e) { 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 unefois pour celui qui vient d'être sélectionné (ceci est vrai dans le cas d'une JComboBox par exemple). Il estdonc important de faire la différence, sous peine de voir son code exécuté deux fois.



FAQ Java GUI



Sommaire > Applets

Certaines méthodes du JDK me demandent uneFrame, Applet ne dérive pas de Frame, que faire ?

Auteurs : Clément Cunin ,Principe :Une solution semble exister au moins avec Netscape Navigator et Appletviewer, en effet ils placentles applets dans une Frame. Il suffit donc d'utiliser getParent() sur l'Applet pour récupérer cette Frame ets'en servir ( éventuellement de manière récursive jusqu'à récupérer la Frame ).

Exemple :

public java.awt.Frame getFrame() { Container container = this.getParent(); while( container != null ) { if( container instanceof Frame ) { return( (Frame)container ); } container = container.getParent(); } return(null); /** Ou une erreur */}

Cet exemple retourne null si le parent n'est pas une java.awt.Frame.

Comment ouvrir une nouvelle page HTML ?Auteurs : L'équipe Java ,Il faut, dans l'applet, récupérer la page puis l'afficher, ceci pouvant être effectué suite à la pression d'unbouton.

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





FAQ Java GUI



• "un_nom" -> nouvelle fenêtre nommée.

Comment récupérer des arguments d'une page HTML dans une applet ?Auteurs : L'équipe Java ,Code HTML :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 ?Auteurs : L'équipe Java ,Il faut utiliser la méthode showStatus(java.lang.String) sur un objet de type java.applet.AppletContext.

Comment faire communiquer deux applets ?Auteurs : L'équipe Java ,Les applets se trouvent dans la même frame HTML :Il faut que l'applet ait été déclarée dans le code HTMLde 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éralementune seule JVM, l'espace mémoire est partagé. Une astuce est donc alors de créer une classe ne contenantque des membres statiques et permettant l'enregistrement et la récupération d'applet. Ces membresstatiques 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);}






FAQ Java GUI



Dans les applets on peut ainsi faire l'équivalent de ce qui est fait avec l'AppletContext :

Applet autre_applet = AppletDataBase.getApplet("tagname");

Mon applet ne marche pas avec un plugin Java, que faire ?Auteurs : L'équipe Java ,En fait pour faire marcher votre applet avec un plugin, il va falloir modifier le contenu de votre pageHTML. La marche à suivre dépend de votre navigateur. Vous trouverez plus d'informations à l'adressesuivante : http://www.javasoft.com/products/plugin/1.3/docs/tags.html

Comment signer une applet ?Auteurs : L'équipe Java ,

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

Comment jouer un son dans une applet ?Auteurs : Clément Cunin ,Même si les sons ont plutôt tendance à m'énerver quand je navigue sur la toile, voila un un bout de codepour faire faire du son à votre applet.

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




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 combiner des composants AWT et Swing ?Auteurs : bouye ,Les composant AWT sont dits heavyweight ou composants lourds tandis que les composants Swing sontdits lightweight ou composants légers.

Précédemment lorsqu'on mélangeant de tels composants le composant heavyweight s'affichaittoujours par dessus les autres composants lightweight. Il était possible d'appeler les méthodessetDefaultLightWeightPopupEnabled() et setLightWeightPopupEnabled() des classes JPopupMenu etJComboBox pour pallier à certains défauts de superposition mais cela ne réglait pas tous les problèmes.Depuis Java 6 update 12 et le JDK 7 build 19 (préversion du JDK 7), il est possible de mélanger descomposants Swing avec des composants AWT sans avoir les composants AWT qui s'affichent tout le tempsau-dessus des composant Swing.

Les restrictions suivantes s'appliquent cependant :

1. Suite à un bug dans Swing (6852592), il faut absolument revalider la hiérarchie des composants dès quecelle-ci devient invalide. Il ne faut pas simplement appeler revalidate() sur le composant mais égalementappeler validate() sur un conteneur parent (la JFrame par exemple).

monComposant.revalidate();maFrame.validate();

Lorsque ce bug aura été corrigé ce workaround pourra être retiré de votre code.

2. Lorsqu'un composant heavyweight doit être ajouté dans un JScrollPane, il faut mettre son scroll mode àla valeur SIMPLE_SCROLL_MODE. Les autres modes de scroll ne sont pas supportés car ils sont optimisésuniquement pour des composants ligthweight.

monScrollPane.setScrollMode(JScrollPane. SIMPLE_SCROLL_MODE) ;

3. En cas de superposition de composants lightweight non-rectangulaires par-dessus un composantheavyweight, il vous faut utiliser la méthode setComponentMixingCutoutShape() de la classecom.sun.awt.AWTUtilities de manière à définir la forme (Shape) utilisée par le composant lightweight. Sivous ne le faites pas, le composant lightweight sera traité comme ayant une surface rectangulaire et doncle composant heavyweight qui se trouve sous lui ne s'affichera correctement.

Cette méthode ne faisant pas partie de l'API publique, elle peut changer ou être retirée dans les futuresversions de Java. Il est également possible qu'elle soit déplacée dans une autre classe dans la versionfinale du JDK 7. Sun recommande d'utiliser la réflexion pour l'invoquer mais vous pouvez également utiliserl'API AWTUtilities d'adiGuba.

Il existe également des limitations :

• La superposition de composants lightweight semi-transparents par-dessus un composantheavyweight n'est pas supportée : la partie du composant heavyweight située sous le composantlightweight ne s'affichera pas.

• Les composants heavyweight doivent appartenir au même processus que celui qui a crée la frameou l'applet contenant les composants lightweight.

• La gestion avancée des évènements Swing telle que ceux se basant sur InputMap peut ne pasfonctionner correctement en cas de mélange de composants lightweight et heavyweight.




http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6852592

FAQ Java GUI



• Si vos applications mélangent déjà des composants AWT et Swing et qu'elles ne se comportent pluscorrectement une fois passées à des versions plus récentes de Java, il est possible de désactivercette fonctionnalité en mettant la propriété système sun.awt.disableMixing à la valeur �false�.

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 programmepar 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èmesd'exploitations. C'est pourquoi, il faut veiller à tester d'abord si les fonctions sont supportées par votresystème d'exploitation avant d'é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 Desktop



http://www.developpez.net/forums/u110786/orian/


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

FAQ Java GUI



lien : The mailto URL scheme (RFC 2368)

Comment ouvrir l'explorateur par défaut pour visualiser une page Web ?Auteurs : Baptiste Wicht ,Depuis Java 6, il y a une solution toute simple pour ouvrir l'explorateur par défaut à une page quelconque.Il vous faut employer la classe java.awt.Desktop pour cela.

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

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}



Comment ouvrir un fichier avec le programme par défaut ?Auteurs : Baptiste Wicht ,Depuis Java 6, il y a une solution toute simple pour ouvrir un fichier avec le programme par défaut pour cetype de fichier. Il vous faut employer la classe java.awt.Desktop pour cela.

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

if(Desktop.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}



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




FAQ Java GUI





Comment imprimer un fichier avec le programme par défaut ?Auteurs : Baptiste Wicht ,Depuis Java 6, il y a une solution toute simple pour imprimer un fichier avec le programme par défaut pource type de fichier. Il vous faut employer la classe java.awt.Desktop pour cela.

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}








Documents

FAQ Java GUI - WordPress.com · La méthode setLocationRelativeTo(java.awt.Component) de la classe java.awt.Window permets de faire un centrage par rapport à un composant ou à l'écran