Um Plug-in Mínimo

Sabemos que "Hello World" parece muito com o conhecido Java sem utilizar qualquer interface do usuário ou outra estrutura.

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

O que acontece com esse padrão conhecido no contexto da plataforma do Eclipse? Em vez de imaginar o Hello World como um programa em si, o remodelamos como um extensão de plataforma. Se desejarmos dizer olá para o mundo, precisaremos idealizar como estender o workbench para incluir nossa saudação.

Quando nos aprofundamos nos componentes de interface do usuário na plataforma, fazemos uma revisão meticulosa das maneiras de estender e personalizar a UI do workbench. Por ora, iniciaremos com uma das extensões mais simples do workbench - uma exibição. 

É possível pensar na janela do workbench como um quadro que apresenta várias partes visuais. Estas partes pertencem às duas categorias principais: exibições e editores.  Veremos os editores mais tarde.  As Exibições fornecem informações sobre alguns objetos com os quais o usuário está trabalhando no workbench. As exibições alteram seu conteúdo com freqüência à medida que o usuário seleciona objetos diferentes no workbench.

Exibição Hello World

Para nosso plug-in hello world, implementaremos nossa própria exibição para saudar o usuário com "Hello World."

O pacote org.eclipse.ui e seus sub-pacotes contêm as interfaces públicas que definem a interface do usuário (UI) API do workbench. Muitas dessas interfaces possuem as classes de implementação padrão que podem ser estendidas para fornecer modificações simples ao sistema. No nosso exemplo "hello world", aumentaremos uma exibição de workbench para fornecer uma etiqueta que diga "hello".

A interface de interesse é IViewPart, que define os métodos que devem ser implementados para contribuir com uma exibição para o workbench. A classe ViewPart fornece uma implementação padrão dessa interface. Em poucas palavras, uma parte de exibição é responsável pela criação de widgets necessários para mostrar a exibição.

As exibições padrão no workbench exibem, com freqüência, algumas informações sobre um objeto que o usuário selecionou ou está navegando. As exibições atualizam seus conteúdos com base em ações que ocorrem no workbench. No nosso caso, estamos somente dizendo "hello", então, nossa exibição é muito simples.

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() {
        // definir o foco para meu widget.  Para uma etiqueta, não
        // tem muito sentido, mas para conjuntos mais complexos de widgets
        // você decidiria qual seria focalizado.
    }

}

A parte da exibição cria os widgets que a representarão no método createPartControl. Nesse exemplo, criamos uma etiqueta SWT e nele definimos o texto"Hello World". 

Terminamos a parte de códigos!  É possível compilar nossa classe nova (não se esqueça de verificar se os arquivos JAR da plataforma estão visíveis no seu IDE ou ambiente do compilador para que você possa compilar o plug-in), mas ainda temos que idealizar a execução de nossa nova exibição. 

Nossa nova exibição deveria parecer com esta:

Como incluímos esta exibição na plataforma?

O plug-in hello world

Precisamos informar à plataforma que desejamos contribuir com uma exibição. Isso é feito estendendo o ponto de extensão org.eclipse.ui.views. Registramos nossa extensão fornecendo um arquivo de manifest, plugin.xml, que descreve nosso plug-in, incluindo onde seu código está localizado e a extensão que estamos incluindo.

<?xml version="1.0" ?>
<plugin
    name="Hello World Example" 
    id="org.eclipse.examples.helloworld"
    version="1.0"
    provider-name="Object Technology International, Inc.">
    <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>

Nesse arquivo, definimos o nome, id, versão e nome-do-provedor do nosso plug-in.

Também listamos os nossos plug-ins necessários. Já que usamos o workbench e o SWT API no nosso plug-in, devemos listar org.eclipse.ui. Devemos também descrever onde está localizado o nosso código executável. No nosso caso, faremos o pacote do código em helloworld.jar.

Finalmente, declaramos a que ponto de extensão o nosso plug-in está contribuindo. A extensão org.eclipse.ui.views possui vários parâmetros de configuração diferentes. Revisemos os parâmetros que especificamos no nosso manifest.

Primeiro, declaramos uma categoria para nossa extensão de exibição. As categorias podem ser utilizadas para agrupar exibições relacionadas no diálogo Mostrar Exibições do workbench. Definimos nossa própria categoria, "Hello," para que seja exibida no seu próprio grupo.

Declaramos um único id para nossa exibição e especificamos o nome da classe que fornece a implementação da exibição. Também especificamos um nome para a exibição, "Saudações" que será exibido no diálogo Mostrar Exibição e em nossa barra de título da exibição.

Ids de plug-in

Há muitos ids utilizados no arquivo de manifest de plug-in. Os pontos de extensão individuais definem, com freqüência, parâmetros de configuração que exigem ids (como o id de categoria utilizado acima dos pontos de extensão de exibições). Também definimos um id de plug-in. Em geral, devem ser utilizados os prefixos de nome do pacote Java para todos os seus ids a fim de garantir exclusividade entre todos os plug-ins instalados. 

O nome específico que você utiliza depois do prefixo é exclusivamente de sua escolha. Entretanto, se o prefixo do id do plug-in tiver exatamente o mesmo nome que um dos seus pacotes, você deve evitar utilizar os nomes de classe daquele pacote.   Caso contrário, você terá dificuldade para saber se está vendo um nome de id ou um nome de classe. 

Você deve também evitar utilizar o mesmo id para diferentes parâmetros de configuração de extensão. No manifest acima, utilizamos um prefixo de id comum (org.eclipse.examples.helloworld), mas todos os nossos ids são únicos.  Essa abordagem de nomes nos ajuda a ler o arquivo e ver quais ids estão relacionados.