<!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>
    <!-- -*- xhtml -*- -->
    <title>Tutorial do aplicativo Paint para a Plataforma NetBeans 6.8</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="gwielenga@netbeans.org"/>
    <meta name="indexed" content="y"/>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <meta name="description"
          content="A guide to creating a Paint application."/>
   <!--      Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. -->
        <!--     Use is subject to license terms.-->
</head>
<body>

<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><strong class="notes">Nota:</strong> este documento utiliza a vers&atilde;o NetBeans IDE 6.5. Se voc&ecirc; estiver utilizando o NetBeans IDE 0.x, consulte <a href="60/nbm-paintapp_pt_BR.html">a vers&atilde;o 6.0/6.1 deste documento</a>.</p>
   
    <p><b>Conte&uacute;do</b></p>
   
   <p><img src="../images/articles/69/netbeans-stamp7-8-9.png" class="stamp" width="114" height="114" alt="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 6.5, 6.7, 6.8" title="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 6.5, 6.7, 6.8" /></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>
     <ul>
         <li><a href="#creatingModuleSuite">Criando o esqueleto do aplicativo</a></li>
         <li><a href="#creatingLibWrapModule">Criando o m&oacute;dulo de wrapper de bibliotecas</a></li>
         <li><a href="#creatingModProj">Criando o m&oacute;dulo</a></li>
         <li><a href="#specifyingModProjDep">Especificando as depend&ecirc;ncias do m&oacute;dulo</a></li>
     </ul></li>
     <li><a href="#impMod">Criando e incorporando a tela do Paint</a>
     <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>
     <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, os softwares e recursos listados na tabela seguinte s&atilde;o necess&aacute;rios.</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"><a href="https://netbeans.org/downloads/index.html">NetBeans IDE</a></td>
                <td class="tbltd1">vers&atilde;o 6.7 ou superior</td>
            </tr>
            <tr>
                <td class="tbltd1"><a href="http://java.sun.com/javase/downloads/index.jsp">Java Developer Kit (JDK)</a></td>
                <td class="tbltd1">Vers&atilde;o 6 ou<br/>vers&atilde;o 5</td>
            </tr>
        </tbody>
    </table>

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

<p>Este tutorial foi concebido para come&ccedil;ar o mais r&aacute;pido poss&iacute;vel. Voc&ecirc; gerar&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:</p>

 <p><img 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">Nota:</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><img src="../images/tutorials/paintapp/sample-in-new-project-60.png" alt="Painel Nome e localiza&ccedil;&atilde;o" /></p>

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

<p>Nesta se&ccedil;&atilde;o, a estrutura do aplicativo ser&aacute; criada. Primeiro &eacute; preciso criar o esqueleto de um aplicativo, o que pode ser feito atrav&eacute;s de um assistente. O aplicativo depende de uma biblioteca, assim, voc&ecirc; tamb&eacute;m gerar&aacute; criar um m&oacute;dulo de wrapper de bibliotecas que conter&aacute; o arquivo JAR da biblioteca. Finalmente, voc&ecirc; gerar&aacute; criar o m&oacute;dulo que conter&aacute; o c&oacute;digo.</p>
 
<div class="indent">
    
<p><a name="creatingModuleSuite"></a></p><h3 class="tutorial">Criando o esqueleto do aplicativo</h3>

<p>O modelo &quot;Aplicativo da plataforma NetBeans&quot; gerar&aacute; criar o esqueleto do aplicativo. O esqueleto consistir&aacute; em um conjunto de m&oacute;dulos que funcionam juntos para formar a base do aplicativo. Voc&ecirc; utilizar&aacute; a caixa de di&aacute;logo Propriedades do projeto para atribuir a tela inicial do aplicativo, o nome do aplicativo e o tipo e o n&uacute;mero de m&oacute;dulos NetBeans que deseja utilizar. Tamb&eacute;m &eacute; poss&iacute;vel 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 Aplicativo da plataforma NetBeans:
 <p><img src="../images/tutorials/paintapp/paintapp-proj-wiz.png" alt="modelo de projeto" /></p>
 <p>Clique em Pr&oacute;ximo.</p></li>
	<li>No painel Nome e local, digite <tt>PaintApp</tt> em Nome do projeto. Altere Local de projeto para qualquer diret&oacute;rio no computador. Deixe marcada a caixa de verifica&ccedil;&atilde;o Definir como projeto principal. Clique em Terminar.</li>

      </ol>

