Développement d’interfaces graphiques en Java à l’aide de SWING …entrepotforall.free.fr/Cours 2003-2004/Java/Labo Sun... · 2003-12-13 · [email protected] Développement

http://www.labo-java.com

[email protected]

Développement d’interfaces graphiques en Java à l’aide de

SWING

Auteur : Medaghri-Alaoui Youssef Version 1.3 – 26 novembre 2003

Ecole Supérieure d’Informatique de Paris 23. rue Château Landon 75010 – PARIS www.supinfo.com [email protected]

Essentiel Java : Les Swing 2 / 62

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

Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs.

Table des matières 1. INTRODUCTION ................................................................................................................................................ 3 1.1. RAPPEL SUR LES JFC........................................................................................................................................ 3 1.2. AWT ................................................................................................................................................................ 3 1.3. SWING ............................................................................................................................................................ 3

2. PREMIERE APPLICATION SWING............................................................................................................... 3 2.1. TD1 : PREMIERE APPLICATION ........................................................................................................................ 3

2.1.1. Code Source : PremiereApp.java ............................................................................................................ 3 2.1.2. Compilation en exécutable JAR ............................................................................................................... 3

3. FENÊTRES,PANNEAUX ET BORDURES...................................................................................................... 3 3.1. FENETRES ......................................................................................................................................................... 3

3.1.1. JFrame...................................................................................................................................................... 3 3.1.2. JDialog ..................................................................................................................................................... 3 3.1.3. JWindow ................................................................................................................................................... 3

3.2. PANNEAUX ....................................................................................................................................................... 3 3.2.1. JRootPane................................................................................................................................................. 3 3.2.2. JPanel ....................................................................................................................................................... 3 3.2.3. JMenuBar ................................................................................................................................................. 3 3.2.4. JLayeredPanel.......................................................................................................................................... 3 3.2.5. La gestion des événements ....................................................................................................................... 3

3.3. BORDURES........................................................................................................................................................ 3 3.3.1. TD3 PremiereBordure ............................................................................................................................. 3 3.3.2. TD4 BordurePersonalisée........................................................................................................................ 3

4. LIBELLES ET BOUTONS.................................................................................................................................. 3 4.1. JLABEL (LIBELLE) ............................................................................................................................................ 3 4.2. BOUTONS.......................................................................................................................................................... 3

4.2.1. JButton...................................................................................................................................................... 3 4.2.2. JToggleButton .......................................................................................................................................... 3

4.3. TD5 BOUTONS BASCULES ET ACTIONLISTENERS ........................................................................................... 3 5. LAYOUTS ............................................................................................................................................................. 3 5.1. LAYOUTS LES PLUS COURANTS ........................................................................................................................ 3

5.1.1. FlowLayout............................................................................................................................................... 3 5.1.2. GridLayout ............................................................................................................................................... 3 5.1.3. BoxLayout................................................................................................................................................. 3 5.1.4. BorderLayout............................................................................................................................................ 3

5.2. TD6 LAYOUTS LES PLUS COURANTS ................................................................................................................ 3 5.2.1. La maquette du formulaire....................................................................................................................... 3 5.2.2. Definition des layouts et architecture de la fenêtre................................................................................. 3 5.2.3. Passage au code ....................................................................................................................................... 3

6. COMBO BOX ....................................................................................................................................................... 3 6.1. JCOMBOBOX .................................................................................................................................................... 3

6.1.1. TD7 ComboBox pour choix de films........................................................................................................ 3 6.1.2. TD8 ComboBox personnalisée ................................................................................................................ 3

7. LIST BOX (JLIST)............................................................................................................................................... 3 7.1. PERSONNALISER LA SELECTION ....................................................................................................................... 3

7.1.1. Le mode de sélection ................................................................................................................................ 3 7.1.2. Le contenu de le sélection ........................................................................................................................ 3 7.1.3. Détecter les changements de sélection .................................................................................................... 3




7.2. TD9 LISTE DE CHOIX MULTIPLES ..................................................................................................................... 3 7.3. TD10 PERSONNALISATION DE LA JLIST........................................................................................................... 3

8. JTREE.................................................................................................................................................................... 3 8.1.1. Personnalisation d’un arbre .................................................................................................................... 3 8.1.2. Sélection dans un arbre............................................................................................................................ 3 8.1.3. TD11 Un Premier JTree........................................................................................................................... 3

9. JTABLE ................................................................................................................................................................. 3 9.1. UTILISATION SIMPLE D’UNE JTABLE................................................................................................................ 3

9.1.1. TD12 JTable Simple ................................................................................................................................. 3 9.1.2. TD13 Un Renderer Personnalisé............................................................................................................. 3 9.1.3. Renderers par défaut................................................................................................................................ 3 9.1.4. TD14 L’utilisation d’un TableModel....................................................................................................... 3 9.1.5. Les Editors................................................................................................................................................ 3 9.1.6. Fonctionnement des Editors..................................................................................................................... 3 9.1.7. Créer notre Editor.................................................................................................................................... 3 9.1.8. TD15 Les Editors ..................................................................................................................................... 3

10. LES CONTAINERS .................................................................................................................................. 3 10.1. JFRAME (CONTAINER RACINE) ........................................................................................................................ 3 10.2. JPANEL ............................................................................................................................................................. 3 10.3. JSCROLLPANE (CONTAINER AVEC DEFILEMENT)............................................................................................. 3 10.4. JTABBEDPANE (PANNEAU A ONGLETS)........................................................................................................... 3 10.5. JSPLITPANE (BARRE DE SEPARATION) ............................................................................................................. 3 10.6. TD 16 : TOUT CE QUE L’ON VIENT DE VOIR ..................................................................................................... 3

11. LES COMPOSANTS TEXTE.................................................................................................................. 3 11.1. JTEXTFIELD...................................................................................................................................................... 3 11.2. JPASSWORDFIELD ............................................................................................................................................ 3 11.3. JTEXTAREA...................................................................................................................................................... 3 11.4. JTEXTPANE ...................................................................................................................................................... 3

11.4.1. Definir des styles ...................................................................................................................................... 3 11.4.2. Formater un contenu................................................................................................................................ 3

11.5. TD 17 : LES COMPOSANTS TEXTE ................................................................................................................... 3 12. LES BOITES DE DIALOGUES .............................................................................................................. 3 12.1. JDIALOG ........................................................................................................................................................... 3

12.1.1. TD 18 : Les Boîtes de dialogue personnalisées....................................................................................... 3 12.2. JOPTIONPANE................................................................................................................................................... 3

12.2.1. Fonctions showXxxDialog ....................................................................................................................... 3 12.3. JFILECHOOSER ................................................................................................................................................. 3

13. LES APPLICATIONS MDI ..................................................................................................................... 3 13.1. JLAYEREDPANE................................................................................................................................................ 3

13.1.1. Positions dans un layer ............................................................................................................................ 3 13.1.2. Profondeur (Depth) .................................................................................................................................. 3 13.1.3. Ajout dans un Layer ................................................................................................................................. 3 13.1.4. TD18 Afficher un fond.............................................................................................................................. 3

13.2. CREATIONS D’INTERFACES MDI ...................................................................................................................... 3 13.2.1. JDesktopPane........................................................................................................................................... 3 13.2.2. JInternalFrame......................................................................................................................................... 3 13.2.3. TD19 Première Application Mdi ............................................................................................................. 3 13.2.4. TD20 Application TP Mdi........................................................................................................................ 3




1. INTRODUCTION Swing est une librairie Java fournie avec le JDK (Java Developpement Kit) standard. Historiquement elle n’est pas la première librairie fournie par Sun pour construire des interfaces graphiques, la librairie AWT est arrivée la première. Elle est toujours utilisée car swing elle même utilise des éléments d’AWT. On peut considérer que Swing est une évolution d’AWT.

1.1. Rappel sur les JFC Les JFC (Java Foundation Classes) sont un ensemble de librairies Java permettant la construction d’applications graphiques pouvant fonctionner à la fois sous Windows, mais aussi sur d’autres systèmes d’ exploitations de plus en plus populaires tels que Linux ou Mac OSX. Les JFC sont constitués de cinq parties majeures :

AWT : Bibliothèque permettant de créer des programmes exécutables dans un

environnement graphique (GUI) tel que Windows, Linux ou Mac OS

SWING : Extension de AWT pour la conception d’applications graphiques ( Sujet de l’étude )

Accessibility : Support pour les personnes handicapées

Java 2D : Fonctions graphiques avançées pour la 2D, la gestion des graphismes et

de l’impression.

Internationalization : Support pour le langage et les conventions culturelles

1.2. AWT AWT (Abstract Windowing Toolkit) est une librairie fournie pour construire des interfaces graphiques. Elle encapsule les ressources système qu’elle utilise par des abstractions, de sorte que le développeur ne perçoit pas directement ces ressources propres au système. Ainsi les éléments graphiques ( Champs, boutons …) crées à l’aide d’AWT auront l’apparence que le système d’exploitation leur donne. De plus il n’est pas possible avec une telle architecture d’utiliser des éléments graphiques spécifiques d’un système particulier car ils ne sauraient être dessinés à l’écran par d’autres systèmes.

1.3. SWING La librairie SWING a été développée en partie pour corriger certains inconvénients tels que celui évoqué précédemment, et plus généralement pour assurer une portabilité accrue. Les éléments graphiques développés à l’aide de Swing sont dessinés par la librairie elle même, l’affichage n’est pas délégué au système. Un élément graphique Swing aura toujours la même apparence d’une plate-forme à l’autre. En outre un élément graphique peut être défini par Swing sans même que ce composant ait un équivalent au niveau du système d’exploitation. Il faut toutefois se garder de croire que SWING remplace AWT, elle est une couche située au dessus d’AWT et dont la plupart des composant dérivent.




2. PREMIERE APPLICATION SWING Notre premier programme va consister à écrire une phrase dans une fenêtre, en l’occurrence il va s’agir du traditionnel « Hello World ». Le code ne présente aucune difficulté, toutefois la procédure de compilation en ligne de commande doit respecter des règles précises. Vous pouvez bien évidemment opter pour un Environnement de développement (Forte de Sun par exemple ou Eclipse d’IBM), mais pour l’instant le duo Notepad, Command devrait suffire.

2.1. TD1 : Première Application

