netbeans.apache.org/src/old_content/content/tutorials/74/nbm-maven-modulesuite_pt_BR.adoc

// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Trabalhando com o suíte de módulos NetBeans utilizando o Maven
:jbake-type: platform_tutorial
:jbake-tags: tutorials 
:jbake-status: published
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:icons: font
:experimental:
:description: Trabalhando com o suíte de módulos NetBeans utilizando o Maven - Apache NetBeans
:keywords: Apache NetBeans Platform, Platform Tutorials, Trabalhando com o suíte de módulos NetBeans utilizando o Maven

Este documento demonstra como criar uma suíte de módulos da plataforma NetBeans de um arquetipo Maven e como construir e instalar a suíte em sua instalação do IDE. Neste tutorial, será possível criar um projeto de suíte de módulos que contém três módulos NetBeans como subprojetos. O projeto Maven que contém os subprojetos é um projeto POM simples que declara como o suíte é compilado no destino da instalação.

Este documento tem base no  link:https://netbeans.apache.org/tutorials/nbm-selection-1.html[Tutorial de gerenciamento de seleção do NetBeans] com base no Ant e ilustra algumas das diferenças entre a utilização do Ant e do Maven para desenvolver uma suíte de módulos da plataforma NetBeans. Após compreender algumas das diferenças, é possível prosseguir com facilidade através dos outros tutoriais na  link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[Trilha de aprendizado da plataforma NetBeans].

Caso seja novo na plataforma NetBeans, recomenda-se com ênfase que você assista à série de screencasts  link:https://netbeans.apache.org/tutorials/nbm-10-top-apis.html[As 10 principais APIs do NetBeans].





*Para seguir este tutorial, são necessários os softwares e recursos listados na tabela a seguir.*


NOTE:  não é necessário baixar uma versão avulsa da plataforma NetBeans para desenvolver os aplicativos para a plataforma NetBeans. Normalmente, se desenvolve os aplicativos e módulos no NetBeans IDE e, em seguida, inclui-se somente os módulos necessários para executar a plataforma NetBeans e seu aplicativo.

Antes de começar este tutorial, talvez você queira se familiarizar com a documentação a seguir.

*  link:https://netbeans.apache.org/wiki/[FAQ Desenvolvedor NetBeans]
*  link:http://wiki.netbeans.org/MavenBestPractices[Melhores práticas para o Apache Maven no NetBeans 6.x]
*  link:http://www.sonatype.com/books/maven-book/reference/introduction.html[Capítulo 1. Introdução ao Apache Maven] (do  link:http://www.sonatype.com/books/maven-book/reference/public-book.html[Maven: o guia definitivo])
*  link:https://netbeans.apache.org/kb/docs/java/gui-functionality_pt_BR.html[Introdução à construção de GUI]


== Utilizando Maven com o IDE

Se este for seu primeiro projeto Maven, talvez queira se familiarizar com as definições de configurações e com o navegador do repositório Maven.


=== Configurando as opções do Maven

É possível utilizar a aba Maven na janela Opções para configurar o comportamento do Maven no IDE e verificar se sua configuração está correta.


[start=1]
1. Selecione a categoria Miscelâneos na janela Opções e clique na aba Maven.

[start=2]
1. Especifique a localização da instalação local do Maven (requer 2.0.9 ou mais recente).

[start=3]
1. Verifique se a localização do repositório local do Maven está correta.

[start=4]
1. Clique em OK.

Na maioria dos casos, se a configuração do Maven for típica a informação na janela Opções já deve estar correta.

*Nota.* O suporte ao Maven é ativado como parte do conjunto de recursos do Java SE. Se a aba Maven não estiver disponível na janela Opções, confirme se o Java SE está ativado ao criar um aplicativo Java.


=== Visualizando repositórios Maven

Os artefatos que são utilizados pelo Maven para construir todos os seus projetos são armazenados em seu repositório local Maven. Quando um artefato é declarado como uma dependência do projeto, o artefato é baixado para o repositório local a partir de um dos repositórios remotos registrados se não estiver instalado.