<p>O novo esqueleto do aplicativo &eacute; aberto no IDE. Ele cont&eacute;m dois n&oacute;s na janela Projetos. O primeiro n&oacute;, o n&oacute; &quot;M&oacute;dulos&quot;, &eacute; para adi&ccedil;&atilde;o manual de m&oacute;dulos e m&oacute;dulos de wrapper de bibliotecas no aplicativo. Al&eacute;m disso, ao utilizar o assistente para M&oacute;dulo ou o assistente para M&oacute;dulo de wrapper de bibliotecas, o m&oacute;dulo que voc&ecirc; criar poder&aacute; ser adicionado automaticamente ao aplicativo.</p>

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

<p>Um m&oacute;dulo de wrapper de biblioteca &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, &eacute; poss&iacute;vel 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">Nota:</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 utilizado 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 (&eacute; poss&iacute;vel encontrar o c&oacute;digo-fonte para tal no NetBeans CVS em <tt>contrib/coloreditor</tt>). O arquivo JAR &eacute; nomeado <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. </p>

 <p>Para criar um m&oacute;dulo de wrapper de bibliotecas para o arquivo <tt>ColorChooser.jar</tt> fa&ccedil;a o seguinte:</p>

  <ol>
<li>Escolha Arquivo &gt; Novo projeto. Em Categorias, selecione M&oacute;dulos do NetBeans. Em Projetos, selecione M&oacute;dulo de wrapper de bibliotecas e clique em Pr&oacute;ximo.</li>
      <li>No painel Selecionar biblioteca, 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. Clique em Pr&oacute;ximo.</li>
 <li>No painel Nome e localiza&ccedil;&atilde;o, preencha o nome do projeto, defina o local do projeto e certifique-se de que a lista suspensa Adicionar &agrave; su&iacute;te de m&oacute;dulos mostra que o m&oacute;dulo ser&aacute; adicionado ao aplicativo. Clique em Pr&oacute;ximo.</li>
 <li>No painel Configura&ccedil;&atilde;o b&aacute;sica de m&oacute;dulos, digite um nome exclusivo no nome base do c&oacute;digo, especifique um nome de exibi&ccedil;&atilde;o para o m&oacute;dulo e o local do pacote de localiza&ccedil;&atilde;o do m&oacute;dulo:

<p><img src="../images/tutorials/paintapp/lib-wrap-1.png" alt="Painel Nome e localiza&ccedil;&atilde;o" /></p>

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

<p>O m&oacute;dulo que empacota o <tt>colorchooser.jar</tt> selecionado &eacute; criado pelo IDE. A estrutura do novo m&oacute;dulo &eacute; mostrada na janela Projetos. O n&oacute; &quot;M&oacute;dulos&quot; na estrutura do aplicativo mostra que o m&oacute;dulo faz parte do aplicativo.</p>

<h3 class="tutorial"><a name="creatingModProj"></a>Criando o m&oacute;dulo</h3>
 <p>Agora, &eacute; preciso 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 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 o aplicativo <tt>PaintApp</tt> esteja selecionado 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, digite <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 pacote de localiza&ccedil;&atilde;o. Clique em Gerar camada XML e n&atilde;o altere o local sugerido, para que o pacote de localiza&ccedil;&atilde;o e o arquivo de camada XML sejam armazenados em um pacote com o nome <tt>org.netbeans.paint</tt>. 
 <p>Esses destinos fazem o seguinte:</p>
 <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> Registra itens como menus e bot&otilde;es da barra de ferramentas no aplicativo da plataforma NetBeans. 
</li>
 </ul>


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

<p> O IDE cria o projeto <tt>Paint</tt>. O projeto cont&eacute;m todos os metadados de projeto e c&oacute;digos-fonte, como o script de constru&ccedil;&atilde;o Ant do projeto. O projeto se abre no IDE. &Eacute; poss&iacute;vel 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><img src="../images/tutorials/paintapp/paintapp-start-1.png" alt="paint app" /></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 bundle e a vers&atilde;o do m&oacute;dulo.</li>
 <li><b>Script de constru&ccedil;&atilde;o.</b> Fornece um local onde &eacute; poss&iacute;vel 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>N&atilde;o ser&aacute; preciso modificar qualquer um desses arquivos durante este tutorial.</p>



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



