<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    <!-- -*- xhtml -*- -->
    <title>Tutorial de in&iacute;cio r&aacute;pido da Plataforma NetBeans 6.0</title>
    <link rel="stylesheet" type="text/css" href="https://netbeans.org/netbeans.css">
    <meta name="AUDIENCE" content="NBUSER">
    <meta name="TYPE" content="ARTICLE">
    <meta name="EXPIRES" content="N">
    <meta name="developer" content="jtulach@netbeans.org">
    <meta name="indexed" content="y">
    <meta name="description"
          content="A short guide to using the Nodes API.">
    <!--      Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved. -->
    <!--     Use is subject to license terms.-->
</head>
<body>
    <h1>Tutorial de in&iacute;cio r&aacute;pido da Plataforma NetBeans 6.0</h1>
    
    <p>Este tutorial demonstra como construir um Editor HTML, sem qualquer codifica&ccedil;&atilde;o Java. No
     fim deste tutorial, voc&ecirc; ter&aacute; um Editor HTML que se parece com este:
    
    </p><p align="left"><img src="../../images/tutorials/htmleditor/html_editor_60.png" border="1" alt="painel da tela de abertura">
  
    </p><p>Embora seja uma aplica&ccedil;&atilde;o demonstrativa muito simples, ela n&atilde;o &eacute; um brinquedo! &Eacute; um programa <i>real</i>
    que d&aacute; suporte a edi&ccedil;&atilde;o f&aacute;cil de p&aacute;ginas HTML, com recursos como auto-completar de c&oacute;digo, valida&ccedil;&atilde;o e fragmentos de c&oacute;digo HTML predefinidos.
    
    </p><p>O Editor HTML que voc&ecirc; cria neste tutorial &eacute; uma aplica&ccedil;&atilde;o rich-client conclu&iacute;da &quot;sobre a Plataforma NetBeans&quot;. O que isso significa &eacute; que o n&uacute;cleo do IDE, que <i><u>&eacute;</u></i> a Plataforma NetBeans, ser&aacute; a base da sua aplica&ccedil;&atilde;o. Sobre a Plataforma NetBeans, voc&ecirc; adiciona os m&oacute;dulos necess&aacute;rios e exclui aqueles de que o IDE precisa mas que a sua aplica&ccedil;&atilde;o n&atilde;o. Aqui voc&ecirc; v&ecirc; alguns dos m&oacute;dulos do IDE, adicionados &agrave; Plataforma NetBeans, que &eacute; a sua base:
    
    </p><p align="left"><img src="../../images/tutorials/htmleditor/diagram.png" alt="Editor HTML">
    
    </p><p>Criar esse Editor HTML significa gerar um esqueleto de aplica&ccedil;&atilde;o, excluindo os m&oacute;dulos e os itens de interface do usu&aacute;rio de que voc&ecirc; n&atilde;o precisa e, em seguida, definir a janela Favoritos como a janela que ser&aacute; aberta por padr&atilde;o quando o IDE se iniciar. Todas essas atividades s&atilde;o suportadas pelos elementos de interface do usu&aacute;rio no IDE. </p>
    
    <p>Voc&ecirc; ver&aacute; por si mesmo como &eacute; simples e f&aacute;cil construir, ou para ser mais preciso, <em>montar</em> uma aplica&ccedil;&atilde;o completa sobre a Plataforma NetBeans. No fim, &eacute; mostrado como tornar o produto final facilmente baix&aacute;vel e inici&aacute;vel usando o WebStart.
    </p>
    
    
    <p><b>Observa&ccedil;&atilde;o:</b> embora seja um produto separado, n&atilde;o &eacute; necess&aacute;rio baixar a Plataforma NetBeans separadamente por causa deste tutorial. Voc&ecirc; desenvolver&aacute; a aplica&ccedil;&atilde;o rich-client no IDE e, em seguida, excluir&aacute; os m&oacute;dulos que s&atilde;o espec&iacute;ficos do IDE, mas que s&atilde;o sup&eacute;rfluos para a sua aplica&ccedil;&atilde;o.
    

 </p><h3>Conte&uacute;do</h3>
     <table border="0" cellpadding="0" cellspacing="0" width="100%">
       <tbody><tr>
         <td align="left" valign="top">
