Chapitre 7 Java Abstract Window Toolkit

Chapitre 7 Java Abstract Window Toolkit
A. Nejeoui

Abstract Window Toolkit
Introduction L’API Java offre un ensemble de packages qui permettent aux programmeurs de concevoir des applications basés sur des interfaces graphiques, la collecte des information se traduit par des interaction entre l’utilisateur et les composants de l’interface graphique (click de souris, frappes de clavier et autres ..). Dans ce chapitre on va voir comment utiliser le package java.awt pour construire des interfaces graphiques. Les objectifs de ce chapitre : Décrire le package java.awt et ces composants. Définir les termes : conteneur, composant, gestionnaire de positionnement, et voir comment ces composants collaborent pour construire une interface graphique. Utiliser les gestionnaires de positionnement : FlowLayout, BorderLayout, GridLayout, CardLayout, GridBagLayout Utiliser les conteneurs : Window, Frame, Panel … Construire des interfaces graphique complexe par imbrication de conteneurs. Abstract Window Toolkit

GUI - historique GUI (Graphical User Interface). Opposé à Command-line interface. Interface (dialogue avec l’utilisateur) utilisant les capacités graphiques des ordinateurs pour faciliter l’utilisation et la gestion de l’ordinateur. 1981 : Xerox STAR " Multifenetrage " et Souris 3 boutons Machine Apple Lisa en 1983 Macintosh en 1984. MS Windows à partir de 1985 Abstract Window Toolkit

AWT - historique La bibliothèque AWT a été la première interface graphique (GUI) livrée avec Java dans sa première version, version 1,0 (1995). A cette époque , l’utilisation de la bibliothèque AWT était indispensable pour tout programmeur en Java qui désirait intégrer une interface graphique dans ses applications, AWT permet d’afficher et de manipuler des fenêtres, des boutons, et d'autres composants graphiques. AWT est également responsable de la gestion des événements générées par les composants graphiques, comme les clics de souris et les événements de clavier. Ces événements sont captés par la MVJ et sont envoyés comme des événement objets de classes AWT. Abstract Window Toolkit

AWT - historique Dans la version JDK 1.1 SunMicrosystem a lancé un nouveau package appelé swing (en Mars 1998) qui supporte tous les composant graphiques offerts par l’AWT et y ajoute d’autres composants , Aujourd’hui AWT vit avec et peut être utilisé maintenant exactement comme il l’était au commencement, C'est-à-dire on peut toujours utiliser l’AWT pour créer des fenêtres et des composants d'interface graphique, mais la plupart des développeurs des applications Java préfèrent Swing, car il fournit une plus grande flexibilité et environnement de développement d'interface graphique plus puissant. Toutefois, AWT est considéré comme une ressource critique dans le processus de construction d’interfaces graphique que se soit sous swing, swt (Standard Widget Toolkit), JFace, SwingX … Abstract Window Toolkit

Java et les Systèmes de fenêtrage
Problème : les systèmes de gestion d'interface utilisateur (GUI Graphical User Interface systems) sont très différents les uns des autres : X Window + motif X Window + gtk MacOS X MS Windows …etc. Deux stratégies possibles : faire une utilisation maximale du système graphique cible (composants lords ou « heavy weight components») 1- faire une utilisation minimale du système graphique cible (composants légers light weight component). Abstract Window Toolkit

Java et les Systèmes de fenêtrage
2- Faire une utilisation maximale du système graphique sous-jacent le composant java délègue la plupart de ses tâches à un composant natif. Par exemple le programmeur java utilise un objet TextField Objet TextField délègue à une classe adaptateur dépendant de l'OS : MotifTextField, GTKTextField, WindowsTextField, MacOSTextField .... Le système graghique natif réalise la plus grande partie du travail Abstract Window Toolkit

Avantages et inconvénients (composants lords)
apparence et le comportement (look and feel) des interfaces Java identique à celui d'applications "ordinaires" pas besoin de réimplémenter des composants existants Inconvénients ne permet de ne fournir que les composants disponibles sur toutes les plateformes difficile de garantir un comportement identique sur toutes les plateformes (portabilité). Ce Choix est adopté dans JAVA AWT ( AWT Abstract Window Toolkit) packages java.awt.* présents dans Java depuis version 1.0. Abstract Window Toolkit

