diff --git a/docs/org.eclipse.wst.xsl.doc/.project b/docs/org.eclipse.wst.xsl.doc/.project
index 5f1ca8e..f266912 100644
--- a/docs/org.eclipse.wst.xsl.doc/.project
+++ b/docs/org.eclipse.wst.xsl.doc/.project
@@ -15,6 +15,11 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.pde.PluginNature</nature>
diff --git a/docs/org.eclipse.wst.xsl.doc/.settings/org.eclipse.wst.validation.prefs b/docs/org.eclipse.wst.xsl.doc/.settings/org.eclipse.wst.validation.prefs
new file mode 100644
index 0000000..6ecc4d4
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/.settings/org.eclipse.wst.validation.prefs
@@ -0,0 +1,14 @@
+#Sat Sep 06 19:52:11 GMT 2008
+DELEGATES_PREFERENCE=delegateValidatorList
+USER_BUILD_PREFERENCE=enabledBuildValidatorList
+USER_MANUAL_PREFERENCE=enabledManualValidatorList
+USER_PREFERENCE=overrideGlobalPreferencestruedisableAllValidationfalseversion1.2.0.v200807211450
+eclipse.preferences.version=1
+override=true
+suspend=false
+vals/org.eclipse.jst.jsp.core.JSPBatchValidator/global=FF01
+vals/org.eclipse.jst.jsp.core.JSPContentValidator/global=FF01
+vals/org.eclipse.wst.html.ui.HTMLValidator/global=FF01
+vals/org.eclipse.wst.wsdl.validation.wsdl/global=FF02158org.eclipse.wst.wsdl.validation.internal.eclipse.Validator
+vals/org.eclipse.wst.xsd.core.xsd/global=FF02162org.eclipse.wst.xsd.core.internal.validation.eclipse.Validator
+vf.version=3
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 6d6fc3d..cc51997 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/editor/editor.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/editor/editor.xml
@@ -1,111 +1,206 @@
 <?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">
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+          "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<chapter>
 	<?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. 
+   <title>XSL Editing</title>
+   <para>
+      The XSL Tools 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 id="Validation">
+   <section id="Validation">
     	<?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.
+      <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.
     	</para>
-    </section>
-	<section id="ContentAssist">
+   </section>
+   <section id="ContentAssist">
 		<?dbhtml filename="editor/xsleditor_contentassist.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 <emphasis>XPath Templates</emphasis> preference page.
-		</para>
-		<para>
-			The elements and attributes that have content assist available are as follows:
-		</para>
-		<itemizedlist>
-			<listitem>
-				<para>
-				    <emphasis role="bold">template</emphasis> - The template element has several content assist
-				    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>
-					<emphasis role="bold">variable</emphasis> and <emphasis
-					role="bold">param</emphasis> - The variable and param elements have content assist
-					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>
-					<emphasis role="bold">if</emphasis> and <emphasis role="bold">when</emphasis> - The
-					if and when elements have content assist for the <emphasis>test</emphasis> attribute.
-					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>
-			    	<emphasis role="bold">apply-template</emphasis> - The apply template has content
-			    	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.
+      <title>Content Assist</title>
+      <para>
+         XSL Tools 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
+         <emphasis>XPath Templates</emphasis>
+         preference page.
+      </para>
+      <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 id="XSLEditorTemplates">
+      </important>
+      <section id="SelectTest">
+         <title>Select and Test Attributes </title>
+         <para>
+            Where ever an xsl element supports a
+            <emphasis>select</emphasis>
+            or
+            <emphasis>test</emphasis>
+            attribute, content assistance is
+            available. This includes support for
+            the following:
+         </para>
+         <itemizedlist>
+            <title>Select and Test Assistance</title>
+            <listitem>
+               <para>
+                  <emphasis>Variables</emphasis>
+                  - both local and global variables are supported within the current
+                  stylesheet. Any local or global
+                  variable will be
+                  added to the list
+                  and the name is prefixed with a dollar sign $ symbol.
+               </para>
+            </listitem>
+            <listitem>
+               <para>
+                  <emphasis>XPath 1.0</emphasis>
+                  - XPath 1.0 is supported through the use of templates. All of the
+                  XPath 1.0 and XSLT xpath
+                  extension
+                  functions are available, as well
+                  as
+                  <emphasis>axis</emphasis>
+                  operations. Currently XPath 2.0 is not supported
+                  directly, but will
+                  be added in the future.
+               </para>
+            </listitem>
+         </itemizedlist>
+         <para>
+            Content assistance for the select and test attributes is
+            intelligent enough to know that it is within an
+            XPath expression, and will try to determine and provide content assistance based on the
+            current cursor
+            position. If a word has been partially typed it will
+            filter the available assistance.
+			</para>
+      </section>
+      <section id="ExcludeResultPrefixesContentAssist">
+         <title>Exclude-Result-Prefixes</title>
+         <para>
+            The
+            <emphasis>exclude-result-prefixes</emphasis>
+            attribute in both XSLT 1.0 and XSLT 2.0 allows for the exclusion of
+            certain namespace
+            declarations in the
+            output document. The content
+            assistance populates a list of available namespaces that have been
+            defined in
+            the
+            stylseheet and provides them as proposals as shown in
+            <xref linkend="fig_ExcludeResultPrefixesContentAssist1" />
+            .
+         </para>
+         <figure id="fig_ExcludeResultPrefixesContentAssist1">
+            <title>Exclude-result-prefixes Content
+               Assistance</title>
+            <mediaobject>
+               <imageobject>
+                  <imagedata align="center" fileref="../images/editor/ExcludeContentAssist1.png" />
+               </imageobject>
+            </mediaobject>
+         </figure>
+         <para>
+            If the attribute has no values defined, then the
+            <emphasis>#all</emphasis>
+            value will be available in the list. If #all
+            is already in the
+            attributes value, then no content assistance
+            will be available.
+         </para>
+         <figure id="fig_ExcludeResultPrefixesContentAssist2">
+            <title>Filtered exclude-result-prefixes proposals</title>
+            <mediaobject>
+               <imageobject>
+                  <imagedata align="center" fileref="../images/editor/ExcludeContentAssist2.png" />
+               </imageobject>
+            </mediaobject>
+         </figure>
+         <para>
+            Content assistance is intelligent enough to know when a
+            namespace prefix is already in the list of
+            excluded namespaces. In
+            this
+            case it will not show the namespace in the proposal list.
+			</para>
+         <note>
+            <title>Why isn't the XSL Namespace prefix in the proposals?
+				</title>
+            <para>
+               Currently the xsl prefix or any prefix that uses the XSL
+               namespace is excluded from the list. This may
+               be changed at
+               a future
+               date. This will depend on user feedback.
+				</para>
+         </note>
+      </section>
+   </section>
+   <section id="XSLEditorTemplates">
 		<?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.
