Un plug-in elementare

L'aspetto di "Hello World" nel vecchio codice Java senza l'utilizzo di alcuna interfaccia utente o altra struttura è noto.

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

Cosa succede a questo vecchio standard nel contesto della piattaforma Eclipse? Anziché pensare a Hello World come un programma indipendente, si provi a rivederlo come estensione della piattaforma. Poiché si desidera utilizzarlo, è necessario decidere come estendere il workbench perché lo includa.

Quando si affronteranno in dettaglio i componenti dell'interfaccia utente della piattaforma, si effettuerà un riepilogo completo di come sia possibile estendere e personalizzare l'interfaccia utente del workbench. Per ora, si inizierà con una delle estensioni del workbench più semplici: una vista. 

È possibile considerare la finestra del workbench come un frame che presenta diverse parti visive. Tali parti rientrano in due categorie principali: viste e editor.  Gli editor verranno trattati in seguito. Le   viste forniscono informazioni sull'oggetto che l'utente sta utilizzando nel workbench. Le viste cambiano spesso il loro contenuto man mano che l'utente seleziona differenti oggetti nel workbench.

Vista di Hello world

Per il plug-in Hello world, verrà implementata la vista dell'utente per mostrare "Hello World."

Il pacchetto org.eclipse.ui e i rispettivi sottopacchetti contengono le interfacce pubbliche che definiscono l'API dell'interfaccia utente del workbench. Molte di queste interfacce dispongono di classi di implementazione predefinite che possono essere estese per fornire semplici modifiche al sistema. Nell'esempio Hello world, verrà estesa una vista del workbench per fornire un'etichetta che riporti "hello".

L'interfaccia di interesse è IViewPart, che definisce i metodi che devono essere implementati per fornire una vista al workbench. La classe ViewPart fornisce un'implementazione predefinita di questa interfaccia. ViewPart è responsabile della creazione dei widget necessari per aprire la vista.

Le viste standard presenti nel workbench spesso mostrano alcune informazioni relative a un oggetto che è stato selezionato o che viene esplorato dall'utente. Le viste aggiornano il proprio contenuto in base alle azioni che si verificano nel workbench. Nel nostro caso, si tratterà solo di inserire la scritta "hello", quindi la vista è abbastanza semplice.

Utilizzo degli strumenti per scrivere il plug-in

Per creare plug-in Eclipse, è possibile utilizzare qualsiasi IDE Java si desideri; in questo caso, tuttavia, si procederà attraverso le varie fasi per la creazione del nuovo plug-in utilizzando l'IDE Java Eclipse.  Se non si ha ancora dimestichezza con il workbench Eclipse e l'IDE Java, consultare la Guida per l'utente per lo sviluppo Java per ulteriori informazioni sulle varie operazioni che si stanno effettuando.  Inizialmente ci si occuperà del codice, non dello strumento.  Tuttavia, vi sono alcune istruzioni di base che occorre conoscere ed applicare per poter cominciare.

Impostazione dell'ambiente

Se si inizia con un ambiente pulito, è necessario assicurarsi che il codice abbia accesso ai plug-in org.eclipse.ui. Importare questo plug-in e i plug-in necessari nel workbench di run-time eseguendo la procedura sotto riportata. Se nell'istanza del workbench questi plug-in sono già presenti, procedere con la sezione "Creazione del progetto di plug-in".

  1. Dalla prospettiva delle risorse, utilizzare File > Importa... > Frammenti e plug-in esterni.
  2. Continuare a fare clic sui pulsanti Avanti > fino a visualizzare la schermata denominata Selezione. Tale schermata contiene un elenco di tutti i plug-in presenti nell'istanza del workbench host.
  3. Selezionare org.eclipse.ui e fare clic sul pulsante Aggiungi plug-in obbligatori.
  4. Fare clic sul pulsante Fine. La vista Selezione dovrebbe contenere org.eclipse.ui e tutti i plug-in necessari (compreso org.eclipse.swt).

Per una trattazione completa dell'impostazione delle istanze del workbench host e di run-time, consultare la Guida PDE.

Creazione del progetto di plug-in

  1. Per eseguire il lavoro, è necessario creare un progetto.  Il metodo più semplice consiste nell'aprire la procedura guidata Nuovo progetto... (File > Nuovo > Progetto...) e scegliere Progetto di plug-in dalla categoria Sviluppo plug-in. In tal modo si imposterà il progetto per la scrittura del codice e si otterrà un file manifest di plug-in predefinito.   Utilizzare org.eclipse.examples.helloworld come nome da assegnare al progetto. Per impostazione predefinita, la procedura guidata imposta org.eclipse.examples.helloworld anche come id.  La procedura guidata offre la possibilità di generare codice per diversi tipi di plug-in, ma è preferibile non complicare troppo la procedura.  Per ora, limitarsi a scegliere Crea progetto di un plug-in vuoto nella pagina Generatori del codice di plug-in.
  2. Quando viene richiesto se si desidera passare alla prospettiva Sviluppo plug-in, rispondere .
  3. Creare un pacchetto org.eclipse.examples.helloworld al di sotto della directory src per il progetto. Per eseguire questa operazione, fare doppio clic sul progetto org.eclipse.examples.helloworld nella vista Esplora pacchetti. In questo modo il progetto viene espanso e viene visualizzata la directory src. Fare clic con il pulsante destro del mouse sulla directory src per visualizzare il menu di scelta rapida. Utilizzare Nuovo > Pacchetto per creare un nuovo pacchetto ed assegnargli il nome org.eclipse.examples.helloworld.
  4. Creare una nuova classe denominata HelloWorldView all'interno di questo pacchetto. Fare clic con il pulsante destro del mouse sul pacchetto appena creato nel passo precedente per visualizzare il menu di scelta rapida. Utilizzare Nuova > Classe per creare la nuova classe con il nome HelloWorldView.

