<?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'
/*******************************************************************************
 * Copyright (c) 2009-2010 Eclipse Foundation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors: Christopher Guindon (Eclipse Foundation)
 * Nathan Gervais (Eclipse Foundation)
 *    
 *******************************************************************************/

	#
	# Begin: page-specific settings.  Change these. 
	$page           = "Who is Kepler?";
	$pageTitle 		= "Eclipse.org - Kepler Simultaneous Release : " . $page;
	$pageKeywords	= "eclipse kepler, release, simultaneous, release train, kepler";
	$pageAuthor		= "Christopher Guindon";
	
	# Paste your HTML content between the EOHTML markers!	
	ob_start();	
	?>
	<div id="fullcolumn" class="kepler subpage whoiskepler">
		<?php include_once('includes/nav.php');?>
		<div id="page-right">
			<div class="page-container">
				<h2 id="h2_kepler">Who is Kepler?</h2>
				<p><img src="/kepler/images/kepler.png" id="kepler_pic"/><strong>Johannes Kepler</strong> (German: <span title="Representation in the International Phonetic Alphabet (IPA)">[ˈkʰɛplɐ]</span>; December 27, 1571 – November 15, 1630) was a German mathematician, astronomer and astrologer. A key figure in the 17th century scientific revolution, he is best known for his eponymous laws of planetary motion, codified by later astronomers, based on his works <em>Astronomia nova</em>, <em>Harmonices Mundi</em>, and <em>Epitome of Copernican Astronomy</em>. These works also provided one of the foundations for Isaac Newton's theory of universal gravitation.</p>
				<p>During his career, Kepler was a mathematics teacher at a seminary school in Graz, Austria, where he became an associate of Prince Hans Ulrich von Eggenberg. Later he became an assistant to astronomer Tycho Brahe, and eventually the imperial mathematician to Emperor Rudolf II and his two successors Matthias and Ferdinand II. He was also a mathematics teacher in Linz, Austria, and an adviser to General Wallenstein. Additionally, he did fundamental work in the field of optics, invented an improved version of the refracting telescope (the Keplerian Telescope), and mentioned the telescopic discoveries of his contemporary Galileo Galilei.</p>
				<p class="legal">This article uses material from the Wikipedia article <a href="http://en.wikipedia.org/wiki/Johannes_Kepler" target="_blank">Johannes Kepler</a>, which is released under the <a href="http://creativecommons.org/licenses/by-sa/3.0/">Creative Commons Attribution-Share-Alike License 3.0</a>.</p>
			</div>
		</div>
	</div>
	<?
	$html = ob_get_clean();
	# Generate the web page
	$App->Promotion = TRUE;
	$App->AddExtraHtmlHeader('<link href="http://fonts.googleapis.com/css?family=EB+Garamond" rel="stylesheet" type="text/css"/>');
	$App->AddExtraHtmlHeader('<link type="text/css" href="/kepler/css/styles.min.css?chrisguindon-eclipse" rel="stylesheet"/>');	
	$App->AddExtraHtmlHeader('<!--[if IE 7]><link rel="stylesheet" type="text/css" href="/home/content/ie7_nova.css" media="screen"/><![endif]-->');
	$App->generatePage('Nova', $Menu, NULL , $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
