
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 371</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">
				Issue # 371 - Dec 08, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3025">NetBeans IDE 6.5 for JavaFX Now Available!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2237&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='51' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						JavaFX 1.0 is here and NetBeans IDE is the official IDE for JavaFX development! Developers can create, test, debug and deploy JavaFX applications for desktop, browser and mobile platforms using the NetBeans IDE. Ready-to-run sample projects are available for a quick start in building rich internet applications using JavaFX. <a href="https://netbeans.org/features/javafx/index.html">Learn more</a> about NetBeans IDE for JavaFX and <a href="https://netbeans.org/downloads/index.html">download</a> it today!
<ul>
<li>If NetBeans IDE 6.5 is already installed add JavaFX 1.0 using the IDE's Update Center. In the IDE, navigate to <i>Tools -> Plugins</i> and select the JavaFX checkboxes.
<li>If NetBeans IDE 6.5 is not already installed visit the <a href="https://netbeans.org/downloads/index.html">NetBeans download page</a> and select the JavaFX download bundle. </ul></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3024">NetBeans IDE & NetBeans Platform Available with Fedora 10</a></h2>
						<p style="margin-left:8px;">
						The NetBeans IDE and NetBeans Platform are now a part of the newly released Fedora 10. With the integration, developers using Fedora get:
<ul><li>An easy and rapid way to organize an environment for developing systems that can be based on modern technologies and popular programming languages.
<li>A way for developing Rich Client Swing applications based on the NetBeans Platform.</ul>
<a href="http://wiki.netbeans.org/Fedora">Learn more</a>  about NetBeans in Fedora.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3026">NetBeans IDE for JavaFX Developer Center</a></h2>
						<p style="margin-left:8px;">
						Visit this documentation site to learn about what you can do with the NetBeans IDE and JavaFX. Find tutorials that show how easily JavaFX applications can be created in the NetBeans IDE, and also get resources to get you connected with the JavaFX community.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3029">Top 10 NetBeans Platform APIs (Part 4-6)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2240&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This ten-part screencast series introduces the main NetBeans APIs, why and how to use them. In Part 4, learn about the NetBeans FileSystem API; in
<a href="https://channelsun.sun.com/category/playlist?id=81">Part 5</a> the Nodes API and Explorer & Property Sheet API. <a href="https://channelsun.sun.com/category/playlist?id=81">Part 6</a> ends with a brand new NetBeans Platform application consisting of three modules.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3027">Generating a JavaServer Faces CRUD Application from a Database</a></h2>
						<p style="margin-left:8px;">
						This tutorial demonstrates how the NetBeans IDE can generate robust and easily maintainable code when creating JSF pages from entity classes.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3028">Tech Tip: NetBeans 6.x Local History</a></h2>
						<p style="margin-left:8px;">
						Mistakes happen. If you lose a chunk of code, how do you get it back? The Local History option in NetBeans gives entire file snapshots in time. You can restore code by reverting to old versions of your file in local history. Learn more from this tech tip.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3032">NekoBean Has a New Fan?</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2243&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='81' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Last March, the NetBeans Japanese community introduced a new mascot: NekoBean. At the time, we agreed that it/he/she (?) was cute, but we had no clue it had grand ambitions.... As shown on Masaki Katakai's blog, clearly this little blue box is going places and meeting all the right people!</p><br style="clear:both;"/>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3022">JavaFX 1.0 - Access Services Hosted on Embedded GlassFish</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta shows how to create a simple JavaFX application using NetBeans IDE. The application plays a movie; allows the viewer to cast votes; and see aggregate responses from other viewers. The application is developed using NetBeans 6.5, JavaFX 1.0 plugin, and coded using JavaFX Script. The voting engine is deployed as a RESTful Web service using Jersey on GlassFish.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3023">Swing is Especially Effective if...</a></h2>
						<p style="margin-left:8px;">
						When creating GUIs (graphical user interfaces), should you use the Standard Widget Toolkit (SWT) or the Swing Toolkit? In this blog entry, Dream Team member Adam Bien shares his expertise of what situations call for an effective use of Swing.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3031">How to Create an Applet with JNLP Support in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Petr Chytil's blog entry gives a quick HelloWorld introduction to developing applets using NetBeans 6.5.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Tinuola Awopetu<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>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2008-12-08.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>