
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 43</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 # 43 - Feb 13, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4759">Patch 1 para o NetBeans IDE 6.8 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.8. O patch inclui algumas <a href="http://wiki.netbeans.org/NetBeans6.8PatchesInfo">correções de bugs</a>. Para obter as correções, o NetBeans IDE 6.8 precisa estar instalado e rodando. Obtenha o patch usando o gerenciador de Plugins do IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4758">Dê seu feedback sobre a nova funcionalidade do PHP: símbolo de erro</a></h2>
						<p style="margin-left:8px;">
						A equipe do NetBeans PHP quer seu feedback sobre um recurso experimental que pode fazer parte do NetBeans 6.9: símbolo de erro. Se você tem um arquivo PHP com qualquer erro, o arquivo pode ser marcado diretamente na janela Projetos. Este recurso é útil? Diga à equipe.</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4756">Swing e Twitter com Java e NetBeans</a></h2>
						<p style="margin-left:8px;">
						Neste tutorial Alfonso Romero descreve como construir uma aplicação personalizada para o Twitter usando Java e NetBeans, ao invés de usar a interface padrão da web.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4757">Suporte RTSP em aplicativos JavaFX</a></h2>
						<p style="margin-left:8px;">
						O Suporte Real-Time Streaming Protocol (RTSP) está disponível no SDK do JavaFX desde a versão 1.2. Este documento esclarece quais plataformas suportam esta funcionalidade, e fornece recomendações básicas para possibilitar o streaming de mídia em seu aplicativo.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4755">Adicionando um seletor de arquivos para um aplicativo Java</a></h2>
						<p style="margin-left:8px;">
						Aprenda a adicionar um seletor de arquivos para um aplicativo Java, utilizando o componente javax.swing.JFileChooser e o construtor de interfaces gráficas do NetBeans.</p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4753">Vídeo: JavaFX & NetBeans IDE na Jfokus 2010</a></h2>
						<p style="margin-left:8px;">
						Desenvolvedores do Epsilon, um empresa sueca de consultoria em tecnologia e sistemas, são fãs do JavaFX e do NetBeans IDE. Na apresentação do Jfokus 2010, eles demonstrarão um projeto e irão discutir o uso das duas tecnologias.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4754">JavaFX Composer - Um grande passo para o JavaFX?</a></h2>
						<p style="margin-left:8px;">
						O JavaFX Composer é um novo plugin visual do editor NetBeans 6.8 (similar ao do Projeto Matisse para Swing). O DZone entrevistou membros da equipe de desenvolvimento do JavaFX para ficar sabendo dos comentários dos usuários da ferramenta. Mais ferramentas como o JavaFX Composer podem levar a um aumento de aplicativos baseados em JavaFX, tais como o aplicativo de visualização de medalhas do site da Olimpíada de Inverno de 2010.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4752">Crie seu próprio sistema de janela</a></h2>
						<p style="margin-left:8px;">
						Sabia que você pode criar um sistema de janelas personalizadas na API de Sistema de Janela do NetBeans? Que pode se integrar com outros idiomas do NetBeans? Saiba mais nesta reportagem do blog de Geertjan Wielenga e Toni Epple.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4751">Conecte ao banco de dados Oracle usando o NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A 107a. "Dica do Dia" de Arun Gupta, explica como se conectar ao banco de dados Oracle com o NetBeans IDE para aproveitar todos os recursos fornecidos pelo IDE para desenvolvimento de aplicações Java EE, Rails, e outros.</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/2010-02-13_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>