Scrittura del codice

A questo punto è possibile analizzare parte del codice.  Sono disponibili tutti gli elementi necessari nella HelloWorldView.  (È possibile copiare il contenuto che segue nella classe creata). 

   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() {
         // impostare come attivo il widget. Per un'etichetta, ciò non
         // è significativo, ma per insiemi più complessi di widget
         // è necessario decidere a quale widget assegnare lo stato attivo.
      }
   }

La parte vista crea i widget che la rappresenteranno nel metodo createPartControl. In questo esempio, viene creata un'etichetta SWT in cui viene impostato il testo "Hello World". 

È possibile  ora compilare la nuova classe, assicurandosi però che .classpath sia impostato correttamente in modo da poter eseguire la compilazione del codice.  

  1. Selezionare il progetto org.eclipse.examples.helloWorld e aprire la finestra di dialogo Proprietà (fare clic con il pulsante destro del mouse sul progetto org.eclipse.examples.helloWorld > Proprietà).
  2. Nelle proprietà Percorso di generazione Java, scegliere la scheda Progetti, quindi selezionare i progetti  org.eclipse.ui e org.eclipse.swt. Si tratta dei progetti che contengono le classi importate.
  3. Utilizzare l'opzione Ricrea per ricreare il progetto. 

A questo punto la vista è stata compilata.  La nuova vista dovrebbe avere aspetto simile a quello riportato di seguito:

Vista semplice con la voce Hello World

Come eseguire il codice e aggiungere questa vista al workbench?

Il plug-in hello world

È necessario informare la piattaforma che si intende fornire la vista. Per eseguire tale operazione occorre estendere il punto di estensione org.eclipse.ui.views. L'estensione viene registrata fornendo un file manifest, plugin.xml, che descrive il plug-in, incluso il punto in cui è ubicato il codice, e l'estensione che si sta aggiungendo.

(Se si sta ancora eseguendo la procedura, è possibile copiare queste informazioni nel plugin.xml generato alla creazione del progetto).

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

In questo file vengono definiti il nome, l'id e la versione relativi al plug-in.

Vengono anche elencati i plug-in necessari. Dato che si utilizza il workbench e l'API SWT nel plug-in, è necessario elencare org.eclipse.ui. È anche necessario descrivere il punto in cui è posizionato il codice eseguibile. Poiché verrà inserito in helloworld.jar, il codice viene registrato come nome della libreria.

Infine, si dichiara il punto di estensione fornito dal plug-in. L'estensione org.eclipse.ui.views ha vari parametri di configurazione differenti. Per prima cosa si dichiara una categoria per l'estensione della vista. Le categorie possono essere utilizzate per raggruppare insieme viste correlate nella finestra di dialogo Mostra vista del workbench. Verrà definita una categoria personalizzata, "Hello", in modo che verrà visualizzata in un proprio gruppo.  Viene dichiarato un id univoco per la vista e viene specificato il nome della classe che fornisce l'implementazione della vista. Inoltre, si specifica un nome per la vista, "Hello Greetings", che verrà mostrata nella finestra di dialogo Mostra vista e nella barra del titolo della vista.

ID dei plug-in

Esistono molti id utilizzati in un file manifest di plug-in. I punti di estensione singoli spesso definiscono parametri di configurazione che richiedono id (come l'id di categoria utilizzato in precedenza per il punto di estensione delle viste). L'utente definisce anche un id del plug-in. In generale, si dovrebbero utilizzare prefissi di nomi di pacchetto Java per tutti gli id per poter assicurare l'unicità tra tutti i plug-in installati. 

Il nome specifico utilizzato dopo il prefisso è di esclusiva scelta dell'utente. Tuttavia, se il prefisso dell'id del plug-in corrisponde esattamente al nome di uno dei pacchetti dell'utente, è bene evitare di utilizzare i nomi di classe di questo pacchetto.   In caso contrario, sarà difficile capire se si sta esaminando il nome di un id oppure il nome di una classe. 

È anche preferibile evitare l'utilizzo dello stesso id per parametri di configurazione di estensioni diverse. Nel manifest precedente, è stato utilizzato un prefisso di id comune (org.eclipse.examples.helloworld) ma tutti gli id sono univoci.   Questo approccio di denominazione agevola l'utente nella lettura del file e nell'individuazione degli id correlati. 

Passaggi successivi

A questo punto, è stata implementata una nuova vista e dichiarata l'aggiunta nel manifest di plug-in.  Occorre ora installare il plug-in nella piattaforma per poterla eseguire.

Copyright IBM Corporation e altri 2000, 2003.