blob: b8c12a6f34101ee3122649c0f5cd7ac341ca585c [file] [log] [blame]
//
// 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.
//
= Início rápido de plug-in do NetBeans
:jbake-type: platform_tutorial
:jbake-tags: tutorials
:jbake-status: published
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:icons: font
:experimental:
:description: Início rápido de plug-in do NetBeans - Apache NetBeans
:keywords: Apache NetBeans Platform, Platform Tutorials, Início rápido de plug-in do NetBeans
Bem-vindo ao desenvolvimento do plug-in do NetBeans!
Este tutorial fornece uma introdução muito simples e rápida ao fluxo de trabalho do desenvolvimento do plug-in do NetBeans orientando-o através da criação de uma nova barra de ferramentas para o NetBeans IDE. Após concluir este tutorial, você terá adquirido um conhecimento geral sobre como criar, construir e instalar plug-ins do NetBeans IDE.
Após concluir este tutorial, você pode passar para a link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[trilha do aprendizado da plataforma NetBeans] A trilha do aprendizado fornece tutoriais abrangentes que destacam uma ampla gama de APIs do NetBeans para uma variedade de tipos de aplicativos. Se não desejar criar um aplicativo "Hello world", ignore este tutorial e vá direito para a trilha do aprendizado.
*Observação:* este documento usa a versão NetBeans IDE 6.8. Se você estiver usando uma versão anterior, veja link:67/nbm-google_pt_BR.html[a versão 6.7 deste documento].
Opcionalmente, para fins de solução de problemas, você pode link:http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=13794[baixar a amostra completa] e inspecionar os códigos-fonte.
A barra de ferramentas criada neste tutorial terá esta aparência:
image::images/google_60_googlebar-2.png[]
Quando o usuário pressionar Enter na barra de ferramentas acima, o navegador padrão do IDE será aberto e o texto na barra de ferramentas será enviado para uma pesquisa do Google, com os resultados disponíveis no navegador aberto. Para criar esta barra de ferramentas, você usará as link:http://bits.netbeans.org/dev/javadoc/[APIs do NetBeans] para aprimorar o conjunto de recursos do IDE. Especificamente, crie uma ação que seja chamada por um botão na barra de ferramentas. Em seguida, crie um Swing JPanel contendo ``JLabel`` e ``JTextField`` como componentes de GUI. Finalmente, você irá implementar o link:http://bits.netbeans.org/dev/javadoc/org-openide-util/org/openide/util/actions/Presenter.Toolbar.html[ ``Presenter.Toolbar`` ] para retornar o JPanel para que ele seja exibido na barra de ferramentas ao invés de no botão.
== Configurando o projeto de módulo
Ao desenvolver o módulo, verifique se a estrutura do projeto está configurada corretamente. O NetBeans IDE oferece um assistente para Projeto de módulo que configura todos os arquivos básicos necessários para um módulo.
[start=1]
1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Em Categorias, selecione Módulos do NetBeans. Em Projetos, selecione Módulo . Clique em Próximo.
[start=2]
1. No painel Nome e localização, digite ``GoogleToolbar`` no campo Nome do projeto. Altere Local do projeto para qualquer diretório no computador. Deixe marcadas a opção Módulo independente e a caixa de verificação Definir como projeto principal. Clique em Próximo.
[start=3]
1. No painel Configuração básica de módulos, digite ``org.myorg.googletoolbar`` no Nome base de código.
[start=4]
1. Selecione "Gerar camada XML". Deixe as localizações do pacote de localizações e a camada XML, de modo que sejam armazenados em um pacote com o nome ``org/myorg/googletoolbar`` . Clique em Terminar.
O IDE cria o projeto ``GoogleToolbar`` . O projeto contém todos os metadados de projeto e fontes, como o script de construção Ant do projeto. O projeto se abre no IDE. Você pode visualizar a estrutura lógica na janela Projetos (Ctrl+1) e a estrutura de arquivos na janela Arquivos (Ctrl+2).
Se você expande o nó Arquivos importantes, poderá abrir o Module Manifest, que tem este conteúdo:
[source,java]
----
Manifest-Version: 1.0
OpenIDE-Module: org.myorg.googletoolbar
OpenIDE-Module-Layer: org/myorg/googletoolbar/layer.xml
OpenIDE-Module-Localizing-Bundle: org/myorg/googletoolbar/Bundle.properties
OpenIDE-Module-Specification-Version: 1.0
----
Para obter detalhes sobre estas chaves do manifeste específicas do NetBeans, leia a descrição Javadoc do link:http://bits.netbeans.org/dev/javadoc/org-openide-modules/org/openide/modules/doc-files/api.html[API do módulo NetBeans].
== Codificando o módulo da
Para codificar o módulo, você precisa completar as seguintes etapas:
* <<creating-action,Criando a ação>>
* <<creating-panel,Criando o JPanel>>
* <<resolving-errors,Resolvendo erros>>
* <<overriding,Substituindo getToolbarPresenter()>>
=== Criando a ação
[start=1]
1. Clique com o botão direito do mouse no nó do projeto e escolha Nova > Ação (se Ação não estiver exibida, acesse-a escolhendo Outra, em seguida, no assistente para Novo arquivo em Categorias, selecione Desenvolvimento de módulo). Clique em Próximo.
[start=2]
1. No painel Tipo de ação, mantenha a configuração padrão, que permitirá que o IDE crie uma ação que subclassifique ``ActionListener`` , como mostrado abaixo:
image::images/google_65_action-wiz-1.png[] Clique em Próximo.
[start=3]
1. No painel Registro com GUI, selecione Editar na lista suspensa Categoria. A lista suspensa Categoria controla onde uma ação é mostrada no editor de atalhos de teclado no IDE. Em seguida, desmarque Item de menu global e selecione Botão da barra de ferramentas global. Na lista suspensa Barra de ferramentas, selecione Arquivo, em seguida, na lista suspensa Posição, selecione _qualquer posição na lista suspensa_, como a mostrada abaixo:
image::images/google_65_action-wiz-2.png[] Clique em Próximo.
[start=4]
1.
No painel Novo e localização, digite ``GoogleAction`` como o Nome da classe e ``Google Action`` como o Nome de exibição. Vá para um ícone que tenha uma dimensão de 16x16 pixels. Na verdade, você não usará o ícone - em vez disso, exibirá o formulário JPanel que criará na próxima seção. Entretanto, o assistente para Nova ação requer que você especifique um ícone. Portanto, o ícone poderia ser de qualquer dimensão, já que você não o usará. Clique em Terminar.
*Observação:* ``GoogleAction.java`` é adicionado ao pacote ``org.myorg.googletoolbar`` na janela Projetos.
=== Criando o JPanel
Nesta seção, você criará um JPanel que será a barra de ferramentas exibida como parte da principal barra de ferramentas do aplicativo.
[start=1]
1. Clique com o botão direito do mouse no nó do projeto e escolha Novo > Outro. Em Categorias, selecione Formulários GUI Swing. Em Projetos, selecione Formulário JPanel. Clique em Próximo.
[start=2]
1. No painel Nome e localização, digite ``GooglePanel`` como o Nome da classe e selecione o painel na lista suspensa. Clique em Terminar. ``GooglePanel.java`` é adicionado ao pacote e é aberto na visualização Design no Editor de código-fonte.
[start=3]
1. Coloque o cursor no canto inferior direito do JPanel, em seguida, selecione o JPanel e arraste o cursor para redimensioná-lo, de forma que sua largura e cumprimento fiquem parecidos com os de uma barra de ferramentas, como mostrado abaixo:
image::images/google_60_jpanel-2.png[]
[start=4]
1. Arraste um item JTextField e um item JLabel da Paleta (Ctrl+Shift+8) diretamente para o JPanel, em seguida, redimensione o JPanel e os outros dois itens, para que eles se encaixem. Finalmente, clique no JLabel e altere o texto para ``Google:`` e, em seguida, exclua o texto padrão no JTextField. Seu JPanel agora deve se parecer com a imagem mostrada abaixo:
image::images/google_60_jpanel-3.png[]
[start=5]
1. Verifique se o Inspetor de propriedades está aberto (Janela > Navegação > Inspetor), em seguida, clique com o botão direito do mouse em JTextField e escolha Eventos > Tecla > keyTyped. Isso gera um método ``jTextField1KeyTyped()`` no código-fonte ``GooglePanel.java`` , que é exibido no Editor de código-fonte, como mostrado abaixo:
image::images/google_60_jpanel-4.png[]
[start=6]
1. No Editor de código-fonte, na visualização Código-fonte do ``GooglePanel.java`` , preencha o método ``jTextField1KeyTyped()`` , da seguinte forma (texto inserido mostrado em *negrito*):
[source,java]
----
private void jTextField1KeyTyped(java.awt.event.KeyEvent evt) {
*int i = evt.getKeyChar();
if (i==10){//The ENTER KEY
// we display the google url.
try{
URLDisplayer.getDefault().showURL
(new URL("http://www.google.com/search?hl=en&amp;q="+jTextField1.getText()+"&amp;btnG=Google+Search"));
} catch (Exception eee){
return;//nothing much to do
}
}*
}
----
Se precisar, clique com o botão direito do mouse no Editor de código-fonte e escolha Formatar (Alt+Shift+F).
=== Resolvendo erros
Observe que uma linha de código está sublinhada em vermelho, indicando erros. Isso acontece porque pacotes necessários ainda não foram importados. Coloque o cursor sobre o ícone da lâmpada exibido na coluna imediatamente à esquerda da linha vermelha de ``URLDisplayer`` . É exibida uma dica de ferramenta, indicando o motivo do erro:
image::images/google_60_tooltip.png[]
Para resolver isso, você precisa disponibilizar a classe `` link:http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/HtmlBrowser.URLDisplayer.html[HtmlBrowser.URLDisplayer]`` , incluída no pacote link:http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/package-summary.html[ ``org.openide.awt`` ], para o seu projeto. Para isso, execute as seguintes etapas:
[start=1]
1. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades. Na caixa de diálogo Propriedades do projeto, selecione Bibliotecas sob o título Categorias. Em seguida, em Dependências de módulo, clique no botão Adicionar. A caixa de diálogo Adicionar dependência de módulo é exibida.
[start=2]
1. Na caixa de texto do filtro exibida na parte inferior da caixa de diálogo Adicionar dependência de módulo, comece a digitar `` link:http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/HtmlBrowser.URLDisplayer.html[URLDisplayer]`` e observe que a seleção dos módulos retornados se estreita até que somente a listagem restante seja a link:http://bits.netbeans.org/dev/javadoc/org-openide-awt/overview-summary.html[API de utilitários de IU]:
image::images/google_60_add-module-dependency.png[] Clique em OK, em seguida, clique em OK novamente para sair da caixa de diálogo Propriedades do projeto.
[start=3]
1. Clique com o botão direito do mouse no Editor de código-fonte e escolha Corrigir importações (Alt+Shift+F). A caixa de diálogo Corrigir todas as importações é exibida, listando os caminhos sugeridos para classes não reconhecidas:
image::images/google_60_fix-all-imports.png[] Clique em OK. O IDE cria as instruções de importação seguintes para ``GooglePanel.java`` :
[source,java]
----
import java.net.URL;
import link:http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/HtmlBrowser.URLDisplayer.html[org.openide.awt.HtmlBrowser.URLDisplayer];
----
Observe também que todos os erros desaparecem do Editor de código-fonte.
=== Implementado o Presenter.Toolbar
Como o JPanel que acaba de ser criado é o componente real que irá exibir a barra de ferramentas do Google, é preciso implementar o `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util/org/openide/util/actions/Presenter.Toolbar.html[Presenter.Toolbar]`` para que seja exibido na barra de ferramentas. Em ``GoogleAction.java`` , faça o seguinte:
[start=1]
1. Abra ``GoogleAction.java`` e observe que possui este conteúdo:
[source,java]
----
package org.myorg.googletoolbar;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public final class GoogleAction implements ActionListener {
public void actionPerformed(ActionEvent e) {
// TODO implement action body
}
}
----
[start=2]
1. Altere a assinatura para que o `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util/org/openide/util/actions/Presenter.Toolbar.html[Presenter.Toolbar]`` também seja implementado, porque você deseja que a ação seja apresentada na barra de ferramentas.
[source,java]
----
package org.myorg.googletoolbar;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public final class GoogleAction implements Presenter.Toolbar, ActionListener {
Component comp = new GooglePanel();
@Override
public void actionPerformed(ActionEvent e) {
// TODO implement action body
}
@Override
public Component getToolbarPresenter() {
return comp;
}
}
----
[start=3]
1. Abra o arquivo ``layer.xml`` e você verá o seguinte:
[source,xml]
----
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE filesystem PUBLIC "-//NetBeans//DTD Filesystem 1.2//EN" "https://netbeans.org/dtds/filesystem-1_2.dtd">
<filesystem>
<folder name="Actions">
<folder name="File">
<file name="org-myorg-googletoolbar-GoogleAction.instance">
<attr name="SystemFileSystem.localizingBundle" stringvalue="org.myorg.googletoolbar.Bundle"/>
<attr name="delegate" newvalue="org.myorg.googletoolbar.GoogleAction"/>
<attr name="displayName" bundlevalue="org.myorg.googletoolbar.Bundle#CTL_GoogleAction"/>
<attr name="iconBase" stringvalue="org/myorg/googletoolbar/icon.png"/>
<attr name="instanceCreate" methodvalue="org.openide.awt.Actions.alwaysEnabled"/>
<attr name="noIconInMenu" stringvalue="false"/>
</file>
</folder>
</folder>
<folder name="Toolbars">
<folder name="File">
<file name="org-myorg-googletoolbar-GoogleAction.shadow">
<attr name="originalFile" stringvalue="Actions/File/org-myorg-googletoolbar-GoogleAction.instance"/>
<attr name="position" intvalue="0"/>
</file>
</folder>
</folder>
</filesystem>
----
[start=4]
1. O conteúdo mostrado acima foi criado pelo assistente de Nova ação. Exclua o atributo "instanceCreate", porque você não deseja criar uma instância de uma classe Ação, neste caso. Já que, aqui você deseja que um Jpanel apareça em seu lugar.
Nesta seção, você criou um JPanel que exibirá um JTextField e um JLabel. Se você pressionar Enter no JTextField, seu conteúdo será enviado para uma pesquisa no Google. O navegador de HTML será aberto e você verá o resultado da pesquisa no Google. A classe da ação é usada para integrar o JPanel na barra de ferramentas do aplicativo, como registrado no arquivo ``layer.xml`` .
== Compilando, instalando e usando o módulo
O NetBeans IDE usa um script de construção Ant para compilar e instalar seu módulo no IDE. O script de construção foi criado para você quando o projeto do módulo foi criado em <<creating-module-project,Configurando o projeto de módulo>> acima. Agora que o módulo está pronto para ser compilado e adicionado ao IDE, você pode usar o suporte a Ant do NetBeans IDE a fim fazê-lo:
[start=1]
1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto ``GoogleToolbar`` e escolha Executar. O módulo é construído e instalado em uma nova instância do IDE (por exemplo, a plataforma de destino). Por padrão, a plataforma de destino padrão é a versão do IDE em que você está trabalhando no momento. A plataforma de destino se abre, de modo que você possa experimentar o novo módulo.
[start=2]
1. Quando ele é instalado com êxito, o módulo adiciona um novo botão na barra de ferramentas Editar do IDE.
*Observação:* O botão da barra de ferramentas não exibe um ícone. Em vez disso, ele exibe o JPanel que você criou em <<creating-panel,Criando o JPanel>> acima:
image::images/google_60_googlebar.png[]
[start=3]
1. Digite uma string de pesquisa no campo de texto:
image::images/google_60_googlebar-2.png[]
[start=4]
1. Pressione Enter. O navegador padrão do IDE é iniciado, se você tiver definido um na janela Opções. A URL do Google e a sua string de pesquisa são enviadas para o navegador e uma pesquisa é realizada. Quando os resultados da pesquisa são retornados, você pode visualizá-los no navegador.
== Compartilhando o módulo
Agora que você construiu um módulo de trabalho que aprimora o IDE, por que não compartilhá-lo com outros desenvolvedores? O NetBeans IDE oferece uma forma fácil de criar um arquivo de módulo binário do NetBeans (.nbm), que é um meio universal de permitir que outros o experimentem em suas próprias versões do IDE (na verdade, isso é o que você fez em <<compiling,Compilando, instalando e usando o módulo>> acima).
Para criar um binário do módulo, faça o seguinte:
Na janela Projetos, clique com o botão direito do mouse no nó do projeto ``GoogleToolbar`` e escolha Criar NBM. O novo arquivo NBM é criado e você pode visualizá-lo na janela Arquivos (Ctrl+2):
image::images/google_60_create-nbm.png[]
link:http://netbeans.apache.org/community/mailing-lists.html[ Envie-nos seus comentários]
== Veja também
Isto conclui o Início rápido do plug-in do NetBeans. Este documento descreveu como criar um plug-in que adiciona uma barra de ferramentas do Google Search ao IDE. Para obter mais informações sobre a criação e o desenvolvimento de plug-ins, consulte os seguintes recursos:
* link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[Trilha do aprendizado da plataforma NetBeans]
* link:http://bits.netbeans.org/dev/javadoc/[Javadoc da API da NetBeans ]
* Classes do NetBeans API usadas neste tutorial:
* `` link:http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/HtmlBrowser.URLDisplayer.html[HtmlBrowser.URLDisplayer]``
* `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util/org/openide/util/actions/Presenter.Toolbar.html[Presenter.Toolbar]``