O repositório NetBeans e vários outros repositórios conhecidos Maven indexados são registrados e listados, por padrão, na janela Navegador do repositório. O repositório NetBeans contém a maioria dos artefatos públicos necessários para a construção do seu projeto. É possível utilizar o navegador do repositório Maven para visualizar o conteúdo dos repositórios locais e remotos. Você expande o nó Repositório local para ver os artefatos que estão presentes localmente. Os artefatos listados sob os nós repositório NetBeans podem ser adicionados como dependências de projeto, mas nem todos eles estão presentes no local. Eles são adicionados ao repositório local somente quando são declarados como dependências do projeto.

Para abrir o navegador do repositório Maven:

* Escolha Janela > Outro > Navegador do repositório Maven no menu principal.

image::images/maven-quickstart68_maven-nbm-netbeans-repo.png[title="Captura de tela do navegador do repositório Maven"]


== Criando a suíte de módulos da plataforma NetBeans

Nesta seção, será utilizado o assistente Novo projeto para criar um aplicativo da suíte de módulos da plataforma NetBeans a partir de um arquetipo Maven. O assistente criará um projeto POM que conterá os projetos do módulo. Nesse assistente, será criado um módulo como subprojeto da suíte.


[start=1]
1. Abra o assistente Novo projeto e escolha suíte de módulos do NetBeans Maven na categoria Maven. Clique em Próximo.

[start=2]
1. Digite *MavenSelectionSuite* como o nome do projeto. Clique em Próximo.

[start=3]
1. Selecione Criar projeto de módulo e digite *MyAPI* para o nome do módulo. Clique em Terminar.

Ao clicar em Terminar, o IDE cria o projeto MavenSelectioneSuite e o subprojeto módulo MyAPI NetBeans.

image::images/maven-suite_maven-suite-projectswindow.png[title="Captura de tela da janela Projetos"]

MavenSelectionSuite é um projeto POM que é um contêiner para subprojetos, nesse caso projetos de módulo NetBeans. O projeto POM não contém nenhum arquivo de código-fonte. O projeto POM contém instruções para compilar a suíte, e se observar o POM para o projeto é possível visualizar que  ``pom``  é específico para o pacote.


[source,xml]
----

     <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>MavenSelectionSuite</artifactId>
    *<packaging>pom</packaging>*
    <version>1.0-SNAPSHOT</version>
    <name>MavenSelectionSuite Netbeans Module Suite</name>
    ...
        <properties>
            <netbeans.version>RELEASE69</netbeans.version>
        </properties>
    *<modules>
        <module>MyAPI</module>
    </modules>*
</project>
----

O POM também contém uma lista de módulos que serão incluídos ao construir o projeto POM. É possível visualizar que o projeto MyAPI está listado como módulo.

Se expandir o nó módulo na janela Projetos, será possível visualizar que o projeto MyAPI está listado como um módulo. Na janela Arquivos, é possível visualizar que o diretório do projetoMyAPI está localizado no diretório  ``MavenSelectionSuite`` . Ao criar um novo projeto no diretório de um projeto POM, o IDE adiciona automaticamente o projeto na lista de módulos no POM que estão incluídos ao construir e executar o projeto POM.

Ao criar uma suíte de módulos da plataforma NetBeans do arquetipo Maven, não é necessário especificar o destino da instalação da plataforma NetBeans no assistente Novo projeto, assim como ao utilizar o Ant. Para visualizar a instalação da plataforma NetBeans é necessário modificar o elemento  ``<netbeans.installation>``  no arquivo de projeto POM  ``profiles.xml``  e especificar explicitamente o caminho para a instalação da plataforma NetBeans. Para mais, consulte a seção <<05b,Especificando a localização da instalação do NetBeans>> neste tutorial.


== Modificando o módulo MyAPI

O módulo MyAPI foi criado ao criar a suíte de módulos, mas não é necessário criar uma classe no módulo e expor a classe para outros módulos.


=== Criando uma classe no módulo MyAPI

Neste exercício, será criada uma classe simples nomeada  ``APIObject`` . Cada instância do  ``APIObject``  será único, porque o campo  ``índice``  foi incrementado por 1 cada vez que uma nova instância de  ``APIObject``  é criada.


[start=1]
1. Expanda o pacote MyAPI na janela Projetos.

[start=2]
1. Clique com o botão direito do mouse no nó Pacotes de fontes e escolha Novo > Classe Java.

[start=3]
1. Digite *APIObject* como nome da classe e selecione  ``com.mycompany.mavenselectionsuite``  da lista suspensa Pacote. Clique em Terminar.

