Plug-in Eclipse : Création d'un Editeur Basique
Date de publication : 25/05/2005 ,
Date de mise a jour : 25/05/2005 Licence : CC-by-SA
Par
Sébastien Le Ray (Accueil)
Ce tutoriel est la première partie d'un ensemble qui nous conduira à créer un éditeur Assembleur
disposant de coloration syntaxique, complétion automatique, indentation, etc. Cependant, il
devrait rester assez général pour vous permettre de vous en servir pour un autre langage.
Dans cette première partie, nous verrons comment créer l'éditeur et faire en sorte qu'il
soit pris en compte par Eclipse. Cet article est assez théorique, mais il est nécessaire
de disposer de bases avant d'aller plus loin.
I. Introduction
II. Création du projet
II.A. Prérequis
II.B. Démarrage
II.C. Classe Principale
II.D. Fichier plugin.xml
III. Création de l'Editeur
III.A. Ajout des dépendances
III.B. Création de la classe
III.C. Ajout du point d'extension
III.D. Lancement et test de l'éditeur
III.E. Ca ne marche pas chez moi !
IV. Conclusion
V. Ressources
VI. Remerciements
VI. Téléchargements
I. Introduction
Eclipse est aujourd'hui LA plateforme de développement Java. Cependant, elle ne lui est
en rien dédiée. En effet, le coeur d'Eclipse comprend simplement tous les mécanismes
nécessaires à l'affichage et à la manipulation de différentes entités (vues, éditeurs,
perspectives, outline, etc.). C'est ainsi que dans sa version de base, c'est-à-dire
sans les JDT (Java Development Tools) et sans le PDE (Plug-in Development Environment),
Eclipse ne propose qu'un seul éditeur, l'éditeur de ressources.
Malgré cela, tous les mécanismes nécessaires à son extension sont déjà présents. On peut
donc décrire Eclipse comme un ensemble de plug-ins liés par un robuste framework.
Dans cette série de tutoriels, je vous propose de vous plonger dans les mécanismes
sous-jacents d'Eclipse au travers de la création de plug-in. Nous commencerons cette
découverte par la création d'un éditeur auquel nous ajouterons des fonctionnalités au fur
et à mesure de notre avancement.
En vous souhaitant une bonne lecture et un bon développement.
II. Création du projet
II.A. Prérequis
Vous devez disposer du Eclipse SDK pour pouvoir développer des plug-ins
(c'est particulièrement le plug-in PDE qui nous est utile car il permet
une manipulation plus simple des différents éléments composant un plug-in
eclipse). Pour savoir si c'est du SDK que vous diposez, allez tout
simplement dans "Help/About Eclipse Platform" et cliquez sur Plug-in
details si "Eclipse Plug-in Development Environment" apparait dans la
liste "Plug-in Name", vous avez tout ce qu'il faut.
II.B. Démarrage
Une fois ces vérifications effectuées, nous pouvons commencer.
Je précise que pour ce tutoriel, je pars d'un workspace vierge,
tout neuf. Je commence donc en perspective resource.
Si vous avez déjà des projets dans votre workspace, c'est peut-être
le moment d'en changer pour en prendre vous aussi un vierge.
Pour cela c'est simple : modifiez le raccourci (ou créez le si vous
lancez eclipse directement) et ajoutez l'option -data
chemin/vers/votre nouveau workspace. Vous aurez ainsi un nouveau
workspace tout propre vous aussi (c'est toujours plus pratique d'avoir
un workspace par gros projet et un projet pour chaque sous-projet...).
Commençons donc par créer un projet Plug-in. Pour cela, comme
d'habitude : menu "File/New/Project...". Dans la liste qui
apparait, ouvrez le dossier "Plug-in Development" et sélectionnez
"Plug-in Project". Une fenêtre apparait vous demandant les
renseignements classiques sur un nouveau projet (Nom, emplacement,
etc.), mais également si vous désirez créer un manifest OSGi
(Open Services Gateway initiative).
Le manifest OSGi permet entre autres de déterminer les conditions
d'activation du plug-in, les dépendances, etc. Il reprend des
informations que l'on retrouve dans le fichier plugin.xml
(voir plus bas) mais sous une forme standardisée qui n'est
compatible qu'avec les versions 3+ d'Eclipse. Si vous ne créez pas ce
fichier, les informations seront tout simplement reportées dans plugin.xml
Laissez donc la case décochée et appuyez sur "Next".
Vous arrivez sur une fenêtre de saisie de renseignements à propos du
plug-in :
Plug-in ID : Identifiant du plug-in,
indiquez par exemple le package de base suivi du
nom de la fonctionnalité (pour
moi, org.phpopensoft.eclipse.asm.editor) ;
Plug-in Version : Version du plug-in,
en général, elle est synchronisée
sur celle d'Eclipse (au moins pour la version
majeure) ;
Plug-in ID : Identifiant du plug-in,
indiquez par exemple le package de base (pour
moi, org.phpopensoft.eclipse.asm) ;
Plug-in Name : Nom du plug-in ;
Plug-in Provider : Fournisseur du plug-in,
vous ! ;
Plug-in Provider : Runtime Library,
fichier JAR qui contiendra le code du plug-in
proprement dit.
Laissez cochées les cases "Generate the Java class that controls the
plug-in's life cycle (recommended)", ça nous évitera d'avoir à le faire
et "This plug-in will make contributions to the UI". La dernière case,
"Intended for use with older Eclipse plarforms (prior to 3.0)" doit
rester décochée (elle ne nous concerne pas).
Votre fenêtre de création de projet devrait ressembler à ça :
 Création du projet Eclipse
