Conteúdo


Usando Eclipse Ganymede para Desenvolvimento de Dispositivos para Desktop, Web e Remotos, Parte 1

Desenvolvendo para a Plataforma Rich Client, da Maneira Ganymede

Aplicativos Desktop com RCP, Subversion e p2

Comments

Conteúdos da série:

Esse conteúdo é a parte # de # na série: Usando Eclipse Ganymede para Desenvolvimento de Dispositivos para Desktop, Web e Remotos, Parte 1

Fique ligado em conteúdos adicionais dessa série.

Esse conteúdo é parte da série:Usando Eclipse Ganymede para Desenvolvimento de Dispositivos para Desktop, Web e Remotos, Parte 1

Fique ligado em conteúdos adicionais dessa série.

Antes de Iniciar

Este tutorial destina-se ao desenvolvedor Eclipse que quer aprender sobre alguns dos novos recursos interessantes disponíveis no Ganymede e para aqueles interessados em utilizar esses recursos para desenvolver aplicativos que possam ser implementados em diversas plataformas com base de código comum. Você deve ter um entendimento de como programar na linguagem de programação Java e ter uma certa familiaridade com a plataforma Eclipse e seu modelo de uso de plug-ins.

Sobre esta Série

A Parte 1 ("Desenvolvimento para Rich Client Platform, o Jeito Ganymede") fornece uma introdução aos novos recursos do RCP, à nova integração do Subversion Eclipse e ao sistema de distribuição e pacote p2. A Parte 2 ("Leve-o para a Web") introduz o Rich Ajax Platform (RAP) para gravar aplicativos para a Web. E Parte 3 ("Tornando-se Remoto") discute como utilizar o embedded Rich Client Platform (eRCP) para desenvolver um aplicativo para um dispositivo remoto.

Sobre este Tutorial

O RCP é uma arquitetura Eclipse que permite que um desenvolvedor selecione e escolha os plug-ins do Eclipse necessários — e apenas os necessários — para construir um aplicativo desktop cliente. Para demonstrar alguns dos novos recursos do Ganymede, você vai desenvolver um aplicativo RCP simples (um organizador pessoal). Fazendo isso, você verá algumas das mudanças no RCP no Ganymede e você vai utilizar esse aplicativo para explorar o novo controle de origem do Subversion e os sistemas de compactação e distribuição p2.

Os tópicos incluem:

  • Como fazer o download e instalar pacotes Ganymede.
  • Como configurar o cliente Subversion e armazenar sua origem no Subversion.
  • Como configurar a plataforma de destino e alternar de um sistema operacional para outro (isto é, Mac OS X para Microsoft® Windows® Vista).
  • Como criar um modelo de aplicativo e plug-ins do usuário.
  • Como criar uma definição de produto e compactar e distribuir seu aplicativo utilizando p2.

Requisitos do Sistema

Você precisa das seguintes tecnologias para prosseguir:

Introdução ao Ganymede

Antes de começar a desenvolver seu aplicativo organizador pessoal, você precisa fazer o download e instalar o pacote Ganymede do Eclipse. Nesta seção, você verá de onde fazer seu download e como configurá-lo para seguir adiante.

Fazendo Download do Ganymede

O pacote Ganymede representa o próximo release incremental para o Eclipse, e como tal, significa uma nova instalação da plataforma Eclipse. Assim como com todos os releases do Eclipse, existem inúmeros pacotes dentre os quais escolher, dependendo de suas necessidades de desenvolvimento. O Web site do Eclipse fornece um gráfico de comparação, que pode ser visto na Figura 1.

Figura 1. Comparação de Pacotes do Eclipse
Comparação de Pacotes do Eclipse
Comparação de Pacotes do Eclipse

Para o propósito desta série, você pode fazer o download da versão do RCP/plug-in, já que ela tem tudo que você precisa para desenvolver e implementar um aplicativo RCP (consulte Figura 2). Escolha a versão para o seu sistema operacional, selecione um espelho apropriado e faça o download. (O arquivo é bastante grande — cerca de 200 MB, dependendo de sua plataforma — portanto, seja paciente.)

Figura 2. Página de Download para o Pacote do RCP/plug-in do Eclipse Ganymede
Página de Download para o Pacote do RCP/plug-in do Eclipse Ganymede
Página de Download para o Pacote do RCP/plug-in do Eclipse Ganymede

Instalando e Executando

Quando o download for concluído, descompacte arquivo ZIP do pacote onde quer que o Eclipse seja instalado e dê um clique duplo no ícone do Eclipse para executá-lo. Selecione uma área de trabalho e o Eclipse o levará para a página de boas-vindas. Aqui, escolha o ícone Ambiente de Trabalho (a seta à direita da tela de boas-vindas, mostrada na Figura 3).

Figura 3. Tela de Boas-vindas para Configuração do Eclipse
Tela de Boas-vindas para Configuração do Eclipse
Tela de Boas-vindas para Configuração do Eclipse

Até aqui, nada disso é muito diferente dos releases anteriores do Eclipse, embora na próxima seção você verá alguns aprimoramentos incrementais em um dos principais componentes de desenvolvimento do Eclipse: o Rich Client Platform.

Agora você instalou o release do Ganymede. Mas você pode se surpreender ao saber que não instalou cada pacote que faz parte do Ganymede. Em seguida, quando explorar o Subversion, você terá que fazer o download e instalar separadamente o pacote relevante. Embora o Subversion seja considerado parte do release do Ganymede, as restrições de licenciamento o impedem de ser distribuído automaticamente com o restante do pacote, exigindo que você faça um download separado de dentro do Eclipse.

Controle do Subversion Utilizando o Plug-in Subversive

O controle de origem é uma parte essencial de qualquer esforço de desenvolvimento de software sério, principalmente daqueles que suportam desenvolvimento distribuído para uma equipe distribuída geograficamente (os co-autores deste tutorial, por exemplo, estão em lados opostos de um continente). Tal sistema permite mudanças não coordenadas em uma base de código, sem que ninguém tenha medo de que uma mudança feita por um programador afete adversamente o outro — e sem uma autoridade central controlando o processo inteiro ou sem a necessidade de uma coordenação contígua ou meticulosa entre os programadores.

O Subversion é um sistema de controle de versão de software livre, semelhante ao CVS, mas bastante considerado seu eventual sucessor. O suporte do Subversion para o Eclipse esteve disponível por muitos anos através de plug-ins de terceiros, sendo que o mais popular deles era chamado Subversive. O projeto do Ganymede pegou o desenvolvimento do Subversive e o incluiu como uma biblioteca principal do Eclipse. Entretanto, problemas jurídicos pendentes o impedem de ser distribuído com o restante do Ganymede, assim, pelo menos por quanto, você ainda deve instalar separadamente o plug-in Subversive de dentro do Ganymede.

