netbeans.apache.org/src/old_content/content/tutorials/67/nbm-filetype_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.
//

= Tutorial de integração de tipo de arquivo
:jbake-type: platform_tutorial
:jbake-tags: tutorials 
:jbake-status: published
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:icons: font
:experimental:
:description: Tutorial de integração de tipo de arquivo - Apache NetBeans
:keywords: Apache NetBeans Platform, Platform Tutorials, Tutorial de integração de tipo de arquivo

Este tutorial mostra como gravar um módulo que permite que o IDE, ou qualquer outro aplicativo construído na Plataforma NetBeans, reconheça um novo tipo de arquivo.

*Observação:* este documento usa a versão NetBeans IDE 6.5. Se você estiver usando o NetBeans IDE 6.x, consulte  link:60/nbm-filetype_pt_BR.html[a versão 6.1 deste documento].









== Introdução à integração do tipo de arquivo

Os tipos de arquivo reconhecidos no IDE possuem seus próprios ícones, itens de menu e comportamento. Os "arquivos" mostrados são  ``FileObjects``  - wrappers em torno de  ``java.io.File``  ou, no caso dos arquivos de configuração, geralmente wrappers em torno dos dados armazenados de outra maneira, como em arquivos XML em módulos. O que você _vê_, na verdade, são  ``nós`` , que fornecem funcionalidade como ações e nomes localizados a objetos como arquivos. Entre os  ``nós``  e os  ``FileObjects``  estão os  ``DataObjects`` . Um  ``DataObject``  é parecido com um  ``FileObject`` , só que ele sabe qual tipo de arquivo está sendo mostrado e geralmente há tipos diferentes de  ``DataObject``  para arquivos com extensões diferentes e arquivos XML com namespaces diferentes. Cada  ``DataObject``  é fornecido por um módulo diferente, cada um implementando suporte para um ou mais tipos de arquivos. Por exemplo, o módulo Imagem permite que sejam reconhecidos e abertos arquivos  ``.gif``  e  ``.png`` .

Um módulo que reconhece um tipo de arquivo instala um  ``DataLoader`` : uma fábrica para um  ``DataObject``  específico de um tipo de arquivo. Quando uma pasta é expandida, o IDE pergunta a cada  ``DataLoader``  conhecido, "Você sabe o que é isto?" O primeiro que responder "Sim" cria o  ``DataObject``  para o arquivo. Para realmente exibir algo para cada arquivo, o sistema chama  ``DataObject.getNodeDelegate()``  para cada  ``DataObject``  e os  ``nós``  são o que você vê na verdade no IDE.

Abaixo, o diagrama à esquerda mostra o que cada item mencionado acima disponibiliza:


image::images/filetype_diagram-dataobject2.png[]

Neste tutorial, você criará um módulo para instalar um  ``DataLoader``  para arquivos "Abc" imaginários (extensão de arquivo  ``.abc`` ). Por padrão, um arquivo com a extensão "abc" é tratado como qualquer outro arquivo que o IDE não reconheça: ele é tratado como um arquivo de texto e, como resultado, o IDE fornece a mesma funcionalidade para os arquivos Abc que fornece para os arquivos de texto. Após ter criado o módulo, você saberá como aprimorá-lo com funcionalidades que estarão disponíveis somente para arquivos Abc. Quando você concluir o ciclo de desenvolvimento, poderá permitir facilmente que outras pessoas utilizem o seu módulo; o IDE permite que você crie um binário que pode ser enviado para outras pessoas, que poderão instalá-lo através da Central de Atualizações.


== Criando o projeto do módulo

Nesta seção, usaremos um assistente para criar a estrutura de código-fonte que todo módulo NetBeans precisa. A estrutura do código-fonte consiste em determinadas pastas em locais específicos e em um conjunto de arquivos que sempre são necessários. Por exemplo, cada módulo NetBeans requer uma pasta  ``nbproject`` , que contém os metadados do projeto, e um arquivo  ``layer.xml`` , para registro de declaração de itens como janelas e botões da barra de ferramentas.


[start=1]
1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Em Categorias, selecione Módulos do NetBeans. Em Projetos, selecione Módulo e clique em Próximo.

[start=2]
1. No painel Nome e localização, digite  ``AbcFileType``  em Nome do projeto. Altere a Localização do projeto para qualquer diretório no computador, como  ``c:\meusmodulos`` . Deixe o botão de opção Módulo independente selecionado. O painel agora deve ter esta aparência:


image::images/filetype_65-projectwizard1.png[]

Clique em Próximo.


[start=3]
1. No painel Configuração básica de módulos, digite  ``org.myorg.abcfiletype``  como o Nome base de código. Adicione espaços ao Nome de exibição do módulo sugerido, para que ele seja alterado para  ``Tipo de arquivo Abc`` . Marque a caixa de verificação "Gerar camada XML" e deixe o pacote de localização e a camada XML onde estão, para que eles sejam armazenados em um pacote com o nome  ``org/myorg/abcfiletype`` . O painel agora deve ter esta aparência:


image::images/filetype_65-projectwizard2.png[]


[start=4]
1. Clique em Terminar.

O IDE cria o projeto  ``Tipo de arquivo Abc`` . 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 ver a estrutura lógica na janela Projetos (Ctrl-1) e a estrutura de arquivos na janela Arquivos (Ctrl+2). Por exemplo, a janela Projetos agora deve ter esta aparência:


image::images/filetype_65-projectswindow1.png[] 


== Reconhecendo arquivos Abc

Nesta seção, usaremos um assistente para criar as classes necessárias para reconhecer arquivos Abc como sendo distintos de todos os outros. Conforme discutido no início deste tutorial, precisamos de um objeto de dados e um carregador de dados, assim como de um solucionador de tipo MIME e entradas de registro no arquivo  ``layer.xml`` , para fazer isso. O Assistente de novo tipo de arquivo criará tudo isso.


[start=1]
1. Clique com o botão direito do mouse no nó do projeto e escolha Novo > Tipo de arquivo.

[start=2]
1. No Painel de reconhecimento de arquivos, faça o seguinte:

* Digite  ``text/x-abc``  na caixa de edição Tipo MIME.
* Digite  ``.abc .ABC``  na caixa de edição Por extensão de nome de arquivo.

O Painel de reconhecimento de arquivos agora deve ter esta aparência:


image::images/filetype_60-filewizard1.png[]

Observe o seguinte sobre os campos no Painel de reconhecimento de arquivos:

* *Tipo MIME.* Especifica o tipo MIME exclusivo do objeto de dados.
* por
* *Extensão de nome de arquivo.* Especifica uma ou mais extensões que o IDE irá reconhecer como pertencente ao tipo de MIME determinado. A extensão do arquivo pode opcionalmente ser precedida por um ponto. Os separadores são vírgulas, espaços ou ambos. Portanto, todos os exemplos a seguir são válidos:

*  ``.abc,.def`` 
*  ``.abc .def`` 
*  ``abc def`` 
*  ``abc,.def ghi, .wow`` 

Vamos imaginar que os arquivos Abc diferenciem maiúsculas de minúsculas. Por esse motivo, você especificará _dois_ tipos MIME neste tutorial— ``.abc``  e  ``.ABC`` .

* *Elemento raiz XML.* Especifica um único namespace que distingue um tipo de arquivo XML de todos os outros tipos de arquivos XML. Como muitos arquivos XML possuem a mesma extensão ( ``xml`` ), o IDE faz a distinção entre os arquivos XML através de seus elementos raiz XML. Mais especificamente, o IDE pode distinguir entre namespaces e o primeiro elemento XML em arquivos XML. Você pode usar isto para, por exemplo, distinguir entre um descritor de deployment JBoss e um descritor de deployment WebLogic. Após ter feito essa distinção, você poderá certificar-se de que os itens de menu adicionados ao menu contextual do descritor de deployment JBoss não estão disponíveis no descritor de deployment WebLogic. Para obter um exemplo, consulte o  link:nbm-palette-api2.html[Tutorial do módulo da paleta de componentes do NetBeans].

Clique em Próximo.


[start=3]
1. No painel Nome e localização, digite  ``Abc``  como o Prefixo do nome da classe e vá para qualquer arquivo de imagem de 16 x 16 pixels como o ícone do novo tipo de arquivo, conforme mostrado abaixo.


image::images/filetype_65-filewizard2.png[]

*Observação:* você pode usar qualquer ícone. Se desejar, você pode clicar neste e salvá-lo localmente e depois especificá-lo na etapa do assistente acima: 
image::images/filetype_Datasource.gif[]


[start=4]
1. Clique em Terminar.

A janela Projetos agora deve ter esta aparência:


image::images/filetype_65-projectswindow2.png[]

Cada um dos arquivos recém-gerados é brevemente apresentado:

* *AbcDataObject.java.* Inclui um  ``FileObject`` . DataObjects são produzidos por DataLoaders. Para obter mais informações, consulte  link:https://netbeans.apache.org/wiki/devfaqdataobject[O que é um DataObject?].
* *AbcResolver.xml.* Mapeia as extensões  ``.abc``  e  ``.ABC``  para o tipo de MIME. O  ``AbcDataLoader``  reconhece somente o tipo MIME; ele não conhece a extensão de arquivo.
* *AbcTemplate.abc.* Fornece a base para um modelo de arquivo registrado no  ``layer.xml``  de forma que seja instalado na caixa de diálogo Novo arquivo como um novo modelo.
* *AbcDataObjectTest.java.* Classe de teste JUnit para  ``DataObject`` .

No arquivo  ``layer.xml`` , você deve ver o seguinte:


[source,xml]
----

<folder name="Loaders">
    <folder name="text">
        <folder name="x-abc">
            <folder name="Actions">
                <file name="org-myorg-abcfiletype-MyAction.shadow">
                    <attr name="originalFile" stringvalue="Actions/Edit/org-myorg-abcfiletype-MyAction.instance"/>
                    <attr name="position" intvalue="600"/>
                </file>
                <file name="org-openide-actions-CopyAction.instance">
                    <attr name="position" intvalue="100"/>
                </file>
                <file name="org-openide-actions-CutAction.instance">
                    <attr name="position" intvalue="200"/>
                </file>
                <file name="org-openide-actions-DeleteAction.instance">
                    <attr name="position" intvalue="300"/>
                </file>
                <file name="org-openide-actions-FileSystemAction.instance">
                    <attr name="position" intvalue="400"/>
                </file>
                <file name="org-openide-actions-OpenAction.instance">
                    <attr name="position" intvalue="500"/>
                </file>
                <file name="org-openide-actions-PropertiesAction.instance">
                    <attr name="position" intvalue="700"/>
                </file>
                <file name="org-openide-actions-RenameAction.instance">
                    <attr name="position" intvalue="800"/>
                </file>
                <file name="org-openide-actions-SaveAsTemplateAction.instance">
                    <attr name="position" intvalue="900"/>
                </file>
                <file name="org-openide-actions-ToolsAction.instance">
                    <attr name="position" intvalue="1000"/>
                </file>
                <file name="sep-1.instance">
                    <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
                    <attr name="position" intvalue="1100"/>
                </file>
                <file name="sep-2.instance">
                    <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
                    <attr name="position" intvalue="1200"/>
                </file>
                <file name="sep-3.instance">
                    <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
                    <attr name="position" intvalue="1300"/>
                </file>
                <file name="sep-4.instance">
                    <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
                    <attr name="position" intvalue="1400"/>
                </file>
            </folder>
            <folder name="Factories">
                <file name="AbcDataLoader.instance">
                    <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/myorg/abcfiletype/Datasource.gif"/>
                    <attr name="dataObjectClass" stringvalue="org.myorg.abcfiletype.AbcDataObject"/>
                    <attr name="instanceCreate" methodvalue="org.openide.loaders.DataLoaderPool.factory"/>
                    <attr name="mimeType" stringvalue="text/x-abc"/>
                </file>
            </folder>
        </folder>
    </folder>
</folder>
----



== Instalando e testando a funcionalidade

Agora vamos instalar o módulo e usar a funcionalidade básica criada até o momento. O IDE utiliza um script de construção Ant para construir e instalar seu módulo. O script de construção é criado quando o projeto é criado.


[start=1]
1. Na janela Projetos, clique com o botão direito do mouse no projeto  ``Tipo de arquivo Abc``  e escolha Instalar/recarregar no IDE de desenvolvimento.

O módulo é construído e instalado no IDE em execução atualmente.


[start=2]
1. Crie qualquer tipo de aplicativo no IDE.

[start=3]
1. Clique com o botão direito do mouse no nó do aplicativo e escolha Novo > Outro. Na categoria Outro, um modelo fictício está disponível para o novo tipo de arquivo:


image::images/filetype_60-action4.png[]


[start=4]
1. Caso você deseje fornecer código padrão através do modelo fictício, adicione o código ao arquivo  ``AbcTemplate.abc``  que o Assistente de novo tipo de arquivo criou para você.



== Criando recursos para arquivos Abc

