<?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();	$theme = NULL; include($App->getProjectCommon());   # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# index.php
	#
	# Author: 	 	Ian Skerrett
	# Date:			2008-06-18
	#
	# Description: Pulsar Support Page
	#
	#****************************************************************************
	#
	# Begin: page-specific settings.  Change these.
	$pageTitle 		= "Support Eclipse";
	$pageKeywords	= "eclipse membership";
	$pageAuthor		= "Eclipse Foundation, Inc.";

	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank)
	# $Nav->addCustomNav("My Link", "mypage.php", "_self");
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank");

	# End: page-specific settings
	#

	# Place your html content in a file called content/en_pagename.php
	ob_start();
	?>
	<div id="midcolumn">



			<h1>Support Eclipse</h1>
			<p>There are three simple ways you can financially support the Eclipse Foundation. Choose whichever
			way is best for you, and please do not hesitate to <a href="mailto:membership@eclipse.org">contact us.</a></p>


			<h2>1 - Become an Associate Member</h2>
			<ul>
				<li>What are the benefits of becoming an Associate Member?</li>
				<p>The key benefit is supporting the infrastructure that brings you
				<a href="http://wiki.eclipse.org/images/c/ca/Eclipse_foundation_about_us.pdf">great open source software</a>!
				In addition to that, we'll put you on the inside track of information about the Eclipse Ecosystem,
				invite you to members' meetings, and give you discounts to Foundation events &mdash; and your
				staff will appreciate knowing you support free software too. If you would like more
				benefits, such as help promoting your products and
				services to the Eclipse Ecosystem, voting rights, and board representation, consider
				<a href="http://www.eclipse.org/membership/become_a_member/" target="_blank">other membership options</a>.
				</p>
				<li>How do I become an Associate Member?</li>
				<p>It's easy &mdash; just complete and fax these three documents listed on our
				<a href="http://www.eclipse.org/membership/become_a_member/membershipProcess.php">Membership Page</a>.
				It really is quite simple. One
				doc is simply for your contact information. Another doc says it's ok for us to post your logo
				(and vice versa). The third doc has a lot of stuff relevant to other membership
				classes; for Associate Membership, it basically says that you agree to support the Foundation and
				we agree to invite you to the members' meetings and events.</p>
				<li>How much is Associate Membership?</li>
				<p>The minimum contribution is $5,000 USD per year. If it's more convenient for you, we can break that
				into quarterly payments.</p>

			</ul>

			<h2>2 - Be a Corporate Sponsor</h2>
			<p>
				If Associate Membership isn't your style, there are other ways to financially support the
				Eclipse Foundation by being a
				<a href="/corporate_sponsors/">corporate sponsor</a>.
				Please <a href="mailto:membership@eclipse.org">contact us</a> to discuss additional
				options including:
				<ul>
				<li>Being a logo sponsor of Eclipse Foundation events</li>
				<li>Being a corporate sponsor for some of our <a href="http://www.eclipse.org/org/foundation/thankyou.php">infrastructure</a></li>
				<li>Simply making a cash contribution</li>
				</ul>
			</p>

			<h2>3 - Become a Friend of Eclipse</h2>
			<p>
				If having your organization become a member or sponsor isn't in the cards, and you still want to show
				support for the Eclipse Foundation, consider personally becoming a
				<a href="http://eclipse.org/donate/index.php">Friend of Eclipse</a>.

				<br><br><br>

			</p>
	</div>

	<? include("./rightcolumn.php"); ?>


	<?
	$html = ob_get_clean();
	# Generate the web page
	$App->Promotion = TRUE;
	$App->AddExtraHtmlHeader('<link type="text/css" href="style.css" rel="stylesheet"/>');
	$App->generatePage(NULL, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
