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. Essas partes são divididas em duas categorias principais: exibições e editores. Veremos os editores posteriormente. As Exibições fornecem informações sobre algum objeto com o qual 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.
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 subpacotes contêm as interfaces públicas que definem a API da UI (interface do usuário) 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.
É possível utilizar qualquer IDE Java para construir os plug-ins do Eclipse, mas faremos uma escala pelas etapas para construir nosso plug-in com o IDE Java do Eclipse. Se ainda não estiver familiarizado com o workbench do Eclipse e com o IDE Java, consulte o Guia do Usuário de Desenvolvimento Java para obter mais explicações sobre as etapas que estamos executando. Por enquanto, vamos nos concentrar no código, não na ferramenta. No entanto, existem algumas logísticas do IDE para iniciar.
Se estiver iniciando com um ambiente "limpo", será necessário garantir que seu código possua acesso aos plug-ins org.eclipse.ui. Importe esse plug-in e quaisquer plug-ins que ele necessite em sua instância de tempo de execução do workbench executando as etapas a seguir. Se você já possuir esses plug-ins em sua instância do workbench, prossiga com a seção "Criando seu projeto de plug-in".
Para obter uma abordagem completa da configuração do host e das instâncias do workbench de tempo de execução, consulte o Guia do PDE.
Agora estamos prontos para estudar o código. A seguir, tudo o que é necessário no HelloWorldView. (Você pode copiar o conteúdo a seguir na classe criada).
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() { // focalizar meu widget. Para um rótulo, não // faz muito sentido, mas para conjuntos de widgets mais complexos // você decidirá qual será focalizado. } }
A parte da exibição cria os widgets que a representarão no método createPartControl. Nesse exemplo, criamos um rótulo SWT e nele definimos o texto "Hello World".
É tudo o que precisamos! Podemos compilar nossa nova classe, mas é melhor nos certificarmos de que nosso .classpath esteja configurado adequadamente para que possamos compilar o código.
Tudo certo, compilamos a exibição. Nossa nova exibição deve parecer mais ou menos assim:
Como executamos o código e incluímos esta exibição no workbench?
Precisamos informar à plataforma que desejamos contribuir com nossa exibição. Isso é feito estendendo-se o ponto de extensão org.eclipse.ui.views. Registramos nossa extensão fornecendo um arquivo de manifesto, plugin.xml, que descreve nosso plug-in, incluindo onde seu código está localizado e a extensão que estamos incluindo.
(Se ainda estiver nos acompanhando, poderá copiar estas informações para o arquivo plugin.xml gerado durante a criação do projeto.)
<?xml version="1.0" ?> <plugin name="Exemplo de 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>
Nesse arquivo, definimos o nome, o id e a versão de 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. Pretendemos compactar o código em helloworld.jar, portanto, registramos com o nome de nossa biblioteca.
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. 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.
Há muitos IDs utilizados no arquivo de manifesto 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 manifesto acima, utilizamos um prefixo de ID comum (org.eclipse.examples.helloworld) mas todos os nossos IDs são exclusivos. Essa abordagem de nomes nos ajuda a ler o arquivo e ver quais IDs estão relacionados.
Por enquanto, implementamos uma exibição e declaramos nossa contribuição no manifesto de nosso plug-in. Agora, precisamos instalar nosso plug-in na plataforma para que seja possível executá-la.