+      <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>
+      <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.
+         <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>
-	<section id="XSLEditorDebugging">
+      </section>
+   </section>
+   <section id="XSLEditorDebugging">
 	   <?dbhtml filename="editor/xsleditor_debugging.html" ?>
-		<title>XSL Debugging</title>
-		<para>
-			TODO: Add XSL Debugging documentation.
+      <title>XSL Debugging</title>
+      <para>
+         TODO: Add XSL Debugging documentation.
 		</para>
-	</section>
+   </section>
 </chapter>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/general/general.xml b/docs/org.eclipse.wst.xsl.doc/docbook/general/general.xml
index d98016b..b72c45a 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/general/general.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/general/general.xml
@@ -1,6 +1,7 @@
 <?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">
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+          "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<chapter>
 	<?dbhtml filename="general/general.html" ?>
 	<title>General</title>
 	<para>This section covers topics that don't have any other particular place to go.</para>
@@ -13,7 +14,7 @@
         allows for separating out large xml documents into more manageable chunks of information.
       </para>
 		<para>
-      	The XSL Tooling project includes an ANT task that can be run with in eclipse, eclipse
+      	The XSL Tools project includes an ANT task that can be run with in eclipse, eclipse
       	headless, and without eclipse at all.   If running outside of eclipse, you will need
       	to make sure that the jar file xinclude.jar in the org.eclipse.wst.xsl.core.jar file
       	is made avaiable on your class path.
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/images/editor/ExcludeContentAssist1.png b/docs/org.eclipse.wst.xsl.doc/docbook/images/editor/ExcludeContentAssist1.png
new file mode 100644
index 0000000..2f0f2cb
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/images/editor/ExcludeContentAssist1.png
Binary files differ
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/images/editor/ExcludeContentAssist2.png b/docs/org.eclipse.wst.xsl.doc/docbook/images/editor/ExcludeContentAssist2.png
new file mode 100644
index 0000000..2e53677
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/images/editor/ExcludeContentAssist2.png
Binary files differ
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/launching/launching.xml b/docs/org.eclipse.wst.xsl.doc/docbook/launching/launching.xml
index ed9aa5a..8c6307b 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/launching/launching.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/launching/launching.xml
@@ -1,10 +1,11 @@
 <?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">
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+          "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<chapter>
 	<?dbhtml filename="launching/launching.html" ?>
 	<title>XSL Launching and Debugging</title>
 	<para>
-		The XSL Tooling adds support for XSL Launch and Debugging configurations.
+		XSL Tools adds support for XSL Launch and Debugging configurations.
 		These allow you to setup XSL configurations for various jobs, and to also
 		debug xsl stylsheet transformations.	
 	</para>
@@ -13,7 +14,7 @@
 		<title>XSL Launching</title>
 		<para>
 			In the Project Explorer, simply select the input XML file and the stylesheet(s) to transform it, and then right-click and select 
-			<i>Run As &gt; XSL Transformation</i>. 
+			<emphasis>Run As > XSL Transformation</emphasis>. 
 	    </para>
 		<mediaobject>
 			<imageobject>
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/legal.xml b/docs/org.eclipse.wst.xsl.doc/docbook/legal.xml
index 51cdd5c..58e7ad8 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/legal.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/legal.xml
@@ -1,6 +1,7 @@
 <?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">
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+          "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<chapter>
 	<?dbhtml filename="legal.html" ?>
 	<title>Notices</title>
 	<para>
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 c543e77..35063de 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/preferences/preferences.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/preferences/preferences.xml
@@ -1,8 +1,9 @@
 <?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">
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+          "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<chapter id="XSLPreferences">
 	<?dbhtml filename="preferences/xslpreferences.html" ?>
-	<title>XSL Tooling Preferences</title>
+	<title>XSL Tools Preferences</title>
 	<para>
 		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
@@ -20,7 +21,7 @@
 		<title>Features</title>
 		<para>
    			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
+   			processor.   XSL Tools 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.
    		</para>
@@ -32,7 +33,7 @@
 		</mediaobject>
 		<para>
    			The <emphasis role="bold">Processor Type</emphasis> 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
+   			this is for the processor that is being installed.   XSL Tools comes with Xalan 2.7.0, and it is the only available
    			processor type by default.
    		</para>
 		<para>
