
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 287</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 {text-align:center; padding-top:50px; 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;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 287 - Apr 16, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1140">Video: Getting Ready for NB Day San Francisco</a></h2>
						<p style="margin-left:8px;">
						Excitement is building for the 2007 JavaOne Conference - now less than a month away. One of the hottest topics at the show is sure to be NetBeans 6.0, the latest and greatest version of the venerable IDE. This week on SDNtv, Sun’s Tim Boudreau and Tor Norbye discuss what’s new in NetBeans 6.0, including a revamped editor that’s faster than ever and includes semantic highlighting. A new integrated profiler targets specific code, saving time and generally making a developer’s job easier. You can see 6.0 firsthand on May 7th at <a href="https://netbeans.org/community/articles/javaone/2007/nb-day.html">NetBeans Day</a>, the day before JavaOne.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1137">JAX 2007 Germany</a></h2>
						<p style="margin-left:8px;">
						Join NetBeans April 24th to April 27th at the JAX 07 conference in Wiesbaden, Germany. <a href="http://jax.de/konferenzen/jax07/overview_speaker_eng.php#2459-boudreau-tim">Tim Boudreau</a> will be giving a keynote address entitled, <i>"Using the Right Tool for the Job"</i> and <a href="http://jax.de/konferenzen/jax07/overview_speaker_eng.php#2456-strobl-roman">Roman Strobl</a> will be giving two sessions: <i>"NetBeans: Open Source Java IDE and More"</i> & <i>"Stepping Onto NetBeans Platform"</i>. Be sure to stop by our booth at the event.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1141">Learn How to Create Ajax-Enabled JSF Components at JavaOne</a></h2>
						<p style="margin-left:8px;">
						For the past few months, <a href="http://blogs.sun.com/divas">Chris Kutler</a>, <a href="http://blogs.sun.com/craigmcc/">Craig McClanahan</a>, Matthew Bohm, <a href="http://www.asgteach.com/">Gail and Paul Anderson</a>, <a href="http://blogs.sun.com/winston/entry/creating_ajax_jsf_component">
and Winston Prakash</a> have been collaborating to bring you a fantastic  hands on lab for <a href="http://java.sun.com/javaone/sf/">JavaOne 2007</a>.
<br>
<br>
This lab, session # LAB-4460 <a href="http://www28.cplan.com/cc158/sessions_catalog.jsp?ilc=158-1&ilg=english&isort=&isort_type=&is=yes&icriteria1=+&icriteria2=+&icriteria7=+&icriteria9=LAB-4460&icriteria8=&icriteria3">Building Ajax-Enabled JavaServer Faces Components and Web Applications With jMaki, Dynamic Faces, and the NetBeans IDE</a>, starts out by showing how to use <a href="http://jsf-extensions.dev.java.net/nonav/mvn/">Dynamic Faces</a> (JSF Extensions) to add Ajax functionality to plain old JavaServer Faces components by creating a chat application. It then teaches you how to build your own JSF Ajax-enabled image browsing component and add design-time features so that you can use it in the NetBeans Visual Web Pack. Last, it shows how to build a JSF component from a <a href="http://ajax.dev.java.net/">jMaki widget</a>. By leveraging the existing jMaki image browser widget and <a href="http://widgets.dev.java.net/">specialized base classes</a>, you quickly build an Ajax-enabled JavaServer Faces component offering a rich user interface with a minimum of code.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1136">Struggling with Regular Expressions?</a></h2>
						<p style="margin-left:8px;">
						Geertjan discusses, with illustrations, a very helpful NetBeans plugin, created by Sandip, that helps you when you need to construct regular expressions. It highlights all the code in the current document that is captured by a regular expression typed in a text field in the toolbar.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1134">Accessing a MultiView Element's TopComponent</a></h2>
						<p style="margin-left:8px;">
						OK, so you have a nice XML multiview for your XML files and thats helping you to edit the file in a visually attractive way. But if you need to access the TopComponent which contains the MultiView elements, say for the purpose of displaying properties of a node in properties window, what then? Vadiraj answers his own question in his blog.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1142">Ruby Debugger Works...</a></h2>
						<p style="margin-left:8px;">
						Roman shows a screenshot in his blog where he discovers that it's possible to debug Ruby in Milestone 8 of NetBeans 6.0 with Ruby support installed from the update center.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1139">Developing a Media Management Application</a></h2>
						<p style="margin-left:8px;">
						This article describes how to install and use the PhotoAlbum sample application, which is a web application through which users can manage different types of media--such as photos or audio data--stored in a local or remote database. The article highlights the important features of the PhotoAlbum sample application, and along the way illustrates how you might use the NetBeans IDE Visual Web Pack 5.5 module to implement a similar application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1138">Integrating NetBeans IDE Profiler With Sun Java System Web Server 7.0</a></h2>
						<p style="margin-left:8px;">
						Even though profiling simple applications is usually a straightforward task, setting up a profiler to work on a Web server or application server requires extra steps. Configuring the Profiler in the NetBeans IDE (henceforth, NetBeans Profiler), however, is easily accomplished, usually on the first attempt. Not only does NetBeans Profiler support a wide range of profiling tasks on the Solaris, Windows, and Linux (Ubuntu) platforms, it also delivers numerous benefits.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1135">How do I use MySQL in a web application in NetBeans IDE?!</a></h2>
						<p style="margin-left:8px;">
						Let Troy tell you everything you need to know. Plus, you will learn about the International Former Professional Wrestlers' Association for Counseling and Development...</p>
					</div>
	<div class="edited">
	This week's 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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-04-16.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>