05 - Labo Sun - Cours - Swing Base - 4.0

http://www.labo-sun.com [email protected]

Auteur : Maxime Vialette Version n° 0.1 – 16 octobre 2006

Nombre de pages : 61

Ecole Supérieure d’Informatique de Paris 23. rue Château Landon 75010 – PARIS

www.supinfo.com

Les bases de Swing INTERFACE HOMME-MACHINE

Les bases de Swing – Interface Homme-Machine

2 / 61

http://www.labo-sun.com Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs


3 / 61


Table des matières

1. INTRODUCTION......................................................................................................................................... 5

2. LES JAVA FOUNDATION CLASSES....................................................................................................... 6

2.1. API AWT ................................................................................................................................................. 6 2.2. API SWING ............................................................................................................................................... 6 2.3. API JAVA2D............................................................................................................................................. 6 2.4. DRAG & DROP.......................................................................................................................................... 6 2.5. API ACCESSIBILITY & INTERNATIONALIZATION ...................................................................................... 6

3. FONCTIONNEMENT D’UNE APPLICATION GRAPHIQUE......... ..................................................... 8

3.1. ARCHITECTURE GLOBALE......................................................................................................................... 8 3.2. ÉCRITURE DE L’APPLICATION ................................................................................................................... 9

3.2.1. Création de la classe ........................................................................................................................ 9 3.2.2. Déclaration des composants graphiques.......................................................................................... 9 3.2.3. Initialisation de l’interface graphique.............................................................................................. 9 3.2.4. Définir le conteneur racine............................................................................................................. 10 3.2.5. Lancement de l’application ............................................................................................................ 11

4. LES COMPOSANTS SWING ................................................................................................................... 12

4.1. LES CONTENEURS DE HAUT NIVEAU........................................................................................................ 13 4.1.1. Le conteneur JFrame...................................................................................................................... 13 4.1.2. Le conteneur JDialog ..................................................................................................................... 14 4.1.3. Le conteneur JWindow ................................................................................................................... 17 4.1.4. Le conteneur JApplet ...................................................................................................................... 17

4.2. LES CONTENEURS D’USAGE GENERAL..................................................................................................... 19 4.2.1. Le conteneur JPanel ....................................................................................................................... 19 4.2.2. Le conteneur JScrolPane................................................................................................................ 20 4.2.3. Le conteneur JSplitPane................................................................................................................. 20 4.2.4. Le conteneur JTabbedPane ............................................................................................................ 21 4.2.5. Le conteneur JToolBar ................................................................................................................... 22

4.3. LES CONTENEURS SPECIFIQUES............................................................................................................... 23 4.3.1. JRootPane....................................................................................................................................... 23 4.3.2. ContentPane ................................................................................................................................... 23 4.3.3. JMenuBar ....................................................................................................................................... 24 4.3.4. GlassPane....................................................................................................................................... 25 4.3.5. JLayeredPane................................................................................................................................. 26

4.3.5.1. JDesktopPane ........................................................................................................................................... 27 4.3.5.2. JInternalFrame.......................................................................................................................................... 28

5. LES COMPOSANTS COURANTS........................................................................................................... 29

5.1. LA CLASSE JCOMPONENT....................................................................................................................... 29 5.2. LES COMPOSANTS BOUTONS................................................................................................................... 29

5.2.1. AbstractButton................................................................................................................................ 29 5.2.2. JButton............................................................................................................................................ 30 5.2.3. JRadioButton .................................................................................................................................. 32

5.3. LES COMPOSANTS TEXTE........................................................................................................................ 33 5.3.1. Le JLabel ........................................................................................................................................ 33 5.3.2. La classe JTextComponent ............................................................................................................. 36 5.3.3. JTextField ....................................................................................................................................... 36 5.3.4. JFormattedTextField ...................................................................................................................... 36 5.3.5. JPasswordField .............................................................................................................................. 36 5.3.6. JTextArea........................................................................................................................................ 37 5.3.7. JEditorPane.................................................................................................................................... 39 5.3.8. JTextPane ....................................................................................................................................... 40 5.3.9. Options de style et de formatage ............................................................Erreur ! Signet non défini.


4 / 61


5.4. COMPOSANTS PROPOSANT UNE LISTE DE VALEURS................................................................................. 41 5.4.1. JCheckBox ...................................................................................................................................... 41 5.4.2. JComboBox..................................................................................................................................... 42 5.4.3. JList ................................................................................................................................................ 43 5.4.4. JSpinner.......................................................................................................................................... 45 5.4.5. JSlider............................................................................................................................................. 45

5.5. LES COMPOSANTS DE MENU.................................................................................................................... 46 5.5.1. JMenuBar ....................................................................................................................................... 46 5.5.2. JPopupMenu................................................................................................................................... 46 5.5.3. JMenu ............................................................................................................................................. 46 5.5.4. JMenuItem ...................................................................................................................................... 46 5.5.5. JCheckBoxMenuItem...................................................................................................................... 46 5.5.6. JRadioButtonMenuItem.................................................................................................................. 47

5.6. LES COMPOSANTS INFORMATIFS NON EDITABLES................................................................................... 48 5.6.1. JProgressBar.................................................................................................................................. 48 5.6.2. JToolTip.......................................................................................................................................... 48

5.7. LES CONTROLES DE HAUT-NIVEAU .......................................................................................................... 49 5.7.1. JColorChooser ............................................................................................................................... 49 5.7.2. JFileChooser .................................................................................................................................. 49 5.7.3. JTable ............................................................................................................................................. 49 5.7.4. JTree............................................................................................................................................... 49

6. LA GESTION DES EVENEMENTS......................................................................................................... 50

6.1. PRINCIPE................................................................................................................................................. 50 6.2. LES CLASSES D’EVENEMENTS................................................................................................................. 50

6.2.1. Principe .......................................................................................................................................... 50 6.3. UTILISATION ........................................................................................................................................... 51 6.4. ÉVENEMENTS SPECIFIQUES..................................................................................................................... 51

6.4.1. Evénements de java.awt.event ........................................................................................................ 51 6.4.2. Evénements de javax.swing.event ................................................................................................... 52

6.5. LES LISTENERS D’EVENEMENTS.............................................................................................................. 52

7. UTILISATION DES “MODELES”........................................................................................................... 55

8. AUTRES FONCTIONNALITES............................................................................................................... 56

8.1. LE LOOK-AND-FEEL................................................................................................................................ 56 8.2. LE MODE DE DISTRIBUTION D’APPLICATIONS JAVA ................................................................................. 57 8.3. CHARGEMENTS DES RESSOURCES SITUEES DANS UN JAR ........................................................................ 58 8.4. JAVA WEB START ................................................................................................................................... 59 8.5. INTERNATIONALISATION (I18N) ............................................................................................................. 60

9. CONCLUSION............................................................................................................................................ 61


5 / 61


1. Introduction Dans de nombreux langages de programmation, tels que le C++, la réalisation d’interfaces utilisateur graphiques a posé de nombreux problèmes aux développeurs. De plus, en Java les interfaces doivent être portables d’un système d’exploitation à un autre et offrir des fonctions d’accessibilité puissantes (raccourcis, internationalisation des applications, …) Swing constitue la solution la plus employée pour réaliser des interfaces graphiques en Java car c’est une logique simple et efficace à mettre en œuvre. Swing reprend beaucoup de concept d’AWT (Abstract Window Toolkit), l’ancienne API permettant de réaliser des applications graphiques. Toute la gestion des événements est d’ailleurs toujours centralisée dans l’API d’AWT, Swing a simplement ajouté de nouveaux composants graphiques avec de nouvelles fonctionnalités. Une autre librairie existe. Connue sous le nom de SWT (Standard Widget Toolkit), cette librairie permet de se reposer de façon transparente sur la couche graphique du système d’exploitation (GTK pour linux, Carbon pour MacOSX, …). Les applications sont donc mieux intégrées à l’environnement de l’utilisateur, comme Eclipse. SWT n’est cependant pas compatible avec Swing ou AWT. De plus, cette librairie est trop dépendante d’élément non-Java, donc cela pose certains problèmes de portabilité.


6 / 61


2. Les Java Foundation Classes Il s’agit d’un ensemble de librairies Java fournies avec Java SE afin de permettre la création d’interfaces graphiques (GUI) et de fonctionnalités graphiques.

2.1. API AWT

Cette API existe depuis la version 1.0 de JAVA. Les composants appartenant à l’API AWT sont dits lourds, car ils s’appuient sur le système d’exploitation sous-jacent pour dessiner les composants. Cependant, dans la version 1.1 de Java, AWT a été étendue pour permettre la création de composants dits « légers » ne s’appuyant pas sur le système d’exploitation. Ceci peut causer des problèmes, surtout au niveau de la portabilité, car les composants ont l’aspect du système sur lequel ils s’exécutent, ce qui peut créer des problèmes d’un système à un autre.

2.2. API Swing

Cette API est apparue en même temps que les JFC (Java Foundation Classes) dont elle constitue la pierre angulaire. Cette API est totalement écrite en langage Java et s’avère être totalement portable. Cependant, Swing n’a pas pour vocation de remplacer AWT, mais plutôt de la compléter.

2.3. API Java2D

Cette API permet la gestion des graphiques bidimensionnels. Ainsi, il sera aisé d’ajouter du texte et des graphiques de qualité dans nos applications. De plus, de nombreuses fonctions utilitaires sont disponibles : gestion de l’impression, représentation de graphiques, rotation, mise à l’échelle, lissage de texte, etc.

2.4. Drag & Drop

Cette API permet les transferts de données entre des applications indépendantes. Ainsi, le copier-coller et le glisser-déplacer sont implémentés.

2.5. API Accessibility & Internationalization

L’API Accessibility permet d’utiliser des fonctions d’assistance diverses à l’attention, entre autres, des déficients physiques. L’API Internationalization permet au développeur de créer des applications multilingues qui s’adaptent au contexte géographique et culturel (nous apprendrons à nous en servir dans cet essentiel).


7 / 61



8 / 61


3. Fonctionnement d’une application graphique

3.1. Architecture globale

Une application graphique est un emboitement d’objets.

On utilise des objets « conteneurs » pour rassembler par groupe les composants que l’on affiche. Il peut s’agir de fenêtres, ou bien des « Panels », qui sont plus discrets mais permettent d’organiser la disposition.