2.1.1. Code Source : PremiereApp.java import javax.swing.*; public class PremiereApp { private static String Texte= "Hello World !"; public static void main(String args[]) { // Pourquoi static ? Car elle doit être exécutée

// à un moment où il n’existe aucun objet JFrame fenetre = new JFrame("Première App"); fenetre.setSize(200,100); JLabel Libelle = new JLabel(Texte,0); fenetre.getContentPane().add(Libelle); fenetre.show(); fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }

2.1.2. Compilation en exécutable JAR Pour pouvoir exécuter un fichier JAR, il faut soit avoir au préalable installé un Java Runtime Environment (JRE), soit le lancer depuis la ligne de commande à l’aide de l’instruction java –jar app.jar Compilation : Javac PremiereApp.java (Javac –verbose permet de voir ce que fait le compilateur) Si la compilation s’est bien passé un fichier PremiereApp.class est généré. Reste à créer un fichier Manifest.mf (ou nommez le comme vous voulez ) contenant la ligne suivante : Main-Class : PremiereApp (attention n’oubliez pas un retour à la ligne) Exécutable JAR : Jar –cmf Manifest.mf PremiereApp.jar PremiereApp.class pour obtenir l’archive jar exécutable.




3. FENÊTRES,PANNEAUX ET BORDURES Swing offre la possibilité d’utiliser trois types de fenêtres qui sont les JFrame, JDialog, et JWindow. JFrame correspond aux fenêtres que nous connaissons classiquement, JDialog est utilisé pour les boîtes de dialogue et JWindow pour les Splash-Screens.

3.1. Fenêtres 3.1.1. JFrame

classe javax.swing.Jframe Dans une application Swing, le conteneur principal est une JFrame (Fenêtre). Juste en dessous de lui une instance de JRootPane (Panneau Racine) est crée. JRootPane est lui même conteneur de plusieurs panneaux enfants.

JFrame

JRootPane

glassPane layeredPane ( JLayeredPane) (1 Jpannel par défaut)

contentPane menuBar (1 JPannel par défaut) (Null JmenuBar par défaut)

Tous ces panneaux seront étudiés plus en détail dans la partie qui va suivre. Ci-dessous, nous allons présenter quelques méthodes utiles de la classe JFrame. Méthodes utiles : Class JFrame

JFrame() : Crée une nouvelle fenêtre initialement invisible JFrame(String) : Crée une nouvelle fenêtre initialement invisible avec un titre getContentPane() : Retourne le contentPane de la fenêtre setDefaultCloseOperation(int) : spécifie l’action de fermeture par défaut setJMenuBar() : Attribue un Menu à cette fenêtre setLayout() : Attribue un Layout ( doit être utilisée par le contentPane) show() : Affiche la fenêtre ou l’amène en premier plan si elle est déjà visible setTitle(String) : Attribue un titre à la fenêtre setSize(int, int) : Attribue des dimensions à la fenêtre




3.1.2. JDialog

classe javax.swing.JDialog

Peu de choses différencient les deux 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. JDialog est utilisée pour afficher des boîtes de dialogues tandis que JFrame est utilisée en tant que fenêtre principale de l’application.

3.1.3. JWindow

classe javax.swing.JWindow

JWindow est un cas particulier de fenêtre, c’est une sorte de JFrame sans « pourtour » . Cette fenêtre n’est ni redimensionnable ni déplaçable par l’utilisateur. Il n’existe pas non plus de bouton système de fermeture de l’application, c’est au développeur de programmer la fermeture de ce type de fenêtre. 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. Pour ne pas surcharger l’enseignement de cette première partie, JDialog et JWindow seront étudiés en détail ultérieurement.

3.2. Panneaux 3.2.1. JRootPane

classe javax.swing.JRootPane

Comme je l’ai brièvement évoqué ci-dessus, une instance de JRootPane est créée automatiquement par la JFrame lors de son initialisation. En effet, le constructeur de JFrame fait automatiquement appel à la méthode createRootPane().

Le JRootPane ainsi créé contient les éléments suivants :

glassPane (un JPannel par défaut) layeredPane (un JLayeredPane) contentPane (un JPannel par défaut) menuBar (un JMenuBar null par défaut)

La figure 3.2.1.1 de la page suivante permet de visualiser ces éléments.




figure 3.2.1.1

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 application MDI de Microsoft.

contentPane est un panneau crée lui aussi par défaut, il reçoit les composant à l’aide de l’instruction suivante :

maJFrame.getContentPane().add(monComponent)

menuBar n’existe pas par défaut (il est null donc pas encore instancié), mais il est aisément créé par la méthode suivante :

setJMenuBar(menu);

3.2.2. JPanel

classe javax.swing.JPanel

JPanel est un container simple qui est utilisé pour regrouper des composants. Jpanel fait partie intégrante de JRootPane , et chaque JPanel est géré par un layout manager qui détermine sa position, sa taille. Il faut savoir que le layout manager par défaut d’un JPanel est le FlowLayout. Il existe cepandant une exception, le contentPane de JRootPane est géré par défaut par le BorderLayout. Nous aurons l’occasion de revenir sur les layouts au chapitre 5

3.2.3. JMenuBar classe javax.swing.JmenuBar

JMenuBar est une barre de menu. 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.

glassPane

menuBar

layeredPane

contentPane




Méthodes utiles : Class JMenuBar : Barre de menu principale

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

Class JMenu : Menu

JMenu() : Constructeur par défaut JMenu(string) : Constructeur d’un menu avec son libellé add(JMenuItem) : Méthode d’ajout d’un MenuItem au menu addSeparator() : Méthode d’ajout d’une barre de séparation

Class JMenuItem : Elément de menu

JMenuItem() : Constructeur par défaut JMenuItem(string) : Constructeur d’un élément de menu avec son libellé addActionListener(ActionListener) : Listener pour transmettre les évènements

Class JFrame (Méthodes correspondantes) setJMenuBar(JMenuBar) : Méthode pour transmettre une barre de menu à JFrame

3.2.3.1. TD2 : PremierJMenu Il s’agit de créer le menu présenté en figure 3.2.3.1.1. Il faut gérer le click sur chacun des éléments du menu qui permettre de modifier en conséquence un libellé (JLabel), donc il peut être utile de lire le paragraphe 3.2.4 (la gestion des évènements).

figure 3.2.3.1.1




3.2.3.2. TD2 : Second Menu Il s’agit de créer le menu présenté en figure 3.2.3.1.2. Ce menu contient des sous menus. La création d’un sous-menu est réalisée en ajoutant un JMenu à un autre JMenu.

figure 3.2.3.1.2

3.2.4. JLayeredPanel Ce type de panel permet la création de fenêtres filles (MDI), mais est d'une utilisation complexe. Il sera étudié en détail dans le dernier chapitre.

3.2.5. La gestion des événements 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 JMenu, 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. Cet objet est d’ailleurs appelé la source de l’événement. Voici ci-dessous quelques exemples de classes d’évènements et de l’interaction utilisateur à laquelle elles correspondent. FocusEvent : Passage du focus à un composant MouseEvent : Clic sur un JPanel ActionEvent : Clic sur un JButton DocumentEvent : Ajout d’une lettre à un JTextField … Un évènement est capable d’encapsuler des informations concernant son contexte d’apparition :

Le composant source de l’événement. Les coordonnées du clic (dans le cas d’un MouseEvent). La valeur de la touche tapée pour un keyEvent.




L’objet qui intercepte l’interaction utilisateur est appelé en java un Listener. Comme ce nom l’indique son rôle principal est d’être « à l’écoute » d’un composant (JButton, JPanel). Cette capacité d’être à l’écoute est permise à n’importe quel type d’objet, mais cela n’est pas fait de manière automatique. 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.

Le principe de la gestion des événements C’est au niveau du composant que l’on trouve les fonctions d’abonnement à différents listeners. Par ailleurs ces fonctions sont héritées de la classe Container et sont donc communes à un grand nombre de composants. Exemples de fonctions d’abonnement : addActionListener, addKeyListener, addFocusListener … Selon la méthode, une interface est requise. Par exemple addActionListener (ActionListener l) requière l’interface ActionListener. C’est dans cette interface que l’on trouve les fonctions qui permettront de traiter les événements et qu’il faut obligatoirement ajouter au code de notre application. Il est aussi possible de désabonner un listener du composant auquel il a été abonné à l’aide de la méthode public void removeTypeListener ou Type doit être remplaçé par le nom de l’événement.

3.2.5.1. Les classes d’évènements Le mécanisme de gestion des événements repose sur les classes d’événements. A la base de la hiérarchie de ces classes on trouve la classe EventObject (de java.util). Elle représente la superclasse pour tous les événements. C’est dans cette classe que l’on va trouver deux méthodes qui sont toString() et getSource() . La méthode toString() retourne l’évènement sous forme d’une chaîne de caractère et présente donc un intérêt limité. Par contre la méthode getSource() est particulièrement intéressante car elle permet de retourner la source de l’évènement. Cet objet source pourra être alors casté dans son type d’origine. Les classes d’évènements les plus importantes sont présentées ci-dessous :

ActionEvent : Evènement généré si on clique sur un bouton, 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énement. ( dans le cas d’un bouton retourne son libellé )

Bouton

Abonnement

listener

Notification




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 cast peut être necessaire)

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 container ou supprimé.

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

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

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 point. int getClickCount() : retourne le nombre de clics effrectués lors de l’événement.

3.2.5.2. Les interfaces de Listener d’évènements Les Listeners sont créés par l’implémentation d’une ou de plusieurs interfaces fournies par le package java.awt.event. Lorsque l’événement survient la source appelle la méthode du listener appropriée. L’implémentation d’une interface impose donc d’implémenter une ou plusieurs fonctions obligatoires. Les interfaces les plus courantes sont présentées ci-dessous :

ActionListener : Définit la méthode pour intercepter les événements d’actions.

void actionPerformed(ActionEvent ae)

ComponentListener : définit quatre méthodes pour détecter si un élément graphique est caché, déplacé, redimensionné ou visible.

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




ContainerListener : définit deux méthodes pour détecter si un élément graphique est ajouté ou

supprimé d’un container.

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

FocusListener : définit deux méthodes pour détecter si un élément graphique a perdu ou obtenu le focus.

void focusGained(FocusEvent fe) void focusLost(FocusEvent fe)

KeyListener : définit trois méthodes pour détecter si une touche est appuyée, relâchée ou si une lettre a été tapée. 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)

MouseListener : définit cinq méthodes pour détecter si on a cliqué avec la souris, si on a