Agora que a Plataforma NetBeans consegue distinguir arquivos Abc de todos os outros tipos de arquivos, é hora de adicionar recursos especificamente para esses tipos de arquivos. Nesta seção, adicionaremos um item de menu no menu contextual de clique com o botão direito do nó do arquivo na janela do explorer, como na janela Projetos, e permitiremos que o arquivo seja aberto em uma janela, em vez de em um editor.


=== Adicionando uma ação

Nesta subseção, usaremos o Assistente de nova ação para criar uma classe Java que realizará uma ação para o nosso tipo de arquivo. O assistente também registrará a classe no arquivo  ``layer.xml``  de forma que o usuário possa chamar a ação do menu contextual de clique com o botão direito do nó do tipo de arquivo em uma janela do explorer.


[start=1]
1. Clique com o botão direito do mouse no nó do projeto e escolha Nova > Ação

[start=2]
1. No painel Tipo de ação, clique em Habilitada condicionalmente. Digite  ``AbcDataObject`` , que é o nome do objeto de dados gerado acima pelo Assistente de novo tipo de arquivo, conforme mostrado abaixo:


image::images/filetype_60-action1.png[]

Clique em Próximo.


[start=3]
1. No painel Registro de 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 Item de menu de conteúdo de tipo de arquivo. Na lista suspensa Tipo de conteúdo, selecione o tipo MIME especificado acima no Assistente de novo tipo de arquivo, conforme mostrado abaixo:


image::images/filetype_60-action2.png[]

Observe que você pode definir a posição do item de menu e que pode separar o item de menu do item antes e depois dele. Clique em Próximo.


[start=4]
1. No painel Novo e localização, digite  ``MyAction``  como o Nome da classe e  ``My Action``  como o Nome de exibição. Os itens de menu fornecidos por menus contextuais não exibem ícones. Assim, clique em Terminar e  ``MyAction.java``  será adicionado ao pacote  ``org.myorg.abcfiletype`` .

[start=5]
1. No Editor de código-fonte, adicione código ao método  ``performAction``  da ação:

[source,java]
----

protected void performAction(Node[] activatedNodes) {
	AbcDataObject d = (AbcDataObject) activatedNodes[0].getCookie(AbcDataObject.class);
	FileObject f = d.getPrimaryFile();
	String displayName = FileUtil.getFileDisplayName(f);
	String msg = "I am " + displayName + ". Hear me roar!"; 
        NotifyDescriptor nd = new NotifyDescriptor.Message(msg);
        DialogDisplayer.getDefault().notify(nd);
}
----

Pressione Ctrl-Shift-I. O IDE automaticamente adiciona comandos import à parte superior da classe. Ainda há algum código sublinhado em vermelho, para indicar que nem todos os pacotes necessários estão no classpath. Clique com o botão direito do mouse no projeto do projeto, escolha Propriedades e clique em Bibliotecas na caixa de diálogo Propriedades do projeto. Clique em Adicionar na parte superior do painel Bibliotecas e adicione a API das caixas de diálogo.

Na classe  ``MyAction.java`` , pressione Ctrl-Shift-I novamente. O sublinhado vermelho desaparece porque o IDE encontra os pacotes necessários na API das caixas de diálogo.


[start=6]
1. No nó Arquivos importantes, expanda Camada XML. Os dois nós  ``<esta camada>``  e  ``<esta camada no contexto>`` , junto com seus subnós, formam o navegador  link:https://netbeans.apache.org/tutorials/nbm-glossary.html[Sistema de arquivos do sistema]. Expanda  ``<esta camada>`` , expanda  ``Carregadores`` , continue expandindo nós até ver a  ``Ação``  criada acima.

[start=7]
1. Arraste e solte  ``Minha ação``  para que ela apareça abaixo da ação  ``Abrir`` , como mostrado abaixo:


image::images/filetype_60-action3.png[]

Como você pode ver nas últimas duas etapas, o Navegador Sistema de arquivos do sistema pode ser usado para reorganizar rapidamente a seqüência de itens registrados no sistema de arquivos do sistema.


[start=8]
1. Instale o módulo novamente, como foi feito na seção anterior.

[start=9]
1. Crie um arquivo ABC e clique com o botão direito do mouse no nó do arquivo em uma das exibições do Explorer, como na janela Projetos ou a janela Favoritos.

Observe que o arquivo Abc possui o ícone atribuído a ele em seu módulo e que a lista de ações definidas no arquivo  ``layer.xml``  está disponível do menu contextual de clique com o botão direito do mouse:


image::images/filetype_60-dummytemplate.png[]


[start=10]
1. Escolha o novo item de menu, o nome e a localização do arquivo Abc são mostrados:


image::images/filetype_60-information.png[]


=== Abrindo o arquivo em uma janela

Por padrão, quando o usuário abre um arquivo do tipo definido neste tutorial, o arquivo é aberto em um editor básico. Entretanto, algumas vezes você pode querer criar uma representação visual do arquivo, e permitir que o usuário arraste e solte widgets na representação visual. A primeira etapa na criação dessa interface do usuário é permitir que o usuário abra o arquivo em uma janela. Esta subseção mostra como fazê-lo.


[start=1]
1. Clique com o botão direito do mouse no nó do projeto e escolha Novo > Componente da janela. Use essas configurações:


image::images/filetype_65-topc-1.png[]


[start=2]
1. Clique em Próximo e digite "Abc" como o prefixo do nome da classe:


image::images/filetype_65-topc-2.png[]


[start=3]
1. Altere  ``DataObject``  para usar OpenSupport em vez de DataEditorSupport, alterando o construtor de  ``DataObject``  da seguinte maneira:


[source,java]
----

public AbcDataObject(FileObject pf, AbcDataLoader loader) 
        throws DataObjectExistsException, IOException {

    super(pf, loader);
    CookieSet cookies = getCookieSet();
    //cookies.add((Node.Cookie) DataEditorSupport.create(this, getPrimaryEntry(), cookies));
    cookies.add((Node.Cookie) new AbcOpenSupport(getPrimaryEntry()));
              
}
----


[start=4]
1. Crie a classe  ``OpenSupport`` :


[source,java]
----

class AbcOpenSupport extends OpenSupport implements OpenCookie, CloseCookie {

    public AbcOpenSupport(AbcDataObject.Entry entry) {
        super(entry);
    }

    protected CloneableTopComponent createCloneableTopComponent() {
        AbcDataObject dobj = (AbcDataObject) entry.getDataObject();
        AbcTopComponent tc = new AbcTopComponent();
        tc.setDisplayName(dobj.getName());
        return tc;
    }
 
}
----


[start=5]
1. Ajuste o TopComponent para estender CloneableTopComponent, em vez de TopComponent. Defina o modificador de classe do TopComponent e o modificador de seu construtor, como público em vez de privado.

Instale o módulo novamente e, quando um arquivo Abc for aberto, a classe OpenSupport lidará com a abertura de forma que o arquivo seja aberto no TopComponent em vez de no editor básico que o DataEditorSupport oferece:


image::images/filetype_65-topc-3.png[]

O  link:https://netbeans.apache.org/tutorials/60/nbm-visual_library_pt_BR.html[tutorial do NetBeans Visual Library 6.0] fornece um exemplo do que você pode fazer para desenvolver o TopComponent ainda mais para que ele exiba o conteúdo de um arquivo que corresponda ao tipo de arquivo definido neste tutorial.



== Criando um binário de módulo que pode ser compartilhado

Agora que o módulo está concluído, você pode permitir que ele seja utilizado por outras pessoas. Para isso, você precisa criar um arquivo "NBM" (módulo NetBeans) binário e distribui-lo.


[start=1]
1. Na janela Projetos, clique com o botão direito do mouse no projeto  ``Tipo de arquivo Abc``  e escolha Criar NBM.

O arquivo NBM é criado e você pode visualizá-lo na janela Arquivos (Ctrl+-2):


image::images/filetype_60-shareable-nbm.png[]


[start=2]
1. Disponibilize-o para outras pessoas, por exemplo, através do  link:http://plugins.netbeans.org/PluginPortal/[Portal de plug-in do NetBeans]. O destinatário deve usar o Gerenciador de plug-ins (Ferramentas > Plug-ins) para instalá-lo.


link:http://netbeans.apache.org/community/mailing-lists.html[Envie-nos seus comentários]



== Próximas etapas

Para obter mais informações sobre a criação e o desenvolvimento de módulos do NetBeans, consulte os seguintes recursos:

*  link:https://netbeans.apache.org/platform/index.html[Página inicial da Plataforma NetBeans ]
*  link:https://bits.netbeans.org/dev/javadoc/[Lista de APIs do NetBeans (Versão de desenvolvimento atual)]
*  link:https://netbeans.apache.org/tutorials[Outros tutoriais relacionados]