IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo

FAQ Plateforme EclipseConsultez toutes les FAQ

Nombre d'auteurs : 6, nombre de questions : 26, dernière mise à jour : 13 janvier 2019  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de www.developpez.net/forums et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci .

Sur ce, nous vous souhaitons une bonne lecture.

L'équipe Java/Eclipse

SommaireDéveloppement de plugins (4)
précédent sommaire suivant
 

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 :

Mis à jour le 9 juillet 2011 Laurent.B

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:


Il est à noter que le Plug-in Menu Spy n'est apparu qu'à partir de la version 3.5 d'Eclipse.

Mis à jour le 26 avril 2012 Gueritarish

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 :

Code xml : Sélectionner tout
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>
Où :

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

Ensuite, créer la classe MySourceProvider dans le package com.foo.myapp. Cette classe hérite de AbstractSourceProvider (pour plus de lisibilité).

Code java : Sélectionner tout
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); 
		} 
	} 
}
Dans le fichier plugin.xml, à la définition du handler de la commande, rajouter :

Code xml : Sélectionner tout
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>
Ensuite, appeler la méthode setVariableState() pour mettre à jour la valeur de la variable (enabled ou non). Ex. dans un listener :

Code java : Sélectionner tout
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); 
	    } 
	}
Pour ce qui est de rendre visible ou invisible le menu, on peut utiliser le même principe, c'est-à-dire en déclarant ceci :

Code xml : Sélectionner tout
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>

Mis à jour le 7 septembre 2011 Gueritarish

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.

Vous pouvez alors contrôler que dans l'onglet MANIFEST.MF celui-ci comporte effectivement une référence similaire à celle-ci :

Code text : Sélectionner tout
Bundle-ClassPath: une_bibliotheque.jar
Il en va de même pour le fichier build.properties, lequel doit quant à lui contenir une référence similaire à ceci :

Code text : Sélectionner tout
1
2
bin.includes = META-INF/,\ 
               une_bibliotheque.jar
Le JAR référencé est à présent prêt à être utilisé au sein du plug-in qui le contient.

cas n°2 :

A partir du moment où vous avez besoin qu'un JAR puisse être utilisé par plusieurs de vos plug-ins, le plus judicieux est de créer un plug-in totalement dédié à celui-ci.

Vous avez alors 2 possibilités, soit de réaliser manuellement toute l'opération nécessaire, soit de laisser faire Eclipse par l'intermédiaire d'un assistant.

L'opération n'étant pas particulièrement compliquée, voici tout d'abord comment la réaliser manuellement :

  • 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.

Vous pouvez contrôler le fait que les packages sont bien indiqués comme exportés, en sélectionnant l'onglet MANIFEST.MF, puis en contrôlant la présence d'un code similaire à ceci :

Code text : Sélectionner tout
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
En ce qui concerne la solution consistant à faire appel à l'assistant d'Eclipse, celle-ci produira le même résultat. Elle n'a d'avantage que le fait d'être plus rapide et légèrement plus aisée.
Pour ce faire :

  • 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.

A présent, vous pouvez faire référence à ce nouveau plug-in, comme à n'importe quel autre, et la bibliothèque que vous avez inclue dans celui-ci est désormais accessible aux autres plug-ins.

Cette pratique est ce que l'on peut appeler la "bundleisation d'un JAR".

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.

Mis à jour le 24 septembre 2012 Gueritarish Laurent.B

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.