<?xml version="1.0" encoding="UTF-8"?>
<?NLS TYPE="org.eclipse.help.contexts"?>
<contexts>

	<!-- ********************************** -->
	<!-- Dialogs							-->
	<!-- ********************************** -->

	<context id="sync_view_preference_dialog_context">
		<description>This dialog allows you set configure the active synchronization in the Synchronize View.</description>
	</context>

	<context id="configre_refresh_schedule_dialog_context">
		<description>This dialog allows you to configure the active synchronization to be automatically refreshed at a specified interval.</description>
	</context>

	<!-- ********************************** -->
	<!-- Wizard Pages						-->
	<!-- ********************************** -->

	<context id="share_project_page_context">
		<description>This page helps you select what type of target site you wish to connect the project to.</description>
	</context>

	<context id="import_project_set_page_context">
		<description>This page helps you import a project set from a file on the file system or directly from a URL. A project set is a lightweight description of a set of shared projects. It can be used to reconstruct a lineup of shared projects that you have in your workspace.</description>
	</context>

	<context id="export_project_set_page_context">
		<description>This page helps you export a project set to a file which can be shared with other team members. A project set is a lightweight description of a set of shared projects. It can be used to reconstruct a lineup of shared projects that you have in your workspace.</description>
	</context>

	<context id="sync_resource_selection_page_context">
		<description>This page allows you to choose the resources that are to be synchronized.</description>
	</context>

	<context id="refresh_wizard_selection_page_context">
		<description>This page allows you to choose the type of synchronization you want to create.</description>
	</context>

	<!-- ********************************** -->
	<!-- Preference Pages					-->
	<!-- ********************************** -->

	<context id="ignore_preference_page_context">
		<description>You may wish to exclude certain resources from version control. Resources whose names match any enabled pattern will not be released. The wildcard characters '*' and '?' are permitted. Examples: '/*/a/*' matches all files and sub-folders in '/x/a/' and also in '/x/y/z/a/', '/?/a/*' matches all in '/x/a/', '/?/a/*.doc' matches all .doc files in '/x/a/' folder and its sub-folders. These settings will not affect resources already under version control.</description>
		<topic label="Creating a global ignore pattern" href="tasks/tasks-100d1.htm"/>
	</context>

	<context id="model_preference_page_context">
		<description>This page allows you to manage which models are available in the Synchronize view.</description>
		<topic label="CVS Synchronize view" href="reference/ref-33.htm"/>
	</context>

	<context id="sync_preference_page_context">
	<description>This page allows you to configure various aspects of the Synchronize View.</description>
		<topic label="CVS Synchronize view" href="reference/ref-33.htm"/>
	</context>

	<context id="sync_startup_preference_page_context">
		<description>This page allows you to configure whether the Synchronize view is populated automatically when Eclipse starts.</description>
	</context>

	<context id="resource_model_preference_page_context">
		<description>This page allows you to configure how file system resources appear in the synchronize view.</description>
	</context>

	<context id="file_type_preference_page_context">
		<description>This page allows you to associate a file extension with its content type (ASCII or binary). These setting are used by repository providers, such as CVS</description>
		<topic label="Setting the content type of a file extension" href="tasks/tasks-team-1.htm"/>
	</context>

	<!-- ********************************** -->
	<!-- TargetMenuActions 					-->
	<!-- ********************************** -->

	<context id="target_get_action_context">
		<description>Downloads the selected resources from the site into your workspace.</description>
	</context>

	<context id="target_put_action_context">
		<description>Uploads the selected resources from your workspace to the site.</description>
	</context>

	<context id="target_synchronize_action_context">
		<description>Show any differences between the local and remote site state of the selected resources in the Synchronize view.</description>
	</context>

	<context id="target_getas_action_context">
		<description>Downloads the selected resources from the site into your workspace. You may specify the local name of the resources.</description>
	</context>

	<context id="target_getasproject_action_context">
		<description>Downloads the selected resources from the site into your workspace. A project is created in the workspace for each of the selected items.</description>
	</context>

	<context id="target_disconnect_action_context">
		<description>Discards the selected target sites from the list of remembered sites.</description>
	</context>

	<!-- ********************************** -->
	<!-- TargetCatchupReleaseViewer			-->
	<!-- ********************************** -->

	<context id="target_catchup_release_viewer_context">
		<description>This view shows incoming, outgoing and conflicting changes.</description>
	</context>

	<!-- ********************************** -->
	<!-- TargetActions						-->
	<!-- ********************************** -->

	<context id="sync_get_action_context">
		<description>Downloads the selected resources from the site into your workspace.</description>
	</context>

	<context id="sync_put_action_context">
		<description>Uploads the selected resources from your workspace to the site.</description>
	</context>

	<context id="share_project_action_context">
		<description>Shares the selected project with any version control management systems available in Eclipse.</description>
	</context>

	<context id="apply_patch_action_context">
		<description>Applies a patch to files and folders in your workspace.</description>
		<topic label="Working with patches" href="tasks/tasks-68c.htm"/>
	</context>

	<!-- ********************************** -->
	<!-- Views								-->
	<!-- ********************************** -->

	<context id="site_explorer_view_context">
		<description>The Site Explorer view allows you to browse of the contents of known target sites and download remote resources into the local workspace.</description>
	</context>

	<context id="sync_view_context">
		<description>The Synchronize view allows the synchronization of the local contents of the workspace with a remote repository or target.</description>
		<topic label="CVS Synchronize view" href="reference/ref-33.htm"/>
	</context>

	<context id="local_history_context">
		<description>The Local History view allows users to view the local history of a file or an element contained in a file.</description>
		<topic label="Local History" href="gettingStarted/qs-55.htm"/>
		<topic label="Local History Preferences" href="reference/ref-14.htm"/>
		<topic label="Working with Local History" href="tasks/tasks-1f.htm"/>
	</context>

	<!-- ********************************** -->
	<!-- SiteExplorerViewActions			-->
	<!-- ********************************** -->

	<context id="add_site_action_context">
		<description>Creates a new target site to which you can upload or download resources.</description>
	</context>

	<context id="new_folder_action_context">
		<description>Creates a new folder on the target site.</description>
	</context>

	<!-- ********************************** -->
	<!-- SyncViewActions					-->
	<!-- ********************************** -->

	<context id="refresh_action_context">
		<description>Refreshes the contents of the view.</description>
	</context>

	<context id="open_action_context">
		<description>Show the comparison of the local and remote contents of the file in the comparison viewer.</description>
	</context>

	<context id="expandall_action_context">
		<description>Fully expands all selected items.</description>
	</context>

	<context  id="remove_action_context">
		<description>Removes the selected items from the Synchronize view.</description>
	</context>

	<context  id="navigator_show_action_context">
		<description>Selects and reveals the selected items in the Navigator view.</description>
	</context>

</contexts>