41. Les éléments d'interfaces graphiques de l'AWT

Niveau :

Intermédiaire

API legacy Ce chapitre est conservé pour des raisons historiques

Les classes du toolkit AWT (Abstract Windows Toolkit) permettent d'écrire des interfaces graphiques indépendantes du système d'exploitation sur lesquel elles vont fonctionner. Cette librairie utilise le système graphique de la plate-forme d'exécution (Windows, MacOS, X-Window) pour afficher les objets graphiques. Le toolkit contient des classes décrivant les composants graphiques, les polices, les couleurs et les images.

Le diagramme ci-dessus définit une vue partielle de la hiérarchie des classes (les relations d'héritage) qu'il ne faut pas confondre avec la hiérarchie interne à chaque application qui définit l'imbrication des différents composants graphiques.

Les deux classes principales d'AWT sont Component et Container. Chaque type d'objet de l'interface graphique est une classe dérivée de Component. La classe Container, qui hérite de Component est capable de contenir d'autres objets graphiques (tout objet dérivant de Component).

Ce chapitre contient plusieurs sections :

• Les composants graphiques
• La classe Component
• Les conteneurs
• Les menus
• La classe java.awt.Desktop

41.1. Les composants graphiques

Pour utiliser un composant, il faut créer un nouvel objet représentant le composant et l'ajouter à un conteneur existant grâce à la méthode add().

import java.applet.*;
import java.awt.*;

public class AppletButton extends Applet {

   Button b = new Button(" Bouton ");

   public void init() {
      super.init();
      add(b);
   }
}

41.1.1. Les étiquettes

Il faut utiliser un objet de la classe java.awt.Label

Label la = new Label( );
la.setText("une etiquette");
// ou Label la = new Label("une etiquette");

Il est possible de créer un objet de la classe java.awt.Label en précisant l'alignement du texte

Label la = new Label("etiquette", Label.RIGHT);

Le texte à afficher et l'alignement peuvent être modifiés dynamiquement lors de l'exécution :

la.setText("nouveau texte");
la.setAlignment(Label.LEFT);

41.1.2. Les boutons

Il faut utiliser un objet de la classe java.awt.Button

Cette classe possède deux constructeurs :

Button bouton = new Button();
bouton.setLabel("bouton");
// ou Button bouton = new Button("bouton");

Le libellé du bouton peut être modifié dynamiquement grâce à la méthode setLabel() :

bouton.setLabel("nouveau libellé");

41.1.3. Les panneaux

Les panneaux sont des conteneurs qui permettent de rassembler des composants et de les positionner grâce à un gestionnaire de présentation. Il faut utiliser un objet de la classe java.awt.Panel.

Par défaut le gestionnaire de présentation d'un panel est de type FlowLayout.

Panel p = new Panel();

L'ajout d'un composant au panel se fait grâce à la méthode add().

p.add(new Button("bouton"));

41.1.4. Les listes déroulantes (combobox)

Il faut utiliser un objet de la classe java.awt.Choice

Cette classe ne possède qu'un seul constructeur sans paramètres.

Choice maCombo = new Choice();

Les méthodes add() et addItem() permettent d'ajouter des éléments à la combobox.

maCombo.addItem("element 1");
// ou maCombo.add("element 2");

Plusieurs méthodes permettent la gestion des sélections :

Méthodes	Rôle
void select( int );	sélectionner un élément par son indice : le premier élément correspond à l'indice 0. Une exception IllegalArgumentException est levée si l'indice ne correspond pas à un élément. Exemple ( code Java 1.1 ) : maCombo.select(0);
void select( String);	sélectionner un élément par son contenu Aucune exception n'est levée si la chaîne de caractères ne correspond à aucun élément : l'élément sélectionné ne change pas. Exemple ( code Java 1.1 ) : maCombo.select("element 1");
int countItems( );	déterminer le nombre d'éléments de la liste. La méthode countItems() permet d'obtenir le nombre d'éléments de la combobox. Exemple ( code Java 1.1 ) : int n; n=maCombo.countItems(); il faut utiliser getItemCount() à la place Exemple ( code Java 1.1 ) : int n; n=maCombo.getItemCount();
String getItem( int );	lire le contenu de l'élément d'indice n Exemple ( code Java 1.1 ) : String c = new String( ); c = maCombo.getItem(n);
String getSelectedItem();	déterminer le contenu de l'élément sélectionné Exemple ( code Java 1.1 ) : String s = new String( ); s = maCombo.getSelectedItem();
int getSelectedIndex( );	déterminer l'index de l'élément sélectionné Exemple ( code Java 1.1 ) : int n; n=maCombo.getSelectedIndex();

41.1.5. La classe TextComponent

La classe TextComponent est la classe mère des classes qui permettent l'édition de texte : TextArea et TextField.

Elle définit un certain nombre de méthodes dont ces classes héritent.

41.1.6. Les champs de texte

Il faut déclarer un objet de la classe java.awt.TextField

Il existe plusieurs constructeurs :

Cette classe possède quelques méthodes utiles :

Méthodes	Rôle
String getText( )	lecture de la chaîne saisie Exemple ( code Java 1.1 ) : String saisie = new String(); saisie = tf.getText( );
int getColumns( )	lecture du nombre de caractères prédéfini Exemple ( code Java 1.1 ) : int i; i = tf.getColumns( );
void setEchoCharacter()	pour la saisie d'un mot de passe : remplace chaque caractère saisi par celui fourni en paramètre Exemple ( code Java 1.1 ) : tf.setEchoCharacter('*'); TextField tf = new TextField(10); il faut utiliser la méthode setEchoChar() Exemple ( code Java 1.1 ) : tf.setEchoChar('*');

41.1.7. Les zones de texte multilignes

Il faut déclarer un objet de la classe java.awt.TextArea

Il existe plusieurs constructeurs :

Les principales méthodes sont :

Méthodes	Rôle
String getText()	lecture du contenu intégral de la zone de texte Exemple ( code Java 1.1 ) : String contenu = new String; contenu = ta.getText( );
String getSelectedText( )	lecture de la portion de texte sélectionnée Exemple ( code Java 1.1 ) : String contenu = new String; contenu = ta.getSelectedText( );
int getRows()	détermination du nombre de lignes Exemple ( code Java 1.1 ) : int n; n = ta.getRows( );
int getColumns( )	détermination du nombre de colonnes Exemple ( code Java 1.1 ) : int n; n = ta.getColumns( );
void insertText(String, int)	insertion de la chaîne à la position fournie Exemple ( code Java 1.1 ) : String text = new String("texte inséré"); int n =10; ta.insertText(text,n); Il faut utiliser la méthode insert() Exemple ( code Java 1.1 ) : String text = new String("texte inséré"); int n =10; ta.insert(text,n);
void setEditable(boolean)	Autoriser la modification Exemple ( code Java 1.1 ) : ta.setEditable(False); //texte non modifiable
void appendText(String)	Ajouter le texte transmis au texte existant Exemple ( code Java 1.1 ) : ta.appendTexte(String text); Il faut utiliser la méthode append()
void replaceText(String, int, int)	Remplacer par text le texte entre les positions start et end Exemple ( code Java 1.1 ) : ta.replaceText(text, 10, 20); il faut utiliser la méthode replaceRange()

41.1.8. Les listes

Il faut déclarer un objet de la classe java.awt.List.

Il existe plusieurs constructeurs :

Les principales méthodes sont :

Méthodes	Rôle
void addItem(String)	ajouter un élément Exemple ( code Java 1.1 ) : li.addItem("nouvel element"); // ajout en fin de liste il faut utiliser la méthode add()
void addItem(String, int)	insérer un élément à un certain emplacement : le premier élément est en position 0 Exemple ( code Java 1.1 ) : li.addItem("ajout ligne",2); il faut utiliser la méthode add()
void delItem(int)	retirer un élément de la liste Exemple ( code Java 1.1 ) : li.delItem(0); // supprime le premier element il faut utiliser la méthode remove()
void delItems(int, int)	supprimer plusieurs éléments consécutifs entre les deux indices Exemple ( code Java 1.1 ) : li.delItems(1, 3); cette méthode est deprecated
void clear()	effacement complet du contenu de la liste Exemple ( code Java 1.1 ) : li.clear( ); il faut utiliser la méthode removeAll()
void replaceItem(String, int)	remplacer un élément Exemple ( code Java 1.1 ) : li.replaceItem( "ligne remplacee", 1);
int countItems()	nombre d'éléments de la liste Exemple ( code Java 1.1 ) : int n; n = li.countItems( ); il faut utiliser la méthode getItemCount()
int getRows()	nombre de lignes de la liste Exemple ( code Java 1.1 ) : int n; n = li.getRows( );
String getItem(int)	contenu d'un élément Exemple ( code Java 1.1 ) : String text = new String( ); text = li.getItem(1);
void select(int)	sélectionner un élément Exemple ( code Java 1.1 ) : li.select(0);
setMultipleSelections(boolean)	déterminer si la sélection multiple est autorisée Exemple ( code Java 1.1 ) : li.setMultipleSelections(true); il faut utiliser la méthode setMultipleMode()
void deselect(int)	désélectionner un élément Exemple ( code Java 1.1 ) : li.deselect(0);
int getSelectedIndex( )	déterminer l'élément sélectionné en cas de sélection simple : renvoie l'indice ou -1 si aucun élément n'est sélectionné Exemple ( code Java 1.1 ) : int i; i = li.getSelectedIndex();
int[] getSelectedIndexes( )	déterminer les éléments sélectionnés en cas de sélection multiple Exemple ( code Java 1.1 ) : int i[]=li.getSelectedIndexes();
String getSelectedItem( )	déterminer le contenu en cas de sélection simple : renvoie le texte ou null si pas de sélection Exemple ( code Java 1.1 ) : String texte = new String( ); texte = li.getSelectedItem( );
String[] getSelectedItems()	déterminer les contenus des éléments sélectionnés en cas de sélection multiple : renvoie les textes sélectionnés ou null si pas de sélection Exemple ( code Java 1.1 ) : String texte[ ] = li.getSelectedItems(); for (i = 0 ; i < texte.length(); i++) System.out.println(texte[i]);
boolean isSelected(int)	déterminer si un élément est sélectionné Exemple ( code Java 1.1 ) : boolean selection; selection = li.isSelected(0); il faut utiliser la méthode isIndexSelect()
int getVisibleIndex()	renvoie l'index de l'entrée en haut de la liste Exemple ( code Java 1.1 ) : int top = li.getVisibleIndex();
void makeVisible(int)	assure que l'élément précisé sera visible Exemple ( code Java 1.1 ) : li.makeVisible(10);

import java.awt.*;  

class TestList {  
 
  static public void main (String arg [ ]) {  
 
    Frame frame = new Frame("Une liste");  
 
    List list = new List(5,true);  
    list.add("element 0");  
    list.add("element 1");  
    list.add("element 2");  
    list.add("element 3");  
    list.add("element 4");  
 
    frame.add(List);  
    frame.pack();  
    frame.show();  
  }  
}

41.1.9. Les cases à cocher

Il faut déclarer un objet de la classe java.awt.Checkbox

Il existe plusieurs constructeurs :

Les principales méthodes sont :

cb.setLabel( "libelle de la case : " );

cb.setState( true );

boolean etat;
etat = cb.getState( );

String commentaire = new String( );
commentaire = cb.getLabel( );

41.1.10. Les boutons radio

Déclarer un objet de la classe java.awt.CheckboxGroup

CheckboxGroup rb;
Checkbox cb1 = new Checkbox(" etiquette 1 ", rb, etat1_boolean);
Checkbox cb2 = new Checkbox(" etiquette 2 ", rb, etat1_boolean);
Checkbox cb3 = new Checkbox(" etiquette 3 ", rb, etat1_boolean);

Les principales méthodes sont :

Méthodes	Rôle
Checkbox getCurrent()	retourne l'objet Checkbox correspondant à la réponse sélectionnée il faut utiliser la méthode getSelectedCheckbox()
void setCurrent(Checkbox)	Coche le bouton radio passé en paramètre il faut utiliser la méthode setSelectedCheckbox()

41.1.11. Les barres de défilement

Il faut déclarer un objet de la classe java.awt.Scrollbar

Il existe plusieurs constructeurs :

• orientation : Scrollbar.VERTICALE ou Scrollbar.HORIZONTAL
• valeur_initiale : position du curseur à la création
• visible : taille de la partie visible de la zone défilante
• min : valeur minimale associée à la barre
• max : valeur maximale associée à la barre

Les principales méthodes sont :

Méthodes	Rôle
sb.setValues(int,int,int,int )	mise à jour des paramètres de la barre Exemple ( code Java 1.1 ) : sb.setValues( valeur, visible, minimum, maximum );
void setValue(int)	modifier la valeur courante Exemple ( code Java 1.1 ) : sb.setValue(10);
int getMaximum( );	lecture du maximum Exemple ( code Java 1.1 ) : int max = sb.getMaximum( );
int getMinimum( );	lecture du minimum Exemple ( code Java 1.1 ) : int min = sb.getMinimum( );
int getOrientation( )	lecture de l'orientation Exemple ( code Java 1.1 ) : int o = sb.getOrientation( );
int getValue( );	lecture de la valeur courante Exemple ( code Java 1.1 ) : int valeur = sb.getValue( );
void setLineIncrement( int );	détermine la valeur à ajouter ou à ôter quand l'utilisateur clique sur une flèche de défilement il faut utiliser la méthode setUnitIncrement()
int setPageIncrement( );	détermine la valeur à ajouter ou à ôter quand l'utilisateur clique sur le conteneur il faut utiliser la méthode setBlockIncrement()

41.1.12. La classe Canvas

C'est un composant sans fonction particulière : il est utile pour créer des composants graphiques personnalisés.

Il est nécessaire d'étendre la classe Canvas pour en redéfinir la méthode Paint().

syntaxe : Cancas can = new Canvas( );

import java.awt.*;

public class MonCanvas extends Canvas {

   public void paint(Graphics g) {
      g.setColor(Color.black);
      g.fillRect(10, 10, 100,50);
      g.setColor(Color.green);
      g.fillOval(40, 40, 10,10);
   }

}


import java.applet.*;
import java.awt.*;

public class AppletButton extends Applet {

   MonCanvas mc = new MonCanvas();

   public void paint(Graphics g) {
      super.paint(g);
      mc.paint(g);
   }
}

41.2. La classe Component

Les contrôles fenêtrés descendent plus ou moins directement de la classe AWT Component.

Cette classe contient de nombreuses méthodes :

Méthodes	Rôle
Rectangle bounds()	renvoie la position actuelle et la taille des composants utiliser la méthode getBounds().
void disable()	désactive les composants utiliser la méthode setEnabled(false).
void enable()	active les composants utiliser la méthode setEnabled(true).
void enable(boolean)	active ou désactive le composant selon la valeur du paramètre utiliser la méthode setEnabled(boolean).
Color getBackGround()	renvoie la couleur actuelle d'arrière plan
Font getFont()	renvoie la fonte utilisée pour afficher les caractères
Color getForeGround()	renvoie la couleur de premier plan
Graphics getGraphics()	renvoie le contexte graphique
Container getParent()	renvoie le conteneur ( composant de niveau supérieur )
void hide()	masque l'objet utiliser la méthode setVisible().
boolean inside(int x, int y)	indique si la coordonnée écran absolue se trouve dans l'objet utiliser la méthode contains().
boolean isEnabled()	indique si l'objet est actif
boolean isShowing()	indique si l'objet est visible
boolean isVisible()	indique si l'objet est visible lorsque sont conteneur est visible
void layout()	repositionne l'objet en fonction du Layout Manager courant utiliser la méthode doLayout().
Component locate(int x, int y)	retourne le composant situé à cet endroit utiliser la méthode getComponentAt().
Point location()	retourne l'origine du composant utiliser la méthode getLocation().
void move(int x, int y)	déplace les composants vers la position spécifiée utiliser la méthode setLocation().
void paint(Graphics);	dessine le composant
void paintAll(Graphics)	dessine le composant et ceux qui sont contenus en lui
void repaint()	redessine le composant par appel à la méthode update()
void requestFocus();	demande le focus
void reshape(int x, inty, int w, int h)	modifie la position et la taille (unité : points écran) utiliser la méthode setBounds().
void resize(int w, int h)	modifie la taille (unité : points écran) utiliser la méthode setSize().
void setBackground(Color)	définit la couleur d'arrière plan
void setFont(Font)	définit la police
void setForeground(Color)	définit la couleur de premier plan
void show()	affiche le composant utiliser la méthode setVisible(True).
Dimension size()	détermine la taille actuelle utiliser la méthode getSize().

41.3. Les conteneurs

Les conteneurs sont des objets graphiques qui peuvent contenir d'autres objets graphiques, incluant éventuellement des conteneurs. Ils héritent de la classe Container.

Un composant graphique doit toujours être incorporé dans un conteneur :

L'insertion de composant dans un conteneur se fait grâce à la méthode add(Component) de la classe Container.

Panel p = new Panel();

Button b1 = new button(" Premier ");
p.add(b1);
Button b2;
p.add(b2 = new Button (" Deuxième "));
p.add(new Button("Troisième "));

41.3.1. Le conteneur Panel

C'est essentiellement un objet de rangement pour d'autres composants.

La classe Panel possède deux constructeurs :

Panel p = new Panel( );

Button b = new Button(" bouton ");
p.add( b);

41.3.2. Le conteneur Window

La classe Window contient plusieurs méthodes dont voici les plus utiles :

41.3.3. Le conteneur Frame

Ce conteneur permet de créer des fenêtres d'encadrement. Il hérite de la classe Window qui ne s'occupe que de l'ouverture de la fenêtre. Window ne connait pas les menus ni les bordures qui sont gérés par la classe Frame. Dans une applet, elle n'apparait pas dans le navigateur mais comme une fenêtre indépendante.

Il existe deux constructeurs :

Les principales méthodes sont :

Méthodes	Rôle
setCursor(int)	changer le pointeur de la souris dans la fenêtre Exemple : f.setCursor(Frame.CROSSHAIR_CURSOR); utiliser la méthode setCursor(Cursor).
int getCursorType()	déterminer la forme actuelle du curseur utiliser la méthode getCursor().
Image getIconImage()	déterminer l'icone actuelle de la fenêtre
MenuBar getMenuBar()	déterminer la barre de menus actuelle
String getTitle()	déterminer le titre de la fenêtre
boolean isResizeable()	déterminer si la taille est modifiable
void remove(MenuComponent)	Supprimer un menu
void setIconImage(Image);	définir l'icone de la fenêtre
void setMenuBar(MenuBar)	Définir la barre de menus
void setResizeable(boolean)	définir si la taille peut être modifiée
void SetTitle(String)	définir le titre de la fenêtre

import java.applet.*;
import java.awt.*;

public class AppletFrame extends Applet {

   Frame f;

   public void init() {
      super.init();
      // insert code to initialize the applet here

      f = new Frame("titre");
      f.add(new Label("hello "));
      f.setSize(300, 100);
      f.show();
   }
}

Le message « Warning : Applet window » est impossible à enlever dans la fenêtre : cela permet d'éviter la création d'une applet qui demande un mot de passe.

Le gestionnaire de mise en page par défaut d'une Frame est BorderLayout (FlowLayout pour une applet).

import java.awt.*;

public class MaFrame extends Frame {

   public MaFrame() {
      super();
      setTitle(" Titre de la Fenetre ");
      setSize(300, 150);
      show(); // affiche la fenetre

   }

   public static void main(String[] args) {
      new MaFrame();
   }
}

41.3.4. Le conteneur Dialog

La classe Dialog hérite de la classe Window.

Une boîte de dialogue doit dérivée de la Classe Dialog de package java.awt.

Un objet de la classe Dialog doit dépendre d'un objet de la classe Frame.

import java.awt.*;
import java.awt.event.*;

public class Apropos extends Dialog {

   public APropos(Frame parent) {
      super(parent, "A propos ", true);
      addWindowListener(new
      AProposListener(this));
      setSize(300, 300);
      setResizable(False);
   }
}

class AProposListener extends WindowAdapter {

   Dialog dialogue;
   public AProposListener(Dialog dialogue) {
      this.dialogue = dialog;
   }

   public void windowClosing(WindowEvent e) {
      dialogue.dispose();
   }

}

L'appel du constructeur Dialog(Frame, String, Boolean) permet de créer une instance avec comme paramètres : la fenêtre à laquelle appartient la boîte de dialogue, le titre de la boîte, le caractère modale de la boîte.

La méthode dispose() de la classe Dialog ferme la boîte et libère les ressources associées. Il ne faut pas associer cette action à la méthode windowClosed() car dispose provoque l'appel de windowClosed ce qui entrainerait un appel récursif infini.

41.4. Les menus

Il faut insérer les menus dans des objets de la classe Frame (fenêtre d'encadrement). Il n'est donc pas possible d'insérer directement des menus dans une applet.

Il faut créer une barre de menus et l'affecter à la fenêtre d'encadrement. Il faut ensuite créer les entrées de chaque menu et les rattacher à la barre. Ajouter ensuite les éléments à chacun des menus.

import java.awt.*;

public class MaFrame extends Frame {

   public MaFrame() {
      super();
      setTitle(" Titre de la Fenetre ");
      setSize(300, 150);
      
      MenuBar mb = new MenuBar();
      setMenuBar(mb);
      
      Menu m = new Menu(" un menu ");
      mb.add(m);
      m.add(new MenuItem(" 1er element "));
      m.add(new MenuItem(" 2eme element "));
      Menu m2 = new Menu(" sous menu ");

      CheckboxMenuItem cbm1 = new CheckboxMenuItem(" menu item 1.3.1 ");
      m2.add(cbm1);
      cbm1.setState(true);
      CheckboxMenuItem cbm2 = new CheckboxMenuItem(" menu item 1.3.2 ");
      m2.add(cbm2);

      m.add(m2);

      pack();
      show(); // affiche la fenetre


   }

   public static void main(String[] args) {
      new MaFrame();
   }

}

import java.awt.*;

public class MenuFenetre extends java.awt.MenuBar {

   public MenuItem menuQuitter, menuNouveau, menuApropos;

   public MenuFenetre() {

      Menu menuFichier = new Menu(" Fichier ");
      menuNouveau = new MenuItem(" Nouveau ");
      menuQuitter = new MenuItem(" Quitter ");

      menuFichier.add(menuNouveau);

      menuFichier.addSeparator();

      menuFichier.add(menuQuitter);

      Menu menuAide = new Menu(" Aide ");
      menuApropos = new MenuItem(" A propos ");
      menuAide.add(menuApropos);

      add(menuFichier);

      setHelpMenu(menuAide);
   }
}

La méthode setHelpMenu() confère sur certaines plates-formes un comportement particulier à ce menu.

La méthode setMenuBar() de la classe Frame prend en paramètre une instance de la classe MenuBar. Cette instance peut être directement une instance de la classe MenuBar qui aura été modifiée grâce aux méthodes add() ou alors une classe dérivée de MenuBar qui est adaptée aux besoins.

import java.awt.*;

public class MaFrame extends Frame {

   public MaFrame() {
      super();
      setTitle(" Titre de la Fenetre ");
      setSize(300, 150);
      MenuFenetre mf = new
      MenuFenetre();

      setMenuBar(mf);

      pack();

      show(); // affiche la fenetre


   }

   public static void main(String[] args) {
      new MaFrame();
   }

}

41.4.1. Les méthodes de la classe MenuBar

Méthodes	Rôle
void add(Menu)	ajouter un menu dans la barre
int countMenus()	renvoie le nombre de menus utiliser la méthode getMenuCount().
Menu getMenu(int pos)	renvoie le menu à la position spécifiée
void remove(int pos)	supprimer le menu à la position spécifiée
void remove(Menu)	supprimer le menu de la barre de menu

41.4.2. Les méthodes de la classe Menu

Méthodes	Rôle
MenuItem add(MenuItem) void add(String)	ajouter une option dans le menu
void addSeparator()	ajouter un trait de séparation dans le menu
int countItems()	renvoie le nombre d'options du menu utiliser la méthode getItemCount().
MenuItem getItem(int pos)	déterminer l'option du menu à la position spécifiée
void remove(MenuItem mi)	supprimer la commande spécifiée
void remove(int pos)	supprimer la commande à la position spécifiée

41.4.3. Les méthodes de la classe MenuItem

Méthodes	Rôle
void disable()	désactiver l'élément utiliser la méthode setEnabled(false).
void enable()	activer l'élément utiliser la méthode setEnabled(true).
void enable(boolean cond)	désactiver ou activer l'élément en fonction du paramètre utiliser la méthode setEnabled(boolean).
String getLabel()	Renvoie le texte de l'élément
boolean isEnabled()	renvoie l'état de l'élément (actif / inactif)
void setLabel(String text)	définir un nouveau texte pour la commande

41.4.4. Les méthodes de la classe CheckboxMenuItem

41.5. La classe java.awt.Desktop

Cette classe, ajoutée dans Java SE 6, permet de manipuler des documents sous la forme d'un fichier ou d'une URI à partir de leur type mime défini sur le système d'exploitation sous-jacent.

La méthode statique isDesktopSupported() permet de savoir si la classe Desktop est supportée par la plate-forme.

La méthode statique Desktop.getDesktop() donne un accès à l'instance de la classe Desktop.

Plusieurs constantes sont définies dans Desktop.Action pour préciser le type d'opération qu'il est possible de réaliser sur un document : BROWSE, EDIT, MAIL, OPEN et PRINT.

La méthode isSupported() permet de savoir si l'action est supportée sur la plate-forme mais cela ne signifie pas que cette action soit supportée pour tous les types mimes enregistrés sur la plate-forme.

Plusieurs méthodes permettent d'exécuter les actions : browse(), edit(), mail(), open() et print().

package fr.jmdoudoux.dej.java6;

import java.awt.*;
import java.io.*;

public class TestDektop {

    public static void main(String args[]) {
        if (Desktop.isDesktopSupported()) {
            
            Desktop desktop = Desktop.getDesktop();
            if (args.length == 1) {
                File fichier = new File(args[0]);
                if (desktop.isSupported(Desktop.Action.OPEN)) {
                    System.out.println("Ouverture du fichier " + fichier.getName());
                    try {
                        desktop.open(fichier);
                    } catch (IOException ioe) {
                        ioe.printStackTrace();
                    }
                }
            }            
        }
    }
}

La méthode mail() attend en paramètre une uri qui doit utiliser le protocole mailto:.

La méthode browse() attend en paramètre une uri qui utilise un protocole reconnu par le navigateur http, https, ...