
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 401</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 # 401 - Jul 21, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3930">GlassFish ESB v2.1 GA & Other OpenESB Components Available for NetBeans 6.7</a></h2>
						<p style="margin-left:8px;">
						GlassFish ESB v2.1 is now available on both NetBeans 6.7 and NetBeans 6.5.1. The GlassFish ESB design tooling includes the latest version of the BPEL editor, WSDL editor, and more. To install these design time components, go to the <a href="http://open-esb.dev.java.net/Downloads.html">OpenESB download page</a>; download and execute the components-only installer, and select the installation directory of your NetBeans 6.7 installation.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3929">jVi KeyBindings 1.2.6 Available for NetBeans 6.7 & NetBeans 6.5</a></h2>
						<p style="margin-left:8px;">
						Release 1.2.6 of jVi KeyBindings for NetBeans is now available and tested with NetBeans 6.7 and NetBeans 6.5. There are over 200 normal mode commands, including vim's visual block mode, tag stack, text objects and external process ("!") filters. <a href="http://jvi.sourceforge.net/?CHANGES.html">Learn more</a> about recent features and NetBeans-specific details. For vim undo/redo granularity check out the small optional patch on the download page.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3928">New Plugin Makes Visuals for NetBeans Tutorials Easier</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member <a href="http://www.sepix.de/blogs/blogrittner">Aljoscha Rittner</a> has created a cool new plugin: "NetBeans Tutorial Builder-Screen Capture und Crop Tool". The plugin lets users easily create screenshots for use in their tutorials. <a href="http://www.sepix.de/blogs/blogrittner/blog/archive/2009/july/15/plugin_netbeans_tutorial_builder_screen_capture_und_crop_tool/index.html">Download it today</a>!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3932">Tutorials: Zembly + JavaFX + Facebook + NetBeans</a></h2>
						<p style="margin-left:8px;">
						The Zembly Client Library allows users to build JavaFX apps while using Zembly services. Charles Ditzel provides links to tutorials that show Zembly, JavaFX and the NetBeans IDE in action creating a Facebook app.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3927">Defining Your C/C++ Project's Development Environment</a></h2>
						<p style="margin-left:8px;">
						This short tutorial takes you through the basic steps of selecting the development host and tool collection for building and debugging a C or C++ project in NetBeans 6.7.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3925">NetBeans Ant-Based Project Type Module Tutorial</a></h2>
						<p style="margin-left:8px;">
						Learn how to create a new project type for projects that need to use Ant as their build tool.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3924">Creating Solutions for Blind Programmers on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Andreas Stefik, a professor at Central Washington University (CWU) discusses his work using the NetBeans Platform to create better tools for visually impaired programmers.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3933">NetBeans for PHP - Ignored Folders?</a></h2>
						<p style="margin-left:8px;">
						From the NetBeans PHP team blog, details of a new feature that lets users specify folders that are not visible in the UI, that is, the folders are not scanned or indexed. Test out the feature and give the team feedback.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3931">Wicket Support for Maven Projects in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						An update about Wicket development in the NetBeans IDE. New patches provided by Milos Kleint are available that will make it easier to integrate Wicket support in Maven web artifacts in the NetBeans IDE. Get more details in this blog entry from Geertjan Wielenga.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3926">NetBeans Platform Meets Swing Application Framework: SessionStorage</a></h2>
						<p style="margin-left:8px;">
						Florian Brunner explains how to use the Swing Application Framework (JSR-296) as a utility library in a NetBeans Platform application to reuse its session storage feature.</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/2009-07-21.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>