<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html xmlns="http://www.w3.org/1999/xhtml">
  <!--Attention: No screenshots have been added yet.  JB -->     
 
 <head>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">

    <link rel="stylesheet" type="text/css" href="../../../netbeans.css"> 
 
    <title>
        Tutorial do aplicativo Paint para a Plataforma NetBeans 6.0
    </title>

<link rel="shortcut icon" href="https://netbeans.org/favicon.ico" type="image/x-icon" >

<meta name="keywords" content="NetBeans, IDE, Platform, free, open source, developer" >

<h1>Tutorial do aplicativo Paint para a Plataforma NetBeans</h1>

<p>Este tutorial orienta-o atrav&eacute;s dos fundamentos do uso do NetBeans IDE para desenvolver aplicativos rich-client na Plataforma NetBeans. Ao desenvolver aplicativos na Plataforma NetBeans, voc&ecirc; est&aacute; desenvolvendo no n&uacute;cleo do NetBeans IDE. Todos os m&oacute;dulos que perten&ccedil;am ao IDE e n&atilde;o sejam relevantes para o seu aplicativo ser&atilde;o exclu&iacute;dos, mas os &uacute;teis ser&atilde;o mantidos. Ao reutilizar recursos prontamente dispon&iacute;veis no n&uacute;cleo do IDE, voc&ecirc; economiza tempo e energia. 

    </p><p><b>Conte&uacute;do</b></p>
   
      <img  src="../../images/articles/60/netbeans-stamp60-61.gif" class="stamp" width="114" height="114" alt="O conte&uacute;do desta p&aacute;gina se aplica ao IDE NetBeans 6.1 " title="O conte&uacute;do desta p&aacute;gina se aplica ao IDE NetBeans 6.1"> </p>
      <ul class="toc">
     <li><a href="#intro">Introdu&ccedil;&atilde;o ao aplicativo Paint</a></li>
     <li><a href="#setup">Configurando o aplicativo Paint</a></li>
     <ul>
         <li><a href="#creatingModuleSuite">Criando a su&iacute;te de m&oacute;dulos</a></li>
         <li><a href="#creatingLibWrapModule">Criando o projeto de m&oacute;dulo de wrapper de bibliotecas</a></li>
         <li><a href="#creatingModProj">Criando o projeto do m&oacute;dulo </a></li>
         <li><a href="#specifyingModProjDep">Especificando as depend&ecirc;ncias do projeto de m&oacute;dulo</a></li>
     </ul>
     <li><a href="#impMod">Criando e incorporando a tela do Paint</a></li>
     <ul>
         <li><a href="#creatingCanv">Criando a tela</a></li>
         <li><a href="#prepTopComp">Preparando a classe TopComponent</a></li>
         <li><a href="#initTopComp">Inicializando a classe TopComponent</a></li>
         <li><a href="#fillSkelMeth">Preenchendo os m&eacute;todos do esqueleto</a></li>
         <li><a href="#savingImage">Salvando a imagem em disco</a></li>
     </ul>
     <li><a href="#defNew">Criando o item de menu Nova tela</a></li>
     <li><a href="#defSave">Criando o item de menu Salvar tela</a></li>
     <li><a href="#wrappingUp">Empacotando</a></li>
     <li><a href="#creatingDist">Criando uma distribui&ccedil;&atilde;o</a></li>
       </ul>
         
<p><b>Para seguir este tutorial, voc&ecirc; preciso dos softwares e recursos listados na tabela seguinte.</b></p>

    <table>
        <tbody>
            <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o necess&aacute;ria</th>
            </tr> 
           <tr>
                <td class="tbltd1">NetBeans IDE</td>
                <td class="tbltd1">vers&atilde;o <a href="http://download.netbeans.org/netbeans/6.1/final/">vers&atilde;o 6.1</a> ou<br>
                vers&atilde;o 6.0</td>
            </tr>
            <tr>
                <td class="tbltd1">Java Developer Kit (JDK)</td>
                <td class="tbltd1"><a href="http://java.sun.com/javase/downloads/index.jsp">vers&atilde;o 6</a> ou<br>
                vers&atilde;o 5</td>
            </tr>
        </tbody>
    </table>

 <p><a name="intro"></a></p><h2>Introdu&ccedil;&atilde;o ao aplicativo Paint</h2>

<p>Este tutorial foi concebido para come&ccedil;ar o mais rapidamente poss&iacute;vel. Voc&ecirc; ir&aacute; criar e instalar um aplicativo simples na Plataforma NetBeans. O aplicativo permite que o usu&aacute;rio pinte na tela e salve os resultados:<br>

 </p><p><a name="sampleImage"></a><img border="1" src="../../images/tutorials/paintapp/result-without-menus-60.png" alt="imagem do aplicativo conclu&iacute;do">

</p><p>Esta vers&atilde;o inicial est&aacute; longe de ser um aplicativo paint desenvolvido, mas demonstra um caso muito simples de cria&ccedil;&atilde;o de um aplicativo na Plataforma NetBeans. 

</p><p><b class="notes">Observa&ccedil;&atilde;o:</b> o <a href="nbm-google_pt_BR.html">In&iacute;cio r&aacute;pido do plug-in do NetBeans</a> &eacute; um tutorial melhor se voc&ecirc; quiser aprender sobre m&oacute;dulos do NetBeans e n&atilde;o sobre aplicativos rich-client. 

 </p><p>Neste tutorial, recriaremos um aplicativo que &eacute; uma amostra fornecida com o IDE. Para ver o produto final, ou para solucionar problemas enquanto trabalhar neste tutorial, obtenha a amostra do Assistente para novo projeto, na localiza&ccedil;&atilde;o mostrada abaixo:</p>
  
  <p align="left"><img border="1" src="../../images/tutorials/paintapp/sample-in-new-project-60.png" alt="Painel Nome e localiza&ccedil;&atilde;o">

 
 </p><p><a name="setup"></a></p><h2>Configurando o aplicativo Paint</h2>

<p>Nesta se&ccedil;&atilde;o, voc&ecirc; criar&aacute; a estrutura do aplicativo. Primeiro, &eacute; necess&aacute;rio criar um projeto de su&iacute;te de m&oacute;dulos, que representar&aacute; o aplicativo. O aplicativo depende de uma biblioteca, assim, voc&ecirc; ir&aacute; criar um projeto de m&oacute;dulo de wrapper de bibliotecas que conter&aacute; o arquivo JAR da biblioteca. Finalmente, crie o projeto de m&oacute;dulo que conter&aacute; o c&oacute;digo.
 
</p><div class="indent">
    
<p><a name="creatingModuleSuite"></a></p><h3 class="tutorial">Criando a su&iacute;te de m&oacute;dulos </h3>

