jdic zakaria bentahar

JDIC Zakaria BENTAHAR

Table des matières

1. Introduction ............................................................................................................................................ 3

2. Le Desktop Component ........................................................................................................................... 4

3. Le composant de type de fichiers ........................................................................................................... 5

4. Le composant navigateur ........................................................................................................................ 7

5. Le composant Packager ......................................................................................................................... 10

6. Conclusion ............................................................................................................................................. 13

1. Introduction

Si vous êtes un développeur Java pour un temps vous pouvez avoir eu l'expérience d'être dit que Java

ne peut pas faire tout ce natif C peut. Vous avez peut être lutté avec le volet HMTL Editor tandis que les

développeurs de Windows au bout du couloir inclus Internet Explorer dans leurs programmes avec juste

quelques lignes de code. Je l'admets: aussi grand que Java est, il ya des fois où j'ai longtemps pour les

fonctionnalités et l'accès au système de la programmation autochtone. Eh bien, nous n'avons pas à

attendre plus longtemps.

Vous avez surement entendu parler des composants d'intégration JDesktop (JDIC). Cette nouvelle API

permet aux développeurs Java le genre de choses qu’ils ont toujours envié de nos frères indigènes. Ce

rapport va vous donner un aperçu complet des caractéristiques JDIC, avec un petit exemple de chacun,

et une liste de choses à télécharger pour démarrer.

JDesktop composants d'intégration, ou JDIC, est un projet fourre-tout pour un ensemble de modules qui

donne aux développeurs un accès aux fonctionnalités natives de Java à travers la Croix-API de la plate-

forme. Il a été lancé par le groupe Desktop chez Sun pour permettre aux applications Java une meilleure

intégration avec le bureau sur lequel ils fonctionnent. Ils ont fait JDIC open source comme un moyen

d'obtenir rapidement des commentaires des développeurs sur les fonctionnalités souhaitées, ainsi que

les rapports de bogues. Bien qu'il n'y ait actuellement aucun plan pour ce faire, l'équipe JDIC est à la

recherche en tirant partie des fonctionnalités JDIC dans une future version de la bibliothèque Java de

base.

JDIC est divisé en cinq composantes et un projet d'incubateur:

* Desktop: Lancement des programmes de bureau pour ouvrir, éditer, imprimer, et les fichiers de

courrier.

* Types de fichiers: Ensembles de bureau des associations de fichiers de type.

* Navigateur: embarque un navigateur web natif (Internet Explorer ou Mozilla) en une toile de l'AWT.

* Packager: outils ligne de commande pour la conversion de Java Web programmes Bon départ dans

les installateurs indigènes.

* Tray API: Support pour les icônes de plateau de système et pop-up menus.

* SaverBeans: Ecrans de veille du système en Java

2. Le Desktop Component

La composante Desktop est la plus simple et peut-être la plus utile des composants JDIC. Son

existence entière est consacrée aux services de bureau de base comme l'ouverture d'un fichier

dans l'éditeur de droite, à partir d'un message électronique ou l'envoi d'une URL dans le

navigateur web par défaut. Ce sont toutes les choses qui nécessitent beaucoup de travail sous

le capot de construction, mais très peu à utiliser. Si vous voulez indiquer à l'OS d'ouvrir un

