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 agrupan en dos categorías principales: las vistas y los editores. Dejaremos los editores para más adelante. Las vistas proporcionan información sobre algún objeto con el que esté trabajando el usuario 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 si desea 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:

  1. Tendrá que crear un proyecto. La manera más sencilla de hacerlo consiste en abrir el asistente Proyecto nuevo... y elegir Proyecto de conector en 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 explicaremos ahora mismo). Utilice org.eclipse.examples.helloworld para el nombre del proyecto y el id del conector. 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 de generadores de código.
  2. Cree un paquete org.eclipse.examples.helloworld bajo el directorio src del proyecto.
  3. Cree una clase nueva llamada HelloWorldView en este paquete.

Escribir el código

Ya estamos preparados para escribir 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". 

¡Y esto es todo! Podemos compilar nuestra clase, 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.
  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, pues ya hemos compilado la vista. Su aspecto debe ser parecido al de esta figura:

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á prefijar los ID con los nombres de los paquetes Java 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 que podamos ejecutarlo.

Copyright IBM Corp. y otros 2000, 2002.