Un conector mínimo

Todos conocemos qué aspecto tiene "Hello World" en la versión antigua y sencilla de Java sin utilizar ninguna interfaz de usuario ni otra infraestructura.

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

¿Qué le sucede a este estándar antiguo en el contexto de la plataforma Eclipse? En lugar de considerar el programa Hello World como autocontenido, lo replantearemos como si fuese una extensión de la plataforma. Puesto que queremos saludar al mundo, tenemos que averiguar cómo ampliar el entorno de trabajo para incluir nuestro saludo.

Al profundizar en los componentes de la interfaz de usuario de la plataforma, haremos una revisión exhaustiva de las maneras en las que se puede ampliar y personalizar la UI del entorno de trabajo. De momento, empezaremos por una de las extensiones más simples del entorno de trabajo: una vista. 

La ventana del entorno de trabajo es como un marco que presenta los diversos componentes visuales. Estos componentes se dividen en dos categorías principales: vistas y editores.  Examinaremos los conectores posteriormente. Las   vistas proporcionan información sobre algunos objetos con los que el usuario está trabajando en el entorno de trabajo. Las vistas suelen cambiar de contenido a medida que el usuario selecciona diferentes objetos en el entorno de trabajo.

Vista de Hello World (Hola mundo)

En el caso de nuestro conector Hello World, implementaremos nuestra propia vista para saludar al usuario con "Hello World".

El paquete org.eclipse.ui y sus subpaquetes contienen las interfaces públicas que definen la API de la interfaz del usuario (UI). Muchas de estas interfaces tienen clases de implementación por omisión que podrá ampliar para proporcionar modificaciones simples al sistema. En el ejemplo Hello World, ampliaremos una vista del entorno de trabajo para proporcionar una etiqueta en la que figure la palabra hello (hola).

La interfaz que nos interesa es IViewPart, que define los métodos que deben implementarse para contribuir aportando una vista al entorno de trabajo. La clase ViewPart proporciona una implementación por omisión de esta interfaz. En pocas palabras, el componente vista se encarga de crear los widgets que se necesitan para mostrar la vista.

Las vistas estándar del entorno de trabajo suelen visualizar información sobre un objeto que el usuario ha seleccionado o por el que está navegando. Las vistas actualizan su contenido basándose en las acciones que tienen lugar en el entorno de trabajo. En este caso, tan solo pretendemos saludar, por lo que nuestra vista es muy sencilla.

Utilizar las herramientas para escribir nuestro conector

Puede utilizar cualquier IDE Java para construir conectores de Eclipse, pero ahora construiremos paso a paso nuestro conector con el IDE Java de Eclipse. Si todavía no está familiarizado con el entorno de trabajo de Eclipse ni con su IDE Java, en el manual del usuario del desarrollo Java hallará más explicaciones sobre los pasos que seguiremos.  Por ahora, nos centraremos en el código, no en la herramienta.  Sin embargo, a modo de iniciación, revisaremos algunos aspectos logísticos del IDE.

Configurar el entorno

Si empieza desde un entorno limpio, deberá asegurarse de que el código tiene acceso a los conectores org.eclipse.ui. Importe este conector y los que éste necesite en la instancia del entorno de trabajo de tiempo de ejecución llevando a cabo los pasos que se indican más abajo. Si ya tiene estos conectores en la instancia del entorno de trabajo, pase a la sección "Crear el proyecto de conector".

  1. Desde la perspectiva de recursos, utilice Archivo > Importar... > Conectores externos y fragmentos.
  2. Continúe pulsando los botones Siguiente > hasta llegar a la pantalla titulada Selección. Esta pantalla contendrá una lista de todos los conectores de la instancia del entorno de trabajo del sistema principal.
  3. Seleccione org.eclipse.ui y, a continuación, pulse el botón Añadir conectores necesarios.
  4. Pulse el botón Finalizar. La vista Navegador debe contener org.eclipse.ui y todos los conectores que éste requiere (incluyendo org.eclipse.swt).

Para obtener una descripción completa de cómo configurar las instancias de entorno de trabajo de tiempo de ejecución y sistema principal, consulte la guía del PDE.

Crear el proyecto de conector

  1. Necesitará crear un proyecto para realizar el trabajo.  La forma más sencilla de hacerlo es abrir el asistente Proyecto nuevo... (Archivo > Nuevo > Proyecto...) y elegir Proyecto de conector desde la categoría Desarrollo de conectores.  Esto hará que el proyecto quede configurado para escribir código Java y le proporcionará un archivo de manifiesto de conector por omisión (que describiremos ahora mismo).  Utilice org.eclipse.examples.helloworld como nombre del proyecto. Por omisión, el asistente establece también org.eclipse.examples.helloworld como ID.  El asistente le brinda la oportunidad de generar código para diferentes clases de conectores, pero ahora nos interesa que el proceso sea simple.  En esta ocasión, elija Crear un proyecto de conector en blanco en la página Generadores de código de conector.
  2. Cuando se le solicite si desea cambiar a la perspectiva Desarrollo de conectores, responda .
  3. Cree un paquete org.eclipse.examples.helloworld bajo el directorio src del proyecto. Para ello, efectúe una doble pulsación sobre el proyecto org.eclipse.examples.helloworld en la vista Explorador de paquetes. Con ello expandirá el proyecto y visualizará el directorio src. Pulse el directorio src con el botón derecho del ratón para abrir el menú de contexto. Utilice Nuevo > Paquete para crear un paquete nuevo y denomínelo org.eclipse.examples.helloworld
  4. Cree una clase nueva llamada HelloWorldView en este paquete. Pulse sobre el paquete que acaba de crear en el paso anterior con el botón derecho del ratón para abrir el menú de contexto. Utilice Nuevo > Clase para crear la clase nueva con el nombre HelloWorldView.

