
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 336</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 # 336 - Apr 07, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1739">NetBeans Plugin Portal Has New Features!</a></h2>
						<p style="margin-left:8px;">
						The new version of the NetBeans Plugin Portal is now live and includes enhanced features such as:
<ul>
<li>Verification process for publishing plugins in the NetBeans IDE
<li>Email notification
<li>Comments management
<li> and More!
</ul>
To learn about all the improvements to the NetBeans Plugin Portal read the <a href="https://netbeans.org/source/browse/*checkout*/pluginportal/www/docs/phaseIII_func_spec.pdf?rev=1.2">functional specification</a>.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1749">NetBeans Day Poland (April 11 - 13)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=886&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 Polish NetBeans community has organized a three-day NetBeans tour through Poland with stops in Krakow (11th), Warsaw (12th) and Wroclaw (13th). Attend NetBeans Day to learn about new features and support available in the NetBeans IDE.</p><br style="clear:both;"/>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1746">Talking with Sun JavaFX Developer Josh Marinacci</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=882&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;'/>
						Sun Microsystems evangelist David Coldrick interviews Sun JavaFX developer Josh Marinacci during the Sun Tech Days in Sydney, Australia. Marinacci discuss upcoming features and support in JavaFX Script.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1740">Beta, Blogs & Groovy - NetBeans Podcast Episode #42</a></h2>
						<p style="margin-left:8px;">
						Tune in to hear Roman and Gregg talk about the beta release of NetBeans 6.1, the NetBeans blogging contest, what's new in the Groovy world, the latest patches, a preview of NetBeans Day at CommunityOne, and more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1745">Create Your NetBeans Network on my.netbeans, FaceBook & MySpace!</a></h2>
						<p style="margin-left:8px;">
						Social networking comes to the NetBeans community! Find out the different ways that NetBeans users worldwide can now stay connected through social networking sites, including our very own <a href="http://my.netbeans.org/">my.netbeans.org</a>, and help to grow the community!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1747">NetBeans, Ruby and AppleScript</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=883&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;'/>
						"Mac Developer Tips" blogger John Muchow describes how to use NetBeans and rb-appscript (a bridge to connect Ruby to the Apple Event Manager) to control scriptable applications on a Mac. This introduction shows how you can get started using Ruby as an alternative to AppleScript for scripting applications on Mac OS X.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1741">Adding Support For a Web Framework</a></h2>
						<p style="margin-left:8px;">
						This tutorial describes how to add support for a web framework in the NetBeans IDE using the Plugin Manager.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1744">Support Missing Languages Using Schliemann</a></h2>
						<p style="margin-left:8px;">
						The Generic Languages Framework (codename Schliemann) offers an easy way to support your language within the NetBeans IDE. This tutorial shows you how to support the common STEP Physical File (ISO 10303 Part21) format, a file format used in the exchange off CAD and Product Structure Exchange.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1748">Updated Plugin - Visual Web Woodstock Component Theme Builder</a></h2>
						<p style="margin-left:8px;">
						Winston Prakash has updated the Visual Web Woodstock Component Theme Builder plugin to work with NetBeans releases 6.0 and 6.0.1. His blog entry includes links for downloading the updates, installing and using the plugin.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1742">Find OpenOffice Extensions in the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Do you use both the NetBeans IDE and OpenOffice.org? OpenOffice.org has many plugins (also known as extensions). Geerjan Wielenga's blog entry details how the NetBeans IDE can inform you about available OpenOffice.org extensions.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1743">Why Referencing an EntityManager Inside JPA Entities is Needed</a></h2>
						<p style="margin-left:8px;">
						The generation of JSF front-end is available in NetBeans IDE 6.1. This post from Adam Bien describes the JSF and JPA scaffolding with NetBeans IDE 6.1 in greater detail.</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_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-04-07.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>