diff --git a/docs/org.eclipse.wst.xsl.doc/build.xml b/docs/org.eclipse.wst.xsl.doc/build.xml
index e4b9785..36c9f66 100644
--- a/docs/org.eclipse.wst.xsl.doc/build.xml
+++ b/docs/org.eclipse.wst.xsl.doc/build.xml
@@ -12,10 +12,10 @@
 	<property name="base.dir" value="${htmldir}"/>
 
 	<target name="create-doc">
-		<xslt force="true" style="${docbookdir}/eclipse33.xsl" in="${docbooksource}/preferences/preferences.xml" out="test.xml">
+		<xslt force="true" style="${docbookdir}/eclipse33.xsl" in="${docbooksource}/xslhelpcombined.dbk" out="test.xml">
 			<factory name="${xalan}" />
 			<param name="manifest" expression="1"/>
-			<param name="base.dir" expression="${htmldir}/preferences/"/>
+			<param name="base.dir" expression="${htmldir}/"/>
 			<param name="create.plugin.xml" expression="0"/>
 			<param name="chunker.output.indent" expression="yes"/>
 			<param name="navig.showtitles" expression="0"/>
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/editor/editor.xml b/docs/org.eclipse.wst.xsl.doc/docbook/editor/editor.xml
index de954e1..dde79e5 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/editor/editor.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/editor/editor.xml
@@ -1,19 +1,31 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <chapter xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:noNamespaceSchemaLocation="http://www.docbook.org/xsd/4.5/docbook.xsd">
+	<?dbhtml filename="editor/xsleditor.html" ?>
 	<title>XSL Editing</title>
 	<para>
       The XSL Tooling plugins extend the ability of the Web Standard Tools XML
       editor.  This extension adds specific support and functionality for working
       with and debugging XSL files. 
     </para>
+    <section>
+    	<?dbhtml filename="editor/xsleditor_validation.html" ?>
+    	<title>Validation</title>
+    	<para>
+    		The XSL extensions for the eclipse XML editor include as you type validation for XSL specific features.  This includes not
+    		only the ability to syntax check the grammar, but to also to validate specific XSL specification rules.  Grammar validation will
+    		be triggered based on the version attribute for the style sheet that is being edited.   Valid version numbers are 1.0, and 2.0.
+    		Currently XSLT 1.1 which was a transitional specification is not supported for editing.
+    	</para>
+    </section>
 	<section>
+		<?dbhtml filename="editor/xsleditor_validation.html" ?>
 		<title>Content Assist</title>
 		<para>
 		    XSL Tooling extends the existing content assistance support of the XML
 		    Editor to provide content assistance for several XSL namespace attributes.
 		    The content assistance provided covers the available XPath statements as
-		    defined in the XPath Tempalates preference page.
+		    defined in the <emphasis>XPath Templates</emphasis> preference page.
 		</para>
 		<para>
 			The elements and attributes that have content assist available are as follows:
@@ -25,6 +37,9 @@
 				    options available for the <emphasis>match</emphasis>, <emphasis>name</emphasis>, and 
 				    <emphasis>mode</emphasis> attributes.
 				</para>
+				<para>
+					Add image showing template completion.
+				</para>
 			</listitem>
 			<listitem>
 				<para>
@@ -33,6 +48,10 @@
 					for xpath, axis, parmaters and variables that have already been predefined when using the optional
 					<emphasis>select</emphasis> attribute.
 				</para>
+				<para>
+					Add image showing variable completion.
+				</para>
+				
 			</listitem>
 			<listitem>
 				<para>
@@ -41,6 +60,9 @@
 					This content assistance is available for all paramaters and variables that are in
 					scope, as well as any available xpath or axis statement.
 				</para>
+				<para>
+					Add image showing test completion.
+				</para>
 			</listitem>
 			<listitem>
 			    <para>
@@ -48,7 +70,36 @@
 			    	assistance for both the <emphasis>mode</emphasis> and <emphasis>select</emphasis>
 			    	attributes. 
 			    </para>
+				<para>
+					Add image showing apply-template completion.
+				</para>
 			</listitem>
 		</itemizedlist>
