1 Cours JAVA / Y.Laborde Java : Interface Homme-Machine LES CONCEPTS de LIHM : Introduction LAWT...

Cours JAVA / Y.Laborde

1Java : 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


2Java : 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.


3Java : IHM / Introduction

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


4

ApplicatifJAVA JVM

Applicatifstandard en C WM

Java : IHM / Introduction

SE

Jouer

click

EvénementClick sur le bouton

(FONCTION en C)

WM

SE

Jouer

click

EvénementClick sur le bouton

(FONCTION en C)

Evénement Click sur le bouton

(OBJET JAVA)

Tous les événements du

WM sont systématiquement encapsulés par la

JMV.

Les applicatifs Java reçoivent desobjets Java.

Code C

Code Java

dessin

dessin

action

action

Traite-ment

Traite-ment


5Java : AWT / le package java.awt

Object

FlowLayout

BorderLayout

GridLayout

CardLayout

GrisBagLayout

Gestionnaires de

mise en forme

abstract

Toolkit

abstract

…

MenuComponent

MenuBar

MenuItem

Menu

CheckboxMenuItem

PopupMenu

Menus

…

Les quatre principaux

sous-groupesdu package

java.awt

abstract

Component

Button

Checkbox

Choice

List

TextComponent

TextArea

TextField

Canvas

Composants

simples

Label

Panel

Window

ScrollPane

Dialog

Frame

Conteneurs de composants

Container



Les composants graphiquesLes 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

…


7

CONSTRUCTEURS :protected Component ()

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)

PRINCIPALES METHODES :

public abstract class java.awt.Component extends Object




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


9

CONSTRUCTEURS :Container ()

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)


public class java.awt.Container extends Component




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


11

PRINCIPAUX CONSTRUCTEURS :Frame () Frame (String title)

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)


public class java.awt.Frame extends Windowimplements MenuContainer (, Accessible, ImageObserver, MenuContainer, Serializable)



Le conteneur Dialogpublic 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


13

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)

void show () void hide ()

String getTitle () void setTitle (String title)

boolean isResizable () void setResizable (boolean resizable)

boolean isModal () void setModal (boolean b


public class java.awt.Dialog extends Window(implements Accessible,ImageObserver, MenuContainer, Serializable)



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


15

PRINCIPAUX CONSTRUCTEURS :Window (Frame owner)

Window (Window owner)

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)


public class java.awt.Window extends Containerimplements Accessible (, ImageObserver, MenuContainer, Serializable)



Le conteneur ScrollPane

public class java.awt.ScrollPane extends Container


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


17

CONSTRUCTEURS :ScrollPane () ScrollPane (int scrollbarDisplayPolicy)

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


public class java.awt.ScrollPane extends Containerimplements Accessible (, ImageObserver, MenuContainer, Serializable)



Le conteneur Panelpublic class java.awt.Panel extends Container


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


19

CONSTRUCTEURS :Panel () Panel (LayoutManager layout)

public class java.awt.Panel extends Containerimplements Accessible (, ImageObserver, MenuContainer, Serializable)



Les gestionnaires de mise en forme

Bouton 1 Bouton 2 Mon bouton 3

Label 1

Label 2

Label 3

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 !


21Java : Les gestionnaires de mise en forme

Le gestionnaire de mise en forme FlowLayoutpublic class java.awt.FlowLayout extends Object

implements LayoutManager , SerializableCe 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

(gestionnaire

par défaut)

CONSTRUCTEURS :FlowLayout () FlowLayout (int align) FlowLayout (int align, int hgap, int vgap)

VARIABLES de CLASSE : (public static final)

int LEFT, CENTER, RIGHT, LEADING, TRAILINGLes variables de classes sont utiles pour fixer les

paramètres (int align) des constructeurs.


22Java : Le LayoutManager FlowLayout

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");this.add (b);

b = new Button ("Close");this.add (b);

} }

CloseOpenOk

EXEMPLE :



Le gestionnaire de mise en forme BorderLayoutpublic class java.awt.BorderLayout extends Object

implements LayoutManager2 , SerializableCe 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


