Plug-in minimal

Nous savons tous à quoi ressemble "Hello World" en ancien langage Java, sans avoir recours à une interface utilisateur ou à d'autre structure.

   public class HelloWorld {
      public static void main (String [] args) {
         System.out.println("Hello World");
      }
   }

Qu'arrive t-il à ce vieux standard dans le contexte de la plateforme Eclipse ? Au lieu d'envisager Hello World en tant que programme indépendant, reconsidérons-le comme une extension de la plateforme. Le but étant de dire bonjour (hello) à tout le monde, il faut trouver comment étendre le plan de travail pour inclure cette salutation.

En entrant plus profondément dans les composants de l'interface utilisateur de la plateforme, une révision complète des moyens d'extension et de personnalisation de l'interface utilisateur du plan de travail peut être effectuée. Commençons dès à présent avec l'une des extensions les plus simples du plan de travail : une vue.

Vous pouvez considérer la fenêtre du plan de travail comme un cadre présentant diverses parties visuelles. Ces parties appartiennent à deux catégories principales : les vues et les éditeurs. Nous aborderons les éditeurs plus tard. Les vues fournissent des informations sur certains objets utilisés par l'utilisateur dans le plan de travail. Le contenu des vues change souvent à mesure que l'utilisateur sélectionne différents objets dans le plan de travail.

Vue Hello world

Pour le plug-in Hello World, nous implémenterons notre propre vue pour afficher le message"Hello World" à l'utilisateur.

Le package org.eclipse.ui et ses sous-packages contiennent les interfaces publiques définissant l'API de l'interface utilisateur du plan de travail. Un grand nombre de ces interfaces possède des classes d'implémentation par défaut qui peuvent être étendues pour apporter de simples modifications au système. Dans l'exemple d'hello world, une vue du plan de travail sera étendue pour fournir un libellé disant "hello".

L'interface intéressante est IViewPart. Elle définit les méthodes qui doivent être implémentées pour faire contribuer une vue au plan de travail. La classe ViewPart fournit une implémentation par défaut de cette interface. Pour être bref, une partie de la vue est responsable de la création des widgets nécessaires à l'affichage de la vue.

Les vues standard du plan de travail affichent souvent des informations sur un objet que l'utilisateur a sélectionné ou dans lequel il navigue. Les vues mettent à jour leur contenu en fonction des actions qui se produisent dans le plan de travail. Dans le cas présent, il s'agit tout simplement de dire bonjour (hello), aussi la vue est très simple.

Utilisation des outils pour écrire notre plug-in

Vous pouvez utiliser tout IDE Java pour générer des plug-ins Eclipse. Nous nous intéresserons ici l'IDE Eclipse. Si vous ne connaissez pas le plan de travail Eclipse et l'IDE Java, reportez-vous au document Java Development User Guide pour mieux cerner la procédure. Nous nous concentrons pour l'instant sur le code, et non l'outil. Toutefois, voici quelques concepts de l'IDE pour une première approche.

Configuration de l'environnement

Si vous commencez avec un environnement propre, vous devez vérifier que le code peut accéder au plug-in org.eclipse.ui. Importez celui-ci et tout autre plug-in requis dans l'instance de plan de travail en exécution en procédant comme suit. Si ces plug-ins se trouvent déjà dans l'instance du plan de travail, passez à la section "Création d'un projet de plug-in".

  1. Dans la perspective des ressources, choisissez Fichier > Importer... > Plug-in et fragments externes.
  2. Cliquez sur les boutons Suivant> jusqu'à ce que l'écran Sélection apparaisse. Cet écran contient la liste de tous les plug-ins dans votre instance de plan de travail hôte.
  3. Sélectionnez org.eclipse.ui puis cliquez sur le bouton Ajouter les plug-ins requis.
  4. Cliquez sur Fin. La vue Navigateur doit contenir le plug-in org.eclipse.ui et tous ceux requis (dont org.eclipse.swt).

Pour en savoir plus sur la configuration des instances de plan de travail hôte et en exécution, reportez-vous au Guide PDE.

Création d'un projet de plug-in

  1. Pour travailler, vous devez créer un projet. La façon la plus simple consiste à ouvrir l'assistant Nouveau projet... (Fichier > Nouveau > Projet...) et de choisir Projet de plug-in dans la catégorie Développement de plug-in. Vous configurez ainsi votre projet pour l'écriture de code Java et obtenez un fichier manifeste de plug-in par défaut (expliqué plus loin). Prenez org.eclipse.examples.helloworld comme nom de projet. Par défaut, l'assistant prend également org.eclipse.examples.helloworld comme ID. Même s'il vous permet de générer du code pour plusieurs types de plug-ins, nous allons faire simple. Pour l'instant, choisissez Créer un projet de plug-in vide dans la page Générateurs de code de plug-in.
  2. Pour confirmer que vous souhaitez passer à la perspective Développement de plug-in, cliquez sur Oui.
  3. Créez un package org.eclipse.examples.helloworld sous le répertoire src du projet. Pour ce faire, cliquez deux fois sur le projet org.eclipse.examples.helloworld dans la vue Package. Le projet est alors étendu et présente le répertoire src. Cliquez avec le bouton droit de la souris sur ce répertoire src pour en afficher le menu contextuel. Choisissez Nouveau > Package pour créer un package et nommez-le org.eclipse.examples.helloworld.
  4. Créez une classe nommée HelloWorldView dans ce package. Cliquez avec le bouton droit de la souris sur le package créé à l'étape précédente pour en afficher le menu contextuel. Choisissez Nouveau > Classe pour créer une classe nommée HelloWorldView.

