
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 46</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 # 46 - Mar 07, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4829">Os 10 atalhos mais interessantes do NetBeans</a></h2>
						<p style="margin-left:8px;">
						Aqui está um pacote com coisas que Geertjan Wielenga tem adicionado ao cartão de atalhos (alguns novos, alguns antigos que não tinham sido incluídos antes) que você pode achar interessantes também.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4827">Criando uma interface SVG sensível ao toque para dispositivos Java ME</a></h2>
						<p style="margin-left:8px;">
						Este tutorial mostra como desenvolver interfaces ricas para Java ME com dispositivos de tela sensível ao toque. As widgets descritas aqui são suportadas em dispositivos com ou sem telas sensíveis ao toque.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4828">Análise de I/O em projetos C/C++ no Solaris</a></h2>
						<p style="margin-left:8px;">
						A ferramenta de uso de disco do NetBeans mostra um gráfico de leitura e escrita sobre o seu projeto C/C++. Você pode executar o IDE localmente no seu PC ou Mac e configurar seu projeto para usar um sistema Solaris remotamente para o desenvolvimento e beneficiar este recurso DTrace.</p>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4824">Novo vídeo falando sobre a Plataforma NetBeans!</a></h2>
						<p style="margin-left:8px;">
						Gephi é uma plataforma de visualização e exploração de todos os tipos de redes e sistemas complexos, gráficos dinâmicos e hierárquicos. É o Swing e a Plataforma NetBeans em ação, muito legal!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4825">A próxima fase do NetBeans PoWeR</a></h2>
						<p style="margin-left:8px;">
						NetBeans Power (Plataforma Wapper Repository) é uma iniciativa semi-experimental para fornecer NBM pré-prontos para a Plataforma NetBeans, e envolvendo algumas  bibliotecas de terceiros bem populares, semelhante ao Eclipse Orbit. Dê uma olhada e diga ao membro da comunidade Fabrizio Giudici o que você achou!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4826">Java Móvel no Mac, Solaris e Linux</a></h2>
						<p style="margin-left:8px;">
						O microemulador de Karol Harezlak habilita o suporte básico para desenvolvimento Java ME CLDC no NetBeans no Solaris, Mac OS e Linux. O projeto tem uma nova hospedagem em dev.java.net -- Aqui você encontrará links para download, bem como as instruções de instalação.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4822">Conclusão de código para cores no CSS</a></h2>
						<p style="margin-left:8px;">
						Ouvimos seus comentários e acrescentamos uma outra melhoria para o NetBeans IDE para PHP: a conclusão do código para o CSS agora inclui um seletor de cores para as propriedades de cor e fundo.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4823">Blog JavaFX Composer</a></h2>
						<p style="margin-left:8px;">
						Siga o blog NetBeans JavaFX Composer e seja o primeiro a saber sobre os novos recursos do IDE. É também um bom lugar para experimentar demos divertidos e compartilhar novos exemplos de código. Deixe um comentário se você já desenvolveu um aplicativo JavaFX de exemplo e quer doá-lo ao nosso catálogo de exemplos!</p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4821">Implementando a ação salvar</a></h2>
						<p style="margin-left:8px;">
						Tim Boudreau atualizou seu aplicativo de exemplo Paint e melhorou a ação "Salvar". Ao invés de criar sua própria ação para salvar a tela, agora você pode se integrar com a a funcionalidade de Salvar padrão da plataforma NetBeans. O código funciona com a plataforma NetBeans 6.8 e 6.9.</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-03-07_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>