Siga adiante para ver como configuramos o Subversive e o utilizamos para gerenciar o código de origem para o aplicativo do organizador pessoal.

Instale o Subversive

O Subversive consiste em duas partes, sendo que cada uma deve ser instalada separadamente. A primeira é o plug-in Subversive em si, que fornece os elementos de UI para integrar o suporte do Subversion ao Eclipse. A segunda parte são as bibliotecas do conector, e elas são desenvolvidas e licenciadas separadamente. Para instalar o plug-in Subversive de dentro do Eclipse, navegue para Ajuda > Atualizações de Software.

Figura 4. Atualizações de Software no Menu Ajuda
Atualizações de Software no Menu Ajuda
Atualizações de Software no Menu Ajuda

Escolha a tela Software Disponível e clique em Incluir Site. Para Local, insira http://download.eclipse.org/technology/subversive/0.7/update-site/ e clique em OK.

Figura 5. Incluir Site para Subversive
Incluir Site para Subversive
Incluir Site para Subversive

Isso incluirá uma lista de plug-ins relacionados, mas antes de instalá-los, clique em Incluir Site novamente e inclua o local para os conectores do Subversive. Insira http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/ para o local e clique em OK.

Figura 6. Incluir Site para Conectores do Subversive
Incluir Site para Conectores do Subversive
Incluir Site para Conectores do Subversive

Você verá que ambos os sites de atualização incluíram inúmeros possíveis plug-ins diferentes. Você pode selecionar todos eles, mas o mínimo necessário por enquanto são aqueles rotulados como SVN Team Provider e Subversive SVN Connectors. Selecione-os na lista e clique em Instalar.

Figura 7. Plug-ins Subversive
Plug-ins Subversive
Plug-ins Subversive

O Eclipse levará você até um conjunto de telas padrão para instalar o plug-ins, incluindo uma tela solicitando que você revise e aceite os termos de licença. Trabalhe nessas telas e, quando for solicitado, reinicie o ambiente de trabalho do Eclipse. Os plug-ins Subversive agora estão instalados.

Configure um Repositório

O Subversion, como CVS, é um repositório de código de origem baseado em servidor, o que o transforma em uma excelente opção para o desenvolvimento de software colaborativo entre equipes distribuídas. A parte do servidor não é uma parte do Eclipse, e a instalação e a configuração de um servidor Subversion estão além do escopo deste tutorial. Entretanto, existem inúmeras maneiras de se executar um, incluindo o uso do Apache (consulte Recursos para obter mais informações).

Quando você tiver um servidor Subversion que possa ser utilizado, você poderá configurar seu projeto para armazenar sua origem e suas configurações através do plug-in Subversive. Realce o nome do projeto no Package Explorer e exiba seu menu de contexto. Lá, escolha Equipe > Compartilhar Projetos. O Eclipse exibirá uma tela oferecendo opções de sistemas de versão: CVS, que esteve disponível como recurso principal do Eclipse por algum tempo; e SVN, que é a notação estenográfica para o Subversion, que foi ativada quando você incluiu o Subclipse.

Figura 8. Compartilhando um Projeto via SVN
Compartilhando um Projeto via SVN
Compartilhando um Projeto via SVN

Selecione SVN e escolha Avançar. Você será apresentado a uma tela (mostrada na Figura 9) onde irá inserir a URL do servidor e as credenciais para seu servidor Subversion. Insira as informações para seu servidor. Aqui, você pode aceitar os padrões para nomear o repositório que estão configurados nas próximas telas e clicar em Concluir.

Figura 9. Assistente Compartilhar Projeto
Assistente Compartilhar Projeto
Assistente Compartilhar Projeto

O Eclipse vai apresentar uma tela de confirmação para seu projeto (consulte Figura 10). Todos os arquivos que fazem parte do nosso projeto serão selecionados por padrão, mas você pode optar por impedir que alguns deles sejam registrados neste momento se quiser. Também será solicitado que você faça um comentário inicial de registro de entrada. É uma boa prática inserir comentários em cada registro de entrada. Insira seu comentário e clique em OK. Para o código do aplicativo organizador, todos os arquivos foram registrados.

Figura 10. Caixa Registro de Entrada do Subversion
Caixa Registro de Entrada do Subversion
Caixa Registro de Entrada do Subversion

Agora o Eclipse incluiu todos os arquivos para nosso organizador no seu repositório do Subversion. Se você estiver utilizando uma versão WebDAV do Subversion, como através do Apache como nós fizemos, você pode explorar a estrutura do repositório utilizando seu navegador da Web. Simplesmente insira as mesmas URL e credenciais utilizadas para configurar o repositório no Subversive e navegue pela árvore do diretório por meio dos hyperlinks em cada arquivo ou diretório.

Figura 11. Uma Visualização do Repositório do Subversion através da Web
Uma Visualização do Repositório do Subversion através da Web
Uma Visualização do Repositório do Subversion através da Web

Você pode ver que nosso projeto agora está ligado ao Subversion no Package Explorer. Cada arquivo sob o controle do Subversion possui um número de revisão próximo dele, e o projeto em si tem o nome do repositório próximo do seu nome.

Figura 12. O Package Explorer após Ser Compartilhado através do Subversion
O Package Explorer após Ser Compartilhado através do Subversion
O Package Explorer após Ser Compartilhado através do Subversion

Trabalhando com o Código no Repositório

Como CVS, agora podemos acessar as funções de controle de origem do Subversion no menu de contexto Equipe. Para selecionar um arquivo no Package Explorer que queremos atualizar no repositório, chame o menu de contexto e selecione Equipe. Agora isso mostra todos os recursos do Subversion neste menu de contexto.

A seguir está uma lista dos comandos mais comuns que utilizaremos (consulte Figura 13):

Commit
Para salvar suas mudanças no repositório
Update
Para atualizar sua cópia local com o que há de mais recente no repositório
Revert
Para descartar suas mudanças e substituí-las pelo que há de mais recente no repositório
Add to Version Control
Para marcar arquivos locais recém-criados no repositório (depois você deve emitir um Commit para o arquivo para incluí-lo no servidor).
Figura 13. O Menu de Contexto do Subversion
O Menu de Contexto do Subversion
O Menu de Contexto do Subversion

Para excluir um arquivo do repositório, exclua-o do Package Explorer como faria normalmente (o item Excluir no menu de contexto desse arquivo). Em seguida, emita um commit para o diretório-pai desse arquivo. Antes de executar qualquer commit no servidor, você terá uma chance de rever todas as mudanças; para uma exclusão, você verá o nome e o local do arquivo excluído.