[start=4]
1. Modifique a classe para declarar alguns campos e adicione os métodos simples a seguir.

[source,java]
----

public final class APIObject {

   private final Date date = new Date();
   private static int count = 0;
   private final int index;

   public APIObject() {
      index = count++;
   }

   public Date getDate() {
      return date;
   }

   public int getIndex() {
      return index;
   }

   public String toString() {
       return index + " - " + date;
   }

}
----


[start=5]
1. Corrija as importações e salve as alterações.


=== Especificando os pacotes públicos

Neste tutorial, serão criados módulos adicionais que necessitarão acessar os métodos no  ``APIObject`` . Neste exercício, os conteúdos do módulo público MyAPI serão criados para que outros módulos possam acessar os métodos. Para declarar o pacote  ``com.mycompany.mavenselectionsuite``  como público, é necessário modificar o elemento  ``configuração``  do  ``nbm-maven-plugin``  no POM a fim de especificar os pacotes que são exportados como públicos. É possível efetuar as alterações ao POM no editor ao selecionar os pacotes para tornar público na janela Propriedades do projeto.


[start=1]
1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades para abrir a janela Propriedades.

[start=2]
1. Selecione o pacote *com.mycompany.mavenselectionsuite* na categoria *Pacotes públicos*. Clique em OK. 
image::images/maven-suite_maven-suite-publicpackages.png[title="Pacotes públicos na janela Propriedades"]

Ao selecionar um pacote para exportar, o IDE modifica o elemento  ``nbm-maven-plugin``  no POM para especificar o pacote.


[source,xml]
----

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>nbm-maven-plugin</artifactId>
    <extensions>true</extensions>
    <configuration>
        <publicPackages>
            *<publicPackage>com.mycompany.mavenselectionsuite</publicPackage>*
        </publicPackages>
    </configuration>
</plugin>
----


[start=3]
1. Clique com o botão direito do mouse no projeto e escolha Construir.

Ao construir o projeto, o  ``nbm-maven-plugin``  gerará um cabeçalho de manifesto no  ``MANIFEST.MF``  do JAR, que especifica os pacotes públicos.

Para mais informações, consulte o  link:http://bits.netbeans.org/mavenutilities/nbm-maven-plugin/manifest-mojo.html#publicPackages[manifesto de documentação nbm-maven-plugin].


== Criando o módulo MyViewer

Nesta seção, um novo módulo nomeado MyViewer será criado e um componente de janela será adicionado em dois campos de texto. O componente implementará  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util-lookup/org/openide/util/LookupListener.html[LookupListener]``  para alertar as alterações no link:https://netbeans.apache.org/wiki/devfaqlookup[Lookup].


=== Criando o módulo

Neste exercício, será criado o módulo MyViewer no diretório  ``MavenSelectionSuite`` .


[start=1]
1. Escolha Arquivo > Novo projeto do menu principal (Ctrl-Shift-N).

[start=2]
1. Selecione o módulo NetBeans Maven da categoria Maven. Clique em Próximo.

[start=3]
1. Digite *MyViewer* como o nome do projeto.

[start=4]
1. Confirme se a localização do projeto é o diretório  ``MavenSelectionSuite`` . Clique em Terminar.

[start=5]
1. Clique com o botão direito do mouse no nó Bibliotecas na janela Projetos e escolha Adicionar dependência.

[start=6]
1. Selecione o módulo NetBeans MyAPI na aba Abrir projetos. Clique em OK.
image::images/maven-suite_maven-suite-addapi.png[title="Pacotes públicos na janela Propriedades"]

Ao clicar em OK, o IDE adiciona artefatos para a lista de dependências no POM e exibe o artefato abaixo do nó Bibliotecas.

Ao observar o POM do módulo MyViewer, é possível perceber que o projeto principal para o módulo é MavenSelectionSuite, que  ``nbm``  e especificado para  ``empacotamento``  e que o *nbm-maven-plugin* será utilizado para construir o projeto como módulo NetBeans.


[source,xml]
----

<modelVersion>4.0.0</modelVersion>
*<parent>
    <groupId>com.mycompany</groupId>
    <artifactId>MavenSelectionSuite</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>*
