<!--
	Copyright (c) 2010, 2012 Eike Stepper (Berlin, Germany) 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:
	  Martin Fluegge - initial API and implementation
-->
<contexts>
	<context id="viewer" title="Sample View">
		<description>This is the context help for the sample view with a tree viewer. It was generated by a PDE template.</description>
		<topic href="/PLUGINS_ROOT/org.eclipse.platform.doc.isv/guide/ua_help_context.htm" label="Context-sensitive help">
			<enablement>
				<with variable="platform">
	            	<test property="org.eclipse.core.runtime.isBundleInstalled" args="org.eclipse.platform.doc.isv"/>
	     		</with>
			</enablement>
		</topic>
	</context>
</contexts>
