
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 84</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/appl/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/appl/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 # 84 - Jan 03, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5956">Patch3 para o NetBeans IDE 6.9.1 já está disponível</a></h2>
						<p style="margin-left:8px;">
						A equipe do NetBeans disponibilizou um novo patch, que é uma atualização para o NetBeans IDE 6.9.1. O pacote inclui correções de bugs nos módulos para C/C++, Platforma IDE, Java e PHP. Obtenha mais <a href="http://wiki.netbeans.org/NetBeans6.9PatchesInfo">informações sobre os patches do NetBeans IDE 6.9</a>. Para obter as correções, o NetBeans IDE deve estar instalado e funcionando. Você pode baixar as correções através do Gerenciador de Plugin do IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5954">Suporte ao Glassfish para NetBeans IDE 7.0</a></h2>
						<p style="margin-left:8px;">
						Vince Kraemer da equipe GlassFish fala dos mais recentes desenvolvimentos sobre o plugin GlassFish para o NetBeans IDE 7.0. E ele gostaria de conhecer seus comentários e ideias!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5955">Plugin: Histórico da área de transferência</a></h2>
						<p style="margin-left:8px;">
						Veja um módulo que implementa uma área de transferência que mantém controle de itens copiados para que eles possam ser colados mais tarde.</p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5951">Nova versão do NetBeans IDE para cegos</a></h2>
						<p style="margin-left:8px;">
						Andreas Stefik da Southern Illinois University Edwardsville anuncia o mais recente lançamento de um ambiente de programação para cegos, baseado no NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5952">Versão inicial do Perl IDE</a></h2>
						<p style="margin-left:8px;">
						Um novo IDE está sendo criado em cima do NetBeans IDE, especialmente para os desenvolvedores Perl. Leia tudo sobre ele aqui - especialmente se você quiser contribuir com código para este novo projeto ou fornecer feedback sobre o status atual.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5953">NetBeans no JavaOne China</a></h2>
						<p style="margin-left:8px;">
						Muitas atividades relacionadas ao NetBeans ocorreram no JavaOne China, leia sobre isso aqui, e veja as fotos.</p>
					</div>
				<h1>Tutoriais</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5948">Como estender tipos de projetos existentes</a></h2>
						<p style="margin-left:8px;">
						Criando seus próprios tipos de projeto usando a API do NetBeans? Talvez você pode estender um tipo de projeto existentes em vez disso, através deste recente lançamento da do tutorial da Plataforma NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5949">Modelos de código no NetBeans IDE para PHP</a></h2>
						<p style="margin-left:8px;">
						Este tutorial descreve os modelos de código PHP disponíveis no NetBeans IDE, como usá-los, e alguns casos de uso.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5950">Conclusão do tutorial e-commerce do NetBeans</a></h2>
						<p style="margin-left:8px;">
						A série do Tutorial NetBeans Ecommerce chega ao fim com uma demonstração ao vivo de um aplicativo de comércio eletrônico simples, que foi construído aos poucos ao longo da série, utilizando tecnologias baseadas em Java e NetBeans IDE.</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5945">Treinamento em Linz, Áustria</a></h2>
						<p style="margin-left:8px;">
						Anton Epple e Jaroslav Tulach voltou para Linz, na Áustria, para mais uma interessante sessão de treinamento na universidade.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5946">Treinamento em Belgrado, Sérvia</a></h2>
						<p style="margin-left:8px;">
						O Grupo de Usuários NetBeans Sérvia tiveram seu primeiro treinamento da Plataforma NetBeans na universidade.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5947">Treinamento na Dinamarca</a></h2>
						<p style="margin-left:8px;">
						O treinamento da Plataforma NetBeans será realizado em janeiro, em Odense, Dinamarca, enquanto um breve resumo foi apresentado recentemente, conforme descrito neste artigo.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5943">Esquema de cores Deserto para o NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Mude o tema de fundo do seu NetBeans IDE com a implementação de esquema de cores Deserto de Mark Fearby. Seu blog inclui uma tela e um link para obter o arquivo.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5944">JDK 7 e NetBeans 7</a></h2>
						<p style="margin-left:8px;">
						Adam Bien aprova o suporte ao JDK 7 do NetBeans 7, depois de assistir a uma demonstração ao vivo no JavaOne China, em Pequim.</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_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</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/2011-01-03_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>