@@ -117,7 +118,7 @@
 			<listitem>
 				<para>
 					<emphasis role="bold">xpath 2.0</emphasis> - Represents an XPath 2.0 function.
-					<emphasis>Note: That currently XSL Tooling only ships with templates defined for XPath 1.0 .</emphasis>
+					<emphasis>Note: That currently XSL Tools only ships with templates defined for XPath 1.0 .</emphasis>
 				</para>
 			</listitem>
 			<listitem>
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/samples/samples.xml b/docs/org.eclipse.wst.xsl.doc/docbook/samples/samples.xml
index 2c8106e..710cf1c 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/samples/samples.xml
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/samples/samples.xml
@@ -1,7 +1,7 @@
 <?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"
-	xmlns:xi="http://www.w3.org/2001/XInclude">
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+          "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<chapter>
 	<?dbhtml filename="samples/samples.html" ?>
 	<title>XSL Tooling Samples</title>
 	<para>This section contains several samples and references to sample projects.</para>
@@ -11,7 +11,7 @@
 		<para></para>
 		<section id="DocbookEclipseHelp">
 			<?dbhtml filename="samples/docbookhelp.html" ?>
-			<title>Creating Eclipse Help with Docbook and XSL Tooling</title>
+			<title>Creating Eclipse Help with Docbook and XSL Tools</title>
 			<para>
 				This tutorial assumes that you have knowledge of Docbook, ANT, and the
 				ability to setup ANT build scripts.
@@ -22,7 +22,7 @@
 		</section>
 		<section id="DITAEclipseHelp">
 			<?dbhtml filename="samples/ditahelp.html" ?>
-			<title>Creating Eclipse Help with DITA and XSL Tooling</title>
+			<title>Creating Eclipse Help with DITA and XSL Tools</title>
 			<para>
 				This tutorial assumes that you have knowledge of DITA, ANT, and the
 				ability to setup ANT build scripts.
diff --git a/docs/org.eclipse.wst.xsl.doc/docbook/xslhelp.dbk b/docs/org.eclipse.wst.xsl.doc/docbook/xslhelp.dbk
index 5b0014b..1fb67b1 100644
--- a/docs/org.eclipse.wst.xsl.doc/docbook/xslhelp.dbk
+++ b/docs/org.eclipse.wst.xsl.doc/docbook/xslhelp.dbk
@@ -1,8 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<book id="XSLUser" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.docbook.org/xsd/4.5/docbook.xsd"
-	  xmlns:xi="http://www.w3.org/2001/XInclude">
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+          "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<book id="XSLUser" xmlns:xi="http://www.w3.org/2001/XInclude">
   <bookinfo>
-      <title>XSL Tooling User Documentation</title>
+      <title>XSL Tools User Documentation</title>
       <author>
          <firstname>David</firstname>
          <surname>Carver</surname>
