
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 361</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 # 361 - Sep 30, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2705">Register for NetBeans Day Seoul, South Korea - October 17</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1865&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='77' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Where will you find the <a href="https://netbeans.org/community/articles/worldtour/">NetBeans World Tour</a> in the coming months? Connecting with developers in Asia! Look out for the NetBeans Team in South Korea, China, Japan and Singapore as part of Sun Tech Days.
Join us on October 17 in Seoul for a deep dive into what's new and cool with NetBeans IDE 6.5. Registration for NetBeans Day is always FREE, but seating is limited. Register now!</p><br style="clear:both;"/>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2706">Dream Projects Become Reality - Innovators Grant Contest Winners!</a></h2>
						<p style="margin-left:8px;">
						Eight months and 170-plus proposals later, the NetBeans Team is proud to officially announce the winners of the NetBeans Innovators Grant Contest. 13 innovative developers will share a cash prize of USD $127,500 for successfully completing their dream projects. The NetBeans Team and Community congratulate all the developers for their outstanding work! Learn more about the <a href="https://netbeans.org/grant/projects.html">winning projects</a> and read Sun's <a href="http://www.sun.com/aboutsun/pr/2008-09/sunflash.20080929.4.xml">press release</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2708">NetBeans Innovators Grant Contest - Selecting 13 Innovators</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1897&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;'/>
						How did we whittle over 170 cool project proposals down to 13 winners for the NetBeans Innovators Grant contest? In this podcast interview, NetBeans Technical Community Manager Jirka Kovalsky gives an overview of the contest, from initial submissions to the final decisions.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2707">Ready for Translation: New NetBeans 6.5 Localization Kit</a></h2>
						<p style="margin-left:8px;">
						A notice for NetBeans community members working on translations for NetBeans 6.5: A new L10N (Localization) kit is ready for your translation efforts. Language teams working with an older kit will need to update or regenerate some files. Please consult the NetBeans 6.5 L10N wiki.<br><br>
<i>Interested in localizing for NetBeans? Become a member of the <a href="http://translatedfiles.netbeans.org/">Translation Project</a>!</i></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2701">Introduction to the Struts Web Framework</a></h2>
						<p style="margin-left:8px;">
						A brief guide to creating a web application using the Struts framework in NetBeans IDE 6.1. Struts enable you to create maintainable, extensible, and flexible web applications based on standard technologies, such as JSP pages, JavaBeans, resource bundles, and XML.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2703">Your First Project with IT Mill Toolkit in NetBeans IDE 6.1</a></h2>
						<p style="margin-left:8px;">
						IT Mill Toolkit is an open-source Java framework for creating RIAs in Java. It introduces a server-side widget model together with GWT (Google Web Toolkit) client-side APIs to simplify the programming of rich and secure web applications. With this tutorial create your first IT Mill Toolkit project using NetBeans IDE 6.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2702">Creating a CSS-Based Fixed Page Layout</a></h2>
						<p style="margin-left:8px;">
						Learn how to use the NetBeans IDE Visual Web JSF framework to create a CSS-based fixed page layout. Use different Layout Panels and other HTML elements from the palette to complete the layout for your page.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2704">Tech Tip: Using NetBeans GUI Builder and Eclipse in Parallel</a></h2>
						<p style="margin-left:8px;">
						Already running a project on Eclipse but want to take advantage of NetBeans's Swing GUI Builder? This quick and easy tip from Moritz Petersen shows how to integrate the two platforms.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2699">Customizing the NetBeans Platform Main Window: When & How</a></h2>
						<p style="margin-left:8px;">
						Are you developing an application on the NetBeans Platform? You've probably discovered by now that the NetBeans Window System is cool and easy to reuse, but did you know that it's just like a JFrame? Geertjan Wielenga offers some tips about what you can do with it.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2700">Create a WordPress Theme with NetBeans PHP IDE</a></h2>
						<p style="margin-left:8px;">
						Toni Epple jazzes up his WordPress blog by creating a new layout theme using the PHP support in NetBeans IDE 6.5.</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>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2008-09-30.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>