Escribir el código

Ya estamos preparados para estudiar el código.  A continuación figura todo lo que necesita en la vista HelloWorldView.  (Puede copiar el siguiente contenido en la clase que ha creado). 

   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() {
         // Establecer el foco en mi widget. En el caso de una etiqueta, ello
         // no tiene mucho sentido, pero para conjuntos de widgets más complejos,
         // hay que decidir cuál de ellos obtendrá el foco.
      }
   }

El componente vista crea los widgets que la representarán en el método createPartControl. En este ejemplo, creamos una etiqueta de SWT y en ella establecemos el texto "Hello World". 

Eso es todo cuanto necesitamos.  Podemos compilar la clase nueva, pero antes es mejor asegurarnos de que nuestro archivo .classpath está debidamente configurado para compilar el código.  

  1. Seleccione el proyecto org.eclipse.examples.helloWorld y abra el diálogo Propiedades (pulse con el botón derecho del ratón el proyecto org.eclipse.examples.helloWorld > Propiedades).
  2. En las propiedades Vía de construcción Java, seleccione la pestaña Proyectos y marque los proyectos org.eclipse.ui y org.eclipse.swt. En estos proyectos están las clases que importamos.
  3. Reconstruya el proyecto. 

Bien, ya hemos compilado la vista.  Su aspecto debe ser parecido al siguiente:

Vista simple con el texto Hello World

¿Cómo ejecutamos el código y añadimos esta vista al entorno de trabajo?

El conector Hello World (Hola mundo)

Tenemos que comunicar a la plataforma que queremos contribuir con nuestra vista. Para ello, ampliamos el punto de extensión org.eclipse.ui.views. Registramos la extensión proporcionando un archivo de manifiesto, plugin.xml, que describe nuestro conector (incluida la ubicación del código) y la extensión que estamos añadiendo.

(Si todavía está siguiendo estas instrucciones, puede copiar esta información en el archivo plugin.xml que se generó al crear el proyecto).

   <?xml version="1.0" ?>
<plugin
      name="Ejemplo Hello World" 
      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>

En este archivo, definimos los atributos name, id y version de nuestro conector.

También proporcionamos una lista de los conectores necesarios, en el parámetro requires. Puesto que utilizamos la API del entorno de trabajo y de SWT en nuestro conector, debemos incluir org.eclipse.ui en la lista. También debemos indicar en qué lugar se encuentra el código ejecutable. Nos proponemos empaquetar el código en el archivo helloworld.jar, por lo que lo registraremos como nombre de biblioteca (parámetro library name).

Por último, declaramos con qué punto de extensión va a contribuir el conector. La extensión org.eclipse.ui.views tiene varios parámetros de configuración diferentes. En primer lugar, declaramos una categoría (parámetro category) en la extensión de nuestra vista. Las categorías permiten agrupar las vistas relacionadas en el diálogo Mostrar vista del entorno de trabajo. Definimos nuestra propia categoría, "Hello", para que se visualice en el grupo que le corresponde.  Declaramos un id exclusivo para nuestra vista y especificamos el nombre de la clase (parámetro class) que proporciona la implementación de la vista. También especificamos el nombre (atributo name) de la vista, "Hello Greetings", que figurará en el diálogo Mostrar vista y en la barra de título de nuestra vista.

Identificadores de los conectores

En un archivo de manifiesto de un conector hay muchos identificadores. Los puntos de extensión individuales suelen definir parámetros de configuración que requieren identificadores (como el ID de categoría utilizado anteriormente para el punto de extensión de las vistas). También definimos un ID para el conector. En general, deberá utilizar prefijos de nombre de paquete Java para todos los ID para garantizar que son exclusivos entre todos los conectores instalados. 

Usted es quien decide el nombre concreto que utilizará a continuación del prefijo. Sin embargo, si el prefijo del ID del conector coincide exactamente con el nombre de uno de los paquetes, no debe utilizar los nombres de clase que se deriven de ese paquete.   De lo contrario, resultará difícil saber si está haciendo referencia al nombre de un ID o al nombre de una clase. 

Tampoco debe utilizar un mismo ID para distintos parámetros de configuración de extensión. En el manifiesto anterior, hemos utilizado un prefijo de ID común (org.eclipse.examples.helloworld), pero todos nuestros ID son exclusivos.  Este enfoque de denominación nos ayuda a leer el archivo y ver qué identificadores están relacionados. 

¿Cuál es el siguiente paso?

En este momento ya hemos implementado una vista y declarado nuestra contribución en el manifiesto de nuestro conector.  Ahora tendremos que instalar el conector en la plataforma para poder ejecutarlo.

Copyright IBM Corporation y otros 2000, 2003.