appuyé sur un bouton, si on a relâché 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) void mouseExited(MouseEvent me) void mousePressed(MouseEvent me) void mouseReleased(MouseEvent me)

3.2.5.3. TD 2 Evenements : FocusEvent Il s’agit de comprendre le fonctionnement du FocusListener. Chaque fois que l’un des trois boutons obtient le focus, il prend une couleur donnée.

figure 3.2.4.3.1




3.2.5.4. TD 2 Evenements : KeyEvent Il s’agit de comprendre le fonctionnement du KeyListener. Chaque fois que l’on presse une touche on écrit le caractère correspondant dans la barre de titre de la fenêtre. La touche Suppr (Code 8) efface la barre de titre.

figure 3.2.4.4.1

3.3. Bordures package javax.swing.border

Une bordure (border) est une sorte de cadre de différentes natures qui peut entourer un composant. Les bordures sont souvent utilisées dans une interface graphique pour regrouper les composants par zones distinctes. Le package border fournit les classes de bordures suivantes qui peuvent être appliquées à n’importe quel composant Swing.

BevelBorder : Bordure 3D (élevée / abaissée) TitledBorder : Bordure avec titre. EtchedBorder : Bordure à l’apparence gravée. CompoundBorder : Combinaison de bordures interne et externe. EmptyBorder : Bordure transparente délimitant des espaces vides. LineBorder : Bordure aplatie. MatteBorder : Bordure pleine (couleur) ou en mosaïque (images). SoftBevelBorder : Bordure 3D avec côtés arrondis.

3.3.1. TD3 PremiereBordure Méthodes et classes utiles :




Class BorderFactory : Classe pour construire des Bordures rapidement createBevelBorder(int) : Retourne une BevelBorder createEtchedBorder() : Retourne une EtchedBorder createTitled(string) : Retourne une TitledBorder

Class BevelBorder : Classe de Bordure de type Bevel

BevelBorder(int) : Constructeur par défaut Voir dans le package javax.swing.border (Méthodes correspondantes)

setBorder(Border) : Méthode pour attribuer une bordure à un composant Pour modifier une bordure existante, il est nécessaire de recréer une nouvelle instance de bordure pour remplacer la précédente.

3.3.2. TD3 BordurePersonalisée Swing permet de créer des composants personnalisés, qui n’ont pas besoin d’exister dans le système d’exploitation, ce qui constitue un atout très important. Les méthodes suivantes relatives aux bordures permettent ainsi de créer très facilement une bordure personnalisée. void paintBorder(Component c, Graphics g): Dessine la bordure définie sur une région (Inset) Insets getBorderInsets(Component c): retourne une région (haut, bas , gauche , droite). boolean isBorderOpaque(): Retourne si la bordure est opaque ou transparente.




4. LIBELLES ET BOUTONS

4.1. JLabel (libellé)

classe javax.swing.JLabel

JLabel est l’un des composants Swing les plus simples. Il permet d’afficher du text, des icônes, ou les deux, et celà dans n’importe quelle position.

Méthodes et classes de base : Class JLabel : Classe pour construire des libellés

JLabel() : Crée un libellé sans image et avec une chaine vide pour titre JLabel(Icon ) : Crée un libellé avec une image JLabel(Icon , int) : Crée un libellé avec une image alignée horizontalement JLabel(String) : Crée un libellé avec du texte JLabel(String,int) : Crée un libellé avec du texte aligné horizontalement JLabel(String, Icon ,int ) : Texte + image et alignement Horizontal setHorizontalAlignement(int alignement) : définit l’alignement horizontal du contenu setVerticalAlignement(int alignement) : définit l’alignement horizontal du contenu setHorizontalTextPosition(int ) : définit la position du texte relativement à l’image setVerticalTextPosition(int textPosition) : Idem mais sur l’axe des y setIcon(Icon) : Permet de spécifier ou de remplacer à tout moment l’image du libellé setText(String) : Permet de spécifier le texte pour le bouton (supporte le <html>)

Class ImageIcon : Classe pour construire des icônes

ImageIcon(String filename) : Crée une icône à partir d’un fichier gif 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. Pour spécifier l’alignement on peut utiliser l’interface Javax.swing.SwingConstants. - SwingConstants.LEFT - SwingConstants.CENTER - SwingConstants.RIGHT - SwingConstants.TOP - SwingConstants.BOTTOM

Ci-dessous voici un schéma récapitulatif des alignements possibles




4.2. Boutons

classe javax.swing.AbstractButton

La classe AbstractButton est la classe de base à partir de laquelle dérivent les boutons suivants :

Les boutons poussoirs(JButton), les boutons bascule (JToggleButton), les cases à cocher (JCheckBox), les boutons radio (JRadioButton), mais aussi les élements de menu (JMenuItems) et les menus eux-mêmes (JMenus).

4.2.1. JButton

classe javax.swing.JButton

JButton est un bouton poussoir classique très simple.

Tout ce que nous savons sur JLabel s’applique à JButton. Nous pouvons lui ajouter des images, spécifier l’alignement, ou encore appliquer des couleurs de fond et d’avant plan.

De plus on peut ajouter des listeners (ActionListeners, ChangeListeners, ItemListeners) pour capturer les évènements.

Méthodes et classes de base : Class JButton : Classe pour construire des Boutons Poussoirs

JButton() : Crée un bouton sans image et avec une chaine vide pour titre JButton(Icon image) : Crée un bouton avec une image JButton(String text) : Crée un bouton avec du texte JButton(String text,Icon image) : Crée un bouton avec du texte et une image setHorizontalAlignement(int alignement) : définit l’alignement horizontal du contenu setVerticalAlignement(int alignement) : définit l’alignement horizontal du contenu setHorizontalTextPosition(int textPosition) : définit la position du texte relativement à

l’image setVerticalTextPosition(int textPosition) : Idem mais sur l’axe des y setIcon(Icon icon) : Permet de spécifier ou de remplacer à tout moment l’image du

bouton setPressedIcon(Icon) : Permet de spécifier une image lorsque le bouton est pressé setRolloverIcon(Icon) : Permet de spécifier une image lorsque le bouton est survolé getText() : Récupère le texte du bouton getIcon() : Récupère l’icône du bouton setIcon(Icon) : Permet de spécifier l’image du bouton setText(String) : Permet de spécifier le texte pour le bouton (supporte le <html>) setMnemonic(char) : Crée un raccourci vers char (ex : setMnemonic(’C’) Alt+C) addActionListener(ActionListener) : Ajouter le bouton à un ActionListener (voir ci-après) setEnabled(Boolean) : Activer / Désactiver le Bouton setActionCommand(string) : Permet de définir une commande liée au listener du bouton

Class JRootPane : JPanel par défaut de la fenêtre

setDefaultButton(JButton button) : Défini le bouton qui aura initialement le focus




4.2.2. JToggleButton

classe javax.swing.JToggleButton

C’est à partir de cette classe que dérivent JCheckBox et JRadioButton.

Cette classe 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 radios classiques).

Il suffit pour cela des grouper les boutons en question dans une instance de ButtonGroup à l’aide de la méthode add(Button) .

En ce qui concerne les méthodes de base, on peut se référer à celles déjà présentées pour JButton.

4.2.2.1. JCheckBox et JRadioButton

classe javax.swing.JCheckBox et classe javax.swing.JRadioButton

Ils héritent tous deux de toutes les fonctionnalités de JToggleButton.

4.3. TD4 Boutons Bascules et ActionListeners

Pour capturer des évènements sur des boutons, on a la possibilité d’utiliser l’interface ActionListener du package java.awt.event.* . Il faut donc que la classe puisse implémenter l’interface en question. Pour cela il faut ajouter la clause implements à la déclaration de la classe. Dans le cas de l’implémentation de l’interface ActionListener, il est impératif d’ajouter à la classe la fonction requise suivante :

public void actionPerformed(ActionEvent e) Enfin, il faut abonner le bouton au Listener par la méthode monbouton.addActionListener(this). Il est de plus très pratique d’utiliser setActionCommand(string) pour définir une action liée au bouton. Elle pourra être traitée dans la fonction actionPerformed(ActionEvent e) de la manière suivante :

if (e.getActionCommand().equals(string))

Il est à noter que ce procédé est parfaitement utilisable avec les JMenu.




5. LAYOUTS Lorsqu’une interface graphique contient plusieurs composants, il devient nécessaire de procéder à la gestion de la position de ceux-ci. Le rôle des layouts est précisément la gestion de la position des composants. Il faut bien comprendre cependant qu’un composant est contenu dans un container. Ce dernier s’attache les services d’un layout pour le positionnement des composants dont il a la charge. Pour comprendre la suite, rappelons qu’il y a deux tailles pour un composant, la taille effective (size) et la taille idéale (preferredSize). Un layout va essayer de rendre la taille effective le plus proche possible de la taille idéale compte tenu des contraintes liées à sa stratégie.

5.1. Layouts les plus courants

5.1.1. FlowLayout

classe java.awt.FlowLayout

C’est un layout très simple qui place les composants de gauche à droite, les uns à coté des autres et sur une même ligne tant que c’est possible en se basant sur la taille idéale des composants. Si il n’y a pas assez de place sur une ligne pour contenir un composant, une nouvelle ligne est ajoutée en dessous. Comme le placement dépend de la taille courante de la fenêtre, il est impossible de connaitre à l’avance la ligne sur laquelle sera plaçé un composant. FlowLayout est le layout par défaut de tous les JPanels hormis le Content Pane d’un JRootPane qui est lui initialisé par défaut avec un BorderLayout. Méthodes et classes de base : Class FlowLayout : Classe pour construire des FlowLayouts

FlowLayout() : Crée un FlowLayout centré FlowLayout(int align) : Crée un FlowLayout avec un alignement spécifique

Class JPanel : Classe pour construire des JPanels

JPanel(LayoutManager) : Crée un JPanel avec un gestionnaire de Layout spécifique setLayout(LayoutManager) : Attache les services d’un layout au JPanel

Constantes d’alignement : FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER




5.1.2. GridLayout

classe java.awt.GridLayout

Le GridLayout met en place une stratége simple et efficace. L’espace du container est découpé en une grille (tableau) dont le nombre de lignes et de colonnes est fixé lors de l’instanciation du GridLayout. La grille se remplit de gauche à droite suivant le nombre de colonnes, puis de haut en bas suivant le nombre de lignes. Le GridLayout s’efforce de faire occuper toute la place disponible dans un container, ce qui peut apporter des changements non souhaités de la taille des composants. Méthodes et classes de base : Class GridLayout : Classe pour construire des GridLayouts

