Comment ajouter une entrée au menu contextuel d'eclipse Package Explorer pour lancer un TextEditor ?

Question

J'essaie d'ajouter une entrée au menu contextuel de l'explorateur de paquets qui ouvre une version modifiée d'un fichier dans un éditeur lorsque l'entrée est sélectionnée.

J'utilise Eclipse Indigo sur un ordinateur portable Fedora 15.

Voici une question très spécifique qui peut être suffisamment bien ciblée et qui pourrait fournir l'aide dont j'ai besoin pour résoudre le problème général que j'ai.

Eclipse fournit un exemple de plugin nommé org.eclipse.ui.examples.readmetool, qui peut être configuré à partir de la page Aide->Bienvenue.

Ce plugin définit un éditeur nommé ReadmeEditor.java. Il définit également un point d'extension "org.eclipse.ui.popupMenus" dans plugin.xml. Lorsque vous utilisez cette action à partir de la vue de l'explorateur de projet d'eclipse sur un fichier avec le suffixe ".readme", vous obtenez juste une petite fenêtre popup.

Comment puis-je modifier le plugin readmetool de sorte que lorsque vous sélectionnez l'élément de menu de l'explorateur de projet défini ci-dessus sur un fichier foo.readme, vous obtenez à la place un nouveau ReadmeEditor dans eclipse, avec foo.readme dedans ?

Le besoin plus spécifique du projet auquel je me heurte est le suivant :

• Dans l'explorateur de paquets, naviguez jusqu'à un fichier.

• Cliquez avec le bouton droit de la souris sur le fichier pour obtenir un menu contextuel.

• Voir un nouvel article "Vue de la version".

• En sélectionnant cette entrée, trouvez le fichier, exécutez-le par le biais d'un programme externe pour créer un fichier temporaire, et affichez le contenu de ce fichier temporaire dans une nouvelle fenêtre TextEditor. (Et, ne laissez pas traîner un fichier temporaire orphelin après qu'il ne soit plus nécessaire).

J'ai mis en place certaines des pièces ci-dessus ; j'ai augmenté l'exemple de MultiPageEditor pour qu'il fasse le travail d'exécuter le programme externe, de créer le fichier temporaire et d'ouvrir le fichier temporaire dans un éditeur de texte.

Cependant, la seule façon dont je peux actuellement accéder à cette fonctionnalité est de sélectionner l'option "Ouvrir avec" dans la fenêtre contextuelle du fichier dans l'explorateur de projet, puis d'aller dans "Autre" dans cette fenêtre et de sélectionner ma nouvelle option d'éditeur.

Donc, là où je suis bloqué pour le moment, c'est comment ajouter la bonne magie à plugin.xml pour que j'obtienne une nouvelle option sur la fenêtre contextuelle du gestionnaire de projet, et la connecter avec une nouvelle fenêtre TextEditor.

Cela ressemble beaucoup à ce que ferait l'option vanille "Open", et il semble que cela devrait être une chose assez basique à faire dans Eclipse. Tout exemple et/ou conseil serait grandement apprécié.

Greg

Answer 1

Voici un exemple laconique mais complet de mise en place et d'utilisation d'un projet. (En parcourant le net, il y avait beaucoup de conseils sur Eclipse, mais ils avaient tendance à être plutôt fragmentés et fragmentaires, et lorsque je me battais pour résoudre mon problème, il aurait été utile d'avoir un HOWTO complet et autonome. Donc, c'est ça )

Cette recette suppose que vous utilisez Eclipse Indigo ou Juno avec :

• IDE Eclipse pour les développeurs Java
• Environnement de développement de plug-ins Eclipse.

Pour confirmer ce qui précède à partir d'eclipse, voir

Help -> About Eclipse -> Installation Details -> Installed Software

1. démarrer Ecipse Indigo, avec un espace de travail frais et vide :

   you, before starting eclipse:
             move or delete ~/eclipse.d/popup_workspace.d
             mkdir -p ~/eclipse.d/popup_workspace.d
   start eclipse:  eclipse
   eclipse:  "Select a workspace"
   you:      "Browse", navigate to above-created popup_workspace.d; "OK" "OK"
   eclipse:  "Welcome to Eclipse IDE for Java Developers"
   you:      select "Workbench"

2. créer un nouveau projet, en utilisant le projet de plug-in comme point de départ pratique :

   you:      File -> New -> Project
   eclipse:  "Select a wizard:
   you:      Plug-in Development -> Plug-in Project;  Next>
   eclipse:  "Plug-in Project"
   you:      Project name:  org.mypopup.popup_editor  Next>
   eclipse:  "Content"
   you:      Next>
   eclipse:  "Templates"
   you:      Plug-in with a popup menu                Finish
   eclipse:  "This kind of project is associated with the
             Plug-in Development perspective..."
   you:      Yes