+		<important>
+			<title>XPath 2.0 Support</title>
+			<para>
+				Currently XPath 2.0 is not supported directly.  However, a user can add this support if they need it by
+				adding the missing XPath functions to the XPath Templates.
+			</para>
+		</important>
+	</section>
+	<section>
+		<?dbhtml filename="editor/xsleditor_templates.html" ?>
+		<title>Templates</title>
+		<para>
+			Specific XSL code completion templates can be added to the XML editor's Templates.   This allows a user
+			to define specific markup completion templates that are commonly used.   In addition, the XPath Templates page
+			can be enhanced to allow commonly used XPath templates to be included, in addition to those installed by default.
+			This allows a user the ability to add custom extension functions for XSLT that may be processor specific.  Adopters
+			may also use the standard template extension point to add additional functionality.
+		</para>
+		<section>
+			<?dbhtml filename="editor/xsleditor_xpathtemplates.html" ?>
+			<title>XPath Templates</title>
+			<para>
+				The XSL XPath Templates preference page allows for a user or adopter to add specific xpath extensions so that
+				they show up in the content assistance.   See the XPath Templates documentation for more information.
+			</para>
+		</section>
 	</section>
 </chapter>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/preferences/preferences.xml b/docs/org.eclipse.wst.xsl.doc/docbook/preferences/preferences.xml
index 402c856..5269618 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/preferences/preferences.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/preferences/preferences.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <chapter id="XSLPreferences" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:noNamespaceSchemaLocation="http://www.docbook.org/xsd/4.5/docbook.xsd">
-	<?dbhtml filename="xslpreferences.html" ?>
+	<?dbhtml filename="preferences/xslpreferences.html" ?>
 	<title>XSL Tooling Preferences</title>
 	<para>
 		The XSL Preference pages has several sub sections.  Each of these allow for configuration
@@ -16,7 +16,7 @@
 		</imageobject>
 	</mediaobject>
 	<section id="XSLFeatures">
-		<?dbhtml filename="xslfeatures.html" ?>
+		<?dbhtml filename="preferences/xslfeatures.html" ?>
 		<title>Features</title>
 		<para>
    			The XSL Features preference page allows for the configuration of features for a particular
@@ -43,7 +43,7 @@
    		</para>
 	</section>
 	<section id="XSLProcessors">
-		<?dbhtml filename="xslprocessors.html" ?>
+		<?dbhtml filename="preferences/xslprocessors.html" ?>
 		<title>Installed Processors</title>
 		<para>
   			The installed processors page lets you pick which of the installed XSLT processors will be used
@@ -57,7 +57,7 @@
       	</mediaobject>
 	</section>
 	<section id="XSLOutputProperties">