diff --git a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor.html b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor.html
index 14c9584..7e8c138 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor.html
@@ -1,10 +1,23 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;2.&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="../general/general.html" title="Chapter&nbsp;1.&nbsp;General"><link rel="next" href="xsleditor_contentassist.html" title="Content Assist"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><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. 
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;2.&nbsp;XSL Editing</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="../index.html" title="XSL Tools User Documentation"><link rel="prev" href="../general/general.html" title="Chapter&nbsp;1.&nbsp;General"><link rel="next" href="xsleditor_contentassist.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="N10044"></a>Chapter&nbsp;2.&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#Validation">Validation</a></span></dt><dt><span class="section"><a href="xsleditor_contentassist.html">Content Assist</a></span></dt><dd><dl><dt><span class="section"><a href="xsleditor_contentassist.html#SelectTest">Select and Test Attributes </a></span></dt><dt><span class="section"><a href="xsleditor_contentassist.html#ExcludeResultPrefixesContentAssist">Exclude-Result-Prefixes</a></span></dt></dl></dd><dt><span class="section"><a href="xsleditor_templates.html">Templates</a></span></dt><dd><dl><dt><span class="section"><a href="xsleditor_templates.html#N100B4">XPath Templates</a></span></dt></dl></dd><dt><span class="section"><a href="xsleditor_debugging.html">XSL Debugging</a></span></dt></dl></div><p>
+      The XSL Tools 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="Validation"></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></body></html>
\ No newline at end of file
+         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.
+    	</p></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_contentassist.html b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_contentassist.html
index d7c4563..215aec7 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_contentassist.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_contentassist.html
@@ -1,36 +1,83 @@
-<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;2.&nbsp;XSL Editing"><link rel="prev" href="xsleditor.html" title="Chapter&nbsp;2.&nbsp;XSL Editing"><link rel="next" href="xsleditor_templates.html" title="Templates"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><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></body></html>
\ No newline at end of file
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Content Assist</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="xsleditor.html" title="Chapter&nbsp;2.&nbsp;XSL Editing"><link rel="prev" href="xsleditor.html" title="Chapter&nbsp;2.&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="ContentAssist"></a>Content Assist</h2></div></div></div><p>
+         XSL Tools 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><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 class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="SelectTest"></a>Select and Test Attributes </h3></div></div></div><p>
+            Where ever an xsl element supports a
+            <span class="emphasis"><em>select</em></span>
+            or
+            <span class="emphasis"><em>test</em></span>
+            attribute, content assistance is
+            available. This includes support for
+            the following:
+         </p><div class="itemizedlist"><p class="title"><b>Select and Test Assistance</b></p><ul type="disc"><li><p>
+                  <span class="emphasis"><em>Variables</em></span>
+                  - both local and global variables are supported within the current
+                  stylesheet. Any local or global
+                  variable will be
+                  added to the list
+                  and the name is prefixed with a dollar sign $ symbol.
+               </p></li><li><p>
+                  <span class="emphasis"><em>XPath 1.0</em></span>
+                  - XPath 1.0 is supported through the use of templates. All of the
+                  XPath 1.0 and XSLT xpath
+                  extension
+                  functions are available, as well
+                  as
+                  <span class="emphasis"><em>axis</em></span>
+                  operations. Currently XPath 2.0 is not supported
+                  directly, but will
+                  be added in the future.
+               </p></li></ul></div><p>
+            Content assistance for the select and test attributes is
+            intelligent enough to know that it is within an
+            XPath expression, and will try to determine and provide content assistance based on the
+            current cursor
+            position. If a word has been partially typed it will
+            filter the available assistance.
+			</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="ExcludeResultPrefixesContentAssist"></a>Exclude-Result-Prefixes</h3></div></div></div><p>
+            The
+            <span class="emphasis"><em>exclude-result-prefixes</em></span>
+            attribute in both XSLT 1.0 and XSLT 2.0 allows for the exclusion of
+            certain namespace
+            declarations in the
+            output document. The content
+            assistance populates a list of available namespaces that have been
+            defined in
+            the
+            stylseheet and provides them as proposals as shown in
+            <a class="xref" href="xsleditor_contentassist.html#fig_ExcludeResultPrefixesContentAssist1" title="Figure&nbsp;2.1.&nbsp;Exclude-result-prefixes Content Assistance">Figure&nbsp;2.1, &ldquo;Exclude-result-prefixes Content
+               Assistance&rdquo;</a>
+            .
+         </p><div class="figure"><a name="fig_ExcludeResultPrefixesContentAssist1"></a><p class="title"><b>Figure&nbsp;2.1.&nbsp;Exclude-result-prefixes Content
+               Assistance</b></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/editor/ExcludeContentAssist1.png" align="middle" alt="Exclude-result-prefixes Content Assistance"></div></div></div><br class="figure-break"><p>
+            If the attribute has no values defined, then the
+            <span class="emphasis"><em>#all</em></span>
+            value will be available in the list. If #all
+            is already in the
+            attributes value, then no content assistance
+            will be available.
+         </p><div class="figure"><a name="fig_ExcludeResultPrefixesContentAssist2"></a><p class="title"><b>Figure&nbsp;2.2.&nbsp;Filtered exclude-result-prefixes proposals</b></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/editor/ExcludeContentAssist2.png" align="middle" alt="Filtered exclude-result-prefixes proposals"></div></div></div><br class="figure-break"><p>
+            Content assistance is intelligent enough to know when a
+            namespace prefix is already in the list of
+            excluded namespaces. In
+            this
+            case it will not show the namespace in the proposal list.
+			</p><div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Why isn't the XSL Namespace prefix in the proposals?
+				</h3><p>
+               Currently the xsl prefix or any prefix that uses the XSL
+               namespace is excluded from the list. This may
+               be changed at
+               a future
+               date. This will depend on user feedback.
+				</p></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_debugging.html b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_debugging.html
index 650f19b..c9c2448 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_debugging.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_debugging.html
@@ -1,3 +1,3 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>XSL Debugging</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;2.&nbsp;XSL Editing"><link rel="prev" href="xsleditor_templates.html" title="Templates"><link rel="next" href="../launching/launching.html" title="Chapter&nbsp;3.&nbsp;XSL Launching and Debugging"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
-			TODO: Add XSL Debugging documentation.
-		</p></body></html>
\ No newline at end of file
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>XSL Debugging</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="xsleditor.html" title="Chapter&nbsp;2.&nbsp;XSL Editing"><link rel="prev" href="xsleditor_templates.html" title="Templates"><link rel="next" href="../launching/launching.html" title="Chapter&nbsp;3.&nbsp;XSL Launching and Debugging"></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="XSLEditorDebugging"></a>XSL Debugging</h2></div></div></div><p>
+         TODO: Add XSL Debugging documentation.
+		</p></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
index e8f5532..a53bb63 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_templates.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/editor/xsleditor_templates.html
@@ -1,10 +1,25 @@
-<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;2.&nbsp;XSL Editing"><link rel="prev" href="xsleditor_contentassist.html" title="Content Assist"><link rel="next" href="xsleditor_debugging.html" title="XSL Debugging"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><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="N100AF"></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></body></html>
\ No newline at end of file
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Templates</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="xsleditor.html" title="Chapter&nbsp;2.&nbsp;XSL Editing"><link rel="prev" href="xsleditor_contentassist.html" title="Content Assist"><link rel="next" href="xsleditor_debugging.html" title="XSL Debugging"></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="XSLEditorTemplates"></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="N100B4"></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/general/general.html b/docs/org.eclipse.wst.xsl.doc/html/general/general.html
index 725ec20..0c6f17d 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/general/general.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/general/general.html
@@ -1,9 +1,9 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;1.&nbsp;General</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="../editor/xsleditor.html" title="Chapter&nbsp;2.&nbsp;XSL Editing"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>This section covers topics that don't have any other particular place to go.</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="XInclude"></a>XInclude</h2></div></div></div><p>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;1.&nbsp;General</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="../index.html" title="XSL Tools User Documentation"><link rel="prev" href="../index.html" title="XSL Tools User Documentation"><link rel="next" href="../editor/xsleditor.html" title="Chapter&nbsp;2.&nbsp;XSL Editing"></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="N10012"></a>Chapter&nbsp;1.&nbsp;General</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="general.html#XInclude">XInclude</a></span></dt></dl></div><p>This section covers topics that don't have any other particular place to go.</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="XInclude"></a>XInclude</h2></div></div></div><p>
       	XInclude allows a user to import or include other XML files into one xml file.
         It is used primarily with documentation file formats like Docbook and DITA.  It
         allows for separating out large xml documents into more manageable chunks of information.
       </p><p>