Les composants awt Java.awt est constitué de plusieurs classes. Pour bien comprendre les fonctionnalités offertes par ce package on va présenter les classes les plus utilisées dans ce package et expliquer la relation entre ses différents composants. Abstract Window Toolkit

La classe component La classe component est une classe abstraite qui représente la classe des objets qui possèdent une représentation graphique qu’on peut afficher à l’écran et qui interagissent avec l’utilisateur. Toute personne utilisant un PC est familier avec les composants : fenêtres, boutons, cases à couché … void SetBackground(Color) void SetSize(int, int) int getWidth() int getHeight() setLocation(int x, int y) // positionner le coins supérieur gauche du //composant. Point getLocationOnScreen() Abstract Window Toolkit

Label Lorsque vous réaliser une application graphique, il est important d’y ajouter suffisamment de libellés afin de faciliter l’ergonomie de cette dernière. Vous devrez pour cela utiliser la classe Label qui est l’un des composants awt les plus simples. Il permet d’afficher du texte dans n’importe quelle position. Voici un descriptif des méthodes les plus employées : Label() Crée un libellé vide Label(String) Crée un libellé avec du texte Label(String, int) Crée un libellé avec du texte aligné horizontalement setText(String) Permet de spécifier le texte pour le label. setBackground(Color) pour définir la couleur de l’arrière plan Abstract Window Toolkit

Les Labels Abstract Window Toolkit

Button Button est un bouton poussoir classique très simple. Nous pouvons lui ajouter un texte comme label ou encore appliquer des couleurs arrière et d’avant plan. De plus on peut ajouter des listeners (ActionListener…) pour capturer les évènements. Nous reviendrons en détail sur cette partie dans le chapitre 8 : La gestion des évènements Voici un descriptif des méthodes les plus employées : Button() Button(String) getLabel() setLabel(String) void addActionListener(ActionListener) Ajouter le bouton à un ActionListener. Abstract Window Toolkit

Button Abstract Window Toolkit

Checkbox et CheckboxGroup
Une CheckBox est une case à cocher, on peut ajouter un libellé à se composant directement lors de sa création afin de rendre plus explicite son utilisation. Il faut pour cela utiliser le constructeur suivant : CheckBox("un label"). Les CheckBox sont utilisés lors de choix multiples que l’utilisateur doit réaliser par le biais de l’interface graphique. Le CheckboxGroup sert à regrouper un ou plusieurs case à coucher de telle manière à ce que une seule case soit couchée, voir l’exemple suivant : Voici un descriptif de quelque méthodes les plus employées : Checkbox() Checkbox(String label) Checkbox(String label, boolean state) Checkbox(String label, boolean state, CheckboxGroup group) Abstract Window Toolkit

Checkbox et CheckboxGroup
Abstract Window Toolkit

Choice Les composants Checkbox et CheckboxGroup provoquent un problème lorsqu’on a à gérer un grand nombre de choix, ces composants consomment une grande partie de l’espace réservé à l’interface graphique. Le composant Choice a été créer pour pallier à ce problème il permet d’utiliser efficacement l’espace graphique. Choice(); addItem(String choix) Abstract Window Toolkit

Choice Abstract Window Toolkit

List Entre CheckboxGroup et Choice on trouve un autre composant : List. Avec List le programmeur peut spécifier le nombre de choix visible, les autres choix sont toujours disponible moyennant un menue déroulant. Par contre à Choice, Liste permet de faire multiple choix. List() // tous les éléments sont visibles List(int nbr) // seules nbr éléments sont visibles List(int nbr, boolean multipleMode) // seules nbr éléments sont visibles avec possibilité de choix multiple si multipleMode=true. Abstract Window Toolkit

List Abstract Window Toolkit