<ul>
    <li><a href="#gettingstarted">Guia de introdu&ccedil;&atilde;o</a></li>
        <li><a href="#generating">Gerando a aplica&ccedil;&atilde;o de esqueleto</a></li>
        <li><a href="#tweakingthemenuitems">Otimizando a interface do usu&aacute;rio</a>
        </li><li><a href="#tweakingthewindowlayout">Otimizando o layout da janela</a></li>
        <li><a href="#tweakingthefavorites">Otimizando a janela Favoritos</a></li>
        <li><a href="#runningtheapplication">Executando o aplicativo</a></li>
        <li><a href="#updatingtheapplication">Incluindo a funcionalidade de atualiza&ccedil;&atilde;o</a></li>
        <li><a href="#distributingtheapplication">Distribuindo a aplica&ccedil;&atilde;o</a></li>
        <li><a href="#distributingshared">Distribuindo o Editor HTML por meio do Reposit&oacute;rio JNLP compartilhado do NetBeans</a></li>
    </ul>
    </td>
         <td width="20"> </td>

         <td align="right" valign="top"> 
      <img src="../../images/tutorials/netbeans-stamp.gif" 
alt=" O conte&uacute;do desta p&aacute;gina se aplica ao IDE NetBeans 6.0 " title="O conte&uacute;do desta p&aacute;gina se aplica ao IDE NetBeans 6.0 " border="0" height="45" width="206">
   </td>
       </tr>
     </tbody></table>

    
    <p>Para obter mais informa&ccedil;&otilde;es sobre como trabalhar com m&oacute;dulos, consulte a <a href="https://platform.netbeans.org/index.html">Home page do projeto de desenvolvimento do NetBeans</a> no site do NetBeans.  Se voc&ecirc; tiver d&uacute;vidas, visite as <a href="http://wiki.netbeans.org/wiki/view/NetBeansDeveloperFAQ">Perguntas freq&uuml;entes do desenvolvedor do NetBeans</a> ou use o link de coment&aacute;rios na parte inferior desta p&aacute;gina.</p>
    
    <br />
    
    <!-- ===================================================================================== -->
    <h2 class="tutorial"><a name="gettingstarted"></a>Guia de introdu&ccedil;&atilde;o</h2>
    
    
    <p>Antes de come&ccedil;ar, voc&ecirc; deve instalar o seguinte software no seu computador:</p>