3. dans "Package Explorer", naviguez jusqu'à NewActions.java et double-cliquez pour l'ouvrir :

   org.mypopup.popup_editor
       -> src
           -> org.mypopup.popup_editor.popup.actions
               -> NewAction.java
   
   delete entire contents and replace with:
   
   package org.mypopup.popup_editor.popup.actions;
   
   import org.eclipse.jface.viewers.TreeSelection;
   import org.eclipse.jface.viewers.TreePath;
   import org.eclipse.core.resources.IFile;
   import org.eclipse.core.filesystem.EFS;
   import org.eclipse.core.runtime.IPath;
   import org.eclipse.jface.action.IAction;
   import org.eclipse.jface.viewers.ISelection;
   import org.eclipse.ui.IObjectActionDelegate;
   import org.eclipse.ui.IWorkbenchPage;
   import org.eclipse.ui.IWorkbenchPart;
   import org.eclipse.ui.IWorkbenchWindow;
   import org.eclipse.ui.PlatformUI;
   import org.eclipse.ui.ide.IDE;
   
   public class NewAction implements IObjectActionDelegate {
       public NewAction() {
           super();
       }
   
       public void run(IAction action) {
           try {
               IWorkbenchWindow window =
                       PlatformUI.getWorkbench().getActiveWorkbenchWindow();
   
               ISelection selection = window.getSelectionService()
                       .getSelection("org.eclipse.ui.navigator.ProjectExplorer");
   
               TreePath[] paths = ((TreeSelection) selection).getPaths();
               TreePath p = paths[0];
               Object last = p.getLastSegment();
   
               if (last instanceof IFile) {
                   IPath ipath = ((IFile) last).getLocation();
   
                   IWorkbenchPage page = window.getActivePage();
   
                   IDE.openEditorOnFileStore(page,
                           EFS.getLocalFileSystem().getStore(ipath));
               }
           } catch (Exception blah) {
           }
       }
   
       public void setActivePart(IAction action, IWorkbenchPart targetPart) { }
   
       public void selectionChanged(IAction action, ISelection selection) { }
   }

4. ajouter des dépendances au projet pour pouvoir résoudre les importations :

   in Package Explorer, navigate to and open META-INF -> MANIFEST.MF
   
   Select "Dependencies" tab along the bottom of the resulting
   "org.mypopup.plugin_editor" window
   
   "Add..."; "Select a Plug-in:" enter org.eclipse.core.filesystem; "OK"
   "Add..."; "Select a Plug-in:" enter org.eclipse.ui.ide; "OK"
   
   File -> Save my.popup.popup_editor

5. Exécutez le nouveau projet, avec un nouveau répertoire cible vide :

   outside of eclipse, browse to the directory containing popup_workspace.d,
   in this case ~/eclipse.d, and if a folder "runtime-EclipseApplication"
   exists, move it or delete it.
   
   right-click META-INF -> MANIFEST.MF, select Run As -> Eclipse Application
   
   in new eclipse window:
   eclipse:  "Welcome to Eclipse"
   you:      select "Workbench"
   you:      File -> New -> Project
   eclipse:  "Select a wizard"
   you:      General -> Project              Next>
   eclipse:  "Project"
   you:      project name popup_test         Finish
   you:      in Project Explorer, right-click popup_test, select New -> File
   eclipse:  "File"
   you:      File name:  test_file1          Finish
   you:      enter a little text in test_file1, File -> Save; File -> Close

6. le grand moment : ouvrez le fichier avec votre nouvelle entrée de menu contextuel :

   in Project Explorer, right-click popup_test -> test_file1
   select New Submenu -> New Action

Answer 2

Le site readmetool fournit déjà une action de menu contextuel pour les fichiers .readme :

<extension
     point="org.eclipse.ui.popupMenus">
  <objectContribution
        objectClass="org.eclipse.core.resources.IFile"
        nameFilter="*.readme"
        id="org.eclipse.ui.examples.readmetool">
     <action
           label="%PopupMenus.action"
           icon="$nl$/icons/ctool16/openbrwsr.gif"
           helpContextId="org.eclipse.ui.examples.readmetool.open_browser_action_context"
           class="org.eclipse.ui.examples.readmetool.PopupMenuActionDelegate"
           menubarPath="additions"
           enablesFor="1"
           id="org.eclipse.ui.examples.readmetool.action1">
     </action>
  </objectContribution>
  ...
</extension>

Il s'appelle Show Readme Action mais vous pouvez le renommer en Version view en modifiant le fichier plugin.properties qui contient les noms des étiquettes correspondantes :

PopupMenus.action = &Version view

Ensuite, il vous suffit de modifier PopupMenuActionDelegate et modifier son implémentation pour faire ce que vous voulez :

public class PopupMenuActionDelegate implements IObjectActionDelegate {

    public void run(IAction action) {
        // invoke the external tool and open the result in a new editor
    }
    ...
}

Answer 3

Voici un petit exemple autonome d'ouverture d'une fenêtre d'éditeur en réponse à la sélection d'une option de fenêtre contextuelle. À titre de test, il ouvre un fichier avec un nom câblé.

public void run(IAction action) {
    try {
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        File f = new File("/tmp/testum");
        IPath ipath = new Path(f.getAbsolutePath());
        IWorkbenchPage page = window.getActivePage();
        IDE.openEditorOnFileStore(page, EFS.getLocalFileSystem().getStore(ipath));
    } catch (Exception blah) {
        System.err.println("Exception!");
    }
}