TextComponent Deux composants de java.awt sont disponibles pour saisir du texte à partir du clavier : TextField pour une seule ligne de texte et TextArea pour plusieurs lignes de texte. Voici un descriptif de quelque méthodes les plus employées : tf1 = new TextField(); // Zone de texte vide tf2 = new TextField("", 20); // Zone de texte vide avec 20 colonnes tf3 = new TextField("Hello!"); // Zone de texte avec un texte par défaut tf4 = new TextField("Hello", 30); // Zone de texte avec un texte par défaut sur 30 colonnes. TextArea() TextArea(int rows, int columns) TextArea(String text) TextArea(String text, int rows, int columns) TextArea(String text, int rows, int columns, int scrollbars) scrollbars== SCROLLBARS_BOTH, SCROLLBARS_VERTICAL_ONLY, SCROLLBARS_HORIZONTAL_ONLY, SCROLLBARS_NONE. Abstract Window Toolkit

TextField et TextArea Abstract Window Toolkit

ScroollBar Java offre deux composants dont leurs seul but est de générer des événements : Button et ScrollBar. (tous les autres composants peuvent générer des évenements mais c’est pas la seule fonctionnalité qu’ils remplissent) . Tous le monde est familier avec les barres de défilement (ScrollBars), on les utilise avec les éditeurs de texte dans les pages web…etc. Comme on l’a déjà cité les ScrollBar génèrent seulement des événement lorsqu’un utilisateur agit sur eux. Le développeur est responsable de gérer correctement ces événements pour réaliser la fonction désirée. Notez bien que plusieurs composants awt dispose de leur inhérents ScrollBars ce qui facilite énormément la tâche (TextArea, ScrollPane …) Abstract Window Toolkit

Les conteneurs L’interface graphique utilisateur est représenté par une hiérarchie de composants graphiques que l’on peut schématiser sous forme d’arbre. Dans ce cas les feuilles représentent des composants. Les noeuds, eux, qui sont constitués de composants sont appelés conteneurs. En AWT, tous les conteneurs dérivaient de java.awt.Container. Un objet de type Container est un conteneur awt qui peut contenir d’autres composants awt. Les composant ajoutés à un conteneurs sont rangés dans une liste , si aucun index n’a était spécifié lors de l’ajout, le composant est rangé dans le dernier élément de la liste. La classe Container contient en particulier différentes formes de méthodes add et remove permettant respectivement l'ajout et la suppression d'un composant dans le conteneur courant dont on peut citer : add(Component comp) add(Component comp, int index) getComponent(int n) setLayout(LayoutManager mgr) setVisible(boolean b) Abstract Window Toolkit

Les conteneurs Abstract Window Toolkit

Panel Il s'agit du type de conteneur le plus simple. Le gestionnaire de placement par défaut en est FlowLayout. Une application peut y attacher tout type de composants. Un panaeau (Panel) est tout simplement un espace auquel vous pouvez attachez d’autres composants y compris d’autres paneau (voir l’exemple qui suit). Panel accepte deux constructeurs : Panel() Panel(LayoutManager layout) Abstract Window Toolkit

Panel Abstract Window Toolkit

Il s'agit d'une fenêtre sans bordures ni barre de menu dont le gestionnaire de positionnement par défaut est de type BorderLayout. Lors de sa construction elle doit appartenir à une instance de Frame (ou une instance de Dialog ou une autre instance d’un Window). Les instances de cette classe sont typiquement utilisées pour acquérir des données de l'utilisateur. (Rarement instanciée directement, on utilise ses sous-classes Dialog et Frame). Quelques constructeurs : Window(Frame owner) Window(Window owner) Abstract Window Toolkit

Frame Il s'agit d'une fenêtre avec titre, bordure, boutons de minimisation, maximisation et fermeture (gestionnaire par défaut BorderLayout). A sa création, une instance est invisible jusqu'à ce que lui appliquée la méthode setVisible(true). Frame vous permet de changer le curseur de la souris, définir une icône image, et avoir des menus. Parmi les méthodes de la classe, citons void setVisible(boolean b); void setTitle (String titre); MenuBar getMenuBar() void setCursor(Cursor c); Abstract Window Toolkit