<ul>
    <li>O J2SE(TM) Development Kit (JDK), vers&atilde;o 5.0 ou compat&iacute;vel 
    (<a href="http://java.sun.com/javase/downloads/index.jsp">baixe o 
    JDK mais recente</a>).</li>
        <li>NetBeans IDE 6.0 (<a href="http://download.netbeans.org/netbeans/6.0/final/">download</a>).
    </li></ul>
    <br />
    
    
    <!-- ===================================================================================== -->
 
    <h2 class="tutorial"><a name="generating"></a>Gerando a aplica&ccedil;&atilde;o de esqueleto</h2>
    
            <p>Ao criar uma aplica&ccedil;&atilde;o na Plataforma NetBeans,
                o primeiro passo &eacute; criar um projeto de conjunto de m&oacute;dulos.
                O projeto de conjunto de m&oacute;dulos padr&atilde;o inclui <i>todos</i> os m&oacute;dulos
                inclu&iacute;dos na Plataforma NetBeans, assim como <i>todos</i> os
                m&oacute;dulos inclu&iacute;dos no NetBeans IDE. J&aacute; que n&atilde;o precisamos de todos esses m&oacute;dulos, excluiremos os que n&atilde;o s&atilde;o necess&aacute;rios.
                
                
                </p><ol><li>Usando o assistente para Novo projeto (Ctrl-Shift-N), crie um Projeto de conjunto de m&oacute;dulos a partir do modelo na categoria de m&oacute;dulos do NetBeans, como mostrado abaixo:</p>
        
            <p align="left"><img border="1" src="../../images/tutorials/htmleditor/module-suite-60.png" border="1" alt="painel da tela de abertura">
        
        
            </p><p>Clique em Pr&oacute;ximo e chame o conjunto de m&oacute;dulos de &quot;Editor HTML do NetBeans&quot;.
            Clique em Terminar.
        </p></li><li>Clique com o bot&atilde;o direito do mouse no n&oacute; do projeto, escolha Propriedades e, em seguida, fa&ccedil;a algumas altera&ccedil;&otilde;es na caixa de di&aacute;logo Propriedades do projeto do conjunto de m&oacute;dulos:
        <ul><li>No painel Construir, clique em &quot;Criar aplica&ccedil;&atilde;o independente&quot; para especificar que vai ser uma aplica&ccedil;&atilde;o rich-client sobre a Plataforma NetBeans. </p>
            
                 <p>Verifique se voc&ecirc; gosta do nome da marca do execut&aacute;vel e do t&iacute;tulo da aplica&ccedil;&atilde;o da barra de t&iacute;tulo, como mostrado abaixo:</p>
            
            <p align="left"><img border="1" src="../../images/tutorials/htmleditor/application_panel-60.png" border="1" alt="painel da aplica&ccedil;&atilde;o">
                </p></li><li>No painel Tela de abertura, forne&ccedil;a a tela de abertura da aplica&ccedil;&atilde;o, como mostrado abaixo:
            </p>
            
            <p align="left"><img border="1" src="../../images/tutorials/htmleditor/splash_screen_panel-60.png" border="1" alt="painel da tela de abertura">
            
            </p><p>Se voc&ecirc; n&atilde;o tiver uma tela de abertura, use <a href="../../images/tutorials/htmleditor/splash.gif">esta</a>.
        </p></li>
        <li>No painel Bibliotecas da caixa de di&aacute;logo Propriedades do projeto, voc&ecirc; v&ecirc; uma lista de &quot;clusters&quot;. Um cluster &eacute; uma cole&ccedil;&atilde;o de m&oacute;dulos relacionados. Os &uacute;nicos clusters que precisam ser selecionados
        s&atilde;o <tt>ide8</tt> e <tt>platform7</tt>. Desmarque todos os outros clusters.
        
        </li><li>No cluster <tt>platform7</tt>, voc&ecirc; precisa somente dos seguintes m&oacute;dulos:</p>
        
        <p>APIs de a&ccedil;&atilde;o
        <br>Bootstrap
        <br>N&uacute;cleo
        <br>N&uacute;cleo - Execu&ccedil;&atilde;o
        <br>N&uacute;cleo - UI
        <br>N&uacute;cleo - Janelas
        <br>API de Sistema de dados
        <br>API das caixas de di&aacute;logo
        <br>API de Execu&ccedil;&atilde;o
        <br>API do explorer e folha de propriedades
        <br>Favoritos
        <br>API do sistema de arquivos
        <br>Consultas Gerais da API
        <br>APIs de E/S
        <br>Integra&ccedil;&atilde;o com o JavaHelp
        <br>Op&ccedil;&otilde;es do mapa de teclas
        <br>Biblioteca de Personaliza&ccedil;&atilde;o de Apar&ecirc;ncia &amp; Funcionalidade
        <br>API de pesquisa MIME
        <br>Pesquisa MIME em SystemFS
        <br>Sistema de arquivos mestre
        <br>API do m&oacute;dulo de sistema
        <br>API de n&oacute;s
        <br>SPI e Di&aacute;logo de op&ccedil;&otilde;es
        <br>Janela de sa&iacute;da
        <br>API de progresso
        <br> UI de progresso
        <br>API de configura&ccedil;&otilde;es
        <br>API das op&ccedil;&otilde;es de configura&ccedil;&atilde;o
        <br>Inicializa&ccedil;&atilde;o
        <br>Integra&ccedil;&atilde;o das extens&otilde;es de layout do Swing
        <br>Controle de Abas
        <br>API de Texto
        <br>API de utilit&aacute;rios da IU
        <br>API de utilit&aacute;rios
        <br>API do sistema de janelas
        
        </p></li><li>No cluster <tt>ide8</tt>, somente os m&oacute;dulos seguintes s&atilde;o necess&aacute;rios:</p>
        
        <p>Paleta comum
            <br>Comparar
            <br>Editor
            <br>Coincid&ecirc;ncia de colchetes do editor
            <br>Auto-completar de c&oacute;digo do editor
            <br>Dobramento de c&oacute;digo do editor
            <br>Se&ccedil;&otilde;es protegidas do editor
            <br>Recuo do editor
            <br>Biblioteca do editor
            <br>Biblioteca2 do editor
            <br>Configura&ccedil;&otilde;es do editor
            <br>Armazenamento de configura&ccedil;&otilde;es do editor
            <br>Utilit&aacute;rios do editor
            <br>API da faixa de erros
            <br>N&uacute;cleo da faixa de erros
            <br>Pain&eacute;is da caixa de di&aacute;logo de op&ccedil;&otilde;es gerais
            <br>Framework de linguagens gen&eacute;ricas
            <br>HTML
            <br>Editor HTML
            <br>Biblioteca do editor HTML
            <br>Analisador l&eacute;xico HTML
            <br>Padr&otilde;es IDE
            <br>Imagem
            <br>Analisador l&eacute;xico
            <br>Analisador l&eacute;xico para ponte NetBeans
            <br>API do navegador
            <br>Editor simples
            <br>Biblioteca do editor simples
            <br>API de projeto
            <br>API de pesquisa
            <br>Biblioteca de editores baseados em marcas
            
    </p> </li></ul></li>
  
    