-      	The XSL Tooling project includes an ANT task that can be run with in eclipse, eclipse
+      	The XSL Tools project includes an ANT task that can be run with in eclipse, eclipse
       	headless, and without eclipse at all.   If running outside of eclipse, you will need
       	to make sure that the jar file xinclude.jar in the org.eclipse.wst.xsl.core.jar file
       	is made avaiable on your class path.
@@ -19,9 +19,9 @@
 					<span class="bold"><strong>out</strong></span> - The full path to the output file 
 					to be written with all includes expanded.  This is typically used as the
 					input to a stylesheet transformation process.
-				</p></li></ul></div><div class="example"><a name="N10040"></a><p class="title"><b>Example&nbsp;1.1.&nbsp;XInclude Example</b></p><div class="example-contents"><pre class="programlisting">
+				</p></li></ul></div><div class="example"><a name="N1003D"></a><p class="title"><b>Example&nbsp;1.1.&nbsp;XInclude Example</b></p><div class="example-contents"><pre class="programlisting">
 &lt;target name="merge"&gt;
     &lt;xsl.xinclude in="${docbooksource}/xslhelp.dbk"
                   out="${docbooksource}/xslhelpcombined.dbk"/&gt;
 &lt;/target&gt;	    		    	
-	    	</pre></div></div><br class="example-break"></div></body></html>
\ No newline at end of file
+	    	</pre></div></div><br class="example-break"></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/images/editor/ExcludeContentAssist1.png b/docs/org.eclipse.wst.xsl.doc/html/images/editor/ExcludeContentAssist1.png
new file mode 100644
index 0000000..2f0f2cb
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/html/images/editor/ExcludeContentAssist1.png
Binary files differ
diff --git a/docs/org.eclipse.wst.xsl.doc/html/images/editor/ExcludeContentAssist2.png b/docs/org.eclipse.wst.xsl.doc/html/images/editor/ExcludeContentAssist2.png
new file mode 100644
index 0000000..2e53677
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/html/images/editor/ExcludeContentAssist2.png
Binary files differ
diff --git a/docs/org.eclipse.wst.xsl.doc/html/index.html b/docs/org.eclipse.wst.xsl.doc/html/index.html
index 908afa9..a88166a 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/index.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/index.html
@@ -1 +1,2 @@
-<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="general/general.html" title="Chapter&nbsp;1.&nbsp;General"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"></body></html>
\ No newline at end of file
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>XSL Tools User Documentation</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="index.html" title="XSL Tools User Documentation"><link rel="next" href="general/general.html" title="Chapter&nbsp;1.&nbsp;General"></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="XSLUser"></a>XSL Tools 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="general/general.html">1. General</a></span></dt><dd><dl><dt><span class="section"><a href="general/general.html#XInclude">XInclude</a></span></dt></dl></dd><dt><span class="chapter"><a href="editor/xsleditor.html">2. XSL Editing</a></span></dt><dd><dl><dt><span class="section"><a href="editor/xsleditor.html#Validation">Validation</a></span></dt><dt><span class="section"><a href="editor/xsleditor_contentassist.html">Content Assist</a></span></dt><dd><dl><dt><span class="section"><a href="editor/xsleditor_contentassist.html#SelectTest">Select and Test Attributes </a></span></dt><dt><span class="section"><a href="editor/xsleditor_contentassist.html#ExcludeResultPrefixesContentAssist">Exclude-Result-Prefixes</a></span></dt></dl></dd><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#N100B4">XPath Templates</a></span></dt></dl></dd><dt><span class="section"><a href="editor/xsleditor_debugging.html">XSL Debugging</a></span></dt></dl></dd><dt><span class="chapter"><a href="launching/launching.html">3. XSL Launching and Debugging</a></span></dt><dd><dl><dt><span class="section"><a href="launching/launching.html#XSLLaunch">XSL Launching</a></span></dt><dt><span class="section"><a href="launching/debuglaunching.html">Launch Debugging</a></span></dt></dl></dd><dt><span class="chapter"><a href="preferences/xslpreferences.html">4. XSL Tools 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><dt><span class="section"><a href="preferences/xpathtemplates.html">XPath Templates</a></span></dt><dd><dl><dt><span class="section"><a href="preferences/xpathtemplates.html#XPathTemplateNew">Creating New Templates</a></span></dt><dt><span class="section"><a href="preferences/xpathtemplates.html#XPathImport">Import XPath Templates</a></span></dt><dt><span class="section"><a href="preferences/xpathtemplates.html#XPathExport">Import XPath Templates</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="samples/samples.html">5. XSL Tooling Samples</a></span></dt><dd><dl><dt><span class="section"><a href="samples/samples.html#EclipseHelp">Eclipse Help</a></span></dt><dd><dl><dt><span class="section"><a href="samples/samples.html#DocbookEclipseHelp">Creating Eclipse Help with Docbook and XSL Tools</a></span></dt><dt><span class="section"><a href="samples/samples.html#DITAEclipseHelp">Creating Eclipse Help with DITA and XSL Tools</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="legal.html">6. Notices</a></span></dt></dl></div><div class="list-of-figures"><p><b>List of Figures</b></p><dl><dt>2.1. <a href="xsleditor_contentassist.html#fig_ExcludeResultPrefixesContentAssist1">Exclude-result-prefixes Content
+               Assistance</a></dt><dt>2.2. <a href="xsleditor_contentassist.html#fig_ExcludeResultPrefixesContentAssist2">Filtered exclude-result-prefixes proposals</a></dt></dl></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/index.xml b/docs/org.eclipse.wst.xsl.doc/html/index.xml
new file mode 100644
index 0000000..f515bc8
--- /dev/null
+++ b/docs/org.eclipse.wst.xsl.doc/html/index.xml
@@ -0,0 +1 @@
+<index></index>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/launching/debuglaunching.html b/docs/org.eclipse.wst.xsl.doc/html/launching/debuglaunching.html
index 5a64229..3988d97 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/launching/debuglaunching.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/launching/debuglaunching.html
@@ -1,3 +1,3 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Launch Debugging</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="launching.html" title="Chapter&nbsp;3.&nbsp;XSL Launching and Debugging"><link rel="prev" href="launching.html" title="Chapter&nbsp;3.&nbsp;XSL Launching and Debugging"><link rel="next" href="../preferences/xslpreferences.html" title="Chapter&nbsp;4.&nbsp;XSL Tooling Preferences"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Launch Debugging</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="launching.html" title="Chapter&nbsp;3.&nbsp;XSL Launching and Debugging"><link rel="prev" href="launching.html" title="Chapter&nbsp;3.&nbsp;XSL Launching and Debugging"><link rel="next" href="../preferences/xslpreferences.html" title="Chapter&nbsp;4.&nbsp;XSL Tools 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="XSLDebug"></a>Launch Debugging</h2></div></div></div><p>
 	   		This is a place holder until some actual documentation can be written.
