
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 343</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 # 343 - May 26, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1997">Bug Fixes for NetBeans IDE 6.1 Now Available</a></h2>
						<p style="margin-left:8px;">
						NetBeans.org has released a new patch, which is an update to the NetBeans IDE 6.1. The patch includes bug fixes in modules for BPEL, C/C++, Database, Editing Files, GUI Builder, IDE Platform, Java, Java Debugger, Java EE, Java Persistence, JBoss Application Server, Mercurial, Mobility, NetBeans Plugin Development, RESTful Web Services, Ruby and Rails, SOA,Spring Web MVC, UML, Visual JSF, Visual Mobility Designer, Web Applications, Web Services, and XML and Schema.

<br><br>To obtain the fixes, the NetBeans IDE must be installed and running. You can download the fixes through the IDE's Update Center. </p></p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2006">Governance Board Elections - Nominations Closing</a></h2>
						<p style="margin-left:8px;">
						The DEADLINE for nominations is Tuesday, May 27, midnight in the last time
zone. For the current nominees and more information visit the board elections page. Voting begins on Wednesday, May 28.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2005">JavaScript and PHP Support in NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						In this interview from artima.com, Frank Sommers and Sun's Gregg Sporar discuss NetBeans increasing support of languages focusing on JavaScript and PHP support.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1998">NetBeans.tv: Emebbed Player</a></h2>
						<p style="margin-left:8px;">
						There's now a very cool NetBeans.tv player that you can embed in your blog entries, or on any other site, to let your readers watch movies of better quality than YouTube. Uploading movies to share them with others is now also much easier than before. Geertjan's blog shows you how.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2001">NetBeans Platform Based Bible Study Application</a></h2>
						<p style="margin-left:8px;">
						Kiyut in Indonesia has released an advanced Bible study toolkit on top of the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2003">Two NetBeans Keyboard Shortcuts That Will Change Your Life (Forever)</a></h2>
						<p style="margin-left:8px;">
						There are many cool NetBeans keyboard shortcuts, but these two, spotlighted at NetBeans Zone, are really special. Seriously, try these two out and you'll like the NetBeans Java editor even more than before.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2000">Comment/Uncomment Lines in HTML, JSP, HTML</a></h2>
						<p style="margin-left:8px;">
						Ctrl-Shift-C or Ctrl-Slash comment out lines in Java files. But what about HTML files, XML files, and JSP files? NetBeans IDE 6.1 provides no support for commenting out lines in these file types. Download this plugin and add that missing functionality today!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1999">Embeddable GlassFish in Action - Servlet in a Maven project</a></h2>
						<p style="margin-left:8px;">
						This blog how to host a Servlet using GlassFish embeddability APIs and write a simple Maven test to invoke the Servlet - all within the same VM.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1973">Embedded Derby and Bean Binding with NetBeans 6</a></h2>
						<p style="margin-left:8px;">
						By Prakan Puvibunsuk. A fantastic video demo that shows you embedded Derby datbase and bean binding in NetBeans 6.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2002">Chinese Community Member‘s NetBeans Plugin - Gmail Notifier</a></h2>
						<p style="margin-left:8px;">
						<a href="http://blog.csdn.net/DL88250">Liang Ding(88250)</a>, from <a href="http://zh-cn.netbeans.org/community">Chinese Community</a>, has created a new Gmail Notifier plugin that is available through the <a href="http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=9558">Plugin Portal</a>.
<br><br>Features Include:
<br> * auto check mail box
<br> * auto display mail subject scrolly
<br> * tool tip notification
<br> * new mail sound propmt
<br><br>
Usage:
<br> * Left click will open the Gmail in your web browser
<br> * Right click will check your new mails
<br> * Set Gmail Account in Tools->Options dialog</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2004">Drag & drop code snippets into the Palette</a></h2>
						<p style="margin-left:8px;">
						NetBeans users have often asked for functionality allowing them to drag code snippets into the palette. That way, you can build up a palette of custom snippets that you can then very easily reuse. Stan Aubrecht, the NetBeans engineer responsible for the Palette API, gives you a preview of this functionality in his blog. You can already use it if you get a post-6.1 development build.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Robert Demmer<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_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-05-26.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>