<!-- ===================================================================================== -->
    
    <h2 class="tutorial"><a name="tweakingthemenuitems"></a>Otimizando a interface de usu&aacute;rio</h2>
    
        <p>Voc&ecirc; pode manter ou rejeitar o quanto quiser da interface de usu&aacute;rio do IDE. Seu Editor HTML provavelmente
            n&atilde;o precisa de um ou todos os itens do menu Ferramentas. Semelhantemente, talvez haja barras de ferramentas
            ou bot&otilde;es da barra de ferramentas que n&atilde;o sejam necess&aacute;rios. Nesta se&ccedil;&atilde;o, voc&ecirc; remove a interface de usu&aacute;rio do IDE at&eacute; que haja um
            subconjunto que seja &uacute;til para a sua aplica&ccedil;&atilde;o rich-client.
            
            </p><ol><li>Expanda o conjunto de m&oacute;dulos, clique com o bot&atilde;o direito do mouse no n&oacute; M&oacute;dulos e
        escolha Adicionar novo, como mostrado abaixo:</p>
        
        <p><img border="1" src="../../images/tutorials/htmleditor/add-module-60.png" alt="esta camada em contexto">
        
        </p><p>O assistente para Novo projeto (Ctrl-Shift-N) aparece.
        Nomeie o projeto de <tt>BrandingModule</tt>, clique em Pr&oacute;ximo e, em seguida, 
        clique em Terminar.
        
        </p></li><li>No n&oacute; Arquivos importantes do m&oacute;dulo de marca, expanda o n&oacute; Camada XML. 
        Dois subn&oacute;s s&atilde;o expostos:</p>
        
        <p><img border="1" src="../../images/tutorials/htmleditor/expanded-xml-layer-60.png" alt="camada xml expandida">
        
        </p></li><li>No n&oacute; <tt>&lt;esta camada em contexto&gt;</tt>, o IDE mostra uma visualiza&ccedil;&atilde;o mesclada de todas as pastas e arquivo que todos os m&oacute;dulos registram em suas camadas. Para excluir os itens, voc&ecirc; pode clicar com o bot&atilde;o direito do mouse neles e escolher 'Excluir', como mostrado abaixo:</p>
        
        <p><img border="1" src="../../images/tutorials/htmleditor/this-layer-in-context-60.png" alt="esta camada em contexto">
        
        </p><p>O IDE adiciona
        marcas ao arquivo <tt>layer.xml</tt> do m&oacute;dulo que, quando o m&oacute;dulo &eacute; instalado,
        oculta os itens que voc&ecirc; excluiu. Por exemplo, clicando com o bot&atilde;o direito do mouse em <tt>Barra de menus/Editar</tt>, voc&ecirc; pode remover itens de menu do menu Editar que n&atilde;o s&atilde;o necess&aacute;rios para o Editor HTML. 
        Fazendo isso, voc&ecirc; gera trechos de c&oacute;digo como o seguinte no arquivo <tt>layer.xml</tt>:
        
        </p><pre class="examplecode">&lt;folder name=&quot;Menu&quot;&gt;
    &lt;folder name=&quot;Edit&quot;&gt;
        &lt;file name=&quot;org-netbeans-modules-editor-MainMenuAction$StartMacroRecordingAction.instance_hidden&quot;/&gt;
        &lt;file name=&quot;org-netbeans-modules-editor-MainMenuAction$StopMacroRecordingAction.instance_hidden&quot;/&gt;
    &lt;/folder&gt;       
&lt;/folder&gt;</pre>
        
        <p>
        O resultado do trecho de c&oacute;digo acima &eacute; que as a&ccedil;&otilde;es <tt>Iniciar grava&ccedil;&atilde;o de macro</tt> e <tt>Parar grava&ccedil;&atilde;o de macro</tt> fornecidas por outro m&oacute;dulo s&atilde;o removidas do menu por seu m&oacute;dulo de marca.
        
        </p></li><li>Use a abordagem descrita na etapa anterior para ocultar as barras de ferramentas, os bot&otilde;es da barra de ferramentas, os menus e os itens de menu que voc&ecirc; desejar.
        
        </li></ol>
        