O Subversion também se assemelha ao CVS porque utiliza bloqueio otimista — ou seja, em vez de efetuar o registro de saída de um arquivo para edição e bloqueá-lo para outros, o código pode ser editado localmente e ser registrado quando for concluído. No momento do registro de entrada, quaisquer conflitos são resolvidos.

Criando um Aplicativo RCP no Ganymede

Nesta seção, você vai criar o aplicativo organizador — um aplicativo RCP simples de uma única visualização — utilizando assistentes do Eclipse para criar a estrutura do RCP, incluindo o código para a lógica e executando-o.

Criando uma Estrutura de Aplicativo RCP

Comece criando um novo projeto selecionando Arquivo > Novo > Projeto. O Eclipse exibirá o Assistente Novo Projeto, conforme mostrado abaixo.

Figura 14. O Assistente Novo Projeto
O Assistente Novo Projeto
O Assistente Novo Projeto

Escolha Projeto de Plug-in e selecione Avançar. A próxima tela permitirá que você insira detalhes do projeto. Como você vai estar criando um aplicativo organizador pessoal, nomeie o projeto com.devworks.tutorial.po (como "organizador pessoal"). Utilize o local padrão para o projeto (o Eclipse criará uma pasta sob sua área de trabalho nomeada após o projeto). Certifique-se de que a caixa de opção Criar um Projeto Java em Configurações de Projeto esteja selecionada e mantenha os padrões de src e bin para os nomes de pastas. Para a plataforma de destino, selecione o botão de opções para Versão do Eclipse e escolha 3.4 no menu suspenso. Deixe a caixa de opção para Incluir Projeto em Conjuntos de Trabalho vazia e selecione Avançar.

O assistente Novo Projeto de Plug-in mostrado na Figura 15 continuará na tela Conteúdo do Plug-in, onde você vai inserir informações sobre o plug-in que será incluído no arquivo de manifesto que descreve o plug-in e permite que você configure opções para seu plug-in.

Figura 15. Tela do Assistente Novo Projeto de Plug-in
Tela do Assistente Novo Projeto de Plug-in
Tela do Assistente Novo Projeto de Plug-in

Para o ID do plug-in, escolha o nome do projeto que você utilizou anteriormente (com.devworks.tutorial.po). Como este é o primeiro release do seu plug-in, deixe o valor da versão do plug-in com o padrão de 1.0.0. Da mesma maneira, você pode manter os valores padrão de Po Plug-in para o nome do plug-in e DEVWORKS para o provedor do plug-in.

O menu suspenso Ambiente de Execução permite destinar um ambiente de tempo de execução específico para o plug-in a partir de uma seleção de ambientes conhecidos do Eclipse. Para este tutorial, selecione JavaSE-1.6.

A próxima seção configura as opções do plug-in. Certifique-se de que a caixa esteja marcada para Gerar um ativador, uma classe Java que controle o ciclo de vida do plug-in e altere o nome da classe do Ativador padrão, com.devworks.tutorial.po.Activator, para com.devworks.tutorial.po.Activator.

Como esse plug-in terá um componente visual, certifique-se de selecionar a caixa de opção para Este plug-in fará contribuições para a interface com o usuário. Deixe a caixa de opção para Ativar Análise de API em branco. Isso está além do escopo deste tutorial (consulte Recursos para obter mais informações). Finalmente, já que este será um aplicativo RCP, selecione o botão de opções Sim para a pergunta Gostaria de criar um aplicativo rich client?, e selecione Avançar para continuar com o assistente.

Figura 16. Tela de Conteúdo do Plug-in no Assistente Novo Projeto de Plug-in
Tela de Conteúdo do Plug-in no Assistente Novo Projeto de Plug-in
Tela de Conteúdo do Plug-in no Assistente Novo Projeto de Plug-in

A Figura 17 pergunta qual tipo de modelo de RCP você gostaria de utilizar. Como nosso projeto terá um componente visual, selecione Aplicativo RCP com uma Visualização e selecione Avançar.

Figura 17. Tela Modelos do Assistente Novo Projeto de Plug-in
Tela Modelos do Assistente Novo Projeto de Plug-in
Tela Modelos do Assistente Novo Projeto de Plug-in

Na tela final do assistente mostrado na Figura 18, O Aplicativo RCP de Visualização Única, você terá a oportunidade de inserir informações relevantes para o modelo que acabou de escolher. Dê ao título da janela do aplicativo o nome de Organizador Pessoal. Mantenha o nome do pacote Java™ como o padrão de com.devworks.tutorial.po e nomeie a classe do aplicativo TaskOrganizerApplication. Por fim, selecione a tag Incluir Marca, que exibirá uma tela inicial quando seu aplicativo for iniciado. Clique em Concluir.

Figura 18. Tela Propriedades do RCP de Visualização Única no Assistente Novo Projeto
Tela Propriedades do RCP de Visualização Única no Assistente Novo Projeto
Tela Propriedades do RCP de Visualização Única no Assistente Novo Projeto

O Eclipse perguntará se você quer alternar a visualização de seu ambiente de trabalho para a perspectiva Desenvolvimento de Plug-in. Essa perspectiva conterá uma visualização de tudo que precisamos ver para esse esforço, portanto, diga Sim. O assistente é concluído gerando arquivos de modelos relacionados ao aplicativo RCP de visualização única no diretório do projeto em sua área de trabalho, bem como uma estrutura de diretório padrão útil para o desenvolvimento de um plug-in. Ele então apresenta uma tela do ambiente de trabalho na perspectiva Desenvolvimento de Plug-in.

Figura 19. Perspectiva de Plug-in do Ambiente de Trabalho após a Conclusão do Assistente Novo Projeto
Perspectiva de Plug-in do Ambiente de Trabalho após a Conclusão do Assistente Novo Projeto
Perspectiva de Plug-in do Ambiente de Trabalho após a Conclusão do Assistente Novo Projeto

Os arquivos de modelo criados pelo Eclipse são listados em src no Package Explorer. Resumidamente, aqui estão suas funções:

Ativador
O ponto de ativação do plug-in
TaskOrganizerApplication
O Ativador do Aplicativo que implementa Aplicativo e define o ciclo de vida do aplicativo
ApplicationActionBarAdvisor
A classe responsável por gerenciar o ciclo de vida de ações incluídas em janelas
ApplicationWorkbenchAdvisor
A classe que inicializa a perspectiva
ApplicationWorkbenchWindowAdvisor
A classe responsável por muitos dos aspectos visuais das janelas (tamanho, linha de status, barras de menu, etc.)
Perspectiva
As Visualizações e o Editor que estarão visíveis no aplicativo
Visualização
Um visualizador de Tabela simples com três elementos