GridLayout() : Crée un GridLayout de 1 ligne x 1colonne GridLayout(int ligne,int col) : Crée un GridLayout de ligne x col GridLayout(int ligne,int col,int larg,int haut) : ligne x col avec tailles lignes,colonnes

5.1.3. BoxLayout

classe java.swing.BoxLayout

Les layouts présentés précédemment appartenaient au package awt, tandis que la classe BoxLayout est une classe du package Swing. Les layouts ne sont pas des composants et n’héritent donc pas ni de Component (awt) ni de JComponent (Swing). C’est la raison pour laquelle les layouts définis dans le package awt peuvent êtres utilisés sans problème par les applications Swing. Le BoxLayout est une sorte de FlowLayout vertical ou horizontal. Il permet d’aligner les composants les uns à côté des autres ou les uns en dessous des autres. Dès que les composants sont alignés dans un sens, ils le resteront quelle que soit la taille du container. Le BoxLayout possède un seul constructeur, qui reçoit la référence du container qu’il va gérer, ainsi qu’une direction. Les composants sont affichés en fonction de leur preferredSize, et ne sont pas redimensionnés par ce layout. Méthodes et classes de base : Class BoxLayout : Classe pour construire des BoxLayouts

BoxLayout(Container target, int axis) : Crée un BoxLayout où les composants sont alignés suivant l’axe axis.




5.1.3.1. Box

classe java.swing.Box

Le BoxLayout utilise en interne la classe Box. Celle-ci permet la création d’objets comme les glues, les structures solides, et les zones rigides qui peuvent agir sur le BoxLayout.

1) Les structures solides Une structure solide est un composant invisible dont il faut préciser la taille en pixels. Elle sert à maintenir un espace fixe entre des composants (par exemple entre un champ texte et le bouton adjacent). La stucture solide peut être horizontale ou verticale en fonction du constructeur utilisé. 2) Les Glues Une glue est un composant invisible qui occupe le plus d’espace possible horizontalement ou verticalement. Elle peut être horizontale ou verticale en fonction du constructeur utilisé. 3) Les Zones Rigides Une zone rigide est un composant invisible de taille fixe.

Méthodes et classes de base :

Class Box : Classe pour construire des Composants Box Box(int axis) : Crée un Box où les composants sont alignés suivant l’axe axis. createGlue(int axis) : Crée un composant invisible « glue ». createHorizontalGlue(): Crée un composant invisible « glue » horizontal. createHorizontalStrut(int width) : Crée une structure solide de largeur fixe createVerticalGlue(): Crée un composant invisible « glue » vertical. createVerticalStrut(int height) : Crée une structure solide de largeur fixe createRigidArea(Dimension d) : Crée un composant invisible de taille fixe




5.1.4. BorderLayout

classe java.awt.BorderLayout

Le BorderLayout implémente une stratégie de positionnement très utile. Il réserve dans l’espace de son container cinq cases (voir fig 5.1). Une case centrale occupe le maximum d’espace possible dans toutes les directions, et quatre cases bordent cette case centrale. Ces cases périphériques sont nommées du nom des points cardinaux.

figure 5.1.4.1

La zone centrale prend toujours le maximum de place si toutefois les composants périphériques ne prennent pas toute la place (si la fenêtre est réduite à l’excès par exemple) . Les zones nord et sud occupent le maximum de place horizontalement mais le minimum verticalement. En d’autres termes, ils ont leurs tailles souhaitables verticalement, mais sont étirés horizontalement. Les zones est et ouest occupent le maximum de place verticalement mais le minimum horizontalement. En d’autres termes, ils ont leurs tailles souhaitables horizontalement, mais sont étirés verticalement. Méthodes et classes de base :

Class BorderLayout : Classe pour construire des BorderLayouts

BorderLayout() : Crée un BorderLayout sans espace entre les cases. BorderLayout(int hgap,int vgap) : Crée un BorderLayout avec les espacements spécifiés. Add(Component comp,Object Constraints) : Ajoute un componant à la case spécifiée

Constantes Object Constraints : BorderLayout.NORTH, BorderLayout.SOUTH, BorderLayout.EAST, BorderLayout.WEST, BorderLayout.CENTER

NORD (NORTH)

SUD (SOUTH)

OUEST (WEST)

EST (EAST)

CENTRE (CENTER)




5.2. TD5 Layouts les plus courants Ce TD va consister à comprendre l’approche pour l’utilisation des layouts. Celle-ci se décompose en trois parties :

La maquette du formulaire La définition des layouts et l’architecture de la fenêtre Le passage au code

5.2.1. La maquette du formulaire Le formulaire que l’on souhaite implémenter est représenté ci-dessous. Il va contenir deux champ textes (JTextField), deux boutos radios (JRadioButton), quatre libellés (JLabel), et une zone de texte (JTextArea).

La première étape consiste à repérer les composants principaux de l’architecture.

Partie 1

Partie 1a Partie 1b

Partie 2

Partie 3

Partie 2a

Partie 2b




5.2.2. Définition des layouts et architecture de la fenêtre Il faut bien comprendre qu’un layout est associé à un Panel, donc en fait on ajoute tous les composants (JButton, JLabel …) à un panel et non pas à un layout. Pour ne pas alourdir d’avantage les explications qui vont suivre, il faut bien comprendre qu’à chaque fois que l’on parle d’un layout, il s’agit en fait d’un panel auquel on a associé le layout en question.

5.2.2.1. Analyse des contraintes Fenêtre : Il faut que les Parties 1 et 3 aient une taille verticale fixe. Par contre la partie 2 peut avoir une taille verticale variable. Cela correspond parfaitement à l’implémentation d’un BorderLayout.

• Partie 1 : BorderLayout.NORTH

La partie 1a doit être alignée verticalement et chaque ligne doit avoir la même taille. Cette description correspond à celle d’un GridLayout de 3 lignes sur 1 colonne. La Partie 1b doit respecter les même contraintes que la partie 1a. De plus les lignes doivent coïncider entre les deux parties. Etant donné que la Partie 1 est déjà contenue dans la case NORTH d’un BorderLayout, elle est verticalement de taille fixe, et donc les lignes coïncideront. On peut donc utiliser un gridLayout (3,1) pour la partie 1b.

o Partie1b : GridLayout(3,1)

La première ligne contient deux boutons radios alignés à gauche. Il faut donc utiliser un FlowLayout aligné à gauche pour cette ligne.

• Partie 2 : BorderLayout.CENTER

La partie 2a doit être verticalement de taille fixe, tandis que la partie 2b peut avoir une taille verticale variable. On va ici aussi implémenter un BorderLayout. La Partie 2a sera ajoutée au Nord et la Partie 2b au centre.

• Partie 3 : BorderLayout.SOUTH Cette partie contient deux boutons alignés au centre, il faut donc utiliser un FlowLayout aligné au centre pour ces deux boutons.

L’étape précédente ne sert ici que d’explication au schéma qui va suivre, celui-ci est beaucoup plus utile et permet ensuite de passer très facilement au code.




5.2.2.2. Architecture de la fenêtre Pour réaliser un schéma d’architecture de la fenêtre on va utiliser le formalisme suivant :

: JPanel, ContentPane

: Boutons, Labels, Champs Texte …

: FlowLayout, GridLayout, BorderLayout, BoxLayout

Container

Composant

getContentPane()

p3 (JPanel)p2 (JPanel)p1 (JPanel)

SOUTH

CENTER

NORTH

Layout

Flow Center

BtEffacer (JButton)

BtOuvrir (JButton)

p2b (JScrollPanel) p2a (JPanel)

Border

Border CENTER NORTH

txtDescription JTextArea

lblDescription JLabel

p1b (JPanel)p1a (JPanel)

CENTER WEST

Grid (3,1)

Grid (3,1)

lblType Jlabel

lblUrl Jlabel

lbNom (Jlabel)

p1b1 (JPanel)txtUrl

JTextField

txtNom JTextField

RbMp3 JRadioButton

RbDivx (JRadioButton

)

Flow Left

Border

Flow Left