<!-- ===================================================================================== -->        
        
        <h2 class="tutorial"><a name="tweakingthewindowlayout"></a>Otimizando o layout da janela</h2>
        <p>
            Usando o n&oacute; <tt>&lt;esta camada em contexto&gt;</tt>, voc&ecirc; pode n&atilde;o somente excluir itens existentes, mas tamb&eacute;m pode alterar o conte&uacute;do deles. Por exemplo, o Editor HTML trabalha em arquivos HTML, sendo assim, ao contr&aacute;rio do IDE regular, que trabalha com arquivos-fonte Java e projetos, faz sentido mostrar a janela <tt>Favoritos</tt> no layout inicial.
        </p>
        
        <p>
            A defini&ccedil;&atilde;o do layout da janela tamb&eacute;m &eacute; descrita como arquivos em camadas,
            tudo armazenado na pasta <tt>Janelas2</tt>. Os arquivos na pasta <tt>Janelas2</tt> s&atilde;o arquivos XML pseudo-leg&iacute;veis por humanos definidos pelas <a href="http://bits.netbeans.org/dev/javadoc/org-openide-windows/org/openide/windows/doc-files/api.html">APIs do sistema de janelas</a>. Eles s&atilde;o complexos mas a boa not&iacute;cia &eacute; que, para fins do nosso Editor HTML, n&atilde;o &eacute; necess&aacute;rio compreend&ecirc;-los completamente, como mostrado abaixo.
        </p>
        
        <ol><li>Em seu n&oacute; <tt>&lt;esta camada em contexto&gt;</tt> do m&oacute;dulo de marca,
        clique com o bot&atilde;o direito do mouse no n&oacute; <tt>Janelas2</tt> e escolha Localizar,
    como mostrado abaixo:</p>
    
    <p><img border="1" src="../../images/tutorials/htmleditor/find-favorites-60.png" alt="localizar favoritos">
    
    </p></li><li>Procure por
        um objeto chamado <tt>Favoritos</tt>, ignorando o uso de mai&uacute;sculas/min&uacute;sculas. Voc&ecirc; encontrar&aacute; dois arquivos:
    </p>
    <p><img border="1" src="../../images/tutorials/htmleditor/find-favorites2-60.png" alt="localizar favoritos">
    
    </p><p>
        O primeiro arquivo define a apar&ecirc;ncia do componente e como ele &eacute; criado. Como o componente n&atilde;o precisa ser alterado, n&atilde;o &eacute; necess&aacute;rio modificar o arquivo. O segundo &eacute; mais interessante para os seus prop&oacute;sitos, 
        ele cont&eacute;m o seguinte:
    </p>
    <pre class="examplecode">
&lt;tc-ref version=&quot;2.0&quot;&gt;
    &lt;module name=&quot;org.netbeans.modules.favorites/1&quot; spec=&quot;1.1&quot; /&gt;
    &lt;tc-id id=&quot;favorites&quot; /&gt;
    &lt;state opened=&quot;false&quot; /&gt;
&lt;/tc-ref&gt;</pre>    
    <p>
    </p></li><li>Embora a maior parte do XML seja criptografada, existe uma linha que parece promissora &mdash; sem precisar ler nenhum tipo de documenta&ccedil;&atilde;o, &eacute; prov&aacute;vel que alterar <tt>false</tt> para <tt>true</tt> tornar&aacute; o componente aberto por padr&atilde;o. Fa&ccedil;a isso agora.
    
    </li><li>
    De uma forma semelhante, voc&ecirc; pode alterar a Paleta do componente para que ela abra por padr&atilde;o, e o Navegador para que ele se feche. Realize estas etapas.
    
    </li></ol>
     
        <p>Agora voc&ecirc; deve ver que o seu m&oacute;dulo de marca cont&eacute;m tr&ecirc;s novos arquivos,
            um para cada um dos arquivos que voc&ecirc; alterou. Na verdade, esses arquivos substituem aqueles que voc&ecirc; encontrou nas etapas anteriores, sendo que agora voc&ecirc; forneceu as informa&ccedil;&otilde;es necess&aacute;rias para substituir o layout da janela:</p>
    
        <p><img border="1" src="../../images/tutorials/htmleditor/wstcrefs-overridden-60.png" alt="localizar favoritos">