<p>Uma su&iacute;te de m&oacute;dulos &eacute; o equivalente a um aplicativo: &eacute; um conjunto de m&oacute;dulos que funcionam juntos para criar resultados espec&iacute;ficos. Ela tamb&eacute;m permite que voc&ecirc; atribua a sua pr&oacute;pria tela de abertura (identifica&ccedil;&atilde;o de marca), o nome do aplicativo e o tipo e n&uacute;mero de m&oacute;dulos NetBeans que voc&ecirc; deseja usar. Voc&ecirc; tamb&eacute;m pode se beneficiar de a&ccedil;&otilde;es como a cria&ccedil;&atilde;o de uma distribui&ccedil;&atilde;o ZIP e a constru&ccedil;&atilde;o de um aplicativo JNLP (Java WebStart), que s&atilde;o ferramentas importantes para tornar seu aplicativo dispon&iacute;vel para os outros usu&aacute;rios.
</p><ol>
	<li>Escolha Arquivo &gt; Novo projeto. Em Categorias, selecione M&oacute;dulos do NetBeans. Em Projetos, selecione Projeto de conjunto de m&oacute;dulos e clique em Pr&oacute;ximo.</li>
	<li>No painel Nome e local, digite <tt>PaintApp</tt> em Nome do projeto.
 Altere Local do projeto para qualquer diret&oacute;rio no computador. Deixe marcada a caixa de verifica&ccedil;&atilde;o Definir como projeto principal:<br><br>

<p align="left"><img border="1" src="../../images/tutorials/paintapp/newmodulesuite-60.png" alt="Painel Nome e localiza&ccedil;&atilde;o">

 </p><p>Clique em Terminar.

      </p></li>

<p>O novo projeto de su&iacute;te de m&oacute;dulos &eacute; aberto no IDE. Ele cont&eacute;m um n&oacute; na janela Projeto. Este n&oacute;, o n&oacute; M&oacute;dulos, &eacute; para a adi&ccedil;&atilde;o manual de projetos de m&oacute;dulo e projetos de m&oacute;dulo de wrapper de bibliotecas ao projeto de su&iacute;te de m&oacute;dulos. Quando voc&ecirc; usar o Assistente para projeto de m&oacute;dulo ou o Assistente para projeto de m&oacute;dulo de wrapper de bibliotecas, o m&oacute;dulo que voc&ecirc; criar poder&aacute; ser adicionado automaticamente ao projeto de su&iacute;te de m&oacute;dulos.

</p><p></p><h3 class="tutorial"><a name="creatingLibWrapModule"></a>Criando o projeto de m&oacute;dulo de wrapper de bibliotecas</h3>

<p>Um m&oacute;dulo de wrapper de bibliotecas &eacute; um m&oacute;dulo cujo arquivo JAR n&atilde;o cont&eacute;m c&oacute;digo, ele apenas aponta para uma biblioteca. Ele transforma a biblioteca em um m&oacute;dulo do NetBeans, para que todas as prote&ccedil;&otilde;es do sistema carregador de classes do NetBeans sejam aplicadas nele, sem modificar o arquivo JAR original. O aplicativo poder&aacute;, ent&atilde;o, depender da biblioteca simplesmente como se ela fosse outro m&oacute;dulo do NetBeans. E, se novas vers&otilde;es da biblioteca se tornarem dispon&iacute;veis, voc&ecirc; poder&aacute; distribu&iacute;-las sem precisar distribuir nada al&eacute;m de um simples arquivo NBM (NetBeans Module) para o wrapper de bibliotecas.

</p><p><b class="notes">Observa&ccedil;&atilde;o:</b> um dos benef&iacute;cios da constru&ccedil;&atilde;o na Plataforma NetBeans &eacute; que a interface do usu&aacute;rio &eacute; baseada em Swing: o kit de ferramentas padr&atilde;o de interface do usu&aacute;rio para Java. Como o Swing tem sido usado h&aacute; bastante tempo, h&aacute; muitos componentes Swing que podem ser reutilizados no aplicativo. Neste tutorial, reutilize um JavaBean de seletor de cores existente (voc&ecirc; pode encontrar a fonte para tal no NetBeans CVS em <tt>contrib/coloreditor</tt>). O arquivo JAR &eacute; chamado <tt>ColorChooser.jar</tt>. &Eacute; poss&iacute;vel fazer o download da biblioteca <a href="https://colorchooser.dev.java.net/">aqui</a>. Salve-a em qualquer lugar no sistema de arquivos. Fa&ccedil;a o seguinte para criar um m&oacute;dulo de wrapper de bibliotecas para o arquivo <tt>ColorChooser.jar</tt>:
  </p><ol>
<li>Escolha Arquivo &gt; Novo projeto. Em Categorias, selecione M&oacute;dulos do NetBeans. Em Projetos, selecione Projeto de m&oacute;dulo de wrapper de biblioteca e clique em Pr&oacute;ximo.</li>
<li>No painel Nome e localiza&ccedil;&atilde;o, para a caixa de texto Biblioteca, digite o caminho para <tt>ColorChooser.jar</tt> ou navegue at&eacute; sua localiza&ccedil;&atilde;o.
</li><li>Deixe o campo de texto Licen&ccedil;a vazio. Se voc&ecirc; pretender distribuir o produto completo, dever&aacute; incluir o arquivo de licen&ccedil;a da biblioteca externa.
 </li><li>Clique em Pr&oacute;ximo e o seguinte dever&aacute; ser exibido:</p>

<p align="left"><img border="1" src="../../images/tutorials/paintapp/newmodulesuite-library-60.png" alt="Painel Nome e localiza&ccedil;&atilde;o">

</p><p>Clique em Pr&oacute;ximo novamente e, em seguida, em Terminar.</p></li>


<h3 class="tutorial"><a name="creatingModProj"></a>Criando o projeto do m&oacute;dulo </h3>
 <p>Agora, voc&ecirc; precisa de um m&oacute;dulo para receber o c&oacute;digo real que voc&ecirc; vai escrever. 
     </p><ol>
	<li>Escolha Arquivo &gt; Novo projeto. Em Categorias, selecione M&oacute;dulos do NetBeans. Em Projetos, selecione Projeto de m&oacute;dulo e clique em Pr&oacute;ximo.</li>
	<li>No painel Nome e local, digite <tt>Paint</tt> em Nome do projeto.
 Altere Local do projeto para qualquer diret&oacute;rio no computador. Certifique-se de que o bot&atilde;o de op&ccedil;&atilde;o Adicionar &agrave; su&iacute;te de m&oacute;dulos esteja selecionado e de que a su&iacute;te de modelos <tt>PaintApp</tt> esteja selecionada na lista suspensa Su&iacute;te de m&oacute;dulos. Selecione a caixa de verifica&ccedil;&atilde;o Definir como projeto principal. Clique em Pr&oacute;ximo.

 </li><li>No painel Configura&ccedil;&atilde;o b&aacute;sica de m&oacute;dulos, altere <tt>yourorghere</tt> em Nome base de c&oacute;digo para <tt>netbeans</tt>, de modo que o nome inteiro seja <tt>org.netbeans.paint</tt>. Deixe <tt>Paint</tt> como o Nome de exibi&ccedil;&atilde;o do m&oacute;dulo. Deixe o local do conjunto de localiza&ccedil;&otilde;es e a camada XML, de modo que ser&atilde;o armazenados em um pacote com o nome <tt>org.netbeans.paint</tt>. Esses destinos fazem o seguinte:
 <ul>
 <li><b>Pacote de localiza&ccedil;&atilde;o.</b> Especifica as strings de linguagem espec&iacute;fica para internacionaliza&ccedil;&atilde;o.</li>
 <li><b>Camada XML.</b> Registre itens como menus e bot&otilde;es da barra de ferramentas no sistema do NetBeans. 
