
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsleter, Issue # 300</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 # 300 - Jul 16, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1268">300 Reasons to Read NetBeans Weekly!</a></h2>
						<p style="margin-left:8px;">
						<b>Welcome to Issue #300 of the NetBeans Weekly Newsletter!</b><br><br> Since its launch in January 29, 2001, the NetBeans Weekly Newsletter has played a pivotal role in keeping you informed about developments—big and small—related to NetBeans. We're proud to mark this milestone issue with a quick look at 300 reasons—<i>Yes, we know there are more...</i>—to look forward to your inbox.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1262">Which IDE Won the JUG Cologne Shootout?</a></h2>
						<p style="margin-left:8px;">
						The NetBeans IDE went up against three other IDEs at JUG Cologne's IDE shootout—the first of its kind. How did we do? Get the details and check out pictures from the event.</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1259">Help Shape the Next Plugin Portal</a></h2>
						<p style="margin-left:8px;">
						The <a href="http://plugins.netbeans.org/PluginPortal/">NetBeans Plugin Portal</a> (the "Plugins" tab on <a href="https://netbeans.org/index.html">NetBeans.org</a>) is a live NetBeans project. We are currently in the functionality stage of Phase III. Now is your chance to have an impact on how the Plugin Portal will look and operate in the future. Visit the portal and check out the project. Then download the Phase III functional specification and provide feedback on the users@pluginportal.netbeans.org email alias.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1266">Project Tango - An Overview</a></h2>
						<p style="margin-left:8px;">
						Curious about Project Tango? Its features? What it can do? Check out Arun Gupta's blog for links to a comprehensive overview.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1260">Using Selection Lists in Rails</a></h2>
						<p style="margin-left:8px;">
						Selection lists (drop down boxes) are common to just about every web application. In this entry, Brian Leonard extends the web log he's been building to include a category selection list.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1261">The Divas Share Some Web UI Component Layout Tips</a></h2>
						<p style="margin-left:8px;">
						The Tutorial Divas have posted two blog entries with helpful layout tips for Visual Web projects. First, they show how to <a href="http://blogs.sun.com/divas/entry/laying_out_multiple_table_components">layout multiple tables on a page</a>. Then they show how to use a Grid Panel component to <a href="http://blogs.sun.com/divas/entry/centering_web_ui_components_on">layout components such that they are always centered</a>, regardless of how wide the user makes the browser.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1265">Cool Tip: New Visual Web Settings</a></h2>
						<p style="margin-left:8px;">
						A useful tip from Community Docs Manager James Branam. Modifying default Visual Editor and Drag & Drop setting has changed in NetBeans 6.0. A new tab make it easier to tweak Visual Web functionality. Just go to Tools > Options > Miscellaneous > Visual Web.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1269">Kirk Pepperdine: Further Integrated into NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Want Kirk Pepperdine as your NetBeans Wizard? Geertjan Wielenga and Toni Epple show you how.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1264">Using JavaServer Faces Component Library to Access a LDAP Server</a></h2>
						<p style="margin-left:8px;">
						Learn how to access a LDAP Server from a visual web project using a set of JavaServer Faces components. These components are available in a downloadable component library.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1267">Using Maven Projects with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Ant versus Maven? Dream Team-er Emilian Bold enters the fray with a tutorial, the first in a multi-part series.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1263">Community Docs Spotlight: Kosol Tuanveeradej</a></h2>
						<p style="margin-left:8px;">
						Check out Kosol Tuanveeradej's contribution to the NetBeans Community Docs wiki: Getting a project to build by changing the Ant version in the IDE.</p>
					</div>
	<div class="edited">
	This week's 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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-07-16.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>