<!-- ===================================================================================== -->     
     
        </p><h2 class="tutorial"><a name="tweakingthefavorites"></a>Otimizando a janela Favoritos</h2>
        <p>
            Nas subpastas de uma pasta de <tt>marca</tt> do conjunto de m&oacute;dulos, que esteja vis&iacute;vel na janela Arquivos, voc&ecirc; pode substituir as strings definidas nos c&oacute;digos-fonte do NetBeans. Nesta
            se&ccedil;&atilde;o, voc&ecirc; substituir&aacute; as strings que definem os
            r&oacute;tulos usados na janela Favoritos. Por exemplo, alteraremos o r&oacute;tulo
            &quot;Favoritos&quot; para &quot;Arquivos HTML&quot;,
            pois usaremos essa janela especificamente para arquivos 
            HTML.
        </p>
        
        <ol><li>Abra a janela Arquivos e 
            expanda a pasta de <tt>marca</tt> do conjunto de m&oacute;dulos.
            </li><li>Crie uma nova estrutura de pastas em <tt>marca/m&oacute;dulos</tt>.
                A nova pasta deve se chamar <tt>org-netbeans-modules-favorites.jar</tt>.
                Dentro dessa pasta, crie uma hierarquia de pastas
                <tt>org/netbeans/m&oacute;dulos/favoritos</tt>. Dentro da pasta final,
                ou seja, <tt>favoritos</tt>, crie um novo arquivo <tt>Bundle.properties</tt>.
                Essa estrutura de pastas e arquivo de propriedades correspondem &agrave;
                estrutura de pastas nos c&oacute;digos-fonte do NetBeans relacionados &agrave;
                janela Favoritos.
            </li><li>Adicione as strings mostradas na captura de tela abaixo para substituir as mesmas strings definidas no arquivo de propriedades correspondentes nos c&oacute;digos-fonte da janela Favoritos:</p>
             
            <p><img border="1" src="../../images/tutorials/htmleditor/favorites-branding-60.png" alt="localizar favoritos">
     
            </p><p>Para facilitar a c&oacute;pia e colagem, essas s&atilde;o as strings definidas acima:
            
</p><pre>Favorites=HTML Files
ACT_AddOnFavoritesNode=&amp;Find HTML Files...
ACT_Remove=&amp;Remove from HTML Files List
ACT_View=HTML Files
ACT_Select=HTML Files
ACT_Select_Main_Menu=Select in HTML Files List

# JFileChooser
CTL_DialogTitle=Add to HTML Files List
CTL_ApproveButtonText=Add
ERR_FileDoesNotExist={0} does not exist.
ERR_FileDoesNotExistDlgTitle=Add to HTML Files List
MSG_NodeNotFound=The document node could not be found in the HTML Files List.</pre>
                
            </li></ol>
            
            
            <!-- ===================================================================================== -->     
     
        <h2 class="tutorial"><a name="runningtheapplication"></a>Executando o aplicativo</h2>
        <p>
            Executar a sua aplica&ccedil;&atilde;o &eacute; t&atilde;o simples quando clicar com o bot&atilde;o direito do mouse no n&oacute; do projeto e escolher um item de menu.
        </p>
        
        <ol>
        <li>Clique com o bot&atilde;o direito do mouse no n&oacute; do projeto da aplica&ccedil;&atilde;o e escolha Limpar e construir tudo.
        </li><li>Clique com o bot&atilde;o direito do mouse no n&oacute; do projeto da aplica&ccedil;&atilde;o e escolha Executar:</p>
             
            <p><img border="1" src="../../images/tutorials/htmleditor/run-app-60.png" alt="executando a aplica&ccedil;&atilde;o">

            </p></li><li>Depois que a aplica&ccedil;&atilde;o &eacute; implantada, voc&ecirc; pode clicar com o bot&atilde;o direito do mouse dentro da janela Favoritos e escolher uma pasta contendo arquivos HTML e, em seguida, abrir um arquivo HTML, como mostrado abaixo:</p>
        
    <p align="left"><img src="../../images/tutorials/htmleditor/html_editor_60.png" border="1" alt="painel da tela de abertura">
            
        </p></li>
        
        <!-- ===================================================================================== -->     
     
        <h2 class="tutorial"><a name="updatingtheapplication"></a>Incluindo a funcionalidade de atualiza&ccedil;&atilde;o</h2>
        <p>
            Para estender sua aplica&ccedil;&atilde;o, voc&ecirc; deve permitir que os usu&aacute;rios instalem m&oacute;dulos para aprimorar a funcionalidade da aplica&ccedil;&atilde;o. Para fazer isso, voc&ecirc; precisa simplesmente ativar alguns m&oacute;dulos extras, que empacotar&atilde;o o gerenciador de plug-ins com o seu Editor HTML.
        </p>
        
        <ol><li>Clique com o bot&atilde;o direito do mouse no projeto de conjunto de m&oacute;dulos e escolha Propriedades. Na caixa de di&aacute;logo Propriedades do projeto,
         use o painel Bibliotecas e marque as caixas de verifica&ccedil;&atilde;o que s&atilde;o real&ccedil;adas abaixo:</p>
             
            <p><img border="1" src="../../images/tutorials/htmleditor/auto-update-60.png" alt="executando a aplica&ccedil;&atilde;o">