5.2.3. Passage au code Le passage au code est très simple à l’aide de cette méthode, il suffit de transcrire le schéma précédent. import java.awt.*; import javax.swing.*; import javax.swing.border.*; public class LayoutDemo extends JFrame { protected JRadioButton RdMp3,RdDivx ; protected JLabel lblType, lblNom, lblUrl, lblDescription ; protected JTextField txtNom,txtUrl; protected JTextArea txtDescription; protected JButton BtEffacer,BtOuvrir; protected JPanel p1b1, p1a, p1b, p2a, p1, p2, p3; protected JScrollPane p2b; public static void main(String args[]) { LayoutDemo App = new LayoutDemo(); } public LayoutDemo() { // Initialisation des JPanels p1b1=new JPanel() ; p1a=new JPanel() ; p1b=new JPanel() ; p2a=new JPanel() ; p2b=new JScrollPane(); p1=new JPanel() ; p2=new JPanel() ; p3=new JPanel() ; // Associations avec les layouts p1b1.setLayout(new FlowLayout(FlowLayout.LEFT)); p1a.setLayout(new GridLayout(3,1)); p1b.setLayout(new GridLayout(3,1)); p2a.setLayout(new FlowLayout(FlowLayout.LEFT)); p1.setLayout(new BorderLayout()); p2.setLayout(new BorderLayout()); p3.setLayout(new FlowLayout(FlowLayout.CENTER)); getContentPane().setLayout(new BorderLayout()); //Initialisation des autres objets RdMp3=new JRadioButton("Mp3"); RdDivx= new JRadioButton("Divx"); lblType=new JLabel("Type"); lblUrl=new JLabel("Url"); lblNom=new JLabel("Nom"); txtNom=new JTextField();




txtUrl=new JTextField(); lblDescription=new JLabel("Description"); txtDescription=new JTextArea(20,1); BtOuvrir=new JButton("Ouvrir"); BtEffacer=new JButton("Effacer"); //Ajouter des bordures (facultatif plus esthétique) p1.setBorder(new EtchedBorder()); p2.setBorder(new EtchedBorder()); p3.setBorder(new EtchedBorder()); //Ajout des composants aux différents panels suivant les layouts p1b1.add(RdMp3) ; p1b1.add(RdDivx) ; p1b.add(p1b1) ; p1b.add(txtNom) ; p1b.add(txtUrl) ; p1a.add(lblType) ; p1a.add(lblNom) ; p1a.add(lblUrl) ; p1.add(p1a,BorderLayout.WEST) ; p1.add(p1b,BorderLayout.CENTER) ; p2a.add(lblDescription); p2b.setViewportView(txtDescription); // Pour un JScrollPanel on n’utilise pas Add p2.add(p2a, BorderLayout.NORTH) ; p2.add(p2b,BorderLayout.CENTER); p3.add(BtOuvrir); p3.add(BtEffacer); getContentPane().add(p1, BorderLayout.NORTH) ; getContentPane().add(p2, BorderLayout.CENTER) ; getContentPane().add(p3, BorderLayout.SOUTH) ; //Afficher la fenêtre setSize(600,400); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); show(); } }




6. COMBO BOX 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. JComboBox est en fait constitué d’un composant JList et d’un bouton. Le composant ComboBox ainsi que les composants JTable, JList, et JTree qui vont vous être présentés dans les chapitres suivants peut être qualifié de complexe, en ce sens qu’il est possible de le paramétrer très finement. Il est bien sûr possible d’utiliser ces composants de façon très sommaire, en appliquant tels quels les constructeurs les plus simples. Toutefois on verra pourquoi la personnalisation des composant complexes n’a pas de repercussions néfastes en terme de mémoire.

6.1. JComboBox

classe javax.swing.JComboBox

Méthodes et classes de base : Class JComboBox : Classe pour construire des listes de choix

JComboBox() : Crée un ComboBox avec un modèle par défaut JComboBox(Vector) : Crée un ComboBox qui contient les élément d’un vecteur JComboBox(Object[ ]) : Crée un ComboBox qui contient les élément d’un tableau JComboBox(ComboBoxModel) : Creé un ComboBox qui contient les élément d’un

modèle existant addActionListener(ActionListener) : Ajoute un ActionListener à la ComboBox addItem(Object) : Ajoute un objet à la liste getSelectedIndex() : Retourne l’index (int) correspondant à la sélection getSelectedItem() : Retourne l’objet correspondant à la sélection insertItemAt(Object, int) : Insère un objet à l’emplacement spécifié (index) paramString() : Retourne la chaîne correspondante à la sélection removeAllItems() : Supprime tous les objets de la comboBox removeItem(Object) : Supprime un objet de la liste removeItemAt(int) : Supprime un objet de la liste à partir de son index setEditable(boolean) : rendre éditable ou non la ComboBox setEnabled(boolean) : activer / désactiver le composant setMaximumRowCount(int) : définit le nombre de lignes affichable sans ascenseur setModel(ComboBoxModel): définit le modèle de données que doit utiliser la ComboBox setSelectedIndex(int) : définit l’objet à sélectionner par son index (0 1er objet) setSelectedItem(Object) : définit l’objet existant à sélectionner dans la Combo Box




6.1.1. TD6 ComboBox pour choix de films Dans ce TD nous allons nous intéresser uniquement à la création d’une combo box à l’aide du constructeur JComboBox(Object[]), qui reçoit une liste d’objets. En effet, l’utilisation du constructeur JComboBox(Vector) est très similaire à celle étudiée dans ce TD car Vector est lui-même un tableau (dynamique). Au TD suivant nous verront l’utilité de JComboBox(ComboBoxModel) qui nous permettra de créer des ComboBoxes avec des icônes et du texte. Dans ce TD, il va s’agir de créer une interface permettant de sélectionner un film grâce à une comboBox. Une fois le film sélectionné, la jaquette et le synopsis correspondant sont affichés automatiquement. Pour permettre de faire un rappel sur les Entrées/Sorties on lira les synopsis à partir de fichiers textes. Les packages à inclure sont javax.swing.* , java.awt.event.*, java.io.*, et java.awt.* L’application est représentée en figure 6.1.1.1

figure 6.1.1.1

6.1.1.1. Explication du code (nouveaux concepts uniquement) protected Film[] films; films = new Film[5]; films[0]=new Film("Les Bronzés font du ski","lesbronzes.jpg","lesbronzes.txt"); films[1]=new Film("StarWars épisode II","starwars.jpg","starwars.txt"); films[2]=new Film("Le Boulet","leboulet.jpg","leboulet.txt"); films[3]=new Film("Spiderman","spiderman.jpg","spiderman.txt"); films[4]=new Film("L'Âge de glace","agedeglace.jpg","agedeglace.txt");




Film[] films est une tableau d’objets qui sont créés à partir de la classe Film qui doit être définie au sein de la classe de notre application. La ComboBox peut alors être crée à l’aide du constructeur JComboBox(Object[]) Toutefois pour pouvoir afficher une(des) donnée(s) particulière(s) de la classe film, cette dernière doit posséder la fonction suivante qui indique à la ComboBox, la chaîne à afficher pour un objet. public String toString() { return nom; // on pourrait aussi avoir : return nom + ” “ + prenom; } Pour les actions, plutôt que d’implémenter ActionListener pour toute la classe, on va utiliser une méthode différente. On peut ajouter un ActionListener à notre ComboBox de la manière suivante : ActionListener lst = new ActionListener() { public void actionPerformed(ActionEvent e) { Film film = (Film)cb1.getSelectedItem(); //Ne pas oublier le cast if (film != null) { showFilm(film); loadSynopsis(film); } } }; cb1.addActionListener(lst); //Ajout de l’action listener à la ComboBox Pour la lecture des fichiers on peut utiliser FileInputStream FileInputStream fichier; try { fichier=new FileInputStream(filename); } catch (FileNotFoundException e) { txtSynopsis.setText("Synopsis non trouvé, "+filename); return;} do {

try{ i=fichier.read(); } catch (IOException e) {/* problème de lecture */} if (i!=-1) txtSynopsis.append(""+(char) i); //i=-1 correspond à EOF

} while (i!=-1); try{ fichier.close(); } catch (IOException e) {/* problème de fermeture*/} }

6.1.2. TD6 ComboBox personnalisée Pour comprendre comment il est possible de personnaliser une ComboBox, il faut d’abord comprendre le mécanisme des renderers.




6.1.2.1. Les Renderers

Le renderer est un objet qui va permettre de dessiner le composant complexe.

En effet le composant complexe est lui-même composé graphiquement de plusieurs composants simples. Par exemple chaque ligne d’une comboBox correspond graphiquement à un JLabel.

Le renderer permet l’instanciation des lignes de la ComboBox en tant que composant graphique habituel (en l’occurrence un JLabel), et il permet aussi de libérer ces instances de la mémoire dès que les lignes ont été dessinées.

Le mécanisme peut être schématisé ainsi :

6.1.2.2. Créer son propre Renderer

Pour créer notre propre render, il nous est indispensable d’implémenter l’une des interfaces de type « Renderer » présentées ci-dessous.

L’interface de type renderer utilisée pour les ListBox est aussi celle utilisée pour les ComboBox du fait de la ressemblance de ces composants.

La seule méthode à implémenter est la méthode suivante :

getListCellRendererComponent(JList list, Object value, int index, Boolean isSelected, Boolean hasFocus)

Interface

ListCellRenderer

Interface

TableCellRenderer

Interface

TreeCellRenderer

DefaultListCellRenderer

DefaultTableCellRenderer

DefaultTreeCellRenderer

Combo BoxComment dois je dessiner la ligne ? ( envoi de l’objet )

Objet Renderer

Renvoie le composant graphique entièrement

paramétré

JLabel




Les différents paramètres correspondent aux informations suivantes :

list Le composant utilisateur du renderer

value L’objet à afficher

index la position de la ligne

isSelected et hasFocus l’état du composant à afficher

6.1.2.3. Notre ComboBox Personalisée Il s’agit dans cet exemple de créer une ComboBox dont les lignes permettent d’afficher à la fois une icône et du texte (voir fig 6.1.2.3.1)

figure 6.1.2.3.1

Pour arriver à ce résultat, on va transmettre tout d’abord au constructeur JComboBox(Object[]), un tableau d’images.

Chaque objet ImageIcon va contenir l’image et sa description.

protected ImageIcon images[]; images[0]=new ImageIcon("DrapeauFrance.gif"); images[0].setDescription("France"); … cb1=new JComboBox(images);

Notre Classe Renderer personnalisée doit dériver de JLabel (l’objet que le renderer va retourner) et implémenter comme convenu l’interface ListCellRenderer.

class MonRenderer extends JLabel implements ListCellRenderer { public MonRenderer() {




setOpaque(true); // pour afficher le rectangle de sélection } public Component getListCellRendererComponent(JList list,Object value,int index,boolean isSelected, boolean cellHasFocus) { if (isSelected) { setBackground(list.getSelectionBackground()); setForeground(list.getSelectionForeground()); } else { setBackground(list.getBackground()); setForeground(list.getForeground()); }

ImageIcon icon = (ImageIcon)value; setText(icon.getDescription()); setIcon(icon); return this;

}

Il est ensuite possible d’appliquer le renderer à notre ComboBox de la facon suivante :

MonRenderer renderer=new MonRenderer(); cb1.setRenderer(renderer);




7. LIST BOX (JList) Le composant JList est assez similaire à JComboBox. 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 quand à lui trois types de sélections dont nous parlerons dans ce chapitre. Le mécanisme des renderers utilisé précédemment ne sera pas rappelé ici, car il s’applique de manière complètement identique. Le JList tout comme JTree et JTable (chapitres suivants) à 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é.

classe javax.swing.JList

Méthodes et classes de base : Class JList : Classe pour construire des listes de choix

JList() : Crée une JList avec un modèle par défaut JList(Vector) : Crée une JList qui contient les élément d’un vecteur JList(Object[ ]) : Crée une JList qui contient les élément d’un tableau JList(ListModel) : Creé une JList qui contient les élément d’un modèle existant getModel() : Retourne le modèle associé à la liste setModel(ListModel) : Définit le modèle associé à la liste setListData(Object[]) : Définit les élements de la liste. setListData(Vector) : Définit les élements de la liste. addListSelectionListener(ListSelectionListener) : Ajoute un Listener à la liste setSelectedIndex(int) : Définit la sélection courante par son index setSelectedValue(Object, boolean) : Définit la sélection courante , le booleen indique s’il

faut faire défiler la liste pour afficher l’élément setSelectedInterval(int, int) : Définit un intervalle de sélection getSelectedIndex() : Retourne l’index de la sélection courante getMinSelectionIndex() : Retourne l’index du 1er élément de l’intervalle getMaxSelectionIndex() : Retourne l’index du dernier élément de l’intervalle getSelectedIndices() : Retourne une liste d’index d’éléments sélectionnés getSelectedValue() : Retourne l’objet correspondant à la sélection courante getSelectedValues() : Retourne une liste d’objets corresp aux éléments sélectionnés setSelectionMode(int) : Définit le mode de sélection getSelectionMode() : Retourne le mode de sélection de la liste clearSelection() : Désélectionne tous les éléments isSelectionEmpty() : Retourne un booléen vérifiant : aucun élément sélectionné isSelectedIndex(int) : Retourne un booléen vérifiant : index i sélectionné ensureIndexIsVisible(int) : Génère un défilement afin que l’index soit visible getFirstVisibleIndex() : Retourne l’index du 1er élement visible getLastVisibleIndex() : Retourne l’index du dernier élement visible setVisibleRowCount(int) : Définit le nombre de lignes visibles getVisibleRowCount() : Retourne le nombre de lignes visibles




Constantes de Sélection : SINGLE_SELECTION, SINGLE_INTERVAL_SELECTION, MULTIPLE_INTERVAL_SELECTION

7.1. Personnaliser la sélection

7.1.1. Le mode de sélection Sur un composant JList, il existe plusieurs politiques de sélection possibles : 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. On peut utiliser l’une ou l’autre des commandes suivantes pour spécifier une politique de sélection. MaListe.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

MaListe.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

7.1.2. Le contenu de le sélection Pour obtenir les lignes sélectionnées dans une liste,on peut utiliser les méthodes suivantes :

• La méthode getSelectedIndices() renvoie un tableau d’entiers avec les index des lignes sélectionnées.

• La méthode getSelectedValues() renvoie un tableau d’objets correspondants aux lignes sélectionnées.

• En Mode de sélection unique on utilisera de préference getSelectedIndex() et getSelectedValue().




7.1.3. 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 addListSelectionListener(ListSelectionListener). L’interface à implémenter est donc ListSelectionListener, cette interface ne spécifie qu’une seule méthode qui est public void valueChanged(ListSelectionEvent e)

7.2. TD9 Liste de choix multiples Il s’agit de créer une petite application qui affiche dans la zone de droite la ou les couleurs sélectionnées dans la liste (voir fig 7.2.1). Dans le cas d’une sélection multiple, les composantes Rouge, Vert, Bleu sont mélangées de manière uniforme.

figure 7.2.1 Informations utiles : Pour implémenter l’interface ListSelectionListener, on peut opter pour l’une des deux méthodes suivantes (la seconde est plus facile à mettre en place). 1) La classe principale doit implémenter ListSelectionListener (mot clé « implements ») Pour cela elle doit contenir la fonction suivante : Public void valueChanged(ListSelectionEvent e) { . . . . . } L’abonnement de notre composant JList à ce listener se fait alors à l’aide de l’expression suivante : Ma_JList.addListSelectionListener(this);

2) On peut aussi créer, au moment même de l’abonnement, une instance de ListSelectionListener et y inclure la fonction valueChanged de la manière suivante : Ma_JList.addListSelectionListener( new ListSelectionListener() { public void valueChanged(ListSelectionEvent e) { . . . . . . } }; On peut alors avoir un accès direct à tous les objets de la classe principale.




7.3. TD10 Personnalisation de la JList Le but de ce TD est très simple. Il s’agit d’utiliser le mécanisme des renderers pour obtenir le même résultat que celui présenté sur la figure 7.2.2. La fonction permettant de spécifier un renderer pour une JList est : Ma_JList.setCellRenderer(MonRenderer);

figure 7.2.2




8. JTree Dans le cas d’un JTree il existe une difficulté concernant la création de l’arborescence. En effet même si il existe un constructeur qui prend en paramètre un vecteur d’objets, celui-ci crée un arbre où tous les éléments sont situés au même niveau d’arborescence (en l’occurrence à la racine) . Dans un objet JTree, les nœuds sont représentés par des objets TreeNode. Il existe des méthodes permettant d’accéder au parent et à la liste des enfants d’un TreeNode. Le Constructeur le plus avantageux pour construire un JTree est le constructeur suivant : Public JTree (TreeNode root) Le paramètre de ce constructeur est un objet implémentant l’interface TreeNode. Cette interface se trouve dans le package javax.swing.Tree. Une classe instanciable implémentant TreeNode est la classe DefaultMutableTreeNode. Cette classe est très facile à utiliser, on peut ajouter des enfants, accéder à un parent, ect … La Création d’un arbre et des nœuds se fait de la manière suivante : DefaultMutableTreeNode Top = new DefaultMutableTreeNode("Top"); DefaultMutableTreeNode N1 = new DefaultMutableTreeNode("N1"); DefaultMutableTreeNode N1_1 = new DefaultMutableTreeNode("N1"); DefaultMutableTreeNode N2 = new DefaultMutableTreeNode("N1"); … Puis on décrit l’arborescence en ajoutant les enfants à leur parent: N1.add(N1_1); Top.add(N1); Top.add(N2); Enfin on Crée l’arbre grâce au constructeur évoqué précédemment : JTree arbre = new JTree(Top);

8.1.1. Personnalisation d’un arbre Pour personnaliser un arbre (icônes personnalisées), on peut utiliser la méthode des renderers dont on à parlé au chapitre 6. On va dans le cas d’un JTree utiliser le DefaultTreeCellRenderer. On peut spécifier les 3 icônes suivantes :

• Nœud Fermé : setClosedIcon(Icon) • Nœud Ouvert : setOpenIcon(Icon); • Feuille : setLeafIcon(Icon);




8.1.2. Sélection dans un arbre Pour gérer la sélection dans un arbre, on va utiliser l’interface TreeSelectionListener. La fonction de traitement de l’évènement est la fonction suivante : public void valueChanged(TreeSelectionEvent e) {

8.1.3. TD11 Un Premier JTree Le JTree présenté dans cette application utilise le mécanisme du DefaultTreeCellRenderer et gère la sélection.

figure 8.1.3.1




9. JTable JTable est un composant extrêmement utile mais malheureusement assez complexe. En effet un package complet, nommé javax.swing.table lui est consacré. Nous étudierons ici assez brièvement ce package, mais il ne faut pas oublier que ce dernier intègre diverses fonctionnalités que nous n’étudierons pas ici telles que l’impression et l’affichage avant impression, les interactions Client-Serveur à l’aide de Corba … JTable implémente les listeners TableModelListener, TableColulmnModelListener, ListSelectionListener, CellEditorListener et l’interface Scrollable (ce qui signifie qu’il peut être placé dans un JScrollPane) . Chaque JTable dispose de trois modèles qui sont TableModel, TableColumnModel, et ListSelectionModel .

• TableModel définit la manière dont sont stockées les données, et gère l’ajout, la suppression et la récupération des données. Il définit aussi les types de données de chaque colonne, et spécifie aussi si une cellule est éditable. Toutes les données de la table sont stockées dans le TableModel (Tableau à 2 dimension ou Vecteur de Vecteurs).

• TableColumnModel gère des instances de TableColumn (c'est-à-dire une colonne de la table).

TableColumnModel est responsable de l’affichage des colonnes dans la table. Chaque TableColumn possède un cell renderer, un cell editor, un table header, et un cell renderer pour le table header.

• ListSelectionModel définit le mode de sélection (single-interval, multiple-interval).

ListSelectionModel est très flexible et permet de personnaliser les sélections de toutes les manières que l’on souhaite.

9.1. Utilisation simple d’une JTable La méthode la plus simple pour construire une table est de passer un vecteur de vecteurs en paramètres du constructeur. Le constructeur suivant va être utilisé : JTable (Vector rowData, Vector ColumnNames) Ce Constructeur reçoit des Vecteurs de Vecteurs (rowData pour les lignes, ColumnNames pour les entêtes). Pour pouvoir ensuite afficher la table il est préférable d’utiliser l’interface Scrollable implémentée par JTable. JScrollPane sp=new JScrollPane(table);




9.1.1. TD12 JTable Simple Il s’agit de créer grâce à la méthode présentée ci-dessus une première table particulièrement simple.

figure 9.1.1

9.1.2. TD13 Un Renderer Personnalisé Dans cet exemple nous allons utiliser le mécanisme des renderers pour créer un renderer personnalisé qui met la 1ère colonne en majuscule. Le mécanisme des renderers en ce qui concerne les JTable se met en place grâce à l’utilisation de l’interface TableCellRenderer.

figure 9.1.2




9.1.3. Renderers par défaut Nous allons nous intéresser ici à un mécanisme particulièrement utile qui est celui de l’utilisation des renderers par défaut. En l’occurrence il va s’agir ici de DefaultTableCellRenderer. Le principe est de s’appuyer sur les renderers par défaut. Pour cela la JTable doit connaître le type de données à afficher, pour cela il va s’adresser à l’objet qui encapsule les données, c'est-à-dire le TableModel. Il y a alors deux cas possible :

• Il n’existe pas de TableModel crée par l’utilisateur. JTable utilise le TableModel crée par défaut.

• Il existe un TableModel personnalisé. JTable s’adresse à ce dernier.

Une fois que JTable connaît le type de données à afficher, il se réfère à son dictionnaire liant les types et leurs renderers associés. Ce dictionnaire est la classe suivante : Protected transient Hashtable defaultRenderersByColumnClass Ce dictionnaire contient par défaut la liste suivante :

• Boolean ( JCheckbox ) • Number ( JLabel aligné à droite ) • Date ( JLabel formaté avec DateFormat et aligné à droite) • ImageIcon ( JLabel aligné au centre ) • Object ( JLabel aligné à gauche affichant une chaîne de caractères)

Il va donc s’agir de redéfinir un TableModel pour notre JTable et de lui inclure la méthode qui renvoie le type d’objet : Public Class getColumnClass(int colonne) { Return getValueAt(0,colonne).getClass(); }

JTable

Demande au modèle quel est le type des objets contenus dans la colonne i : Modele.getColumnClass(i)

DefaultTableModel

L’implémentation par défaut renvoie toujours la classe Object

JTable

Demande au modèle quel est le type des objets contenus dans la colonne i : Modele.getColumnClass(i)

MonModele extends AbstractTableModel

La fonction getColumnClass redéfinie renvoie le type exact de la donnée à afficher.




9.1.4. TD14 L’utilisation d’un TableModel Il va s’agir ici de reprendre l’exemple précédent. En créant un TableModel renvoyant le type de données, l’affichage se fait automatiquement en respectant les spécifications du dictionnaire. On peut voir ici que la colonne contenant des booléens est affichée automatiquement avec des JCheckBox.

figure 9.1.4 Il va d’abord s’agir de créer un TableModel class MonTableModel extends AbstractTableModel { String[] nomColonnes = {"Nom","Prénom","Adresse","Inscrit"}; Object[][] donnees = {{"Michelin", "Jean", "31 rue de la source", new Boolean(false)}, {"Benmiloud", "Aziz", "102 Boulevard Jean Jaurès", new Boolean(true)}, {"Andersson", "Gunnar", "22 Spelfältet Avenue", new Boolean(true)}, {"Zerbib", "Ariel", "18 rue de la boétie", new Boolean(false)}}; public int getColumnCount() { return nomColonnes.length; } // Nombre de colonnes public int getRowCount() { return donnees.length; } // Nombre de lignes public String getColumnName(int col) { return nomColonnes[col]; } //Nom de la colonne public Object getValueAt(int row,int col) { return donnees[row][col]; } //Type Objet public Class getColumnClass(int c) {return getValueAt(0,c).getClass();} //Type d’objet (int,boolean..) } Il suffit de créer la table à l’aide du constructeur suivant : MonTableModel Modele = new MonTableModel(); JTable MaTable = new JTable(Modele);




9.1.5. Les Editors Comme on a pu le constater, par défaut les cellules d’une JTable sont éditables. Par contre, lorsque l’on utilise un renderer personnalisé, on peut choisir de rendre le tableau non éditable. Il est souvent possible que l’on cherche à mettre en place une manière précise d’éditer une cellule, par exemple de faire apparaître une JList où l’on doit sélectionner une valeur. C’est à cela que servent les editors.

9.1.6. Fonctionnement des Editors Le fonctionnement des editors est très similaire à celui des renderers. Lorsque l’utilisateur cherche à modifier le contenu d’une cellule (double clic, frappe clavier), l’editor prend le contrôle sur la cellule. La figure 9.1.6.1 schématise le fonctionnement d’un editor.

figure 9.1.6.1 Comme dans le cas des renderers, on est assez libre dans l’implémentation. On peut choisir d’hériter d’un composant graphique (extends JLabel ….), ou bien d’encapsuler ce composant dans une variable d’instance. Il est toutefois indispensable d’implémenter l’interface en question (ici CellEditor). La figure ci-dessous présente la hiérarchie des classes editor.

figure 9.1.6.2

JTable

Demande à l’editor comment gérer la cellule (i,j) que l’utilisateur souhaite éditer

Object Editor

Renvoie le composant graphique entièrement paramétré

Interface CellEditor

Interface TableCellEditor

Interface TreeCellEditor

AbstractCellEditor

DefaultCellEditor DefaultTreeCellEditor




On peut remarquer qu’il n’existe pas de classe de type ListCellEditor (ce qui est logique car JList n’est pas un composant éditable). La classe DefaultCellEditor peut être utilisée pour les tables et pour les arbres car elle hérite des deux interfaces TableCellEditor et TreeCellEditor. Il existe néanmoins une classe plus adaptée à l’édition d’un arbre, qui est DefaultTreeCellEditor.

9.1.7. Créer notre Editor Pour illustrer l’implémentation d’un editor appliqué à notre exemple précédent, on considère que l’utilisateur doit choisir une ville dans une liste déroulante. Une manière simple de créer un editor est d’utiliser la classe DefaultCellEditor. Celle-ci encapsule le composant graphique sous la forme d’une variable nommée editorComponent. Il est possible d’afficher un JTextField, une JCheckBox ou encore une JComboBox. DefaultCellEditor dispose de constructeurs permettant d’accepter chacun des composants précités. Object[] villes = {"Paris","Venise","Mexico","Toulouse","Bordeaux"}; JComboBox cboVilles = new JComboBox(villes); DefaultCellEditor monEditor = new DefaultCellEditor(cboVilles); TableColumn col3=table.getColumnModel().getColumn(3); col3.setCellEditor(monEditor); Une autre manière de créer un editor personnalisé consiste à hériter de AbstractCellEditor, et d’implémenter les fonctions getTableCellEditorComponent et getCellEditorValue. En voici un exemple : class EditorPerso extends AbstractCellEditor implements TableCellEditor { public JTextField MonChamp; public EditorPerso() { MonChamp=new JTextField(); MonChamp.setBackground(Color.GREEN); } public Component getTableCellEditorComponent (JTable table, Object value, boolean isSelected, int row, int column) { MonChamp.setText((String)value); return MonChamp; } public Object getCellEditorValue() { String a=MonChamp.getText();; return a; } }




9.1.8. TD15 Les Editors Il s’agit d’implémenter deux editors. L’un à l’aide de la méthode DefaultCellEditor, pour créer une JComboBox. L’autre en héritant de AbstractCellEditor. Puis de les appliquer sur les troisième et quatrième colonne.




10. Les Containers Un container est un composant dont le rôle est de contenir d’autres composants. C’est au sein de la classe Container que l’on va trouver les méthodes add(Component comp,int index) et remove(Component) qui seront héritées par les classes héritant de Container.

10.1. JFrame (Container Racine) Une interface graphique peut être considérée comme un arbre de composants swing où les nœuds sont des containers (Container) et les feuilles des composants (JComponent). La racine d’une interface graphique est soit une fenêtre, soit une boîte de dialogue. Pour une fenêtre principale JFrame, le container racine est le contentPane. C’est la raison pour laquelle pour ajouter un composant à notre fenêtre on passe par getContentPane().add(Composant).

10.2. JPanel Le container JPanel déjà présenté au chapitre 3 est très utilisé dans la conception d’interfaces graphiques. L’aspect graphique d’un JPanel est réduit au strict minimum. Il peut être perçu comme une sorte de rectangle, parfois invisible graphiquement, dans lequel on ajoute des composants. Il est possible de modifier la couleur de fond d’un JPanel, sa taille, sa position, son état (visible, invisible, armé désarmé). JPanel est le nœud idéal dans une arborescence de composants. L’ajout d’un composant dans un JPanel se fait par le biais de la méthode add(…) héritée de Container. P1.add(bouton 1); P2.add(monLabel); …. Fenetre.getContentPane().add(P1) Fenetre.getContentPane().add(P2)

Fenêtre

P1 (JPanel) P2 (JPanel)

3 JButtonJLabel

JTextField




10.3. JScrollPane (Container avec défilement) Lorsque le composant que l’on cherche a afficher est trop grand pour être affiché dans sa totalité (JTable, JTextArea …), il est alors possible de faire appel au container JScrollPane. Souvent le composant placé dans un JScrollPane va être lui aussi un container (JPanel …). JScrollPane contrairement à JPanel n’accepte qu’un seul composant. Il à un impact graphique plus important que JPanel du fait de la présence d’ascenseurs. 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 l’instruction suivante : setViewportView(Composant) JScrollPane sp = new JScrollPane(); //déclaration du ScrollPane 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 fenetre principale

10.4. JTabbedPane (Panneau à Onglets) Ce container permet d’afficher plusieurs panneaux qui partagent tous 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 container. Les trois constructeurs existants sont les suivants :

• JTabbedPane() : Crée un TabbedPane vide avec placement des onglets en haut • JTabbedPane(int tabPlacement) : + spécifie le placement des onglets

o JTabbedPane.TOP o JTabbedPane.BOTTOM o JTabbedPane.LEFT o JTabbedPane.RIGHT

• JTabbedPane(int tabPlacement, int tabLayoutPolicy) : + politique d’affichage des onglets o JTabbedPane.WRAP_TAB_LAYOUT o 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) ; … fenetre.getContentPane().add(MonPanneau) ;




10.5. JSplitPane (Barre de séparation) JSplitPane est un container qui permet de séparer une fenêtre en deux parties dont les surfaces peuvent changer dynamiquement. Ce container s’utilise de façon classique mais il peut ne contenir que deux composants (ou containers), un de chaque côté de la barre. JSplitPane peut être orienté horizontalement ou verticalement suivant que l’on utilise les méthodes suivantes (elles vont par 2) :

• MonSplit.setLeftComponent(composant) & MonSplit.setRightComponent(composant) • MonSplit.setTopComponent(composant) & MonSplit.setBottomComponent(composant)

D’autres méthodes permettent quand à elles de modifier ou non la taille des deux parties dynamiquement :

• MonSplit.setContinuousLayout(true) : Dynamique (Modifier) • MonSplit.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.

• MonSplit.setOneTouchExpandable(true)

10.6. TD 16 : Tout ce que l’on vient de voir




11. Les Composants texte Swing fournit des composants texte qui répondent aux besoins classiques des applications. Ils sont présentés en figure 11.1

figure 11.1

11.1. JTextField Ce composant va permettre la saisie d’une seule ligne de texte. Il n’est pas possible d’utiliser des styles de texte (gras, italique …), ni d’inclure d’autres composants. On peut utiliser l’un des deux constructeurs suivants : JTextField () : Crée un champ de saisie vide JTextField (String text) : Crée un champ de saisie avec un texte par défaut

11.2. JPasswordField Ce Composant permet de créer un champ pour la saisie des mots de passes. Le caractère par défaut ‘*’ peut être remplacé à l’aide de la méthode : setEchoChar (char ) : par exemple monChamp. setEchoChar ('-') ; pour remplacer * par -




11.3. JTextArea classe javax.swing.JTextArea

JTextArea est un composant permettant d’afficher plusieurs lignes de texte. A l’instar de JTextField il ne permet pas d’afficher des polices et des couleurs de différents types. Il gère le passage à la ligne et permet de spécifier si on peut couper un mot ou non. JTextArea MonChamp = new JTextArea() ; MonChamp.setLineWrap(true) ; // passage à la ligne actif MonChamp.setWrapStyleWord(true) ; // refuser la coupure au milieu d’un mot L’ajout de texte dans un JTextArea se fait soit par le biais de l’utilisation de l’un des deux constructeurs suivants : JTextArea (String text) ; JTextArea (String text, int rows, int columns) ; Il est aussi possible d’ajouter du texte grâce aux méthodes suivantes : Void append(String text) : Ajout d’une chaîne à la fin du doument Void insert(String text, int position) : Ajout d’une chaîne à une position donnée Void replaceRange(String text, int start, int end) : Remplace la chaîne contenu entre start et end Void setText(String text) : Remplace tout le texte par la chaîne Le composant JTextArea est souvent utilisée avec un JScrollPane afin d’ajouter des barres de défilement.

11.4. JTextPane Ce composant est le composant texte le plus riche. Le JTextPane accepte différentes mises en forme ainsi que l’ajout d’autres composants graphiques ou d’images. txt.insertComponent(Component c) ; // ajout d’un composant txt.insertIcon(Icon i) ; // ajout d’une image JTextPane repose sur le concept de styles définis en java, qu’il est possible de personnaliser.




11.4.1. Definir des styles Un style est encapsulé dans un objet d’une classe implémentant l’interface Style. Les styles forment une arborescence. A partir d’un parent unique, on définit les autres éléments de l’arborescence. La racine est donc le style par défaut. L’obtention du style par défaut se fait de la manière suivante : Style racine = StyleContext.getDefaultStyleContext().getStyle(StyleContext.DEFAULT_STYLE) ; On peut alors modifier l’une des caractéristique du style par défaut ainsi : StyleConstants.setFontFamily(racine, "SansSerif") ; // Pour modifier le type de police StyleConstants.setFontSize(racine, 16) ; // Pour modifier la taille de la police Les autres styles vont alors pouvoir être définis à partir du style racine grâce à la méthode addStyle() JTextPane txt =new JTextPane() ; Style x = txt.addStyle("Italique", racine) ; StyleConstants.setItalic(x, true) ; Style x = txt.addStyle("Gras", racine) ; StyleConstants.setBold(x, true) ; Style x = txt.addStyle("check", racine); StyleConstants.setComponent(x, new JCheckBox("bouton")); Pour pouvoir attribuer un style au JTextPane, on peut utiliser la méthode setLogicalStyle(Style s) Txt.setLogicalStyle(txt.getStyle("Italique")) ;

11.4.2. Formater un contenu Pour ajouter du texte formaté avec un style particulier, il faudra en plus de ce qui a été fait ci-dessus, passer par le biais d’une instance de Document, et de la méthode insertString(int,String,Style) . DefaultStyledDocument doc = new DefaultStyledDocument(); try { doc.insertString(doc.getLength(),"Première ligne de texte.\n" ,racine); doc.insertString(doc.getLength(),"Seconde ligne de texte (en gras).\n" ,txt.getStyle("Gras")); doc.insertString(doc.getLength()," " ,txt.getStyle("check")); // On peut même ajouter des // composants } catch (BadLocationException e) {} txt.setDocument(doc) ; // Associer le Document au JTextPane




11.5. TD 17 : Les Composants Texte Programmez l’application affichée en page 43 sur la figure 11.1.




12. Les boîtes de dialogues La classe JDialog de Swing permet l’implémentation des boîtes de dialogues modales et non modales. Dans certains cas simples (afficher un message, ou saisir une seule valeur) on pourra utiliser la classe JOptionPane pour obtenir des boîtes de dialogues prédéfinies. Deux autres classes fournissent en plus des mécanismes de sélection et de navigation avancés , ce sont les classes JColorChooser et JFileChooser.

12.1. JDialog Class javax.swing.JDialog 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 container pratiquement identique à JFrame. Méthodes et classes de base : Class JDialog : Classe pour construire des boîtes de dialogue

JDialog() : Crée une JDialog non modale, sans titre et sans parent JDialog(Dialog, String,boolean) : Crée une JDialog modale ou non, avec titre et parent JDialog(Frame,String,boolean) : Crée une JDialog modale ou non, avec titre et parent

Pour construire une JDialog, il faut opter pour l’un de ses constructeurs. Les constructeurs avec boolean permettent de créer des boîtes de dialogue modales ou non. En ce qui concerne la classe JDialog, elle s’utilise de la même manière que JFrame (getContentPane..). JDialog se positionnant 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.

12.1.1. TD 18 : Les Boîtes de dialogue personnalisées Construire l’application présentée ci-dessous, à l’aide de la classe JDialog




12.2. JOptionPane Class javax.swing.JOptionPane 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 :

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

Zone de Message

Zone d’options (Boutons)

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

( JTextField ou JComboBox)




Object[] options = { "ACCEPTER", "REFUSER" }; JOptionPane.showOptionDialog(null, "Les valeurs doivent elles êtres définitivement effacées ?", "Attention",JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,null, options, options[0]); 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]);




12.2.1. Fonctions showXxxDialog Quelques fonctions showXxxDialog les plus 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és et le groupe de boutons associés

showInputDialog(Component Parent, Object message) Crée une boîte de dialogue d’entrée

showMessageDialog(Component Parent, Object message)

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

showOptionDialog(Component Parent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue) 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 function showXxxDialog retourne un entire, les valeurspossibles sont :

• YES_OPTION • NO_OPTION • CANCEL_OPTION • OK_OPTION • CLOSED_OPTION




12.3. JFileChooser Class javax.swing.JFileChooser

La classe JFileChooser fournit une boîte de dialogue avec des fonctions de navigation avançées.

Méthodes et classes de base : Class JFileChooser : Classe pour construire des boîtes de dialogue

JFileChooser(File CurrentDirectory) : Crée une JFileChooser positionné sur File JFileChooser(String CurrentDirectoryPath) : Crée une JFileChooser positionné sur Dir getSelectedFiles() : Retourne les fichiers séléctionnés (File[]) getSelectedFile() : Retourne le fichier séléctionné (File) getCurrentDirectory() : retourne l’objet File associé au repertoire courant setDialogTitle(String title) : définir le titre de la boîte de dialogue setFileSelectionMode(int Mode) : Fichiers , Répertoires, ou les deux showDialog(Component, String ApproveButton) : Boîte de dialogue personnalisée showOpenDialog(Component) : Affiche la boîte de dialogue « OpenFile » showSaveDialog(Component) : Affiche la boîte de dialogue « SaveFile »




13. Les applications MDI Pour construire des applications Swing MDI (Multiple document Interface), on utilise le container JLayeredPane que l’on a très brièvement évoqué au chapitre 3, et que je présente ci-après.

13.1. JLayeredPane Class javax.swing.JLayeredPane JLayeredPane compte parmi les composants du package Swing les plus puissant et les plus robustes. C’est un container qui peut posséder un nombre de couches quasi illimité. Les composants contenus dans un Layer (une couche de JLayeredPane) sont organisés selon leur position. Lorsque deux composants d’un même layer se chevauchent le composant de valeur élevée est affichés en dessous de celui de valeur basse. Cepandant, en ce qui concerne les Layers, c’est le contraire qui se passe. Les Layers de valeur élevée sont affichés au dessus des Layers de valeur basse.

13.1.1. Positions dans un layer Dans un layer contenant N composants, les positions de ceux-cis sont numérotées de -1 à (N-1). En ce qui concerne l’affichage, le composant de position 0 est au dessus du composant de position N.

13.1.2. Profondeur (Depth) Lorsqu’un composant est contenu dans un layer, ce dernier est considéré comme étant la profondeur (Depth) du composant. 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 suivantes :

FRAME_CONTENT_LAYER DEFAULT_LAYER PALETTE_LAYER MODAL_LAYER POPUP_LAYER DRAG_LAYER

Ces Layers sont destinés à être les Layers standard.




13.1.3. Ajout dans un 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 standard, par exemple JLayeredPane.POPUP_LAYER Pour ajouter un composant à un layer particulier et à une position donnée on utilisera add(Component composant, Object obj, int position)

13.1.4. TD18 Afficher un fond Un layer n’est pas affecté par le re-dimensionnement de la fenêtre. Grâce aux layers il est possible d’ajouter un fond statique à l’arrière de notre contentPane().

13.2. Créations d’interfaces MDI La création d’interfaces MDI à partir de swing est un processus qui peut être très complexe. En effet, si l’on cherche à créer une application MDI à l’aide de JLayeredPane, c’est une opération qui est dans ce cas particulièrement complexe, car il faut programmer toutes les fonctionnalités des fenêtres filles telles que le déplacement, l’agrandissement …. Une alternative s’offre à nous. Elle consiste à utiliser les classes JDesktopPane et JInternalFrame qui ont été spécialement implémentées pour faciliter la programmation MDI sous Swing.




13.2.1. JDesktopPane class javax.swing.JDesktopPane

JDesktopPane est une extension de JLayeredPane spécialement construite pour gérer des fenêtres filles du type JInternalFrame. JDektopPane, comme JTextPane ou JTabbedPane permet d’ajouter des composant à 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. En plus de la méthode add , d’autres méthodes peuvent être utiles, comme : JInternalFrame [] getAllFrames() : retourne une collection de JInternalFrames actuellement affichées Dans le JDesktopPane setSelectedFrame(JInternalFrame f ) : rend la JInternalFrame f active

13.2.2. JInternalFrame class javax.swing.JInternalFrame JInternalFrame est une fenêtre qui peut être déplacée, agrandie, réduite, iconifiée, … 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 : setLocation(int x, int y) : Définit la position de la JInternalFrame setSize(int,int) : Définit la taille de la fenêtre setDefaultCloseOperation() : Ici on donnera la constante HIDE_ON_CLOSE,

DISPOSE_ON_CLOSE ou encore DO_NOTHING_ON_CLOSE setResizable(Boolean) : Définit si la fenêtre peut être retaillée ou non setIconifiable(boolean) : Définit si la fenêtre peut être iconifiée ou non setIcon(boolean) : Iconifie / Désiconifie la fenêtre setMaximizable(boolean) : Définit si la fenêtre peut être agrandie ou non setMaximum(boolean) : Maximise la fenêtre ou revient à la taille normale setClosable(boolean) : Définit si la fenêtre peut être fermée ou non setClosed(boolean) : Ferme la fenêtre




13.2.3. TD19 Première Application Mdi A l’aide des explications précédentes créer une application MDI Simple avec JMenu.

13.2.4. TD20 Application TP Mdi

Il faut créer une application MDI qui permet d’ouvrir les TD 2 et 10, et aussi d’ouvrir une fenêtre fille du même type que la fenêtre principale. Il faudra légèrement modifier les TD 2 et 10 (JFrame JInternalFrame) et supprimer les méthodes spécifiques à JFrame (setDefaultCloseOperation … )

Documents

Développement d’interfaces graphiques en Java à l’aide de SWING …entrepotforall.free.fr/Cours 2003-2004/Java/Labo Sun... · 2003-12-13 · [email protected] Développement