diff --git a/docs/org.eclipse.wst.server.ui.doc.user/DocBuild.xml b/docs/org.eclipse.wst.server.ui.doc.user/DocBuild.xml
new file mode 100644
index 0000000..ee647cd
--- /dev/null
+++ b/docs/org.eclipse.wst.server.ui.doc.user/DocBuild.xml
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- 
+
+	This script build the Help plug-in by transforming the DITA source files into HTML.
+	
+	To use this script, you must install DITA-OT on your machine in the directory
+	defined by the dita.ot.dir property.
+	
+	Run the default target after you edit the DITA source files to regenerate the HTML.
+	
+	To customize this script for other Help plug-ins, modify the value of the args.input property
+	to be the DITA map file for the plug-in.
+	
+	NOTE: This script assumes that links to sibling Help plug-ins have scope="peer", otherwise the
+	output directory structure will be shifted incorrectly.
+	
+	NOTE: This script assumes that you hand code your plugin.xml file in myplugin.xml. This file
+	will be copied over the generated plugin.xml which is currently not being generated correctly
+	by DITA-OT.
+	
+	ChangeLog:
+	2006-04-05 Arthur Ryman <ryman@ca.ibm.com>
+	- Created.
+	2008-05-05 Kate Price <katep@ca.ibm.com>
+	- modified to add generation of pre-built help index. 
+	- Must delete /index folder before running build
+-->
+<project name="eclipsehelp" default="all">
+
+	<property name="dita.ot.dir" location="C:/DITA-OT1.2.2" />
+
+	<path id="dost.class.path">
+		<pathelement location="${dita.ot.dir}${file.separator}lib${file.separator}dost.jar" />
+	</path>
+
+	<taskdef name="integrate" classname="org.dita.dost.platform.IntegratorTask">
+		<classpath refid="dost.class.path" />
+	</taskdef>
+	<target name="all" depends="integrate, eclipsehelp">
+	</target>
+	<target name="integrate">
+		<integrate ditadir="${dita.ot.dir}" />
+	</target>
+
+	<!-- revise below here -->
+	<target name="eclipsehelp">
+		<ant antfile="${dita.ot.dir}${file.separator}conductor.xml" target="init" dir="${dita.ot.dir}">
+			<property name="args.copycss" value="no" />
+			<property name="args.csspath" value="../org.eclipse.wst.doc.user" />
+			<property name="args.eclipse.provider" value="Eclipse.org" />
+			<property name="args.eclipse.version" value="3.4.0" />
+			<property name="args.input" location="wtp_reltable.ditamap" />    		
+			<property name="clean.temp" value="true" />
+			<property name="dita.extname" value=".dita" />
+			<property name="dita.temp.dir" location="temp" />
+			<property name="output.dir" location="" />
+			<property name="transtype" value="eclipsehelp" />
+		</ant>
+		<copy file="myplugin.xml" tofile="plugin.xml" overwrite="yes" />
+	</target>
+	<target name="build.index" description="Builds search index for the plug-in" if="eclipse.running">
+	     <help.buildHelpIndex manifest="plugin.xml" destination="."/>
+	</target>
+</project>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/META-INF/MANIFEST.MF b/docs/org.eclipse.wst.server.ui.doc.user/META-INF/MANIFEST.MF
index b3c61b5..91fa686 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/META-INF/MANIFEST.MF
+++ b/docs/org.eclipse.wst.server.ui.doc.user/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.wst.server.ui.doc.user; singleton:=true
-Bundle-Version: 1.1.300.qualifier
+Bundle-Version: 1.1.400.qualifier
 Bundle-Vendor: %pluginProvider
 Bundle-Localization: plugin
 Eclipse-LazyStart: true
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/index/_15.cfs b/docs/org.eclipse.wst.server.ui.doc.user/index/_15.cfs
index 0a5167d..3990af0 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/index/_15.cfs
+++ b/docs/org.eclipse.wst.server.ui.doc.user/index/_15.cfs
Binary files differ
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_contributions b/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_contributions
index d0569c3..b3c37c2 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_contributions
+++ b/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_contributions
@@ -1,3 +1,3 @@
 #This is a generated file; do not edit.
-#Wed May 19 16:20:46 EDT 2010
-org.eclipse.wst.server.ui.doc.user=org.eclipse.wst.server.ui.doc.user\n1.1.300.qualifier
+#Mon Apr 11 10:50:36 EDT 2011
+org.eclipse.wst.server.ui.doc.user=org.eclipse.wst.server.ui.doc.user\n1.1.400.qualifier
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_dependencies b/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_dependencies
index f7014e2..0405183 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_dependencies
+++ b/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_dependencies
@@ -1,4 +1,4 @@
 #This is a generated file; do not edit.
-#Wed May 19 16:20:46 EDT 2010
+#Mon Apr 11 10:50:36 EDT 2011
 lucene=1.9.1.v20080530-1600
 analyzer=org.eclipse.help.base\#3.3.101.M20080728_34x?locale\=en
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_docs b/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_docs
index 36a6885..78b00f7 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_docs
+++ b/docs/org.eclipse.wst.server.ui.doc.user/index/indexed_docs
@@ -1,5 +1,5 @@
 #This is a generated file; do not edit.