</p></li><li>Clique com o bot&atilde;o direito do mouse no n&oacute; do projeto da aplica&ccedil;&atilde;o e escolha Limpar e construir tudo.
            </li><li>Execute a aplica&ccedil;&atilde;o e observe que agora voc&ecirc; tem um novo item de menu, chamado &quot;Plug-ins&quot;, no menu Ferramentas:</p>
         
    <p align="left"><img src="../../images/tutorials/htmleditor/auto-update2-60.png" border="1" alt="painel da tela de abertura">
            
    </p></li><li>Escolha o nome item de menu Plug-ins e instale alguns
     plug-ins que sejam &uacute;teis para seu Editor HTML.
        Navegue no <a href="http://plugins.netbeans.org/PluginPortal/">Portal Plug-in</a>
         para localizar alguns que sejam adequados.
    
        </li></ol>
        
           <!-- ===================================================================================== -->     
     
        <h2 class="tutorial"><a name="distributingtheapplication"></a>Distribuindo a aplica&ccedil;&atilde;o</h2>
        <p>
            O IDE pode criar uma aplica&ccedil;&atilde;o JNLP, para Web,
            iniciando a sua aplica&ccedil;&atilde;o, assim como um arquivo ZIP,
            que inclui o iniciador da aplica&ccedil;&atilde;o. Nesta
            se&ccedil;&atilde;o, examinamos a &uacute;ltima abordagem.
        </p>
        
        
        <ol><li>Clique com o bot&atilde;o direito do mouse no n&oacute; do projeto da aplica&ccedil;&atilde;o e escolha Construir distribui&ccedil;&atilde;o de ZIP, como mostrado abaixo:</p>
             
            <p><img border="1" src="../../images/tutorials/htmleditor/zip-app-60.png" alt="executando a aplica&ccedil;&atilde;o">

            </p><p>Um arquivo ZIP &eacute; criado na pasta <tt>dist</tt> do conjunto de m&oacute;dulos, que voc&ecirc; pode ver na janela Arquivos.
            
            </p></li><li>Depois de descompactar a aplica&ccedil;&atilde;o, voc&ecirc; deve ver o seguinte:</p>
            
            <p><img border="1" src="../../images/tutorials/htmleditor/unzipped-app-60.png" alt="executando a aplica&ccedil;&atilde;o">
            
            </p><p><b>Observa&ccedil;&atilde;o:</b> o iniciador da aplica&ccedil;&atilde;o &eacute; criado na pasta <tt>bin</tt>, como mostrado acima.
        </p></li>
    
    <br />
  <!-- ======================================================================================== -->

<h2><a name="distributingshare"></a>Distribuindo o Editor HTML por meio do Reposit&oacute;rio JNLP compartilhado do NetBeans</h2>



  <p>
  Finalmente, vamos ajustar o arquivo <tt>master.jnlp</tt> que &eacute;
  gerado na primeira vez em que voc&ecirc; inicia a aplica&ccedil;&atilde;o. Embora ele fa&ccedil;a o trabalho, ele
   n&atilde;o est&aacute; pronto para distribui&ccedil;&atilde;o. Pelo menos, voc&ecirc; precisa alterar a se&ccedil;&atilde;o de informa&ccedil;&otilde;es
    para fornecer melhores descri&ccedil;&otilde;es e &iacute;cones.
    
    </p><p>
    Outra altera&ccedil;&atilde;o na infra-estrutura JNLP padr&atilde;o &eacute; o uso de um reposit&oacute;rio JNLP compartilhado em www.netbeans.org. Por padr&atilde;o, a aplica&ccedil;&atilde;o JNLP gerada para um conjunto sempre cont&eacute;m todos os seus m&oacute;dulos, assim como os m&oacute;dulos do qual ela depende.
    Isso pode ser &uacute;til para uso de intranet, mas &eacute; um pouco menos pr&aacute;tico para uso amplo na internet. Na internet, &eacute; muito melhor que todos as aplica&ccedil;&otilde;es constru&iacute;das na Plataforma NetBeans fa&ccedil;am refer&ecirc;ncia a um reposit&oacute;rio de m&oacute;dulos do NetBeans, o que significa que tais m&oacute;dulos s&atilde;o compartilhados e n&atilde;o precisam ser baixados mais de uma vez.
    </p>
    
    <p>
    Existe um reposit&oacute;rio como tal para NetBeans 6.0. Ele n&atilde;o cont&eacute;m todos os m&oacute;dulos que o NetBeans IDE possui, mas ele cont&eacute;m o suficiente para criar aplica&ccedil;&otilde;es n&atilde;o-IDE como o nosso Editor HTML. (<a href="https://netbeans.org/bugzilla/show_bug.cgi?id=112726">Consulte o problema 112726.</a>)
      Para usar o reposit&oacute;rio, voc&ecirc; s&oacute; precisa modificar <tt>platform.properties</tt>,
    adicionando a URL correta:
    </p>