-	   </p></body></html>
\ No newline at end of file
+	   </p></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/launching/launching.html b/docs/org.eclipse.wst.xsl.doc/html/launching/launching.html
index 828269a..61227c4 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/launching/launching.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/launching/launching.html
@@ -1,8 +1,8 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;3.&nbsp;XSL Launching and Debugging</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_debugging.html" title="XSL Debugging"><link rel="next" href="debuglaunching.html" title="Launch Debugging"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
-		The XSL Tooling adds support for XSL Launch and Debugging configurations.
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;3.&nbsp;XSL Launching and Debugging</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="../index.html" title="XSL Tools User Documentation"><link rel="prev" href="../editor/xsleditor_debugging.html" title="XSL Debugging"><link rel="next" href="debuglaunching.html" title="Launch Debugging"></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="N100C1"></a>Chapter&nbsp;3.&nbsp;XSL Launching and Debugging</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="launching.html#XSLLaunch">XSL Launching</a></span></dt><dt><span class="section"><a href="debuglaunching.html">Launch Debugging</a></span></dt></dl></div><p>
+		XSL Tools adds support for XSL Launch and Debugging configurations.
 		These allow you to setup XSL configurations for various jobs, and to also
 		debug xsl stylsheet transformations.	
 	</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="XSLLaunch"></a>XSL Launching</h2></div></div></div><p>
 			In the Project Explorer, simply select the input XML file and the stylesheet(s) to transform it, and then right-click and select 