Dans l’interface utilisateur que nous voyons ci-dessus, nous pouvons dénombrer des conteneurs :

- La fenêtre, du type JFrame

- La liste des villes, dans un JPanel

- L’entrée « jContentPane », qui est le panel principale de la fenêtre.

Les composants que l’on affiche sont des champs de texte, mais il en existe beaucoup d’autres (boutons, listes déroulantes, etc.).


9 / 61


3.2. Écriture de l’application

Dans l’exemple que nous allons voir, nous allons écrire une fenêtre qui contiendra des Labels (champs texte non éditables). Lorsque vous exécuterez l’application, vous devriez voir l’équivalent de l’interface graphique vue plus haut.

L’intérêt n’est pas d’expliquer les composants de façon précise, nous le ferrons dans les chapitres suivants, mais de pouvoir déclarer une première interface graphique.

3.2.1. Création de la classe

Nous allons créer une classe nommée TravelMonth, située dans le package com.labosun.swing.exercise1 :

package com.labosun.swing.exercise1; // import awt and swing objects import java.awt.*; import javax.swing.*; public class TravelMonth extends JFrame {

…

}

Nous allons par la suite écrire le code de cette classe.

3.2.2. Déclaration des composants graphiques

Nous déclarons maintenant tous les composants dont nous avons besoin. Les explications sur chaque composant sont en commentaire dans le code :

// optional field, used by Serialization private static final long serialVersionUID = 1L; // root container of the JFrame private JPanel jContentPane = null; // enclose some jlabels private JPanel jPanel = null; // display text informations private JLabel travel1 = null; private JLabel travel2 = null; private JLabel travel3 = null; private JLabel jLabel = null;

3.2.3. Initialisation de l’interface graphique

Dans un premier temps, le constructeur initialise la fenêtre, de type JFrame, et ici représentée par le mot clé this.


10 / 61