<pre class="examplecode">
# share the libraries from common repository on netbeans.org
# this URL is for release60 JNLP files:
jnlp.platform.codebase=https://netbeans.org/download/6_0/jnlp/
</pre>    
    <p>
    Assim que a aplica&ccedil;&atilde;o &eacute; iniciada como uma aplica&ccedil;&atilde;o JNLP, todos os seus m&oacute;dulos de plug-in compartilhados s&atilde;o carregados a partir de netbeans.org e compartilhados com as aplica&ccedil;&otilde;es que fazem o mesmo.</p>
    
	

    
<br />
  

    
    <!-- ======================================================================================== -->
    <br>
    <div class="feedback-box"><a href="https://netbeans.org/about/contact_form.html?to=3&amp;subject=Feedback:%20NetBeans%20Platform%206.0%20Quick%20Start%20Tutorial">Envie-nos seus coment&aacute;rios</a></div>
    <br style="clear:both;" />
    
    <!-- ======================================================================================== -->
    
    <h2><a name="nextsteps"></a>Pr&oacute;ximas etapas</h2>
    
    <p>Agora que voc&ecirc; aprendeu v&aacute;rios truques interessantes e possui uma aplica&ccedil;&atilde;o funcional constru&iacute;da na Plataforma NetBeans, &eacute; poss&iacute;vel observar ainda mais os subn&oacute;s do n&oacute; Camada XML. Sem muito trabalho, voc&ecirc; pode continuar ajustando a sua aplica&ccedil;&atilde;o, removendo-a e otimizando-a at&eacute; ter uma aplica&ccedil;&atilde;o s&oacute;lida, simplificada, que faz exatamente o que voc&ecirc; deseja que ela fa&ccedil;a. Em seguida,
    descubra como &eacute; f&aacute;cil adicionar seus pr&oacute;prios m&oacute;dulos &agrave; sua aplica&ccedil;&atilde;o. Os 
    <a href="https://platform.netbeans.org/tutorials/index.html">Tutoriais para m&oacute;dulo do NetBeans (Plug-in) e desenvolvimento de aplica&ccedil;&atilde;o rich-client</a> mostram uma ampla variedade de casos de uso para estender o Editor HTML. Por exemplo, talvez voc&ecirc; queira adicionar seus pr&oacute;prios itens de menu na barra de menus.
    Ou talvez voc&ecirc; queira fornecer trechos de c&oacute;digo HTML adicionais na paleta do componente. Ambos cen&aacute;rios, e muito mais,
    s&atilde;o destacados nos tutoriais nos Recursos do desenvolvedor de m&oacute;dulo.
    
    </p><p>Consulte tamb&eacute;m o 
        <a href="https://platform.netbeans.org/tutorials/60/nbm-paintapp.html">Tutorial da aplica&ccedil;&atilde;o Paint da Plataforma NetBeans 6.0</a>, que mostra
        como criar sua pr&oacute;pria aplica&ccedil;&atilde;o Paint. Finalmente, uma aplica&ccedil;&atilde;o um pouco mais complexa &eacute; fornecida no <a href="https://platform.netbeans.org/tutorials/60/nbm-feedreader.html">Tutorial do leitor de alimenta&ccedil;&atilde;o da Plataforma NetBeans 6.0</a>.
    </p>
    
    <hr>
    <!-- ======================================================================================== -->

    
</ol></ol></ol></body>
</html>
