
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 532</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">
				Issue # 532 - Apr 10, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7269">JavaOne Tokyo</a></h2>
						<p style="margin-left:8px;">
						Masaki Katakai reports on JavaOne in Tokyo. NetBeans is being used in demos throughout the conference, so the interest at the NetBeans booth was very high!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7279">PrimeFaces Team Needs NetBeans Feedback</a></h2>
						<p style="margin-left:8px;">
						The PrimeFaces team is gathering feedback on how the support in NetBeans for the PrimeFaces JSF UI component framework can be improved. Are you using PrimeFaces in NetBeans too? Your feedback is needed!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7276">Plugin: JRebel for NetBeans</a></h2>
						<p style="margin-left:8px;">
						This plugin enables NetBeans users to continue to use the debugging facilities of NetBeans when debugging JVM applications that use JRebel.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7271">Seven NetBeans Hints for Modernizing Java Code</a></h2>
						<p style="margin-left:8px;">
						Dustin Marx, digs <a href="http://marxsoftware.blogspot.com/2010/10/seven-indispensable-netbeans-java-hints.html">further</a> into the very large library of coding hints that NetBeans provides out of the box. Want to improve your code quickly and easily? Read Dustin's article!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7270">Free Online NetBeans RCP Book</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Javier Ortiz, together with Miloš Šilhánek, has published a book that will quickly get you up to speed on the NetBeans APIs. And it is free!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7277">Continually Updated NetBeans Newspaper</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Toni Epple has created an on-line newspaper that is updated automatically with news about NetBeans!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7272">Work Faster with WordPress in NetBeans</a></h2>
						<p style="margin-left:8px;">
						Ryan Nutt's blog provides a lot of helpful hints about using WordPress. In this entry, you learn about setting up templates to help you quickly create WordPress files.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7273">JavaFX Gaming with NetBeans</a></h2>
						<p style="margin-left:8px;">
						The Eppleton blog has been focusing more on JavaFX emperiments. In this entry, you learn about creating a Tetris game in JavaFX!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7278">Editable OutlineViews</a></h2>
						<p style="margin-left:8px;">
						While tabbing through an OutlineView, until you press the Space key in the selected cell, or until you click the mouse within it, you cannot edit it. Here's how to fix that!</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7274">16 April: Develop Applications for Mobile Phones</a></h2>
						<p style="margin-left:8px;">
						Learn how to create mobile apps using JavaME and the NetBeans IDE in a LIVE virtual class April 16 organized by Oracle University.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7268">17 - 18 April: JavaOne Russia</a></h2>
						<p style="margin-left:8px;">
						NetBeans will be strongly represented at JavaOne Russia, to be held in Moscow next week. If you're at the conference, stop by the NetBeans booth!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7275">23 - 25 April: NetBeans RCP at Wageningen</a></h2>
						<p style="margin-left:8px;">
						A free NetBeans Platform course is scheduled to be held from 23 to 25 April, 2012, at Wageningen University in the Netherlands. If you're in the area, you're welcome to join in.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Geertjan Wielenga<br/>If you do not want to receive this newsletter, you can <a href="https://netbeans.org/community/lists/top.html">unsubscribe here</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">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2012-04-10.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>