<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# friends.php
	#
	# Author: 		Nathan Gervais
	# Date:			2009-05-21
	#
	# Description:  Galileo Friends Landing Page
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Friends of Eclipse";
	$pageKeywords	= "Friends of Eclipse, Galileo";
	$pageAuthor		= "Nathan Gervais";
		
	# Paste your HTML content between the EOHTML markers!	
	ob_start();
	?>
	<style>
		h1 { font-size:24px;}
		#bulletList li {
			list-style-image: url('/eclipse.org-common/themes/Nova/images/leftNavSelected.png');
			font-size:14px;line-height:21px;
		}
	</style>
	<div id="midcolumn">
		
		<h1>Get Galileo Sooner and Faster</h1>
		
		<ul id="bulletList">
			<li>
				Eclipse Galileo Release is coming June 24.
			</li>
			<li>
				Become a <a href="/donate">Friend of Eclipse</a> to get early access to the Galileo release and a faster download experience[1].
			</li>
			<li>
				At the same time you will be helping support the Eclipse Foundation and the Eclipse community.  <a href="/donate">Join now for only US$35</a>.
			</li>
		</ul>
		
		<p style="font-size:12px;color:#555;">
			[1] Friends of Eclipse get special access to the Eclipse Foundation download server.  This server will be available to Friends of Eclipse while the download packages are being synchronized to our mirrors.  This typically means the packages will be available up to 24 hrs before everyone else.   The Eclipse Foundation will also be dedicating extra bandwidth to this download server, so Friends should experience a faster download.
		</p>
		
		
	</div>
	<!-- remove the entire <div> tag to omit the right column! -->
	<div id="rightcolumn">
		
		<div id="promos">
			<a href="/donate/"><img width="200px" src="/donate/images/friendslogo.jpg"></a>
		</div>		
	</div> 

	
	<?
	$html = ob_get_clean();

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>