<?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'

	#*****************************************************************************
	#
	# template.php
	#
	# Author: 		Igor Vinnykov
	# Date:			2007-11-23
	#
	# Description: Autogenerated for eclipse.org site pages from Eclipse IDE help
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Eclipse Subversive - Documentation";
	$pageKeywords	= "Subversive, Subversion, SVN, Team Provider, documentation, user guid";
	$pageAuthor		= "Igor Vinnykov";
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

	<div id="midcolumn" style="width:95%">

	
	<h1>Installation and migration</h1>
		<p>
		    Subversive distribution consists of two parts - Subversive plug-in and Subversive SVN Connectors. Both parts are required in order to work with Subversive. Subversive plug-in is provided under the terms and conditions of the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.php">http://www.eclipse.org/legal/epl-v10.html</a>. Subversive SVN Connectors are external libraries with their own licenses, which are distributed from external location at <a href="http://www.polarion.org/index.php?page=overview&amp;project=subversive">www.polarion.org</a>.
		</p>
		<p>
		    In order to install Subversive you should install Subversive plug-in and at least one Subversive SVN connector, such as native (win32 only) JavaHL connector or pure Java SVNKit connector. Subversive plug-in and Subversive SVN Connectors are distributed from different update sites on different locations, so you should point two update sites in Eclipse update manager.
		</p>

		<h2>Migration from Subversive 1.1.x</h2>		
		<p>
		    Version distributed on Eclipse.org, is the successor of Subversive 1.1.x stream, previously distributed from Polarion.org site. If you want to migrate to this version, you should install it, then perform migration steps and uninstall previous version of the Subversive. You can find step-by-step process descriptions in <a href="gettingStarted/aboutSubversive/update_polarion.php">Migration instructions</a>.
		</p>		
		<h2>Installation and update process</h2>
		<p>
		    Installation and update process is simple and straightforward. You can find step-by-step process descriptions in <a href="gettingStarted/aboutSubversive/install.php">Installation instructions</a> and in <a href="gettingStarted/aboutSubversive/update_eclipse.php">Update instructions</a>.
		</p>

        <h2>Requirements</h2>
        <p>
            This version requires Eclipse 3.3 and doesn't support previous versions of Eclipse IDE. You can see full list of requirements in <a href="gettingStarted/aboutSubversive/requirements.php">'Requirements'</a> topic.
        </p>
		
	<p><i>If you have some questions on Subversive versions refer to <a href="faq.php#versions">Versions and compatibility</a> FAQ section.</i></p>
		<br/>
	<br/>
	</div>	

EOHTML;


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