</li>
 </ul>


<p>Clique em Terminar.</p></li>

<p> O IDE cria o projeto <tt>Paint. </tt> O projeto cont&eacute;m todos os metadados de projeto e fontes, como o script de constru&ccedil;&atilde;o Ant do projeto. O projeto se abre no IDE. Voc&ecirc; pode ver a estrutura l&oacute;gica na janela Projetos (Ctrl-1) e a estrutura de arquivos na janela Arquivos (Ctrl+2). Por exemplo, a janela Projetos deve ter esta apar&ecirc;ncia:</p>

<p align="left"><img src="../../images/tutorials/paintapp/initial-proj-window60.png" border="1" alt="estrutura l&oacute;gica da janela Projetos">


</p><p>Al&eacute;m do pacote de localiza&ccedil;&atilde;o e da camada XML, o projeto tamb&eacute;m inclui os seguintes arquivos importantes:
 </p><ul>
 <li><b>Manifesto do m&oacute;dulo.</b> Declara que o projeto &eacute; um m&oacute;dulo. Al&eacute;m disso, define algumas configura&ccedil;&otilde;es espec&iacute;ficas do m&oacute;dulo, tais como a localiza&ccedil;&atilde;o da camada XML, a localiza&ccedil;&atilde;o do pacote de localiza&ccedil;&atilde;o e a vers&atilde;o do m&oacute;dulo.
 </li><li><b>Script de constru&ccedil;&atilde;o.</b> Fornece um local em que voc&ecirc; pode criar seus pr&oacute;prios destinos Ant e substituir aqueles que s&atilde;o especificados em <tt>nbproject/build-impl.xml</tt>.
 </li><li><b>Metadados do projeto.</b> Cont&eacute;m informa&ccedil;&otilde;es como o tipo do projeto, conte&uacute;do, plataforma, classpath, depend&ecirc;ncias e mapeamentos entre os comandos do projeto e os destinos em scripts Ant.

</li></ul>
<p>Voc&ecirc; n&atilde;o precisar&aacute; modificar qualquer um desses arquivos durante esse tutorial.

</li>

</p><p></p><h3 class="tutorial"><a name="specifyingModProjDep"></a>Especificando as depend&ecirc;ncias do projeto de m&oacute;dulo</h3>



<p>Voc&ecirc; precisa criar subclasses de v&aacute;rias classes que pertencem &agrave;s <a href="https://netbeans.org/download/dev/javadoc/">APIs do NetBeans</a>. Al&eacute;m disso, o projeto depende do arquivo <tt>ColorChooser.jar</tt>. Todas as APIs do NetBeans s&atilde;o implementadas por m&oacute;dulos, portanto, concluir ambas essas tarefas realmente significa adicionar alguns m&oacute;dulos &agrave; lista de m&oacute;dulos de que nosso m&oacute;dulo precisa para ser executado.
  </p><ol>
	  <li>Na janela Projetos, clique com o bot&atilde;o direito do mouse no n&oacute; do projeto <tt>Paint</tt> e escolha Propriedades. A caixa de di&aacute;logo Propriedades do projeto &eacute; aberta. Em Categorias, clique em Bibliotecas.</li>
	
 <li>Para cada uma das APIs listadas na tabela abaixo, clique em &quot;Adicionar depend&ecirc;ncia...&quot; e, em seguida, na caixa de texto Filtro, comece digitando o nome da classe cuja subclasse deseja criar.<br><br>  
 
 <p><table width="76%" border="1">
 <tbody>
   <tr>
 <td>
	<div align="left"><b></b>Classe</div>
      </td>
      <td>
        <div align="left"><b>API</b></div>
      </td>
     
      <td>
	<div align="left"><b>Finalidade</b></div>
      </td>
  </tr>
    <tr>
<td><tt>Seletor de cores</tt></td>
		<td><tt>Seletor de cores</tt></td>

                <td>O m&oacute;dulo do wrapper de biblioteca do componente seletor de cores que voc&ecirc; criou</td>
            </tr>
            <tr>
<td><tt>DataObject</tt></td>
		<td><tt>API de sistemas de dados</tt></td>

                <td>O m&oacute;dulo do NetBeans que cont&eacute;m a classe DataObject</td>
            </tr>
            <tr>
<td><tt>DialogDisplayer</tt></td>
		<td><tt>API de caixas de di&aacute;logo</tt></td>
 
                <td>Isso permite a cria&ccedil;&atilde;o da notifica&ccedil;&atilde;o do usu&aacute;rio, uma descri&ccedil;&atilde;o da caixa de di&aacute;logo e permite que ela seja exibida</td>
            </tr>
            <tr>
 <td><tt>AbstractFile</tt></td>
		<td><tt>API do sistema de arquivos</tt></td>

                <td>Isso fornece uma API comum para acessar os arquivos de uma maneira uniforme</td>
            </tr>
            <tr>
<td><tt>AbstractNode</tt></td>
		<td><tt>API de n&oacute;s</tt></td>

                <td>Isso serve como o aparato principal para a visualiza&ccedil;&atilde;o de objetos no NetBeans</td>
            </tr>
            <tr>
<td><tt>StatusDisplayer</tt></td>
		<td><tt>API de utilit&aacute;rios para UI</tt></td>

                <td>A classe StatusDisplayer usada para criar a barra de status na janela principal</td>
            </tr>
            <tr>
<td><tt>WeakListeners</tt></td>
		<td><tt>API de utilit&aacute;rios</tt></td>

                <td>Isso cont&eacute;m a classe WeakListeners</td>
            </tr>
            <tr>
<td><tt>TopComponent</tt></td>
		<td><tt>API do sistema de janelas</tt></td>

                <td>Isso cont&eacute;m a classe JPanel TopComponent</td>
            </tr>
  
  </tbody>
</table>
 
 </p><p>A primeira coluna na tabela acima lista todas as classes cuja subclasse voc&ecirc; vai criar neste tutorial. Em casa caso, comece a digitar o nome da classe no filtro e veja a lista M&oacute;dulo diminuir. Use a segunda coluna da tabela para selecionar a API apropriada (ou, no caso de <tt>ColorChooser</tt>, a biblioteca) nas lista M&oacute;dulo diminu&iacute;da e clique em OK para confirmar a escolha:

</p><p align="left"><img border="1" src="../../images/tutorials/paintapp/libfilter-60.png" alt="initial-proj-window">