document Microsoft Word, vous n'avez qu'à appeler Desktop.open (new File ( "bentahar.doc

"));.

Le paquet org.jdesktop.jdic.desktop n'a que trois classes: Desktop, le message et

DesktopException. La classe Desktop est statique et ne peut pas être instanciée. Elle a des

méthodes pour l'ouverture, l'édition et l'impression de fichiers. Vous pouvez également ouvrir

un nouvel e-mail et le remplir avec du texte. C'est là que la classe de message intervient, ce qui

vous permet de définir le destinataire, corps, pièces jointes, et l'ensemble des autres parties du

message électronique.

La meilleure chose qu’on peut dire sur le package de composants de bureau est qu’il est facile à

utiliser ; vous n'avez pas à enregistrer un pilote spécial ou changer la configuration qui d’ailleurs

basé sur la plateforme actuelle. Fini ce scénario car tout ceci se fait grâce à JDIC. Tant que le

fichier jdic.jar est dans votre classpath et les lib natives corrects se trouvent dans votre chemin

de bibliothèques, le code fonctionnera tout simplement.

En voici quelques exemples:

Lancer un naviagteur ( i.e : Yahoo)

Desktop.browse(new URL("http://www.yahoo.com/"));

Envoyer un email

LinkedList<String> addresse = new LinkedList<String>();

addresse.add("[email protected]");

addresse.add("[email protected]"); Message

message = new Message();

message.setBody("je vous informe que les etudes vont commencer

le …");

message.setSubject("bonjour");

message.setToAddrs(addresse);

Desktop.mail(message);

Ouvrir un document ( i.e word) Desktop.open(new File("G://MQL//java//recherche//projet.docx"));

3. Le composant de type de fichiers

La prochaine composante de base de JDIC est le package de types de fichiers, qui définit les

associations de fichiers de type. Cela signifie que vous pouvez dire au système d'exploitation

quel programme à utiliser avec les fichiers, telles que l'ouverture toujours des fichiers texte en

utilisant Word au lieu de Bloc-notes. En utilisant cette API, vous pouvez interroger le système

afin de connaitre les associations existantes, et même de les supprimer.

Étant donné que les associations de types de fichiers sont généralement assez spécifique au

système d'exploitation, cette API est plus utile pour récupérer des associations ou

l'enregistrement de la requête elle-même plutôt que pour la création des associations. Par

exemple, l'association habituelle fichier texte sous Windows est d'appeler notepad.exe dans un

répertoire bien connu. Sous Gnome, il pourrait être de demander / usr / local / bin / gedit.

Comme il s'agit du système spécifique, il n'est probablement pas très utile de fixer des

associations à l'exception de lier une application Java à ses propres types de fichiers. Pourtant,

peu importe ce que vous faites avec elle, la composante Filetypes s'occupe de toutes les levage

lourd pour vous, qui traite du Registre et MIME-type base de données.

Voici un court exemple de la création des associations de fichiers:

Action action = new

Action("open","C:\\WINDOWS\\system32\\notepad.exe");

Association assoc = new Association();

assoc.addFileExtension(".BEN");

assoc.setMimeType("application/ben-chatter");

assoc.addAction(action);

AssociationService svc = new AssociationService();

svc.registerUserAssociation(assoc);

Les deux premières lignes permettent de créer une action qui va ouvrir le fichier avec

notepad.exe. Les quatre prochaines lignes pour créer une association entre l'action et

l'extension de fichier. BEN. J'ai jeté le type MIME, (Multipurpose Internet Mail Extensions est

un standard internet qui étend le format de données des courriels pour supporter des textes en

différents codage de caractères autres que l'ASCII), là-dedans pour faire une bonne mesure.

Dans le passé, la plupart des systèmes d'exploitation sont fondés exclusivement sur l'extension

du fichier ou des métadonnées de propriétés pour déterminer le type de fichier. Cependant, ces

jours-ci, , la plupart des systèmes d'exploitation évoluent vers des paramètres MIME pour tous

typage de fichiers, donc il est bon de commencer à les utiliser maintenant. Les deux dernières

lignes enregistrent réellement l'association sur système. Comme avec toutes les API JDIC, aussi

longtemps que la lib native est dans votre chemin de la bibliothèque, vous n'avez pas besoin de

faire quelque chose de spécial pour le faire travailler.

4. Le composant navigateur

La 3ème principale composante du JDIC est le navigateur. Contrairement aux deux précédentes,

ce qui vous donne juste l'accès aux services du système, ce volet vous donne un widget AWT

réelle à utiliser dans les applications graphiques. Auparavant, vous pouviez utiliser un tiers

composants intégrés ou tous les navigateurs Java, mais avec JDIC c’est une autre histoire car

elle permet d'intégrer les navigateurs web par défaut à l'intérieur de votre application, ouvrant

la porte à de nombreuses possibilités. En écrivant des choses comme les lecteurs RSS avec tout

le soutien du web devient possible. Le téléchargement sera aussi plus rapide, parce que vous

n'aurez pas à inclure le navigateur natif de votre demande.

L'API navigateur vous donne accès à un ensemble d'événements et de contrôle sur l'historique

de navigation (précédent, suivant, rafraîchissement). Les prochaines révisions de l'API sont

censés de fournir plus d’accès vers le navigateur et tous les documents chargés.

En utilisant le navigateur de votre application est vraiment très facile, voici un exemple:

WebBrowser browser = new WebBrowser(); browser.setURL(new URL("http://www.google.com"));

JFrame frame = new JFrame("Browser Test");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.getContentPane().add(browser);

frame.pack();

frame.setSize(500,500);

frame.setVisible(true);

Comme vous l’avez constaté, l'objet WebBrowser est juste un composant AWT que vous

pouvez mettre dans un JFrame standard. La première ligne crée un WebBrowser nouvelles et la

seconde met l'URL que vous voulez afficher. Le reste du code crée un cadre, ajoute le

navigateur, son écran ressemble à la figure 1.

Il ne faut pas oublier que le navigateur Web est un composant AWT natif, de sorte que vous

pouvez rencontrer des problèmes combinant avec Swing. Les deux règles pour réaliser ce

mélange est :

1) de ne jamais se chevaucher Swing et composants AWT

2) Appeller setLightWeightPopupEnabled(false) sur vos menus ou ils disparaitront derrière le

composant navigateur.

À l'heure actuelle, le composant navigateur utilisera l'utilisateur du navigateur Web par défaut,

ce qui signifie habituellement Internet Explorer ou Mozilla, mais vous ne pouvez pas regrouper

les éléments nécessaires de Mozilla avec votre application comme vous pouvez le faire avec

JRex. Ce comportement est probablement bien pour Windows, où IE est quasiment assuré

d'être là, mais ce sera plus problématique sous Linux où, le navigateur par défaut peut ne pas

être Mozilla (elle peut être Konquorer dans KDE, par exemple).

5. Le composant Packager

Contrairement au reste de JDIC, le module de package n'est pas une API. Au lieu de cela, c'est

un ensemble d'outils ligne de commande qui convertissent JNLP (Java Web Start) applications

dans les installateurs indigènes. (RPM pour Linux, pkgs pour Solaris, et MSI pour Windows). Cela

ne signifie pas que votre demande est refusée dans un fichier EXE. JSmooth, avec ou JExePack,

elle vous offre simplement un installateur cliquer pour une application Web Start. Une fois le

programme installé, il se mettra à jour sur Internet, utilisez le descripteur JNLP, et faire toutes

les autres choses que des applications Web Start faire.

La composante Packager exige J2SE 5.0 et les outils natifs. Pour Windows, vous aurez

également besoin d'installer Microsoft MSI SDK. Une fois que votre environnement est

configuré, vous pouvez utiliser la commande jnlp2msi outils en ligne, jnlp2rpm, et jnlp2pkg de

convertir votre application Web Start dans une plate-forme d'installation spécifique.

La barre d'état système (The System Tray)

La barre d'icône de l'API est utilisée pour constituer un projet d'incubateur, mais ce est grâce

aux efforts assidus de la communauté java.net, il a mûri et a été promu à un statut complet.

Son but est de créer pour nos programmes ces petits icônes en bas à droite de l'écran de votre

écran, en supposant que votre système d'exploitation dispose d'un concept de plateau de

système. Dans la pratique, cela signifie que Windows et Linux. Les utilisateurs Mac OS X ne sont

pas de chance (ou mieux, selon votre point de vue). Il soutient aussi des pop-up menus et les

info-bulles automatique pour les icônes. Comme le reste de JDIC, l'appui du système exige le

code natif, mais vous pouvez coder à l'encontre d'une API Java avec un pré-compilés

bibliothèque native.

Depuis l'API est une jolie petite envergure, il n'ya que deux classes: SystemTray et TrayIcon. La

classe SystemTray a une méthode de fabrique statique pour accéder à la barre d'état système

par défaut. TrayIcon vous permet de joindre une JPopupMenu et une icône pour le prochain

espace disponible sur le plateau de système. Enfin, appelez SystemTray.getDefaultSystemTray

(). AddTrayIcon () pour obtenir votre "pop-up apparaîtra. Examinons un petit exemple:

JPopupMenu menu = new JPopupMenu("Tray Icon Menu");

JMenuItem yahooItem = new JMenuItem("Yahoo");

menu.add(yahooItem);

menu.addSeparator();

JMenuItem quitItem = new JMenuItem("Quit");

quitItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent evt) {

System.exit(0);

}

});

yahooItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

JOptionPane.showMessageDialog(null, "Redirection vers yahoo",

"About", JOptionPane.INFORMATION_MESSAGE);

try {


} catch (MalformedURLException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

} catch (DesktopException e1) {



}

}

});

menu.add(quitItem);

// Resource file "duke.gif" must exist at the same directory

// as this class file.

ImageIcon icon = new ImageIcon("yahoo.gif");

TrayIcon ti = new TrayIcon(icon, "Yahoo", menu);

// Action listener for left click.

ti.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

try {


} catch (MalformedURLException e1) {



} catch (DesktopException e1) {



}

}

});

SystemTray tray = SystemTray.getDefaultSystemTray();

tray.addTrayIcon(ti);

}

Dans les premières lignes du constructeur SystemTrayTest nous créons un JPopupMenu avec

trois éléments de menu. Le dernier, quitter, ajoute un ActionListener pour quitter le

programme. Maintenant, au lieu d'ajouter le menu pour une barre de menu ou JComponent,

nous avons mis le menu dans le constructeur d'une TrayIcon. Le ImageIcon pour l'image de

plateau de système est également passé dans le TrayIcon, avec le texte d'une info-bulle. Enfin,

nous ajoutons le TrayIcon à la valeur par défaut SystemTray et le programme est terminé.

Compilez ce avec tray.jar dans votre classpath et tray.dll dans votre chemin de la bibliothèque

(généralement le répertoire de travail). L'icône et ses menus sont affichés dans la figure 2.

L'API Tray soutient également GIF animés et des icônes à cliquable à gauche. Avec cette API,

vous pouvez faire disparaître complètement votre application dans la barre des tâches jusqu'à

leur utilisation.

6. Conclusion

Bien que JDIC soit encore bêta, elle montre de grandes promesses. Des modifications ont été

arrivée à grand pas. Des travaux sont déjà en cours pour plier à des projets plus anciens,

corriger les bugs, à soutenir le Mac, et éventuellement migrer certaines parties de JDIC au

runtime de base.

Bien que cela semble venir de nulle part, JDIC est quelque chose que beaucoup de

développeurs Java attendent depuis longtemps. Maintenant que c'est ici, nous pouvons

vraiment développer des applications Java qui font tout ce que les programmes natifs peuvent

faire.

jdic zakaria bentahar

Documents