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

NOTE:  este documento usa a versão NetBeans IDE 6.5. Se você estiver utilizando 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ê realmente vê 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`` ). Como 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 a criação de 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, utilizaremos 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 códigos-fonte, 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, utilizaremos 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, para fazer isso 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`` . 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 gerará 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[]

*Nota:* você pode utilizar qualquer ícone com uma dimensão de 16x16 pixels. 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 utilizar 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 Executar.

Uma nova instância do IDE é iniciada, instalando o módulo nele próprio.


[start=2]
1. Utilize a caixa de diálogo Novo projeto (Ctrl-Shift-N) para criar 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 está disponível para trabalhar com o novo tipo de arquivo:


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

Complete o assistente e assim terá criado um modelo que pode ser utilizado para iniciar o trabalho do usuário com o tipo de arquivo fornecido.

Se você desejar fornecer código padrão através do modelo, adicione o código ao arquivo  ``AbcTemplate.abc``  que o assistente 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, utilizaremos 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 algum código ao método  ``actionPerformed``  da ação:

[source,java]
----

@Override
public void actionPerformed(ActionEvent ev) {
   FileObject f = context.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 nó 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 utilizado para reorganizar rapidamente a sequência de itens registrados no Sistema de arquivos do sistema.


[start=8]
1. Execute novamente o módulo, como fez na seção anterior.

[start=9]
1. Crie um arquivo ABC, utilizando o modelo mostrado na seção anterior, e clique com o botão direito do mouse no nó do arquivo de uma das visualizações do explorer, como a janela Projeto 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[]

Você agora sabe como criar uma nova ação que aparece no menu de contexto de um arquivo do tipo fornecido, na janela Projetos, janela Arquivos ou na janela Favoritos.


=== Abrindo o arquivo em uma janela

Como 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. Defina "editor" para Posição da janela e "Abrir na inicialização do aplicativo", como abaixo mostrado:


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[]

Clique em Terminar.


[start=3]
1. Altere  ``DataObject``  para utilizar  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-loaders/org/openide/loaders/OpenSupport.html[OpenSupport ]``  em vez de DataEditorSupport, alterando o construtor de  ``DataObject``  da seguinte maneira:

[source,java]
----

public AbcDataObject(FileObject pf, MultiFileLoader 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  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-loaders/org/openide/loaders/OpenSupport.html[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;
    }
 
}
----

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 depois, quando um arquivo Abc estiver aberto, a classe  ``OpenSupport `` lidará com a abertura de forma que o arquivo seja aberto no  ``TopComponent``  em vez de abrir no editor básico do  ``DataEditorSupport:`` 


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

O  link:https://netbeans.apache.org/tutorials/nbm-visual_library.html[tutorial do NetBeans Visual Library ] 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 uma janela de múltiplas visualizações

Agora que somos capazes de abrir um arquivo em uma janela, vamos tornar esta janela mais interessante. Iremos criar uma janela de múltiplas visualizações. A primeira aba de uma janela com múltiplas visualizações é normalmente utilizada para exibir uma representação visual do arquivo, enquanto a segunda aba normalmente mostra a visualização fonte. Mais do que duas abas podem ser fornecidas, cada uma fornecendo mais níveis de detalhes sobre o arquivo aberto.


[start=1]
1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades. Na caixa de diálogo Propriedades do projeto, escolha Bibliotecas, e clique em Adicionar. Defina uma dependência na " link:http://bits.netbeans.org/dev/javadoc/org-netbeans-core-multiview/overview-summary.html[Janela com múltiplas visualizações]". Clique em OK, em seguida, clique em OK novamente para sair da caixa de diálogo Propriedades do projeto.

[start=2]
1. Para cada aba que deseja criar na janela com múltiplas visualizações, crie uma classe que implemente  `` link:http://bits.netbeans.org/dev/javadoc/org-netbeans-core-multiview/org/netbeans/core/spi/multiview/MultiViewDescription.html[MultiViewDescription]``  e  ``Serializable`` .

Para os propósitos deste tutorial, comece por criar uma classe denominada  ``AbcMultiviewDescription1`` , implementando as classes especificadas:


[source,java]
----

public class AbcMultiviewDescription1 implements MultiViewDescription, Serializable {

    public int getPersistenceType() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public String getDisplayName() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public Image getIcon() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public HelpCtx getHelpCtx() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public String preferredID() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public MultiViewElement createElement() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

}
----

Na classe  ``AbcMultiviewDescription1``  acima, o método  ``createElement()``  retorna um MultiViewElement. O que você deseja retornar aqui é seu  ``TopComponent`` , o que faremos na próxima etapa.


[start=3]
1. Reescreva a assinatura da classe. Para fornecer um elemento de múltiplas visualizações para a descrição na etapa anterior, precisamos implementar  `` link:http://bits.netbeans.org/dev/javadoc/org-netbeans-core-multiview/org/netbeans/core/spi/multiview/MultiViewElement.html[MultiViewElement]`` :

[source,java]
----

public final class AbcTopComponent extends TopComponent implements MultiViewElement {
----

Na  ``TopComponent`` , você agora precisa excluir (colocar um comentário) os métodos  ``findInstance()`` ,  ``getPersistenceType()`` ,  ``writeReplace()``  e  ``preferredID()`` .


[start=4]
1. Para o momento, forneça implementações bem simples para cada um dos métodos necessários. Comece por definir uma nova  ``JToolbar``  acima da classe  ``TopComponent`` :

[source,java]
----

private JToolBar toolbar = new JToolBar();
----

A seguir, implemente os métodos como segue:


[source,java]
----

    public JComponent getVisualRepresentation() {
        return this;
    }

    public JComponent getToolbarRepresentation() {
        return toolbar;
    }

    public void setMultiViewCallback(MultiViewElementCallback arg0) {
    }

    public CloseOperationState canCloseElement() {
        return null;
    }

    public Action[] getActions() {
        return new Action[]{};
    }

    public Lookup getLookup() {
        return Lookups.singleton(this);
    }

    public void componentShowing() {
    }

    public void componentHidden() {
    }

    public void componentActivated() {
    }

    public void componentDeactivated() {
    }

    public UndoRedo getUndoRedo() {
        return UndoRedo.NONE;
    }
----


[start=5]
1. Agora você pode redefinir a  ``AbcMultiviewDescription1``  como segue:

[source,java]
----

public class AbcMultiviewDescription1 implements MultiViewDescription, Serializable {

    public int getPersistenceType() {
        return TopComponent.PERSISTENCE_ALWAYS;
    }

    public String getDisplayName() {
        return "Tab 1";
    }

    public Image getIcon() {
        return ImageUtilities.loadImage("/org/myorg/abcfiletype/Datasource.gif");
    }

    public HelpCtx getHelpCtx() {
        return null;
    }

    public String preferredID() {
       return "AbcMultiviewDescription1";
    }

    public MultiViewElement createElement() {
        return new AbcTopComponent();
    }

}
----


[start=6]
1. Altere o método  ``createCloneableTopComponent``  na classe  ``OpenSupport``  para abrir seu  ``TopComponent``  através da classe  ``MultiViewDescription``  acima criada:

[source,java]
----

protected CloneableTopComponent createCloneableTopComponent() {

    // Create an array of multiview descriptors:
    AbcMultiviewDescription1 firstTab = new AbcMultiviewDescription1();
    MultiViewDescription[] descriptionArray = { firstTab };

    // Create the multiview window:
    CloneableTopComponent tc = MultiViewFactory.createCloneableMultiView(descriptionArray, firstTab,  null);
    tc.setDisplayName(entry.getDataObject().getName());
    return tc;

}
----

O segundo argumento em  ``MultiViewFactory.createCloneableMultiView``  determina quais abas são abertas por padrão. Aqui está a  ``firstTab`` , a aba definida por  ``AbcMultiViewDescription1`` .


[start=7]
1. Instale e abra novamente o arquivo. Agora você tem uma janela com múltiplas visualizações com uma aba:


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

Agora você tem uma aba única em uma janela com múltiplas visualizações. Para cada aba adicional, crie uma nova classe  ``MultiviewDescription``  com um novo  ``TopComponent`` , e, em seguida, crie a instância da classe  ``MultiViewDescription``  na extensão  ``OpenSupport``  , como mostrado acima.


== Criando um binário de módulo compartilhável

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 distribuí-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 plug-in do NetBeans]. O destinatário deve utilizar 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/kb/docs/platform_pt_BR.html[Outros tutoriais relacionados]