/**

* This is the default constructor */ public TravelMonth() { super(); initialize(); } /** * This method initializes "this" * * @return void */ private void initialize() { // define the size of the frame this.setSize(300, 200); // define the default operation when // the frame is closed this.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE); // define which panel is the root panel this.setContentPane(getJContentPane()); // define the title of the frame this.setTitle( "Travel Agency" ); }

3.2.4. Définir le conteneur racine

Le conteneur correspond à la variable « jContentPane ». Nous allons l’instancier dans la méthode suivante :

/** * This method initializes jContentPane * * @return javax.swing.JPanel */ private JPanel getJContentPane() { // if the jContentPane has not been initialized yet if ( jContentPane == null) { // create an instance of JPanel jContentPane = new JPanel(); // display the following phrase "Travels during thi s month : " // on the top of your application jLabel = new JLabel(); jLabel .setText( "Travels during this month :" ); jContentPane .add( jLabel ); // dispose a panel at the center of the frame jContentPane .add(getJPanel()); } return jContentPane ; }

La méthode getJPanel() n’a pas encore été vue. Voici son contenu : /** * This method initializes jPanel


11 / 61


* * @return javax.swing.JPanel */ private JPanel getJPanel() { // if this object has not been initialized yet if ( jPanel == null) { // create an instance of JPanel jPanel = new JPanel(); // the jPanel variable contains the // following 3 labels, which are // also initialized in the current method travel3 = new JLabel(); travel3 .setText( "Shanghai" ); travel2 = new JLabel(); travel2 .setText( "Beijing" ); travel1 = new JLabel(); travel1 .setText( "Madrid" ); // add the labels to the jPanel jPanel .add( travel1 , null); jPanel .add( travel2 , null); jPanel .add( travel3 , null); } return jPanel ; }

3.2.5. Lancement de l’application

La méthode main(…) sert de point d’entrée dans notre application.

/** * This is the entry point of the application * * @param args */ public static void main(String[] args){ TravelMonth exercice = new TravelMonth(); // a JFrame is not visible by default exercice.setVisible( true); }


12 / 61


4. Les composants Swing Il existe beaucoup de composants Swing et nous allons devoir les regrouper par ensemble :

- Les composants de haut niveau : les fenêtres (JFrame, JDialog, etc.) - Les conteneurs d’usage général : les onglets (JTabbedPane), le scrolling (JScrollPane), les

panels (JPanel), … - Les conteneurs spécifiques : les fenêtres interne, appelées aussi MDI (JDesktopPane), utiliser

des calques (JLayeredPane), - Les contrôles courants : les boutons (JButton), les listes (JList), les menus (JMenu), … - Les composants graphiques non-éditables : barre de progression (JProgressBar), … - Les contrôles de haut-niveau : les sélecteurs de fichiers (JFileChooser), les tableurs (JTable),

les explorateurs (JTree), … En rappel du chapitre précédent, « conteneurs » sont des composants servant à en contenir d’autres. Par exemple dans l’arbre des composants suivant nous pouvons dénombrer un JFrame (à la racine), un JPanel comme conteneur principale pour le JFrame (jContentPane) ainsi qu’un second regroupant 3 labels. Le dernier est la barre de menu, appelé jJMenuBar :


13 / 61


4.1. Les conteneurs de haut niveau

4.1.1. Le conteneur JFrame

Cette classe se situe, comme beaucoup d’autres, dans le package javax.swing. Dans une application Swing, le conteneur principal est une JFrame (Fenêtre). Une de ses propriétés se nomme rootPane, une instance de JRootPane (Panneau Racine), et c’est à ce conteneur que l’on ajoutera des composants. Nous reviendrons sur ce composant un peu plus tard.

Nous allons voir en détails tous ces objets dans la suite du cours.

Ci-dessous, nous allons présenter les principales méthodes de la classe JFrame.

Parmi les constructeurs de la classe JFrame :

o JFrame() crée une nouvelle fenêtre initialement invisible

o JFrame(String) crée une nouvelle fenêtre initialement invisible avec un titre spécifié

Méthodes utiles de la classe JFrame :

o getContentPane() retourne le contentPane de la fenêtre

o add(Component c) ajoute un composant au ContentPane de la fenêtre

o setDefaultCloseOperation(int) spécifie l’action de fermeture par défaut

o setJMenuBar(JMenuBar menu) attribue un menu à cette fenêtre

o setLayout(LayoutManager lay) attribue un Layout qui doit être utilisé par le ContentPane

o setVisible(boolean) affiche ou fait disparaître la fenêtre (remplace les méthodes show() et hide() qui sont dépréciées)

o setTitle(String) attribue un titre à la fenêtre

o setSize(int, int) attribue des dimensions à la fenêtre


14 / 61


4.1.2. Le conteneur JDialog

Peu de choses différencient les classes JFrame et JDialog. JFrame est une fenêtre principale, alors que JDialog est une fenêtre secondaire, qui peut être modale par rapport à une autre JDialog ou JFrame. La classe JDialog est utilisée pour afficher des boîtes de dialogue tandis que JFrame est utilisée en tant que fenêtre principale de l’application.

Une fenêtre de type JDialog s’utilise de la même façon qu’une JFrame. La classe JDialog hérite de java.awt.Dialog et est utilisée pour créer une boîte de dialogue personnalisée. JDialog est en effet un conteneur pratiquement identique à JFrame.

Voici les différents constructeurs auxquels vous avez accès :

o JDialog() crée une JDialog non modale, sans titre et sans parent

o JDialog(Dialog, String,boolean) crée une JDialog modale ou non, avec titre et parent

o JDialog(Frame,String,boolean) crée une JDialog modale ou non, avec titre et parent

Une JDialog se positionne dans le coin gauche et haut de l’écran, il faut obligatoirement coder le placement de la boîte de dialogue, pour obtenir son placement au centre de la fenêtre parent.

Voici un exemple d’utilisation :

La classe JOptionPane fournit une manière facile et pratique d’afficher des boîtes de dialogues standard.

Une boîte de dialogue standard de type JOptionPane se présente de la manière suivante :

Zone de Message

Zone d’options (Boutons)

Zone d’image (icône) Zone de saisie

( JTextField ou JComboBox)


15 / 61


Il est à noter qu’une boîte de dialogue JOptionPane est modale.

JOptionPane n’hérite pas de JDialog, mais directement de JComponent.

A ce titre JOptionPane agit comme un container et peut être placé dans n’importe quel type de container.

Il est possible d’instancier directement des JOptionPane de la façon suivante :

JOptionPane.showMessageDialog( null, "Votre disque va être entièrement effacé" , "Alerte" , JOptionPane.ERROR_MESSAGE);

JOptionPane.showConfirmDialog( null, "Voulez vous quitter l'application" , "Sélection" , JOptionPane.YES_NO_OPTION);

Object[] options = { "ACCEPTER", "REFUSER"}; JOptionPane.showOptionDialog( null, "Les valeurs doivent elles êtres définitivement effacées ?" , "Attention" , JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_M ESSAGE, null, options, options[0]);


16 / 61


String inputValue = JOptionPane.showInputDialog( "Entrez une valeur" );

Object[] possibleValues = { "France" , "Royaume-Uni" , "Allemagne" , "Irlande" , "Belgique" }; Object selectedValue = JOptionPane.showInputDialog( null, "Choose one" , "Input" , JOptionPane.INFORMATION_MESSAGE, null, possibleValues, possibleValues[0]);

4.1.3. Méthodes showXxxDialog

Quelques méthodes showXxxDialog(), les plus usitées, sont présentées ci-après, toutefois celles-ci sont plus nombreuses en réalité.

showConfirmDialog(Component Parent,Object Message)

Affiche une DialogBox avec les boutons Oui, Non et Annuler, avec le titre Sélectionnez une option (on peut passer null comme parent, sinon un JComponent, et l’object peut être une String)

showConfirmDialog(Component Parent, Object Message, String title, int optionType, int messageType)

Cette méthode permet de personnaliser les icônes affichées et le groupe de boutons associés

showInputDialog(Component Parent, Object message)

Crée une boîte de dialogue de saisie


17 / 61


showMessageDialog(Component Parent, Object message)

Crée une boîte de dialogue affichant un message

showOptionDialog(Component Parent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object i nitialValue)

Crée une boîte de dialogue d’options avec un choix initial (focus), une icône personnalisée, et une liste de choix (Combo)

Les constantes associées sont les suivantes : messageType : définit le style de message

• ERROR_MESSAGE • INFORMATION_MESSAGE • WARNING_MESSAGE • QUESTION_MESSAGE • PLAIN_MESSAGE

optionType : définit le type de boutons d’options qui apparaissent en bas de la boîte de dialogue.

• DEFAULT_OPTION • YES_NO_OPTION • YES_NO_CANCEL_OPTION • OK_CANCEL_OPTION

Valeurs de retour : lorsqu’une fonction showXxxDialog retourne un entier, les valeurs possibles sont :

• YES_OPTION • NO_OPTION • CANCEL_OPTION • OK_OPTION • CLOSED_OPTION

4.1.4. Le conteneur JWindow

JWindow est un cas particulier de fenêtre. Cela ressemble à une JFrame sans « pourtour » (bordure). Cette fenêtre n’est ni redimensionnable, ni déplaçable par l’utilisateur. Il n’existe pas non plus de bouton pour fermer l’application, c’est au développeur de programmer la fermeture de ce type de fenêtre.

La classe JWindow est très utilisée pour coder un splash screen, cette image qui s’affiche au lancement d’une application pendant la durée de l’initialisation de cette dernière.

4.1.5. Le conteneur JApplet

18 / 61


Un applet est un petit programme qu’un navigateur capable d’interpréter le Java, par exemple Internet Explorer ou Netscape Navigator, peut télécharger à partir d’internet et exécuter. JApplet est une sous classe de java.applet.Applet. Comme JApplet est un conteneur Swing de haut-niveau, chaque applet Swing a un panneau racine (root pane), ainsi qu’un content pane unique. Pour ajouter un composant à votre applet, vous devez donc l’ajouter au content pane de votre JApplet, et pas directement dans l’applet. Inclure un applet dans une page HTML : Pour ajouter un applet dans une page HTML, il est recommandé de l’inclure en utilisant la balise « applet » de cette façon : <applet code="MonApplet.class" width="600" height="95"> </applet>

Si vous souhaitez visualiser l’applet que vous avez incluse dans votre page HTML (qu’on appellera pour l’exemple maPageAvecMonApplet.html), vous pouvez l’exécuter en utilisant l’application appletviewer, présente dans le JDK, en ligne de commande, de cette façon : appletviewer maPageAvecMonApplet.html Vous pouvez également tout simplement charger votre page HTML dans votre navigateur. Le cycle de vie d’un applet : Basiquement, il y a quatre méthodes dans la classe Applet :

• init() : Cette méthode est utilisée pour l’initialisation de l’applet. Elle est appelée après les attributs « param » de la balise « applet ».

• start() : Cette méthode est automatiquement appelée après la méthode init() . Elle est également appelée chaque fois que l’utilisateur retourne à la page contenant l’applet après avoir visité d’autres pages.

• stop() : Cette méthode est automatiquement appelée chaque fois que l’utilisateur quitte la page contenant l’applet. Vous pouvez utiliser cette méthode pour stopper une animation.

• destroy() : Cette méthode est appelée uniquement quand le navigateur est éteint normalement. Ainsi, l’applet peut être initialisé une et seulement une fois, démarré et stoppé une ou plusieurs fois dans sa vie, et détruit une et seulement une fois.


19 / 61


4.2. Les conteneurs d’usage général

4.2.1. Le conteneur JPanel Le conteneur JPanel est l’un des conteneurs les plus utilisés. Il sert souvent à rassembler les composants par « groupes » afin de simplifier la disposition. L’aspect graphique d’un JPanel est réduit au strict minimum, il peut être perçu comme un rectangle, parfois même invisible graphiquement. Il est possible de modifier la couleur de fond d’un JPanel, sa taille, sa position, son état (visible, invisible, avec ou sans bordure, etc). JPanel est un nœud « idéal » dans une arborescence de composants. La création d’un nouveau JPanel n’est cependant pas obligatoire. En effet, vous pouvez réutiliser le JPanel définit par défaut dans votre JFrame en utilisant la méthode getContentPane() qui permet de récupérer ce dernier. L’ajout d’un composant dans un JPanel se fait par le biais de la méthode add(…) héritée de Container. JFrame myFrame = new Jframe(); JPanel p1 = new JPanel(); JPanel p2 = new JPanel(); JButton button1 = new JButton(); JButton button2 = new JButton(); JButton button3 = new JButton(); p1.add(button1); p1.add(button2); p1.add(button3); JLabel myLabel = new JLabel(); JTextField myTextField = new JTextField(); p2.add(myLabel); p2.add(myTextField); myFrame.getContentPane().add(p1); myFrame.getContentPane().add(p2);

Voici une représentation hiérarchique de l’ensemble de vos composants :

Exemple d’imbrication des composants de Swing


20 / 61


4.2.2. Le conteneur JScrolPane Lorsque le composant que l’on cherche à afficher est trop grand (une image, un tableau, un champ texte,…), il est alors possible de faire appel au conteneur JScrollPane afin d’utiliser une barre de défilement. JScrollPane, contrairement à JPanel, n’accepte qu’un seul composant. Il a un impact graphique plus important que JPanel du fait de la présence de barre de défilement.

JScrollPane propose une barre de défilement

L’acceptation d’un composant dans un JScrollPane est un processus particulier. En effet, le JScrollPane forme une vue sur le composant, on n’utilise pas add() mais la méthode setViewportView(Composant). Voici un exemple de code : JScrollPane sp = new JScrollPane(); // déclaration du JScrollPane JLabel monLabel = new JLabel( "Mon Libellé" ); // déclaration du libellé sp.setViewportView(monLabel); // formation de la vue sur le // composant fenetre.getContentPane().add(sp); // ajout de JScollPane à la fenêtre // principale

4.2.3. Le conteneur JSplitPane JSplitPane est un conteneur qui permet de séparer une fenêtre en deux parties dont les surfaces peuvent changer dynamiquement. Ce conteneur s’utilise de façon classique, mais il ne peut contenir que deux composants (ou conteneurs), un de chaque côté de la barre de séparation.


21 / 61


JSplitPane permet de diviser verticalement une partie de la fenêtre

JSplitPane peut être orienté horizontalement ou verticalement, suivant que l’on utilise les méthodes suivantes (elles vont par 2) :

o setLeftComponent(composant) o setRightComponent(composant) ou o setTopComponent(composant) o setBottomComponent(composant)

D’autres méthodes servent, quant à elles, à permettre ou non de redimensionner la taille des deux parties dynamiquement :

o setContinuousLayout(true) : Dynamique (Modifier) o setContinuousLayout(false) : Statique (Ne pas Modifier)

Enfin, il existe aussi une méthode qui permet le double clic sur la barre pour la faire apparaître ou disparaître brusquement. setOneTouchExpandable(true)

4.2.4. Le conteneur JTabbedPane Ce conteneur permet d’afficher plusieurs panneaux qui partagent le même espace graphique. L’accès à chaque panneau se fait par le biais d’onglets le plus souvent situés en haut du conteneur.

JTabbedPane permet de partager l’espace de travail

Les trois constructeurs existants sont les suivants :

o JTabbedPane() : crée un TabbedPane vide par défaut. o JTabbedPane(int tabPlacement) : spécifie le placement des onglets


22 / 61


• JTabbedPane.TOP • JTabbedPane.BOTTOM • JTabbedPane.LEFT • JTabbedPane.RIGHT

o JTabbedPane(int tabPlacement, int tabLayoutPolicy) : politique d’affichage des onglets • JTabbedPane.WRAP_TAB_LAYOUT • JTabbedPane.SCROLL_TAB_LAYOUT

On peut ensuite créer les onglets un à un à l’aide de la méthode addTab() : JTabbedPane monPanneau = new JTabbedPane(); JPanel pan1 = new JPanel( new BorderLayout()); JPanel pan2 = new JPanel( new BorderLayout()); ... monPanneau.addTab( "Onglet 1" , pan1); monPanneau.addTab( "Onglet 1" , pan2); ... getContentPane().add(monPanneau);

4.2.5. Le conteneur JToolBar La classe JToolBar permet d’avoir une barre d’outils avec des boutons de raccourci.

JToolBar permet de placer des raccourcis dans une barre verticale ou horizontale

… JToolBar toolBar = new JToolBar(); toolBar.add( new JLabel( "mon test" )); myFrame.getContentPane().add(toolBar); …


23 / 61


4.3. Les conteneurs spécifiques

4.3.1. JRootPane

Une instance de JRootPane est créée automatiquement par la JFrame lorsque son constructeur fait appel à la méthode createRootPane().

Le JRootPane ainsi créé contient les éléments suivants : o ContentPane (un JPanel par défaut) o MenuBar (un JMenuBar null par défaut) o GlassPane (un JPanel par défaut) o LayeredPane (un JLayeredPane)

Voici l’illustration des différents éléments évoqués précédement :

• ContentPane est un panneau créé lui aussi par défaut. Il reçoit les composants à l’aide de l’instruction suivante :

maJFrame.getContentPane().add(monComponent)

• MenuBar n’existe pas par défaut (il est à null, donc pas encore instancié). Cependant, on peut le définir avec la méthode suivante :

setJMenuBar(menu);

• GlassPane est transparent et s’avère très utile lorsqu’il va s’agir d’intercepter des événements générés par la souris.

• LayeredPane correspond à un type particulier (JLayeredPane), et il va permettre de contenir des fenêtres filles à l’instar des applications MDI de Microsoft.

Nous allons étudier d’avantage ces quatre derniers objets.

4.3.2. ContentPane Il sagit du conteneur associé au JRootPane, et qui contient l’ensemble des composants que nous détaillerons plus tard (les boutons, les listes, …).

GlassPane LayeredPane

ContentPane

MenuBar


24 / 61


4.3.3. JMenuBar

JMenuBar est une barre de menus. Il ne peut en exister qu’une seule par JFrame.

Une instance de JMenuBar est composée de plusieurs instances de JMenu, qui sont les éléments visibles directement dans la barre de menus.

Chaque instance de JMenu peut contenir plusieurs instances de JMenuItem, qui sont les éléments visibles quand l’utilisateur clique sur un menu.

JMenuBar permet d’afficher des … barres de menu

Voici la liste des méthodes les plus utilisées afin de construire une fenêtre avec une barre de menus :

o Classe JMenuBar

• JMenuBar() Constructeur unique. • add(JMenu) Méthode d’ajout d’un menu à la barre de menus.

o Classe JMenu

• JMenu() Constructeur par défaut. • JMenu(String s) Constructeur d’un menu avec son libellé • add(JMenu) Méthode d’ajout d’un JMenu au menu afin d’obtenir des

sous-menus. • add(JMenuItem item) Méthode d’ajout d’un JMenuItem au menu • addSeparator() Méthode d’ajout d’une barre de séparation

o Classe JMenuItem (Elément de menu)

• JMenuItem() Constructeur par défaut • JMenuItem(String s) Constructeur d’un élément de menu avec son libellé • addActionListener(ActionListener al) Méthode d’ajout de Listener, permettant la

gestion des événements (nous verrons les Listener plus loin dans ce document).

o Classe JFrame

• setJMenuBar(JMenuBar menu) Méthode pour transmettre une barre de menus à JFrame.


25 / 61


Nous reviendrons sur ce composant de façon plus détaillée dans la partie sur les contrôles basiques.

4.3.4. GlassPane Le composant GlassPane représente un panneau transparent positionné au dessus du JRootPane permettant de capturer les événements de souris. Le GlassPane par défaut est accessible via les méthodes getGlassPane() et setGlassPane(Component c) de l’interface RootPaneContainer implémentées par les conteneurs ayant un JRootPane. Ce composant agit comme un calque qui recouvre notre conteneur et qui peu intercepter les évènements ou superposer des éléments graphique. Par exemple, on peut utiliser le composant GlassPane pour désactiver tout un ensemble de composants en intercepetant leurs évènements. On peut également l’utiliser pour superposer des éléments graphiques. En pratique, on personnalise notre propre GlassPane afin de l’affecer au GlassPane par défaut via la méthode setGlassPane(Component c). Dans ce cas précis, l’objet en paramètre serait notre GlassPane personnalisé. Voici un exemple de code permetttant représentant un composant GlassPane personnalisé : // Crée une classe représentant notre GlassPane per sonnalisé. // Ce GlassPlane est un JComponent qui implémente I temListener pour la gesion des // évènements. class MonGlassPane extends JComponent implements ItemListener { Point point ; //Réagit au changement d’état d’un élément. Affiche ou cache la GlassPane. //Quand l’élément est sélectionné alors le Glas sPane est visible sinon non. public void itemStateChanged(ItemEvent e) { setVisible(e.getStateChange() == ItemEvent. SELECTED); } //Dessine un point rouge sur la GlassPane selon les coordonnées du point. protected void paintComponent(Graphics g) { if ( point != null) { g.setColor(Color. red); g.fillOval( point . x - 10, point . y - 10, 20, 20); } } //Modifie la position du point. public void setPoint(Point p) { point = p; } //Constructeur créant un écouteur personnalisé pour les différents éléments de //la fenêtre. //Redirige les écouteur de mouvement et de cliq ue de souris vers l’écouteur //personnalisé. public MyGlassPane(AbstractButton aButton, JMenuBar menuB ar, Container contentPane) { CBListener listener = new CBListener(aButton, menuBar, this, contentPane); addMouseListener(listener); addMouseMotionListener(listener); } }


26 / 61


4.3.5. JLayeredPane

JLayeredPane est un conteneur qui peut posséder un nombre de couches. Les composants contenus dans un Layer (une couche de JLayeredPane) sont organisés selon leur position dans un environnement en « 3 Dimensions » : hauteur, largeur et profondeur.

JLayeredPane permet de définir une profondeur aux éléments contenus

Chaque JLayeredPane est caractérisé par la possibilité d’ajouter un composant à une couche. Pour définir la priorité de cette couche on doit préciser une priorité. Une valeur de type Integer donne ainsi la priorité de la couche par rapport aux autres. Cette prioritée joue également sur l’ordre d’affichage. En effet, plus la valeur est grande plus le panel sera prioritaire et donc mise en avant.

Par exemple, lorsque l’on souhaite ajouter un composant JLabel dans notre JLayeredPane, on spécifie une valeur de type Integer définissant dans quel couche il sera ajoutée.

Pour cela nous avons deux manières de procéder.

D’une manière personnalisée en attribuant une valeur de type Integer en second paramètre.

layeredPane .add(label, new Integer(1));

D’une manière prédéfinie, le JLayeredPane prévoit des valeurs par défaut stocké dans des constantes. layeredPane .add(label, JLayeredPane. DEFAULT_LAYER);


27 / 61


La profondeur (Depth)

Lorsqu’un composant est contenu dans un Layer (couche), ce dernier s’appropie la priorité du Layer.

Mais, un composant est aussi représenté par son index. L’index est une valeur entière différente pour chacun des composants du JLayeredPane. On peut interroger un composant pour connaître son index, mais on ne peut pas changer l’index d’un composant.

Chaque Layer d’un JLayeredPane est représenté par un objet Integer.

La classe JLayeredPane définit les six constantes Integer. Voici dans l’ordre du moins prioritaire au plus prioritaire.

o FRAME_CONTENT_LAYER o DEFAULT_LAYER o PALETTE_LAYER o MODAL_LAYER o POPUP_LAYER o DRAG_LAYER

L’ajout de Layer

Lorsque l’on ajoute un composant au JLayeredPane à l’aide de la méthode add(Component), celui-ci est placé dans le Layer DEFAULT_LAYER (représenté par Integer(0));

Pour ajouter un composant à un Layer particulier, on utilise la méthode add(Component, Object). Pour le Layer 10 par exemple, on passera l’objet Integer(10).

On peut aussi passer les valeurs des Layers standards, par exemple JLayeredPane.POPUP_LAYER

Pour ajouter un composant à un Layer particulier et à une position donnée, on utilisera la méthode add(Component composant, Object obj, int position).

4.3.5.1. JDesktopPane JDesktopPane est une extension de JLayeredPane spécialement construite pour gérer des fenêtres filles du type JInternalFrame. Il est plus souvent utilisé que JLayeredPane car plus fonctionnel.

JDesktopPane permet de gérer des sous-fenêtres

JDesktopPane permet d’ajouter des composants à l’aide de la méthode add(Component). Dans le cas de JDesktopPane, le composant que l’on va ajouter est un objet de la classe JInternalFrame qui correspond aux fenêtres filles d’une application MDI.


28 / 61


En plus de la méthode add(), d’autres méthodes peuvent être utiles, comme :

o JInternalFrame [] getAllFrames() : retourne une collection de JInternalFrame actuellement affichées dans le JDesktopPane.

o setSelectedFrame(JInternalFrame f) : rend la JInternalFrame « f » active. Il est accessible par le biais des méthodes getContentPane() et setContentPane(Container c) de l’interface RootPaneContainer implémentées par les conteneurs ayant un JRootPane.

4.3.5.2. JInternalFrame

JInternalFrame est une fenêtre qui peut être déplacée, agrandie, réduite, iconifiée, … à l’intérieur d’un JDesktopPane. JInternalFrame contient un JRootPane comme JFrame. On peut donc avoir accès à son GlassPane, ContentPane, LayeredPane, et MenuBar. On va donc agir comme on le faisait avec JFrame.

Voici ci-dessous des méthodes utiles :

o setLocation(int x, int y) définit la position de la JInternalFrame. o setLocationRelativeTo(null) positionne selon le centre de l’écran. o setSize(int,int) définit la taille de la fenêtre. o setDefaultCloseOperation() ici, on donnera la constante :

• HIDE_ON_CLOSE • DISPOSE_ON_CLOSE • DO_NOTHING_ON_CLOSE

o setResizable(boolean) définit si la fenêtre peut être retaillée ou non. o setIconifiable(boolean) définit si la fenêtre peut être iconifiée ou non o setIcon(boolean) iconifie / desiconifie la fenêtre. o setMaximizable(boolean) définit si la fenêtre peut être agrandie ou non o setMaximum(boolean) maximise la fenêtre ou revient à la taille normale o setClosable(boolean) définit si la fenêtre peut être fermée ou non o setClosed(boolean) ferme la fenêtre


29 / 61


5. Les composants courants Jusqu’ici nous avions seulement abordé le cas des « conteneurs », cependant, ce qui fait la véritable richesse d’une interface graphique est l’utilisation des composants : les boutons, les champs de saisi, les images, etc. Nous allons maintenant voir ceux les plus communs, et les plus simples à mettre en œuvre.

5.1. La classe JComponent La classe JComponent est la classe mère de tous les composants Swing hormis les conteneurs de haut niveau. Elle étend la classe java.awt.Container. Elle apporte de nombreuses fonctionnalités aux composants Swing, tel que le support des bordures, la possibilité d’associer des icônes aux composants, le support des ToolTips, etc. Les principales méthodes de ce composant sont :

o JComponenent() Constructeur par défaut o createToolTip() Crée une bulle d’aide o getBorder() Retourne la bordure du composant ou null si elle n’est

pas définie o getPreferredSize() Retourne la taille préférée o getMinimumSize() Retourne la taille minimale o getMaximumSize() Retourne la taille maximale o paint(Graphics g) Dessine le composant o requestFocus() Demande à avoir le focus o setVisible(boolean aFlag) Définit si le composant est visible ou non o setBackground(Color bg) Définit la couleur de fond o setBorder() Définit la bordure o setDoubleBuffered(boolean aFlag) Définit si le double buffering sera utilisé o setPreferredSize() Définit la taille préférée o setMinimumSize() Définit la taille minimale o setMaximumSize() Définit la taille maximale o setToolTipText(String text) Crée une bulle d’aide avec le texte spécifié o setVisible(boolean aFlag) Définit t si le composant sera affiché ou non

5.2. Les composants boutons

La classe AbstractButton est la classe de base à partir de laquelle dérivent plusieurs autres composants. Vous n’utiliserez pas directement la classe AbstractButton, car, comme son nom l’indique, cette classe ne peut pas être instanciée. Vous devrez donc utiliser une des classes filles suivantes :

5.2.1. AbstractButton


30 / 61


Ce composant abstrait fournit les éléments communs aux boutons ainsi qu’aux entrées dans la barre de menu. On remarque qu’il hérite de JComponent, et donc de tous les comportements qui en découlent (affichage d’une bordure, définition d’une taille par défaut,…). Cette classe proprose des éléments intéressants qui servent à la gestion des évènements d’un bouton, lorsqu’on le clic par exemple :

• void addActionListener(ActionListener l) Ajoute un ActionListener au bouton (nous traiterons de cette interface plus tard).

• ActionListener[] getActionListeners() Retourne la liste des ActionListener inscrit aux évènements du bouton.

• void removeActionListener(ActionListener l)

Supprime l’ActionListener spécifié en paramètre.

• void doClick() Simule un clic "click".

• protected void fireActionPerformed(ActionEvent event)

Simule un événement.

• String getActionCommand() • void setActionCommand(String actionCommand)

Définie/Retourne l’identifiant du bouton. Cet identifiant permet de savoir exactement quel composant a généré l’événement.

• void setEnabled(boolean b) Active (ou désactive) le bouton. Autres méthodes couramment utilisées :

• void setText(String text) Définit le texte affiché par le bouton

• void setUI(ButtonUI ui) Définit le Look&Feel qui rend ce composant.

5.2.2. JButton

JButton est un bouton poussoir classique très simple. Tout ce que nous savons sur JLabel s’applique à un JButton. Nous pouvons lui ajouter des images, spécifier l’alignement, ou encore appliquer des


31 / 61


couleurs d’arrière et d’avant plan. De plus, nous pouvons ajouter des Listeners (ActionListener, ChangeListener, ItemListener) pour capturer les événements. Nous reviendrons en détail sur cette partie dans le chapitre 10 : « Erreur ! Source du renvoi introuvable. » qui y est dédié.

Méthodes et classes de base :

o JButton() Crée un bouton sans image et sans texte o JButton(Icon) Crée un bouton avec une image o JButton(String) Crée un bouton avec un texte o JButton(String, Icon) Crée un bouton avec un texte et une image o setHorizontalAlignement(int) Définit l’alignement horizontal du contenu o setVerticalAlignement(int) Définit l’alignement horizontal du contenu o setHorizontalTextPosition(int) Définit la position du texte relativement à l’image o setVerticalTextPosition(int) Idem mais sur l’axe des y o setIcon(Icon icon) Permet de spécifier ou de remplacer à tout moment

l’image du bouton o setPressedIcon(Icon) Permet de spécifier une image lorsque le bouton est

pressé o setRolloverIcon(Icon) Permet de spécifier une image lorsque le bouton est

survolé o getText() Récupère le texte du bouton o getIcon() Récupère l’icône du bouton o setIcon(Icon) Permet de spécifier l’image du bouton o setText(String) Permet de spécifier le texte pour le bouton (supporte

le html) o setMnemonic(char) Crée un raccourci vers un caractère

(ex : setMnemonic('C') correspond à « Alt+C ») o addActionListener(ActionListener) Ajouter le bouton à un ActionListener o setEnabled(boolean) Activer / Désactiver le bouton o setActionCommand(String) Permet de définir une commande liée au Listener du

bouton Dans votre application, il se peut également que vous souhaitiez définir le bouton par défaut parmi tous les boutons présents. Pour cela, vous devrez utiliser la méthode setDefaultButton(JButton button) de votre RootPane. Voici le code illustrant ce principe : JFrame myFrame = new JFrame("Commercial Survey"); JButton btnSend = new JButton("Send"); myFrame.add(btnSend);

Voici un exemple de bouton affichant « Send » :

On remarquera également JToggleButton, qui est une variante du JButton. En effet, il s’affiche d’une façon particulière une fois qu’il a été sélectionné (en fonction du Look & Feel sélectionné).

32 / 61


5.2.3. JRadioButton Un JRadioButton est un bouton radio. Il s’utilise comme la classe JCheckBox, mais permet de spécifier qu’il n’y a qu’un seul choix possible parmi toutes les propositions offertes par l’interface graphique. La classe JRadioButton doit cependant être utilisée conjointement avec la classe ButtonGroup si vous souhaitez obtenir le comportement standard de choix unique parmi tous les choix proposés. La classe ButtonGroup permet donc de regrouper des boutons qui peuvent mettre en place un mécanisme de sélection basé sur l’exclusion mutuelle (comme avec les boutons radio classiques). Il suffit pour cela de grouper les boutons en question dans une instance de ButtonGroup , à l’aide de la méthode add(Button). Dans le code suivant, nous allons instance des objets de type JRadioButton puis nous les plaçons dans un ButtonGroup . … /**************************** * create radio buttons ***** ****************************/ // mario choice JRadioButton buttonMario =

new JRadioButton( "<html>Mario Bros</html>" ); // this one is selected by default buttonMario.setSelected( true); // sonic choice JRadioButton buttonSonic =

new JRadioButton( "<html>Sonic the hedgehog</fon t></html>" );

// warcraft choice JRadioButton buttonWarcraft =

new JRadioButton( "<html>Warcraft</html>" );

// group the radio buttons together ButtonGroup group = new ButtonGroup(); group.add(buttonMario); group.add(buttonSonic); group.add(buttonWarcraft); …

Afin de récupérer l’élément sélectionné, nous devons appelé la méthode « ButtonGroup.getSelection() ». Nous récupérerons ainsi le modèle de bouton radio sélectionné. Nous verrons plus tard l’intérêt d’un modèle mais retenons pour l’instant qu’il s’agit d’un objet contenant les données et les états du composant. Voici un exemple d’application utilisant les boutons radio :


33 / 61


Nous avons pu remarquer également la syntaxe HTML que nous venons d’utiliser pour spécifier les couleurs des zones de texte.

5.3. Les composants texte

5.3.1. Le JLabel

Lorsque vous réalisez une application graphique, il est important d’y ajouter suffisament de libellés afin de faciliter l’ergonomie de cette dernière. Vous devrez pour cela utiliser la classe JLabel qui est l’un des composants Swing les plus simples. Il permet d’afficher du texte, des icônes, ou les deux, et cela dans n’importe quelle position.

Voici un descriptif des méthodes les plus employées :

o JLabel() Crée un libellé sans image et avec une chaîne vide pour titre

o JLabel(Icon) Crée un libellé avec une image

o JLabel(Icon, int) Crée un libellé avec une image alignée horizontalement

o JLabel(String) Crée un libellé avec du texte

o JLabel(String, int) Crée un libellé avec du texte aligné horizontalement

o JLabel(String, Icon , int) Texte + image et alignement horizontal

o setHorizontalAlignement(int alignement) Définit l’alignement horizontal du contenu

o setVerticalAlignement(int alignement) Définit l’alignement horizontal du contenu

o setHorizontalTextPosition(int) Définit la position du texte relativement à l’image

o setVerticalTextPosition(int textPosition) Idem mais sur l’axe des y

o setIcon(Icon) Permet de spécifier ou de remplacer à tout moment l’image du libellé

o setText(String) Permet de spécifier le texte pour le label (supporte certaines balises html)

… jLabel = new JLabel();


34 / 61


jLabel .setText( "JLabel" ); …

L’application suivante utilise des JLabel afin d’afficher un message :

Si vous souhaitez ajouter une image dans votre JLabel, vous devrez utiliser la classe ImageIcon en spécifiant dans le constructeur le chemin vers l’image gif : ImageIcon(String filename)

… pictureLabel = new JLabel(); pictureLabel .setText( "" ); // load the picture thanks to the ClassLoader, // this is required in order to load a picture from a jar URL iconURL = getClass().getResource( "/age/0.jpg" ) ; pictureLabel .setIcon(imageIcon); …

Nous reparlerons du ClassLoader à la fin de cet essentiel.

Dans l’application suivante, nous avons utilisé un JLabel afin d’afficher une image :

Par défaut, l’alignement horizontal est à gauche pour un libellé de texte seulement. Pour un libellé contenant une image, l’alignement est au centre.


35 / 61


Pour spécifier l’alignement, on peut utiliser l’interface SwingConstants de la manière suivante :

• SwingConstants.LEFT

• SwingConstants.CENTER

• SwingConstants.RIGHT

• SwingConstants.TOP

• SwingConstants.BOTTOM

Voici un diagramme des différents positionnements possibles :


36 / 61


5.3.2. La classe JTextComponent

Il s’agit de la classe de base pour les composants Swing utilisant du texte. Il fournit de nombreuses fonctionnalités concernant la manipulation du texte, concernant des composants que nous allons voir : JTextField, JTextArea, JEditorPane.

5.3.3. JTextField

Ce composant est l’un des plus simples à utiliser pour la saisie de données. Il ne permet de saisir qu’une seule ligne de texte et ne prend pas en compte les styles (gras, italique …).

On peut utiliser l’un des deux constructeurs suivants :

o JTextField() : Crée un champ de saisie vide o JTextField(String text) : Crée un champ de saisie avec un texte par défaut

Si vous souhaitez récupérer le contenu du champ de saisie, il vous faudra utiliser la méthode getText() qui vous retournera un objet de type String.

5.3.4. JFormattedTextField Cette classe hérite de JTextField en ajoutant le support du formattage de valeurs.

5.3.5. JPasswordField Ce composant permet de créer un champ pour la saisie des mots de passe. Il s’utilise de la même manière que le composant précédent, mais, lorsque vous saisissez un caractère, celui-ci est remplacé par le caractère par défaut ‘*’. Ce dernier peut être remplacé à l’aide de la méthode setEchoChar(char). Remarque : Pour des raisons de sécurité, la méthode getText() de ce composant est à éviter. Il faut utiliser la méthode getPassword() qui retourne un tableau de caractères (char[] ). En effet, il est beaucoup plus difficile de retrouver dans la mémoire d’un programme la valeur d’un tableau de caractère que d’une instance de type String. Voici un exemple d’utilisation : … JPasswordField myPassField = new JPasswordField(); myPassField.setEchoChar( '-' ); // change * by - char[] result = myPassField.getPassword(); String result = new String(result); …

Voici le résultat, au niveau graphique :


37 / 61


La valeur du champ de caractère est masquée

5.3.6. JTextArea

JTextArea est un composant semblable au JTextField, car il permet à l’utilisateur de saisir du texte. Mais ce composant permet d’afficher plusieurs lignes de texte, alors que le JTextField ne permettait d’en saisir qu’une seule. A l’instar de JTextField, il ne permet pas d’afficher des polices et des couleurs de différents types. Il peut gérer le passage à la ligne et permettre de spécifier si on peut couper un mot ou non.

L’ajout de texte dans un JTextArea peut se faire par le biais de l’utilisation de l’un des deux constructeurs suivants :

o JTextArea (String text) o JTextArea (String text, int rows, int columns)

Il est aussi possible d’ajouter du texte grâce aux méthodes suivantes :

o append(String text) : Ajout d’une chaîne à la fin du document o insert(String text, int position) : Ajout d’une chaîne à une position donnée o replaceRange(String text, int start, int end) : Remplace la chaîne contenue entre start et

end o setText(String text) : Remplace tout le texte par la chaîne

Voici un exemple d’utilisation :

JTextArea myField = new JTextArea(); // initialize myField.setLineWrap( true); // start new lines automaticaly myField.setWrapStyleWord( true); // do not cut words


38 / 61


Nous avons ajouté un champ texte afin de récupérer les commentaires

Le composant JTextArea est souvent utilisé avec un JScrollPane afin d’ajouter des barres de défilement. JTextArea myField = new JTextArea(); // initialize jScrollPaneComment = new JScrollPane(); // initialize the scrollpane container jScrollPaneComment.setViewportView( getJTextArea()); // add the component to its container

Grâce au JScrollPane, notre champ texte est plus simple à utiliser


39 / 61


5.3.7. JEditorPane La classe JEditorPane permet d’avoir un composant graphique afin d’éditer facilement du texte à diférents formats. Des moteurs de rendu, implémentant l’interface EditorKit, sont proposés pour les formats :

• text/plain : affiche du texte au format texte brut • text/html : permet d’afficher du HTML 3.2, via la classe

javax.swing.text.html.HTMLEditorKit • text/rtf : support du format Rich Text Format.

Dans les lignes suivantes nous affichons la page principale de la documentation de java : // … URL url = null; try { url = new URL( "http://java.sun.com/j2se/1.5.0/docs/index.html" ); jEditorPane = new JEditorPane(url); } catch (MalformedURLException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } // activation html renderer jEditorPane .setContentType( "text/html" ); // display the component with a horizontal and a ve rtical scrolling bar JScrollPane jScrollPane = new JScrollPane(); jScrollPane .setViewportView(jEditorPane); // …


40 / 61


Affichage d’une page html dans Java

5.3.8. JTextPane

Le JTextPane accepte différentes mises en forme ainsi que l’ajout d’autres composants graphiques ou d’images, dans ce sens il s’agit d’une amélioration de composant JTextArea. JTextPane repose sur le concept de styles définis en Java, qu’il est possible de personnaliser.

On utilise l’objet StyledDocument, qui est le modèle de ce composant, afin de définir le contenu et les propriétés de champs style.

Voici les méthodes à employer pour ajouter d’autres composants ou des images dans votre JTextPane :

o insertComponent(Component c) ajout d’un composant o insertIcon(Icon i) ajout d’une image

L’intérêt de ces méthodes est donc de placer des composants comme des boutons, des labels, etc. au sein même du champ texte. Son utilisation étant particulièrement difficile, nous ne l’étudierons pas ici. Nous pouvons cependant vous rediriger vers l’adresse suivante ou davantage d’exemple et d’explications sont disponibles : http://java.sun.com/docs/books/tutorial/uiswing/com ponents/text.html


41 / 61


Le champ éditable JTextPane affiche de nombreux composants

5.4. Composants proposant une liste de valeurs

5.4.1. JCheckBox

Une JCheckBox est une case à cocher, on peut ajouter un libellé à ce composant directement lors de sa création afin de rendre plus explicite son utilisation. Il faut pour cela utiliser le constructeur suivant : JCheckBox("Ma case a cocher").

Les JCheckBox sont utilisés lors de choix multiples que l’utilisateur doit réaliser par le biais de l’interface.

//In initialization code: chinButton = new JCheckBox( "Chin" ); chinButton.setMnemonic(KeyEvent.VK_C); chinButton.setSelected(true); glassesButton = new JCheckBox( "Glasses" ); glassesButton.setMnemonic(KeyEvent.VK_G); glassesButton.setSelected(true); hairButton = new JCheckBox( "Hair" ); hairButton.setMnemonic(KeyEvent.VK_H); hairButton.setSelected(true); teethButton = new JCheckBox( "Teeth" ); teethButton.setMnemonic(KeyEvent.VK_T); teethButton.setSelected(true);


42 / 61


5.4.2. JComboBox

Ce composant représente une liste déroulante, dans laquelle l’utilisateur peut choisir un seul élément à la fois. Il est utilisé pour présenter une liste de valeurs possibles, au sein desquelles l’utilisateur effectue son choix. La classe JComboBox est en fait constituée d’un composant JList (étudié dans le point suivant) et d’un JButton.

Voici la liste des différents constructeurs de cette classe :

o JComboBox() : Crée une ComboBox avec un modèle par défaut

o JComboBox(Vector) : Crée une ComboBox qui contient les éléments d’un vecteur

o JComboBox(Object[ ]) : Crée une ComboBox qui contient les éléments d’un tableau

o JComboBox(ComboBoxModel) : Crée une ComboBox qui contient les éléments d’un modèle

Voici la liste des méthodes les plus utilisées pour ce composant :

o addActionListener(ActionListener) : Ajoute un ActionListener à la ComboBox

o addItem(Object) : Ajoute un objet à la liste

o getSelectedIndex() : Retourne l’index (int) correspondant à la sélection

o getSelectedItem() : Retourne l’objet correspondant à la sélection

o insertItemAt(Object, int) : Insère un objet à l’emplacement spécifié (index)

o paramString() : Retourne la chaîne correspondant à la sélection

o removeAllItems() : Supprime tous les objets de la ComboBox

o removeItem(Object) : Supprime un objet de la liste

o removeItemAt(int) : Supprime un objet de la liste à partir de son index

o setEditable(boolean) : Rendre éditable ou non la ComboBox

o setEnabled(boolean) : Activer / désactiver le composant

o setMaximumRowCount(int) : Définit le nombre de lignes affichables sans ascenseur

o setModel(ComboBoxModel) : Définit le modèle de données que doit utiliser la ComboBox

o setSelectedIndex(int) : Définit l’objet à sélectionner par son index (0 � 1er objet)

o setSelectedItem(Object) : Définit l’objet existant à sélectionner dans la ComboBox


43 / 61


5.4.3. JList

Le composant JList est assez similaire à JComboBox. Le composant JComboBox est en effet basé sur un composant JList , mais il utilise un modèle de sélection (ListSelectionModel) qui permet uniquement la sélection unique (SINGLE_SELECTION_ONLY ). Le modèle de sélection de JList supporte quant à lui trois types de sélections dont nous parlerons dans ce chapitre.

La JList tout comme le JTree et la JTable (chapitres suivants) a la propriété d’afficher une liste de valeurs construite à partir d’un vecteur d’objets. Les objets construits ne doivent respecter qu’une seule contrainte, qui est d’implémenter une fonction toString(), qui retourne ce qui doit être affiché.

Voici la liste des différents constructeurs de cette classe :

o JList() Crée une JList avec un modèle par défaut

o JList(Vector) Crée une JList qui contient les éléments d’un vecteur

o JList(Object[]) Crée une JList qui contient les éléments d’un tableau

o JList(ListModel) Crée une JList qui contient les éléments d’un modèle existant

Voici la liste des méthodes les plus utilisées pour ce composant :

o getModel() Retourne le modèle associé à la liste

o setModel(ListModel) Définit le modèle associé à la liste

o setListData(Object[]) Définit les élements de la liste.

o setListData(Vector) Définit les élements de la liste.

o addListSelectionListener(ListSelectionListener) Ajoute un Listener à la liste

o setSelectedIndex(int) Définit la sélection courante par son index

o setSelectedValue(Object, boolean) Définit la sélection courante, le booléen indique s’il faut faire défiler la liste pour afficher l’élément

o setSelectedInterval(int, int) Définit un intervalle de sélection

o getSelectedIndex() Retourne l’index de la sélection courante

o getMinSelectionIndex() Retourne l’index du 1er élément de l’intervalle

o getMaxSelectionIndex() Retourne l’index du dernier élément de l’intervalle

o getSelectedIndices() Retourne une liste d’index d’éléments sélectionnés

o getSelectedValue() Retourne l’objet correspondant à la sélection courante

o getSelectedValues() Retourne une liste d’objets correspondant aux éléments sélectionnés

o setSelectionMode(int) Définit le mode de sélection de la liste

o getSelectionMode() Retourne le mode de sélection de la liste


44 / 61


o clearSelection() Désélectionne tous les éléments

o isSelectionEmpty() Retourne un booléen vérifiant : aucun élément sélectionné

o isSelectedIndex(int) Retourne un booléen vérifiant : index i sélectionné

o ensureIndexIsVisible(int) Génère un défilement afin que l’index soit visible

o getFirstVisibleIndex() Retourne l’index du 1er élement visible

o getLastVisibleIndex() Retourne l’index du dernier élement visible

o setVisibleRowCount(int) Définit le nombre de lignes visibles

o getVisibleRowCount() Retourne le nombre de lignes visibles

Vous pouvez également personnaliser le mode de sélection. Voici les trois modes de sélection que vous pouvez utiliser avec le composant JList :

SINGLE_SELECTION :

Un seul élément peut être sélectionné à la fois

SINGLE_INTERVAL_SELECTION : Plusieurs éléments contigus peuvent être sélectionnés.

MULTIPLE_INTERVAL_SELECTION (par défaut) :

Toute combinaison est possible.

Voici les deux possibilités que vous avez pour modifier le mode de sélection :

JList maListe = new Jlist(); maListe.setSelectionMode(ListSelectionModel.SINGLE_ SELECTION); maListe.getSelectionModel().setSelectionMode(ListSe lectionModel.SINGLE_SELECTION);

Détecter les changements de sélection

Parfois, il est nécessaire de détecter un changement de sélection. Lorsque l’on veut, par exemple, modifier une partie de notre interface graphique, lorsqu’une ligne est sélectionnée.

Il faut, pour cela, abonner le composant JList à l’aide de la méthode :

o addListSelectionListener(ListSelectionListener)


45 / 61


L’interface à implémenter est donc ListSelectionListener. Cette interface ne spécifie qu’une seule méthode à redéfinir, qui est :

o valueChanged(ListSelectionEvent e)

C’est dans cette méthode que vous pourrez spécifier l’action à effectuer lors du changement de sélection dans votre JList .

5.4.4. JSpinner JSpinner est un composant composé de trois sous-composants : deux petits boutons et un éditeur. L’éditeur est par défaut un panel qui contient un champ de texte formaté (formatted text field). Les valeurs possibles et courantes du spinner sont gérées par son modèle.

Une zone de texte, deux boutons … le JSpinner est né !

L’API Swing fournit trois modèles de spinner :

• SpinnerListModel : Les valeurs sont définies par un tableau d’objets ou une liste. • SpinnerNumberModel : Supporte des séquences de nombres (de type double, int ou Number).

Vous pouvez spécifier les valeurs minimum et maximum, ainsi que la valeur du pas. • SpinnerDateModel : Supporte des séquences d’objets Date. Vous pouvez spécifier les dates

minimum et maximum, ainsi que le champ (par exemple l’année) à incrémenter ou décrémenter.

Les spinners sont similaires aux combo-boxes et aux listes dans le sens qu’ils laissent l’utilisateur choisir une valeur dans parmi un ensemble important. Comme les combo-boxes éditables, ils permettent généralement à l’utilisateur d’entrer une valeur. Contrairement aux combo-boxes classiques, ils n’ont pas de liste déroulante qui peut recouvrir les autres composants. Ils sont souvent utilisés au lieu des combo-boxes ou des listes lorsque l’ensemble des valeurs possibles est extrêmement grand. Cependant, les spinners doivent seulement être utilisés quand les valeurs possibles et leur séquence sont évidentes.

5.4.5. JSlider La classe JSlider permet d’avoir une barre de sélection (utilisée pour choisir des valeurs entières par exemple). Voici un exemple d’initialisation de ce composant : static final int FPS_MIN = 0; // min value static final int FPS_MAX = 30; // max value static final int FPS_INIT = 15; //initial frames per second ... JSlider framesPerSecond = new JSlider(JSlider.HORIZONTAL, FPS_MIN, FPS_MAX, FPS_INIT); framesPerSecond.addChangeListener( this); //Turn on labels at major tick marks.


46 / 61


framesPerSecond.setMajorTickSpacing(10); framesPerSecond.setMinorTickSpacing(1); framesPerSecond.setPaintTicks(true); framesPerSecond.setPaintLabels( true);

JSlider nous permet ici de définir la vitesse d’une animation graphique

5.5. Les composants de menu

5.5.1. JMenuBar

5.5.2. JPopupMenu La classe JPopupMenu permet d’avoir un menu lors l’on réalise un clique droit dans l’application. // À rédiger

5.5.3. JMenu // À rédiger (voir ancien cours)

5.5.4. JMenuItem // À rédiger (voir ancien cours)

5.5.5. JCheckBoxMenuItem Les classes JCheckBoxMenuItem & JRadioButtonMenuItem permettent d’obtenir des menus plus attrayants. // À rédiger


47 / 61


5.5.6. JRadioButtonMenuItem Les classes JCheckBoxMenuItem & JRadioButtonMenuItem permettent d’obtenir des menus plus attrayants. // À rédiger


48 / 61


5.6. Les composants informatifs non éditables

5.6.1. JProgressBar La classe JProgressBar permet d’avoir une barre de progression (très utilisée pour symboliser les temps de copie de fichiers ou de connexion). // À rédiger

5.6.2. JToolTip // À rédiger


49 / 61


5.7. Les contrôles de haut-niveau

5.7.1. JColorChooser // À rédiger (voir ancien cours) : juste une présentation

5.7.2. JFileChooser // À rédiger (voir ancien cours) : juste une présentation

5.7.3. JTable // À rédiger (voir ancien cours) : juste une présentation

5.7.4. JTree // À rédiger (voir ancien cours) : juste une présentation


50 / 61


6. La gestion des événements 6.1. Principe

En Java, toutes les interactions de l’utilisateur se traduisent par des événements, que ce soit un clic sur un bouton, une sélection dans un menu ou encore un simple déplacement de la souris.

Les événements en Java sont représentés par des objets qui fournissent des informations sur l’événement lui-même et sur l’objet à l’origine de cet événement (source).

Le terme employé lorsque l’on parle de gestion des événements en Java est « Listener ».

6.2. Les classes d’événements

6.2.1. Principe

On trouve la classe java.util.EventObject à la base des classes gérant les évènements. Elle représente la superclasse pour tous les événements.

Celle-ci fournit d’ailleurs une méthode intéressantes : getSource(). En effet, elle permet de retourner la source de l’événement. Cet objet source pourra être alors casté dans son type d’origine.

Un événement est capable d’encapsuler des informations concernant son contexte d’apparition :

o Le composant source de l’événement.

o Les coordonnées du clic (dans le cas d’un MouseEvent).

o La valeur de la touche tapée pour un KeyEvent.

o …

L’objet qui intercepte l’interaction utilisateur est appelé un Listener. Comme ce nom l’indique, son rôle principal est d’être « à l’écoute » d’un composant (JButton, JPanel…).

Le Listener doit s’abonner à l’événement auprès du composant. Il demande ainsi au composant de l’avertir en cas d’interaction utilisateur sur ce composant.

Bouton

Abonnement

Listener

Notification


51 / 61


Le principe de la gestion des événements

C’est au niveau du composant que l’on trouve les méthodes d’abonnement aux différents Listeners. Ces méthodes s’expriment sous la forme addXxxListener(XxxListener l) où Xxx représente le type d’événement écouté.

Exemples de méthodes d’abonnement :

o addActionListener()

o addKeyListener()

o addFocusListener()

o …

Par ailleurs, ces méthodes sont héritées de la classe Container et sont donc communes à un grand nombre de composants et conteneurs.

On utilise la plupart du temps l’interface ActionListener, qui l’on implémente à sa guise, pour gérer les évènements.

Il est aussi possible de désabonner un Listener du composant auquel il a été abonné, à l’aide de la méthode removeXxxListener() ou Xxx doit être remplacé par le nom de l’événement.

6.3. Utilisation

6.4. Évènements spécifiques

6.4.1. Evénements de java.awt.event ActionEvent : Evénement généré si on active un bouton (via le clavier ou la souris), si on double

clique sur un élément de liste ou si on sélectionne un élément de menu. String getActionCommand() retourne le nom de la commande associée à un événe ment. (dans le cas d’un bouton sans action command, reto urne son libellé)

ComponentEvent : Evènement généré lorsqu’un élément est caché, déplacé, redimensionné, ou

lorsqu’il apparaît.

Component getComponent() renvoie l’objet à l’origine de l’événement (le cas t peut être necessaire)


52 / 61


ContainerEvent : Evènement généré lorsqu’un élément est ajouté ou supprimé d’un container. Container getContainer() renvoie une référence au container à l’origine de l’événement Component getChild() renvoie une référence à l’élément ajouté au contai ner ou supprimé

FocusEvent : Evènement généré lorsqu’un élément gagne ou perd le focus.

boolean isTemporary() true si l’événement est temporaire et false dans le cas

contraire Une zone de texte perd temporairement le focus si l’utilisateur manipule l’ascenceur pendant la saisi e

KeyEvent : Evènement généré lorsqu’une touche du clavier est pressée.

char getKeyChar() retourne le caractère saisi int getKeyCode() retourne le code de la touche pressée … + nombreuses autres méthodes

MouseEvent : Evènement généré lorsque l’on déplace la souris, lorsqu’on la fait glisser (drag), lors du

clic ou du relâchement d’un bouton.

int getX() retourne la position horizontale du pointeur int getY() retourne la position verticale du pointeur Point getPoint() retourne les coordonnées du pointeur de la souris dans un objet java.awt.Point int getClickCount() retourne le nombre de clics effrectués lors de l’é vénement

6.4.2. Evénements de javax.swing.event

o TreeSelectionEvent – Changement de la position courante dans un JTree

o HyperlinkEvent – Clic sur un lien hypertexte

o JInternalFrameEvent – Support des évènements ayant pour source une JInternalFrame

o ListSelectionEvent – Changement dans la sélection

o …

6.5. Les listeners d’événements

Les Listeners sont créés par l’implémentation d’une (ou de plusieurs) interface(s) fournie(s) par le package java.awt.event. Lorsque l’événement survient, la source appelle la méthode des Listener qui se sont abonnés à l’évènement.

L’implémentation d’une interface impose donc de redéfinir une (ou plusieurs) méthode(s) obligatoire(s). De plus, des objets, nommés « Adapter », fournissent une implémentation par défaut où toutes les méthodes ont un corps vide. Ces objets là sont en réalité des classes, et non des


53 / 61


interfaces. Le développeur n’a plus à implémenter toutes les méthodes de l’interface, ce qui peut-être fastidieux.

Ils se mettent à l’écoute d’un composant qui s’abonne auprès d’eux et intercepte tous les événements, et selon leur nature va réagir en conséquence en exécutant la méthode cible de l’évènement.

L’abonnement se fait par le biais des méthodes addXxxListener(), où Xxx représentent le type d’événement. Les Listeners les plus communs sont illustrés brièvement ici. Un tableau général fait état de l’ensemble des Listeners avec les méthodes à implémenter :

ActionListener : Définit la méthode pour intercepter les événements d’actions. Il est utilisé le plus souvent lors des cliques sur un bouton par exemple. Le fait d’implémenter ce Listener vous imposera de redéfinir la méthode actionPerformed(ActionEvent).

void actionPerformed(ActionEvent ae)

ComponentListener : Définit le comportement à adopter quand un élément graphique est caché, déplacé, redimensionné ou affiché.

void componentHidden(ComponentEvent ce) void componentMoved(ComponentEvent ce) void componentResized(ComponentEvent ce) void componentShown(ComponentEvent ce)

ContainerListener : Définit le comportement à adopter quand un élément graphique est ajouté ou supprimé d’un container.

void componentAdded(ContainerEvent ce) void componentRemoved(ContainerEvent ce)

FocusListener : Définit le comportement à adopter quand un élément graphique a obtenu ou perdu le focus. Il est utilisé lorsqu’un composant graphique reçoit ou perd le focus. Le fait d’implémenter ce Listener vous imposera de redéfinir les méthodes focusGained(FocusEvent) et focusLost(FocusEvent). Vous pouvez également hériter de la classe FocusAdapter au lieu d’utiliser le principe de l’implémentation. void focusGained(FocusEvent fe) void focusLost(FocusEvent fe)

ItemListener peut être utilisé sur plusieurs composants différents. Le plus souvent il est mis en action lors d’une sélection dans une JComboBox afin de prendre en compte l’élément sélectionné de manière le plus dynamique possible en redéfinissant la méthode itemStateChanged(ItemEvent). ListSelectionListener est utilisé avec le composant JList pour gérer les évènements liés à la sélection de valeur dans ce composant en redéfinissant la méthode valueChanged(ListSelectionEvent).

o Listener relatifs à la sourie et au clavier KeyListener : Définit le comportement à adopter quand une touche est appuyée, relâchée ou si une lettre a été tapée.


54 / 61


Ex : Touche c appuyée → appel successif des 3 méthodes. Ex : Touche Shift appuyée → appel successif des 2 premières méthodes uniquement

void keyPressed(KeyEvent ke) void keyReleased(KeyEvent ke) void keyTyped(KeyEvent ke)

KeyListener est utilisé sur les composants qui permettent à l’utilisateur de saisir du texte, JTextField, JPasswordField, … MouseListener : Définit le comportement à adopter quand on clique avec la souris, appuie sur un bouton, relâche un bouton, si le pointeur de la souris entre ou sort de la zone d’un élément graphique. void mouseClicked(MouseEvent me) void mouseEntered(MouseEvent me)

MouseListener est un Listener, comme le suivant qui peut être employé sur beaucoup de composants différents. Vous pouvez par exemple prendre en compte le clic sur un JLabel contenant une image. Le fait d’implémenter ce Listener vous imposera de redéfinir les méthodes : mouseClicked(MouseEvent), mouseEntered(MouseEvent), mouseExited(MouseEvent), mousePressed(MouseEvent), mouseReleased(MouseEvent) ou vous pouvez hériter de la classe MouseAdapter au lieu d’utiliser le principe de l’implémentation. MouseMotionListener est un Listener très semblable au précédent, cependant celui-ci vous permettra de gérer l’action de drag & drop. Le fait d’implémenter ce Listener vous imposera de redéfinir les méthodes : mouseDragged(MouseEvent), mouseMoved(MouseEvent). Si vous ne souhaitez pas redéfinir les deux méthodes mais uniquement une seule d’entre elles, vous pouvez hériter de la classe MouseMotionAdapter au lieu d’utiliser le principe de l’implémentation.


55 / 61


7. Utilisation des “modèles”


56 / 61


8. Autres fonctionnalités

8.1. Le look-and-feel

On dit que Swing propose une architecture « pluggable look-and-feel ». Ce terme signifie que l’application peut contrôler l’apparence (look) et le comportement (feel) de son interface graphique. Ainsi, une application Swing peut émuler l’apparence et le comportement de la plateforme, ou s’en affranchir et proposer une apparence et un comportement propre et identique d’une plateforme d’exécution à une autre. De plus, le développeur peut implémenter du code permettant de modifier le look-and-feel de l’application dynamiquement. Voici un exemple des différents « look & feel » disponibles avec Java 5:

Sous MacOs X

Sous Windows


57 / 61


Sous Linux (GTK) Si vous portez une attention particulière à cette fonctionnalitée, qui est hautement personnalisable, vous trouverez des compléments d’information à ces adresses : http://java.sun.com/docs/books/tutorial/uiswing/mis c/plaf.html http://www.jgoodies.com/index.html http://java.developpez.com/faq/java/?page=generalit esAWTSwing - lf (français)

8.2. Le mode de distribution d’applications Java

Afin d’assurer la portabilité des applications Java, il n’y a pas de possibilité (en standard) de créer des fichiers exécutables (.exe). Cependant, il est posssible de créer des fichiers JAR, qui sont des fichiers archives (Java ARchive). C’est une manière de distribuer les applications Java. Ce type de fichier se comporte comme un fichier exécutable, il est donc aussi simple d’utilisation.

Il est possible de créer un fichier JAR en ligne de commande :

jar cfm jarfile inputfiles

Quelques options pour la commande jar :

o L’option ‘c’ indique que vous souhaitez créer un fichier JAR

o L’option ‘f’ permet de spécifier le nom du fichier d’archive (c’est dans ce fichier que l’on va diriger l’archive plutôt que dans la sortie standard).

o L’option ‘m’ permet de spécifier le fichier manifest qui va contenir différentes informations pour la création de l’archive (notamment l’indication de la classe contenant la méthode main)

o jarfile est le nom du fichier JAR que vous voulez créer, par convention le fichier a une extension .jar.

o inputfiles regroupe l’ensemble des fichiers contenus dans le fichier JAR que vous voulez créer. Les noms de fichiers à inclure sont séparés par un espace. Si le nom de fichier est un répertoire, son contenu est ajouté de manière récursive.


58 / 61


Exemple :

jar cfm NomDuJar.jar monManifest.mf MaClass1.class MaClass2.class

L’ordre des options n’a pas d’importance, mais il ne doit pas y avoir d’espace entre chacune des options. Par ailleurs, si l’option ‘f’ est située avant l’option ‘m’, alors le nom du fichier JAR devra être placé avant le nom du manifest, et inversement.

Cette commande génèrera un fichier JAR compressé dans le répertoire courant. Cette commande génèrera aussi le fichier manifest monManifest.mf dans le fichier JAR à partir des informations données.

Ce fichier se situe dans le répertoire /META-INF du fichier JAR et se nomme MANIFEST.MF. C’est un descripteur du contenu de votre fichier JAR, et c’est grâce à ce fichier que votre JAR sera auto-exécutable.

Voici un exemple de contenu d’un fichier manifest :

Manifest-Version: 1.0 Main-Class: monpackage.MaClasse

Vous pouvez aussi utiliser un IDE (Integrated Development Environment) pour automatiser toute la génération de votre fichier JAR. Avec Eclipse, un assistant est disponible.

8.3. Chargements des ressources situées dans un Jar

Comme nous venons de le voir, lorsque l’on déploie une application on utilise le format jar pour y stocker le bytecode mais également les ressources (images, fichiers textes, …). Ainsi, afin de pouvoir être sûr d’accéder à celles-ci, que l’application soit sous forme de jar ou pas, il est nécessaire d’utiliser le ClassLoader. En effet, il se base sur le « classpath 1» et non au système de fichier. Il existe deux façon de l’appeler : URL myResourceURL = this.getClass().getResource( "/myPic.jpg "));

ClassLoader loader = Thread. currentThread().getContextClassLoader(); URL url = loader.getResource( "myPic.jpg ");

La deuxième est utilisée dans des méthodes statique, car il n’est pas possible d’avoir accès au pointeur this dans ce cas précis. Remarque : lorsque l’on utilise le second exemple, il ne faut pas faire précéder le chemin vers la ressource d’un « / ».

1 Le classpath est un zone mémoire dans la machine virtuel qui, au lancement d’une application, liste toutes les classes et les ressources à disposition. Pas défaut, il s’agit du répertoire courant ainsi que les librairies installées avec la JRE. On peut le configurer avec la variable d’environnement CLASSPATH.

59 / 61


8.4. Java Web Start

Il s’agit d’un outil permettant de mettre à disposition une application à partir d’internet. Il faut au préalable que l’application soit disponible sous forme de jar (sujet traité dans les pages précédentes). Ensuite nous allons écrire, et surtout commenter, un fichier de déploiement avec l’extension « .jnlp ». Voici par exemple celui d’une application servant de démonstration :     <jnlp spec="1.5+" codebase="http://10.1.77.3/tetris" href="demo_tetris.jnlp"> <information>  <title>Sun laboratory - Demo Tetris</title>  <vendor>Supinfo</vendor>  <homepage href="."/>   <icon href="demo_tetris.gif"/>    <icon kind="splash" href="demo_tetris.gif"/>    <offline-allowed/>   <shortcut online="false"> <desktop/> <menu submenu="Sun Laboratory Applications"/> </shortcut> </information>  <security>  <all-permissions/>

60 / 61


</security>    <resources> <j2se version="1.5.0+" java-vm-args="-esa -Xnoc lassgc"/> <jar href="tetris.jar"/> <jar href="lib/derby.jar"/> <jar href="lib/derbyclient.jar"/> <jar href="lib/derbynet.jar"/> <jar href="lib/derbytools.jar"/> </resources>    <application-desc /> </jnlp>

Pour plus d’information, notamment pour signer une application : http://java.sun.com/j2se/1.5.0/docs/guide/javaws/index.html

8.5. Internationalisation (I18N)

Java fournit des classes permettant de pouvoir changer la langue de l’application. Nous utilisons tout dabord des fichiers de propriété pour chacune d’entre elles : lang_fr.properties : fichier pour la langue française lang_zh.properties : fichier pour la langue chinoise lang.properties : fichier pour la langue par défaut (généralement réservée à l’anglais) Dans notre application, nous devrons appeler la méthode statique suivante : buttonEnglish.setText(

java.util.ResourceBundle.getBundle("lang").getStrin g("English"));

La langue par défaut est celle utilisée par le système d’exploitation. Cependant, si l’on souhaite la modifier dans notre application nous pouvons utiliser : Locale.setDefault(Locale.FRENCH);


61 / 61


9. Conclusion Dans ce cours nous avons parcouru les éléments essentiels de Swing, afin de pouvoir concevoir une interface graphique fonctionnelle et ayant le minimum de composant. Nous approfondirons nos connaissances dans le cours « Swing Avancé » en abordant des composants de haut-niveau, aussi que certains éléments d’architecture. Pour plus d’informations sur certains composants, n’hésitez pas à consulter également le site http://java.sun.com/docs/books/tutorial/uiswing/index.html qui fournit de nombreuses explications sur la plupart des composants. Un livre, ayant déjà quelques années mais toujours d’actualité, est disponible à l’adresse suivante : http://java.sun.com/products/jlf/ed2/book/ .

05 - Labo Sun - Cours - Swing Base - 4.0

Documents

Transcript of 05 - Labo Sun - Cours - Swing Base - 4.0