Além disso, a pasta de ícones contém recursos de bitmap para ícones associados ao aplicativo; e o splash.bpm é o gráfico utilizado para a tela inicial do aplicativo.

Esses arquivos de modelo são um excelente começo para a criação de um plug-in RCP, e você vai compilá-los para criar o organizador. Mas, de fato, eles formam um aplicativo completo (apesar de não fazer muita coisa) que você pode executar imediatamente.

Para vê-los trabalhando juntos, acesse a janela Package Explorer e realce o nome do projeto na parte superior da visualização em árvore; depois, traga para a tela o menu de contexto (clique com o botão direito do mouse em Windows; clique no controle do Mac OS X, etc). Selecione Executar Como > Aplicativo Eclipse. Em breve, você verá uma tela inicial seguida por uma visualização em árvore com três elementos.

Figura 20. Visualização em Árvore Padrão do Organizador do Modelo
Visualização em Árvore Padrão do Organizador do Modelo
Visualização em Árvore Padrão do Organizador do Modelo

Você tem tudo que precisa neste ponto para construir um organizador simples com uma única visualização de lista.

Codificando o Aplicativo Organizador

Aqui, você está pronto para começar a codificar o aplicativo organizador. O organizador apresentará uma única tela com uma lista de tarefas. Cada tarefa conterá uma descrição, uma prioridade, um proprietário e um lugar para registrar a porcentagem concluída. Haverá botões para incluir ou excluir essas tarefas, bem como um botão para fechar o aplicativo inteiro. Para garantir que tenhamos algo para trabalhar imediatamente, o aplicativo irá pré-preencher o gerenciador de tarefa com dez tarefas de amostra com uma variedade de configurações. Para manter a simplicidade, os dados que você inserir não serão armazenados em nenhum lugar entre as sessões.

Os detalhes deste código não são particularmente interessantes para o que estamos tentando demonstrar neste tutorial, portanto, nós o incentivamos a fazer seu download. Muitos dos arquivos, de fato, não mudam nas versões de modelos, mas existem algumas mudanças que você fará na visualização.

Crie um novo pacote sob o projeto chamado Visualização. Aqui, você vai criar arquivos relacionados aos elementos visuais do aplicativo. Comece movendo a atual classe View criada por modelo sob este novo pacote e renomeando-a para PersonalTaskView.

Como você alterou o nome da classe View, será necessário alterar a definição do plug-in de sua principal classe View. Para isso, abra o arquivo META-INF/MANIFEST.MF no editor e alterne para a guia Extensões, conforme mostrado na Figura 21. Expanda a extensão org.eclipse.ui.views na visualização de lista e realce a classe View. O Eclipse exibirá as propriedades dessa classe no lado direito da tela. Altere a classe para o novo pacote e nomeie: com.devworks.tutorial.po.view.PersonalTaskView. Altere o nome da classe para PersonalTaskView. Certifique-se de salvar suas mudanças.

Figura 21. Alterando a Classe View
Alterando a Classe View
Alterando a Classe View

Como o organizador é realmente uma coleta de tarefas, o objeto modelo será chamado PersonalTaskModel (consulte Listagem 1).

Listagem 1. Classe PersonalTaskModel Representando uma Única Tarefa
package com.devworks.tutorial.po.view;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;

public class PersonalTaskModel {

    private final int COUNT = 10;
    private List<PersonalTask> tasks = new ArrayList<PersonalTask>(COUNT);
    private Set changeListeners = new HashSet();

    static final String[] OWNERS_ARRAY = { "-", "Bill", "Larry", "Jo", "Harry",
"Hulk" };
    static final String[] PRIO_ARRAY = { "-", "Low", "Medium", "High" };

    public PersonalTaskModel() {
        super();
        this.initData();
    }

    private void initData() {
        PersonalTask personalTask;
        for (int i = 0; i < COUNT; i++) {
            personalTask = new PersonalTask("Sample Task "  + (i+1));
            personalTask.setTaskOwner(OWNERS_ARRAY[i % 5]);
            personalTask.setTaskPrio(PRIO_ARRAY[i % 3]);
            tasks.add(personalTask);
        }
    };

    public String[] getOwners() {
        return OWNERS_ARRAY;
    }

    public String[] getPrios() {
        return PRIO_ARRAY;
    }

    public List<PersonalTask> getTasks() {
        return tasks;
    }

    public void addTask() {
        PersonalTask task = new PersonalTask("New Sample Task");
        tasks.add(tasks.size(), task);
        Iterator iterator = changeListeners.iterator();
        while (iterator.hasNext())
            ((IPersonalTaskViewer) iterator.next()).addTask(task);
    }

    public void removeTask(PersonalTask task) {
        tasks.remove(task);
        Iterator iterator = changeListeners.iterator();
        while (iterator.hasNext())
            ((IPersonalTaskViewer) iterator.next()).removeTask(task);
    }

    public void taskChanged(PersonalTask task) {
        Iterator iterator = changeListeners.iterator();
        while (iterator.hasNext())
            ((IPersonalTaskViewer) iterator.next()).updateTask(task);
    }

    public void removeChangeListener(IPersonalTaskViewer viewer) {
        changeListeners.remove(viewer);
    }

