badr benmammar [email protected] applet et interfaces graphiques avec awt
TRANSCRIPT
Plan
Applet
Applet Interactive : Écouteurs
Interfaces graphiques avec AWT
Composants simples
Button, Label, TextField, Checkbox, List, …
Composants conteneurs
Frame et Panel
Gestion des évènements
BorderLayout
FlowLayout
GridLayout
Applet : dessiner en JAVA
import java.awt.Graphics ;import java.applet.Applet;public class Prog11 extends
Applet { public void paint (Graphics g) { g.drawLine (10, 30, 200, 30); g.drawRect (20, 40, 100, 50); g.drawOval (140, 40, 50, 50); g.drawString ("bonjour !", 10,
120);
}}
<html> <head><title>applet
Prog11</title> </head> <body> <applet code="Prog11.class"
width=400 height=300> </applet> </body></html>
Une applet est un petit programme Java destiné à être téléchargé et exécuté par un navigateur internet.
Les lignes de la classe : Importer les packages graphique et applet. Notre classe hérite de la classe Applet : il suffit de re-définir la méthode
paint en utilisant des méthodes de dessin de la classe Graphics. drawLine = dessiner une ligne du point (10,30) au point (200,30).
Les lignes du fichier html : Une applet (une fois compilée) doit être appelée dans un fichier html. Puis, pour être exécutée, le fichier html sera visualisé dans un navigateur ou
dans l'outil AppletViewer. 400 et 300 seront les dimensions en pixel (respectivement largeur, hauteur)
de la zone graphique de l'applet. Les points (pixel) composant la fenêtre sont repérés relativement au coin
gauche haut de coordonnées (0,0). Le point de coordonnées (x,y) est placé à x points du bord gauche et y points
du haut.
Applet : dessiner en JAVA
Exécution: appletviewer dessin.html
import java.awt.Graphics;import java.awt.Color;import java.applet.Applet;public class Prog12 extends Applet { public void init( ) { setSize(220,120); setForeground(Color.red); setBackground(Color.white); } public void paint(Graphics g) { g.drawLine(10, 30, 200, 30); g.fillRect(20, 40, 100, 50); g.setColor(Color.blue); g.drawOval(140, 40, 50, 50); g.drawString("texte dessine", 10, 60);}}
Applet : dessiner en JAVA
import java.awt.Graphics;import java.awt.Color;import java.applet.Applet;public class Prog12 extends Applet { public void init( ) { setSize(220,120); setForeground(Color.red); setBackground(Color.white); } public void paint(Graphics g) { g.drawLine(10, 30, 200, 30); g.fillRect(20, 40, 100, 50); g.setColor(Color.blue); g.drawOval(140, 40, 50, 50); g.drawString("texte dessine", 10, 60);}}
Applet : dessiner en JAVA
• La méthode paint reçoit le contexte graphique par défaut.• La méthode init est appelée une seule fois à la création de l'applet.
• Initialisation de l'applet : modification de sa taille, et des couleurs de fond et de dessin.
Applet : dessiner en JAVA
Une Applet ne possède pas de méthode main() mais une ou plusieures méthodes parmi les méthodes init(), start(), stop(), destroy() ou paint() héritées de la super-classe Applet : init() est lancée par le Navigateur dès que le chargement
de l'applet est terminé. start() est lancée après init() et à chaque re-chargement
de la page html. paint() est lancée à chaque fois que l'applet est rendue
visible; cette méthode peut récupérer le paramètre Graphics utile pour dessiner.
stop() est lancée quand le navigateur change de page ou quand l'applet se termine ou avant destroy().
destroy() est lancée à la fermeture du navigateur.
Dessiner des Rectangles
import java.awt.Graphics;public class Rectangle5 { double x, y, largeur, hauteur; Rectangle5 (double valX, double
valY, double valL, double valH) { x = valX; y = valY; largeur = valL; hauteur = valH; } void dessiner(Graphics g) { g.drawRect((int)x, (int)y, (int)largeur, (int)hauteur); }}
import java.awt.Graphics;import java.applet.Applet;import java.awt.Color;public class Prog31 extends Applet { public void init( ) { setSize(220,180); setForeground(Color.red); setBackground(Color.white); } public void paint (Graphics g) { Rectangle5 r1, r2,r3; r1 = new Rectangle5(60,40,45,45); r2 = new Rectangle5(20,90,60,40); r3 = new Rectangle5(85,90,60,40); r1.dessiner(g); r2.dessiner(g); r3.dessiner(g); }}
Affichage de treillis: croisement de lignes
import java.awt.Graphics;import java.applet.Applet;public class Prog13 extends Applet { public void paint (Graphics g) { int x, y, t, i; x=30; y=40; t=140; for (i=0; i<=t; i+=5) g.drawLine (x, y+i, x+i, y+t); }}
Applet Interactiveimport java.awt.*;public class Rectangle6 { double x, y, largeur, hauteur; Color couleur; Rectangle6 (double valX, double valY, double valL, double valH, Color c) { x = valX; y = valY; largeur = valL; hauteur = valH; couleur = c; } void setPosition (double valX, double
valY){ x = valX; y = valY; } boolean estDans (double valX, double
valY){ return
((x<=valX)&&(x+largeur>=valX)
&&(y<=valY))&&(y+hauteur>=valY); }
void dessiner(Graphics g) { g.setColor (couleur); g.fillRect ((int)x, (int)y, (int)largeur, (int)hauteur); }}
import java.awt.*;import java.awt.event.*;import java.applet.Applet;public class Prog67 extends Applet implements MouseListener { Rectangle6 rectRouge, rectBleu; boolean affiche; public void init() { addMouseListener (this); affiche = true; rectRouge =new Rectangle6
(30,30,50,80,Color.red); rectBleu =new Rectangle6
(30,30,50,80,Color.blue); }
public void paint (Graphics g) { if (affiche) rectRouge.dessiner (g); else rectBleu.dessiner (g); } public void mouseClicked (MouseEvent e) { affiche = ! affiche; repaint(); } public void mouseEntered(MouseEvent e) {} public void mouseExited(MouseEvent e) {} public void mousePressed(MouseEvent e) {} public void mouseReleased(MouseEvent e) {}}
<html> <body> <applet code="Prog67.class" width=450 height=150> </applet> </body></html>
Un clic de souris pour faire apparaître le rectangle rouge, puis un autre pour faire apparaître le rectangle bleu. Le clic (enfoncement puis relâchement) d'un bouton de la souris provoque un événement e de type MouseEvent envoyé comme message à l'applet et provoquant l'exécution de la méthode mouseClicked.
Interface MouseListener
MouseListener définit l'écouteur d'événement Souris : press, release, click, enter, exit.
addMouseListener installe un écouteur MouseListener sur un composant.
Les méthodes à (toutes) définir sont : public void mousePressed(MouseEvent e) définit le traitement
quand survient l'événement qui indique qu'un bouton de la souris est pressé dans l'aire du composant.
public void mouseReleased(MouseEvent e) ...événement bouton de souris "relaché" dans l'aire du composant.
public void mouseClicked(MouseEvent e) ...événement bouton de souris "pressé-relaché"
public void mouseEntered(MouseEvent e) ... événement souris "entre" dans l'aire du composant.
public void mouseExited(MouseEvent e) ... événement souris "sort" de l'aire du composant.
mouseEvent.getX() donne la coordonnée x de la souris au moment de l'événement.
mouseEvent.getY() donne la coordonnée y.
Lignes de la classe
L'applet (dans sa zone/fenêtre graphique) est le siège d'événement de la souris.
Jusqu'ici, ces événements étaient ignorés.
Maintenant, on ajoute un écouteur (un gestionnaire) de ces événements : this, c'est à dire l'applet elle-même.
Donc, elle traitera elle-même les événements souris dont elle est le siège.
L'applet aura la capacité de traiter les événement de la souris puisqu'elle implémente MouseListener : elle est à l'écoute des événements de la souris.
Définition de la méthode mouseClicked qui réagit au clic de la souris.
Pour les autres traitements :mousePressed, mouseReleased, mouseEntered et mouseExited, le traitement est vide.
repaint rafraichie l'applet en appelant paint.
Placer un dessin à l'endroit cliqué
import java.awt.*;import java.awt.event.*;import java.applet.Applet;public class Prog36 extends Applet implements MouseListener { Rectangle6 rect; public void init() { rect = new
Rectangle6(30,30,50,80,Color.yellow);
addMouseListener(this); } public void paint(Graphics g) { rect.dessiner(g); }
public void mouseClicked(MouseEvent e) {
int x,y; x = e.getX(); y = e.getY(); rect.setPosition(x,y); repaint(); } public void mouseEntered(MouseEvent
e) {} public void mouseExited(MouseEvent
e) {} public void mousePressed(MouseEvent
e) {} public void
mouseReleased(MouseEvent e) {}}
Evénements et leurs méthodes associéesimport java.awt.*;import java.awt.event.*;import java.applet.Applet;public class Prog37 extends Applet implements MouseListener,
KeyListener, MouseMotionListener { String message = "aucun"; public void init() { addMouseListener (this); addMouseMotionListener (this); addKeyListener (this); } public void paint (Graphics g) { g.drawString(message, 20, 50); } public void mouseClicked(MouseEvent
e) {message = "mouseClicked";
repaint(); } public void mouseEntered(MouseEvent
e) {message = "mouseEntered";
repaint(); }public void mouseExited(MouseEvent e)
{message = "mouseExited";
repaint(); }
public void mousePressed(MouseEvent e) {message = "mousePressed";
repaint(); } public void
mouseReleased(MouseEvent e) {message = "mouseReleased";
repaint(); } public void
mouseDragged(MouseEvent e) {message = "mouseDragged";
repaint(); } public void
mouseMoved(MouseEvent e) {message = "mouseMoved";
repaint(); } public void keyTyped(KeyEvent e) {
message = "mouseMoved"; repaint(); } public void keyPressed(KeyEvent e) {
message = "mouseMoved"; repaint(); } public void keyReleased(KeyEvent e)
{message = "mouseMoved";
repaint(); }}
Interfaces souris et clavier
Attention ! l'Applet ne reçoit pas les événements provenant du
clavier lorsqu'elle est lancée par Appletviewer.
L'interface MouseListener se compose des méthodes
mouseClicked, mousePressed, mouseReleased, mouseEntered et
mouseExited.
Les méthodes mouseClicked, mousePressed, mouseReleased
sont appelées lorsque respectivement la souris est cliquée, un
de ses boutons pressé, relâché.
Les méthodes mouseEntered et mouseExited sont appelées
lorsque respectivement la souris entre ou sort de la "fenêtre" de
l'applet.
Leur paramètre de type MouseEvent permet de récupérer les
coordonnées int de la souris : e.getX() e.getY().
Interfaces souris et clavier
L'interface MouseMotionListener se compose des méthodes
mouseDragged et mouseMoved.
Les méthodes mouseDragged et mouseMoved sont appelées
lorsque la souris est bougé et que respectivement un des
boutons de la souris est enfoncé ou non.
Leur paramètre de type MouseEvent permet de récupérer les
coordonnées int de la souris : e.getX() e.getY().
L'interface KeyListener se compose des méthodes keyPressed,
keyReleased, keyTyped.
Les méthodes keyPressed, keyReleased, keyTyped sont
appelées lorsque respectivement une touche au clavier est
pressée, relâchée, une touche caractère est tapée.
Plusieurs objets à bouger à la sourisimport java.awt.*;import java.awt.event.*;import java.applet.Applet;public class Prog38 extends Applet implements MouseListener, MouseMotionListener { Rectangle6 rect1, rect2; boolean clicRect1, clicRect2; public void init() { rect1 = new
Rectangle6(30,30,50,80,Color.gray);
rect2 = new Rectangle6(100,60,70,30,Color.green);
clicRect1 = false; clicRect2 = false; addMouseListener (this); addMouseMotionListener (this); } public void paint (Graphics g) { rect1.dessiner(g); rect2.dessiner(g); }
public void mousePressed (MouseEvent e){ if (rect1.estDans(e.getX(),e.getY())) clicRect1=true; if (rect2.estDans(e.getX(),e.getY())) clicRect2=true; } public void mouseDragged (MouseEvent e)
{ if (clicRect1) { rect1.setPosition (e.getX(),e.getY()); repaint(); } if (clicRect2) { rect2.setPosition(e.getX(),e.getY()); repaint(); } } public void mouseReleased (MouseEvent e)
{ if (clicRect1) clicRect1=false; if (clicRect2) clicRect2=false; } public void mouseEntered(MouseEvent e)
{} public void mouseExited(MouseEvent e) {} public void mouseClicked(MouseEvent e)
{} public void mouseMoved(MouseEvent e) {}}
Dessin à la sourisimport java.awt.*;import java.awt.event.*;import java.applet.Applet;public class Prog39 extends Applet implements MouseListener, MouseMotionListener
{ int x0, y0; Graphics g; public void init() { x0=0; y0=0; g = getGraphics(); addMouseListener(this); addMouseMotionListener(this); }public void mousePressed (MouseEvent e){ int x,y; x = e.getX(); y = e.getY(); x0=x; y0=y; }
public void mouseDragged (MouseEvent e){
int x,y; x = e.getX(); y = e.getY(); g.drawLine (x0, y0, x, y); x0=x; y0=y; } public void
mouseEntered(MouseEvent e) {} public void
mouseExited(MouseEvent e) {} public void
mouseClicked(MouseEvent e) {} public void
mouseReleased(MouseEvent e) {} public void
mouseMoved(MouseEvent e) {}}
Interfaces graphiques avec AWT
Abstract Window Toolkit (AWT) est une bibliothèque graphique
pour Java, faisant partie de JFC (Java Foundation Classes).
Cette bibliothèque a été introduite dès les premières versions de
Java mais depuis Java 2, la bibliothèque de gestion de fenêtre
officielle est Swing.
Toutefois, AWT sert encore de fondement à Swing, dans la mesure
où de nombreuses classes Swing héritent de classes AWT.
AWT emploie les composants natifs de la plateforme, alors que
Swing utilise des composants en pur Java.
AWT n'est pas compatible avec Swing.
Composants simplesimport java.awt.List; import java.awt.Button; import java.awt.Label; import java.awt.TextField; import java.awt.Checkbox;import java.applet.Applet;public class Prog44 extends Applet {public void init ( ) { Button monBouton = new Button ("bouton");add (monBouton); Label monLabel = new Label("label"); add(monLabel);List maListe = new List(2); maListe.add("bleu"); maListe.add("rouge"); maListe.add("vert"); add(maListe);TextField champTexte = new TextField("du
texte",15);add(champTexte);Checkbox caseACocher = new Checkbox
("ok ?",true);add(caseACocher); } }
Un bouton Button est un composant graphique.
La méthode add() de Applet ajoute un composant graphique dans l'espace de l'applet.
Un "label" Label est un texte constant affiché dans notre applet.
Une liste à choisir List permet de choisir une valeur parmi plusieurs, ici, seuls 2 sont visibles à la fois mais un curseur permet de faire défiler toute la liste.
Un champ texte TextField est une zone éditable simple d'une ligne.
Une case à cocher Checkbox prend une valeur binaire selon qu'il est coché (true) ou non (false).
Composants simples
import java.awt.List; import java.awt.TextArea; import java.awt.Checkbox;import java.awt.CheckboxGroup;import java.applet.Applet; public class Prog45 extends Applet { public void init() { List maListe = new List
(3,true); maListe.add("bleu"); maListe.add("rouge"); maListe.add("vert"); maListe.add("noir"); add(maListe); maListe.select(0); maListe.select(2);
TextArea zoneTexte = new TextArea(10, 20); add(zoneTexte); zoneTexte.setText("une premiere ligne \n"); zoneTexte.append("une seconde ligne"); CheckboxGroup choixCouleur = new CheckboxGroup(); Checkbox caseRouge = new Checkbox("rouge",false,choixCouleur); add(caseRouge); Checkbox caseBleu = new Checkbox("bleu",false,choixCouleur); add(caseBleu); Checkbox caseVert = new Checkbox("vert",false,choixCouleur); add(caseVert);choixCouleur.setSelectedCheckbox(caseBleu); } }
Une liste à choisir peut être à sélection unique ou multiple : Unique : au plus un élément de la liste peut être
sélectionné. Ici, elle est multiple (true).
La méthode select() permet de faire une sélection, les choix sont indicés à partir de 0.
Un "éditeur" TextArea est une zone de texte éditable sur plusieurs lignes, avec souvent des barres de défilement : Ici, il fait 10 lignes et 20 colonnes.
La méthode setText modifie son contenu texte intégralement. La méthode append ajoute du texte. Les cases à cocher Checkbox sont, sans indication,
indépendantes. Un CheckboxGroup permet d'en regrouper pour que leur
sélection soit mutuellement exclusive : une, au plus, est cochée !
La méthode setselectedCheckbox permet d'en cocher une dans le groupe.
Composants simples
Button : un bouton à cliquer. Constructeurs :
Button() crée un bouton sans texte. Button(String texte) crée un bouton avec texte centré.
Quelques méthodes : setLabel(String texte) spécifie le texte du bouton. getLabel() retourne le texte du bouton.
Label : étiquette : affiche un petit texte/message. Constructeurs :
Label() crée une étiquette sans texte. Label(String texte) crée une étiquette avec texte aligné à
gauche. Label(String texte, int aligne) crée une étiquette avec texte
aligné selon aligne : Label.LEFT, Label.CENTER, Label.RIGHT.
Quelques méthodes : setText(String texte) spécifie le texte. getText() retourne le texte de l'étiquette. setAlignment(int aligne) spécifie l'alignement. getAlignment().
Composants simples
TextField : champ texte d'une ligne pour saisir et/ou afficher du texte modifiable
Constructeurs : TextField() crée un champ sans texte. TextField(int nombre) crée un champ sans texte d'une largeur de
nombre caractères. TextField(String texte) crée un champ avec texte. TextField(String texte, int nombre) crée un champ avec texte et
d'une largeur de nombre caractères. Quelques méthodes :
setText(String texte) spécifie le texte du champ. getText() retourne le texte contenu dans le champ. getColumns() retourne la largeur du champ en nombre caractères. setColumns() définit la largeur du champ en nombre caractères. setEditable(boolean modifiable) spécifie si le texte du champ est
modifiable. isEditable() retourne un boolean qui indique si le texte du champ
est modifiable. setEchoChar(char masque) spécifie le caractère de masquage de la
saisie (pour les passwords). echoCharSet() retourne un boolean qui indique si le masquage est
en vigueur. getEchoChar() retourne le caractère de masquage.
Composants simples
TextAera : éditeur de texte pour saisir et/ou afficher du texte modifiable sur plusieures lignes, muni de barres de défilement de comportements prédéfinies : sélection de texte à la souris, raccourci clavier copier/coller, ...,
Constructeurs : TextAera() crée un éditeur sans texte. TextAera(int ligne, int largeur) crée un éditeur sans texte d'une
largeur en nombre de caractères et d'un nombre de lignes spécifiés. TextAera(String texte) crée un éditeur avec texte. TextAera(String texte, int ligne, int largeur) crée un éditeur avec
texte et d'une largeur et d'un nombre de lignes spécifiés. Quelques méthodes :
insertText(String texte, int position) insère le texte à la position indiquée.
replaceText(String texte, int départ, int fin) remplace les caractères entre les positions indiquées par le texte spécifié.
getText() ... setText() isEditable() setEditable()
Composants simples
Checkbox et CheckboxGroup : cases à cocher et boutons radios, peuvent être plusieurs (indépendantes ou exclusives ) et permettent le déclanchement d'action. Les cases à cocher sont indépendantes, les boutons radios sont en exclusion mutuelle, c'est à dire qu'un seul au plus peut être coché.
Constructeurs : Checkbox(String texte) crée une case à cocher (initialisée à non
cochée) avec texte associé. Checkbox(String texte, boolean cochée) crée une case à cocher avec
texte associé, cochée ou non selon la valeur booléenne. CheckboxGroup() crée un groupe de boutons radios. Checkbox(String texte, boolean cochée, CheckboxGroup groupe)
crée une bouton radio avec texte associé, cochée ou non selon la valeur booléenne, faisant partie du groupe indiqué.
Quelques méthodes de Checkbox : setLabel(String texte) spécifie le texte de la case à cocher (ou
bouton radio). getLabel() retourne le texte de la case à cocher. getState() retourne true si la case est cochée. setState(boolean cochée) coche ou non la case selon la valeur
booléenne. Quelques méthodes de CheckboxGroup :
setSelectedCheckbox(Checkbox unBoutonRadio) permet d'en cocher un dans le groupe.
Composants simples
List : une liste à choisir peut être à sélection unique ou multiple : Constructeurs :
List() crée une liste de choix. List(int nombre) crée une liste de choix avec nombre lignes
visible. List(int nombre, boolean choixMultiple) crée une liste de choix
avec nombre lignes visible et à sélection unique si choixMultiple est false sinon à choix multiple.
Quelques méthodes : add(String choix) ajoute un choix en fin de liste. isMultipleMode() true si la liste est en choix multiple. getSelectedIndex() renvoie l'index de la sélection dans la liste
(numérotée à partir de 0), ou -1 s'il n'y en a pas ou s'il y en a plus d'une.
getSelectedIndexes() renvoie un tableau d'entiers : les index des sélections dans la liste.
select(int indice) sélectionne un choix dans la liste à l'indice indiqué.
Composants simples
import java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox; public class Prog58 extends Frame {
public Prog58 ( ) { add ("South", new Button ("bouton1")); add ("East", new Label ("label1")); add ("Center", new Button ("bouton2")); add ("West", new Checkbox ("case à cocher", false)); setVisible (true);
pack (); } public static void main (String args[]) { new Prog58 ( ); }}
Composants conteneurs
Frame
Frame est une fenêtre de haut niveau (top level): une fenêtre d'application, elle peut contenir des composants graphique : la méthode add permet de les ajouter, elle est donc aussi un container.
Les Applets que nous avons souvent utilisés sont des containers mais ne sont pas des fenêtres top level, la fenêtre top level d'une applet est celle du navigateur qui la visualise ou celle de Appletviewer.
L'application crée dans sa méthode main une instance objet graphique "de type Frame".
Les frames sont gérées par défaut par le gestionnaire BorderLayout : qui divise un composant container en 5 zones: North, East, South, West, Center.
La méthode add doit être utilisé ainsi : add ("zone", composant). pack() re-dimensionne la frame et ses composants à la taille "idéale". Pour terminer l'application, la "croix " ou bouton de fermeture ne
marche pas car nous n'avons pas mis en place le code nécessaire. Pour l'instant, CTRL-C dans la console permet de terminer l’application.
Frame : gestionnaire FlowLayout import java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox;import java.awt.FlowLayout; public class Prog59 extends Frame {public Prog59() { setLayout (new FlowLayout (FlowLayout.LEFT,5,15));add (new Button ("bouton1")); add (new Label ("label1")); add (new Button ("bouton2")); add (new Checkbox ("case à cocher", false)); setVisible (true);pack(); } public static void main(String args[]) { new Prog59(); }}
Frame est le container ici et les boutons, label, case à cocher sont les composants contenus dedans. FlowLayout est un des gestionnaires de placement ou encore un geometry manager : ici il organisera les composants contenus dans la frame selon une "politique" à gauche d'abord et avec un espace horizontale de 5 pixels entre les composants contenus et verticalement de 15 pixels.setLayout détermine le nouveau geometry manager du composant container Frame.
Frame : gestionnaire GridLayoutimport java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox;import java.awt.GridLayout; public class Prog69 extends Frame { public Prog69() { setLayout (new GridLayout (2,2)); add (new Button ("bouton1")); add (new Label ("label1")); add (new Button ("bouton2")); add (new Checkbox ("case à cocher", false)); setSize(200,40); setVisible(true); } public static void main(String args[]) { new Prog69(); }}
Le geometry manager GridLayout a une organisation en grille : ici, 2 lignes et 2 colonnes.Les composants contenus sont introduits au fer et à mesure par add en (1,1) puis en (1,2) puis en (2,1) puis en (2,2).setSize() redimensionne la Frame à la dimension indiquée.
Panelimport java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox;import java.awt.GridLayout;import java.awt.Panel;public class Prog70 extends Frame {public Prog70() { setLayout (new GridLayout (3,1)); add (new Button("bouton1")); Panel boite=new Panel (); boite.add (new Label ("label2")); boite.add (new Button ("bouton2")); add (boite); add(new Checkbox("case à cocher", true)); setVisible(true); pack(); } public static void main(String args[]) { new Prog70(); }}
Panel est juste un container : dans ce container, nous plaçons le label2 et le bouton2.Le geometry manager de Panel est par défaut le FlowLayout manager. Ce panel est ajouté dans la Frame.Pour la frame, notre Panel est un composant contenu.
Création de nouveaux composants à partir de Panel
import java.awt.Button; import java.awt.GridLayout;import java.awt.Panel;import java.applet.Applet; class PanneauClavier extends Panel { PanneauClavier ( ) { setLayout (new GridLayout (4,3)); for (int num=1; num <= 9 ; num++)
add (new Button(Integer.toString(num))); add(new Button("*")); add(new Button("0")); add(new Button("# ")); }}public class demo extends Applet { public void init() { add (new PanneauClavier ( )); }}
Même chose avec Frameimport java.awt.Button; import java.awt.GridLayout;import java.awt.Frame;
public class Maframe extends Frame {
public Maframe() { setLayout (new GridLayout (4,3));for (int num=1; num <= 9 ; num++) add(new Button(Integer.toString(num)));
add(new Button("*")); add(new Button("0")); add(new Button("# "));
setVisible(true); pack(); } public static void main(String args[]) { new Maframe(); }}
Charger une image dans une appletimport java.awt.Dimension;import java.awt.Graphics;import java.awt.Image;import java.awt.MediaTracker;import java.awt.Panel;import java.awt.Toolkit;import java.applet.Applet; class LIVRE extends Panel { private Image image; public LIVRE(String filename) { image = Toolkit.getDefaultToolkit().getImage("livre.gif"); try { MediaTracker mt = new MediaTracker(this); mt.addImage(image, 0); mt.waitForAll(); }
catch (Exception e) { e.printStackTrace(); }this.setPreferredSize(new Dimension (image.getWidth(this),image.getHeight(this))); } public void paint(Graphics g) { g.drawImage(image, 0, 0, null); } }public class AfficheImage extends Applet { public void init() { add (new LIVRE ("LIVRE")); }}
Remarque : Le chargement avec Toolkit se fait de façon asynchrone. Il faut alors utiliser une instance de la classe MediaTracker pour patienter le temps de chargement de l'image et ainsi pouvoir déterminer sa taille pour la reporter sur la taille du composant.
Charger une image dans une applet
Ajouter une applet dans une frameimport java.awt.Graphics;import java.applet.Applet;public class dessin extends Applet { public void paint (Graphics g) { g.drawLine (10, 30, 200, 30); g.drawRect (20, 40, 100, 50); g.drawOval (140, 40, 50, 50); g.drawString ("bonjour !", 10, 120); }}
import java.awt.Frame; public class Maframe2 extends Frame { public Maframe2() { add ("Center", new dessin());
setVisible(true);setSize(300,200) ;
} public static void main(String args[]) { new Maframe2(); }}
Classe Component
La plupart des Classes de l'AWT hérite de la classe abstraite
Component (composant en français).
Quelques méthodes :
paint(Graphics g) est la méthode appelée à chaque fois que le
contenu du composant doit être redessiné (la 1ére fois, quand
il fut masqué puis démasqué, ...); elle est à redéfinir en
spécifiant tout ce qui doit être dessiné.
repaint() provoque un appel à paint(), donc redessine le
contenu du composant.
getGraphics() renvoie le contexte graphique de type Graphics
du composant : c'est à dire la trousse à dessiner actuelle.
setVisible(boolean visible) affiche ou masque le composant.
setEnabled(boolean actif) active ou non le composant, c'est à
dire le rend sensible aux événements.
Classe Component
getSize() donne la dimension actuelle du composant, retourne le type Dimension qui est utilisable ainsi : getSize().height et getSize().width.
getPreferedSize() donne la taille "idéale" du composant, retourne le type Dimension.
setSize(Dimension d) redimensionne le composant à la dimension indiquée.
setSize(int largeur, int hauteur) redimensionne le composant.
move(int coordX, int coordY) déplace le composant au point indiqué (coin haut et gauche).
setForeground(Color couleur) définit la couleur d'avant-plan (de dessin) du composant.
setBackground(Color couleur) définit la couleur de fond.
setCursor(Cursor curseur) définit la couleur du curseur.
Classe Container
Classe abstraite pour les composants qui contiennent et gèrent
d'autres composants (conteneur en français).
Chaque container possède un gestionnaire de placement par
défaut, layout ou "geometry manager", qui range les composants
graphiques fils dans le container.
Il est possible de ne pas les utiliser en plaçant chaque composant
à l'aide de la méthode setLocation(int coordX, coordY).
Quelques méthodes :
setLayout (LayoutManager manager) spécifie le geometry
manager qui rangera (arrangera) les composants contenus.
add (composant) ajoute un composant dans le container.
Héritage entre composants
Object
Component
Window Panal
Frame
Button Canvas Checkbox ContainerLabel
List
Graphics
Applet
Classes abstraites
Fenêtre top-levelFenêtre ordinaire
Frame
Frame : fenêtre top-level conteneur d'une application avec barre de titre et des boutons de fermeture.
Le layout par défaut est BorderLayout
Constructeurs :
Frame() crée une fenêtre sans titre.
Frame(String titre) crée une fenêtre avec titre.
Quelques méthodes :
pack() redimensionne la frame et ses composants à leur preferredSize (la taille juste nécessaire).
setTitle(String titre) spécifie le titre.
setMenuBar(MenuBar) applique une barre de menu en haut du cadre.
setResizable(boolean) détermine si le cadre peut être redimensionné par l'utilisateur.
Panel
Panel : composant conteneur d'autres composants.
La classe Applet hérite de Panel.
Le layout par défaut est FlowLayout.
Constructeurs :
Panel() crée un Panel.
Panel(LayoutManager manager) crée un Panel avec le
geometry manager spécifié.
Geometry manager
Plusieurs gestionnaires de placement, geometry manager, qui
rangent des composants graphiques dans un container. Il est
possible de ne pas les utiliser en placant chaque composant
dans un Panel à l'aide de la méthode setLocation (int coordX,
coordY)
FlowLayout : range de gauche à droite et de haut en bas.
Constructeurs :
FlowLayout() range les composants en les centrant avec un
"vspacing et hspacing" (espace vertival, respectivement
horizontal) de 5 pixels.
FlowLayout(int aligne) range les composants en les alignant
selon aligne : FlowLayout.LEFT, FlowLayout.CENTER,
FlowLayout.RIGHT avec un vspacing et hspacing de 5 pixels.
FlowLayout(int aligne, int hspacing, int vspacing) range
selon l'alignement et le vspacing et le hspacing spécifiés.
GridLayout : range dans une grille/matrice de gauche à droite et
de haut en bas.
Constructeurs :
GridLayout(int ligne, int colonne) range les composants dans
la grille de rangement.
GridLayout(int ligne, int colonne, int hspacing, int vspacing)
idem avec le vspacing et le hspacing spécifiés.
BorderLayout : divise un composant container en 5 zones:
North, East, South, West, Center
Constructeurs :
BorderLayout() crée 5 zones.
BorderLayout(int hspacing, int vspacing) idem avec un
espacement spécifié.
La méthode add doit être utilisé ainsi : add("North",
composant).
Geometry manager
Exemple : Frameimport java.awt.Button; import java.awt.GridLayout;import java.awt.Frame;
public class Maframe extends Frame {
public Maframe() { setLayout (new GridLayout (4,3));for (int num=1; num <= 9 ; num++) add(new Button(Integer.toString(num)));
add(new Button("*")); add(new Button("0")); add(new Button("# "));
setVisible(true); pack(); } public static void main(String args[]) { new Maframe(); }}
Classe FrameClasse
Component
Classe Container
java.awt Class Framejava.lang.Object java.awt.Component java.awt.Container java.awt.Window java.awt.Frame
Evénements
Mettre en place un "écouteur" (listener).import java.awt.Button; import java.awt.Label; import java.applet.Applet; import java.awt.Color; public class Prog46 extends Applet { public void init() { Button monBouton = new Button ("Changer"); add(monBouton); Label monLabel = new Label ("Changer"); add(monLabel); monLabel.setForeground(Color.red); monBouton.addActionListener(new Delegue1(monLabel)); } }
Un Button émet un événement ActionEvent lorsqu'il est pressé/cliqué. Par défaut, personne n'écoute/ne reçoit cet événement, qui est perdu. La méthode addActionListener() spécifie que désormais un objet Delegue1 écoutera/sera récepteur d'un tel événement, l'objet Delegue1 reçoit le Label en paramètre.
import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Label;import java.awt.Color; public class Delegue1 implements ActionListener { private Label leLabel; private boolean etatLabel; public Delegue1(Label lab) { leLabel = lab; etatLabel=true; } public void actionPerformed (ActionEvent event) { etatLabel = ! etatLabel; if (etatLabel) leLabel.setForeground (Color.red); else leLabel.setForeground (Color.blue); } }
Evénements
Delegue1 implémente l'interface ActionListener puisqu'il est susceptible de recevoir de tel événement. La réception d'un tel événement provoque l'exécution de la méthode actionPerformed.Ici, la méthode actionPerformed change la couleur du label de notre Applet puisque l'objet Delegue1 à une référence sur le label.Label est un Component dont la méthode setForeground est héritée.
Evénements Button
Button : permet le déclanchement d'action.
Par défaut le nom de l'action d'un bouton est son texte.
Méthodes :
setActionCommand (String texte) spécifie le nom de l'action
du bouton.
getActionCommand() retourne le nom de l'action du bouton.
addActionListener(ActionListener écouteur) met un
"écouteur" d'événement sur le bouton.
removeActionListener(ActionListener écouteur) supprime un
"écouteur" d'événement sur le bouton.
Délégué qui peut agir sur l'objet où s'est produit l'événement
import java.awt.List; import java.awt.Label; import java.applet.Applet; public class Prog47 extends Applet { private List maListe; private Label monLabel; private final Color tabCouleur[]= {Color.red,Color.blue, Color.green,Color.yellow, Color.orange }; public void init() { maListe = new List(3); maListe.add("bleu"); maListe.add("rouge"); maListe.add("vert"); maListe.add("jaune"); maListe.add("orange");
add(maListe); monLabel = new Label ("Choisir"); add(monLabel); maListe.addActionListener(new Delegue2(this)); } public void changeLabel () { int index = maListe.getSelectedIndex(); monLabel.setForeground(tabCouleur[index]); }}
Delegue2 reçoit l'objet Applet en paramètre : donc le Delegue2 aura une référence sur l'Applet. La méthode changeLabel de changement de couleur du label est prévue. Lors d'une sélection de choix d'une List (double-cliquez !), l'événement ActionListener est envoyé.
Délégué qui peut agir sur l'objet où s'est produit l'événement
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent; import java.awt.Label; import java.awt.List; import java.awt.Color; public class Delegue2 implements ActionListener { private Prog47 monApplet; public Delegue2 (Prog47 monApp)
{ monApplet = monApp; } public void actionPerformed (ActionEvent event) { monApplet.changeLabel(); } }
Menus
import java.awt.MenuBar; import java.awt.Menu; import java.awt.MenuItem; import java.awt.Label; import java.applet.Applet; import java.awt.Color; public class Prog48 extends Applet {private Label monLabel;public void init ( ) { Delegue3 monDelegue= new Delegue3 (this);MenuBar maBarreDeMenu = new MenuBar(); add (maBarreDeMenu); Menu menu1 = new Menu("fond"); maBarreDeMenu.add(menu1);MenuItem m1rouge = new MenuItem("fond
rouge");m1rouge.addActionListener (monDelegue);menu1.add (m1rouge); MenuItem m1bleu = new MenuItem ("fond
bleu");m1bleu.addActionListener (monDelegue);menu1.add (m1bleu); MenuItem m1vert = new MenuItem ("fond
vert");m1vert.addActionListener (monDelegue);menu1.add (m1vert); menu1.addSeparator ( );
MenuItem m1noir = new MenuItem ("fond noir"); m1noir.addActionListener (monDelegue); menu1.add (m1noir); Menu menu2 = new Menu ("texte"); maBarreDeMenu.add (menu2); MenuItem m2rouge = new MenuItem ("texte rouge"); m2rouge.addActionListener(monDelegue); menu2.add (m2rouge); MenuItem m2bleu = new MenuItem ("texte bleu"); m2bleu.addActionListener (monDelegue); menu2.add (m2bleu); MenuItem m2vert = new MenuItem ("texte vert"); m2vert.addActionListener (monDelegue); menu2.add (m2vert); MenuItem m2noir = new MenuItem ("texte noir"); m2noir.addActionListener (monDelegue); menu2.add (m2noir); monLabel = new Label ("Changer"); add (monLabel); setVisible (true); pack(); } public void changeLabelFond (Color couleur) { monLabel.setBackground (couleur); } public void changeLabelTexte (Color couleur) { monLabel.setForeground (couleur); }}
Menusimport java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Color; public class Delegue3 implements ActionListener { private Prog48 monApplet;public Delegue3 (Prog48 app) {monApplet = app; }
public void actionPerformed (ActionEvent event) { Color couleur= Color.white; String nomDeMenuChoisi = event.getActionCommand(); if (nomDeMenuChoisi.indexOf ("rouge")>=0) couleur = Color.red; else if (nomDeMenuChoisi.indexOf ("bleu")>=0) couleur = Color.blue; else if (nomDeMenuChoisi.indexOf ("vert")>=0) couleur = Color.green; else if (nomDeMenuChoisi.indexOf ("noir")>=0) couleur = Color.black; if (nomDeMenuChoisi.indexOf ("fond")>=0) monApplet.changeLabelFond (couleur); if (nomDeMenuChoisi.indexOf ("texte")>=0) monApplet.changeLabelTexte (couleur); } }
L'objet délégué ou listener doit distinguer d'ou vient l'événement pour pouvoir agir, dans l'événement passée en paramètre de la méthode actionPerformed, se trouve les informations relatives à l'événement qui s'est produit en particulier, par la méthode getActionCommand, on récupère le nom d'action. Comme les noms d'actions étaient les mêmes que les noms d'items de menus, il est possible de savoir quel item a été sélectionné.
Utiliser les valeurs modifiées de TextField
import java.awt.TextField; import java.awt.Label; import java.applet.Applet; import java.awt.Color; public class Prog49 extends Applet {private TextField valeurR, valeurV,
valeurB;private Label monLabel;public void init ( ) { monLabel = new Label ("intensité couleur [0-
255]"); add (monLabel); Delegue4 monDelegue= new Delegue4
(this);add (new Label ("R:")); valeurR = new TextField ("255",3);add (valeurR);valeurR.addActionListener (monDelegue); add (new Label ("V:")); valeurV = new TextField ("255",3);add (valeurV);valeurV.addActionListener (monDelegue); add (new Label ("B:")); valeurB = new TextField ("255",3);add (valeurB);valeurB.addActionListener (monDelegue); }
private int convertir (String intensite) { int val= (new Integer(intensite)).intValue(); if (val <0) return 0; else if (val >255) return 255; else return val; } public void changeLabel ( ) {int r = convertir (valeurR.getText());int v = convertir (valeurV.getText());int b = convertir (valeurB.getText());monLabel.setBackground (new Color(r,v,b)); }}
Un TextField envoie aussi un événement ActionEvent lorsque la modification du texte est confirmée par la frappe de la touche "entrée" le texte d'un TextField est récupérée par la méthode getText(). Les couleurs peuvent être crées en précisant les intensités RVB (rouge, vert, bleu) sur 8 bits chacune donc un entier entre 0 et 255.
Utiliser les valeurs modifiées de TextField
import java.awt.event.ActionListener; import java.awt.event.ActionEvent; public class Delegue4 implements ActionListener { private Prog49 monApplet; public Delegue4 (Prog49 monApp) { monApplet = monApp; } public void actionPerformed (ActionEvent event) { monApplet.changeLabel ( ); } }
ActionListener
Les événements sont des actions ou des effets indirects d'action de l'utilisateur du GUI (Interface Graphique Utilisateur) : clic de souris, frappe de touche, fenêtre masquée par une autre, ...qu'il faut gérer en mettant en place un "écouteur" de l'événement souhaité sur le composant graphique considéré, puis définir le comportement (les instructions à exécuter, le Handler d'événement) lorsque l'événement surviendra.
ActionListener est une interface pour écouter et traiter les ActionEvents. Par exemple, bouton.addActionListener (composant) met un écouteur
(d'ActionEvent) sur le bouton, le "Handler" sera assurée au niveau du composant désigné qui implémente l'ActionListener; pour un bouton, l'ActionEvent est provoquée par un clic de souris (bouton enfoncé puis relâché).
removeActionListener(ActionListener écouteur) supprime un "écouteur" d'événement.
La classe qui implémente l'interface ActionListener doit définir la méthode :
public void actionPerformed(ActionEvent e) { ... qui est le "Handler" getActionCommand() est une méthode de ActionEvent récupère le nom
de la commande d'action associé au composant par exemple un bouton (par défaut son label).
Evénements des Frames et la classe siège
de l'événement qui est son propre délégué
import java.awt.Label;import java.awt.Frame;import java.awt.event.WindowListener;import java.awt.event.WindowEvent;import java.awt.FlowLayout;public class Prog71 extends Frameimplements WindowListener {public static void main(String args[]) { new Prog71(); }public Prog71() {setTitle("Prog71");setSize(200,100);setLayout(new
FlowLayout(FlowLayout.CENTER));setVisible(true);addWindowListener (this); } public void windowClosing (WindowEvent
e) { add (new Label("fini dans 5 secondes !")); pack();
try { Thread.sleep (5000); } catch (InterruptedException ie) { System.exit (1); } setVisible (false); dispose (); System.exit (0); } public void windowOpened(WindowEvent e) {} public void windowActivated(WindowEvent e) {} public void windowDeactivated(WindowEvent e) {} public void windowClosed(WindowEvent e) {} public void windowIconified(WindowEvent e) {} public void windowDeiconified(WindowEvent e) {}}
Lignes de la classe
La Frame peut être le siège de plusieurs événements WindowEvent :
Ouvrir la Frame.
La rendre active ou passive.
La mettre en icone ou l'inverse.
La fermer par le window manager (ou bureau) : windowClosing.
La fermer par la méthode dispose() : windowClosed.
L'objet Prog71 est le siège d'événements WindowEvent et est aussi le délégué
(le listener) de cet événement par l'instruction : addWindowListener(this);
La méthode static sleep de la classe Thread attend le nombre de millisecondes
indiquées
dispose est la méthode qui ferme la Frame et toutes ses sous-fenêtres s'il y a.
Evénements en résumé
Composant Action Evénement Interface d'écoute
Button, List, MenuItem, TextField, Checkbox,
Canvas
Sélectionner, valider
ActionEvent ActionListener
TextArea, TextField
Changer le texte TextEvent TextListener
Frame Ouvrir, fermer WindowEvent WindowListenerContainer Mouvement et
clic de souris, frappe au clavier
MouseEvent, MouseMotionEve
nt, KeyEvent
MouseListener, MouseMotionListener, KeyListener
Technique des Adapters
import java.awt.Frame;import java.awt.Dimension;import java.awt.Label;import
java.awt.event.WindowAdapter;import
java.awt.event.WindowEvent;import java.awt.FlowLayout;public class Prog72 extends
Frame { public static void main(String
args[]) { new Prog72(); } public Prog72() { setTitle("Prog72"); setSize(200,100);setLayout(new
FlowLayout(FlowLayout.CENTER));
addWindowListener (new WindowAdapter() { public void windowClosing(WindowEvent e) { add(new Label("fini dans 5 secondes !")); pack(); try { Thread.sleep(5000); } catch (InterruptedException ie) { System.exit(1); } setVisible(false); dispose(); System.exit(0); } public void windowDeiconified(WindowEvent e) { Dimension dim=getSize(); setSize(dim.width, dim.height); } }); setVisible(true);
}}
WindowAdapter La classe WindowAdapter est un écouteur prédéfinie (un délégué) qui
implémente l'interface WindowListener (c’est une classe abstraite qui contient 10 méthodes), c’est une classe "écouteur" pour les fenêtres Frame, Dialog, ...
Dans Prog72, nous redéfinissons uniquement les méthodes dont nous avons besoin : windowClosing et windowDeiconified. Cela se fait en mettant l'instanciation d'une classe sans nom qui est sous classe de windowAdapter suivies des redéfinitions de méthodes (cette classe est une inner-classe).
Les Classes Adapters évite l'implémentation de toutes les méthodes abstraites d'une interface Listener.
L'interface WindowListener déclare 7 méthodes abstraites qui sont, dans la classe WindowAdapter définies avec le corps {};
En Pratique, il faut : Créer une sous-classe Ecouteur de WindowAdapter et redéfinir les
méthodes souhaitées : par exemple, public void windowClosing(WindowEvent e) { ... }; et dans le composant à l'"écoute" d'un évènement "fermeture de fenêtre", mettre en place l'écoute : addWindowListener(objetEcouteur);
Ou utiliser la technique d'inner classe décrite ci-dessus.
Application graphique : Editer un fichierimport java.awt.*;
import java.io.*;
import java.awt.event.*;
public class EditerFichier extends Frame implements ActionListener {
TextArea texte;
String messageFichier="Donnez ici un nom de fichier";
String messageTexte="Saisir le texte ici";
TextField champFichier;
public static void main(String[] args) {
new EditerFichier(); }
public EditerFichier() {
this.setTitle("Editer un Fichier");
texte= new TextArea(messageTexte, 20,50);
texte.setEditable(true);
this.add("Center",texte);
champFichier= new TextField(messageFichier,20);
this.add("South",champFichier);
MenuBar barreMenu= new MenuBar(); this.setMenuBar(barreMenu); Menu menuFichier= new Menu("Fichier"); barreMenu.add(menuFichier); MenuItem menuOuvrir= new MenuItem("Ouvrir"); menuOuvrir.addActionListener(this); menuFichier.add(menuOuvrir); MenuItem menuEnregistrer= new MenuItem("Enregistrer"); menuEnregistrer.addActionListener(this); menuFichier.add(menuEnregistrer); MenuItem menuQuitter= new MenuItem("Quitter"); menuQuitter.addActionListener(this); menuFichier.add(menuQuitter); this.pack(); this.setVisible(true); }
public void actionPerformed (ActionEvent e) { String menuSelectionne= e.getActionCommand(); if (menuSelectionne.equals("Quitter")) { this.setVisible(false); this.dispose(); System.exit(0); } else if
(menuSelectionne.equals("Enregistrer")) { if(!
champFichier.getText().equals(messageFichier)) enregistrerFichier(champFichier.getText()); } else if (menuSelectionne.equals("Ouvrir")) if(!
champFichier.getText().equals(messageFichier)) chargerFichier(champFichier.getText()); } public void chargerFichier(String nomFichier) { Fichier fichier= new Fichier(nomFichier); if (!fichier.lirePossible()) { champFichier.setText(messageFichier); return; } texte.setText(""); try { FileReader flotLecture = new FileReader(fichier); long longueurFichier= fichier.length(); int dejaLu = 0;
char car=0;
while (dejaLu < longueurFichier) {
car= (char)flotLecture.read();
dejaLu = dejaLu + 1;
texte.append(String.valueOf(car)); }
flotLecture.close();
} catch (IOException e) {
System.out.println(" erreur :" + e.toString()); }
}
public void enregistrerFichier(String nomFichier) {
Fichier fichier= new Fichier(nomFichier);
if (fichier.ecrirePossible()) {
try {
FileWriter flotEcriture = new FileWriter(fichier);
flotEcriture.write(texte.getText());
flotEcriture.close();
} catch (IOException e) {
System.out.println(" erreur :" + e.toString()); }
texte.setText(messageTexte); }
champFichier.setText(messageFichier);
}}
Application graphique : Editer un fichier
Application graphique : Editer un fichier
Exercice
Le but de ce TP est d'écrire un programme qui permet de tracer des arcs (pleins ou en fil de fer) en lisant au clavier les valeurs de l'angle de départ et la longueur de l'arc à tracer (sous forme d'angle également) :
Longueur de l'arc à tracer
Angle de départ
Exercice
Regarder dans la documentation Java à quoi servent les deux méthodes
drawArc et FillArc de la classe Graphics et comment elles s'utilisent.
Regarder la documentation de la classe Canvas : vous remarquerez
notamment qu'on doit écrire une méthode paint lorsqu'on étend la classe
Canvas.
Regarder à quoi ressemble cette méthode paint dans la classe Canvas,
ainsi que les méthodes update et repaint dans la classe Component.
Ecrire une classe MonCanvas qui étend la classe Canvas et qui a trois
attributs : angleDebut et angleTotal sont des entiers et permettent de
savoir à partir de quel angle on dessine et sur quelle longueur d'arc, le
booléen plein indique si on dessine en fil de fer (false) ou pas (true); cette
classe contiendra une méthode paint.
Exercice
Ecrire la méthode paint qui permet de dessiner l'arc (soit plein, soit en fil
de fer) en rouge (utiliser setColor de la classe Graphics), ainsi que les
deux axes du repère en noir, et éventuellement des graduations comme
sur la figure ci-dessous (utiliser pour cela la méthode getBounds de la
classe Component ou les méthodes getWidth et getHeight).
Ecrire une classe MonPanel permettant de mettre en place l'interface du
programme : les boutons en bas, le canvas au dessus.
On pourra tout écrire dans le constructeur, sans rien mettre en
attribut.
Ecrire une classe MonEcouteur qui contient deux attributs de type
TextField et un attribut de type Canvas. Cette classe est chargée de
mettre à jour le booléen plein et les deux entiers angleDebut et
angleTotal et de rafraichir l'affichage lorsqu'on clique sur l'un des
boutons.
Ecrire une classe TestCanvas contenant une méthode main pour tester le
programme.
Révision
Héritage entre composants
Object
Component
Window
Frame
Button CanvasCheckboxContainerLabel
List
Panel
Graphics
Applet
Classes abstraites
Fenêtre top-levelFenêtre ordinaire
MenuComponent
MenuItem
CheckboxMenuItem Menu
MenuBar
Geometry manager
BorderLayout :
Divise un composant container en 5 zones: North, East, South, West,
Center.
Constructeurs :
BorderLayout() crée 5 zones.
BorderLayout(int hspacing, int vspacing) idem avec un
espacement spécifié.
La méthode add doit être utilisé ainsi : add ("North", composant).
Les frames sont gérées par défaut par le gestionnaire
BorderLayout
Geometry manager
FlowLayout :
Range de gauche à droite et de haut en bas.
Constructeurs :
FlowLayout() range les composants en les centrant avec un
"vspacing et hspacing" (espace vertival, respectivement
horizontal) de 5 pixels.
FlowLayout(int aligne) range les composants en les alignant
selon aligne : FlowLayout.LEFT, FlowLayout.CENTER,
FlowLayout.RIGHT avec un vspacing et hspacing de 5 pixels.
FlowLayout(int aligne, int hspacing, int vspacing) range selon
l'alignement et le vspacing et le hspacing spécifiés.
Le geometry manager de Panel est par défaut le
FlowLayout manager
Geometry manager
GridLayout :
Range dans une grille/matrice de gauche à droite et de haut en
bas.
Constructeurs :
GridLayout(int ligne, int colonne) range les composants dans la
grille de rangement.
GridLayout(int ligne, int colonne, int hspacing, int vspacing)
idem avec le vspacing et le hspacing spécifiés.
setLayout détermine le nouveau geometry manager
Evénements en résumé
Composant Action Evénement Interface d'écoute
Button, List, MenuItem, TextField, Checkbox,
Canvas
Sélectionner, valider
ActionEvent ActionListener
TextArea, TextField
Changer le texte TextEvent TextListener
Frame Ouvrir, fermer WindowEvent WindowListenerContainer Mouvement et
clic de souris, frappe au clavier
MouseEvent, MouseMotionEve
nt, KeyEvent
MouseListener, MouseMotionListener, KeyListener