</p></li><li>Clique em OK para sair da caixa de di&aacute;logo Propriedades do projeto.
</li><li>Na janela Projetos, expanda o n&oacute; do projeto do m&oacute;dulo do Paint se ele ainda n&atilde;o estiver expandido. Em seguida, expanda o n&oacute; Arquivos importantes e clique duas vezes no n&oacute; Metadados do projeto. Observe que as APIs selecionadas foram declaradas como depend&ecirc;ncias de m&oacute;dulo.


    </li></ol>
    </ol></ol></ol></div><br>
    <h2><a name="impMod"></a>Criando e incorporando a tela do Paint</h2> 
       

 <div class="indent">
   <h3 class="tutorial"><a name="creatingCanv"></a>Criando a tela</h3>
    <p>A pr&oacute;xima etapa &eacute; criar o componente real que o usu&aacute;rio pode pintar. Aqui, voc&ecirc; usa um componente Swing puro - portanto, vamos ignorar os detalhes de sua implementa&ccedil;&atilde;o e fornecer apenas a vers&atilde;o final. O bean do seletor de cores, para o qual voc&ecirc; criou o wrapper de biblioteca, &eacute; usado no c&oacute;digo-fonte desse painel &mdash; quando voc&ecirc; executar o aplicativo conclu&iacute;do, ir&aacute; v&ecirc;-lo na barra de ferramentas do painel para edi&ccedil;&atilde;o de imagens.</p>
    <ol type="1">
	<li>Na janela Projetos, expanda o n&oacute; <tt>Paint</tt>, em seguida, expanda o n&oacute; Pacotes de c&oacute;digos-fonte e clique com o bot&atilde;o direito do mouse no n&oacute; <tt>org.netbeans.paint</tt>. Escolha Nova &gt; Classe Java.</li>
	<li>Indique <tt>PaintCanvas</tt> como o Nome da classe. Garanta que <tt>org.netbeans.paint</tt> esteja listado como o pacote. Clique em Terminar. <tt>PaintCanvas.java</tt> se abre no editor de c&oacute;digo-fonte.
	</li><li>Substitua o conte&uacute;do padr&atilde;o do arquivo pelo conte&uacute;do encontrado <a target="source" href="https://platform.netbeans.org/guide/tutorials/paintTutorial/PaintCanvas.java">aqui</a>. Se voc&ecirc; chamou o pacote de algo diferente de <tt>org.netbeans.paint</tt>, corrija o nome do pacote no editor de c&oacute;digo-fonte.</li> 
    </ol>
  
    <p></p><h3 class="tutorial"><a name="prepTopComp"></a>Preparando a classe TopComponent</h3>

