Fragmento de complemento de Eclipse

Question

¿Alguien tiene una muestra o tutorial de "mundo hello" para crear un fragmento de plugin de Eclipse?

que tienen un plugin de acogida de trabajo que, en aras de la simplicidad, es sólo esto ...

public void start(BundleContext context) throws Exception { 
    System.out.println("Hello...."); 
    super.start(context); 
    plugin = this; 
} 

public void stop(BundleContext context) throws Exception { 
    System.out.println("Goodbye..."); 
    plugin = null; 
    super.stop(context); 
} 

Bastante simple y funciona. Ahora quiero agregar un fragmento a ese host, que no parece tan simple como crear un host de complemento. Simplemente no veo cómo crear un proyecto de fragmento y agregarle lógica. Digamos que solo quiero hacer algo simple y tengo el fragmento para imprimir un "Hello2" en start() y "Goodbye2" en stop(). ¿Puede alguien darme un ejemplo de trabajo?

Answer 1

Eclipse -> Archivo -> Nuevo ... -> Proyecto de fragmentación -> configure el complemento de host (que se encuentra en su espacio de trabajo o en los complementos de la plataforma de destino).

Abra el "Editor de manifiestos de complementos" (puede hacerlo haciendo clic en build.properties, manifest.mf o fragment.xml - si no hay tal archivo, créelo a mano) y en la pestaña llamada "Extentions" haga clic en "Agregar ..." y agregue "org.eclipse.ui.startup" y explore la clase que implementa la clase org.eclipse.ui.IStartup. Crea esta clase e impleméntala. Necesita implementar el método earlyStartup() que es el punto de entrada al fragmento.

Nota: Las líneas a continuación son solo un ejemplo. No lo probé para que haya errores ...

Todo lo que necesita es este (esta es la estructura del proyecto/estructura de directorios):

• Fragmento-Proyecto - directorio raíz
  • /META-INF
    • MANIFEST.MF
  • /src (que es directorio de origen)
    • FragmentStartClass.java (que implementa la interfaz org.eclipse.ui.IStartup y método earlyStartup)
  • build.properties
  • fragment.xml

META-INF/MANIFEST.MF contenido:

 
Manifest-Version: 1.0 
Bundle-ManifestVersion: 2 
Bundle-Name: FragmentProject 
Bundle-SymbolicName: FragmentProject;singleton:=true 
Bundle-Version: 1.0.0 
Bundle-ClassPath: src/,. 
Fragment-Host: *HostPluginProjectSymbolicName*;bundle-version="1.0.0" 
Bundle-RequiredExecutionEnvironment: J2SE-1.5 
Require-Bundle: 

build.properties contenido:

 
source.. = src,\ 
output.. = bin/ 
bin.includes = META-INF/, 
       ., 
        fragment.xml 

fragment.xml contenido:

 
<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.2"?> 
<fragment> 
    <extension 
     point="org.eclipse.ui.startup"> 
     <startup 
      class="FragmentStartClass"> 
     </startup> 
    </extension> 
</fragment> 

FragmentStartClass.java contenido:

 
import org.eclipse.ui.IStartup; 


public class FragmentStartClass implements IStartup { 

    public void earlyStartup() { 
     System.out.println("Hello World From Fragment!"); 

    } 


} 

Answer 2

Bueno, ¿qué estás tratando de lograr? ¿Estás seguro de que los fragmentos son la solución?

Los fragmentos son simplemente adiciones a un complemento existente. No hay un Activador de Bundle para "iniciar" el fragmento. Simplemente obtienes los recursos adicionales en el fragmento. Podría usar un punto de extensión para informar al host que alguna funcionalidad particular fue extendida por un fragmento presente. Piense en ello como la fusión de los dos en el tiempo de ejecución.

Ver this note del Eclipse Wiki.

Answer 3

No estoy seguro de poder hacer esto sin que el complemento del host sepa algo sobre cargar el código de implementación extra del fragmento.

Por ejemplo:

MyInterface o = null; 
try { 
    Class<?> c = getClass().getClassLoader().loadClass("my.fragment.Activator"); 
    o = (MyInterface) c.newInstance(); 
} catch (ClassNotFoundException e) { 
} 

if (o != null) { 
    o.start(); 
} 

donde MyInterface es una interfaz definida en el plugin anfitrión, e implementado por su fragmento.

Otra forma podría ser que el fragmento proporcione un punto de extensión que identifique la clase extendida, pero probablemente sea más de lo necesario.

Answer 4

Creo que lo que está tratando de hacer es mejor si usa extension points y plugins separados, ya que desea agregar funcionalidad al plugin base.

Los fragmentos solo se usan para agregar recursos o clases adicionales al complemento base.

Answer 5

Para el registro, que acaba de crear un fragmento de Eclipse que contiene algunas clases de reglas PMD Java.

Al lado de los archivos de clase, no es sólo un archivo requerido en ese tarro: META-INF/MANIFEST.MF:

Manifest-Version: 1.0 
Bundle-ManifestVersion: 2 
Bundle-Name: com.acme.tools.pmd 
Bundle-SymbolicName: com.acme.tools.pmd;singleton:=true 
Bundle-Version: 1.0.0 
Fragment-Host: net.sourceforge.pmd.eclipse.plugin;bundle-version="3.2.6" 
Bundle-RequiredExecutionEnvironment: J2SE-1.5 

yo probamos este con corriente Eclipse 3.7. La implementación consiste en colocar el archivo Jar en <eclipse root>/dropins/plugins (cree esa carpeta si aún no está allí).