Frame Abstract Window Toolkit

Dialog (boîte de dialogue)
C’est une fenêtre de dialogue avec titre et bordures. Une boite Dialogue est toujours attaché à une autre fenêtre quand il est construite. Lorsque le propriétaire d'une boite de Dialogue est minimisé, la Une boite sera automatiquement cacher à l'utilisateur. Lorsque le propriétaire est affiché, la boîte de Dialogue est affichée. Quelques méthodes : Dialog(Dialog owner) Dialog(Dialog owner, String title) Dialog(Frame owner) Dialog(Window owner) setTitle(String title) setVisible(boolean b) Abstract Window Toolkit

Dialog Abstract Window Toolkit

FileDialog fournit une boîte de dialogue préfabriquée qui interagit avec le système de fichiers. Cette fenêtre implémente la boîte de dialogue Open / Save native du système de fenêtrage . Quelques méthodes : FileDialog(Frame parent, String title,int mode) // mode =FileDialog.LOAD ou FileDialog.SAVE void setFile(String file) void setDirectory(String dir) String getFile() Abstract Window Toolkit

ScrollPane Ce composant a été introduit dans la version jdk 1.1, avant si vous avez besoins par exemple de créer un panneau de 200x200 mais vous voulez y ranger un contenu qui dépasse cette taille, le seule moyen c’est de définir un Panel avec BorderLayout comme gestionnaire de positionnement et par la suite ajouter deux ScrollBar pour gérer le défilement (un en bas et l’autre à droite et évidement gérer les événements associés). Avec la version 1.1 est supérieur vous n’avez qu’ à créer un ScrollPane en indiquant ce que vous voulez défiler et c’est tout. Quelques méthodes : ScrollPane() // par défaut SCROLLBARS_AS_NEEDED ScrollPane(int scrollbarDisplayPolicy) // SCROLLBARS_ALWAYS SCROLLBARS_AS_NEEDED SCROLLBARS_NEVER Abstract Window Toolkit

ScrollPane Abstract Window Toolkit

Les gestionnaire du positionnement
Le positionnement des composants dans les conteneurs est l'affaire des gestionnaires de positionnement, ou Layout Managers, qui se chargent : - du positionnement initial des composants, lors des appels de la méthode add, - le cas échéant, de donner une taille et une forme a chaque composant, en fonction de sa « taille préférée », de son contenu et de sa disposition relativement aux autres composants dans le même conteneur, - du repositionnement des composants lorsque la taille ou la forme du conteneur change. Chaque conteneur (Window, Panel, Applet ..) posséde son propre LayoutManager. Par conséquent, sur un même écran, on peut construire plusieurs conteneurs avec pour chacun une positionnement spécifique. Il y a 5 gestionnaires FlowLayout , GridLayout, BorderLayout, CardLayout, GridbagLayout. Abstract Window Toolkit

FlowLayout (flot) C'est le plus simple des 5 gestionnaires : il ajoute les composants en les alignant sur le panneau courant, ligne par ligne et de gauche à droite. Par défaut les composants sont centrés horizontalement et écartés entre eux de 5 pixels, mais on peut changer cela au moment de l'instanciation par exemple : Pour aligner à gauche ou à droite, ajouter un argument. setLayout( new FlowLayout( FlowLayout.LEFT) ); Pour imposer un espacement des composants horizontalement, puis verticalement : setLayout( new FlowLayout( FlowLayout.LEFT, 30 , 10) ); Sur un objet Panel (panneau), la positionnement par défaut est FlowLayout il est donc inutile d'indiquer un paramètre de positionnement si vous voulez utiliser FlowLayout. Abstract Window Toolkit

FlowLayout (flot) Abstract Window Toolkit

BorderLayout (bordure)
Ce gestionnaire permet de placer les objets dans un conteneur suivant 5 positions indiquées par la valeur d'un paramètre de positionnement de type chaîne de caractères : North, South, East, West, Center. C'est le gestionnaire par défaut pour un objet Window, Frame, Dialog. Abstract Window Toolkit