<p>&Eacute; preciso criar subclasses de v&aacute;rias classes que pertencem &agrave;s <a href="http://bits.netbeans.org/dev/javadoc/index.html">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.
 
 <table width="76%" border="1">
 <tbody>
   <tr>
 <td>
	<div><b>Classe</b></div>
      </td>
      <td>
        <div><b>API</b></div>
      </td>
     
      <td>
	<div><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 criado</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 utilizada 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>A primeira coluna na tabela acima, lista todas as classes cuja subclasse ser&aacute; criada neste tutorial. Em cada caso, comece a digitar o nome da classe no filtro e veja a lista M&oacute;dulo diminuir. Utilize a segunda coluna da tabela para selecionar a API apropriada (ou, no caso de <tt>ColorChooser</tt>, a biblioteca) na lista M&oacute;dulo diminu&iacute;da e clique em OK para confirmar a escolha:</p>

<p><img 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>
    </div>
    <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, um componente Swing puro &eacute; utilizado: 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 o wrapper de biblioteca foi criado, &eacute; utilizado no c&oacute;digo-fonte desse painel: quando voc&ecirc; executar o aplicativo conclu&iacute;do, gerar&aacute; v&ecirc;-lo na barra de ferramentas do painel para edi&ccedil;&atilde;o de imagens.</p>
    <ol>
	<li>Na janela Projetos, expanda o n&oacute; <tt>Paint</tt>e, 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>Insira <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 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>
  
    <h3 class="tutorial"><a name="prepTopComp"></a>Preparando a classe TopComponent</h3>

<p>Agora sua primeira classe que utiliza as <a href="http://bits.netbeans.org/dev/javadoc/index.html">APIs do NetBeans</a> ser&aacute; escrita. Trata-se de uma classe <tt><a href="http://bits.netbeans.org/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>
		<li>Na janela Projetos, expanda o n&oacute; <tt>Paint</tt>e, 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. 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>
        <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>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 src="../images/tutorials/paintapp/lightbulb-60.png" alt="L&acirc;mpada." /></p>

Selecione Implementar todos os m&eacute;todos abstratos. O IDE gera dois esqueletos de m&eacute;todo: <tt>actionPerformed()</tt> e <tt>stateChanged()</tt>. Voc&ecirc; os experimentar&aacute; neste tutorial.</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 &eacute; preciso 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; utilizado ao salvar o <tt>TopComponent</tt>. Insira os dois m&eacute;todos seguintes na classe <tt>PaintTopComponent</tt>:
<pre class="examplecode">    @Override
    public int getPersistenceType() {
        return PERSISTENCE_NEVER;
    }

    @Override
    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() {
    }
    
    @Override
    public void actionPerformed(ActionEvent arg0) {
        throw new UnsupportedOperationException(&quot;Not supported yet.&quot;);
    }
    
    @Override
    public void stateChanged(ChangeEvent arg0) {
        throw new UnsupportedOperationException(&quot;Not supported yet.&quot;);
    }
    
    @Override
    public int getPersistenceType() {
        return PERSISTENCE_NEVER;
    }
    
    @Override
    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>
    <li>Defina o construtor e depois corrija as senten&ccedil;as import (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>

<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 o m&eacute;todo ainda n&atilde;o foi escrito, 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 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>


	<li>Expanda o pacote <tt>org.netbeans.paint</tt> na janela Projetos. Clique duas vezes no arquivo <tt>Bundle.properties</tt> para abr&iacute;-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; utilizado 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 Nova 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 utilizar 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. O m&eacute;todo de esqueleto foi gerado 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>
    <p>Pressione Ctrl-Shift-I para gerar as instru&ccedil;&otilde;es de importa&ccedil;&atilde;o necess&aacute;rias. </p></li>

<li>Preencha os outros dois m&eacute;todos gerados. Eles s&atilde;o utilizados 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>
    <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();
        }
        
    }

    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);
            
        }
        
    }

    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>
<h2><a name="defNew"></a>Criando o item de menu Nova tela</h2>

<p>Utilize os modelos de arquivo de desenvolvimento de m&oacute;dulo para criar a base da funcionalidade do m&eacute;todo. Quando um modelo de arquivo &eacute; utilizado, o IDE registra o item que voc&ecirc; cria no arquivo <tt>layer.xml</tt>. Depois de utilizar um assistente para criar o arquivo de modelo, utilize 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; Outro. No assistente para Novo arquivo, escolha Desenvolvimento de m&oacute;dulo 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:
<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">Nota:</b> O local em que a a&ccedil;&atilde;o &eacute; posicionada 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><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, navegue at&eacute; 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><p>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. Isto &eacute; o que voc&ecirc; deve ver:</p>

<pre class="examplecode">/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.netbeans.paint;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public final class NewCanvasAction implements ActionListener {

    public void actionPerformed(ActionEvent e) {
        // TODO implement action body
    }
    
}</pre>



