FAQ Plateforme EclipseConsultez toutes les FAQ

Pour développer un plug-in Eclipse, la première chose à faire est de partir du bundle Eclipse for RCP and RAP Developers, disponible ici http://www.eclipse.org/downloads/.

Ensuite, vous pouvez suivre les tutoriels présents ici http://eclipse.developpez.com/cours/...cat#plugin-dev ou ici http://www.eclipse.org/resources/.

Afin de faciliter votre prise de connaissances sur le développement de plug-ins, n'hésitez pas à vous procurer des livres.
Voici quelques-uns des ouvrages disponibles :

• Eclipse : Principes, patterns et plugins (21 juillet 2004)
• Eclipse Plug-ins (3rd Edition) (21 décembre 2008)
  

Pour pouvoir examiner une classe de la plateforme Eclipse correspondant à un élément affiché directement à l'écran, il faut passer par le plug-in Spy. Cette fonction est accessible à partir de 2 raccourcis clavier :

• ALT + SHIFt + F1 (Plug-in Selection Spy) permet d'afficher les informations sur la sélection courante (typiquement, le composant ayant le focus: wizard, éditeur, vue..). Ces informations donnent le plug-in contribuant à ce composant, l'identifiant de la (des) section(s) d'aide, les classes implémentant ce composant...
  
  Exemple pour l'éditeur Java:
  
  

• ALT + SHIFT + F2 (Plug-in Menu Spy) permet d'afficher les informations sur la sélection de l'utilisateur. On peut donc chercher des informations sur les commandes dans les menus (contextuels ou non), les toolbars... Les informations contiennent en plus l'emplacement de la commande (entre autre).
  
  Exemple pour la commande Save As:
  
  

Tout d'abord, pour créer un menu que l'on peut activer ou désactiver en fonction du contexte, voici comment il faut procéder :

Déclarer un SourceProvider dans le fichier plugin.xml de l'application :

1
2
3
4
5
6
7
8
<extension point="org.eclipse.ui.services"> 
    <sourceProvider provider="com.foo.myapp.MySourceProvider"> 
        <variable  
             name="com.foo.myapp.myVariable" 
             priorityLevel="workbench"> 
        </variable> 
    </sourceProvider> 
</extension>