GridLayout (grille de rangement)
Ce gestionnaire permet d'imposer un positionnement des composants en les plaçant dans les cases d'une grille rectangulaire. Il ajoute les composants en les alignant sur le panneau courant, ligne par ligne et de gauche à droite. Toutes les cases de cette grille ont les mêmes dimensions. Constructeurs grille verticale à une seule colonne GridLayout(); grille de dimension donnée public GridLayout(int nb_lignes, int nb_colonnes); définition en plus des espacements entre les éléments public GridLayout(int nb_lignes, int nb_colonnes, int espace_h, int espace_v); Abstract Window Toolkit

GridLayout Abstract Window Toolkit

GridBagLayout Un gestionnaire GridBagLayout est plus puissant, mais bien plus complexe que les précédents. Il se base sur un quadrillage imaginaire du conteneur tel que l'espace occupé par chaque composant soit une région rectangulaire formée par la réunion d'un certain nombre de cases de ce quadrillage. Lors de son ajout au conteneur, chaque composant est associe a une certaine contrainte qui spécifie quelles cases du quadrillage imaginaire le composant occupe et comment il les occupe. Ensemble, toutes ces contraintes définissent les dimensions des lignes et des colonnes du quadrillage. Abstract Window Toolkit

GridBagLayout Abstract Window Toolkit

GridBagConstraints GradBagLayout est une ardoise blanche, les contraintes attachées à chaque composant déterminent la manière dont GradBagLayout affiche ses composants. Les contraintes sont des instances de la classe GridBagConstraints, dont les principaux champs sont : gridx : numero de la colonne du quadrillage (la premiere colonne porte le numero 0) ou se place l'angle superieur gauche du composant. gridy : numero de la ligne du quadrillage (la premiere ligne porte le numero 0) ou se place l'angle superieur gauche du composant. Abstract Window Toolkit

GridBagConstraints gridheight : nombre de lignes du quadrillage sur lesquelles le composant s'étend. gridwidth : nombre de colonnes du quadrillage sur lesquelles le composant s'etend. weightx : nombre exprimant la largeur de la colonne que le composant occupe ; peu importe l'unité, à condition que ce soit la même pour toutes les colonnes. // pour gérer la distribution de l’espace supplémentaire. Mettez 0 si ce composant s'entend sur plusieurs colonnes ou si la largeur peut se déduire de la contrainte d'un autre composant de cette colonne. weighty : nombre exprimant la hauteur de la ligne que le composant occupe ; peu importe l'unité, à condition que ce soit la même pour toutes les lignes. Mettez 0 si ce composant s'étend sur plusieurs lignes ou si la hauteur peut se déduire de la contrainte d'un autre composant de cette ligne. Abstract Window Toolkit

GridBagConstraints fill : indication de la manière dont le composant doit remplir sa zone. Les valeurs possibles sont : - GridBagConstraints.NONE : le composant doit garder sa taille propre, - GridBagConstraints.HORIZONTAL : le composant doit remplir toute la largeur de sa zone, - GridBagConstraints.VERTICAL : le composant doit remplir toute la hauteur de sa zone, - GridBagConstraints.BOTH : le composant doit remplir toute sa zone. anchor : position du composant dans sa zone, s'il ne la remplit pas entièrement. Les valeurs possibles sont : GridBagConstraints.NORTH (au nord), GridBagConstraints.NORTHEAST (au nord-est), GridBagConstraints.EAST (a l'est), GridBagConstraints.SOUTHEAST (au sud-est), etc. Abstract Window Toolkit

CardLayout Le gestionnaire de positionnement CardLayout est significativement différent des autres gestionnaires, tandis que les autres gestionnaires affichent tous les composants à la fois, CardLayout affiche seulement un composant à chaque fois. Quelques méthode : next(Container parent) // accéder au composant suivant du conteneur parent show(Container parent, String name) // accéder au composant du conteneur qui a été ajouter par le nom name avec la méthode add(String name, Component comp) définie dans java.awt.Container Abstract Window Toolkit

CardLayout Abstract Window Toolkit

