
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 13</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
<meta name="keywords" content="NetBeans, IDE, Platform, free, open source, developer" >
</head>
<body>
<style>
body {
		margin:5px 15px 5px 15px;
		font-size: 11px;
		font-family: Verdana, "Verdana CE",  Arial, "Arial CE", "Lucida Grande CE", lucida, "Helvetica CE", sans-serif;
		background-color:#e3eaf1;
		text-align:center;
}
				
#letter {width:533px;margin-left:auto;margin-right:auto;}
#head {background-image:url("http://services.netbeans.org/appl2/shared_images/head.png");width:533px;height:70px;background-repeat:none;}
#issue-date {padding-top:50px;text-align:center; color:white;}
#footer {background-image:url("http://services.netbeans.org/appl2/shared_images/footer.png"); width:533px;height:28px;background-repeat:none;}
#footer-text {padding-top:5px;color:#6a6b6d;text-align:center;}
#content {border-right:3px solid #747d9e;border-left:3px solid #747d9e; background-color:white; text-align:left; color:#6a6b6d; padding:13px 20px 13px 13px; }
#letter h1 {font-size: 14px; font-weight:normal; margin:3px 0px 5px 0px; padding:0px;color: #EE6B00; border-bottom:1px solid silver;}
#letter h2 {color:#2C3C79;font-size: 13px; font-weight:normal;margin:0px 0px 2px 0px;padding:0px; border:0px;}
#letter p {padding: 0px;margin:0px; text-align:justify;}
#letter a:link, a:visited { color: #045491; font-weight : normal; text-decoration: none;}
#letter a:link:hover, a:visited:hover  { color: #045491; font-normal : bold; text-decoration : underline;}
.item {margin-left:8px; margin-bottom:9px;}
.bold {font-weight:bold;}
#letter a.orange {color: #EE6B00;}
.align-right {text-align:right;}     
.align-center {text-align:center;}  
.edited {margin:15px -20px 0px -13px;padding-top:8px;text-align:center;}
.edge-top {background-color: #f0f7ff;padding:7px 12px 7px 7px;margin-bottom:10px; border:1px solid #747d9e;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Edição # 13 - May 30, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2030">Estão disponíveis as correções de bugs para o NetBeans IDE 6.1</a></h2>
						<p style="margin-left:8px;">
						NetBeans.org liberou um novo patch de atualização para o NetBeans IDE 6.1. O patch inclui correção de bugs nos módulos BPEL, C/C++, Database, Edição de arquivos, Construtor Gráfico, Plataforma IDE, Java, Depurador Java, Java EE, Persistência Java, Servidor de Aplicações JBoss, Mercurial, Mobilidade, Desenvolvimento de Plugin do NetBeans, Serviços Web RESTful, Ruby e Rails, SOA, Spring Web MVC, UML, Visual JSF, Visual Mobility Designer, Aplicações Web, Serviços Web, e XML e Schema.

Para obter as correções, o NetBeans precisa estar instalado e em execução. Você pode baixar as correções através da Central de Atualizações do IDE.</p>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2040">Eleições da Câmara de Administração - Candidaturas fechadas</a></h2>
						<p style="margin-left:8px;">
						O prazo final para as candidaturas foi terça-feira, 27 de maio, meia noite no último fuso horário. Para conhecer os atuais candidatos e para mais informações visite a página das Eleições da Câmara. A votação começa na quarta-feira, 28 de maio.</p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2035">Comentar/Descomentar linhas em HTML, JSP, XML</a></h2>
						<p style="margin-left:8px;">
						Ctrl-Shift-C ou Ctrl-/ comenta as linhas em arquivos Java. Mas como é para os arquivos HTML, XML e JSP? O NetBeans IDE 6.1 não fornece suporte para comentários de linhas nestes tipos de arquivos. Baixe este plugin e adicione esta funcionalidade!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2036">Dois atalhos de teclado do NetBeans que irão mudar a sua vida (para sempre)</a></h2>
						<p style="margin-left:8px;">
						Existem muitos atalhos de teclado legais do NetBeans , mas estes dois, em destaque no NetBeans Zone, são realmente especiais. É sério, teste estes dois e você vai gostar ainda mais do editor Java do NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2037">Aplicação de estudo da Bíblia baseado na Plataforma NetBeans</a></h2>
						<p style="margin-left:8px;">
						Kiyut na Indonésia liberou um toolkit avançado de estudo da Bíblia construído em cima da Plataforma NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2038">NetBeans.tv: Tocador embutido</a></h2>
						<p style="margin-left:8px;">
						Existe agora um tocador do NetBeans.tv muito legal que você pode embutir em seu blog, ou em qualquer outro site, para que seus leitores assistam aos vídeos com mais qualidade do que o YouTube. Também ficou mais fácil enviar vídeos para compartilhar com outras pessoas. O blog do Geertjan mostra como fazer.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2039">Suporte ao JavaScript e PHP no NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						Nesta entrevista do artima.com, Frank Sommers e Gregg Sporar da Sun discutem o crescimento do suporte à linguagens do NetBeans com foco no suporte ao JavaScript e PHP.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2031">Arraste e solte códigos snippets dentro da paleta</a></h2>
						<p style="margin-left:8px;">
						Os usuários do NetBeans têm perguntado por funcionalidades que permitam arrastar códigos snippets dentro da paleta. Dessa maneira você pode construir uma paleta de snippets personalizados que você pode reutilizar mais facilmente. Stan Aubrecht, o engenheiro do NetBeans responsável pela API da Paleta, lhe fornece uma visualização desta funcionalidade em seu blog. Você já pode utilizar isto se você tiver uma versão de desenvolvimento do NetBeans pós 6.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2032">Plugin NetBeans de um membro da Comunidade Chinesa - Notificador Gmail</a></h2>
						<p style="margin-left:8px;">
						<a href="http://blog.csdn.net/DL88250">Liang Ding(88250)</a>, da <a href="http://zh-cn.netbeans.org/community">Comunidade Chinesa</a>, criou um novo plugin de Notificação do Gmail que está disponível no <a href="http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=9558">Plugin Portal</a>.

Características incluídas:<br>
* verificação automática da caixa de mensagens<br>
* auto exibição deslizante do assunto da mensagem<br>
* notificação em forma de dica<br>
* aviso sonoro de nova mensagem<br>

Utilização:<br>
* Clicar com o botão esquerdo abrirá o Gmail no seu navegador web<br>
* Clicar com o botão direito irá verificar seus novos e-mails<br>
* Configure a conta do Gmail na caixa de diálogo Ferramentas -> Opções<br></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2033">O Derby embutido e o Bean Binding com o NetBeans 6</a></h2>
						<p style="margin-left:8px;">
						Por Prakan Puvibunsuk. Um vídeo fantástico de demonstração que mostra o banco de dados Derby embutido e o bean binding no NetBeans 6.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2034">GlassFish Incorporável em ação - Servlet em um projeto Maven</a></h2>
						<p style="margin-left:8px;">
						Este blog fala como fazer para hospedar um Servlet utilizando as APIs de incorporabilidade do GlassFish e escreve um simples teste do Maven para chamar o Servlet -  tudo dentro da mesma VM.</p>
					</div>
	<div class="edited">
	Esta edição foi enviada para você por: Henrique Meira<br/>Se você não deseja receber este boletim, <a href="https://netbeans.org/community/lists/top.html">remova sua inscrição aqui</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				Este boletim também é acessível em   <a href="https://netbeans.org/community/news/newsletter/2008-05-30_pt_BR.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive_pt_BR.html">arquivo de boletins</a>
		</div>
	</div>

</body>
</html>