-			<span style="color: red">&lt;i&gt;Run As &gt; XSL Transformation&lt;/i&gt;</span>. 
-	    </p><div class="mediaobject" align="center"><img src="../images/launching/launchShortcut.png" align="middle"></div></div></body></html>
\ No newline at end of file
+			<span class="emphasis"><em>Run As &gt; XSL Transformation</em></span>. 
+	    </p><div class="mediaobject" align="center"><img src="../images/launching/launchShortcut.png" align="middle"></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/legal.html b/docs/org.eclipse.wst.xsl.doc/html/legal.html
index 45f7032..60068e5 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/legal.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/legal.html
@@ -1,4 +1,4 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;6.&nbsp;Notices</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="samples/samples.html" title="Chapter&nbsp;5.&nbsp;XSL Tooling Samples"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;6.&nbsp;Notices</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="index.html" title="XSL Tools User Documentation"><link rel="up" href="index.html" title="XSL Tools User Documentation"><link rel="prev" href="samples/samples.html" title="Chapter&nbsp;5.&nbsp;XSL Tooling Samples"></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="N10190"></a>Chapter&nbsp;6.&nbsp;Notices</h2></div></div></div><p>
       The material in this guide is Copyright (c) Doug Satchwell (<a class="ulink" href="http://www.chasetechnology.co.uk" target="_top">Chase Technology Ltd</a>), 
       David Carver ((<a class="ulink" href="http://www.starstandard.org" target="_top">Standards for Technology in Automotive Retail</a>)
       and others 2008.
@@ -8,4 +8,4 @@
 		<a class="ulink" href="http://www.eclipse.org/legal/epl-v10.html" target="_top">http://www.eclipse.org/legal/epl-v10.html</a>.
     </p><p>
 		<a class="ulink" href="about.html" target="_top">Terms and conditions regarding the use of this guide.</a>.
-	</p></body></html>
\ No newline at end of file
+	</p></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/html/preferences/xpathtemplates.html b/docs/org.eclipse.wst.xsl.doc/html/preferences/xpathtemplates.html
index bb3096d..03d326c 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/preferences/xpathtemplates.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/preferences/xpathtemplates.html
@@ -1,4 +1,4 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>XPath 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="xslpreferences.html" title="Chapter&nbsp;4.&nbsp;XSL Tooling Preferences"><link rel="prev" href="xsloutputproperties.html" title="Output Properties"><link rel="next" href="../samples/samples.html" title="Chapter&nbsp;5.&nbsp;XSL Tooling Samples"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>XPath Templates</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="xslpreferences.html" title="Chapter&nbsp;4.&nbsp;XSL Tools Preferences"><link rel="prev" href="xsloutputproperties.html" title="Output Properties"><link rel="next" href="../samples/samples.html" title="Chapter&nbsp;5.&nbsp;XSL Tooling Samples"></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="XPathTemplates"></a>XPath Templates</h2></div></div></div><p>
 		    XPath template proposal is supported by the XSL Tooling project through the
 		    built in template functionality of eclipse.   Users and Adopters can add
 		    their own specific xpath extensions for processor specific extensions.  An
@@ -16,7 +16,7 @@
 					are functions as defined by the XPath 1.0 specification.
 				</p></li><li><p>
 					<span class="bold"><strong>xpath 2.0</strong></span> - Represents an XPath 2.0 function.
-					<span class="emphasis"><em>Note: That currently XSL Tooling only ships with templates defined for XPath 1.0 .</em></span>
+					<span class="emphasis"><em>Note: That currently XSL Tools only ships with templates defined for XPath 1.0 .</em></span>
 				</p></li><li><p>
 					<span class="bold"><strong>operator</strong></span> - An xpath logical operator like AND, OR, etc.
 				</p></li></ul></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="XPathTemplateNew"></a>Creating New Templates</h3></div></div></div><p>
@@ -25,4 +25,4 @@
 		      Add documentation about importing new templates.
 		   </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="XPathExport"></a>Import XPath Templates</h3></div></div></div><p>
 		      Add documentation about importing new templates.
-		   </p></div></body></html>
\ No newline at end of file
+		   </p></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 5c4b619..82f8152 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/preferences/xsloutputproperties.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/preferences/xsloutputproperties.html
@@ -1,4 +1,4 @@
-<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;4.&nbsp;XSL Tooling Preferences"><link rel="prev" href="xslprocessors.html" title="Installed Processors"><link rel="next" href="xpathtemplates.html" title="XPath Templates"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Output Properties</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="xslpreferences.html" title="Chapter&nbsp;4.&nbsp;XSL Tools Preferences"><link rel="prev" href="xslprocessors.html" title="Installed Processors"><link rel="next" href="xpathtemplates.html" title="XPath 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="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
@@ -6,4 +6,4 @@
 		</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
+		</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 400bdc2..773f9bb 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,20 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;4.&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="../launching/debuglaunching.html" title="Launch Debugging"><link rel="next" href="xslprocessors.html" title="Installed Processors"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;4.&nbsp;XSL Tools Preferences</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="../index.html" title="XSL Tools User Documentation"><link rel="prev" href="../launching/debuglaunching.html" title="Launch Debugging"><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;4.&nbsp;XSL Tools 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><dt><span class="section"><a href="xpathtemplates.html">XPath Templates</a></span></dt><dd><dl><dt><span class="section"><a href="xpathtemplates.html#XPathTemplateNew">Creating New Templates</a></span></dt><dt><span class="section"><a href="xpathtemplates.html#XPathImport">Import XPath Templates</a></span></dt><dt><span class="section"><a href="xpathtemplates.html#XPathExport">Import XPath Templates</a></span></dt></dl></dd></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
+   			processor.   XSL Tools 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
+   			this is for the processor that is being installed.   XSL Tools 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
+   		</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 b92f1e5..7860e7c 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,5 @@
-<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;4.&nbsp;XSL Tooling Preferences"><link rel="prev" href="xslpreferences.html" title="Chapter&nbsp;4.&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>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Installed Processors</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="xslpreferences.html" title="Chapter&nbsp;4.&nbsp;XSL Tools Preferences"><link rel="prev" href="xslpreferences.html" title="Chapter&nbsp;4.&nbsp;XSL Tools 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></body></html>
\ No newline at end of file
+      	</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/html/samples/samples.html b/docs/org.eclipse.wst.xsl.doc/html/samples/samples.html
index e66ebb3..1ffd504 100644
--- a/docs/org.eclipse.wst.xsl.doc/html/samples/samples.html
+++ b/docs/org.eclipse.wst.xsl.doc/html/samples/samples.html
@@ -1,11 +1,11 @@
-<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;5.&nbsp;XSL Tooling Samples</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="../preferences/xpathtemplates.html" title="XPath Templates"><link rel="next" href="../legal.html" title="Chapter&nbsp;6.&nbsp;Notices"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><p>This section contains several samples and references to sample projects.</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="EclipseHelp"></a>Eclipse Help</h2></div></div></div><p></p><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="DocbookEclipseHelp"></a>Creating Eclipse Help with Docbook and XSL Tooling</h3></div></div></div><p>
+<html><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Chapter&nbsp;5.&nbsp;XSL Tooling Samples</title><meta content="DocBook XSL Stylesheets V1.74.0" name="generator"><link rel="home" href="../index.html" title="XSL Tools User Documentation"><link rel="up" href="../index.html" title="XSL Tools User Documentation"><link rel="prev" href="../preferences/xpathtemplates.html" title="XPath Templates"><link rel="next" href="../legal.html" title="Chapter&nbsp;6.&nbsp;Notices"></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="N10171"></a>Chapter&nbsp;5.&nbsp;XSL Tooling Samples</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="samples.html#EclipseHelp">Eclipse Help</a></span></dt><dd><dl><dt><span class="section"><a href="samples.html#DocbookEclipseHelp">Creating Eclipse Help with Docbook and XSL Tools</a></span></dt><dt><span class="section"><a href="samples.html#DITAEclipseHelp">Creating Eclipse Help with DITA and XSL Tools</a></span></dt></dl></dd></dl></div><p>This section contains several samples and references to sample projects.</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="EclipseHelp"></a>Eclipse Help</h2></div></div></div><p></p><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="DocbookEclipseHelp"></a>Creating Eclipse Help with Docbook and XSL Tools</h3></div></div></div><p>
 				This tutorial assumes that you have knowledge of Docbook, ANT, and the
 				ability to setup ANT build scripts.
 			</p><p>
 				To Do write up the rest of the tutorial.
-			</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="DITAEclipseHelp"></a>Creating Eclipse Help with DITA and XSL Tooling</h3></div></div></div><p>
+			</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="DITAEclipseHelp"></a>Creating Eclipse Help with DITA and XSL Tools</h3></div></div></div><p>
 				This tutorial assumes that you have knowledge of DITA, ANT, and the
 				ability to setup ANT build scripts.
 			</p><p>
 				To Do write up the rest of the tutorial.
-			</p></div></div></body></html>
\ No newline at end of file
+			</p></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.xsl.doc/toc.xml b/docs/org.eclipse.wst.xsl.doc/toc.xml
index dc99486..f813bdd 100644
--- a/docs/org.eclipse.wst.xsl.doc/toc.xml
+++ b/docs/org.eclipse.wst.xsl.doc/toc.xml
@@ -1 +1 @@
-<toc topic="html/index.html" label="XSL Tooling User Documentation"><topic href="html/general/general.html" label="General"><topic href="html/general/general.html#XInclude" label="XInclude"></topic></topic><topic href="html/editor/xsleditor.html" label="XSL Editing"><topic href="html/editor/xsleditor.html#Validation" label="Validation"></topic><topic href="html/editor/xsleditor_contentassist.html" label="Content Assist"></topic><topic href="html/editor/xsleditor_templates.html" label="Templates"><topic href="html/editor/xsleditor_templates.html#N100AF" label="XPath Templates"></topic></topic><topic href="html/editor/xsleditor_debugging.html" label="XSL Debugging"></topic></topic><topic href="html/launching/launching.html" label="XSL Launching and Debugging"><topic href="html/launching/launching.html#XSLLaunch" label="XSL Launching"></topic><topic href="html/launching/debuglaunching.html" label="Launch Debugging"></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 href="html/preferences/xpathtemplates.html" label="XPath Templates"><topic href="html/preferences/xpathtemplates.html#XPathTemplateNew" label="Creating New Templates"></topic><topic href="html/preferences/xpathtemplates.html#XPathImport" label="Import XPath Templates"></topic><topic href="html/preferences/xpathtemplates.html#XPathExport" label="Import XPath Templates"></topic></topic></topic><topic href="html/samples/samples.html" label="XSL Tooling Samples"><topic href="html/samples/samples.html#EclipseHelp" label="Eclipse Help"><topic href="html/samples/samples.html#DocbookEclipseHelp" label="Creating Eclipse Help with Docbook and XSL Tooling"></topic><topic href="html/samples/samples.html#DITAEclipseHelp" label="Creating Eclipse Help with DITA and XSL Tooling"></topic></topic></topic><topic href="html/legal.html" label="Notices"></topic></toc>
\ No newline at end of file
+<toc topic="html/index.html" label="XSL Tools User Documentation"><topic href="html/general/general.html" label="General"><topic href="html/general/general.html#XInclude" label="XInclude"></topic></topic><topic href="html/editor/xsleditor.html" label="XSL Editing"><topic href="html/editor/xsleditor.html#Validation" label="Validation"></topic><topic href="html/editor/xsleditor_contentassist.html" label="Content Assist"><topic href="html/editor/xsleditor_contentassist.html#SelectTest" label="Select and Test Attributes"></topic><topic href="html/editor/xsleditor_contentassist.html#ExcludeResultPrefixesContentAssist" label="Exclude-Result-Prefixes"></topic></topic><topic href="html/editor/xsleditor_templates.html" label="Templates"><topic href="html/editor/xsleditor_templates.html#N100B4" label="XPath Templates"></topic></topic><topic href="html/editor/xsleditor_debugging.html" label="XSL Debugging"></topic></topic><topic href="html/launching/launching.html" label="XSL Launching and Debugging"><topic href="html/launching/launching.html#XSLLaunch" label="XSL Launching"></topic><topic href="html/launching/debuglaunching.html" label="Launch Debugging"></topic></topic><topic href="html/preferences/xslpreferences.html" label="XSL Tools 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 href="html/preferences/xpathtemplates.html" label="XPath Templates"><topic href="html/preferences/xpathtemplates.html#XPathTemplateNew" label="Creating New Templates"></topic><topic href="html/preferences/xpathtemplates.html#XPathImport" label="Import XPath Templates"></topic><topic href="html/preferences/xpathtemplates.html#XPathExport" label="Import XPath Templates"></topic></topic></topic><topic href="html/samples/samples.html" label="XSL Tooling Samples"><topic href="html/samples/samples.html#EclipseHelp" label="Eclipse Help"><topic href="html/samples/samples.html#DocbookEclipseHelp" label="Creating Eclipse Help with Docbook and XSL Tools"></topic><topic href="html/samples/samples.html#DITAEclipseHelp" label="Creating Eclipse Help with DITA and XSL Tools"></topic></topic></topic><topic href="html/legal.html" label="Notices"></topic></toc>
\ No newline at end of file