-#Wed May 19 16:20:46 EDT 2010
+#Mon Apr 11 10:50:36 EDT 2011
 /org.eclipse.wst.server.ui.doc.user/topics/tservlet.html=0
 /org.eclipse.wst.server.ui.doc.user/topics/twaddprj.html=0
 /org.eclipse.wst.server.ui.doc.user/topics/tdecor.html=0
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/index/segments b/docs/org.eclipse.wst.server.ui.doc.user/index/segments
index de0c19e..20405aa 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/index/segments
+++ b/docs/org.eclipse.wst.server.ui.doc.user/index/segments
Binary files differ
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/myplugin.xml b/docs/org.eclipse.wst.server.ui.doc.user/myplugin.xml
index 0fed91f..3d30b56 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/myplugin.xml
+++ b/docs/org.eclipse.wst.server.ui.doc.user/myplugin.xml
@@ -2,7 +2,7 @@
 <?eclipse version="3.6"?>
 <?NLS TYPE="org.eclipse.help.toc"?>
 <!-- /*******************************************************************************
- * Copyright (c) 2000, 2010 IBM Corporation and others.
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/plugin.xml b/docs/org.eclipse.wst.server.ui.doc.user/plugin.xml
index 0fed91f..3d30b56 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/plugin.xml
+++ b/docs/org.eclipse.wst.server.ui.doc.user/plugin.xml
@@ -2,7 +2,7 @@
 <?eclipse version="3.6"?>
 <?NLS TYPE="org.eclipse.help.toc"?>
 <!-- /*******************************************************************************
- * Copyright (c) 2000, 2010 IBM Corporation and others.
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.html
index 0f5de91..662db60 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.dita
index 57ddcf5..6d0b8bf 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.dita
@@ -1,39 +1,48 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2006, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
 <!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN"
  "concept.dtd">
 <concept id="cwover_wst" xml:lang="en-us">
 <title id="cwover_title">Testing and publishing on your server</title>
-<shortdesc id="cwover_shortdesc"><ph id="cwover_shortdesc_ph1">The testing
-and publishing tools provides runtime environments where you can test JSP
-files, servlets, HTML files,</ph> <ph id="cwover_shortdesc_ph2">and <tm tmclass="special"
-tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> classes.</ph></shortdesc>
+<shortdesc id="cwover_shortdesc"><ph id="cwover_shortdesc_ph1">The
+testing and publishing tools provides runtime environments where you
+can test JSP files, servlets, HTML files,</ph> <ph
+id="cwover_shortdesc_ph2"><tm tmclass="special"
+tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> classes
+and many more artifacts.</ph></shortdesc>
 <prolog><metadata>
-<keywords id="index"><indexterm keyref="cwover|1|applicationclientprojectstestingonservers"
+<keywords id="index"><indexterm
+keyref="cwover|1|applicationclientprojectstestingonservers"
 status="changed">application client projects<indexterm>testing</indexterm></indexterm>
 <indexterm keyref="cwover|2|serverstestingprojectresources" status="new">servers<indexterm>testing
 project resources</indexterm></indexterm></keywords>
 </metadata></prolog>
 <conbody>
 <p id="cwover_p1">You can use the workbench to test and publish resources
-from the following types of projects:</p>
+from many types of projects, here are examples:</p><?Pub Caret -1?>
 <ul id="cwover_ul1">
-<li>Dynamic Web projects, which typically contain JSP files, HTML files, servlets,
-and <tm tmclass="special" tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="JavaBeans">JavaBeans</tm></li>
-<li>Static Web projects, which typically contain HTML files and graphic files</li>
-<li>Enterprise Applications projects, which may contain <tm tmclass="special"
-tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="Java">Java</tm> Archive
-(JAR) files or Web Archive (WAR) files or both, and pointers to other Web
-or EJB projects</li>
+<li>Dynamic Web projects, which typically contain JSP files, HTML
+files, servlets, and <tm tmclass="special"
+tmowner="Sun Microsystems, Inc." tmtype="tm" trademark="JavaBeans">JavaBeans</tm></li>
+<li>Static Web projects, which typically contain HTML files and graphic
+files</li>
+<li>Enterprise Applications projects, which may contain <tm
+tmclass="special" tmowner="Sun Microsystems, Inc." tmtype="tm"
+trademark="Java">Java</tm> Archive (JAR) files or Web Archive (WAR)
+files or both, and pointers to other Web or EJB projects</li>
 <li>EJB projects, which contain enterprise beans</li>
 <li>Application client projects</li>
 </ul>
-<p id="cwover_p2">After testing your application locally, you can use the
+<p id="cwover_p2">After testing your application, you can use the
 tools to publish the application.</p>
 <section id="cwover_server_definitions"><title>Server definitions</title><p>The
-server tools use  <varname>servers</varname> to test and publish your projects.
-Servers are definitions that identify where you want to test your projects.
-You can either have the development environment create the servers automatically
-for you, or you can create them using a wizard.</p></section>
+workbench defines <varname>servers</varname> to test and publish your
+projects. Servers are definitions that identify where you want to
+test your projects. You can either have the development environment
+create the servers automatically for you, or you can create them using
+the <uicontrol>New Server</uicontrol> wizard (right-click in the Servers
+view and select <menucascade><uicontrol>New</uicontrol><uicontrol>Server</uicontrol>
+</menucascade>).</p></section>
 </conbody>
 </concept>
+<?Pub *0000002489?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.html
index d5f5654..63bbb30 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwover.html
@@ -2,15 +2,15 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
 <meta content="concept" name="DC.Type" />
 <meta name="DC.Title" content="Testing and publishing on your server" />
-<meta name="abstract" content="The testing and publishing tools provides runtime environments where you can test JSP files, servlets, HTML files, and Java classes." />
-<meta name="description" content="The testing and publishing tools provides runtime environments where you can test JSP files, servlets, HTML files, and Java classes." />
+<meta name="abstract" content="The testing and publishing tools provides runtime environments where you can test JSP files, servlets, HTML files, Java classes and many more artifacts." />
+<meta name="description" content="The testing and publishing tools provides runtime environments where you can test JSP files, servlets, HTML files, Java classes and many more artifacts." />
 <meta content="application client projects, testing, servers, testing project resources" name="DC.subject" />
 <meta content="application client projects, testing, servers, testing project resources" name="keywords" />
 <meta content="XHTML" name="DC.Format" />
@@ -26,22 +26,23 @@
 
 
 
-<div><p><span id="cwover_shortdesc_ph1"><a name="cwover_shortdesc_ph1"><!-- --></a>The testing
-and publishing tools provides runtime environments where you can test JSP
-files, servlets, HTML files,</span> <span id="cwover_shortdesc_ph2"><a name="cwover_shortdesc_ph2"><!-- --></a>and Java™ classes.</span></p>
+<div><p><span id="cwover_shortdesc_ph1"><a name="cwover_shortdesc_ph1"><!-- --></a>The
+testing and publishing tools provides runtime environments where you
+can test JSP files, servlets, HTML files,</span> <span id="cwover_shortdesc_ph2"><a name="cwover_shortdesc_ph2"><!-- --></a>Java™ classes
+and many more artifacts.</span></p>
 
 <p id="cwover_wst__cwover_p1"><a name="cwover_wst__cwover_p1"><!-- --></a>You can use the workbench to test and publish resources
-from the following types of projects:</p>
+from many types of projects, here are examples:</p>
 
 <a name="cwover_wst__cwover_ul1"><!-- --></a><ul id="cwover_wst__cwover_ul1">
-<li>Dynamic Web projects, which typically contain JSP files, HTML files, servlets,
-and JavaBeans™</li>
+<li>Dynamic Web projects, which typically contain JSP files, HTML
+files, servlets, and JavaBeans™</li>
 
-<li>Static Web projects, which typically contain HTML files and graphic files</li>
+<li>Static Web projects, which typically contain HTML files and graphic
+files</li>
 
-<li>Enterprise Applications projects, which may contain Java Archive
-(JAR) files or Web Archive (WAR) files or both, and pointers to other Web
-or EJB projects</li>
+<li>Enterprise Applications projects, which may contain Java Archive (JAR) files or Web Archive (WAR)
+files or both, and pointers to other Web or EJB projects</li>
 
 <li>EJB projects, which contain enterprise beans</li>
 
@@ -49,14 +50,17 @@
 
 </ul>
 
-<p id="cwover_wst__cwover_p2"><a name="cwover_wst__cwover_p2"><!-- --></a>After testing your application locally, you can use the
+<p id="cwover_wst__cwover_p2"><a name="cwover_wst__cwover_p2"><!-- --></a>After testing your application, you can use the
 tools to publish the application.</p>
 
 <div class="section" id="cwover_wst__cwover_server_definitions"><a name="cwover_wst__cwover_server_definitions"><!-- --></a><h4 class="sectiontitle">Server definitions</h4><p>The
-server tools use  <var class="varname">servers</var> to test and publish your projects.
-Servers are definitions that identify where you want to test your projects.
-You can either have the development environment create the servers automatically
-for you, or you can create them using a wizard.</p>
+workbench defines <var class="varname">servers</var> to test and publish your
+projects. Servers are definitions that identify where you want to
+test your projects. You can either have the development environment
+create the servers automatically for you, or you can create them using
+the <span class="uicontrol">New Server</span> wizard (right-click in the Servers
+view and select <span class="menucascade"><span class="uicontrol">New</span> &gt; <span class="uicontrol">Server</span>
+</span>).</p>
 </div>
 
 </div>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwres.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwres.html
index 676a87e..c8d8324 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwres.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwres.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/raccessserver.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/raccessserver.html
index daa05fd..f71e7e6 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/raccessserver.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/raccessserver.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.html
index 3c4b8a8..479dc49 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/rwtcpvw.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/rwtcpvw.html
index fce509a..5cc0bbf 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/rwtcpvw.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/rwtcpvw.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -63,7 +63,7 @@
 </div>
 
 <div><div class="reltasks"><strong>Related tasks</strong><br />
-<div><a href="../topics/twtcpprf.html" title="Using the Preferences page, you can define the TCP/IP Monitor attributes. To define these preferences, complete the following:">Defining the TCP/IP Monitor preferences</a></div>
+<div><a href="../topics/twtcpprf.html" title="Using the Preferences page, you can define the TCP/IP Monitor attributes.">Defining the TCP/IP Monitor preferences</a></div>
 </div>
 </div>
 
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tclean.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tclean.html
index 4df77e2..96b248d 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tclean.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tclean.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tcreate.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tcreate.html
index fbab15f..cf4a470 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tcreate.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tcreate.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tdbgjsp.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdbgjsp.html
index a7b201f..d2cec0b 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tdbgjsp.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdbgjsp.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tdebug.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdebug.html
index 9c1d0ff..bbe611d 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tdebug.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdebug.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.html
index d9b66cc..6d6c229 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.dita
index 20e0936..2ea6d3d 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.dita
@@ -1,67 +1,67 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2006, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
 <!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
  "task.dtd">
 <task id="testing_wst" xml:lang="en-us">
 <title id="testing_title">Testing artifacts on a server</title>
-<shortdesc id="testing_shortdesc">You can use the workbench to test one or
-more application artifacts on a server.</shortdesc>
+<shortdesc id="testing_shortdesc">You can use the workbench to test
+one or more application artifacts on a server.</shortdesc>
 <prolog><metadata>
 <keywords id="index"><indexterm>artifacts<indexterm>testing on servers</indexterm></indexterm>
-<indexterm>servers<indexterm>testing artifacts</indexterm></indexterm></keywords>
+<indexterm>servers<indexterm>testing artifacts</indexterm></indexterm>
+</keywords>
 </metadata></prolog>
 <taskbody>
-<prereq></prereq>
-<context></context>
+<context id="context">To test artifacts on a server:</context>
 <steps>
-<step id="testing_step1"><cmd>In the Project Explorer view from the Java EE
-perspective, expand the project that contains the file you want to test.</cmd>
-</step>
-<step id="testing_step2"><cmd>Right-click the artifact that you want to test.</cmd>
-<info>Examples of artifacts include the Web project or a file within the Web
-project (such as a JSP file, servlet, or HTML file), or an enterprise bean.</info>
-</step>
+<step id="testing_step1"><cmd>In the Project Explorer view from the
+Java EE perspective, expand the project that contains the file you
+want to test.</cmd></step>
+<step id="testing_step2"><cmd>Right-click the artifact that you want
+to test.</cmd><info>Examples of artifacts include the Web project
+or a file within the Web project (such as a JSP file, servlet, or
+HTML file), or an enterprise bean.</info></step>
 <step id="testing_step3"><cmd>Select  <uicontrol>Run As > Run on Server</uicontrol>.
 The Server selection wizard appears.</cmd></step>
-<step id="testing_step4"><cmd>Use the radio buttons to specify how you want
-to select the server. Select from the following options:</cmd>
+<step id="testing_step4"><cmd>Use the radio buttons to specify how
+you want to select the server. Select from the following options:</cmd>
 <choicetable>
-<chrow><choption>Choose an existing server</choption><chdesc>This option uses
-an existing server that is defined in your workbench. </chdesc></chrow>
-<chrow><choption>Manually define a server</choption><chdesc>This option creates
-a new server.</chdesc></chrow>
+<chrow><choption>Choose an existing server</choption><chdesc>This
+option uses an existing server that is defined in your workbench. </chdesc>
+</chrow>
+<chrow><choption>Manually define a server</choption><chdesc>This option
+creates a new server.</chdesc></chrow>
 </choicetable>
 </step>
-<step id="testing_step5"><cmd>Under the <uicontrol>Select the server that
-you want to use</uicontrol> list, select a server you want to run your application.</cmd>
-<info>The list of available servers, under the <uicontrol>Select the server
-that you want to use</uicontrol> list, depends on the Java EE specification
-level you defined for the artifact and the supported servers on this workbench.</info>
-</step>
+<step id="testing_step5"><cmd>Under the <uicontrol>Select the server
+that you want to use</uicontrol> list, select a server you want to
+run your application.</cmd><info>The list of available servers, under
+the <uicontrol>Select the server that you want to use</uicontrol> list,
+depends on the Java EE specification level you defined for the artifact
+and the supported servers on this workbench.</info></step>
 <step id="testing_step6"><cmd>(Optional) Click <uicontrol>Next</uicontrol> to
-configure additional settings, such as configuring settings specific to the
-server, and adding or removing projects configured on the server.</cmd></step>
+configure additional settings, such as configuring settings specific
+to the server, and adding or removing projects configured on the server.</cmd>
+</step>
 <step><cmd><ph id="testing_step7_ph1">Click <uicontrol>Finish.</uicontrol></ph></cmd>
-<info><ph id="testing_step7_ph2">The server tools automatically complete the
-following tasks for you: </ph><ul>
-<li id="testing_li1">If this is the first time you are creating the server
-on the workspace and if the server generates server configuration files, the
-workbench creates a server project with <uicontrol>Servers</uicontrol> as
-the default name to hold the generated server configuration files.</li>
-<li id="testing_li2">Creates the server and adds it to the Servers View.</li>
+<info><ph id="testing_step7_ph2">The server tools automatically complete
+the following tasks for you: </ph><ul>
+<li id="testing_li2">Creates the server and adds it to the Servers
+View.</li><?Pub Caret -2?>
 <li id="testing_li3">Adds your project to the server.</li>
-<li id="testing_li4">Starts the server. (This may take time depending on the
-server settings.)</li>
-<li id="testing_li5">If the  <uicontrol>Automatically publish when starting
-servers</uicontrol> check box on the Server preferences page (<menucascade>
-<uicontrol>Window > Preferences > Server > Launching</uicontrol></menucascade>)
-is selected, the workbench checks to see if your project and files on the
-server are synchronized. If they are not, the project and the files are automatically
-updated when the server is restarted.</li>
-<li id="testing_li6">Depending on the artifact you are testing, the output
-of running your artifact may display in the Console view or in a Web browser
-that automatically opens.</li>
+<li id="testing_li4">Starts the server. (This may take time depending
+on the server settings.)</li>
+<li id="testing_li5">If the  <uicontrol>Automatically publish when
+starting servers</uicontrol> check box on the Server preferences page
+(<menucascade><uicontrol>Window > Preferences > Server > Launching</uicontrol>
+</menucascade>) is selected, the workbench checks to see if your project
+and files on the server are synchronized. If they are not, the project
+and the files are automatically updated when the server is restarted.</li>
+<li id="testing_li6">Depending on the artifact you are testing, the
+output of running your artifact may display in the Console view or
+in a Web browser that automatically opens.</li>
 </ul></info></step>
 </steps>
 </taskbody>
 </task>
+<?Pub *0000003444?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.html
index fc74b65..230243a 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/testing.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -27,83 +27,79 @@
 
 
 
-<div><p>You can use the workbench to test one or
-more application artifacts on a server.</p>
+<div><p>You can use the workbench to test
+one or more application artifacts on a server.</p>
 
-<div class="p" />
-
-<div class="section" />
+<div class="section" id="testing_wst__context"><a name="testing_wst__context"><!-- --></a>To test artifacts on a server:</div>
 
 <ol>
-<li class="stepexpand" id="testing_wst__testing_step1"><a name="testing_wst__testing_step1"><!-- --></a><span>In the Project Explorer view from the Java EE
-perspective, expand the project that contains the file you want to test.</span>
-</li>
+<li class="stepexpand" id="testing_wst__testing_step1"><a name="testing_wst__testing_step1"><!-- --></a><span>In the Project Explorer view from the
+Java EE perspective, expand the project that contains the file you
+want to test.</span></li>
 
-<li class="stepexpand" id="testing_wst__testing_step2"><a name="testing_wst__testing_step2"><!-- --></a><span>Right-click the artifact that you want to test.</span>
- Examples of artifacts include the Web project or a file within the Web
-project (such as a JSP file, servlet, or HTML file), or an enterprise bean.
-</li>
+<li class="stepexpand" id="testing_wst__testing_step2"><a name="testing_wst__testing_step2"><!-- --></a><span>Right-click the artifact that you want
+to test.</span> Examples of artifacts include the Web project
+or a file within the Web project (such as a JSP file, servlet, or
+HTML file), or an enterprise bean.</li>
 
 <li class="stepexpand" id="testing_wst__testing_step3"><a name="testing_wst__testing_step3"><!-- --></a><span>Select  <span class="uicontrol">Run As &gt; Run on Server</span>.
 The Server selection wizard appears.</span></li>
 
-<li class="stepexpand" id="testing_wst__testing_step4"><a name="testing_wst__testing_step4"><!-- --></a><span>Use the radio buttons to specify how you want
-to select the server. Select from the following options:</span>
+<li class="stepexpand" id="testing_wst__testing_step4"><a name="testing_wst__testing_step4"><!-- --></a><span>Use the radio buttons to specify how
+you want to select the server. Select from the following options:</span>
 
 <table class="choicetableborder" summary="" cellspacing="0" cellpadding="4" rules="rows" frame="hsides" border="1">
-<thead><tr><th valign="bottom" id="N1008F-option" align="left">Option</th>
-<th valign="bottom" id="N1008F-desc" align="left">Description</th></tr></thead>
+<thead><tr><th valign="bottom" id="N1008A-option" align="left">Option</th>
+<th valign="bottom" id="N1008A-desc" align="left">Description</th></tr></thead>
 <tbody>
-<tr><td valign="top" headers="N1008F-option" id="N10099"><strong>Choose an existing server</strong></td>
-<td valign="top" headers="N1008F-desc N10099">This option uses
-an existing server that is defined in your workbench. </td>
+<tr><td valign="top" headers="N1008A-option" id="N10094"><strong>Choose an existing server</strong></td>
+<td valign="top" headers="N1008A-desc N10094">This
+option uses an existing server that is defined in your workbench. </td>
+
 </tr>
 
-<tr><td valign="top" headers="N1008F-option" id="N100A8"><strong>Manually define a server</strong></td>
-<td valign="top" headers="N1008F-desc N100A8">This option creates
-a new server.</td>
+<tr><td valign="top" headers="N1008A-option" id="N100A4"><strong>Manually define a server</strong></td>
+<td valign="top" headers="N1008A-desc N100A4">This option
+creates a new server.</td>
 </tr>
 
 </tbody></table>
 
 </li>
 
-<li class="stepexpand" id="testing_wst__testing_step5"><a name="testing_wst__testing_step5"><!-- --></a><span>Under the <span class="uicontrol">Select the server that
-you want to use</span> list, select a server you want to run your application.</span>
- The list of available servers, under the <span class="uicontrol">Select the server
-that you want to use</span> list, depends on the Java EE specification
-level you defined for the artifact and the supported servers on this workbench.
-</li>
+<li class="stepexpand" id="testing_wst__testing_step5"><a name="testing_wst__testing_step5"><!-- --></a><span>Under the <span class="uicontrol">Select the server
+that you want to use</span> list, select a server you want to
+run your application.</span> The list of available servers, under
+the <span class="uicontrol">Select the server that you want to use</span> list,
+depends on the Java EE specification level you defined for the artifact
+and the supported servers on this workbench.</li>
 
 <li class="stepexpand" id="testing_wst__testing_step6"><a name="testing_wst__testing_step6"><!-- --></a><span>(Optional) Click <span class="uicontrol">Next</span> to
-configure additional settings, such as configuring settings specific to the
-server, and adding or removing projects configured on the server.</span></li>
+configure additional settings, such as configuring settings specific
+to the server, and adding or removing projects configured on the server.</span>
+</li>
 
 <li class="stepexpand"><span><span id="testing_wst__testing_step7_ph1"><a name="testing_wst__testing_step7_ph1"><!-- --></a>Click <span class="uicontrol">Finish.</span></span></span>
- <span id="testing_wst__testing_step7_ph2"><a name="testing_wst__testing_step7_ph2"><!-- --></a>The server tools automatically complete the
-following tasks for you: </span><ul>
-<li id="testing_wst__testing_li1"><a name="testing_wst__testing_li1"><!-- --></a>If this is the first time you are creating the server
-on the workspace and if the server generates server configuration files, the
-workbench creates a server project with <span class="uicontrol">Servers</span> as
-the default name to hold the generated server configuration files.</li>
-
-<li id="testing_wst__testing_li2"><a name="testing_wst__testing_li2"><!-- --></a>Creates the server and adds it to the Servers View.</li>
+ <span id="testing_wst__testing_step7_ph2"><a name="testing_wst__testing_step7_ph2"><!-- --></a>The server tools automatically complete
+the following tasks for you: </span><ul>
+<li id="testing_wst__testing_li2"><a name="testing_wst__testing_li2"><!-- --></a>Creates the server and adds it to the Servers
+View.</li>
 
 <li id="testing_wst__testing_li3"><a name="testing_wst__testing_li3"><!-- --></a>Adds your project to the server.</li>
 
-<li id="testing_wst__testing_li4"><a name="testing_wst__testing_li4"><!-- --></a>Starts the server. (This may take time depending on the
-server settings.)</li>
+<li id="testing_wst__testing_li4"><a name="testing_wst__testing_li4"><!-- --></a>Starts the server. (This may take time depending
+on the server settings.)</li>
 
-<li id="testing_wst__testing_li5"><a name="testing_wst__testing_li5"><!-- --></a>If the  <span class="uicontrol">Automatically publish when starting
-servers</span> check box on the Server preferences page (<span class="menucascade">
-<span class="uicontrol">Window &gt; Preferences &gt; Server &gt; Launching</span></span>)
-is selected, the workbench checks to see if your project and files on the
-server are synchronized. If they are not, the project and the files are automatically
-updated when the server is restarted.</li>
+<li id="testing_wst__testing_li5"><a name="testing_wst__testing_li5"><!-- --></a>If the  <span class="uicontrol">Automatically publish when
+starting servers</span> check box on the Server preferences page
+(<span class="menucascade"><span class="uicontrol">Window &gt; Preferences &gt; Server &gt; Launching</span>
+</span>) is selected, the workbench checks to see if your project
+and files on the server are synchronized. If they are not, the project
+and the files are automatically updated when the server is restarted.</li>
 
-<li id="testing_wst__testing_li6"><a name="testing_wst__testing_li6"><!-- --></a>Depending on the artifact you are testing, the output
-of running your artifact may display in the Console view or in a Web browser
-that automatically opens.</li>
+<li id="testing_wst__testing_li6"><a name="testing_wst__testing_li6"><!-- --></a>Depending on the artifact you are testing, the
+output of running your artifact may display in the Console view or
+in a Web browser that automatically opens.</li>
 
 </ul>
 </li>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/thttppreview.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/thttppreview.html
index bbdd709..258ef71 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/thttppreview.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/thttppreview.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -14,6 +14,7 @@
 <meta content="HTTP preview server, testing static Web projects, runtime environments, HTTP Preview, servers, HTTP Preview server" name="DC.subject" />
 <meta content="HTTP preview server, testing static Web projects, runtime environments, HTTP Preview, servers, HTTP Preview server" name="keywords" />
 <meta scheme="URI" name="DC.Relation" content="../topics/tj2ee.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/twcrtins.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="thttppreview_wst" name="DC.Identifier" />
 <meta content="en-us" name="DC.Language" />
@@ -81,6 +82,10 @@
 <div class="familylinks">
 <div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/tj2ee.html" title="You can use the workbench to test one or more projects on a server.">Testing applications on a server</a></div>
 </div>
+
+<div class="familylinks">
+<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/twcrtins.html" title="You can create a server to identify the runtime environment that you want to use for testing your project resources. The term creating a server defines creating a pointer from the workbench to an existing installation of an application server.">Creating a server</a></div>
+</div>
 </div>
 
 </body>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2ee.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2ee.html
index d9e7727..b7ceba9 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2ee.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2ee.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2eepreview.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2eepreview.html
index 79aa069..91cd9f8 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2eepreview.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tj2eepreview.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -14,6 +14,7 @@
 <meta content="J2EE, testing on preview servers, runtime environments, J2EE Preview, servers, J2EE Preview server" name="DC.subject" />
 <meta content="J2EE, testing on preview servers, runtime environments, J2EE Preview, servers, J2EE Preview server" name="keywords" />
 <meta scheme="URI" name="DC.Relation" content="../topics/tj2ee.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/twcrtins.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="tj2eepreview_wst" name="DC.Identifier" />
 <meta content="en-us" name="DC.Language" />
@@ -85,6 +86,10 @@
 <div class="familylinks">
 <div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/tj2ee.html" title="You can use the workbench to test one or more projects on a server.">Testing applications on a server</a></div>
 </div>
+
+<div class="familylinks">
+<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/twcrtins.html" title="You can create a server to identify the runtime environment that you want to use for testing your project resources. The term creating a server defines creating a pointer from the workbench to an existing installation of an application server.">Creating a server</a></div>
+</div>
 </div>
 
 </body>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tmetasrv.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tmetasrv.html
index 3097587..c6e8a2c 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tmetasrv.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tmetasrv.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tmonitorport.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tmonitorport.html
index 70c7239..2a7e6bc 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tmonitorport.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tmonitorport.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tpref.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tpref.html
index 385d947..9f19cd6 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tpref.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tpref.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -47,7 +47,7 @@
 <li class="ulchildlink"><strong><a href="../topics/twinstprf.html">Defining the server runtime environments preferences</a></strong><br />
 Using the Preferences page, you can direct the workbench to use a specific runtime environment of an application server for compiling, testing, or running your application.</li>
 <li class="ulchildlink"><strong><a href="../topics/twtcpprf.html">Defining the TCP/IP Monitor preferences</a></strong><br />
-Using the Preferences page, you can define the TCP/IP Monitor attributes. To define these preferences, complete the following:</li>
+Using the Preferences page, you can define the TCP/IP Monitor attributes.</li>
 <li class="ulchildlink"><strong><a href="../topics/tdecor.html">Showing the state and status in the Servers view</a></strong><br />
 When the Server State Decorator is enabled, the workbench shows in the Servers view label decorations that indicate the state and status of the server and its projects. If the Servers view does not display a current state or status for the project, the workbench cannot retrieve this detail from the server, the server is stopped, or the server does not support this function.</li>
 </ul>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tprefaud.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tprefaud.html
index 98e4102..71690e4 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tprefaud.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tprefaud.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tpublish.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tpublish.html
index 8722708..0883d2a 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tpublish.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tpublish.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.dita
index 247bbae..e246a13 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.dita
@@ -39,8 +39,11 @@
 view opens.</cmd><info>Step through the code, inspect and display
 variables, and make any necessary changes to the servlet. For detailed
 information on debugging, refer to the online help.</info></step>
-<step id="tservlet_step6"><cmd>When you are finished debugging, remove
-the breakpoint and save the servlet.</cmd></step>
+<step id="tservlet_step6"><cmd>When you are finished debugging, save
+the servlet.</cmd><info> Wait for the debugger to refresh and pick
+up the changes. When the debugger refresh is complete, the execution
+of the code resumes at the beginning of the method that was currently
+running.</info></step><?Pub Caret 33?>
 <step id="tservlet_step7"><cmd>Click the  <uicontrol>Resume</uicontrol> icon
 on the Debug toolbar to execute the servlet.</cmd></step>
 <step id="tservlet_step8"><cmd>If you have hot method replace enabled,
@@ -55,7 +58,7 @@
 </step>
 </steps>
 <result id="tservlet_result"><p>The result is the server recognizes
-your changes.</p><?Pub Caret -2?></result>
+your changes.</p></result>
 </taskbody>
 </task>
-<?Pub *0000003369?>
+<?Pub *0000003546?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.html
index 1a4130f..c1b15b5 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tservlet.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -58,8 +58,11 @@
 variables, and make any necessary changes to the servlet. For detailed
 information on debugging, refer to the online help.</li>
 
-<li class="stepexpand" id="tservlet_wst__tservlet_step6"><a name="tservlet_wst__tservlet_step6"><!-- --></a><span>When you are finished debugging, remove
-the breakpoint and save the servlet.</span></li>
+<li class="stepexpand" id="tservlet_wst__tservlet_step6"><a name="tservlet_wst__tservlet_step6"><!-- --></a><span>When you are finished debugging, save
+the servlet.</span>  Wait for the debugger to refresh and pick
+up the changes. When the debugger refresh is complete, the execution
+of the code resumes at the beginning of the method that was currently
+running.</li>
 
 <li class="stepexpand" id="tservlet_wst__tservlet_step7"><a name="tservlet_wst__tservlet_step7"><!-- --></a><span>Click the  <span class="uicontrol">Resume</span> icon
 on the Debug toolbar to execute the servlet.</span></li>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.html
index 6d02a0b..e6e6d41 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twaddprj.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twaddprj.html
index 21875bb..8631688 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twaddprj.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twaddprj.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.dita
index 065f954..fe647e0 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.dita
@@ -38,8 +38,6 @@
 select the type of server or test environment where you want to publish
 or test your resources.</cmd>
 <substeps>
-<substep><cmd>(Optional) Refer to the <uicontrol>Description</uicontrol> section
-for brief details about the server you have selected.</cmd></substep>
 <substep><cmd>(Optional) In the text field under the <uicontrol>Select
 the server type</uicontrol> label, you can replace the text <userinput>type
 filter text</userinput> with keywords to filter the list of available
@@ -65,6 +63,8 @@
 <dd>Filters the list of available servers that supports J2EE 1.2 specification
 level or any servers that may have a version-level of 1.2.</dd>
 </dlentry></dl></info></substep>
+<substep><cmd>There is a brief description about the server selected
+from the server type list.</cmd></substep>
 </substeps>
 </step>
 <step id="step3"><cmd>In the <uicontrol>Server's host name</uicontrol> field,
@@ -77,24 +77,33 @@
 <info> By default, this field is completed with the following naming
 convention: <i>server type</i> at <i>host name</i>, for example <userinput>Tomcat
 v6.0 Server at localhost</userinput>.</info></step>
-<step id="step6"><cmd>In the <uicontrol>Server runtime environment</uicontrol> list,
-select a server runtime environment as defined in the Preferences
+<step id="step6"><cmd>The <uicontrol>Server runtime environment</uicontrol> list
+is available, when you select a server from the server type list that
+contains a runtime environment entry in the Runtime Environments preferences
 page (<menucascade><uicontrol>Window</uicontrol><uicontrol>Preferences</uicontrol>
 <uicontrol>Server</uicontrol><uicontrol>Runtime Environments</uicontrol>
-</menucascade>). You can direct the workbench to use a specific runtime
-environment of an application server for compiling, testing, or running
-your application. To modify the server runtime environment, select
-the <uicontrol>Configure runtime environments</uicontrol> link. To
-add a new server runtime environment, select the <uicontrol>Add</uicontrol> link.</cmd>
-<info>For more details about runtime environments, see the <i>Defining
-the server runtime environments preferences</i> link at the bottom
-of this topic.</info></step><?Pub Caret 614?>
+</menucascade>).</cmd><info> In the <uicontrol>Server runtime environment</uicontrol> list,
+select the runtime environment of an application server for compiling,
+testing, or running your application. To modify the server runtime
+environment, select the <uicontrol>Configure runtime environments</uicontrol> link.
+To add a new server runtime environment, select the <uicontrol>Add</uicontrol> link.
+For more details about runtime environments, see the <i>Defining the
+server runtime environments preferences</i> link at the bottom of
+this topic.</info><info><p>If the <uicontrol>Server runtime environment</uicontrol> list
+is not available, continue to the next page of the New Server wizard
+where it is going to prompt you for the installation directory of
+the server. After you complete this New Server wizard, the workbench
+automatically adds a runtime environment entry in the Runtime Environments
+preference page.</p></info></step>
 <step id="step7"><cmd>Click <uicontrol>Next</uicontrol> and follow
 the instructions in the wizard to specify the details of the server
-that you want to create.</cmd></step>
-<step id="step8"><cmd>Click  <uicontrol>Finish</uicontrol>.</cmd><info>The
-new server appears in the Servers view.</info></step>
+that you want to create.</cmd><info> See the links at the end of this
+topic, as there might be documentation available when continuing through
+this wizard for creating the server you have selected in the server
+type list.</info></step><?Pub Caret 206?>
+<step id="step8"><cmd>After completing the New Server wizard, by click <uicontrol>Finish</uicontrol>,
+the new server appears in the Servers view.</cmd></step>
 </steps>
 </taskbody>
 </task>
-<?Pub *0000005228?>
+<?Pub *0000005898?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.html
index bd26b6f..d2a61f4 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -15,6 +15,9 @@
 <meta content="servers, creating, creating a pointer" name="keywords" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twinstprf.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/tcreate.html" />
+<meta scheme="URI" name="DC.Relation" content="../../org.eclipse.jst.server.ui.doc.user/topics/tomcat.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/thttppreview.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/tj2eepreview.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="twcrtins_wst" name="DC.Identifier" />
 <meta content="en-us" name="DC.Language" />
@@ -60,9 +63,6 @@
 select the type of server or test environment where you want to publish
 or test your resources.</span>
 <ol type="a">
-<li class="substepexpand"><span>(Optional) Refer to the <span class="uicontrol">Description</span> section
-for brief details about the server you have selected.</span></li>
-
 <li class="substepexpand"><span>(Optional) In the text field under the <span class="uicontrol">Select
 the server type</span> label, you can replace the text <kbd class="userinput">type
 filter text</kbd> with keywords to filter the list of available
@@ -102,6 +102,9 @@
 </dl>
 </li>
 
+<li class="substepexpand"><span>There is a brief description about the server selected
+from the server type list.</span></li>
+
 </ol>
 
 </li>
@@ -118,31 +121,50 @@
 convention: <em>server type</em> at <em>host name</em>, for example <kbd class="userinput">Tomcat
 v6.0 Server at localhost</kbd>.</li>
 
-<li class="stepexpand" id="twcrtins_wst__step6"><a name="twcrtins_wst__step6"><!-- --></a><span>In the <span class="uicontrol">Server runtime environment</span> list,
-select a server runtime environment as defined in the Preferences
+<li class="stepexpand" id="twcrtins_wst__step6"><a name="twcrtins_wst__step6"><!-- --></a><span>The <span class="uicontrol">Server runtime environment</span> list
+is available, when you select a server from the server type list that
+contains a runtime environment entry in the Runtime Environments preferences
 page (<span class="menucascade"><span class="uicontrol">Window</span> &gt; <span class="uicontrol">Preferences</span>
  &gt; <span class="uicontrol">Server</span> &gt; <span class="uicontrol">Runtime Environments</span>
-</span>). You can direct the workbench to use a specific runtime
-environment of an application server for compiling, testing, or running
-your application. To modify the server runtime environment, select
-the <span class="uicontrol">Configure runtime environments</span> link. To
-add a new server runtime environment, select the <span class="uicontrol">Add</span> link.</span>
- For more details about runtime environments, see the <em>Defining
-the server runtime environments preferences</em> link at the bottom
-of this topic.</li>
+</span>).</span>  In the <span class="uicontrol">Server runtime environment</span> list,
+select the runtime environment of an application server for compiling,
+testing, or running your application. To modify the server runtime
+environment, select the <span class="uicontrol">Configure runtime environments</span> link.
+To add a new server runtime environment, select the <span class="uicontrol">Add</span> link.
+For more details about runtime environments, see the <em>Defining the
+server runtime environments preferences</em> link at the bottom of
+this topic. <p>If the <span class="uicontrol">Server runtime environment</span> list
+is not available, continue to the next page of the New Server wizard
+where it is going to prompt you for the installation directory of
+the server. After you complete this New Server wizard, the workbench
+automatically adds a runtime environment entry in the Runtime Environments
+preference page.</p>
+</li>
 
 <li class="stepexpand" id="twcrtins_wst__step7"><a name="twcrtins_wst__step7"><!-- --></a><span>Click <span class="uicontrol">Next</span> and follow
 the instructions in the wizard to specify the details of the server
-that you want to create.</span></li>
+that you want to create.</span>  See the links at the end of this
+topic, as there might be documentation available when continuing through
+this wizard for creating the server you have selected in the server
+type list.</li>
 
-<li class="stepexpand" id="twcrtins_wst__step8"><a name="twcrtins_wst__step8"><!-- --></a><span>Click  <span class="uicontrol">Finish</span>.</span> The
-new server appears in the Servers view.</li>
+<li class="stepexpand" id="twcrtins_wst__step8"><a name="twcrtins_wst__step8"><!-- --></a><span>After completing the New Server wizard, by click <span class="uicontrol">Finish</span>,
+the new server appears in the Servers view.</span></li>
 
 </ol>
 
 </div>
 
 <div>
+<ul class="ullinks">
+<li class="ulchildlink"><strong><a href="../../org.eclipse.jst.server.ui.doc.user/topics/tomcat.html">...Apache Tomcat server</a></strong><br />
+</li>
+<li class="ulchildlink"><strong><a href="../topics/thttppreview.html">...HTTP Preview server</a></strong><br />
+</li>
+<li class="ulchildlink"><strong><a href="../topics/tj2eepreview.html">...J2EE Preview server</a></strong><br />
+</li>
+</ul>
+
 <div class="familylinks">
 <div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/tcreate.html" title="">Creating, editing, and deleting servers</a></div>
 </div>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twdelins.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twdelins.html
index b3ae663..e933fdf 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twdelins.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twdelins.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.dita
index 7935d44..f703e1a 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.dita
@@ -1,14 +1,16 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2006, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
 <!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
  "task.dtd">
 <task id="twedtins_wst" xml:lang="en-us">
 <title id="title">Editing a server</title>
-<shortdesc id="shortdesc">You can edit your server using a server editor.
-The fields that you change are dependant on what runtime environment the server
-is defined to use, or whether it is defined as a local or remote server.</shortdesc>
+<shortdesc id="shortdesc">You can edit your server using a server
+editor. The fields that you change are dependant on what runtime environment
+the server is defined to use, or whether it is defined as a local
+or remote server.</shortdesc>
 <prolog><metadata>
-<keywords id="index"><indexterm keyref="twedtins|1|serversediting" status="new">servers<indexterm>editing</indexterm></indexterm>
+<keywords id="index"><indexterm keyref="twedtins|1|serversediting"
+status="new">servers<indexterm>editing</indexterm></indexterm>
 <indexterm keyref="twedtins|3|editorsserver" status="new">editors<indexterm>server</indexterm></indexterm>
 </keywords>
 </metadata></prolog>
@@ -17,23 +19,26 @@
 <steps id="steps">
 <step><cmd>Open a server editor, completing one of the following:</cmd>
 <choices>
-<choice>In the Servers view, double-click on the server that you want to edit.</choice>
-<choice>Right-click on the server in the Servers view, from the pop-up menu
-select <uicontrol>Open</uicontrol>. </choice>
+<choice>In the Servers view, double-click on the server that you want
+to edit.</choice>
+<choice>Right-click on the server in the Servers view, from the pop-up
+menu select <uicontrol>Open</uicontrol>. </choice>
 </choices>
 </step>
-<step><cmd>When the server editor is open on the workbench, you can save your
-changes by either selecting from the toolbar <menucascade><uicontrol>File</uicontrol>
-<uicontrol>Save</uicontrol></menucascade> or type <userinput>CTRL+S</userinput>. </cmd>
-<info><note type="tip">Changes to the server editor that have not yet been
-saved are indicated with a * icon located at the top of the server editor.
-After you save your changes on the server editor, the * icon should no longer
-appear on the server editor.</note></info></step>
-<step><cmd>For good practice, close all server editors before starting, restarting,
-or adding and removing modules on the server.</cmd><info>Otherwise, you might
-be prompt the following message:<codeblock>File Changed
-The server has been changed on the file system.  Do you want to load the changes?  Yes or No.</codeblock></info>
-</step>
+<step><cmd>When the server editor is open on the workbench, you can
+save your changes by either selecting from the toolbar <menucascade>
+<uicontrol>File</uicontrol><uicontrol>Save</uicontrol></menucascade> or
+type <userinput>CTRL+S</userinput>. </cmd><info><note type="tip">Changes
+to the server editor that have not yet been saved are indicated with
+a * icon located at the top of the server editor. After you save your
+changes on the server editor, the * icon should no longer appear on
+the server editor.</note></info></step>
+<step><cmd>Close all server editors before starting, restarting, or
+adding and removing modules on the server.</cmd><info> Otherwise,
+you might be prompt the following message:<codeblock>File Changed
+The server has been changed on the file system.  Do you want to load the changes?  Yes or No.</codeblock><?Pub
+Caret 0?></info></step>
 </steps>
 </taskbody>
 </task>
+<?Pub *0000002063?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.html
index 3b622eb..fe6579f 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twedtins.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -27,38 +27,40 @@
 
 
 
-<div><p>You can edit your server using a server editor.
-The fields that you change are dependant on what runtime environment the server
-is defined to use, or whether it is defined as a local or remote server.</p>
+<div><p>You can edit your server using a server
+editor. The fields that you change are dependant on what runtime environment
+the server is defined to use, or whether it is defined as a local
+or remote server.</p>
 
 <div class="section" id="twedtins_wst__context"><a name="twedtins_wst__context"><!-- --></a>To edit a server:</div>
 
 <a name="twedtins_wst__steps"><!-- --></a><ol id="twedtins_wst__steps">
 <li class="stepexpand"><span>Open a server editor, completing one of the following:</span>
 <ul>
-<li>In the Servers view, double-click on the server that you want to edit.</li>
+<li>In the Servers view, double-click on the server that you want
+to edit.</li>
 
-<li>Right-click on the server in the Servers view, from the pop-up menu
-select <span class="uicontrol">Open</span>. </li>
+<li>Right-click on the server in the Servers view, from the pop-up
+menu select <span class="uicontrol">Open</span>. </li>
 
 </ul>
 
 </li>
 
-<li class="stepexpand"><span>When the server editor is open on the workbench, you can save your
-changes by either selecting from the toolbar <span class="menucascade"><span class="uicontrol">File</span>
- &gt; <span class="uicontrol">Save</span></span> or type <kbd class="userinput">CTRL+S</kbd>. </span>
- <div class="tip"><span class="tiptitle">Tip:</span> Changes to the server editor that have not yet been
-saved are indicated with a * icon located at the top of the server editor.
-After you save your changes on the server editor, the * icon should no longer
-appear on the server editor.</div>
+<li class="stepexpand"><span>When the server editor is open on the workbench, you can
+save your changes by either selecting from the toolbar <span class="menucascade">
+<span class="uicontrol">File</span> &gt; <span class="uicontrol">Save</span></span> or
+type <kbd class="userinput">CTRL+S</kbd>. </span> <div class="tip"><span class="tiptitle">Tip:</span> Changes
+to the server editor that have not yet been saved are indicated with
+a * icon located at the top of the server editor. After you save your
+changes on the server editor, the * icon should no longer appear on
+the server editor.</div>
 </li>
 
-<li class="stepexpand"><span>For good practice, close all server editors before starting, restarting,
-or adding and removing modules on the server.</span> Otherwise, you might
-be prompt the following message:<pre>File Changed
+<li class="stepexpand"><span>Close all server editors before starting, restarting, or
+adding and removing modules on the server.</span>  Otherwise,
+you might be prompt the following message:<pre>File Changed
 The server has been changed on the file system.  Do you want to load the changes?  Yes or No.</pre>
-
 </li>
 
 </ol>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twinstprf.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twinstprf.html
index b1a50a7..319ce12 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twinstprf.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twinstprf.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.dita
index b2af9fa..1cbfd6f 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.dita
@@ -19,8 +19,8 @@
 </keywords>
 </metadata></prolog>
 <taskbody>
-<prereq></prereq>
-<context id="context">To define these preferences, complete the following:</context>
+<context id="context">To define these preferences, complete the following:</context><?Pub
+Caret -2?>
 <steps>
 <step id="step1"><cmd>In the toolbar, select <menucascade><uicontrol>Window</uicontrol>
 <uicontrol>Preferences</uicontrol></menucascade>.</cmd></step>
@@ -41,7 +41,7 @@
 open editors before starting the server</li>
 <li>Prompt - specifies the workbench to prompt you before saving any
 changes in an open server editor</li>
-</ul></chdesc></chrow><?Pub Caret -2?>
+</ul></chdesc></chrow>
 <chrow><choption id="choption1">When switching to a different server
 mode<!--context id = .spge0030--></choption><chdesc><ph id="chdesc1_ph1">When
 switching the server to run in a different mode, for example using
@@ -97,4 +97,4 @@
 </steps>
 </taskbody>
 </task>
-<?Pub *0000005625?>
+<?Pub *0000005607?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.html
index 2d1df09..37ee2c6 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -33,8 +33,6 @@
 use the <span class="uicontrol">Run on Server</span></span><span id="shortdesc_ph2"><a name="shortdesc_ph2"><!-- --></a> or <span class="uicontrol">Debug
 on Server</span> commands.</span></p>
 
-<div class="p" />
-
 <div class="section" id="twlaunchpref_wst__context"><a name="twlaunchpref_wst__context"><!-- --></a>To define these preferences, complete the following:</div>
 
 <ol>
@@ -47,18 +45,18 @@
 <li><span id="twlaunchpref_wst__step3"><a name="twlaunchpref_wst__step3"><!-- --></a>Specify one or more of the following settings:</span>
 
 <table class="choicetableborder" summary="" cellspacing="0" cellpadding="4" rules="rows" frame="hsides" border="1">
-<thead><tr><th valign="bottom" id="N100C1-option" align="left">Option</th>
-<th valign="bottom" id="N100C1-desc" align="left">Description</th></tr></thead>
+<thead><tr><th valign="bottom" id="N100BC-option" align="left">Option</th>
+<th valign="bottom" id="N100BC-desc" align="left">Description</th></tr></thead>
 <tbody>
-<tr><td valign="top" headers="N100C1-option" id="N100CC"><strong>Automatically publish when starting servers</strong></td>
+<tr><td valign="top" headers="N100BC-option" id="N100C7"><strong>Automatically publish when starting servers</strong></td>
 
-<td valign="top" headers="N100C1-desc N100CC">Specifies that all the files should automatically be published
+<td valign="top" headers="N100BC-desc N100C7">Specifies that all the files should automatically be published
 before starting the server.</td>
 </tr>
 
-<tr><td valign="top" headers="N100C1-option" id="N100DD"><strong>Save dirty editors before starting server</strong></td>
+<tr><td valign="top" headers="N100BC-option" id="N100D8"><strong>Save dirty editors before starting server</strong></td>
 
-<td valign="top" headers="N100C1-desc N100DD">Specify the preference for saving the changes in any open
+<td valign="top" headers="N100BC-desc N100D8">Specify the preference for saving the changes in any open
 server editors before starting the server by selecting one of the
 following options:<ul>
 <li>Always - specifies the workbench will automatically save any changes
@@ -74,9 +72,9 @@
 </td>
 </tr>
 
-<tr><td valign="top" headers="N100C1-option" id="choption1"><strong>When switching to a different server
+<tr><td valign="top" headers="N100BC-option" id="choption1"><strong>When switching to a different server
 mode</strong></td>
-<td valign="top" headers="N100C1-desc choption1"><span id="twlaunchpref_wst__chdesc1_ph1"><a name="twlaunchpref_wst__chdesc1_ph1"><!-- --></a>When
+<td valign="top" headers="N100BC-desc choption1"><span id="twlaunchpref_wst__chdesc1_ph1"><a name="twlaunchpref_wst__chdesc1_ph1"><!-- --></a>When
 switching the server to run in a different mode, for example using
 the <span class="menucascade"><span class="uicontrol">Run As</span> &gt; <span class="uicontrol">Run on Server</span>
 </span></span> <span id="twlaunchpref_wst__chdesc1_ph2"><a name="twlaunchpref_wst__chdesc1_ph2"><!-- --></a>or <span class="menucascade"><span class="uicontrol">Debug
@@ -96,9 +94,9 @@
 </td>
 </tr>
 
-<tr><td valign="top" headers="N100C1-option" id="choption2"><strong>When switching the server out of debug
+<tr><td valign="top" headers="N100BC-option" id="choption2"><strong>When switching the server out of debug
 mode</strong></td>
-<td valign="top" headers="N100C1-desc choption2"><span id="twlaunchpref_wst__chdesc2_ph1"><a name="twlaunchpref_wst__chdesc2_ph1"><!-- --></a>When
+<td valign="top" headers="N100BC-desc choption2"><span id="twlaunchpref_wst__chdesc2_ph1"><a name="twlaunchpref_wst__chdesc2_ph1"><!-- --></a>When
 you finish running the server in debug mode and switch out, for example
 using the <span class="menucascade"><span class="uicontrol">Run As</span> &gt; <span class="uicontrol">Run
 on Server</span></span></span><span id="twlaunchpref_wst__chdesc2_ph2"><a name="twlaunchpref_wst__chdesc2_ph2"><!-- --></a> command,
@@ -120,10 +118,10 @@
 </td>
 </tr>
 
-<tr><td valign="top" headers="N100C1-option" id="N1019E"><strong>When switching the server into debug
+<tr><td valign="top" headers="N100BC-option" id="N10199"><strong>When switching the server into debug
 mode, re-enable breakpoints</strong></td>
 
-<td valign="top" headers="N100C1-desc N1019E">When you change the server mode into debug mode, for example
+<td valign="top" headers="N100BC-desc N10199">When you change the server mode into debug mode, for example
 using the <span class="menucascade"><span class="uicontrol">Debug As</span> &gt; <span class="uicontrol">Debug
 on Server</span></span> command, specify how to handle
 the breakpoints currently set in your application by selecting one
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twmanage.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twmanage.html
index 9ef50fa..e109670 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twmanage.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twmanage.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.dita
index 3e3e9dc..ef3c38b 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.dita
@@ -1,28 +1,30 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2005, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
 <!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
  "task.dtd">
 <task id="twprefin_wst" xml:lang="en-us">
 <title id="title">Setting a default server</title>
-<shortdesc id="shortdesc">A default server is the server that you want to
-use when a project has more than one server defined.</shortdesc>
+<shortdesc id="shortdesc">A default server is the server that you
+want to use when a project has more than one server defined.</shortdesc>
 <prolog><metadata>
-<keywords id="index"><indexterm>projects<indexterm>setting default servers</indexterm></indexterm>
-<indexterm>servers<indexterm>setting project defaults</indexterm></indexterm>
-</keywords>
+<keywords id="index"><indexterm>projects<indexterm>setting default
+servers</indexterm></indexterm><indexterm>servers<indexterm>setting
+project defaults</indexterm></indexterm></keywords>
 </metadata></prolog>
 <taskbody>
 <context id="context"><p>To set a default server:</p></context>
 <steps id="steps">
-<step><cmd>Right-click on your project.</cmd><info>The pop-up menu for this
-project appears.</info></step>
-<step><cmd>Select <menucascade><uicontrol>Properties </uicontrol><uicontrol>Server</uicontrol>
-</menucascade>.</cmd><info>The Server pane appears on the right.</info></step>
-<step><cmd>Under the <uicontrol>Default server</uicontrol> list, select the
-server that you want to become the default server.</cmd></step>
+<step><cmd>Right-click on your project.</cmd><info>The pop-up menu
+for this project appears.</info></step><?Pub Caret 29?>
+<step><cmd>Select <menucascade><uicontrol>Properties </uicontrol>
+<uicontrol>Server</uicontrol></menucascade>.</cmd><info>The Server
+pane appears on the right.</info></step>
+<step><cmd>Under the <uicontrol>Always use the following server when
+running this project</uicontrol> list, select the server that you
+want to become the default server.</cmd></step>
 <step><cmd>Click  <uicontrol>Apply</uicontrol> and then <uicontrol>OK</uicontrol> to
 save your changes and close the Properties window.</cmd></step>
 </steps>
 </taskbody>
 </task>
-<?Pub *0000001344?>
+<?Pub *0000001377?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.html
index 4adc0d6..d646b92 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twprefin.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -27,21 +27,23 @@
 
 
 
-<div><p>A default server is the server that you want to
-use when a project has more than one server defined.</p>
+<div><p>A default server is the server that you
+want to use when a project has more than one server defined.</p>
 
 <div class="section" id="twprefin_wst__context"><a name="twprefin_wst__context"><!-- --></a><p>To set a default server:</p>
 </div>
 
 <a name="twprefin_wst__steps"><!-- --></a><ol id="twprefin_wst__steps">
-<li class="stepexpand"><span>Right-click on your project.</span> The pop-up menu for this
-project appears.</li>
+<li class="stepexpand"><span>Right-click on your project.</span> The pop-up menu
+for this project appears.</li>
 
-<li class="stepexpand"><span>Select <span class="menucascade"><span class="uicontrol">Properties </span> &gt; <span class="uicontrol">Server</span>
-</span>.</span> The Server pane appears on the right.</li>
+<li class="stepexpand"><span>Select <span class="menucascade"><span class="uicontrol">Properties </span>
+ &gt; <span class="uicontrol">Server</span></span>.</span> The Server
+pane appears on the right.</li>
 
-<li class="stepexpand"><span>Under the <span class="uicontrol">Default server</span> list, select the
-server that you want to become the default server.</span></li>
+<li class="stepexpand"><span>Under the <span class="uicontrol">Always use the following server when
+running this project</span> list, select the server that you
+want to become the default server.</span></li>
 
 <li class="stepexpand"><span>Click  <span class="uicontrol">Apply</span> and then <span class="uicontrol">OK</span> to
 save your changes and close the Properties window.</span></li>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.dita
index 6cb2a04..0c451c7 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.dita
@@ -55,14 +55,14 @@
 is the <b>Automatically publish when resources change</b> option is
 enabled with a value set in the publishing interval.</p><p>In addition,
 under the <uicontrol>Select publishing actions</uicontrol> list, select
-the tasks you want to run during publishing.</p><?Pub Caret -3?><b
-id="twpub_manualtitle">Manually publishing to a server</b><p
-id="twpub_manual1">If you do not want to wait for the automatic publishing
-interval to pass, at anytime you can manually request the workbench
-to issue a publish command to the server. Each manual publish command
-causes a single publishing request to the server. To publish your
-application manually you can complete one of the following in the
-Servers view:</p><p><ul>
+the tasks you want to run during publishing.</p><b id="twpub_manualtitle">Manually
+publishing to a server</b><p id="twpub_manual1">If you do not want
+to wait for the automatic publishing interval to pass or the <uicontrol>Never
+publish automatically</uicontrol> option is enabled, at anytime you
+can manually request the workbench to issue a publish command to the
+server. Each manual publish command causes a single publishing request
+to the server. To publish your application manually you can complete
+one of the following in the Servers view:</p><?Pub Caret 75?><p><ul>
 <li><ph id="twpub_steps_ph1">Select the server and then click the
  <uicontrol>Publish to the server</uicontrol></ph> <image
 alt="This is an image of the Publish toolbar icon."
@@ -78,4 +78,4 @@
 by the server.</p></result>
 </taskbody>
 </task>
-<?Pub *0000004819?>
+<?Pub *0000004895?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.html
index c60979f..00d581e 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twpub.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -82,12 +82,14 @@
 <p>In addition,
 under the <span class="uicontrol">Select publishing actions</span> list, select
 the tasks you want to run during publishing.</p>
-<strong id="twpub_wst__twpub_manualtitle"><a name="twpub_wst__twpub_manualtitle"><!-- --></a>Manually publishing to a server</strong><p id="twpub_wst__twpub_manual1"><a name="twpub_wst__twpub_manual1"><!-- --></a>If you do not want to wait for the automatic publishing
-interval to pass, at anytime you can manually request the workbench
-to issue a publish command to the server. Each manual publish command
-causes a single publishing request to the server. To publish your
-application manually you can complete one of the following in the
-Servers view:</p>
+<strong id="twpub_wst__twpub_manualtitle"><a name="twpub_wst__twpub_manualtitle"><!-- --></a>Manually
+publishing to a server</strong><p id="twpub_wst__twpub_manual1"><a name="twpub_wst__twpub_manual1"><!-- --></a>If you do not want
+to wait for the automatic publishing interval to pass or the <span class="uicontrol">Never
+publish automatically</span> option is enabled, at anytime you
+can manually request the workbench to issue a publish command to the
+server. Each manual publish command causes a single publishing request
+to the server. To publish your application manually you can complete
+one of the following in the Servers view:</p>
 <div class="p"><ul>
 <li><span id="twpub_wst__twpub_steps_ph1"><a name="twpub_wst__twpub_steps_ph1"><!-- --></a>Select the server and then click the
  <span class="uicontrol">Publish to the server</span></span> <img src="../images/launch_publish.gif" alt="This is an image of the Publish&#10;toolbar icon." /> <span id="twpub_wst__twpub_steps_ph2"><a name="twpub_wst__twpub_steps_ph2"><!-- --></a>icon located
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twremprj.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twremprj.html
index c983d8c..7945c85 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twremprj.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twremprj.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.html
index cf38193..460f88b 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.dita
index 4e668b1..3e033c3 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.dita
@@ -23,8 +23,8 @@
 <context id="twrstins_context"><p>Once you have started the server
 you can test the projects that are associated with the server. You
 can stop and restart the server at any time. The status of the server
-is displayed in the  <uicontrol>Status</uicontrol> column of the Servers
-view.</p><p>To manually start a server:</p></context>
+is displayed in the Servers view.</p><?Pub Caret 185?><p>To manually
+start a server:</p></context>
 <steps id="twrtins_steps">
 <step><cmd>Switch to the Servers view.</cmd></step>
 <step><cmd>In the Servers view, right-click the server you want to
@@ -43,11 +43,11 @@
 start the server. If the server fails to start, check for the reason
 that it failed in the Console.</li>
 <li>In the Servers view, the status of the server changes to  <systemoutput>Started</systemoutput>.</li>
-</ul></info></step><?Pub Caret 34?>
+</ul></info></step>
 </steps>
 <result id="twsrtins_result"><note type="tip">The server is automatically
 started when you right-click on a file and then select  <uicontrol>Run
 As > Run on Server</uicontrol>.</note></result>
 </taskbody>
 </task>
-<?Pub *0000002751?>
+<?Pub *0000002707?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.html
index 026dcbd..2bf6ac7 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
@@ -44,9 +44,9 @@
 <div class="section" id="twsrtins_wst__twrstins_context"><a name="twsrtins_wst__twrstins_context"><!-- --></a><p>Once you have started the server
 you can test the projects that are associated with the server. You
 can stop and restart the server at any time. The status of the server
-is displayed in the  <span class="uicontrol">Status</span> column of the Servers
-view.</p>
-<p>To manually start a server:</p>
+is displayed in the Servers view.</p>
+<p>To manually
+start a server:</p>
 </div>
 
 <a name="twsrtins_wst__twrtins_steps"><!-- --></a><ol id="twsrtins_wst__twrtins_steps">
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrvprf.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrvprf.html
index 2156d36..154b23f 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrvprf.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrvprf.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twstpins.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twstpins.html
index bccb0df..6b177a0 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twstpins.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twstpins.html
@@ -2,8 +2,8 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.dita
index 947212b..d319be4 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.dita
@@ -1,64 +1,73 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2006, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
 <!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
  "task.dtd">
 <task id="twtcpprf_wst" xml:lang="en-us">
 <title id="title">Defining the TCP/IP Monitor preferences</title>
-<shortdesc id="shortdesc">Using the Preferences page, you can define the TCP/IP
-Monitor attributes. To define these preferences, complete the following:</shortdesc>
+<shortdesc id="shortdesc">Using the Preferences page, you can define
+the TCP/IP Monitor attributes.</shortdesc>
 <prolog><metadata>
-<keywords id="index"><indexterm keyref="twtcpprf|1|preferencesTCP/IPMonitor"
-status="new">preferences<indexterm>TCP/IP Monitor</indexterm></indexterm>
-<indexterm keyref="twtcpprf|2|TCP/IPpreferences" status="new">TCP/IP<indexterm>preferences</indexterm></indexterm>
-<indexterm keyref="twtcpprf|3|viewsTCP/IPMonitorpreferences" status="changed">views<indexterm>TCP/IP
-monitors</indexterm></indexterm></keywords>
+<keywords id="index"><indexterm
+keyref="twtcpprf|1|preferencesTCP/IPMonitor" status="new">preferences<indexterm>TCP/IP
+Monitor</indexterm></indexterm><indexterm
+keyref="twtcpprf|2|TCP/IPpreferences" status="new">TCP/IP<indexterm>preferences</indexterm></indexterm>
+<indexterm keyref="twtcpprf|3|viewsTCP/IPMonitorpreferences"
+status="changed">views<indexterm>TCP/IP monitors</indexterm></indexterm>
+</keywords>
 </metadata></prolog>
 <taskbody>
-<context></context>
+<context>To define these preferences, complete the following steps:</context><?Pub
+Caret 57?>
 <steps id="steps">
 <step><cmd>From the toolbar, select <menucascade><uicontrol>Window</uicontrol>
 <uicontrol>Preferences</uicontrol></menucascade>.</cmd></step>
 <step><cmd>In the Preferences window, expand  <uicontrol>Run/Debug</uicontrol> and
 then select  <uicontrol>TCP/IP Monitor</uicontrol>.</cmd></step>
-<step><cmd>Select the <uicontrol>Show TCP/IP Monitor View when there is activity</uicontrol> check
-box if you want to display the TCP/IP Monitor view when there is activity
-through a TCP/IP monitoring server.</cmd></step>
+<step><cmd>Select the <uicontrol>Show TCP/IP Monitor View when there
+is activity</uicontrol> check box if you want to display the TCP/IP
+Monitor view when there is activity through a TCP/IP monitoring server.</cmd>
+</step>
 <step><cmd>To add a TCP/IP monitoring server, complete the following:</cmd>
 <substeps>
-<substep><cmd>Under the <uicontrol>TCP/IP Monitors</uicontrol> lists, click <uicontrol>Add</uicontrol>.</cmd>
-<info>A <uicontrol>New Monitor</uicontrol> dialog opens.</info></substep>
+<substep><cmd>Under the <uicontrol>TCP/IP Monitors</uicontrol> lists,
+click <uicontrol>Add</uicontrol>.</cmd><info>A <uicontrol>New Monitor</uicontrol> dialog
+opens.</info></substep>
 <substep><cmd>Specify the following settings, then click <uicontrol>OK</uicontrol>:</cmd>
 </substep>
 </substeps>
 <choicetable>
-<chrow><choption>Local monitoring port</choption><chdesc>Specify a unique
-port number on your local machine.</chdesc></chrow>
-<chrow><choption>Host name</choption><chdesc>Specify the host name or IP address
-of the machine where the server is running.</chdesc></chrow>
-<chrow><choption>Port</choption><chdesc>Specify the port number of the remote
-server.</chdesc></chrow>
-<chrow><choption>Type</choption><chdesc>Specify whether the request type from
-the Web browser are sent by HTTP or TCP/IP. If the HTTP option is selected
-the requests from the Web browser are modified so that the HTTP header points
-to the remote machine and separated if multiple HTTP requests are received
-in the same connection. If the TCP/IP option is selected, all the requests
-are sent byte for byte and the TCP/IP Monitor will not translate or modify
-any requests that it forwards. </chdesc></chrow>
-<chrow><choption>Timeout (in milliseconds)</choption><chdesc>Specify the length
-of time, in milliseconds, that you can wait before ending the TCP/IP connection
-to a server.</chdesc></chrow>
+<chrow><choption>Local monitoring port</choption><chdesc>Specify a
+unique port number on your local machine.</chdesc></chrow>
+<chrow><choption>Host name</choption><chdesc>Specify the host name
+or IP address of the machine where the server is running.</chdesc>
+</chrow>
+<chrow><choption>Port</choption><chdesc>Specify the port number of
+the remote server.</chdesc></chrow>
+<chrow><choption>Type</choption><chdesc>Specify whether the request
+type from the Web browser are sent by HTTP or TCP/IP. If the HTTP
+option is selected the requests from the Web browser are modified
+so that the HTTP header points to the remote machine and separated
+if multiple HTTP requests are received in the same connection. If
+the TCP/IP option is selected, all the requests are sent byte for
+byte and the TCP/IP Monitor will not translate or modify any requests
+that it forwards. </chdesc></chrow>
+<chrow><choption>Timeout (in milliseconds)</choption><chdesc>Specify
+the length of time, in milliseconds, that you can wait before ending
+the TCP/IP connection to a server.</chdesc></chrow>
 </choicetable>
 </step>
 <step><cmd>Use the <uicontrol>Start</uicontrol> and <uicontrol>Stop</uicontrol> buttons
-to manage the TCP/IP monitoring servers.</cmd><info>The TCP/IP Monitor table
-lists the available TCP/IP monitoring servers. You can add, edit, remove,
-start or stop the available TCP/IP monitoring servers from the TCP/IP Monitor
- table. The <b>Status</b> column shows if the TCP/IP monitor is started or
-stopped. The <b>Host name</b>  column shows the host name or IP address of
-the machine where the server is running. The <b>Type</b>  column shows whether
-the request type from the Web browser are sent by HTTP or TCP/IP.</info></step>
+to manage the TCP/IP monitoring servers.</cmd><info>The TCP/IP Monitor
+table lists the available TCP/IP monitoring servers. You can add,
+edit, remove, start or stop the available TCP/IP monitoring servers
+from the TCP/IP Monitor  table. The <b>Status</b> column shows if
+the TCP/IP monitor is started or stopped. The <b>Host name</b>  column
+shows the host name or IP address of the machine where the server
+is running. The <b>Type</b>  column shows whether the request type
+from the Web browser are sent by HTTP or TCP/IP.</info></step>
 <step><cmd>Click  <uicontrol>Apply</uicontrol> and then  <uicontrol>OK</uicontrol> to
 save your changes.</cmd></step>
 </steps>
 </taskbody>
 </task>
+<?Pub *0000003734?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.html
index 1569992..79aaa84 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.html
@@ -2,15 +2,15 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-<meta name="copyright" content="Copyright (c) 2000, 2009 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
-<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
+<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
+<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
 <meta content="public" name="security" />
 <meta content="index,follow" name="Robots" />
 <meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
 <meta content="task" name="DC.Type" />
 <meta name="DC.Title" content="Defining the TCP/IP Monitor preferences" />
-<meta name="abstract" content="Using the Preferences page, you can define the TCP/IP Monitor attributes. To define these preferences, complete the following:" />
-<meta name="description" content="Using the Preferences page, you can define the TCP/IP Monitor attributes. To define these preferences, complete the following:" />
+<meta name="abstract" content="Using the Preferences page, you can define the TCP/IP Monitor attributes." />
+<meta name="description" content="Using the Preferences page, you can define the TCP/IP Monitor attributes." />
 <meta content="preferences, TCP/IP Monitor, TCP/IP, views, TCP/IP monitors" name="DC.subject" />
 <meta content="preferences, TCP/IP Monitor, TCP/IP, views, TCP/IP monitors" name="keywords" />
 <meta scheme="URI" name="DC.Relation" content="../topics/rwtcpvw.html" />
@@ -29,10 +29,10 @@
 
 
 
-<div><p>Using the Preferences page, you can define the TCP/IP
-Monitor attributes. To define these preferences, complete the following:</p>
+<div><p>Using the Preferences page, you can define
+the TCP/IP Monitor attributes.</p>
 
-<div class="section" />
+<div class="section">To define these preferences, complete the following steps:</div>
 
 <a name="twtcpprf_wst__steps"><!-- --></a><ol id="twtcpprf_wst__steps">
 <li class="stepexpand"><span>From the toolbar, select <span class="menucascade"><span class="uicontrol">Window</span>
@@ -41,14 +41,16 @@
 <li class="stepexpand"><span>In the Preferences window, expand  <span class="uicontrol">Run/Debug</span> and
 then select  <span class="uicontrol">TCP/IP Monitor</span>.</span></li>
 
-<li class="stepexpand"><span>Select the <span class="uicontrol">Show TCP/IP Monitor View when there is activity</span> check
-box if you want to display the TCP/IP Monitor view when there is activity
-through a TCP/IP monitoring server.</span></li>
+<li class="stepexpand"><span>Select the <span class="uicontrol">Show TCP/IP Monitor View when there
+is activity</span> check box if you want to display the TCP/IP
+Monitor view when there is activity through a TCP/IP monitoring server.</span>
+</li>
 
 <li class="stepexpand"><span>To add a TCP/IP monitoring server, complete the following:</span>
 <ol type="a">
-<li class="substepexpand"><span>Under the <span class="uicontrol">TCP/IP Monitors</span> lists, click <span class="uicontrol">Add</span>.</span>
- A <span class="uicontrol">New Monitor</span> dialog opens.</li>
+<li class="substepexpand"><span>Under the <span class="uicontrol">TCP/IP Monitors</span> lists,
+click <span class="uicontrol">Add</span>.</span> A <span class="uicontrol">New Monitor</span> dialog
+opens.</li>
 
 <li class="substepexpand"><span>Specify the following settings, then click <span class="uicontrol">OK</span>:</span>
 </li>
@@ -57,38 +59,40 @@
 
 
 <table class="choicetableborder" summary="" cellspacing="0" cellpadding="4" rules="rows" frame="hsides" border="1">
-<thead><tr><th valign="bottom" id="N100E5-option" align="left">Option</th>
-<th valign="bottom" id="N100E5-desc" align="left">Description</th></tr></thead>
+<thead><tr><th valign="bottom" id="N100E6-option" align="left">Option</th>
+<th valign="bottom" id="N100E6-desc" align="left">Description</th></tr></thead>
 <tbody>
-<tr><td valign="top" headers="N100E5-option" id="N100EF"><strong>Local monitoring port</strong></td>
-<td valign="top" headers="N100E5-desc N100EF">Specify a unique
-port number on your local machine.</td>
+<tr><td valign="top" headers="N100E6-option" id="N100F0"><strong>Local monitoring port</strong></td>
+<td valign="top" headers="N100E6-desc N100F0">Specify a
+unique port number on your local machine.</td>
 </tr>
 
-<tr><td valign="top" headers="N100E5-option" id="N100FE"><strong>Host name</strong></td>
-<td valign="top" headers="N100E5-desc N100FE">Specify the host name or IP address
-of the machine where the server is running.</td>
+<tr><td valign="top" headers="N100E6-option" id="N100FF"><strong>Host name</strong></td>
+<td valign="top" headers="N100E6-desc N100FF">Specify the host name
+or IP address of the machine where the server is running.</td>
+
 </tr>
 
-<tr><td valign="top" headers="N100E5-option" id="N1010D"><strong>Port</strong></td>
-<td valign="top" headers="N100E5-desc N1010D">Specify the port number of the remote
-server.</td>
+<tr><td valign="top" headers="N100E6-option" id="N1010F"><strong>Port</strong></td>
+<td valign="top" headers="N100E6-desc N1010F">Specify the port number of
+the remote server.</td>
 </tr>
 
-<tr><td valign="top" headers="N100E5-option" id="N1011C"><strong>Type</strong></td>
-<td valign="top" headers="N100E5-desc N1011C">Specify whether the request type from
-the Web browser are sent by HTTP or TCP/IP. If the HTTP option is selected
-the requests from the Web browser are modified so that the HTTP header points
-to the remote machine and separated if multiple HTTP requests are received
-in the same connection. If the TCP/IP option is selected, all the requests
-are sent byte for byte and the TCP/IP Monitor will not translate or modify
-any requests that it forwards. </td>
+<tr><td valign="top" headers="N100E6-option" id="N1011E"><strong>Type</strong></td>
+<td valign="top" headers="N100E6-desc N1011E">Specify whether the request
+type from the Web browser are sent by HTTP or TCP/IP. If the HTTP
+option is selected the requests from the Web browser are modified
+so that the HTTP header points to the remote machine and separated
+if multiple HTTP requests are received in the same connection. If
+the TCP/IP option is selected, all the requests are sent byte for
+byte and the TCP/IP Monitor will not translate or modify any requests
+that it forwards. </td>
 </tr>
 
-<tr><td valign="top" headers="N100E5-option" id="N1012B"><strong>Timeout (in milliseconds)</strong></td>
-<td valign="top" headers="N100E5-desc N1012B">Specify the length
-of time, in milliseconds, that you can wait before ending the TCP/IP connection
-to a server.</td>
+<tr><td valign="top" headers="N100E6-option" id="N1012D"><strong>Timeout (in milliseconds)</strong></td>
+<td valign="top" headers="N100E6-desc N1012D">Specify
+the length of time, in milliseconds, that you can wait before ending
+the TCP/IP connection to a server.</td>
 </tr>
 
 </tbody></table>
@@ -96,13 +100,14 @@
 </li>
 
 <li class="stepexpand"><span>Use the <span class="uicontrol">Start</span> and <span class="uicontrol">Stop</span> buttons
-to manage the TCP/IP monitoring servers.</span> The TCP/IP Monitor table
-lists the available TCP/IP monitoring servers. You can add, edit, remove,
-start or stop the available TCP/IP monitoring servers from the TCP/IP Monitor
- table. The <strong>Status</strong> column shows if the TCP/IP monitor is started or
-stopped. The <strong>Host name</strong>  column shows the host name or IP address of
-the machine where the server is running. The <strong>Type</strong>  column shows whether
-the request type from the Web browser are sent by HTTP or TCP/IP.</li>
+to manage the TCP/IP monitoring servers.</span> The TCP/IP Monitor
+table lists the available TCP/IP monitoring servers. You can add,
+edit, remove, start or stop the available TCP/IP monitoring servers
+from the TCP/IP Monitor  table. The <strong>Status</strong> column shows if
+the TCP/IP monitor is started or stopped. The <strong>Host name</strong>  column
+shows the host name or IP address of the machine where the server
+is running. The <strong>Type</strong>  column shows whether the request type
+from the Web browser are sent by HTTP or TCP/IP.</li>
 
 <li class="stepexpand"><span>Click  <span class="uicontrol">Apply</span> and then  <span class="uicontrol">OK</span> to
 save your changes.</span></li>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.ditamap b/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.ditamap
index e1ade20..f4cdf4a 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.ditamap
+++ b/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.ditamap
@@ -57,10 +57,11 @@
 <!--Creating-->
 <topicref href="topics/tcreate.dita" id="create_server" locktitle="yes"
 navtitle="Creating, editing and deleting servers">
-<topicref href="topics/twcrtins.dita" linking="none" locktitle="yes"
-navtitle="Creating a server ">
+<topicref href="topics/twcrtins.dita" linking="targetonly"
+locktitle="yes" navtitle="Creating a server ">
 <navref
-mapref="../org.eclipse.jst.server.ui.doc.user/tomcat_create.ditamap"/>
+mapref="../org.eclipse.jst.server.ui.doc.user/tomcat_create.ditamap"/><?Pub
+Caret -2?>
 <topicref href="topics/thttppreview.dita" locktitle="yes"
 navtitle="...HTTP Preview server"></topicref>
 <topicref href="topics/tj2eepreview.dita" locktitle="yes"
@@ -84,7 +85,7 @@
 navtitle="Starting a server in debug mode"></topicref>
 </topicref>
 <topicref href="topics/twstpins.dita" locktitle="yes"
-navtitle="Stopping a server"></topicref><?Pub Caret -2?>
+navtitle="Stopping a server"></topicref>
 <topicref href="topics/ttimeout.dita"
 navtitle="Setting timeout on the start or stop of the server">
 </topicref>
@@ -119,4 +120,4 @@
 </topicref>
 </topicref>
 </map>
-<?Pub *0000005018?>
+<?Pub *0000005024?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/wtp_reltable.ditamap b/docs/org.eclipse.wst.server.ui.doc.user/wtp_reltable.ditamap
index f2ffc22..70d5772 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/wtp_reltable.ditamap
+++ b/docs/org.eclipse.wst.server.ui.doc.user/wtp_reltable.ditamap
@@ -204,6 +204,37 @@
 <relcell></relcell>
 <relcell></relcell>
 </relrow>
+<relrow>
+<relcell></relcell>
+<relcell>
+<topicref href="topics/twcrtins.dita" locktitle="yes"
+navtitle="Creating a server " scope="local">
+<topicref href="../org.eclipse.jst.server.ui.doc.user/topics/tomcat.dita"
+locktitle="yes" navtitle="...Apache Tomcat server" scope="peer">
+<topicmeta>
+<linktext>...Apache Tomcat server</linktext>
+<shortdesc></shortdesc>
+</topicmeta><?Pub Caret -2?>
+</topicref>
+<topicref href="topics/thttppreview.dita" locktitle="yes"
+navtitle="...HTTP Preview server" scope="local">
+<topicmeta>
+<linktext>...HTTP Preview server</linktext>
+<shortdesc></shortdesc>
+</topicmeta>
+</topicref>
+<topicref href="topics/tj2eepreview.dita" locktitle="yes"
+navtitle="...J2EE Preview server" scope="local">
+<topicmeta>
+<linktext>...J2EE Preview server</linktext>
+<shortdesc></shortdesc>
+</topicmeta>
+</topicref>
+</topicref>
+</relcell>
+<relcell></relcell>
+<relcell></relcell>
+</relrow>
 <!--Managing-->
 <relrow>
 <relcell></relcell>
@@ -222,7 +253,7 @@
 navtitle="Setting timeout on the start or stop of the server">
 </topicref>
 <topicref href="topics/twprefin.dita" locktitle="yes"
-navtitle="Setting a default server"></topicref><?Pub Caret -2?>
+navtitle="Setting a default server"></topicref>
 <topicref href="topics/tmetasrv.dita" locktitle="yes"
 navtitle="Displaying or hiding the metadata of the server"></topicref>
 <topicref href="topics/tclean.dita" locktitle="yes"
@@ -276,4 +307,4 @@
 </relrow>
 </reltable>
 </map>
-<?Pub *0000008786?>
+<?Pub *0000009666?>