Complexe LayoutManager
Les GridBagLayout ne sont pas les seuls outils pour la construction de gestionnaires d'interfaces graphiques complexes. Une autre manière de monter de telles interfaces, plus souple et plus simple, consiste a imbriquer plusieurs panneaux (objets Panel) les uns dans les autres, chacun muni d'un gestionnaire de positionnement adéquat. Voir l’exemple suivant : Abstract Window Toolkit

Complexe LayoutManager

Gestion manuelle de positionnement
il est possible (mais non recommandé) de se passer complètement de gestionnaire de disposition. Cela doit être explicitement demandé, par l'instruction conteneur.setLayout(null); A la suite de cette instruction, chaque composant devra être explicitement dimensionne et positionne lors de son ajout au conteneur (cela génère énormément de calculs avec des pixels !). Les methodes pour cela sont : void setLocation(int x, int y) et void setLocation(Point p) définit la position du coin supérieur gauche du composant, relativement a une origine qui est placée au coin supérieur gauche du conteneur. void setSize(int width, int height), void setSize(Dimension d) définit les dimensions du composant, void setBounds(int x, int y, int width, int height) et void setBounds(Rectangle r) remplit simultanément les fonctions de setLocation et celles de setSize. Abstract Window Toolkit

Attention Lorsque les composants ont été placés manuellement il y a intérêt a interdire les changements de taille et de forme du conteneur. Cela s'obtient par l‘instruction conteneur.setResizable(false); Attention. Certains programmeurs débutants, rebutés par la difficulté qu'il y a parfois a obtenir d'un gestionnaire de disposition qu'il fasse ce qu‘ils veulent, choisissent de placer manuellement les composants. L'expérience montre que, sauf de rares exceptions, se passer de gestionnaire de disposition n'est pas la manière la plus simple de réaliser une interface graphique. Abstract Window Toolkit

Les Menus awt La création de menus se fait très simplement en Java, à l'aide de 4 classes différentes qui héritent toutes de la classe MenuComponent. Une barre de menu se compose d'une instance de la classe MenuBar auquel vous pouvez ajouter grâce à la méthode add () un ou plusieurs menus instances de la classe Menu. Finalement, vous pouvez ajouter à chaque menu grâce à la méthode add () de la classe Menu un ensemble d'éléments instances des classes MenuItem (pour créer des éléments simples), CheckboxMenuItem (pour créer des éléments à cocher) ou Menu (pour créer un sous-menu). Abstract Window Toolkit

Les menues awt Abstract Window Toolkit

Les Menus awt La classe Frame est la seule classe de fenêtre pour laquelle vous pouvez spécifier une barre de menu, grâce à la méthode setMenuBar (). Par conséquent, vous ne pouvez pas donner de menu aux Windows,Dialog … puisque leurs classes n'héritent pas de la classe Frame. setMenuBar ( méthode définie dans la classe Frame) public void setMenuBarn(MenuBar mb) Modifie La barre de menu pour cette frame par la barre de menue spécifiée. Paramètres: mb - the menu bar being set. Si ce paramètre est null, dans ce cas la barre de menue courante est supprimer. Abstract Window Toolkit

MenuComponent La classe MenuComponent qui est abstract est la super classe de toutes les classes de composants utilisables dans un menu (MenuBar, MenuItem, Menu et CheckboxMenuItem). Elle ressemble dans le principe à la classe Component en plus simple. Constructeur public MenuComponent () Quelques Méthodes public MenuContainer getParent () // retourne le conteneur parent de ce menu public Font getFont () et public void setFont (Font font) Ces méthodes permettent d'interroger ou de modifier la police de caractère utilisée pour l'affichage d'un composant de menu. public String toString () Cette méthodes redéfinit la méthode toString() de la classe Object affiche une chaine de caractères décrivant le composant de menu. Abstract Window Toolkit