Cliquez sur "Finish" (le bouton "Next" propose des Wizards dont nous
ne nous servons pas). Eclipse vous demande si vous voulez passer en
"Plug-in Development Perspective" cliquez sur "Yes".
Votre plug-in vous attend.
II.C. Classe Principale
Eclipse crée pour nous un squelette de plug-in avec, comme on le lui a demandé, la classe
gérant le "cycle de vie" du plug-in. Cette classe étend AbstractUIPlugin,
ce qui lui permet de s'intégrer à la plateforme Eclipse et d'être chargée automatiquement.
La classe suit le Design-Pattern
 Singleton.
Il faut savoir qu'Eclipse utilise de manière générale le "lazy loading" c'est-à-dire
qu'il diffère au maximum le chargement des ressources. En l'occurence, le plug-in ne sera
pas chargé au moment du démarrage d'Eclipse mais lors de son activation (ouverture d'un fichier
associé à notre éditeur, affichage d'une vue décrite par le plug-in, etc.).
II.D. Fichier plugin.xml
Le premier fichier intéressant est plugin.xml, il contient les
métainformations sur le plug-in (notamment celles que nous avons
saisies lors de la création du projet). Ouvrez le en double cliquant dessus
(si ce n'est pas déjà fait), un éditeur dédié s'affiche (il présente
les différentes options sous forme d'interface graphique).
La fenêtre est composée de 7 ou 8 onglets (en bas)
selon que vous avez sélectionné la création d'un MANIFEST OSGi ou non.
- Le premier onglet, "Overview" (aperçu), reprend certaines informations saisies
lors de la création du plug-in, vous pouvez toujours les modifier ici si vous
vous êtes trompé. La partie Testing vous permet de lancer un eclipse avec
le plug-in en cours de création (nous l'utiliserons très bientôt). "Deploying"
permet d'exporter le plug-in pour le diffuser ;
- Le second onglet, "Dependencies", référence les dépendances du plug-in
par rapport à d'autres plug-ins ;
- "Runtime" vous permet d'indiquer les bibliothèques nécessaires au fonctionnement
du plug-in. La seconde partie est grisée si vous n'avez pas créé de fichier
MANIFEST ;
- "Extensions" référence toutes les extensions offertes par le plug-in. C'est dans
cet onglet que l'on va indiquer où se "greffe" le plug-in dans l'environnement Eclipse ;
- "Extension points" permet d'indiquer les points d'extension offerts par le plug-in,
c'est-à-dire les endroits où l'on va pouvoir greffer de nouvelles fonctionnalités ;
- "Build" permet de configurer les éléments qui doivent se trouver dans les différentes
options de compilation (binary ou source) en plus du fichier jar contenant les binaires ;
- Enfin, "MANIFEST.MF" (présent si vous avez sélectionné sa création), "plugin.xml" et
"build.properties" permettent de consulter les fichiers générés à partir des informations
saisies dans les autres onglets.
 |
Lorsque vous effectuez des opérations de refactoring, notamment
des renommages/déplacement de classes ou de package, n'oubliez pas de cocher
la case "Update fully qualified name in non-Java files (forces preview)" et
d'indiquer plugin.xml (ou * ou *.xml) dans le "File name patterns" pour mettre
à jour les références dans les méta-informations. Dans le cas contraire, si
la classe était référencée par le descripteur du plug-in, celui-ci ne fonctionnera plus.
|
 Mise à jour des références lors du refactoring
III. Création de l'Editeur
III.A. Ajout des dépendances
Pour pouvoir créer un éditeur, nous allons devoir ajouter les dépendances nécessaires au
bon fonctionnement de notre classe. Celles-ci sont au nombre de deux : org.eclipse.ui.editors
et org.eclipse.ui.workbench.texteditor. Allez donc dans l'onglet "Dependencies" de
l'éditeur de plugin.xml et cliquez sur add dans la section "Required Plug-ins". Une liste de
tous les plug-ins disponibles dans l'environnement courant apparaît, vous n'avez plus
qu'à saisir ou sélectionner le plug-in voulu. Répétez l'opération pour les deux dépendances
puis sauvegardez.
 Ajout des dépendances
III.B. Création de la classe
L'ajout des dépendances était nécessaire pour disposer des classes utiles pour l'implémentation
de notre éditeur. Nous pouvons maintenant le créer. Je vous conseille de créer un sous-package
editor dans le package du plug-in. Par exemple, pour moi, la classe Plugin se trouve dans
org.phpopensoft.eclipse.asm et les classes gérant le comportement de l'éditeur dans
org.phpopensoft.eclipse.asm.editor et ses sous-packages.
S'agissant dans notre cas d'un éditeur de code source, donc de texte, notre classe éditeur
étendra org.eclipse.ui.editors.text.TextEditor (si eclipse ne la trouve pas, vérifiez que
vous avez bien ajouté les dépendances).
Le fichier créé ressemble à cela :
/*
* Created on 12 mai 2005
*/
package org.phpopensoft.eclipse.asm.editor;
import org.eclipse.ui.editors.text.TextEditor;
/**
* Classe gérant le comportement de l'éditeur assembleur
* @author Sébastien Le Ray
*/
public class ASMEditor extends TextEditor {
}
Grâce au fait que la classe étend TextEditor qui est l'éditeur de texte par défaut,
nous disposons de certaines fonctionnalités de base comme "Enregistrer Sous...". Ne
touchez pas à cette classe pour le moment, nous y reviendrons plus tard.
III.C. Ajout du point d'extension
Nous avons donc une classe qui gère le comportement de l'éditeur, il s'agit maintenant
d'indiquer à Eclipse que cette classe existe et qu'il peut l'utiliser pour éditer des
fichiers. Pour cela, nous allons renseigner différentes informations dans plugin.xml.
Pour ajouter un nouvel éditeur, il suffit de se greffer sur un point d'extension appelé
org.eclipse.ui.editors. Pour cela, allons dans l'onglet "Extensions" du plugin.xml et
cliquons sur "Add...". Dans l'onglet "Extensions Points" se trouve la liste de tous
les points d'extensions disponibles.
 Ajout du point d'extension
Sélectionnez org.eclipse.ui.editors dans la liste, n'utilisez pas de wizard si vous voulez
suivre ce tutoriel (cela dit, les exemples Eclipse sont à mon sens plus fournis que ceux
générés par les wizards).
Une nouvelle entrée a été ajoutée à la rubrique, faites un clic droit sur celle-ci et
sélectionnez New/editor. Sélectionnez la nouvelle entrée.
Dans la partie Extension Element Details s'affiche toute une série de propriétés permettant
de donner des informations sur l'extension ajoutée.
- "id" est un identifiant unique pour notre éditeur. En mettant le FQN de la classe,
il ne devrait normalement pas avoir de problèmes ;
- "name" est l'identifiant de l'éditeur dans le menu "Open With" qui apparaît lorsque
l'on fait un clic droit sur une ressource dans Eclipse. On peut mettre un nom en dur ou un
nom qui pourra être traduit (ce point sera peut-être abordé lors d'un prochain tutoriel) ;
- "icon" renvoie à un fichier image qui sera affiché dans l'onglet de l'éditeur et
à côté des ressources ouvertes par l'éditeur. Cette information est obligatoire lorsque l'éditeur
est une classe, facultative lorsqu'il s'agit d'une commande (voir plus bas) ;
- "extensions" est optionnel et correspond aux extensions des fichiers supportés par l'éditeur,
dans le cas où celui-ci peut ouvrir plusieurs types de fichiers, les extensions sont séparées par
des virgules ;
- "class", "command" et "launcher" s'excluent mutuellement. Dans le cas où class est renseignée,
il doit s'agir d'une classe implémentant org.eclipse.ui.IEditorPart, ce qui est le cas de celle que
nous avons créée. command est une commande à lancer pour ouvrir un éditeur externe. launcher est une
classe implémentant org.eclipse.ui.IEditorLauncher en charge du lancement d'un éditeur externe ;
- "contributorClass" est le nom d'une classe implémentant org.eclipse.ui.IEditorActionBarContributor,
elle permet d'ajouter des actions aux menus et aux barres d'outils lorsque l'éditeur est actif ;
- "default" indique si l'éditeur doit être configuré comme éditeur par défaut lorsque deux éditeurs
sont disponibles pour la même ressource. L'éditeur est toujours accessible via le menu contextuel
"Open With..." s'il n'est pas éditeur par défaut et qu'il existe plus de deux éditeurs ;
- "filenames" est utilisé lorsque l'éditeur n'affiche que des fichiers ayant un nom particulier
comme c'est le cas pour l'éditeur de plugin.xml. Si plusieurs fichiers sont possibles, les séparer par
des virgules ;
- "symbolicFontName" est le nom d'une police définie par un point d'extension
org.eclipse.ui.fontDefinitions. Eclipse prend la police par défaut si l'on en spécifie pas.
Après avoir renseigné les différents champs, la partie Extension Element Details devrait ressembler
à cela :
 Paramètres de l'éditeur
III.D. Lancement et test de l'éditeur
Eclipse dispose désormais de toutes les informations nécessaires au lancement du plug-in. Pour tester,
il suffit de se rendre sur la page Overview du plugin.xml et de cliquer sur "Launch a runtime workbench"
dans la partie "Testing". Un nouvel eclipse se lance et dispose du plug-in nouvellement créé.
Créez un nouveau projet simple et un nouveau fichier, attribuez lui l'extension
asm (test.asm) et validez. Si tout s'est bien passé, il devrait avoir une icône identique à celle que
vous avez sélectionnée précédemment et si vous double cliquez dessus, vous arrivez sur un éditeur de texte
style bloc-notes amélioré avec l'icône reportée dans l'onglet.
III.E. Ca ne marche pas chez moi !
Dans le cas où ça ne marche pas, allez dans le menu "Window/Show View..." et sélectionnez "Error Log" (s'il
n'est pas disponible, cherchez le dans "Other/PDE Runtime/ErrorLog") et consultez le dernier message. Si rien
n'apparaît regardez dans l'Error log de l'Eclipse sur lequel vous développez. Vérifiez que le plug-in apparaît
bien dans la liste des plug-ins ("Help/About/Plug-in Details") et que vous avez bien suivi le tutoriel.
IV. Conclusion
Ce premier article nous a permis de nous familiariser avec l'environnement de développement de plug-ins
Eclipse et d'en comprendre certaines notions de base. Dans la suite du tutoriel, nous verrons comment
mettre en place une coloration syntaxique basique.
V. Ressources
Outre les exemples générés par les plug-in wizards, Eclipse propose en téléchargement des exemples de plug-ins
un peu plus fournis et surtout à jour (encore qu'on y trouve encore du deprecated). Vous les trouverez
sur cette page :
 http://eclipse.org/downloads/index.php,
rubrique "Other downloads" for x.y.z (3.0.2 au moment de cet article), catégorie "Example Plug-ins". Le plug-in
intéressant pour ce tutoriel étant javaeditor.
VI. Remerciements
Merci à Ricky81 pour sa relecture et ses corrections ainsi qu'à vedaer, sinarf et Tofalu pour leur aide.
VI. Téléchargements
|