    public void addChangeListener(IPersonalTaskViewer viewer) {
        changeListeners.add(viewer);
    }

Você pode ver que a Listagem 1 define a estrutura de uma tarefa, bem como os métodos que operam nela. Ela também, nesse caso, define os dados de amostra com os quais foi preenchida inicialmente.

A classe PersonalTaskViewer define TableViewer, que é o bloco de construção que contém a lista de tarefas. A criação de PersonalTaskViewer envolve criar TableViewer, incluir Conteúdo e Provedor de Rótulo e, finalmente, inicializar PersonalTaskModel e configurar esse modelo como entrada para TableViewer.

Listagem 2. Fragmento do Método addChildControls() de PersonalTaskViewer
tableViewer = new TableViewer(table);
tableViewer.setUseHashlookup(true);
tableViewer.setColumnProperties(columnNames);

// Crie os editores de célula
CellEditor[] editors = new CellEditor[columnNames.length];

// Coluna 1 : Concluída (Caixa de Opção)
editors[0] = new CheckboxCellEditor(table);

// Coluna 2 : Descrição (Texto Livre)
TextCellEditor textEditor = new TextCellEditor(table);
((Text) textEditor.getControl()).setTextLimit(60);
editors[1] = textEditor;

// Coluna 3 : Prioridade (Caixa de Combinação )
editors[2] = new ComboBoxCellEditor(table, taskList.getPrios(), SWT.READ_ONLY);

// Coluna 4 : Proprietário (Caixa de Combinação)
editors[3] = new ComboBoxCellEditor(table, taskList.getOwners(), SWT.READ_ONLY);

// Coluna 5 : Percentagem concluída (Texto apenas com dígitos)
textEditor = new TextCellEditor(table);
((Text) textEditor.getControl()).addVerifyListener(
    new VerifyListener() {
        public void verifyText(VerifyEvent e) {
            e.doit = "0123456789".indexOf(e.text) >= 0 ;
        }
    });
editors[4] = textEditor;

// Designe os editores de células ao visualizador
tableViewer.setCellEditors(editors);
// Configure o modificador de células para o visualizador
tableViewer.setCellModifier(new TaskCellModifier(this));
// Configure o classificador padrão para o visualizador
tableViewer.setSorter(new PersonalTaskSorter(PersonalTaskSorter.TASK_DESC));

// Crie e configure TableViewer
tableViewer.setContentProvider(new PersonalTaskContentProvider());
tableViewer.setLabelProvider(new TaskLabelProvider());

// A entrada para o visualizador de tabela é a instância de PersonalTaskModel
taskList = new PersonalTaskModel();
tableViewer.setInput(taskList);

PersonalTaskContentProvider possui métodos que retornariam os elementos a serem exibidos em TableViewer quando sua entrada estiver configurada para o elemento fornecido. Essa classe também define operações básicas em PersonalTask como addTask(), removeTask() e updateTask() de IPersonalTaskViewer.

PersonalTaskLabelProvider fornece rótulos e imagens para os dados da coluna da tabela.

Listagem 3. getColumnText() de PersonalTaskLabelProvider
public String getColumnText(Object element, int columnIndex) {
    String result = "";
    PersonalTask task = (PersonalTask) element;
    switch (columnIndex) {
        case 0:
            break;
        case 1 :
            result = task.getTaskDesc();
            break;
        case 2 :
            result = task.getTaskPrio();
            break;
        case 3 :
            result = task.getTaskOwner();
            break;
        case 4 :
            result = task.getPercentComplete() + "";
            break;
        default :
            break;
    }
    return result;
}

TaskCellModifier é utilizada como um modificador de célula para acessar o modelo de dados do editor de célula de maneira abstrata. Ela oferece métodos para verificar se a propriedade do elemento TaskModel pode ser editada, para recuperar um valor de uma propriedade do elemento TaskModel e para armazenar o valor do editor de célula de volta na propriedade do elemento do modelo.

A classe PersonalTaskSorter pega os elementos fornecidos por PersonalTaskContentProvider e os classifica na ordem fornecida. O método compare() classifica os elementos dependendo do SortType.

Listagem 4. compare() de PersonalTaskSorter
public int compare(Viewer viewer, Object o1, Object o2) {
    PersonalTask task1 = (PersonalTask) o1;
    PersonalTask task2 = (PersonalTask) o2;
    switch (sortType) {
        case TASK_DESC :
            return compareDescriptions(task1, task2);
        case TASK_PRIO :
            return comparePrios(task1, task2);
        case TASK_OWNER :
            return compareOwners(task1, task2);
        case TASK_COMPLETE :
            return comparePercentComplete(task1, task2);
        default:
            return 0;
    }
}

PersonalTaskView é a classe View que estende ViewPart.

Listagem 5. createPartControl() de PersonalTaskView
public void createPartControl(Composite parent) {
    viewer = new PersonalTaskViewer(parent);
    viewer.getCloseButton().addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            handleDispose();
        }
    });
}

A Perspectiva do Aplicativo PersonalTaskOrganizer usa essa View para exibição na perspectiva (consulte Listagem 6). Fazendo isso, você estabeleceu a conexão entre os modelos de código gerados pelo assistente do aplicativo RCP e PersonalTaskView.