MenuBar Cette classe qui dérive de la classe MenuComponent, est la classe du package java.awt qui permet de créer et de manipuler une barre de menu. Une fois que vous avez créez une barre de menu vous pouvez y ajouter un ou plusieurs menus. La méthode setMenuBar () de classe Frame permet de spécifier la barre de menu que doit utiliser une fenêtre. Constructeur public MenuBar () Quelques Méthodes public Menu add (Menu menu) // Permet d'ajouter un menu à une barre de menu. public void remove (int index) public void remove (MenuComponent menu) Ces méthodes permettent de supprimer un menu d'une barre de menu, soit en donnant son numéro d'ordre index, soit en donnant directement l'instance de menu à supprimer. Abstract Window Toolkit

MenuBar public int getMenuCount() Renvoie le nombre de menus courant d'une barre de menu. public Menu getMenu (int index) Renvoie le menu dont le numéro d'ordre est index. public Menu getHelpMenu () public void setHelpMenu (Menu m) Ces méthodes permettent d'interroger ou de modifier le menu d'aide. Abstract Window Toolkit

MenuItem Cette classe qui dérive de la classe MenuComponent, est la classe du package java.awt qui permet de créer et de manipuler un élément simple de menu. Un élément de menu a un label qui est le texte affiché dans le menu et peut être éventuellement grisé pour indiquer qu'il n'est pas utilisable à un moment donné. Constructeur public MenuItem (String label) Ce constructeur permet de donner un label au nouveau menu créé. Quelques Méthodes public String getLabel () public void setLabel (String label) Public void addActionListener (ActionListener l) // enregistre l’auditeur l pour écouter des événement de type ActionEvent Abstract Window Toolkit

MenuItem Ces méthodes permettent d'interroger ou de modifier le label d'un menu. public boolean isEnabled () Renvoie true si un élément de menu est utilisable. public void enable () public void disable () public void enable (boolean cond) Vous pouvez rendre utilisable ou inutilisable un composant grâce à ces méthodes. Un élément de menu inutilisable (disabled) est généralement grisé. public String paramString () Méthode de la classe MenuComponent, redéfinie pour renvoyer une chaîne de caractères décrivant l'élément de menu. Abstract Window Toolkit

Menu Cette classe qui dérive des classes MenuItem et MenuComponent est la classe du package java.awt qui permet de créer et de manipuler un menu ou un sous-menu. Un menu a un label et peut contenir un ou plusieurs éléments ; les éléments qui sont eux-mêmes des instances de la classe Menu deviennent des sous-menus. Constructeurs public Menu (String label) Quelque Méthodes public void setEnabled(boolean b) Permet d’activer / désactiver un menu Abstract Window Toolkit

Menu public int countItems () Renvoie le nombre d'éléments d'un menu. public MenuItem getItem (int index) Renvoie l'élément du menu de numéro d'ordre index. public MenuItem add (MenuItem menuItem) public void add (String label) Ces méthodes permettent d'ajouter un élément à un menu. public void addSeparator () Permet d'ajouter un séparateur à un menu. Equivalent à l'appel de la méthode add ("-"). public void remove (int index) public void remove (MenuComponent item) Ces méthodes permettent de retirer d'un menu l'élément de numéro d'ordre index ou l'élément item. Abstract Window Toolkit

CheckboxMenuItem Cette classe qui dérive des classes MenuItem et MenuComponent est la classe du package java.awt qui permet de créer et de manipuler un élément de menu à cocher. Comme un composant de classe Checkbox, ce type d'élément de menu a un état coché ou non. Constructeur CheckboxMenuItem() public CheckboxMenuItem (String label) CheckboxMenuItem(String label, boolean Etat) Quelques Méthodes public boolean getState () public void setState (boolean t) Ces méthodes permettent d'interroger ou de modifier l'état coché ou non de l'élément de menu. public String paramString () Méthode de la classe MenuComponent, redéfinie pour renvoyer une chaîne de caractères décrivant l'élément de menu à cocher. Abstract Window Toolkit

Conclusion Abstract Window Toolkit

Chapitre 7 Java Abstract Window Toolkit

Présentations similaires

Présentation au sujet: "Chapitre 7 Java Abstract Window Toolkit"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Chapitre 7 Java Abstract Window Toolkit

Présentations similaires

Présentation au sujet: "Chapitre 7 Java Abstract Window Toolkit"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back