Java : Interface Homme-Machine

Java : Interface Homme-Machine
Cours LOO / Y.Laborde Java : Interface Homme-Machine LES CONCEPTS de L’IHM : Introduction L’AWT (Abstract Window Toolkit) le package java.awt les composants graphiques les conteneurs de composants les gestionnaires de mise en forme création d’une application Java avec Frame le package java.awt.event l’établissement de liens entre les composants actifs et l’applicatif Cours JAVA / Y.Laborde

Java : IHM / Introduction
Les IHM (Interfaces Homme-Machine) regroupent tout ce qui entre en jeu pour assurer une interaction entre les utilisateurs et les applicatifs. Cela comprend aussi bien les aspects visuels purement graphiques (fenêtres, boutons, …) que comportementaux (déroulement d’une liste, déclenchement d’une action, …) et procéduraux (traitement lié à une action, …). De nos jours, les IHM sont fortement standardisées. Leur mise en œuvre met en jeu de nombreuses couches logicielles. Prenant l’exemple d’applicatifs Java, on trouve : le système d’exploitation (SE), le gestionnaire de fenêtres (WM pour window manager), la machine virtuelle Java (JVM), les composants graphiques et leurs traitements spécifiques depuis l’applicatif. L’objectif, poursuivit depuis de nombreuses années, quant à la standardisation des IHM est d’un enjeu majeur en matière de portabilité des applications. Les SE proposent aujourd’hui une interface graphique commune pour les utilisateurs (GUI pour graphical user interface) et sont basées sur un principe événementiel qui permet d’assurer l’interaction entre les différentes couches logicielles. Les événements passent toujours par le gestionnaire de fenêtres (WM) qui a pour rôle d’en effectuer le routage correct vers les couches supérieures. Cours JAVA / Y.Laborde

Dans une optique Orientée Objet, le langage Java intègre aujourd’hui une JVM masquant presque totalement le WM sur lequel il s’appuie. Pour réaliser cela, tous les événements du WM sont systématiquement encapsulés par la JMV. De plus, la JVM, possédant également des composants qui lui sont propres, peut fabriquer des nouveaux événements non issus du WM. Les événements encapsulés par la JVM se présentent donc aux applications Java comme de véritables objets Java. Une application dite 100% pure Java est telle que ses aspects visuels et comportementaux (look and feel) ne dépendent que de la JVM et en aucun cas du WM (on pourrait même changer dynamiquement de look and feel pendant l’exécution si cela présentait un intérêt !). En pratique, on peut croire l’inverse car Java conserve par défaut l’aspect du système hôte auquel l’utilisateur est habitué ; si bien que le look Java n’existe pas vraiment. Il est à remarquer que ces aspects ne sont pas totalement nouveaux puisque déjà proposés par les concepteurs du langage Smalltalk depuis les années 80 (qui reste une référence en matière de LOO et d’IHM). Malgré tout, Java est un langage objet moderne typé très convainquant par sa spécification, son intégration au système, sa portabilité, son intégrabilité et son évolutivité. Cours JAVA / Y.Laborde

Applicatif standard en C WM dessin click Evénement Click sur le bouton (FONCTION en C) action Traite-ment SE Code C Applicatif JAVA dessin JVM WM Tous les événements du WM sont systématiquement encapsulés par la JMV. Les applicatifs Java reçoivent des objets Java. click Evénement Click sur le bouton (OBJET JAVA) Evénement Click sur le bouton (FONCTION en C) action Traite-ment SE Code Java Cours JAVA / Y.Laborde

Conteneurs de composants
Java : AWT / le package java.awt abstract Component Button Checkbox Choice List TextComponent TextArea TextField Canvas Composants simples Label FlowLayout BorderLayout GridLayout CardLayout GrisBagLayout Gestionnaires de mise en forme Panel Window ScrollPane Dialog Frame Conteneurs de composants Container Object abstract Toolkit … MenuComponent MenuBar MenuItem Menu CheckboxMenuItem PopupMenu Menus Les quatre principaux sous-groupes du package java.awt Cours JAVA / Y.Laborde

Les composants graphiques
Java : AWT / le package java.awt Les composants graphiques Les composants simples sont les formes visibles d’une application. Ils comprennent d’une part les labels, les boutons, les cases à cocher, les boutons de choix, les listes et les zones de texte et d’autre part les canvas. Tous dérivent de la classe Component dont ils tirent leurs propriétés de base. public abstract class java.awt.Component extends Object implements ImageObserver, MenuContainer, Serializable Un composant est un objet ayant une représentation graphique pouvant être dessinée à l’écran et capable d’interagir avec l’utilisateur. Cependant, la classe Component n’est pas instanciable. Par contre, elle peut être dérivée pour former un "composant léger" (i.e. qui n’est pas associé à une fenêtre native opaque). Cela est à différencier du composant Canvas utilisé par une application pour dessiner de sa propre manière. En effet, un canvas possède une représentation graphique minimale consistant à rafraîchir son fond (de couleur blanche). abstract Object Component … Cours JAVA / Y.Laborde

