<?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());    
	# 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";
		
	include("_projectCommon.php");    # All on the same line to unclutter the user's desktop'
	
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

	<div id="midcolumn">
	
	<h2>Diff Viewer</h2>
	<p>
		These preferences can be changed on
			<i>'Team>SVN>Diff Viewer'</i>
		properties page.
		On this page user can configure external diff/merge programs used for comparing different revisions of files.
		User can associate an external diff program to specific file extension or mime type. For example, in order to specify file extension for doc files use .doc. Example of mime-type usage: text/plain.
		Also user can specify external diff program which will be applied for all files by using an asterisk(*) in extension/mime-type field.		
	</p>
	
	<p>
		For each file extension/mime-type user can specify following parameters: diff program path, diff program arguments, merge program path, merge program parameters.
		Diff program settings are applied for compare actions. Merge program settings are applied for Edit Conflicts action.
		The external program will need to obtain the filenames from the command line, along with any other command line options.
		<br/>
		Subversive uses substitution parameters in a form %{param-name}. When it encounters one of these it will substitute the appropriate value.
		<ul>
			<li>base: <i>The original file without your changes.</i></li>
			<li>mine: <i>Your own file, with your changes.</i></li>
			<li>theirs: <i>The file as it is in the repository.</i></li>
			<li>merged: <i>The conflicted file, where to save.</i></li>
			<li>etc.</li>
		</ul>
	</p>
	
	<!-- Default config -->
	<p>
		Subversive is supplied with default configuration for file extension associations, default configuration includes paths to script files
		which allow to run external programs. It includes configuration for following file extensions: doc, docx, xls, xlsx, ppt, pptx, odt, ods.
	</p>	
	
	<table cellpadding="1" cellspacing="0" border="0">
		<tr>
			<td valign="top" align="left">
				<p align="left">
					<i>
						<b>Tip:</b>
					</i>
				</p>
			</td>
			<td valign="top">
				<p>
					<i>
						Default diff handlers provided by Subversive are loaded and can be used only on Microsoft Windows. 
						For other operating systems users can configure their own handlers.
					</i>
				</p>
			</td>
		</tr>
	</table>

	This is how <i>'Diff Viewer'</i> properties page looks like:
	<br/><br/><img border="0" src="../images/pref_diff_viewer.png" alt="Diff Viewer properties page"/>
	<br/>
	<br/>
	
	Here's a list of actions which can call external compare editor:
	<ul> 
		<li>Compare With Base from Working Copy</li>
		<li>Compare With Latest from Repository</li>
		<li>Compare With Revision or Url...</li>
		<li>Compare With Branch...</li>
		<li>Compare With Tag...</li>	
		<li>'Compare In External Compare Editor' action in Synchronize View</li>
		<li>'Edit Conflicts' action in Synchronize View</li>
		<li>Compare actions available from History View, e.g. Compare With Previous State</li>			
		<li>'Compare In External Compare Editor' action available for files when performing comparing for directories</li>
		<li>etc.</li>
	</ul>	
	
	</div>	

EOHTML;


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