-		<?dbhtml filename="xsloutputproperties.html" ?>
+		<?dbhtml filename="preferences/xsloutputproperties.html" ?>
 		<title>Output Properties</title>
 		<para>
 			The various xsl processors support a wide variety of processor specific tweaks.  However there
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/xslhelp.dbk b/docs/org.eclipse.wst.xsl.doc/docbook/xslhelp.dbk
new file mode 100644
index 0000000..dd66687
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/xslhelp.dbk
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<book id="Book1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.docbook.org/xsd/4.5/docbook.xsd">
+  <bookinfo>
+      <title>XSL Tooling User Documentation</title>
+      <author>
+         <firstname>David</firstname>
+         <surname>Carver</surname>
+      </author>
+      <copyright>
+         <year>2008</year>
+         <holder>Eclipse Foundation and others</holder>
+      </copyright>
+   </bookinfo>
+   <xinclude xmlns="http://www.w3.org/2001/XInclude" href="editor/editor.xml"/>
+   <xinclude xmlns="http://www.w3.org/2001/XInclude" href="launching/launching.xml"/>
+   <xinclude xmlns="http://www.w3.org/2001/XInclude" href="preferences/preferences.xml"/>
+</book>
+
diff --git a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor.html b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor.html
new file mode 100644
index 0000000..977dacd
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor.html
@@ -0,0 +1,10 @@
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;1.&nbsp;XSL Editing</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="../index.html" title="XSL Tooling User Documentation"><link rel="up" href="../index.html" title="XSL Tooling User Documentation"><link rel="prev" href="../index.html" title="XSL Tooling User Documentation"><link rel="next" href="xsleditor_validation.html" title="Content Assist"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="N10013"></a>Chapter&nbsp;1.&nbsp;XSL Editing</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="xsleditor.html#N1001B">Validation</a></span></dt><dt><span class="section"><a href="xsleditor_validation.html">Content Assist</a></span></dt><dt><span class="section"><a href="xsleditor_templates.html">Templates</a></span></dt><dd><dl><dt><span class="section"><a href="xsleditor_templates.html#N10079">XPath Templates</a></span></dt></dl></dd></dl></div><p> The XSL Tooling plugins extend the ability of the Web Standard
+			Tools XML editor. This extension adds specific support and
+			functionality for working with and debugging XSL files. </p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="N1001B"></a>Validation</h2></div></div></div><p> The XSL extensions for the eclipse XML editor include as you
+				type validation for XSL specific features. This includes not only
+				the ability to syntax check the grammar, but to also to validate
+				specific XSL specification rules. Grammar validation will be
+				triggered based on the version attribute for the style sheet that is
+				being edited. Valid version numbers are 1.0, and 2.0. Currently XSLT
+				1.1 which was a transitional specification is not supported for
+				editing. </p></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_templates.html b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_templates.html
new file mode 100644
index 0000000..6787896
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_templates.html
@@ -0,0 +1,12 @@
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Templates</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="../index.html" title="XSL Tooling User Documentation"><link rel="up" href="xsleditor.html" title="Chapter&nbsp;1.&nbsp;XSL Editing"><link rel="prev" href="xsleditor_validation.html" title="Content Assist"><link rel="next" href="../preferences/xslpreferences.html" title="Chapter&nbsp;2.&nbsp;XSL Tooling Preferences"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="N10073"></a>Templates</h2></div></div></div><p> Specific XSL code completion templates can be added to the XML
+				editor's Templates. This allows a user to define specific markup
+				completion templates that are commonly used. In addition, the XPath
+				Templates page can be enhanced to allow commonly used XPath
+				templates to be included, in addition to those installed by default.
+				This allows a user the ability to add custom extension functions for
+				XSLT that may be processor specific. Adopters may also use the
+				standard template extension point to add additional functionality. 
+			</p><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="N10079"></a>XPath Templates</h3></div></div></div><p> The XSL XPath Templates preference page allows for a user or
+					adopter to add specific xpath extensions so that they show up in
+					the content assistance. See the XPath Templates documentation for
+					more information. </p></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_validation.html b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_validation.html
new file mode 100644
index 0000000..2e01a21
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_validation.html
@@ -0,0 +1,46 @@
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Content Assist</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="../index.html" title="XSL Tooling User Documentation"><link rel="up" href="xsleditor.html" title="Chapter&nbsp;1.&nbsp;XSL Editing"><link rel="prev" href="xsleditor.html" title="Chapter&nbsp;1.&nbsp;XSL Editing"><link rel="next" href="xsleditor_templates.html" title="Templates"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="N10021"></a>Content Assist</h2></div></div></div><p>
+				XSL Tooling extends the existing content assistance support of the
+				XML Editor to provide content assistance for several XSL namespace
+				attributes. The content assistance provided covers the available
+				XPath statements as defined in the
+				<span class="emphasis"><em>XPath Templates</em></span>
+				preference page.
+			</p><p> The elements and attributes that have content assist available
+				are as follows: </p><div class="itemizedlist"><ul type="disc"><li><p>
+						<span class="bold"><strong>template</strong></span>
+						- The template element has several content assist options
+						available for the
+						<span class="emphasis"><em>match</em></span>
+						,
+						<span class="emphasis"><em>name</em></span>
+						, and
+						<span class="emphasis"><em>mode</em></span>
+						attributes.
+					</p><p> Add image showing template completion. </p></li><li><p>
+						<span class="bold"><strong>variable</strong></span>
+						and
+						<span class="bold"><strong>param</strong></span>
+						- The variable and param elements have content assist for xpath,
+						axis, parmaters and variables that have already been predefined
+						when using the optional
+						<span class="emphasis"><em>select</em></span>
+						attribute.
+					</p><p> Add image showing variable completion. </p></li><li><p>
+						<span class="bold"><strong>if</strong></span>
+						and
+						<span class="bold"><strong>when</strong></span>
+						- The if and when elements have content assist for the
+						<span class="emphasis"><em>test</em></span>
+						attribute. This content assistance is available for all paramaters
+						and variables that are in scope, as well as any available xpath or
+						axis statement.
+					</p><p> Add image showing test completion. </p></li><li><p>
+						<span class="bold"><strong>apply-template</strong></span>
+						- The apply template has content assistance for both the
+						<span class="emphasis"><em>mode</em></span>
+						and
+						<span class="emphasis"><em>select</em></span>
+						attributes.
+					</p><p> Add image showing apply-template completion. </p></li></ul></div><div class="important" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">XPath 2.0 Support</h3><p> Currently XPath 2.0 is not supported directly. However, a
+					user can add this support if they need it by adding the missing
+					XPath functions to the XPath Templates. </p></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/maintopic.html b/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/maintopic.html
deleted file mode 100644
index a476078..0000000
--- a/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/maintopic.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	<title>Main Topic</title>
-</head>
-
-<body>
-<h1>Main Topic</h1>
-Please enter your text here.
-</body>
-</html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/subtopic.html b/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/subtopic.html
deleted file mode 100644
index 8a61c50..0000000
--- a/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/subtopic.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	<title>Sub Topic</title>
-</head>
-
-<body>
-<h1>Sub Topic</h1>
-Please enter your text here.
-</body>
-</html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/subtopic2.html b/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/subtopic2.html
deleted file mode 100644
index 86bcbf9..0000000
--- a/docs/org.eclipse.wst.xsl.doc/html/gettingstarted/subtopic2.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	<title>Sub Topic 2</title>
-</head>
-
-<body>
-<h1>Sub Topic 2</h1>
-Please enter your text here.
-</body>
-</html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/index.html b/docs/org.eclipse.wst.xsl.doc/html/index.html
new file mode 100644
index 0000000..4c9a0fc
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/html/index.html
@@ -0,0 +1 @@
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>XSL Tooling User Documentation</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="index.html" title="XSL Tooling User Documentation"><link rel="next" href="editor/xsleditor.html" title="Chapter&nbsp;1.&nbsp;XSL Editing"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="book" lang="en"><div class="titlepage"><div><div><h1 class="title"><a name="Book1"></a>XSL Tooling User Documentation</h1></div><div><div class="author"><h3 class="author"><span class="firstname">David</span> <span class="surname">Carver</span></h3></div></div><div><p class="copyright">Copyright &copy; 2008 Eclipse Foundation and others</p></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="chapter"><a href="editor/xsleditor.html">1. XSL Editing</a></span></dt><dd><dl><dt><span class="section"><a href="editor/xsleditor.html#N1001B">Validation</a></span></dt><dt><span class="section"><a href="editor/xsleditor_validation.html">Content Assist</a></span></dt><dt><span class="section"><a href="editor/xsleditor_templates.html">Templates</a></span></dt><dd><dl><dt><span class="section"><a href="editor/xsleditor_templates.html#N10079">XPath Templates</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="preferences/xslpreferences.html">2. XSL Tooling Preferences</a></span></dt><dd><dl><dt><span class="section"><a href="preferences/xslpreferences.html#XSLFeatures">Features</a></span></dt><dt><span class="section"><a href="preferences/xslprocessors.html">Installed Processors</a></span></dt><dt><span class="section"><a href="preferences/xsloutputproperties.html">Output Properties</a></span></dt></dl></dd></dl></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/preferences/xsloutputproperties.html b/docs/org.eclipse.wst.xsl.doc/html/preferences/xsloutputproperties.html
index 0c1d782..2fb9b11 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/preferences/xsloutputproperties.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/preferences/xsloutputproperties.html
@@ -1,9 +1,7 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Output Properties</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="xslpreferences.html" title="Chapter&nbsp;1.&nbsp;XSL Tooling Preferences"><link rel="up" href="xslpreferences.html" title="Chapter&nbsp;1.&nbsp;XSL Tooling Preferences"><link rel="prev" href="xslprocessors.html" title="Installed Processors"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
-			The various xsl processors support a wide variety of processor specific tweaks.  However there
-			are several Standard processor features that all XSLT processors support.   These options can be
-			set and will act as the defaults for all transformations unless they are specifically overriden by
-			the stylesheet or the launch configuration.
-		</p><div class="mediaobject" align="center"><img src="../images/preferences/xsl_outputproperties.png" align="middle"></div><p>
-			In addition to the Standard Output Properties, each XSLT processor can have processors
-			specific features.
-		</p></body></html>
\ No newline at end of file
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Output Properties</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="../index.html" title="XSL Tooling User Documentation"><link rel="up" href="xslpreferences.html" title="Chapter&nbsp;2.&nbsp;XSL Tooling Preferences"><link rel="prev" href="xslprocessors.html" title="Installed Processors"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="XSLOutputProperties"></a>Output Properties</h2></div></div></div><p> The various xsl processors support a wide variety of processor
+				specific tweaks. However there are several Standard processor
+				features that all XSLT processors support. These options can be set
+				and will act as the defaults for all transformations unless they are
+				specifically overriden by the stylesheet or the launch
+				configuration. </p><div class="mediaobject" align="center"><img src="../images/preferences/xsl_outputproperties.png" align="middle"></div><p> In addition to the Standard Output Properties, each XSLT
+				processor can have processors specific features. </p></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/preferences/xslpreferences.html b/docs/org.eclipse.wst.xsl.doc/html/preferences/xslpreferences.html
index 48c38ca..149d5b7 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/preferences/xslpreferences.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/preferences/xslpreferences.html
@@ -1,20 +1,22 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;1.&nbsp;XSL Tooling Preferences</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="xslpreferences.html" title="Chapter&nbsp;1.&nbsp;XSL Tooling Preferences"><link rel="next" href="xslprocessors.html" title="Installed Processors"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
-		The XSL Preference pages has several sub sections.  Each of these allow for configuration
-		of various aspects of the preferences.   From the controlling of the default XSL processor
-		to be used during transformations.   To extending the content assist support of the XPath
-		functions available in the XML editor.
-   </p><div class="mediaobject" align="center"><img src="../images/preferences/xslpreferences.png" align="middle"></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="XSLFeatures"></a>Features</h2></div></div></div><p>
-   			The XSL Features preference page allows for the configuration of features for a particular
-   			processor.   XSL Tooling comes with Xalan 2.7.0 by default.  Adopters can extend and include
-   			their own specific features for their own procesoors.   An adopter could extend the tooling
-   			to support XSLT 2.0 transformations, and features particular to that parser.
-   		</p><div class="mediaobject" align="center"><img src="../images/preferences/xslfeatures.png" align="middle"></div><p>
-   			The <span class="bold"><strong>Processor Type</strong></span> allows you to set features for a specific processor.  In this case
-   			this is for the processor that is being installed.   XSL Tooling comes with Xalan 2.7.0, and it is the only available
-   			processor type by default.
-   		</p><p>
-   		    The feature table lists the features that are specific to the processor that was selected.  As you
-   		    select each of the features, information regarding that feature and it's abilitis is displayed in the
-   		    description box.   By clicking in the value column, next to the feature you want to set the value
-   		    for, the user can set the feature.
-   		</p></div></body></html>
\ No newline at end of file
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;2.&nbsp;XSL Tooling Preferences</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="../index.html" title="XSL Tooling User Documentation"><link rel="up" href="../index.html" title="XSL Tooling User Documentation"><link rel="prev" href="../editor/xsleditor_templates.html" title="Templates"><link rel="next" href="xslprocessors.html" title="Installed Processors"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="XSLPreferences"></a>Chapter&nbsp;2.&nbsp;XSL Tooling Preferences</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="xslpreferences.html#XSLFeatures">Features</a></span></dt><dt><span class="section"><a href="xslprocessors.html">Installed Processors</a></span></dt><dt><span class="section"><a href="xsloutputproperties.html">Output Properties</a></span></dt></dl></div><p> The XSL Preference pages has several sub sections. Each of
+			these allow for configuration of various aspects of the preferences.
+			From the controlling of the default XSL processor to be used during
+			transformations. To extending the content assist support of the XPath
+			functions available in the XML editor. </p><div class="mediaobject" align="center"><img src="../images/preferences/xslpreferences.png" align="middle"></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="XSLFeatures"></a>Features</h2></div></div></div><p> The XSL Features preference page allows for the configuration
+				of features for a particular processor. XSL Tooling comes with Xalan
+				2.7.0 by default. Adopters can extend and include their own specific
+				features for their own procesoors. An adopter could extend the
+				tooling to support XSLT 2.0 transformations, and features particular
+				to that parser. </p><div class="mediaobject" align="center"><img src="../images/preferences/xslfeatures.png" align="middle"></div><p>
+				The
+				<span class="bold"><strong>Processor Type</strong></span>
+				allows you to set features for a specific processor. In this case
+				this is for the processor that is being installed. XSL Tooling comes
+				with Xalan 2.7.0, and it is the only available processor type by
+				default.
+			</p><p> The feature table lists the features that are specific to the
+				processor that was selected. As you select each of the features,
+				information regarding that feature and it's abilitis is displayed in
+				the description box. By clicking in the value column, next to the
+				feature you want to set the value for, the user can set the feature. 
+			</p></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/preferences/xslprocessors.html b/docs/org.eclipse.wst.xsl.doc/html/preferences/xslprocessors.html
index 0dabc5b..be0f1a8 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/preferences/xslprocessors.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/preferences/xslprocessors.html
@@ -1,5 +1,4 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Installed Processors</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="xslpreferences.html" title="Chapter&nbsp;1.&nbsp;XSL Tooling Preferences"><link rel="up" href="xslpreferences.html" title="Chapter&nbsp;1.&nbsp;XSL Tooling Preferences"><link rel="prev" href="xslpreferences.html" title="Chapter&nbsp;1.&nbsp;XSL Tooling Preferences"><link rel="next" href="xsloutputproperties.html" title="Output Properties"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
-  			The installed processors page lets you pick which of the installed XSLT processors will be used
-  			by default.   The default is the System Default Procesoor, but you can select any of the
-  			available processors to be used as the default processor.    	
-      	</p><div class="mediaobject" align="center"><img src="../images/preferences/xsl_InstalledProcessors.png" align="middle"></div></body></html>
\ No newline at end of file
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Installed Processors</title><meta content="DocBook XSL Stylesheets V1.73.2" name="generator"><link rel="start" href="../index.html" title="XSL Tooling User Documentation"><link rel="up" href="xslpreferences.html" title="Chapter&nbsp;2.&nbsp;XSL Tooling Preferences"><link rel="prev" href="xslpreferences.html" title="Chapter&nbsp;2.&nbsp;XSL Tooling Preferences"><link rel="next" href="xsloutputproperties.html" title="Output Properties"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="XSLProcessors"></a>Installed Processors</h2></div></div></div><p> The installed processors page lets you pick which of the
+				installed XSLT processors will be used by default. The default is
+				the System Default Procesoor, but you can select any of the
+				available processors to be used as the default processor. </p><div class="mediaobject" align="center"><img src="../images/preferences/xsl_InstalledProcessors.png" align="middle"></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/test.xml b/docs/org.eclipse.wst.xsl.doc/test.xml
deleted file mode 100644
index e69de29..0000000
--- a/docs/org.eclipse.wst.xsl.doc/test.xml
+++ /dev/null
diff --git a/docs/org.eclipse.wst.xsl.doc/toc.xml b/docs/org.eclipse.wst.xsl.doc/toc.xml
index 5ba78ee..b586131 100644
--- a/docs/org.eclipse.wst.xsl.doc/toc.xml
+++ b/docs/org.eclipse.wst.xsl.doc/toc.xml
@@ -1,6 +1,16 @@
-<toc topic="html/preferences/xslpreferences.html" label="XSL Tooling Preferences">
-	<topic href="html/preferences/xslpreferences.html#XSLFeatures"
-		label="Features"></topic>
-	<topic href="html/preferences/xslprocessors.html" label="Installed Processors"></topic>
-	<topic href="html/preferences/xsloutputproperties.html" label="Output Properties"></topic>
+<toc topic="html/index.html" label="XSL Tooling User Documentation">
+	<topic href="html/editor/xsleditor.html" label="XSL Editing">
+		<topic href="html/editor/xsleditor.html#N1001B" label="Validation"></topic>
+		<topic href="html/editor/xsleditor_validation.html" label="Content Assist"></topic>
+		<topic href="html/editor/xsleditor_templates.html" label="Templates">
+			<topic href="html/editor/xsleditor_templates.html#N10079"
+				label="XPath Templates"></topic>
+		</topic>
+	</topic>
+	<topic href="html/preferences/xslpreferences.html" label="XSL Tooling Preferences">
+		<topic href="html/preferences/xslpreferences.html#XSLFeatures"
+			label="Features"></topic>
+		<topic href="html/preferences/xslprocessors.html" label="Installed Processors"></topic>
+		<topic href="html/preferences/xsloutputproperties.html" label="Output Properties"></topic>
+	</topic>
 </toc>
\ No newline at end of file
