<project name="org.eclipse.osee.framework.dev.help.ui" basedir="."
	default="all">
	<property name="osee.base.help.plugin" value="../org.eclipse.osee.framework.help.ui" />
	<property name="ant.file.imported" value="${osee.base.help.plugin}/scripts" />
	<import file="${ant.file.imported}/help-build-common.xml" />

	<description>Generate Eclipse help content for developers</description>

	<property name="osee.help.doc.url.base" value="http://wiki.eclipse.org" />

	<target name="all"
		description="Generate Eclipse help content for the OSEE Developers' guide">
		<sequential>
			<delete failonerror="false">
				<fileset dir="OSEE" />
				<fileset dir="images" />
			</delete>

			<mediawiki-to-eclipse-help wikiBaseUrl="${osee.help.doc.url.base}"
				validate="true" failonvalidationerror="true" prependImagePrefix="images"
				formatoutput="true" defaultAbsoluteLinkTarget="osee_external" dest="${basedir}"
				navigationimages="true" title="OSEE Developer's Guide"
				generateUnifiedToc="true">
				<path name="OSEE/Developers_Guide" title="Developers' Guide" />
				<stylesheet url="book.css" />
				<pageAppendum>

					= Updating This Document =

					This document is maintained in a collaborative wiki. If you wish to
					update or modify this document please visit
					{url}</pageAppendum>
			</mediawiki-to-eclipse-help>
			<mkdir dir="images" />
			<copy todir="${basedir}/images" overwrite="true">
				<fileset dir="${ant.file.imported}/commonImages" />
			</copy>
		</sequential>
	</target>
</project>