<p></p><p>Agora voc&ecirc; escrever&aacute; sua primeira classe que usa as <a href="https://netbeans.org/download/dev/javadoc/">APIs do NetBeans</a>. Trata-se de uma classe <tt><a href="http://www.netbeans.org/download/dev/javadoc/org-openide-windows/org/openide/windows/TopComponent.html">TopComponent</a></tt>. Uma classe <tt>TopComponent</tt> &eacute; apenas uma classe <tt>JPanel</tt> com a qual o sistema de janelas do NetBeans sabe se comunicar - portanto, ela pode ser colocada dentro de um cont&ecirc;iner com guias dentro da janela principal.

 </p><ol type="1">
		<li>Na janela Projetos, expanda o n&oacute; <tt>Paint</tt>, em seguida, expanda o n&oacute; Pacotes de c&oacute;digos-fonte e clique com o bot&atilde;o direito do mouse no n&oacute; <tt>org.netbeans.paint</tt>. Escolha Nova &gt; Classe Java.</li>
       Indique <tt>PaintTopComponent</tt> como o Nome da classe. Garanta que <tt>org.netbeans.paint</tt> esteja listado como o pacote. Clique em Terminar. <tt>PaintTopComponent.java</tt> se abre no editor de c&oacute;digo-fonte.
        <li>Pr&oacute;ximo &agrave; parte superior do arquivo, altere a declara&ccedil;&atilde;o da classe para o seguinte:
            <pre class="examplecode">    public class PaintTopComponent extends TopComponent implements ActionListener, ChangeListener {</pre></li>
        <li>Pressione Ctrl-Shift-I para corrigir as importa&ccedil;&otilde;es e clique em OK na caixa de di&aacute;logo. O IDE faz as declara&ccedil;&otilde;es de pacote de importa&ccedil;&atilde;o necess&aacute;rias na parte superior do arquivo.</p> 
	<p>Observe a linha vermelha sob a declara&ccedil;&atilde;o da classe que voc&ecirc; acabou de indicar. Posicione o cursor na linha e observe que uma l&acirc;mpada aparece na margem esquerda. Clique na l&acirc;mpada (ou pressione Alt-Enter), como mostrado abaixo:

</p><p><img border="1" src="../../images/tutorials/paintapp/lightbulb-60.png" alt="L&acirc;mpada.">

</p><p>Selecione Implementar todos os m&eacute;todos abstratos. O IDE gera dois esqueletos de m&eacute;todo &mdash; <tt>actionPerformed()</tt> e <tt>stateChanged()</tt>. Voc&ecirc; os experimentar&aacute; neste tutorial.</p></li>
	<li>Adicione as tr&ecirc;s declara&ccedil;&otilde;es de vari&aacute;vel seguintes no in&iacute;cio da classe <tt>PaintTopComponent</tt> e corrija as instru&ccedil;&otilde;es de importa&ccedil;&atilde;o (Ctrl-Shift-I).
        <pre class="examplecode">    private PaintCanvas canvas = new PaintCanvas(); //The component the user draws on
    private JComponent preview; //A component in the toolbar that shows the paintbrush size
    private static int ct = 0; //A counter you use to provide names for new images</pre></li>
        <li>Agora voc&ecirc; precisa implementar dois m&eacute;todos padronizados. O primeiro diz ao sistema de janelas para ignorar as janelas abertas quando o aplicativo &eacute; encerrado; o segundo fornece uma string base de um ID de string &uacute;nico do nosso componente. Cada <tt>TopComponent</tt> possui um ID de string &uacute;nico que &eacute; usado ao salvar o <tt>TopComponent</tt>. Insira os dois m&eacute;todos seguintes na classe <tt>PaintTopComponent</tt>:
<pre class="examplecode">    public int getPersistenceType() {
        return PERSISTENCE_NEVER;
    }

    public String preferredID() {
        return &quot;Image&quot;;
    }</pre></li>
    </ol>

<p>A classe agora deve ter esta apar&ecirc;ncia:

</p><pre class="examplecode">public class PaintTopComponent extends TopComponent implements ActionListener, ChangeListener {
    
    private PaintCanvas canvas = new PaintCanvas(); //The component the user draws on
    private JComponent preview; //A component in the toolbar that shows the paintbrush size
    private static int ct = 0; //A counter you use to provide names for new images
    
    public PaintTopComponent() {
    }
    
    public void actionPerformed(ActionEvent arg0) {
        throw new UnsupportedOperationException(&quot;Not supported yet.&quot;);
    }
    
    public void stateChanged(ChangeEvent arg0) {
        throw new UnsupportedOperationException(&quot;Not supported yet.&quot;);
    }
    
    public int getPersistenceType() {
        return PERSISTENCE_NEVER;
    }
    
    public String preferredID() {
        return &quot;Image&quot;;
    }
    
}</pre>
        
    <h3 class="tutorial"><a name="initTopComp"></a>Inicializando a classe TopComponent</h3>
  
<p>Nesta se&ccedil;&atilde;o, adicionamos o c&oacute;digo que inicializa a interface do usu&aacute;rio.
 
</p><ol type="1">
    <li>Preencha o construtor, que o IDE criou para voc&ecirc; ao lado do in&iacute;cio da classe e, em seguida, corrija as instru&ccedil;&otilde;es de importa&ccedil;&atilde;o (Ctrl-Shift-I):
       
<pre class="examplecode">    public PaintTopComponent() {

        initComponents();

        String displayName = NbBundle.getMessage(
                PaintTopComponent.class,
                &quot;UnsavedImageNameFormat&quot;,
                new Object[] { new Integer(ct++) }
        );

        setDisplayName(displayName);

    }</pre></li>

<p>O c&oacute;digo aqui &eacute; muito simples. A primeira chamada a um m&eacute;todo que voc&ecirc; ainda n&atilde;o escreveu, <tt>initComponents()</tt>, que adicionar&aacute; uma barra de ferramentas e um PaintCanvas ao seu <tt>TopComponent</tt>. Como voc&ecirc; ainda n&atilde;o escreveu o m&eacute;todo, uma linha vermelha aparece abaixo dele. Como antes, clique na l&acirc;mpada (ou pressione Alt-Enter) e aceite a sugest&atilde;o:

</p><p><img border="1" src="../../images/tutorials/paintapp/lightbulb-initcomponents-60.png" alt="L&acirc;mpada.">

</p><p>O esqueleto do m&eacute;todo <tt>initComponents()</tt> &eacute; gerado para voc&ecirc;.


	</p><li>Expanda o pacote <tt>org.netbeans.paint</tt> na janela Projetos. Clique duas vezes no arquivo <tt>Bundle.properties</tt> para abri-lo no editor de c&oacute;digo-fonte. Adicionando a linha seguinte no fim: 
    <pre class="examplecode">    UnsavedImageNameFormat=Image {0}</pre>
<p>Isso especifica o texto que ser&aacute; usado para identificar um novo arquivo de imagem no aplicativo antes de ser salvo pelo usu&aacute;rio. Por exemplo, quando um usu&aacute;rio clicar em Novo tela pela primeira vez em seu aplicativo conclu&iacute;do, aparecer&aacute; uma aba acima do editor de c&oacute;digo-fonte com o r&oacute;tulo, 'Image 0'. Salve o arquivo antes de continuar.
</p></li></ol>


<h3 class="tutorial"><a name="fillSkelMeth"></a>Preenchendo os m&eacute;todos do esqueleto</h3>

<p>Nesta se&ccedil;&atilde;o, codificamos a interface do usu&aacute;rio do nosso aplicativo. Tamb&eacute;m poder&iacute;amos usar o Construtor de GUIs do IDE para criar visualmente o layout.

   </p><ol>

<li>O m&eacute;todo <tt>initComponents()</tt> instala os componentes em seu painel, de forma que o usu&aacute;rio tenha algo com que interagir. Voc&ecirc; gerou seu m&eacute;todo de esqueleto durante a se&ccedil;&atilde;o anterior na classe <tt>PaintTopComponent.java</tt>. Preencha da seguinte forma:

<pre class="examplecode">    private void initComponents() {

        setLayout(new BorderLayout());
        JToolBar bar = new JToolBar();

        ColorChooser fg = new ColorChooser();
        preview = canvas.createBrushSizeView();

        //Now build our toolbar:

        //Make sure components don't get squished:
        Dimension min = new Dimension(32, 32);
        preview.setMaximumSize(min);
        fg.setPreferredSize(new Dimension(16, 16));
        fg.setMinimumSize(min);
        fg.setMaximumSize(min);

        JButton clear = new JButton(
          	    NbBundle.getMessage(PaintTopComponent.class, &quot;LBL_Clear&quot;));

        JLabel fore = new JLabel(
         	    NbBundle.getMessage(PaintTopComponent.class, &quot;LBL_Foreground&quot;));

        fg.addActionListener(this);
        clear.addActionListener(this);

        JSlider js = new JSlider();
        js.setMinimum(1);
        js.setMaximum(24);
        js.setValue(canvas.getDiam());
        js.addChangeListener(this);

        fg.setColor(canvas.getColor());

        bar.add(clear);
        bar.add(fore);
        bar.add(fg);
        JLabel bsize = new JLabel(
     	    NbBundle.getMessage(PaintTopComponent.class, &quot;LBL_BrushSize&quot;));

        bar.add(bsize);
        bar.add(js);
        bar.add(preview);

        JLabel spacer = new JLabel(&quot;   &quot;); //Just a spacer so the brush preview
        //isn't stretched to the end of the
        //toolbar

        spacer.setPreferredSize(new Dimension(400, 24));
        bar.add(spacer);

        //And install the toolbar and the painting component:
        add(bar, BorderLayout.NORTH);
        add(canvas, BorderLayout.CENTER);
        
    }</pre></li>
    <p>Pressione Ctrl-Shift-I para gerar as instru&ccedil;&otilde;es de importa&ccedil;&atilde;o necess&aacute;rias. 

</p><li>Preencha os outros dois m&eacute;todos que voc&ecirc; gerou. Eles s&atilde;o usados para ouvir a classe <tt>PaintTopComponent</tt>: 
<pre class="examplecode">    public void actionPerformed(ActionEvent e) {

        if (e.getSource() instanceof JButton) {
           canvas.clear();
        } else if (e.getSource() instanceof ColorChooser) {
           ColorChooser cc = (ColorChooser) e.getSource();
           canvas.setPaint (cc.getColor());
        }
        
        preview.paintImmediately(0, 0, preview.getWidth(), preview.getHeight());
        
    }</pre>

<pre class="examplecode">    public void stateChanged(ChangeEvent e) {

        JSlider js = (JSlider) e.getSource();
        canvas.setDiam (js.getValue());
        preview.paintImmediately(0, 0, preview.getWidth(), preview.getHeight());
        
    }</pre>
</li>
        <li>No arquivo <tt>Bundle.properties</tt>, adicione os pares chave-valor seguintes ao fim do arquivo:
<pre class="examplecode">
    LBL_Clear = Clear
    LBL_Foreground = Foreground 
    LBL_BrushSize = Brush Size
</pre>
<p>Salve o arquivo antes de continuar.

</p></li>
</ol>
    
<h3 class="tutorial"><a name="savingImage"></a>Salvando a imagem em disco</h3>

<p>Em seu novo aplicativo, seria uma boa id&eacute;ia permitir aos usu&aacute;rios salvar as imagens que eles criam. Incluindo o c&oacute;digo seguinte na classe <tt>PaintTopComponent</tt>, essa funcionalidade ser&aacute; ativada.</p>

 <ol type="1">
    <li>Insira o c&oacute;digo seguinte na classe <tt>PaintTopComponent</tt>:

<pre class="examplecode">    public void save() throws IOException {

        if (getDisplayName().endsWith(&quot;.png&quot;)) {
	    doSave(new File(getDisplayName()));
        } else {
	    saveAs();
        }
        
    }</pre>

<pre class="examplecode">    public void saveAs() throws IOException {

        JFileChooser ch = new JFileChooser();
        if (ch.showSaveDialog(this) == JFileChooser.APPROVE_OPTION &amp;&amp; ch.getSelectedFile() != null) {

	    File f = ch.getSelectedFile();
            
	    if (!f.getPath().endsWith(&quot;.png&quot;)) {
	        f = new File(f.getPath() + &quot;.png&quot;);
	    }
            
	    if (!f.exists()) {
            
	        if (!f.createNewFile()) {
		    String failMsg = NbBundle.getMessage(
		             PaintTopComponent.class,
			    &quot;MSG_SaveFailed&quot;, new Object[] { f.getPath() }
	            );
		    JOptionPane.showMessageDialog(this, failMsg);
		    return;
	        }
                
	    } else {
	        String overwriteMsg = NbBundle.getMessage(
		    PaintTopComponent.class,
                    &quot;MSG_Overwrite&quot;, new Object[] { f.getPath() }
	        );
                
	        if (JOptionPane.showConfirmDialog(this, overwriteMsg)
	        != JOptionPane.OK_OPTION) {
		    return;
	        }
                
	    }
            
	    doSave(f);
            
        }
        
    }</pre>

<pre class="examplecode">    private void doSave(File f) throws IOException {

        BufferedImage img = canvas.getImage();
        ImageIO.write(img, &quot;png&quot;, f);
        String statusMsg = NbBundle.getMessage(PaintTopComponent.class,
            &quot;MSG_Saved&quot;, new Object[] { f.getPath() });
        StatusDisplayer.getDefault().setStatusText(statusMsg);
        setDisplayName(f.getName());
        
    }</pre></li>

    <li>Adicione as linhas seguintes ao arquivo <tt>Bundle.properties</tt>:
<pre class="examplecode">    MSG_SaveFailed = Could not write to file {0}
    MSG_Overwrite = {0} exists.  Sobrescrever?    MSG_Saved = Saved image to {0}</pre>

<p>Salve o arquivo antes de continuar.

</p></li>

    <li>Clique em Ctrl-Shift-I para corrigir as instru&ccedil;&otilde;es de importa&ccedil;&atilde;o. Voc&ecirc; observar&aacute; que haver&aacute; dois nomes totalmente classificados para a classe <tt>File</tt>. Escolha a op&ccedil;&atilde;o <tt>java.io.File</tt>.
</li></ol>

</div><br>
<h2><a name="defNew"></a>Criando o item de menu Nova tela</h2>

<p>Use os modelos de arquivo de desenvolvimento de m&oacute;dulo para criar a base da funcionalidade do m&eacute;todo. Quando voc&ecirc; um modelo de arquivo, o IDE registra o item que voc&ecirc; cria no arquivo <tt>layer.xml</tt>. Depois de usar um assistente para criar o arquivo de modelo, use as <a href="https://netbeans.org/download/dev/javadoc/">APIs do NetBeans</a> para continuar a desenvolver o m&oacute;dulo.


      </p><ol>
	<li>Na janela Projetos, clique com o bot&atilde;o direito do mouse no n&oacute; do projeto do m&oacute;dulo Paint  e escolha Novo &gt; Arquivo/Pasta. No assistente para Novo arquivo, escolha Desenvolvimento de m&oacute;dulo do NetBeans em Categorias e A&ccedil;&atilde;o em Tipos de arquivo. Clique em Pr&oacute;ximo.</li>

<li>No painel Tipo de a&ccedil;&atilde;o, aceite os padr&otilde;es. Clique em Pr&oacute;ximo.
</li><li>No painel Registro de GUI, selecione Item de menu global e selecione Barra de ferramentas global. Defina os seguintes valores:
<p>
</p><ul><li><b>Categoria:</b> Editar
</li><li><b>Menu:</b> Arquivo
</li><li><b>Posi&ccedil;&atilde;o:</b> Qualquer lugar que voc&ecirc; desejar! 
</li><li><b>Barra de ferramentas:</b> Arquivo
</li><li><b>Posi&ccedil;&atilde;o:</b> Qualquer lugar que voc&ecirc; desejar! 
</li></ul>
<p><b class="notes">Observa&ccedil;&atilde;o:</b> O local em que voc&ecirc; posiciona a a&ccedil;&atilde;o n&atilde;o &eacute; importante, desde que ela esteja no menu Arquivo e na barra de ferramentas Arquivo.
</p><p>Agora voc&ecirc; deve ver o seguinte:
</p><p align="left"><img src="../../images/tutorials/paintapp/newcanvasaction-60.png" alt="Painel de registro da GUI.">

</p><p>Clique em Pr&oacute;ximo.
</p></li><li>No painel Nome, &iacute;cone e localiza&ccedil;&atilde;o, digite <tt>NewCanvasAction</tt> em Nome da classe e digite <tt>Nova tela</tt> em Nome de exibi&ccedil;&atilde;o. 

<p>Em &Iacute;cone, cole este &iacute;cone (clique com o bot&atilde;o direito do mouse aqui e em, seguida, salve-o na pasta <tt>org.netbeans.paint</tt>): <img src="../../images/tutorials/paintapp/new_icon.png" alt="&iacute;cone Nova tela.">

  </p></li><li>Clique em Terminar.</p>

<p>O IDE cria <tt>NewCanvasAction.java</tt> em <tt>org.netbeans.paint</tt> e abre-o no editor de c&oacute;digo-fonte. Isso &eacute; o que voc&ecirc; deve ver (clique nos links para ver o Javadoc relacionado da API NetBeans):

</p><pre class="examplecode">    package org.netbeans.paint;

    import <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/HelpCtx.html">org.openide.util.HelpCtx</a>;
    import <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/NbBundle.html">org.openide.util.NbBundle</a>;
    import <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/actions/CallableSystemAction.html">org.openide.util.actions.CallableSystemAction</a>;

    public final class NewCanvasAction extends CallableSystemAction {

       public void <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/actions/CallableSystemAction.html#performAction()">performAction()</a> {
   	// TODO implement action body
       }

       public String <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/actions/SystemAction.html#getName()">getName()</a> {
       	return NbBundle.getMessage(NewCanvasAction.class, &quot;CTL_NewCanvasAction&quot;);
       }
    
       protected String <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/actions/SystemAction.html#iconResource()">iconResource()</a> {
        return &quot;org/netbeans/paint/new_icon.png&quot;;
       }
    
       public HelpCtx <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/actions/SystemAction.html#getHelpCtx()">getHelpCtx()</a> {
        return HelpCtx.DEFAULT_HELP;
       }

       protected boolean <a href="https://netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/actions/CallableSystemAction.html#asynchronous()">asynchronous()</a> {
        return false;
       }
       
    }</pre>



