<?php
	set_include_path($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common" . PATH_SEPARATOR . $_SERVER['DOCUMENT_ROOT'] . "/projects" . PATH_SEPARATOR . get_include_path());
	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());
	
	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/subversive/css/root-page.css"/>');
	
	$localVersion = false;
	
	# No left navigation
	$Nav = null;
	
	# Define these here, or in _projectCommon.php for site-wide values
	$pageTitle 		= "Eclipse Subversive - Subversion (SVN) Team Provider";
	$pageKeywords	= "Subversive, Subversion, SVN, Team Provider";
	$pageAuthor		= "Igor Vinnykov";

	$sidebar = file_get_contents($_SERVER['DOCUMENT_ROOT'] . "/subversive/sidebars/main.php");
	
	// 	# Paste your HTML content between the EOHTML markers!
$html = <<<EOHTML

	<!--	<div id="bigbuttons">
<h3>Primary Links</h3>
<ul>
	<li><a id="buttonDownload" href="/subversive/downloads.php"></a></li>
	<li><a id="buttonDocumentation" href="/subversive/documentation.php"></a></li>
	<li><a id="buttonSupport" href="/subversive/support.php"></a></li>
	<li><a id="buttonInvolved" href="/subversive/getting-involved.php"></a></li>
</ul>
</div>
-->
<div id="midcolumn">
		<table width="100%" cellspacing="0" cellpadding="0" style="margin-bottom: 0px;">
			<tr>
				<td width="100%">
					<h1>Eclipse Subversive - Subversion (SVN) Team Provider</h1>
					<p>
						The Subversive project is aimed to integrate the <a href="http://subversion.apache.org/">Subversion</a> (SVN) version control system with the Eclipse platform. Using the Subversive plug-in, you can work with projects stored in Subversion repositories directly from the Eclipse workbench in a way similar to work with other Eclipse version control providers, such as CVS and Git.
					</p>
					<h2>About the Project</h2>
					<p>
						The project was started in 2005 by the <a href="http://www.polarion.com?utm_source=eclipse.org&utm_medium=link&utm_campaign=subversive">Polarion</a> company as an open-source project and was migrated under Eclipse umbrella as an official Eclipse project in 2007. Today, the Subversive project consists of the Subversive plug-in for Eclipse developed as an Eclipse open-source project; and the Subversion connectors (used for communication with SVN) developed as an external open-source project on <a href="http://www.polarion.com/products/svn/subversive.php?utm_source=eclipse.org&utm_medium=link&utm_campaign=subversive">Polarion.com</a>.
					</p>
					<h2>Subversive Features</h2>
					<p>
						Subversive plug-in provides access to Subversion repositories from the Eclipse workbench.
					</p>				
				</td>
			</tr>
			<tr>
				<td>
					<table width="100%" cellspacing="0" cellpadding="0" style="margin-bottom: 0px;">
						<tr valign="top">
							<td width="50%">
								<h4>Full-Scale SVN Client</h4>
								<p>
									Subversive is designed to be used as a full-featured SVN client, so you can update, commit, merge changes, work with SVN properties, view change history and perform other operations with SVN directly from the Eclipse environment.
								</p>
							</td>
							<td>&nbsp;&nbsp;&nbsp;</td>
							<td width="50%">
								<h4>Advanced SVN Features</h4>
								<p>
									Subversive includes several features that extend functionality of the standard SVN client. In particular, Subversive can show the SVN repository content grouped by the logical structures of trunk, branch and tag and display changes on a visual revisions graph.
								</p>
							</td>							
						</tr>
						<tr valign="top">						
							<td>
								<h4>Seamless Integration with Eclipse</h4>
								<p>
									Subversive is an official Eclipse project and an integral part of Eclipse Simultaneous releases. The project follows all Eclipse guidelines and requirements to deliver a quality SVN team provider plug-in similar to CVS and Git implementations.
								</p>								
							</td>
							<td>&nbsp;&nbsp;&nbsp;</td>
							<td>
								<h4>Support of the Latest SVN Versions</h4>
								<p>
									Subversive evolves together with the Subversion project to provide Eclipse users with the features that appeared in new versions of the SVN implementation. You can use the new SVN functionality in Eclipse by installing the Early Access version of Subversive.
								</p>							
							</td>							
						</tr>						
					</table>				
				</td>
			</tr>
			<tr>
				<td>
					<h2>Getting Started</h2>
					<p>
						Are you new to Subversive? Use the following resources to install Subversive and learn how to use it to work with projects stored in SVN repositories.
					</p>
					<ul>
						<li><a href="/subversive/latest-releases.php">Downloads</a> - Learn how to download and install the right Subversive version for your OS platform, Eclipse and SVN environment.</li>
						<li><a href="/subversive/documentation.php">Documentation</a> - Get information on how to use Subversive for work with SVN repositories. Learn more about new features introduced in the latest releases. Find answers to frequently asked questions.</li>						
						<li><a href="/subversive/support.php">Support</a> - Report Subversive bugs using Eclipse Bugzilla. Learn how to get help from the Subversive team and Subversive community members.</li>						
						<li><a href="/subversive/getting-involved.php">Getting Involved</a> - Get access to the project source code and development plans. Learn how to use Subversive API so as to integrate it with your projects.</li>
					</ul>
				</td>
			</tr>
		</table>
</div>

<div id="rightcolumn">
	$sidebar
</div>

EOHTML;
		

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>