24Java : Le LayoutManager FlowLayout


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

} }

EXEMPLE :

North

CenterWest East



Le gestionnaire de mise en forme GridLayoutpublic class java.awt.GridLayout extends Object

implements LayoutManager , SerializableCe 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)


26Java : Le LayoutManager GridLayout


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

} }

EXEMPLE :

1 2

3 4

5 6



Le gestionnaire de mise en forme CardLayoutpublic class java.awt.CardLayout extends Object

implements LayoutManager2 , SerializableCe 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)



Le gestionnaire de mise en forme GridBagLayoutpublic class java.awt.GridBagLayout extends Object

implements LayoutManager2 , SerializableCe 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)


29

Bouton 1 Bouton 2 Mon bouton 3

Label 1

Label 2

Label 3

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

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.

Java : Les gestionnaires de mise en forme

Exercice: écrivez le code permettant de modéliser cet IHM dans une classe MonAppliPanel

Panel de l’applicatif de classe MonAppliPanel


30Java: 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

...

}

}

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

}

}

Classe construisant l’application en tant que fenêtre Frame

Classe capable de recevoir les événements Window qui permettront de fermer la 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.


31

Les classes *Adapterimplémentent les interfaces *Listener correspondantes

Java : AWT / le package java.awt.event

Les trois principaux sous-groupes du package java.awt.event

FocusAdapter

KeyAdapter

MouseAdapter

MouseMotionAdapter

WindowAdapter

Adaptateurs

Toutes ces

classes sont

Abstract

…

Object

AWTEventEventObject

abstract

ActionEvent

ItemEvent

TextEvent

InputMethodEvent

ComponentEvent

FocusEvent

InputEvent…

Evénementsspécifiques

à l’AWT

PaintEvent

WindowtEventKeyEvent

MouseEventabstract

…

INTERFACES

CLASSES

ActionListener

FocusListener

InputMethodListener

KeyListenerItemListener

Interfaces AWT

EventListener

MouseListener

MouseMotionListener

TextListener

WindowListener

…


32Java : 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 itemMais 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

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

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



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

}



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’

}


35Java : 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 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.

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.


36Java : AWT / liens applicatif/composants actifs (exemple 1)

import java.awt.*;



class MyFrame extends Frameimplements ActionListener

{

Button[2] mesBoutons;


...

this.addWindowListener(new MyFrameAdapter());


}

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.

un LISTENER

un LISTENERun LISTENER


// Réception des événements de type Window

// pour la fenêtre Frame de l'application

class MyFrameAdapterextends WindowAdapter

{

public void windowClosing (WindowEvent e) {

// Termine l’application (ferme la Frame)

System.exit(0);

}

}

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.



import java.awt.*;



class MyFrame extends Frameimplements

ActionListener {


...


}

void initIHM() {

Button b = new Button(“Annuler”);

b.setActionCommand(“ANN”);

b.addActionListener(this);

this.add(b);

b = new Button(“OK”);

b.setActionCommand(“OK”);

b.addActionListener(this);

this.add(b);

}


if (e.getActionCommand().equals(“ANN”) )


else if (e.getActionCommand().equals(“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.



import java.awt.*;


class MyFrame extends Frame { public MyFrame(String titre) {

...


}

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

b.addActionListener(actLst);

this.add(b);

}

}


// Une classe Adapter à part pour les 2 boutons

class MyButtonsAdapterimplements

ActionListener {






}

}

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.



import java.awt.*;


class MyFrame extends Frame { public MyFrame(String titre) {

...


}

void initIHM() {

Button b;

b = new MyButton(“Annuler”,“ANN”);

this.add(b);

b = new MyButton(“OK”,“OK”);

this.add(b);

}

}



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

}






}

}

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.


40Java : 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 )

1 Cours JAVA / Y.Laborde Java : Interface Homme-Machine LES CONCEPTS de LIHM : Introduction LAWT...

Documents

Transcript of 1 Cours JAVA / Y.Laborde Java : Interface Homme-Machine LES CONCEPTS de LIHM : Introduction LAWT...