<p>Como especificado no painel Registro da GUI, o IDE registra a classe da a&ccedil;&atilde;o como um item de menu e como um bot&atilde;o da barra de ferramentas no arquivo <tt>layer.xml</tt>.


</p></li><li>No editor de c&oacute;digo-fonte, abra <tt>NewCanvasAction.java</tt> e preencha o m&eacute;todo <tt>performAction()</tt> da seguinte forma:
 

<pre class="examplecode">    public void performAction() {

        PaintTopComponent tc = new PaintTopComponent();
	tc.open();
	tc.requestActive();       
        
    }</pre>
   <p>O que ele faz &eacute; simplesmente criar uma nova inst&acirc;ncia do nosso componente de edi&ccedil;&atilde;o de imagem, abri-lo, de modo que ele apare&ccedil;a na janela principal e ativ&aacute;-lo, enviando o foco do teclado para ele e selecionando sua aba.
  </p></li>

  <h2 class="tutorial"><a name="defSave"></a>Criando o item de menu Salvar tela</h2>

  <p>Como na se&ccedil;&atilde;o anterior, usamos o assistente para Novo a&ccedil;&atilde;o para criar um item de menu, dessa vez para salvar imagens.
   
 </p><ol>
	<li>Na janela Projetos, clique com o bot&atilde;o direito do mouse no n&oacute; do projeto do m&oacute;dulo Paint  e escolha Novo &gt; Arquivo/Pasta. No assistente para Novo arquivo, escolha Desenvolvimento de m&oacute;dulo do NetBeans em Categorias e A&ccedil;&atilde;o em Tipos de arquivo. Clique em Pr&oacute;ximo.</li>