<groupId>com.mycompany</groupId>
<artifactId>MyViewer</artifactId>
*<packaging>nbm</packaging>*
<version>1.0-SNAPSHOT</version>
<name>MyViewer NetBeans Module</name>

----


=== Criando o componente de janela

Neste exercício, um componente de janela será criado e dois campos de texto adicionados.


[start=1]
1. Clique com o botão direito do mouse no projeto MyViewer e escolha Nova > Janela.

[start=2]
1. Selecione *navegador* da lista suspensa e selecione Abrir em Iniciar aplicativo. Clique em Próximo.

[start=3]
1. Digite *MyViewer* como prefixo do nome da classe. Clique em Terminar.

[start=4]
1. Arraste dois rótulos da Paleta para o componente e altere o texto do topo do rótulo para  ``"[nothing selected]"`` .
image::images/maven-suite_maven-suite-myviewertopcomponent.png[title="Campos de texto no componente Janela"]

[start=5]
1. Clique na aba Código-fonte e modifique a assinatura de classe para implementar  ``LookupListener`` .

[source,java]
----

classe pública MyViewerTopComponent estende TopComponent *implemente LookupListener* {
----


[start=6]
1. Implemente os métodos abstratos ao colocar o cursor de inserção na linha e pressionar as teclas Alt-Enter.

[start=7]
1. Adicione o campo  ``privado``   ``resultado``  e defina o valor inicial como nulo.

[source,java]
----

private Lookup.Result result = null;
----


[start=8]
1. Efetue as mudanças a seguir para os métodos  ``componentOpened()`` ,  ``componentClosed()``  e  ``resultChanged()`` .

[source,java]
----

public void componentOpened() {
    *result = Utilities.actionsGlobalContext().lookupResult(APIObject.class);
    result.addLookupListener(this);*
}

public void componentClosed() {
    *result.removeLookupListener (this);
    result = null;*
}

public void resultChanged(LookupEvent le) {
    *Lookup.Result r = (Lookup.Result) le.getSource();
    Collection c = r.allInstances();
    if (!c.isEmpty()) {
        APIObject o = (APIObject) c.iterator().next();
        jLabel1.setText (Integer.toString(o.getIndex()));
        jLabel2.setText (o.getDate().toString());
    } else {
        jLabel1.setText("[no selection]");
        jLabel2.setText ("");
    }*
}
----

Ao utilizar  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util/org/openide/util/Utilities.html#actionsGlobalContext%28%29[Utilities.actionsGlobalContext()]`` , toda vez que o componente é aberto a classe é capaz de alertar globalmente para o objeto de Pesquisa do componente que tem o foco. A Pesquisa é removida quando o componente é finalizado. O método  ``resultChanged()``  implementa o  ``LookupListener``  de forma que o JLabels do formulário seja atualizado de acordo com o  ``APIObject``  que possui o foco.


[start=9]
1. Corrija as importações e assegure-se de adicionar * ``org.openide.util.Utilities`` *. Salve as alterações.


== Criando o módulo MyEditor

Nesta seção, um novo módulo chamado MyEditor será criado. O módulo conterá um  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-windows/org/openide/windows/TopComponent.html[TopComponent]``  que oferecerá instâncias de  ``APIObject``  através da Pesquisa. Também será criada uma ação que abrirá novas instâncias do componente MyEditor.


=== Criando o módulo

Neste exercício, um módulo NetBeans será criado no diretório  ``MavenSelectionSuite``  e uma dependência será adicionada no módulo API.


[start=1]
1. Escolha Arquivo > Novo projeto no menu principal.

[start=2]
1. Selecione o módulo NetBeans Maven da categoria Maven. Clique em Próximo.

[start=3]
1. Digite *MyEditor* como nome do projeto.

[start=4]
1. Confirme se a localização do projeto é o diretório  ``MavenSelectionSuite`` . Clique em Terminar.

[start=5]
1. Clique com o botão direito do mouse no nó Bibliotecas na janela Projetos e escolha Adicionar dependência.

[start=6]
1. Selecione o módulo NetBeans MyAPI na aba Abrir projetos. Clique em OK.


=== Adicionando uma ação

Neste exercício, será criada uma classe para adicionar um item de menu ao menu Arquivo para abrir um componente nomeado MyEditor. O componente será criado no próximo exercício.


[start=1]
1. Clique com o botão direito do mouse no projeto MyEditor e escolha Novo > Ação para abrir a caixa de diálogo Nova ação.

[start=2]
1. Selecione sempre habilitado. Clique em Próximo.

[start=3]
1. Mantenha os padrões na página Registro de GUI. Clique em Próximo.

[start=4]
1. Digite *OpenEditorAction* para o nome da classe.

[start=5]
1. Digite *Open Editor* para o nome de exibição. Clique em Terminar.

O IDE abre a classe  ``OpenEditorAction``  no editor e adiciona o seguinte no arquivo  ``layer.xml`` .


[source,xml]
----

<filesystem>
    <folder name="Actions">
        <folder name="Build">
            <file name="com-mycompany-myeditor-OpenEditorAction.instance">
                <attr name="delegate" newvalue="com.mycompany.myeditor.OpenEditorAction"/>
                <attr name="displayName" bundlevalue="com.mycompany.myeditor.Bundle#CTL_OpenEditorAction"/>
                <attr name="instanceCreate" methodvalue="org.openide.awt.Actions.alwaysEnabled"/>
                <attr name="noIconInMenu" boolvalue="false"/>
            </file>
        </folder>
    </folder>
    <folder name="Menu">
        <folder name="File">
            <file name="com-mycompany-myeditor-OpenEditorAction.shadow">
                <attr name="originalFile" stringvalue="Actions/Build/com-mycompany-myeditor-OpenEditorAction.instance"/>
                <attr name="position" intvalue="0"/>
            </file>
        </folder>
    </folder>
</filesystem>
----


[start=6]
1. Modifique a classe  ``OpenEditorAction``  para modificar o método  ``actionPerformed`` .

[source,java]
----

public void actionPerformed(ActionEvent e) {
    MyEditor editor = new MyEditor();
    editor.open();
    editor.requestActive();
}
----


=== Adicionando o componente de editor

Neste exercício, será criado um componente MyEditor que abre na área do editor quando invocado pelo  ``OpenEditorAction`` . Um modelo de componente de janela não será utilizado porque você desejará várias instâncias do componente e o componente da janela é utilizado para criar componentes singleton. Em vez disso, será utilizado um modelo de forma JPanel e, em seguida, a classe será modificada para estender  ``TopComponent`` .


[start=1]
1. Clique com o botão direito do mouse em Pacotes de código-fonte e escolha Novo > Outro e selecione Formulário JPanel na categoria Formulários Swing de GUI. Clique em Próximo.

[start=2]
1. Digite *MyEditor* para nome de classe e selecione o pacote  ``com.mycompany.myeditor`` . Clique em Terminar.

[start=3]
1. Arraste dois campos de texto para o componente.

[start=4]
1. Torne os campos de texto em somente leitura ao desmarcar a propriedade  ``editável``  para cada campo de texto.
image::images/maven-suite_maven-suite-editableprop.png[title="Propriedade Editável para rótulos"]

[start=5]
1. Clique na aba Código-fonte e modifique a assinatura de classe para estender  ``TopComponent``  no lugar de  ``javax.swing.JPanel`` .

[source,java]
----

classe pública MyEditor estende *TopComponent*
----


[start=6]
1. Coloque o cursor de inserção na assinatura e pressione Alt-Enter para consertar o erro no código, localizando o repositório Maven e adicionando uma dependência no artefato  ``org.openide.windows`` . Corrija suas importações.
image::images/maven-suite_maven-suite-add-topcomponent.png[title="Propriedade Editável para rótulos"]

[start=7]
1. Modifique o construtor para criar uma nova instância de  ``APIObject``  toda vez que a classe é invocada.

[source,java]
----

public MyEditor() {
    initComponents();
    *APIObject obj = new APIObject();
    associateLookup(Lookups.singleton(obj));
    jTextField1.setText("APIObject #" + obj.getIndex());
    jTextField2.setText("Created: " + obj.getDate());
    setDisplayName("MyEditor " + obj.getIndex());*

}
----

A linha  ``associateLookup(Lookups.singleton(obj));``  no construtor criará uma Pesquisa que contém a nova instância de  ``APIObject`` .


[start=8]
1. Corrija suas importações e salve as alterações.

Os campos de texto no componente exibem somente o valor do índice e a data do  ``APIObject`` . Isso possibilitará que você perceba que cada componente MyEditor é único e que o MyViewer está exibindo os detalhes do componente MyEditor que possui o foco.

*Nota.* Os erros no  ``OpenEditorAction``  serão resolvidos após salvar as alterações no  ``MyEditor`` .


== Construindo e executando a suíte de módulos

Nesse momento, você está quase pronto para executar a suíte para verificar se ela constroi, instala e se comporta corretamente.


=== Declarando dependências diretas

Antes de poder construir e executar a suíte necessária para modificar uma das dependências do projeto MyEditor. Se tentar construir a suíte de módulos agora, a saída de construção na janela Saída informará que a suíte não pode compilar porque o módulo MyEditor requer que o artefato  ``org.openide.util-lookup``  esteja disponível no tempo de execução.

Se clicar com o botão direito do mouse no nó do projeto e escolher Mostrar gráfico de dependência, o visualizador gráfico da dependência poderá lhe ajudar a visualizar as dependências de módulo.


image::images/maven-suite_maven-suite-dependency-graph.png[title="gráfico de dependência do artefato"]

É possível visualizar que o MyEditor não tem uma dependência direta no  ``org.openide.util-lookup`` . A dependência é transitiva e o artefato está disponível para o projeto no momento da compilação, mas as dependências necessitam ser diretas se o artefato estiver disponível no tempo de execução. É necessário modificar o POM para declarar o artefato como dependência direta.

É possível transformar o artefato em uma dependência direta editando manualmente o POM ou utilizando o item de menu pop-up na janela Projetos.


[start=1]
1. Expanda o nó Bibliotecas do módulo MyEditor.

[start=2]
1. Clique com o botão direito do mouse no artefato  ``org.openide.util-lookup``  e escolha Declarar como dependência direta.

Ao escolher Declarar como dependência direta, o IDE modifica o POM para adicionar o artefato como uma dependência.

*Nota.* O artefato  ``org.openide.util-lookup``  já é uma dependência direta do módulo MyViewer.


=== Especificando a localização da instalação do NetBeans

Como padrão, nenhum destino de instalação do NetBeans é especificado quando o arquetipo Maven é utilizado para criar uma plataforma de suíte de módulos NetBeans. Para instalar e executar a suíte de módulo em uma instalação do IDE, é necessário especificar o caminho para a instalação do diretório, editando o arquivo  ``profiles.xml``  no projeto POM.


[start=1]
1. Expanda o nó Arquivos de projeto no aplicativo MavenSelectionSuite e clique duas vezes em  ``profiles.xml``  para abrir o arquivo no editor.

[start=2]
1. Modificando o elemento  ``<netbeans.installation>``  para especificar o caminho para a plataforma NetBeans de destino e salve as alterações.

[source,xml]
----

<profile>
   <id>netbeans-ide</id>
   <properties>
       <netbeans.installation>/home/me/netbeans-6.9</netbeans.installation>
   </properties>
</profile>
----

*Nota.* O caminho necessita especificar o diretório que contém o diretório  ``bin``  contendo o arquivo executável.

Por exemplo, no sistema operacional X, o caminho pode se assemelhar ao seguinte.


[source,xml]
----

<netbeans.installation>/Applications/NetBeans/NetBeans6.9.app/Contents/Resources/NetBeans</netbeans.installation>
----


=== Executando o aplicativo

Agora que o destino da instalação do IDE foi especificado, é possível utilizar o comando Executar no projeto suíte.


[start=1]
1. Clique com o botão direito do mouse em MavenSelectionSuite e escolha Executar.

Ao escolher Executar, uma instância do IDE será iniciada com a suíte de módulos instalada.


image::images/maven-suite_maven-suite-run1.png[title="Janelas MyViewer e MyEditor"]

A janela MyEditor abrirá quando o aplicativo for iniciado e exibirá os dois rótulos de texto. Para abrir um componente MyEditor na área do editor, é possível escolher Abrir editor no menu Arquivo. A janela MyViewer exibirá os detalhes do componente MyEditor que possui o foco.

A ação Executar para o projeto suíte de módulos é configurado, como padrão, para utilizar o plug-in Reator, a fim de construir recursivamente e empacotar os módulos que estão especificados como parte da suíte. É possível abrir a janela Propriedades do projeto para visualizar as metas do Maven, que são mapeadas para ações no IDE.


image::images/maven-suite_maven-suite-run-action.png[title="Janelas MyViewer e MyEditor"]

Na categoria Ações, na janela Propriedades, é possível visualizar as metas que são mapeadas para a ação Executar.


== Modificando a Pesquisa dinamicamente

Atualmente, um novo  ``APIObject``  é criado toda vez que um novo componente MyEditor é aberto. Nesta seção, um botão será adicionado ao componente MyEditor, que substituirá o atual  ``APIObject``  do componente com um novo. Será modificado o código para utilizar  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util-lookup/org/openide/util/lookup/InstanceContent.html[InstanceContent]``  a fim de manipular dinamicamente alterações ao conteúdo de Pesquisa.


[start=1]
1. Expanda o projeto MyEditor e abra o formulário  ``MyEditor``  na visualização Desenho do editor.

[start=2]
1. Arraste um botão para o formulário e defina o texto do botão como "Substituir".

[start=3]
1. Clique com o botão direito do mouse e escolha Eventos > Ações > actionPerformed para criar um método do manipulador de eventos para o botão e abrir o formulário no editor de código-fonte.

[start=4]
1. Adicione o campo  ``final``  a seguir para a classe.

[source,java]
----

public class MyEditor extends TopComponent {
    *private final InstanceContent content = new InstanceContent();*
----

Para obter benefícios do  ``InstanceContent``  será necessário utilizar  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util-lookup/org/openide/util/lookup/AbstractLookup.html#AbstractLookup%28org.openide.util.lookup.AbstractLookup.Content%29[AbstractLookup]``  em vez de  ``Lookup``  no construtor.


[start=5]
1. Modifique o corpo do método do manipulador de eventos  ``jButton1ActionPerformed``  para ter a seguinte aparência ao copiar as linhas do construtor de classe e adicionar a chamada para  ``content.set`` .

[source,java]
----

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
    *APIObject obj = new APIObject();
    jTextField1.setText ("APIObject #" + obj.getIndex());
    jTextField2.setText ("Created: " + obj.getDate());
    setDisplayName ("MyEditor " + obj.getIndex());
    content.set(Collections.singleton (obj), null);*
}
----


[start=6]
1. Modifique o construtor para remover as linhas que foram copiadas para o manipulador de eventos, altere  ``associateLookup``  para utilizar  ``AbstractLookup``  e adicione  ``jButton1ActionPerformed(null);`` . O construtor deveria ter a seguinte aparência.

[source,java]
----

public MyEditor() {
    initComponents();
    *associateLookup(new AbstractLookup(content));
    jButton1ActionPerformed(null);*
}
----

Foi adicionado  ``jButton1ActionPerformed(null);``  ao construtor para assegurar que o componente será inicializado quando criado.


[start=7]
1. Corrija as importações e salve as alterações.

Ao executar o projeto da suíte de módulos novamente, será possível visualizar o novo botão em cada componente MyEditor. Ao clicar no botão, o número do índice no texto será aumentado. O rótulo na janela MyViewer também será atualizada para corresponder ao novo valor.

Este tutorial demonstrou como criar e executar uma suíte de módulos da plataforma NetBeans, que você criou a partir de um arquetipo Maven. Você viu como a suíte de módulos são estruturadas e como configurar um módulo POM para especificar os pacotes públicos. Também aprendeu como modificar o projeto POM principal para especificar o destino da instalação do NetBeans, para que o comando Executar no IDE instale a suíte e inicie uma nova instância da Plataforma. Para mais exemplos sobre como construir aplicativos e módulos na Plataforma NetBeans, consulte os tutoriais listados na  link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[Trilha do aprendizado do NetBeans].


== Consulte também

Para mais informações sobre como criar e desenvolver na Plataforma NetBeans, consulte os recursos a seguir.

*  link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[Trilha do aprendizado da plataforma NetBeans]
*  link:https://netbeans.apache.org/wiki/[FAQ Desenvolvedor NetBeans]
*  link:http://bits.netbeans.org/dev/javadoc/[Javadoc da API da NetBeans ]

Se você tiver qualquer dúvida sobre a Plataforma NetBeans, sinta-se a vontade para escrever para a lista de correspondência, dev@platform.netbeans.org, ou consulte o  link:https://mail-archives.apache.org/mod_mbox/netbeans-dev/[arquivo de lista de correspondência NetBeans].