<p>Como especificado no painel Registro da GUI, o IDE registra a classe da a&ccedil;&atilde;o como um item e menu e um bot&atilde;o da barra de ferramentas no arquivo <tt>layer.xml</tt>, junto com informa&ccedil;&otilde;es sobre o &iacute;cone e o nome de exibi&ccedil;&atilde;o.</p></li>


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

<pre class="examplecode">    public void actionPerformed(ActionEvent e) {
        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, abr&iacute;-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>
  </ol>

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

  <p>Como na se&ccedil;&atilde;o anterior, utilizamos o assistente para Nova a&ccedil;&atilde;o a fim de 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; Outro. No assistente para Novo arquivo, escolha Desenvolvimento de m&oacute;dulo 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:

 <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">Nota:</b> o local em que a a&ccedil;&atilde;o &eacute; posicionada n&atilde;o &eacute; importante, desde que ela esteja no menu Arquivo e na barra de ferramentas Arquivo.</p>


Clique em Pr&oacute;ximo.</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>Em &Iacute;cone, cole esse &iacute;cone (clique com o bot&atilde;o direito do mouse aqui e salve-o na pasta <tt>org.netbeans.paint</tt>):</p>
    <img src="../images/tutorials/paintapp/save_icon.png" alt="Salvar &iacute;cone de tela." /></li>

  <li>Clique em Terminar.

<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>Altere a assinatura da classe para que <tt>CallableSystemAction</tt> seja estendida e <tt>PropertyChangeListener</tt> seja implementada:
  
  <pre class="examplecode">public final class SaveCanvasAction extends CallableSystemAction implements PropertyChangeListener</pre></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>actionPerformed()</tt> da seguinte forma:

<pre class="examplecode">    @Override
    public void actionPerformed(ActionEvent e) {
        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>
  <img src="../images/tutorials/paintapp/fiximports-60.png" alt="Corrigir importa&ccedil;&otilde;es." /></li>

<li>Preencha os m&eacute;todos da classe <tt>CallableSystemAction</tt> da seguinte maneira:

<pre class="examplecode">    @Override
    public String getName() {
        return &quot;Save Canvas&quot;;
    }

    @Override
    public HelpCtx getHelpCtx() {
        return null;
    }
</pre>   </li>

<li>Preencha o m&eacute;todo <tt>propertyChange()</tt> da classe <tt>PropertyChangeListener</tt> da seguinte maneira:

<pre class="examplecode">    @Override    
    public void propertyChange(PropertyChangeEvent evt) {

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

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

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

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

    }</pre></li>

<li>Finalmente, defina o construtor:

<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: 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>

<b class="notes">Nota:</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 e duradoura pr&aacute;tica, utilizar um ouvinte fraco, se um ouvinte estiver anexado 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: 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.
 </li>
  </ol>

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

  <p><img src="../images/tutorials/paintapp/final-paint-module.png" alt="visualiza&ccedil;&atilde;o final da janela Projetos" /></p>

 <h2><a name="wrappingUp"></a>Empacotando</h2>
 <p>&Eacute; claro que voc&ecirc; deseja criar um aplicativo aprimorado. Assim, h&aacute; algumas etapas finais que podem ser realizadas. Primeiro, crie uma tela de abertura para o aplicativo e, em seguida, 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. Utilize 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 &eacute; poss&iacute;vel 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). Como padr&atilde;o, voc&ecirc; deve ver o seguinte:

<p><img 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. Se n&atilde;o possuir uma, utilize <a href="https://platform.netbeans.org/images/tutorials/paintapp/splash.gif">esta</a>. Clique em OK para anex&aacute;-la ao seu aplicativo:
<p><img src="../images/tutorials/paintapp/splashscreen-60.png" alt="tela de abertura" /></p></li>

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

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

<p>Alternativamente, em vez de adicionar manualmente as marcas acima, &eacute; poss&iacute;vel 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> e, 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&otilde;es da barra de ferramentas e outros recursos: <img src="../images/tutorials/paintapp/result-without-menus-60.png" alt="resultados sem menus" />
</li>
</ol>

<h2 class="tutorial"><a name="creatingDist"/>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! Voc&ecirc; completou seu aplicativo constru&iacute;do sobre a plataforma NetBeans. Pr&oacute;xima parada: <a href="https://platform.netbeans.org/tutorials/nbm-feedreader.html">Tutorial Feed Reader da Plataforma NetBeans</a>.</p>

<div class="feedback-box"><a href="https://netbeans.org/about/contact_form.html?to=3&amp;subject=Feedback: NetBeans Platform Paint Application Tutorial">Envie-nos seus coment&aacute;rios</a></div>

</body>
</html>