Ecriture du code

Nous sommes prêts à étudier du code. Ci-après tout ce dont vous avez besoin dans votre HelloWorldView. Vous pouvez le copier dans la classe créée : 

   package org.eclipse.examples.helloworld;

   import org.eclipse.swt.widgets.Composite;
   import org.eclipse.swt.widgets.Label;
   import org.eclipse.swt.SWT;
   import org.eclipse.ui.part.ViewPart;

   public class HelloWorldView extends ViewPart {
      Label label;
      public HelloWorldView() {
      }
      public void createPartControl(Composite parent) {
         label = new Label(parent, SWT.WRAP);
         label.setText("Hello World");
      }
      public void setFocus() {
         // activation de mon widget. Ceci ne présente pas vraiment
         // d'intérêt pour un intitulé. Pour des ensembles plus complexes de widgets
         // vous pouvez décider lequel activer.
      }
   }

La partie de la vue crée les widgets qui la représentent dans la méthode createPartControl. Dans cet exemple, un libellé SWT est créé dans lequel le texte "Hello World" est défini. 

Voilà tout ! Nous pouvons compiler notre nouvelle classe, mais il est préférable de s'assurer que notre .classpath est configuré correctement afin de pouvoir compiler le code.  

  1. Sélectionnez le projet org.eclipse.examples.helloWorld et ouvrez la boîte de dialogue Propriétés (cliquez avec le bouton droit de la souris sur le projet org.eclipse.examples.helloWorld et choisissez >Propriétés).
  2. Dans les propriétés Chemin de génération Java, sélectionnez l'onglet Projets et cochez les projets  org.eclipse.ui et org.eclipse.swt. Il s'agit des projets contenant les classes importées.
  3. Regénérez le projet. 

Nous avons donc compilé la vue. La nouvelle doit se présenter comme suit :

Vue simples disant Hello World

Comment exécuter le code et ajouter cette vue au plan de travail ?

Plug-in hello world

Nous devons informer la plateforme que nous voulons ajouter notre vue. Pour ce faire, il suffit d'étendre le point d'extension org.eclipse.ui.views. L'extension est enregistrée en fournissant un fichier manifeste, plugin.xml, qui décrit le plug-in, y compris l'emplacement de son code et l'extension que nous ajoutons.

Vous pouvez copier ces informations dans le fichier plugin.xml généré lors de la création du projet.

   <?xml version="1.0" ?>
   <plugin
      name="Hello World Example" 
      id="org.eclipse.examples.helloworld"
      version="1.0">
      <requires>
         <import plugin="org.eclipse.ui" />
      </requires>
      <runtime>
         <library name="helloworld.jar" />
      </runtime>
      <extension point="org.eclipse.ui.views">
         <category 
            id="org.eclipse.examples.helloworld.hello"
            name="Hello" />
         <view 
            id="org.eclipse.examples.helloworld.helloworldview"
            name="Hello Greetings"
            category="org.eclipse.examples.helloworld.hello"
            class="org.eclipse.examples.helloworld.HelloWorldView" />
      </extension>
   </plugin>

Dans ce fichier, définissez le nom, l'id et la version de notre plug-in.

Les plug-ins requis sont également énumérés. Comme l'API SWT et le plan de travail sont utilisés, org.eclipse.ui doit figurer dans la liste. Vous devez également décrire l'emplacement du code exécutable. Tentez d'assembler le code dans helloworld.jar et enregistrez comme nom de votre bibliothèque.

Enfin, déclarez à quel point d'extension le plug-in contribue. L'extension org.eclipse.ui.views dispose de plusieurs paramètres de configuration différents. Pour l'extension de la vue, une catégorie a d'abord été déclarée. Les catégories peuvent être utilisées pour regrouper les vues connexes dans la boîte de dialogue Affichage de la vue du plan de travail. Définissez votre propre catégorie "Hello" afin qu'elle affiche son groupe. Déclarez un id unique pour la vue et indiquez le nom de la classe offrant l'implémentation de la vue. Un nom est également spécifié pour la vue, "Hello Greetings", qui s'affichera dans la boîte de dialogue Affichage de la vue et dans la barre de titre de la vue.

ID du plug-in

De nombreux ID sont utilisés dans un fichier manifeste de plug-in. Les points d'extension individuels définissent souvent les paramètres de configuration qui requièrent des ID (par exemple l'ID catégorie utilisé ci-dessus pour le point d'extension des vues). Un ID de plug-in est également défini. En règle générale, les préfixes de nom du package Java doivent être utilisés pour tous les ID afin d'assurer l'identité unique parmi tous les plug-ins installés. 

Le nom spécifique utilisé après le préfixe ne dépend que de vous. Cependant, si le préfixe de l'ID de votre plug-in est exactement le même nom que celui de l'un de vos packages, vous devez éviter d'utiliser des noms de classe de ce package. Sinon, il deviendra difficile de dire s'il s'agit d'un nom d'ID ou d'un nom de classe.

Vous devez également éviter d'utiliser le même ID pour différents paramètres de configuration d'extension. Dans le manifeste ci-dessus, un préfixe d'ID commun a été utilisé (org.eclipse.examples.helloworld), mais tous les ID sont uniques. Cette approche de dénomination permet de lire le fichier et de voir quels sont les ID concernés.

Et ensuite ?

ce stade, vous avez implémenté une vue et déclaré votre contribution dans votre manifeste de plug-in. Vous devez désormais installer votre plug-in dans la plateforme afin de pouvoir l'exécuter.

Copyright IBM Corporation and others 2000, 2003.