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