<li>No painel Tipo de a&ccedil;&atilde;o, aceite os padr&otilde;es. Clique em Pr&oacute;ximo.
</li><li>No painel Registro de GUI, selecione Item de menu global e selecione Barra de ferramentas global. Defina os seguintes valores:
<p>
</p><ul><li><b>Categoria:</b> Editar
</li><li><b>Menu:</b> Arquivo
</li><li><b>Posi&ccedil;&atilde;o:</b> Qualquer lugar que voc&ecirc; desejar! 
</li><li><b>Barra de ferramentas:</b> Arquivo
</li><li><b>Posi&ccedil;&atilde;o:</b> Qualquer lugar que voc&ecirc; desejar!
</li></ul>
<p><b class="notes">Observa&ccedil;&atilde;o:</b> O local em que voc&ecirc; posiciona a a&ccedil;&atilde;o n&atilde;o &eacute; importante, desde que ela esteja no menu Arquivo e na barra de ferramentas Arquivo.


</p><p>Clique em Pr&oacute;ximo.
</p></li><li>No painel Nome, &iacute;cone e localiza&ccedil;&atilde;o, digite <tt>SaveCanvasAction</tt> em Nome da classe e digite <tt>Salvar tela</tt> em Nome de exibi&ccedil;&atilde;o. </p>

<p>Em &Iacute;cone, cole esse &iacute;cone (clique com o bot&atilde;o direito do mouse nele aqui e salve-o na pasta <tt>org.netbeans.paint</tt>): <img src="../../images/tutorials/paintapp/save_icon.png" alt="&iacute;ocne Salvar tela.">

  </p></li><li>Clique em Terminar.</p>

<p>O IDE cria <tt>SaveCanvasAction.java</tt> em <tt>org.netbeans.paint</tt> e abre-o no editor de c&oacute;digo-fonte. 

</p></li><li>No editor de c&oacute;digo-fonte, certifique-se de que <tt>SaveCanvasAction.java</tt> est&aacute; aberto e preencha o m&eacute;todo <tt>performAction()</tt> da seguinte forma:
 

<pre class="examplecode">    public void performAction() {

        TopComponent tc = TopComponent.getRegistry().getActivated();
        
        if (tc instanceof PaintTopComponent) {
        
	    try {
	       	((PaintTopComponent) tc).saveAs();
            } catch (IOException ioe) {
                ErrorManager.getDefault().notify (ioe);
            }
            
        } else {
        
            //Theoretically the active component could have changed
            //between the time the menu item or toolbar button was
            //pressed and when the action was invoked.  Not likely,
            //but theoretically possible
            Toolkit.getDefaultToolkit().beep();
            
        }               
        
    }</pre>
  <p>Pressione Ctrl-Shift-I para gerar as instru&ccedil;&otilde;es de importa&ccedil;&atilde;o necess&aacute;rias: 
  </p><p><img border="1" src="../../images/tutorials/paintapp/fiximports-60.png" alt="Corrigir importa&ccedil;&otilde;es.">

</p></li><li>Adicione um ouvinte de altera&ccedil;&atilde;o de propriedade, modificando a declara&ccedil;&atilde;o da classe:

<pre class="examplecode">    public final class SaveCanvasAction extends CallableSystemAction implements PropertyChangeListener {</pre>

<p>Uma linha vermelha aparece novamente. Pressione Alt-Enter para acionar a l&acirc;mpada e selecione a sugest&atilde;o:

</p><p><img border="1" src="../../images/tutorials/paintapp/lightbulb-listener1-60.png" alt="lightbulb-listener1">

</p><p>A linha vermelha aparece novamente. Repita o processo como antes e aceite a sugest&atilde;o:

</p><p><img border="1" src="../../images/tutorials/paintapp/lightbulb-listener2-60.png" alt="lightbulb-listener2">

</p><p>Preencha o m&eacute;todo <tt>propertyChange()</tt> gerado da seguinte forma:

</p><pre class="examplecode">    public void propertyChange(PropertyChangeEvent evt) {

        if (TopComponent.Registry.PROP_ACTIVATED.equals(evt.getPropertyName())){
	    updateEnablement();
        }
        
    }</pre><p>
        
    </p><p>Quando uma linha vermelha aparecer, clique em Alt + Enter para permitir ao IDE criar um m&eacute;todo <tt>updateEnablement()</tt> na classe <tt>SaveCanvasAction</tt>.</p>

<p>Em seguida, defina o m&eacute;todo <tt>updateEnablement()</tt>:

</p><pre class="examplecode">    private void updateEnablement() {

        setEnabled(TopComponent.getRegistry().getActivated()
        instanceof PaintTopComponent);

    }</pre><p>

</p><p>Finalmente, defina o construtor:

</p><pre class="examplecode">    public SaveCanvasAction() {  

        TopComponent.getRegistry().addPropertyChangeListener (
	    WeakListeners.propertyChange(this,
	    TopComponent.getRegistry()));
       
        updateEnablement();
        
    }</pre>
    
    <p>Quando uma linha vermelha aparece, clique em Alt + Enter para permitir ao IDE importar <tt>org.openide.util.WeakListeners</tt>.</p>

<p>O c&oacute;digo principal de interesse &eacute; a adi&ccedil;&atilde;o do ouvinte de altera&ccedil;&atilde;o de propriedade. <tt>TopComponent.Registry</tt> &eacute; um registro de todos os <tt>TopComponents</tt> abertos no sistema &mdash; todas as abas abertas. O que queremos fazer &eacute; ouvir as altera&ccedil;&otilde;es, e ativar e desativar a a&ccedil;&atilde;o dependendo do que possui o foco.

</p><p><b class="notes">Observa&ccedil;&atilde;o:</b> Em vez de anexar diretamente um ouvinte de altera&ccedil;&atilde;o de propriedade, chame <tt>WeakListeners.propertyChange()</tt>. O que ele faz &eacute; gerar um ouvinte de altera&ccedil;&atilde;o de propriedade que se refere ligeiramente &agrave; sua a&ccedil;&atilde;o. Na pr&aacute;tica, sua a&ccedil;&atilde;o existir&aacute; enquanto o aplicativo estiver aberto, &eacute; uma boa pr&aacute;tica e duradouro, usar um ouvinte fraco, se voc&ecirc; estiver anexando um ouvinte e n&atilde;o houver c&oacute;digo que o desanexe. Caso contr&aacute;rio, voc&ecirc; ter&aacute; um vazamento de mem&oacute;ria potencial &mdash; sua a&ccedil;&atilde;o nunca poderia ter o lixo recolhido porque o registro est&aacute; mantendo uma refer&ecirc;ncia a ele em sua lista de ouvintes.

  </p></li>

<p>Isso &eacute; o que voc&ecirc; deve ver agora na janela Projetos:

</p><p><img border="1" src="../../images/tutorials/paintapp/final-proj-window-60.png" alt="visualiza&ccedil;&atilde;o final da janela Projetos">

 </p><h2><a name="wrappingUp"></a>Empacotando</h2>
 <p>Obviamente, voc&ecirc; deseja criar um aplicativo, n&atilde;o um IDE &mdash; portanto, existem algumas etapas finais que podem ser realizadas para excluir os m&oacute;dulos do IDE e os elementos da interface do usu&aacute;rio de que voc&ecirc; n&atilde;o deseja ou precisa. Primeiro, voc&ecirc; cria uma tela de abertura do seu aplicativo, em seguida, remove os m&oacute;dulos desnecess&aacute;rios e, finalmente, cria uma distribui&ccedil;&atilde;o de ZIP e um aplicativo JNLP.

</p><ol>
	<li>Execute o projeto <tt>PaintApp</tt>. Depois que o aplicativo &eacute; iniciado, redimensione a tela principal de forma que fique bem pequena e desenhe uma tela de abertura. Use o bot&atilde;o Salvar para salvar a tela de abertura. </li>
    <li>No projeto original, clique com o bot&atilde;o direito do mouse no n&oacute; <tt>PaintApp</tt>, escolha Propriedades e, em seguida, clique em Construir na caixa de di&aacute;logo Propriedades do projeto.</li> 

    <li>Selecione Criar aplicativo independente. Agora voc&ecirc; pode especificar um nome de marca (que ser&aacute; o nome do iniciador que o IDE pode gerar para voc&ecirc;) e um t&iacute;tulo de aplicativo (que aparecer&aacute; na barra de t&iacute;tulo do aplicativo). Por padr&atilde;o, voc&ecirc; deve ver o seguinte:</p>

<p><img border="1" src="../../images/tutorials/paintapp/splashscreen1-60.png" alt="tela de abertura">
     
       </p></li><li>Clique em Tela de abertura. V&aacute; para a sua tela de abertura. Caso voc&ecirc; n&atilde;o tenha uma, use <a href="https://platform.netbeans.org/images/tutorials/paintapp/splash.gif">esta</a>. Clique em OK para anex&aacute;-la ao seu aplicativo:</li>
<p><img border="1" src="../../images/tutorials/paintapp/splashscreen-60.png" alt="tela de abertura">

</p><li>Clique em Bibliotecas, expanda o n&oacute; <tt>platform7</tt>. Esse &eacute; o &uacute;nico cluster que cont&eacute;m m&oacute;dulos que ser&atilde;o inclu&iacute;dos em seu aplicativo Paint. Os m&oacute;dulos verificados ser&atilde;o inclu&iacute;dos, os que n&atilde;o s&atilde;o ser&atilde;o exclu&iacute;dos. Observe que muitos j&aacute; foram exclu&iacute;dos. H&aacute; um que voc&ecirc; precisa excluir manualmente: <tt>Core UI</tt>. Fa&ccedil;a isso agora, desmarcando-o.</p>

  <p>Agora, no arquivo <tt>layer.xml</tt> do m&oacute;dulo do Paint, adicione as marcas seguintes na pasta Menu. Essas marcas removem os menos Ir para e Exibir, dos quais o aplicativo Paint n&atilde;o precisam.</p>

 <pre class="examplecode">&lt;file name=&quot;GoTo_hidden&quot;/&gt;
&lt;file name=&quot;View_hidden&quot;/&gt;</pre>

<p>Como alternativa, em vez de adicionar manualmente as marcas acima, voc&ecirc; pode excluir as pastas no n&oacute; <tt>&lt;esta camada no contexto&gt;</tt> do arquivo <tt>layer.xml</tt>. Para fazer isso, expanda <tt>&lt;esta camada no contexto&gt;</tt>, em seguida, expanda o n&oacute; Barra de menus. Escolha Excluir no menu do bot&atilde;o direito do mouse de ambos os n&oacute;s Ir para e Exibir.

</p></li><li>Finalmente, execute o aplicativo novamente e observe a tela de abertura. Quando o aplicativo tiver sido inicializado, observe que a barra de t&iacute;tulo exibe o t&iacute;tulo que voc&ecirc; especificou. Al&eacute;m disso, existem muito menos itens de menu, bot&atilde;o da barra de ferramenta e outros recursos:<br><br>

<p><img border="1" src="../../images/tutorials/paintapp/result-without-menus-60.png" alt="resultado sem menus">

</p></li>

<h2 class="tutorial"><a name="creatingDist"></a>Criando uma distribui&ccedil;&atilde;o</h2>
<p>
Agora, &eacute; hora de escolher o meio de distribui&ccedil;&atilde;o. Clique com o bot&atilde;o direito do mouse no n&oacute; <tt>PaintApp</tt> e escolha Criar distribui&ccedil;&atilde;o de ZIP para empacotar o aplicativo inteiro, com todos os m&oacute;dulos e arquivos necess&aacute;rios, como um arquivo zip. Voc&ecirc; tamb&eacute;m pode escolher Construir aplicativo JNLP para criar uma vers&atilde;o JavaWebStart&trade; do aplicativo que voc&ecirc; pode colocar em um servi&ccedil;o Web e vincular diretamente a partir de uma p&aacute;gina da Web (voc&ecirc; precisa definir uma URL correta &mdash; o descritor gerado usa arquivo: protocolo de forma que voc&ecirc; possa testar localmente sua distribui&ccedil;&atilde;o inici&aacute;vel via Web).
   
   
</p><p>Isso &eacute; tudo! Seu primeiro aplicativo constru&iacute;do sobre a Plataforma NetBeans est&aacute; conclu&iacute;do. Pr&oacute;xima parada: <a href="https://platform.netbeans.org/tutorials/60/nbm-feedreader.html">Tutorial Feed Reader da Plataforma NetBeans 6.0</a>.

<br>
</p><div class="feedback-box"><a href="https://netbeans.org/about/contact_form.html?to=3&amp;subject=Feedback: NetBeans Platform 6.0 Paint Application Tutorial">Envie-nos seus coment&aacute;rios</a></div>
<br style="clear:both;" />
<hr>
</ol></ol></ol></body>
</head></html>