public abstract class java.awt.Component extends Object
implements ImageObserver, MenuContainer, Serializable CONSTRUCTEURS : protected Component () PRINCIPALES METHODES : String toString () void setVisible (boolean b) void setEnabled (boolean b) String getName () void setName (String name) Dimension getSize () void setSize (int width, int height) Dimension getMinimumSize () void setBackground (Color c) Dimension getMaximumSize () void setForeground (Color c) Font getFont () void setFont(Font f) Graphics getGraphics () void paint (Graphics g) void repaint () void repaint (int x, int y, int width, int height) void addKeyListener (KeyListener l) void addFocusListener (FocusListener l) void addMouseListener (MouseListener l) void addMouseMotionListener (MouseMotionListener l) void addComponentListener (ComponentListener l) Cours JAVA / Y.Laborde

Les conteneurs de composants
Java : AWT / le package java.awt Les conteneurs de composants public class java.awt.Container extends Component (implements ImageObserver, MenuContainer, Serializable) Les conteneurs sont des composants capables de contenir d’autres composants et d’effectuer sur cet ensemble des opérations complexes comme le placement des composants les uns par rapport aux autres, leurs re-dimensionnements, etc. Les références aux composants ajoutés sont placés dans une liste. Si aucun index n’est spécifié au moment de l’ajout, le composant est ajouté à la fin de la liste. Bien qu’instanciable, cette classe ne l’est généralement pas.Elle est plus considérée comme une classe générique dont les fenêtres applicatives, les boîtes de dialogue, etc…tirent leurs propriétés de base. abstract Object Component Container Cours JAVA / Y.Laborde

public class java.awt.Container extends Component
implements ImageObserver, MenuContainer, Serializable CONSTRUCTEURS : Container () PRINCIPALES METHODES : Component add (Component comp) void add (Component comp, Object constraints) Component add (Component comp, int index) void add (Component comp, Object constraints, int index) void add ContainerListener(ContainerListener l) void remove (Component comp) void remove (int index) void setLayout (LayoutManager mgr) void doLayout () Dimension getPreferredSize () void paintComponents (Graphics g) void print (Graphics g) Cours JAVA / Y.Laborde

Java : AWT / le package java.awt
Le conteneur Frame public class java.awt.Frame extends Window implements MenuContainer (, Accessible, ImageObserver, MenuContainer, Serializable) C’est le conteneur de base de toute application autonome (stand alone) puisqu’il représente une fenêtre applicative (top level window) avec au minimum un encadrement et une barre de titre. Les Frame ont une représentation héritée du système (ou du WM) sur lequel l’application « tourne ». En particulier leur barre de titre contient les boutons d’accès au menu système ainsi que ceux de minimisation ou de maximisation. Les Frame sont ainsi capables de générer les types suivants d’événement : WindowOpened, WindowClosing, WindowClosed, WindowIconified, WindowDeiconified, WindowActivated, WindowDeactivated. En fin de construction, les Frame restent invisibles. Ce sont les seules fenêtres qui peuvent contenir une barre de menus. abstract Object Component Container Window Frame Cours JAVA / Y.Laborde

public class java.awt.Frame extends Window
implements MenuContainer (, Accessible, ImageObserver, MenuContainer, Serializable) PRINCIPAUX CONSTRUCTEURS : Frame () Frame (String title) PRINCIPALES METHODES : String getTitle () void setTitle (String title) boolean isResizable () void setResizable (boolean resizable) int getState () void setState (int state) MenuBar getMenuBar () void setMenuBar (MenuBar mb) Image getIconImage () void setIconImage (Image image) Cours JAVA / Y.Laborde