Listagem 6. createInitialLayout() da Perspectiva
public void createInitialLayout(IPageLayout layout) {
    String editorArea = layout.getEditorArea();
    layout.setEditorAreaVisible(false);
    layout.setFixed(true);
    layout.addStandaloneView(PersonalTaskView.ID,  false, IPageLayout.LEFT, 1.0f,
editorArea);

Execute seu aplicativo da mesma maneira de antes, selecionando Executar > Aplicativo Eclipse no menu de contexto do projeto no Package Explorer. Após a tela inicial, você verá o gerenciador de tarefa pré-preenchido com algumas tarefas de amostra.

Figura 22. Visualização do Gerenciador de Tarefa do Organizador
Visualização do Gerenciador de Tarefa do Organizador
Visualização do Gerenciador de Tarefa do Organizador

Parabéns! Você criou um plug-in RCP simples que agora pode ser destinado para execução em um ambiente desktop de sua escolha.

Criando a Definição do Produto

Em releases anteriores do RCP no Eclipse, os plug-ins incluídos em seu aplicativo para distribuição eram limitados aqueles disponíveis no diretório de destino. Com o Ganymede, agora você tem a capacidade de especificar exatamente de quais plug-ins você precisa, resultando em uma distribuição mais precisa. Nesta seção, você vai compactar seu aplicativo para que ele possa ser distribuído em um pacote compacto, contendo apenas o que é necessário para execução.

Configurando o Ambiente de Destino

Para configurar o ambiente de destino, realce o nome do projeto no Package Explorer e selecione Novo > Configuração do Produto no menu de contexto.

Figura 23. Configuração do Produto no Menu de Contexto
Configuração do Produto no Menu de Contexto
Configuração do Produto no Menu de Contexto

Isso ativará um assistente que permite que você edite a configuração do aplicativo RCP (consulte Figura 24). Na primeira tela do assistente, configure a pasta-pai como com.devworks.tutorial.po e nomeie o arquivo TaskOrganizer.product. Selecione o botão de opções para Inicializar o Conteúdo do Arquivo para Criar um arquivo de configuração com configurações básicas; em seguida, selecione Concluir.

Figura 24. O Assistente Nova Configuração do Produto
O Assistente Nova Configuração do Produto
O Assistente Nova Configuração do Produto

O Eclipse criou um arquivo chamado TaskOrganizer.product que contém uma definição de modelo da configuração, que será exibida no editor, padronizada para a guia Visão Geral.

Especifique o nome que aparece na barra de título do aplicativo como Organizador Pessoal e o identificador do produto será com.devworks.tutorial.po.product. O número da versão do produto é 1.0.0 e o aplicativo é com.devworks.tutorial.po.application. Os dois últimos são selecionados em uma lista suspensa. Por fim, a configuração do produto do seu aplicativo será baseada em plug-ins, portanto, selecione-a como o botão de opções. Como você está editando um arquivo de propriedades, certifique-se de salvar seu trabalho no menu de arquivo ou com a tecla de atalho apropriada para seu sistema operacional.

Agora selecione a guia Configuração, onde você vai incluir os plug-ins necessários, e apenas os plug-ins necessários (consulte Figura 25). Comece incluindo o plug-in que acabou de gravar clicando em Incluir. Um diálogo aparecerá exibindo todos os plug-ins conhecidos; selecione com.devworks.tutorial.po e clique em OK.

Figura 25. Selecionando um Plug-in para Utilizar para Configuração
Selecionando um Plug-in para Utilizar para Configuração
Selecionando um Plug-in para Utilizar para Configuração

Seu plug-in agora aparecerá na lista na guia Configuração do editor TaskOranizer.product (consulte Figura 26).

Figura 26. Visualização do Editor Taskorganizer.product
Visualização do Editor Taskorganizer.product
Visualização do Editor Taskorganizer.product

Tendo dito ao Eclipse que este é um dos plug-ins que você precisa para sua distribuição, agora ele pode intuir todos os plug-ins dependentes e incluí-los automaticamente. Clique em Incluir Plug-ins Necessários, e o Eclipse vai incluir os plug-ins adicionais necessários na lista.

Figura 27. Os Plug-ins Adicionais
Os Plug-ins Adicionais
Os Plug-ins Adicionais

Salve as mudanças e depois navegue para a guia Ativação (consulte Figura 28). Aqui você pode fornecer o nome do executável para o aplicativo. Insira PersonalOrganizer no campo Nome do Ativador.

A Figura 28 também nos permite escolher ícones para o aplicativo. Cada S.O. de destino possui um meio diferente de configura-los, e você pode configurar o ícone para seu sistema operacional escolhendo-o na lista de guias e inserindo um nome de arquivo. Caso não tenha um ícone que gostaria de utilizar por enquanto, você pode deixá-lo em branco e um padrão será fornecido.

Figura 28. A Guia Ativação
A Guia Ativação
A Guia Ativação

Navegue para a guia Tela Inicial e clique em Navegar para ver uma lista de plug-ins disponíveis que podem conter o bitmap de tela inicial. Lembre-se de que os modelos criados pelo assistente Novo Projeto criaram um bitmap de amostra e, portanto, para este tutorial, você vai navegar para o projeto atual. Entretanto, é possível, caso você tenha inúmeros projetos, que a marca seja idêntica para muitos deles e, por isso, talvez você queira reutilizar um bitmap de outro plug-in criado, o que facilitaria.

Figura 29. Selecionando o Local do Plug-in da Tela Inicial
Selecionando o Local do Plug-in da Tela Inicial
Selecionando o Local do Plug-in da Tela Inicial

Selecione seu plug-in, denominado com.devworks.tutorial.po, e ele será incluído na guia Tela Inicial como o local da tela inicial.

Figura 30. Inserindo Informações sobre a Tela Inicial
Inserindo Informações sobre a Tela Inicial
Inserindo Informações sobre a Tela Inicial

Finalmente, selecione a guia Marcas e inclua os dois arquivos GIF criados pelo assistente Novo Projeto sob o diretório de ícones. Eles são imagens que serão exibidas com a janela durante sua execução. Você também pode criar os seus próprios, como GIF ou PNG, e armazená-los com seu plug-in.

Figura 31. A Guia Marcas
A Guia Marcas
A Guia Marcas

Agora você pode executar o aplicativo em seu ambiente de destino. Selecione Arquivo > Exportar > Desenvolvimento de Plug-in > Produto Eclipse.

Figura 32. Tela Exportar Seleção
Tela Exportar Seleção
Tela Exportar Seleção

Selecione Avançar e o Eclipse iniciará o assistente Exportação mostrado na Figura 33.

Figura 33. A Tela Exportação do Produto Eclipse
A Tela Exportação do Produto Eclipse
A Tela Exportação do Produto Eclipse

Use Navegar para selecionar o arquivo de configuração TaskOrganizer.product mostrado na Figura 34. Esse é o arquivo que contém a definição de seu plug-in como um produto independente, e a exportação vai utilizar isso para determinar o que deve ser incluído na distribuição.

Figura 34. Selecionando a Configuração do Produto
Selecionando a Configuração do Produto
Selecionando a Configuração do Produto

Para o Diretório-raiz, insira TaskOrganizer Certifique-se de que a caixa de opção esteja selecionada para Sincronizar antes de Exportar. Para o diretório de destino, escolha um local onde você gostaria de implementar esse aplicativo (no exemplo aqui, utilizaremos apenas um diretório temporário, mas você pode optar por utilizar um diretório de implementação do aplicativo). Por fim, em Opções de Exportação, selecione Incluir Código de Origem; em seguida, clique em Concluir.

Figura 35. A Tela Exportação do Produto Eclipse Concluído
A Tela Exportação do Produto Eclipse Concluído
A Tela Exportação do Produto Eclipse Concluído

O que o Eclipse cria no diretório temporário como resultado da exportação depende de sua plataforma de destino. No Mac OS X, por exemplo, isso se assemelha à Figura 36.

Figura 36. Arquivos Criados pela Exportação
Arquivos Criados pela Exportação
Arquivos Criados pela Exportação

O executável criado é chamado PersonalOrganizer. No Windows, ele criará um PersonalOrganizer.exe. Dê um clique duplo no executável e o aplicativo organizador será executado como um aplicativo nativo em seu desktop.

Criando uma Distribuição para outra Plataforma

E se você quiser implementar seu RCP em um desktop diferente do padrão atual? Suponha que você esteja desenvolvendo no Mac OS X, mas gostaria que se aplicativo fosse executado no Windows Vista. Esse é um dos melhores aprimoramentos no desenvolvimento do RCP no Ganymede.

Em releases anteriores do Eclipse, você tinha duas opções: alternar seu desenvolvimento para o Windows ou construir seu pacote com cada plug-in conhecido. Essa segunda abordagem significava que sua distribuição teria muito mais plug-ins do que o necessário para sua plataforma de destino.

O Ganymede resolve isso permitindo que você escolha os plug-ins relevantes para a plataforma de sua escolha, sem ter que mudar seu desenvolvimento para essa plataforma. Para destinar uma plataforma diferente de seu atual ambiente host, você define uma nova plataforma de destino. A plataforma de destino é, essencialmente, uma configuração Eclipse que contém o conjunto mínimo de plug-ins em relação ao qual o Eclipse vai construir um aplicativo. Por padrão, o Eclipse é configurado para utilizar a si mesmo como destino padrão, o que dá aos plug-ins do RCP acesso potencial a tudo que é carregado no IDE. Configurando uma plataforma de destino especial, você pode assumir o controle direto sobre o conjunto de plug-ins aos quais seu aplicativo RCP pode potencialmente ter acesso e fazer seu aplicativo RCP destinar versões de plug-ins diferentes atualmente carregadas em seu IDE.

Para criar um novo destino, realce o projeto no Package Explorer e exiba seu menu de contexto. Selecione Novo > Definição de Destino.

Figura 37. Definição de Destino a partir do Menu de Contexto
Definição de Destino a partir do Menu de Contexto
Definição de Destino a partir do Menu de Contexto

Selecione o projeto mostrado na visualização em árvore como a pasta-pai (com.devworks.tutorial.po) e utilize o nome do arquivo taskorganizer-other.target. Por fim, selecione Utilizar uma Definição de Destino Existente nos botões de opções para Inicializar o Conteúdo do Arquivo e certifique-se de que o drop-down mostre RCP de Base (Apenas Binário); em seguida, clique em Concluir.

Figura 38. A Tela Criação da Definição de Destino
A Tela Criação da Definição de Destino
A Tela Criação da Definição de Destino

Um arquivo de propriedades agora será aberto na área de janela do editor. Altere o nome de destino para um sistema operacional diferente do seu atual. Neste exemplo, como estamos desenvolvendo no Mac OS X, vamos escolher o Windows nomeá-lo assim.

Se você quisesse implementar em um conjunto de trabalhos de plug-ins que fossem exclusivos para uma versão antiga do Eclipse, você poderia selecionar o local de destino escolhendo Local e selecionar o diretório em seu sistema de arquivos onde essa versão antiga estava armazenada, o que restringiria os plug-ins disponíveis aqueles utilizados por essa versão. Por enquanto, você vai implementar na versão atual do Eclipse, portanto, selecione Utilizar o mesmo local de destino no host (em execução) que a plataforma está utilizando para o local de destino.

Figura 39. O Editor de Arquivo de Propriedades de Destino
O Editor de Arquivo de Propriedades de Destino
O Editor de Arquivo de Propriedades de Destino

Navegue para a guia Ambiente. Aqui, insira os detalhes sobre seu ambiente de destino. Novamente, para este exemplo, vamos desenvolver no Mac OS X, portanto, mostraremos configurações que seriam apropriadas para uma implementação no Windows, mas você pode escolher as configurações para qualquer uma das plataformas suportadas que queira experimentar.

Figura 40. A Guia Ambiente de Destino
A Guia Ambiente de Destino
A Guia Ambiente de Destino

Neste exemplo, como o JRE padrão atual para Mac OS X é V1.5, mostraremos a mudança da versão do JRE para J2SE V1.6, já que ela está mais disponível em sistemas Windows.

Quando terminar a edição, certifique-se de salvar o arquivo. Agora você pode utilizar essa definição de destino para criar o produto.

Clique no link no lado superior direito que diz Configurar como Plataforma de Destino. Você criou uma plataforma de destino que poderia ser utilizada para distribuir seu aplicativo com os plug-ins necessários para uma plataforma diferente daquela com a qual você está desenvolvendo atualmente. Na próxima seção, você verá como compactar seu aplicativo para distribuição com o novo sistema p2 no Ganymede.

Compactando e Distribuindo Aplicativos RCP Utilizando p2

O último aprimoramento que você verá neste tutorial é um novo método de compactação e distribuição de plug-ins. Nas versões anteriores do Eclipse, a compactação era essencialmente a criação de um archive ZIP de todos os arquivos relevantes, junto com um manifesto apropriado, e sua colocação em um servidor publicamente disponível. Depois eles poderiam ser instalados através do recurso Ajuda > Atualizações do menu; mas muitos usuários optaram simplesmente pelo download e por descompactar arquivo ZIP do archive do plug-in diretamente na pasta de instalação apropriada do Eclipse. O mecanismo p2 simplifica esse processo, permitindo uma compactação limpa e uma distribuição automatizada. Nesta seção, você vai criar um site de atualização p2 e vai compactar seu plug-in para distribuição através dele.

Criando a Lista de Recursos

Pacotes contêm recursos, que, por sua vez, são compostos de plug-ins. Portanto, para compactar seu plug-in do organizador para o p2, você precisa começar criando uma lista de recursos. Isso é feito utilizando-se o novo assistente de projeto. No menu do Eclipse, selecione Novo > Projeto > Desenvolvimento de Plug-in > Projeto de Recurso e clique em Avançar.

Figura 41. Criando um Novo Projeto de Recurso
Criando um Novo Projeto de Recurso
Criando um Novo Projeto de Recurso

Nomeie este projeto com.devworks.tutorial.po.feature e armazene-o no local padrão para manter a simplicidade. Deixe o ID do recurso como seu padrão de nome de projeto, mas altere o nome do recurso para Organizador de Tarefa Pessoal. Deixe o restante dos campos como seus padrões e clique em Avançar.

Figura 42. Editor de Propriedades do Recurso
Editor de Propriedades do Recurso
Editor de Propriedades do Recurso

O Eclipse exibirá uma tela perguntando sobre o plug-in que deveria ser utilizado para inicializar este conjunto de recursos. Como esse conjunto de recursos trata apenas do seu plug-in do organizador pessoal, selecione com.devworks.tutorial.po na lista e em Concluir.

Figura 43. Selecionando o Plug-in que Fornece a Definição do Recurso
Selecionando o Plug-in que Fornece a Definição do Recurso
Selecionando o Plug-in que Fornece a Definição do Recurso

O assistente é concluído através da criação de um novo projeto e do preenchimento de um arquivo chamado feature.xml. Ele contém informações sobre os recursos, as dependências, o licenciamento e as instruções de compilação para seus plug-ins — resumindo, tudo que é necessário para a compilação de uma distribuição.

Figura 44. O feature.xml Mostrado no Editor
O feature.xml Mostrado no Editor
O feature.xml Mostrado no Editor

O site de atualização que você criará em seguida utilizará esta lista de recursos.

Crie o Site de Atualização

Agora que você possui um conjunto de recursos, é possível utilizá-lo para criar um site a partir do qual você pode distribuí-lo. O que será criado é um conjunto de arquivos que pode ser disponibilizado publicamente na Internet ou em uma intranet corporativa ou que pode ser distribuído em disco ou como um arquivo zip. Os arquivos e a estrutura criados são feitos simplesmente em um diretório que você pode distribuir como quiser.

Criar um novo site de atualização é simples. Mais uma vez, o assistente Novo Projeto é utilizado. Em Project Explorer, selecione Novo > Projeto > Desenvolvimento de Plug-in > Projeto do Site de Atualização; em seguida, selecione Avançar.

Figura 45. Criando um Novo Projeto de Site de Atualização
Criando um Novo Projeto de Site de Atualização
Criando um Novo Projeto de Site de Atualização

Isso iniciará um assistente que criará um novo projeto que representa seu site de atualização (consulte Figura 46). Insira com.devworks.tutorial.updatesite como o nome do projeto e salve-o em seu sistema de arquivos local. (A seleção do local padrão criará o site de atualização em sua atual área de trabalho; a escolha de um local externo deixará este tutorial um pouco mais claro, mas é você quem decide.) Clique em Concluir.

Figura 46. O Editor de Propriedades do Projeto do Site de Atualização
O Editor de Propriedades do Projeto do Site de Atualização
O Editor de Propriedades do Projeto do Site de Atualização

O assistente criará um projeto com um único arquivo site.xml, exibido no editor. Ele descreve o pacote como o atualizador o verá.

Figura 47. O site.xml Mostrado no Editor
O site.xml Mostrado no Editor
O site.xml Mostrado no Editor

Agora você precisa configurar esse site.xml para incluir uma categoria e recursos. Isso inicia o site de atualização com o material que você quer que ele distribua. Clique em Nova Categoria no editor do site.xml e o lado direito do editor exibirá propriedades que você vai editar (consulte Figura 48). Insira Organizador de Tarefa Pessoal para o nome e Tutorial para o rótulo. Você pode inserir uma descrição de sua escolha; nós utilizamos Este é um Organizador de Tarefa Pessoal.

Figura 48. Incluindo a Categoria
Incluindo a Categoria
Incluindo a Categoria

Agora realce o Organizador de Tarefa Pessoal na caixa de listagem esquerda e clique em Incluir Recurso. O Eclipse exibirá uma lista de recursos disponíveis, incluindo o que você criou anteriormente (consulte Figura 49). Selecione com.devworks.tutorial.po.feature da lista e clique em OK.

Figura 49. Selecionando o Recurso para Incluir no Site de Atualização
Selecionando o Recurso para Incluir no Site de Atualização
Selecionando o Recurso para Incluir no Site de Atualização

Isso o incluirá na lista de recursos em sua categoria.

Figura 50. Recurso Mostrado no Editor site.xml
Recurso Mostrado no Editor site.xml
Recurso Mostrado no Editor site.xml

Você está pronto para construir sua distribuição fisicamente no disco. Salve suas edições, depois realce o Organizador de Tarefa Pessoal novamente na lista de categorias. Clique em Construir Tudo, e isso criará um site de atualização no caminho fornecido.

Parabéns! Você criou uma distribuição de seu organizador, adequada para publicação mundial. Vamos ver como ela apareceria para um usuário buscando-a para download e instalação em seu ambiente Eclipse, carregando-a em seu próprio ambiente Eclipse.

Carregando o Site Local

Você vai incluir seu plug-in da mesma maneira que fez com o plug-in Subversive, por meio da função Atualizações de Software. Navegue para Ajuda > Atualizações de Software e clique em Incluir Site. Dessa vez, entretanto, em vez de uma URL na Web, clique em Local e o Eclipse exibirá uma caixa de navegação de arquivos. Navegue para o diretório onde você criou seu site de atualização e clique em OK, depois em OK novamente na tela Incluir.

Figura 51. Incluindo o Local do Novo Site em Atualizações de Software
Incluindo o Local do Novo Site em Atualizações de Software
Incluindo o Local do Novo Site em Atualizações de Software

Seu site de atualização agora aparece na lista de atualizações disponíveis.

Figura 52. O Organizador na Lista de Atualizações de Software
O Organizador na Lista de Atualizações de Software
O Organizador na Lista de Atualizações de Software

Para instalar seu plug-in, selecione-o na lista e clique em Instalar. Você verá seu plug-in listado em uma tela de instalação de plug-in padrão.

Figura 53. A Tela de Instalação do Organizador
A Tela de Instalação do Organizador
A Tela de Instalação do Organizador

Clique em Avançar e você será apresentado a uma tela de licença (consulte Figura 54). Como não inseriu uma licença, você verá uma mensagem padrão, mas certifique-se de selecionar Aceito e clique em Concluir.

Figura 54. Tela de Termos de Licença
Tela de Termos de Licença
Tela de Termos de Licença

O Eclipse instalará o plug-in do organizador para reiniciar. Após reiniciar, você vai localizar seu plug-in em Janela > Mostrar Visualização > Outro > Outro.

Figura 55. Abrindo o Organizador
Abrindo o Organizador
Abrindo o Organizador

Clique em OK e seu organizador pessoal será carregado e executando dentro do ambiente de trabalho do Eclipse.

Figura 56. O Organizador no Ambiente de Trabalho do Eclipse
O Organizador no Ambiente de Trabalho do Eclipse
O Organizador no Ambiente de Trabalho do Eclipse

Seu organizador pessoal agora faz parte do seu ambiente de trabalho do Eclipse pronto para ser utilizado junto com tudo que compõe sua experiência com o Eclipse.

Resumo

O release do Ganymede é uma excelente inclusão na longa e rica tradição do Eclipse. Este tutorial abordou alguns novos recursos que deixarão o desenvolvimento de plug-ins muito mais fácil e sua distribuição mais limpa e eficiente. Agora o RCP tem a capacidade de compactar apenas os plug-ins que você precisa ou quer. O suporte do Subversion agora é padrão com o Eclipse e vai continuar cada vez mais integrado com o ambiente de trabalho, oferecendo suporte integral para este sistema de controle de origem de última geração.

O sistema de compactação e distribuição p2 representa um salto evolutivo no modelo de implementação, permitindo uma compactação e uma distribuição simples, que são mais limpas e mais padronizadas do que nas versões anteriores do Eclipse. Você explorou todos esses recursos criando um aplicativo organizador pessoal do RCP de tela única simples, compactando-o para implementação e vendo como você poderia criar um ambiente para implementação diferente do seu ambiente atual. Você armazenou a origem para este aplicativo Subversion através do plug-in Subversive, permitindo o acompanhamento de mudanças e a fácil colaboração com outras pessoas. E você aprendeu como compactar seu plug-in para implementação utilizando o novo sistema de distribuição p2, facilitando para as pessoas fazerem o download e instalarem seu trabalho.

Na Parte 2 desta série, você vai expandir o trabalho feito aqui modificando o organizador para utilizar o Rich Ajax Platform para executar seu aplicativo como um aplicativo nativo na Web.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Linux
ArticleID=387276
ArticleTitle=Usando Eclipse Ganymede para Desenvolvimento de Dispositivos para Desktop, Web e Remotos, Parte 1: Desenvolvendo para a Plataforma Rich Client, da Maneira Ganymede
publish-date=09022008