• com.foo.myapp.MySourceProvider est la classe qui va étendre ISourceProvider
• com.foo.myapp.myVariable est le nom de la variable
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class MySourceProvider extends AbstractSourceProvider { 
  
	/** Nom de la variable à vérifier. */ 
	public final static String VARIABLE = "com.foo.myapp.myVariable"; 
  
	/** Valeur de l'état actif. */ 
	private final static String ENABLED = "enabled"; 
  
	/** Valeur de l'état inactif. */ 
	private final static String DISABLED = "disabled"; 
  
	/** L'état courant de la variable. */ 
	private boolean enabled; 
  
	@Override 
	public String[] getProvidedSourceNames() { 
  
	    return new String[] { VARIABLE }; 
	} 
  
	@Override 
	public Map getCurrentState() { 
  
	    String variabletState = enabled ? ENABLED : DISABLED; 
  
	    Map currentState = new HashMap(1); 
	    currentState.put(VARIABLE, variableState); 
  
	    return currentState; 
	} 
  
	/** 
	 * Met à jour l'état de la variable. 
	 * 
	 * @param flag Flag fournissant l'état de la variable : 
	 * 		<code>true</code> pour {@link MySourceProvider#ENABLED ENABLED}, 
	 * 		<code>false</code> pour {@link MySourceProvider#DISABLED DISABLED}. 
	 */ 
	public void setVariableState(boolean flag) { 
  
		if (this.enabled != flag) { 
  
			this.enabled = flag; 
			String currentState = enabled ? ENABLED : DISABLED; 
			fireSourceChanged(ISources.WORKBENCH, VARIABLE, currentState); 
		} 
	} 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<extension 
       point="org.eclipse.ui.handlers"> 
    <handler 
          class="com.foo.MyHandler" 
          commandId="com.foo.myCommand"> 
       <activeWhen> 
          <with 
                variable="com.foo.myapp.myVariable"> 
             <equals 
                   value="enabled"> 
             </equals> 
          </with> 
       </activeWhen> 
    </handler> 
 </extension>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	boolean newVariableState = true; 
	// Récupération du ISourceProviderService. 
	ISourceProviderService sourceProviderService = (ISourceProviderService) PlatformUI.getWorkbench().getService(ISourceProviderService.class); 
  
	if (sourceProviderService != null) { 
  
	    // Récupération du fournisseur de la variable en question. 
	    ISourceProvider provider = sourceProviderService.getSourceProvider(MySourceProvider.VARIABLE); 
  
	    if (provider instanceof MySourceProvider) { 
	        // Positionnement du nouvel état de la variable. 
	        ((MySourceProvider) provider).setVariableState(newVariableState); 
	    } 
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<extension 
         point="org.eclipse.ui.menus"> 
      <menuContribution 
            locationURI="menu:com.foo.my.menu?after=additions"> 
         <command 
               commandId="com.foo.myCommand"> 
            <visibleWhen 
                  checkEnabled="false"> 
               <with 
                     variable="com.foo.myapp.myVariable"> 
                  <equals 
                        value="enabled"> 
                  </equals> 
               </with> 
            </visibleWhen> 
         </command> 
      </menuContribution> 
</extension>

Si l'un de vos plug-ins nécessite l'utilisation d'un JAR spécifique, l'explication suivante va vous indiquer comment intégrer celui-ci. Toutefois, avant de suivre cette procédure, vous devez déterminer le besoin précis, c'est-à-dire si le JAR en question est nécessaire à un seul plug-in ou au contraire à plusieurs.

Si votre composant n'est constitué que d'un seul plug-in ou si vous savez que le JAR ne sera utile qu'à un seul des plug-ins de votre composant, suivez le cas n°1.

Si vous souhaitez utiliser le JAR dans plusieurs des plug-ins de votre composant, suivez le cas n°2.

cas n°1 :

• Placez le fichier JAR concerné à la racine du projet (ce n'est pas obligatoire mais c'est recommandé et cela simplifie la procédure).
• Ensuite, double-cliquez sur le fichier META-INF/MANIFEST.MF, de votre projet de plug-in. Ceci provoque l'ouverture de l'éditeur des propriétés du plug-in.
• Placez vous dans l'onglet Runtime
• Dans la zone ClassPath, cliquez sur le bouton Add..., sélectionnez le fichier JAR que vous aurez mis à la racine, puis validez.
• Placez-vous ensuite sur l'onglet Build et assurez-vous que le fichier JAR est bien coché dans la zone Binary Build. Ainsi, il pourra être intégré au sein du plug-in, au moment du Build.
  

Bundle-ClassPath: une_bibliotheque.jar

1
2
bin.includes = META-INF/,\ 
               une_bibliotheque.jar

• Toute d'abord, il faut créer un projet de plug-in de manière classique.
• Ensuite, procédez de la même manière que dans le cas n°1.
• A présent, il reste à faire en sorte que le JAR puisse être utilisé en dehors de son plug-in dédié. Pour cela, toujours dans le fichier MANFEST.MF, sélectionnez l'onglet Runtime.
• Dans la zone Exported Package, cliquez sur Add... et ainsi vous devriez voir apparaître l'ensemble des packages du JAR.
• Sélectionnez les tous, puis cliquez sur Ok.
  

1
2
3
4
Export-Package: com.mon.composant.une.bibliotheque.biz, 
 com.mon.composant.une.bibliotheque.bean, 
 com.mon.composant.une.bibliotheque.implement, 
 com.mon.composant.une.bibliotheque.util

• Allez dans le menu File > New > Other... > Plug-in Development, puis sélectionnez Plug-in from Existing JAR Archives.
• Sur la page qui s'affiche, cliquez sur Add... ou Add External... (en fonction de votre contexte) afin de sélectionner le ou les JAR à transformer en plug-in, puis cliquez sur Next.
• Spécifiez le nom de votre plug-in. Pour cela, vous aurez avantage à respecter la convention habituelle du nommage de vos plugins&packages, avec éventuellement en suffixe, le package principal du JAR ajouté.
• Réglez les autres paramètres comme bon vous semblera, puis cliquez sur Finish.
  

Remarque : Avant de vous lancer dans la bundleisation d'un JAR, vérifiez que celui-ci ne l'est pas déjà. En effet, vous l'aurez compris, la bundleisation d'une bibliothèque implique simplement de mettre un ou plusieurs JAR dans un nouveau JAR de type plug-in, tout en ajoutant les déclarations OSGi nécessaires, au sein du fichier MANIFEST.MF. De fait, un certain nombre de bibliothèques, comme par exemple celles de la fondation Apache, peuvent déjà avoir été bundleisées. Donc, le cas échéant et sauf besoins particuliers, il sera parfaitement inutile de bundleiser ceux-ci une deuxième fois. Ainsi, pour effectuer cette vérification préalable, il suffit d'observer le contenu du JAR concerné (en le dézippant), notamment au niveau de son fichier META-INF/MANIFEST.MF. Si celui-ci comporte des variables OSGi telles que celles commençant par "Bundle-", alors cela signifie que c'est un JAR effectivement bundleisé. Dès lors, vous pouvez l'utiliser comme n'importe quel autre plug-in. Si vous constatez qu'un JAR n'est pas bundleisé, alors peut-être sera-t-il intéressant de faire une recherche préalable, au cas où une version bundleisée serait disponible par ailleurs. Vous pouvez par exemple, consulter les sites comme Orbit ou SpringSource, lesquels proposent des versions bundleisées de JAR. Dans le cas contraire, vous n'aurez plus qu'à le faire vous-même, comme expliqué précédemment.