
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 426</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 # 426 - Feb 09, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4731">Patch 1 for NetBeans IDE 6.8 Now Available</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team has released a new patch, which is an update to the NetBeans IDE 6.8. The patch includes several <a href="http://wiki.netbeans.org/NetBeans6.8PatchesInfo">bug fixes</a>. To obtain the fixes, the NetBeans IDE 6.8 must be installed and running. Get the patch using the IDE's Plugin Manager.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4736">Give Feedback on New PHP Feature: Error badges</a></h2>
						<p style="margin-left:8px;">
						The NetBeans PHP team wants feedback on an experimental feature that could make it into NetBeans 6.9: Error badges. If you have a PHP file with any error, the file can be marked directly in the Projects window. Useful feature? Let the team know.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4732">RTSP Support in JavaFX Applications</a></h2>
						<p style="margin-left:8px;">
						Real-Time Streaming Protocol (RTSP) support has been available in the JavaFX SDK since the 1.2 version. This document clarifies which platforms support this functionality, and it provides basic recommendations for enabling streaming media in your application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4735">Swinging and Tweeting with Java and NetBeans</a></h2>
						<p style="margin-left:8px;">
						In this Packt Publishing tutorial, author Alfonso Romero outlines how to build a custom application for Twitter using Java and NetBeans, rather than using the standard web interface.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4740">Adding a File Chooser to a Java Application</a></h2>
						<p style="margin-left:8px;">
						Learn to add a file chooser to a Java application, using the javax.swing.JFileChooser component and the NetBeans GUI Builder.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4734">JavaFX Composer - A Big Step for JavaFX?</a></h2>
						<p style="margin-left:8px;">
						The JavaFX Composer is a new visual editor plugin for NetBeans 6.8 (similar to Project Matisse for Swing). DZone interviewed members of the JavaFX development team to learn about user feedback to the tool. More tools like the JavaFX Composer could lead to an increase in high profile JavaFX applications, such as the medal visualizer application on the 2010 Winter Olympics website.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4737">Video: JavaFX & NetBeans IDE at Jfokus 2010</a></h2>
						<p style="margin-left:8px;">
						Developers at Epsilon, a Swedish tech and systems consulting firm, are fans of JavaFX and the NetBeans IDE. At the 2010 Jfokus show, they demo-ed a project and discussed their use of the two technologies.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4733">Create Your Own Window System</a></h2>
						<p style="margin-left:8px;">
						Did you know you can create a custom window system on the NetBeans Window System API? One that can integrate with other NetBeans idioms? Learn more in this blog entry from Geertjan Wielenga and Toni Epple.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4741">Connect to Oracle Database Using NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta's 107th "Tip of the Day" explains how to connect to Oracle database with NetBeans IDE to leverage all the features provided by the IDE for Java EE application development, Rails, and others.</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> | <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/2010-02-09.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>