
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 315</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 # 315 - Oct 29, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1422">Download JavaFX Script Plugin for NetBeans 6.0 Beta 2</a></h2>
						<p style="margin-left:8px;">
						The JavaFX Script plugin for NetBeans 6.0 Beta 2 is available for download from the NetBeans Beta Update Center. This preview release includes several bug fixes and two new JavaFX Script sample projects: JavaFX 2D Graphics Tutorial and WeatherFX Sample Application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1421">Java Declaration Generator Plugin</a></h2>
						<p style="margin-left:8px;">
						This module supports several forms of parameter, variable, array parameter and array variable declarations. The generated code behaves like editor code templates. After modifying the code template parameters, type "Enter" to escape the code template parameter editing mode--the caret will be positioned at the location for the next code. It's all about productivity!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1419">Video: Sun Java Tools Team Celebrates Beta Release</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=517&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;'/>
						The Sun Java Tools Development team celebrated the NetBeans 6.0 Beta release with a picnic. Meet team members and hear what they have to say about the product they develop!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1427">You Asked and Our Experts Answered</a></h2>
						<p style="margin-left:8px;">
						<i>Is there an obfuscator function in NetBeans? How can I run/invoke JavaFx code from a NetBeans module? What is the current status of PHP support in NetBeans?</i><br><br>Last week, NetBeans users posed the above questions and much more to our three NetBeans Experts--Judith Lilienfeld, Brian Leonard, and David Botterill. Check out the session transcript for other great questions the community asked and our experts' responses.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1428">Video: Meet the NetBeans Evangelists</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=502&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;'/>
						NetBeans Evangelists travel far and wide to deliver our gospel. You know them from reading their blogs, listening to their podcasts, and from watching them give demos and talks at user groups and tech conferences. Discover more about who they are and what they have to say about NetBeans in a new series of videos available on NetBeans TV.<br><br>
<b>This week: <a href="https://channelsun.sun.com/category/playlist?id=81">Brian Leonard</a> and <a href="http://www.netbeans.tv/interviews/Bruno-Souza-215/">Bruno Souza</a></b></p><br style="clear:both;"/>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1429">NetBeans Day Beijing, China - November 3</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=520&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='60' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans WorldTour is going strong in Asia. We just wrapped up in Shanghai, where Jeet Kaul delivered the <a href="http://blogs.sun.com/TechDaysEvents/entry/jeet_kaul_on_netbeans_vs">keynote speech</a> and touched on how the competitive IDE field benefits NetBeans. If you missed us in Shanghai, then join us in Beijing on November 3. NetBeans Day is FREE, but space is limited so reserve your spot today!</p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1424">Visual Mobile Designer Custom Components: SMS Composer</a></h2>
						<p style="margin-left:8px;">
						The Visual Mobile Designer (VMD) is a graphical interface within the NetBeans Mobility pack that lets you design mobile applications using drag and drop components. One of these components, the SMS Composer, provides a mechanism and user interface to send short messages using Short Message Service (SMS). This tutorial introduces the basic features of the SMS Composer and its use in a mobile application for Wireless Messaging API (WMA) enabled devices.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1425">Binding Beans and Data in a Desktop Application</a></h2>
						<p style="margin-left:8px;">
						This tutorial introduces you to support in NetBeans IDE 6.0 for beans binding and data binding in Java desktop applications. Steps are offered for binding properties to other properties and data to components. The tutorial also includes an overview of advanced and special binding properties.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1426">Installing and Configuring Ruby Support in NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						Are you ready to check out NetBeans 6.0's Ruby support? This tutorial gets you started with information about downloading, installing, and configuring Ruby support in the IDE, and covers aspects of working with Databases, and deploying a JRuby application to GlassFish.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1423">Task List API</a></h2>
						<p style="margin-left:8px;">
						The Task List API is one of the new 6.0 APIs supported by the NetBeans Platform. In this blog entry, Geertjan gives you a brief overview. Waiting at the end, and for very little code? Something that you might even find useful!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1420">Where's End2End Functionality in NetBeans 6.0?</a></h2>
						<p style="margin-left:8px;">
						End-to-End provides a Mobile Client to Web Application wizard and wizards for generating Java ME Web Service (JSR 172) Client. The wizards require the Web project or Web Services functionality, except these are not part of the Java ME distro. Check out Lukas Hasik's blog for details on how to get them working with NetBeans 6.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1430">Event Review: Midwest Java Technology Day</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Glenn Holmer attended Sun's Midwest Java Technology Day. Glenn was impressed by features in the NetBeans's revamped editor and the Profiler, but which NetBeans plugin made jaws drop? Find out in his entry, which also includes links to presentation slides from the event.</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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-10-29.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>