Le conteneur Dialog public class java.awt.Dialog extends Window (implements Accessible, ImageObserver, MenuContainer, Serializable) Les boîtes de dialogues représentent des fenêtres permettant de recevoir des données en provenance de l’utilisateur. Elles sont utilisées pour : configurer l’applicatif, informer l’utilisateur sur l’état de l’applicatif, saisir des données. Les boîtes de dialogues peuvent être : modales (modal), i.e. bloquantes vis-à-vis de la fenêtre mère. Il faudra refermer le dialogue (pop up) pour réactiver les composants de la fenêtre mère, non modales, i.e. leur exécution est simultanée avec la fenêtre parente. La fenêtre mère doit toujours être une fenêtre Frame si bien qu’un dialogue sera toujours fermé ou minimisé parallèlement à sa Frame. En fin de construction, les Dialog restent invisibles. Les Dialog sont capables de générer les mêmes types d’événement que les Frame : WindowOpened, WindowClosing, WindowClosed, WindowIconified, WindowDeiconified, WindowActivated, WindowDeactivated. abstract Object Component Container Window Dialog Cours JAVA / Y.Laborde

public class java.awt.Dialog extends Window
(implements Accessible,ImageObserver, MenuContainer, Serializable) CONSTRUCTEURS : Dialog (Dialog owner) Dialog (Dialog owner, String title) Dialog (Dialog owner, String title, boolean modal) Dialog (Frame owner) Dialog (Frame owner, String title) Dialog (Frame owner, String title, boolean modal) Dialog (Frame owner, boolean modal) PRINCIPALES METHODES : void show () void hide () String getTitle () void setTitle (String title) boolean isResizable () void setResizable (boolean resizable) boolean isModal () void setModal (boolean b Cours JAVA / Y.Laborde

Le conteneur Window public class java.awt.Window extends Container implements Accessible (, ImageObserver, MenuContainer, Serializable) Ce conteneur représente une classe de base pour les fenêtres autonomes (top level window). Il ne définit ni encadrement, ni menu pour la fenêtre si bien qu’il peut être utilisé pour des fenêtres spéciales telles que les menus contextuels. Suivant les systèmes, les fenêtres Window actives prennent toujours le focus vis-à-vis des autres applications — i.e. elles s’approprient les entrées en provenance du clavier. Une Window doit toujours être construite à l’aide d’une fenêtre Frame, d’un Dialog ou d’une autre Window. En fin de construction, les Window restent invisibles. Les Window ne sont capables de générer que les types suivants d’événement : WindowOpened, WindowClosed. abstract Object Component Container Window Cours JAVA / Y.Laborde

public class java.awt.Window extends Container
implements Accessible (, ImageObserver, MenuContainer, Serializable) PRINCIPAUX CONSTRUCTEURS : Window (Frame owner) Window (Window owner) PRINCIPALES METHODES : void show () void hide () void dispose () void toFront () void toBack () boolean isShowing () void pack () void setCursor (Cursor cursor) Window getOwner () Window[] getOwnedWindows () void addWindowListener (WindowListener l) void removeWindowListener (WindowListener l) void setVisible(boolean b) Cours JAVA / Y.Laborde

Le conteneur ScrollPane
Java : AWT / le package java.awt Le conteneur ScrollPane public class java.awt.ScrollPane extends Container implements Accessible (, ImageObserver, MenuContainer, Serializable) Ce conteneur permet de prendre en charge le défilement (scrolling) à l’intérieur d’un (et d’un seul) composant attaché. Les opérations de défilement sont alors reliées au composant attaché. Les barres de défilement peuvent être soit : vues au besoin, toujours vues ou jamais vues. Elles implémentent l’interface Ajustable permettant de manipuler les attributs du défilement comme l’unité de défilement, la position, etc. Leur taille initiale est de 100x100 pixels, mais ils peuvent être redimensionnés à l’aide de la méthode setSize(). Leur dimension est accessible à l’aide de la méthode getInsets() qui fournit l’espace utilisé par les bordures ainsi que les scrollbars lorsqu’elles sont présentes. Lorsque les scrollbars sont définies jamais vues, le défilement peut être réalisé par programmation. Un ScrollPane est visible dès que le conteneur qui le contient le devient (à moins d’avoir explicitement été rendu invisible). abstract Object Component Container ScrollPane Cours JAVA / Y.Laborde

public class java.awt.ScrollPane extends Container
implements Accessible (, ImageObserver, MenuContainer, Serializable) CONSTRUCTEURS : ScrollPane () ScrollPane (int scrollbarDisplayPolicy) PRINCIPALES METHODES : protected void addImpl (Component comp, Object constraints, int index) Point getScrollPosition () void setScrollPosition (int x, int y) void setScrollPosition (Point p) int getScrollbarDisplayPolicy () Dimension getViewportSize () void doLayout () Adjustable getHAdjustable () Adjustable getVAdjustable () int getHScrollbarHeight () int getVScrollbarWidth () Cours JAVA / Y.Laborde

Le conteneur Panel public class java.awt.Panel extends Container implements Accessible (, ImageObserver, MenuContainer, Serializable) Cette classe permet d’instancier le plus simple des conteneurs — i.e. une fenêtre ne disposant ni d’encadrement, ni de barre de titre, ni de menu ... mais permettant de contenir d’autres composants ou conteneurs. La classe Panel : est très utile pour gérer l’imbrication de multiples composants et conteneurs dans une fenêtre (ou une portion de fenêtre par imbrication de plusieurs Panels), est la classe de base des Applets (toute Applet est une sorte de Panel). Par défaut, un Panel n’offre pas de représentation à l’écran et est souvent utilisé tel quel. Il est toutefois possible de lui faire dessiner son fond d’une certaine couleur. Son gestionnaire de mise en forme par défaut est le FlowLayout. Un Panel est visible dès que le conteneur qui le contient le devient (à moins d’avoir explicitement été rendu invisible). Lorsqu’un Panel est visible, il rend visible tous les composants qu’il contient. abstract Object Component Container Panel Cours JAVA / Y.Laborde

public class java.awt.Panel extends Container
implements Accessible (, ImageObserver, MenuContainer, Serializable) CONSTRUCTEURS : Panel () Panel (LayoutManager layout) Cours JAVA / Y.Laborde

Les gestionnaires de mise en forme
Java : AWT / le package java.awt Les gestionnaires de mise en forme Les gestionnaires de mise en forme (layout manager) sont des objets associés à des conteneurs et qui se chargent de gérer la taille et la disposition relative des composants appartenant aux conteneurs. Prenons l’exemple de la fenêtre ci-dessous : Ses sept composants doivent être positionnés et dimensionnés dans l’espace du Panel. Or, ces opérations deviennent vite très complexes dès lors que le nombre de composants augmente, que leur taille est variée ou que la fenêtre est redimensionnable ! Ce sont justement ces deux aspects que les gestionnaires de mise en forme nous permettent d’automatiser ! Cours JAVA / Y.Laborde

Le gestionnaire de mise en forme FlowLayout
Java : Les gestionnaires de mise en forme Le gestionnaire de mise en forme FlowLayout (gestionnaire par défaut) public class java.awt.FlowLayout extends Object implements LayoutManager , Serializable Ce LayoutManager arrange et dimensionne ses composants à la manière d’un texte — i.e. de gauche à droite sur une ligne avec passage à la ligne suivante s’il y a lieu. Il est typiquement utilisé pour placer des boutons dans un Panel. Il laisse toujours les composants à leur taille préférée (pour un bouton, elle est proportionnelle à la largeur de son texte). C’est le gestionnaire par défaut des conteneurs. Il n’y a donc normalement pas besoin de l’instancier sauf si l’on désire en modifier le paramétrage. Object FlowLayout CONSTRUCTEURS : FlowLayout () FlowLayout (int align) FlowLayout (int align, int hgap, int vgap) VARIABLES de CLASSE : (public static final) int LEFT, CENTER, RIGHT, LEADING, TRAILING Les variables de classes sont utiles pour fixer les paramètres (int align) des constructeurs. Cours JAVA / Y.Laborde

Java : Le LayoutManager FlowLayout
EXEMPLE : import java.awt.Button; public class MyThreeButtonsPanel extends Panel { public MyThreeButtonsPanel () { this.setLayout (new FlowLayout (FlowLayout.CENTER,4,4)); Button b = new Button ("Ok"); this.add (b); b = new Button ("Open"); b = new Button ("Close"); } Close Open Ok Cours JAVA / Y.Laborde

Le gestionnaire de mise en forme BorderLayout
Java : Les gestionnaires de mise en forme Le gestionnaire de mise en forme BorderLayout public class java.awt.BorderLayout extends Object implements LayoutManager2 , Serializable Ce LayoutManager arrange et dimensionne ses composants relativement à un maximum de cinq régions repérées par les quatre directions cardinales plus le centre. Il est utilisé dans de très nombreux cas car il permet de nombreuses configurations du fait que l’on peut utiliser ou non toutes les régions. Il ajuste la taille des composants à celles des régions dans lesquelles ils sont insérés La région du centre est toujours la plus importante (dans un rapport de 1/3 à 1/2 des autres régions) si elle est présente ; les régions des bords se partagent le reste de la surface mais elles peuvent également être disproportionnées entre elles dans le cas où tous les composants d’une région sont de faibles dimensions préférées. Lors de l’ajout d’un composant dans un conteneur, il faut préciser la région désirée. Object BorderLayout CONSTRUCTEURS : BorderLayout () BorderLayout (int hgap, int vgap) VARIABLES de CLASSE : (public static final) int NORTH, SOUTH, EAST, WEST, CENTER String AFTER_LAST_LINE, AFTER_LINE_ENDS, BEFORE_FIRST_LINE, BEFORE_LINE_BEGINS Cours JAVA / Y.Laborde

Java : Le LayoutManager FlowLayout
EXEMPLE : import java.awt.Button; public class MyFourButtonsPanel extends Panel { public MyFourButtonsPanel () { this.setLayout (new BorderLayout (4,4)); Button b = new Button ("North"); this.add (b, BorderLayout.NORTH ); b = new Button ("East"); this.add (b, BorderLayout.EAST ); b = new Button ("Center"); this.add (b, BorderLayout.CENTER ); b = new Button ("West"); this.add (b, BorderLayout.West ); } North Center West East Cours JAVA / Y.Laborde

Le gestionnaire de mise en forme GridLayout
Java : Les gestionnaires de mise en forme Le gestionnaire de mise en forme GridLayout public class java.awt.GridLayout extends Object implements LayoutManager , Serializable Ce LayoutManager arrange et dimensionne ses composants relativement à une grille 2D rectangulaire de dimensions variables à la construction (nombre de lignes et de colonnes). Il divise ainsi l’espace du conteneur en rectangles de tailles égales (largeur, hauteur). Par ailleurs, à chaque rectangle de la grille peut être associé un composant ou un nouveau conteneur. L’ordre d’ajout ne peut pas être précisé à l’aide des constructeurs. Le GridLayout procède à un ajout par lignes (de gauche à droite en commençant par de haut puis en descendant). Object GridLayout CONSTRUCTEURS : GridLayout () GridLayout (int rows, int cols) GridLayout (int rows, int cols, int hgap, int vgap) Cours JAVA / Y.Laborde

Java : Le LayoutManager GridLayout
EXEMPLE : import java.awt.Button; public class MySixButtonsPanel extends Panel { public MySixButtonsPanel () { this.setLayout (new GridLayout (3,2,4,4)); this.add (new Button ("1")); this.add (new Button ("2")); this.add (new Button ("3")); this.add (new Button ("4")); this.add (new Button ("5")); this.add (new Button ("6")); } 1 2 3 4 5 6 Cours JAVA / Y.Laborde

Le gestionnaire de mise en forme CardLayout
Java : Les gestionnaires de mise en forme Le gestionnaire de mise en forme CardLayout public class java.awt.CardLayout extends Object implements LayoutManager2 , Serializable Ce LayoutManager arrange et dimensionne ses composants comme des fiches superposées et de même dimension. Une seule fiche est visible à la fois ; elles sont organisées les unes sur les autres comme une pile de documents. Il n(y a pas d’onglet de sélection mais le CardLayout définit un ensemble de méthodes permettant soit d’accéder séquentiellement aux fiches, soit d’accéder à une fiche spécifique. Pour un accès facilité, il est possible d’associer un identifiant de type String à chaque fiche. Object CardLayout CONSTRUCTEURS : CardLayout () CardLayout (int hgap, int vgap) METHODES : void addLayoutComponent (String name, Component comp) void addLayoutComponent (Component comp, Object constraints) void first (Container parent) void last (Container parent) void previous (Container parent) void next (Container parent) void show (Container parent, String name) Cours JAVA / Y.Laborde

Le gestionnaire de mise en forme GridBagLayout
Java : Les gestionnaires de mise en forme Le gestionnaire de mise en forme GridBagLayout public class java.awt.GridBagLayout extends Object implements LayoutManager2 , Serializable Ce LayoutManager arrange et dimensionne ses composants horizontalement et verticalement comme un GridLayout mais sans qu’il soit nécessaire qu’ils aient la même taille… Un composant peut donc occuper plusieurs cases de la grille. Il permet des configurations complexes de placement des composants mais sa complexité le rend difficile d’utilisation. Il fonctionne en association avec une instance de GridBagConstraints à redéfinir pour chaque composant et qui spécifie comment le composant est doit être placé dans la grille. Lorsque le GridBagLayout arrive en fin de ligne ou qu’un composant est trop long pour être placé en fin de ligne, les contraintes définies dans le GridBagConstraints précisent comment il doit être traité. Il est également possible d’imposer qu’un composant soit ou non le dernier de la ligne, qu’il occupe un espace variable en fonction de la place restante, etc. Object GridBagLayout CONSTRUCTEURS : GridBagLayout () VARAIBLES de CLASSES et METHODES : (voir la documentation du JDK) Cours JAVA / Y.Laborde

Java : Les gestionnaires de mise en forme
Panel de l’applicatif de classe MonAppliPanel Ces 3 boutons devront être placés dans un Panel (pN) de type GridLayout La zone de texte et les Panels pN et pE devront être placés dans un Panel (pBL) de type BorderLayout Bouton 1 Bouton 2 Bouton 3 Ces 3 boutons de choix devront être placés dans un Panel (pG) de type GridLayout ; lui-même placé au Nord d’un Panel (pE) de type BorderLayout. Zone de texte  Check 1  Check 2  Check 3 Exercice: écrivez le code permettant de modéliser cet IHM dans une classe MonAppliPanel Cours JAVA / Y.Laborde

Classe construisant l’application en tant que fenêtre Frame
Java: Création d’une application Java avec Frame (1) import java.awt.*; // La fenêtre Frame applicative class MyFrame extends Frame { static public void main(String[] args) { new MyFrame("Mon application"); } public MyFrame(String titre) { super(titre); this.initIHM(); this.setSize(500, 500); this.setForeground(Color.yellow); this.setFont(new Font("SansSerif" , Font.PLAIN | Font.BOLD, 14)); this.addWindowListener (new MyFrameAdapter()); this.setVisible(true); void initIHM() { // Ici, créer l’IHM // dans le panel de la frame ... Classe construisant l’application en tant que fenêtre Frame Une méthode main() permet de construire la Frame. En général, il n’est pas utile de conserver une référence sur l’objet Frame. Classe capable de recevoir les événements Window qui permettront de fermer la fenêtre Frame import java.awt.event.*; // Réception des événements de type Window // pour la fenêtre Frame de l'application class MyFrameAdapter extends WindowAdapter { public void windowClosing (WindowEvent e) { // Termine l’application (ferme la Frame) System.exit(0); } Cours JAVA / Y.Laborde

Evénements spécifiques à l’AWT Toutes ces classes sont
Java : AWT / le package java.awt.event ActionEvent ItemEvent TextEvent InputMethodEvent ComponentEvent FocusEvent InputEvent … Evénements spécifiques à l’AWT PaintEvent WindowtEvent KeyEvent MouseEvent abstract FocusAdapter KeyAdapter MouseAdapter MouseMotionAdapter WindowAdapter Adaptateurs Toutes ces classes sont Abstract … CLASSES Les classes *Adapter implémentent les interfaces *Listener correspondantes Object AWTEvent EventObject abstract INTERFACES ActionListener FocusListener InputMethodListener KeyListener ItemListener Interfaces AWT EventListener MouseListener MouseMotionListener TextListener WindowListener … Les trois principaux sous-groupes du package java.awt.event Cours JAVA / Y.Laborde

Java : AWT / le package java.awt.event
Lorsqu’un utilisateur interagit avec un composant, la JVM génère puis achemine un événement en correspondance avec le type d’interaction. Exemples, pour un composant de type : - BOUTON, l’utilisateur peut l’actionner (click sur sa surface puis relâchement) - TEXTE, l’utilisateur peut modifier le texte - LISTE, l’utilisateur peut sélectionner ou désélectionner un item Mais aussi, pour tous les composants (et conteneurs), de multiples autres événements peuvent être générés, exemples par rapport à : - la SOURIS, déplacement de la souris, bouton appuyé ou relâché, curseur entrant ou sortant du composant - le CLAVIER, touche appuyée ou relâchée, touche tapée - le FOCUS, obtention du focus ou perte du focus Ce sont les classes notées « Evénements spécifiques à l’AWT » qui permettent la CONSTRUCTION de tels événements (et c’est la JVM qui s’en occupe toute seule !). Mais, en Java, pour qu’un événement puisse être généré puis acheminé vers le programme, il faut que le programmeur en ait fait la demande explicite !!! Ce sont les interfaces notées « Interfaces AWT » ainsi que les classes notées « Adaptateurs » qui permettent l’ACHEMINEMENT des événements (et c’est au programmeur de les dériver ou de les implémenter !). Cours JAVA / Y.Laborde

Par rapport à la CONSTRUCTION des événements : 1) Tous les événements de l’AWT dérivent de deux classes : EventObject est une classe générique qui possède pour méthode principale : - public Object getSource() permettant de récupérer la référence à l’objet d’où l’événement provient initialement. Cette référence pourra être castée sur un type plus précis de composant comme un Button. AWTEvent est une classe générique qui possède pour méthode principale : - public String paramString() permettant de récupérer un String représentant l’état de l’événement C’est une méthode normalement destinée au déboggage. 2) Chaque classe d’événement (*Event) possède ses propres méthodes : ActionEvent : - public String getActionCommand() permettant de récupérer un nom décrivant la commande à effectuer. En résumé, il faut retenir la méthode getSource() ainsi que les méthodes propres à chaque classes *Event comme getActionCommand(). public void ??? (ActionEvent e) { if (e.getSource().equals(MonBouton) ) ... } public void ??? (ActionEvent e) { if (e.getActionCommand().equals(“Ma commande”) ) ... } Cours JAVA / Y.Laborde

Par rapport à l’ACHEMINEMENT des événements : 1) Les interfaces *Listener définissent les méthodes que le programme recevra pour traiter les événements : ActionListener est une interface qui définit une méthode pour déclencher l’action liée à un BOUTON : - public void actionPerformed(ActionEvent e) est la méthode qui sera invoquée par la JVM à chaque fois qu’un utilisateur déclenchera l’action relative à un bouton. ItemListener est une interface qui définit une méthode liée à la sélection d’un ITEM de LISTE : - public void itemStateChanged(ItemEvent e) est la méthode qui sera invoquée par la JVM à chaque fois qu’un utilisateur sélectionnera ou désélectionnera un item d’une liste. WindowListener est une interface qui définit SEPT méthodes liées à des événements concernant des fenêtres : public void windowOpened(WindowEvent e) public void windowClosing(WindowEvent e) public void windowClosed(WindowEvent e) public void windowIconified(WindowEvent e) public void windowDeiconified(WindowEvent e) public void windowActivated(WindowEvent e) public void windowDeactivated(WindowEvent e) 2) Les classes *Adapter fournissent un moyen pour simplifier la création de classes qui doivent implémenter des *Listener (contenant de nombreuses méthodes) : WindowAdapter est une classe qui implémente l’interface WindowListener et qui fournit les 7 méthodes de cette interface avec un corps vide ! Elle pourra être dérivée puis il suffira de donner un corps à la ou les méthodes utiles ; les autres pourront rester vides (VOIR TRANSPARENT #30). En résumé, il faut retenir les méthodes des principaux *Listener comme actionPerformed(). public void actionPerformed(ActionEvent e) { if (e.getSource().equals(MonBouton) ) // ... Écrire ici le code correspondant à l’action sur le bouton ‘MonBouton’ } Cours JAVA / Y.Laborde

Java : AWT / liens entre applicatif et composants actifs
Si les événements (*Event) sont automatiquement générés par la JVM, ils ne seront transmis à l’applicatif que lorsqu’ils auront été LIES à des méthodes spécifiques. Ces méthodes sont celles définies dans les *Listener ou les *Adapter. La liaison à définir consiste à rendre un composant actif en lui associant un objet « écouteur d’événement » (d’où l’appellation « Listener »). Rq: l’autre appellation, « Adapter », est similaire à celle de « Listener » puisque les *Adapter sont des sortes de *Listener de part leur relation d’implémentation. Les *Adapter sont des classes prêtes à être dérivées et pouvant être observées uniquement au travers de leur nature de *Listener. La manière de définir un Listener est commune à tous les composants mais il n’est pas permis de définir n’importe quel Listener pour n’importe quel composant (par ex: un ItemListener ne peut être associé à un bouton mais une liste peut accepter aussi bien un ActionListener qu’un ItemListener). En résumé, pour lier un listener à un composant, il faut invoquer une méthode appartenant au composant et dont le type général est : public void add*Listener (*Listener l) où l’étoile (*) doit être remplacée par le nom spécifique du type d’événement concernant le composant, comme par exemple Action, Item ou Window. Cours JAVA / Y.Laborde

Java : AWT / liens applicatif/composants actifs (exemple 1)
import java.awt.*; import java.awt.event.*; // La fenêtre Frame applicative class MyFrame extends Frame implements ActionListener { Button[2] mesBoutons; public MyFrame(String titre) { ... this.addWindowListener(new MyFrameAdapter()); this.setVisible(true); } void initIHM() { mesBoutons[0] = new Button(“Annuler”); mesBoutons[0].addActionListener(this); this.add(mesBoutons[0]); mesBoutons[1] = new Button(“OK”); mesBoutons[1].addActionListener(this); this.add(mesBoutons[1]); public void actionPerformed(ActionEvent e) { if (e.getSource().equals(mesBoutons[0]) ) // Écrire l’action du bouton ‘Annuler’ else if (e.getSource().equals(mesBoutons[1]) ) // Écrire l’action du bouton ‘OK’ } } Classe construisant la Frame applicative avec 2 boutons « Annuler » et « OK » et servant également de LISTENER pour les 2 boutons. L’événement correspondant aux demandes d’actions des boutons est reçu dans la même méthode (actionPerformed(…)). Le code commence donc par s’informer de quelle bouton provient la demande d’action. Classe définie comme LISTENER des événements Window de la Frame. Elle étend WindowAdapter, elle-même implémentant WindowListener. Cette classe redéfinit seulement la méthode windowClosing(…) car les autres ne l’intéressent pas. un LISTENER import java.awt.event.*; // Réception des événements de type Window // pour la fenêtre Frame de l'application class MyFrameAdapter extends WindowAdapter { public void windowClosing (WindowEvent e) { // Termine l’application (ferme la Frame) System.exit(0); } un LISTENER Cours JAVA / Y.Laborde

import java.awt.*; import java.awt.event.*; // La fenêtre Frame applicative class MyFrame extends Frame implements ActionListener { public MyFrame(String titre) { ... this.setVisible(true); } void initIHM() { Button b = new Button(“Annuler”); b.setActionCommand(“ANN”); b.addActionListener(this); this.add(b); b = new Button(“OK”); b.setActionCommand(“OK”); public void actionPerformed(ActionEvent e) { if (e.getActionCommand().equals(“ANN”) ) // Écrire l’action du bouton ‘Annuler’ else if (e.getActionCommand().equals(“OK”)) // Écrire l’action du bouton ‘OK’ } } Ici, on a utilisé le couple : void <aButton>.setActionCommand(…) et String <anActionEvent>.getActionCommand() plutôt que : Object <anActionEvent>.getSource() Cela a permis de ne pas conserver les références sur les objets Button. Rq: un même bouton pourrait alors faire varier son action en modifiant son actionCommand. Cela peut être utile dans les cas où l’action d’un bouton dépend d’actions antérieures par exemple. Cours JAVA / Y.Laborde

import java.awt.*; // La fenêtre Frame applicative class MyFrame extends Frame { public MyFrame(String titre) { ... this.setVisible(true); } void initIHM() { ActionListener actLst = new MyButtonsAdapter(); Button b = new Button(“Annuler”); b.setActionCommand(“ANN”); b.addActionListener(actLst); this.add(b); b = new Button(“OK”); b.setActionCommand(“OK”); import java.awt.event.*; // Une classe Adapter à part pour les 2 boutons class MyButtonsAdapter implements ActionListener { public void actionPerformed(ActionEvent e) { if (e.getActionCommand().equals(“ANN”) ) // Écrire l’action du bouton ‘Annuler’ else if (e.getActionCommand().equals(“OK”)) // Écrire l’action du bouton ‘OK’ } Avec le couple : void <aButton>.setActionCommand(…) et String <anActionEvent>.getActionCommand() Cela est utile lorsque l’on désire que le LISTENER des boutons soit une classe à part. Celui-ci n’a alors pas à connaître les références sur les boutons dont il gère les actions. Cours JAVA / Y.Laborde

import java.awt.*; // La fenêtre Frame applicative class MyFrame extends Frame { public MyFrame(String titre) { ... this.setVisible(true); } void initIHM() { Button b; b = new MyButton(“Annuler”,“ANN”); this.add(b); b = new MyButton(“OK”,“OK”); import java.awt.Button; import java.awt.event.*; // La classe Button est dérivée pour être son propre Adapter class MyButton extends Button implements ActionListener { public MyButton(String caption , String actCom) { super(caption); this.setActionCommand(actCom); this.addActionListener(this); } public void actionPerformed(ActionEvent e) { if (e.getActionCommand().equals(“ANN”) ) // Écrire l’action du bouton ‘Annuler’ else if (e.getActionCommand().equals(“OK”)) // Écrire l’action du bouton ‘OK’ Avec le couple : void <aButton>.setActionCommand(…) et String <anActionEvent>.getActionCommand() En dérivant la classe Button, on peut également en faire un LISTENER commun à tous les boutons. Celui-ci n’a alors pas à connaître les références sur les boutons dont il gère les actions. Cours JAVA / Y.Laborde

Java : AWT / Une calculatrice
Exercice: écrivez le code permettant de modéliser une calculatrice simple. Vous réaliserez l’IHM sans menu et en groupant les LISTENER des boutons par catégories : groupe des boutons numériques ( 0 à 9, +/-, . ) groupe des boutons de mémoires ( MC, MR, MS, M+ ) groupe des boutons d’opérations binaires ( /, *, -, + ) groupe des boutons d’opérations unaires ( Rac, %, 1/x, = ) groupe des boutons de commandes ( Retour arrière, CE, C ) Cours JAVA / Y.Laborde

Java : Interface Homme-Machine

Présentations similaires

Présentation au sujet: "Java : Interface Homme-Machine"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Java : Interface Homme-Machine

Présentations similaires

Présentation au sujet: "Java : Interface Homme-Machine"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back