diff --git a/docs/org.eclipse.wst.server.ui.doc.user/about.html b/docs/org.eclipse.wst.server.ui.doc.user/about.html
index 2199df3..f3924bb 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/about.html
+++ b/docs/org.eclipse.wst.server.ui.doc.user/about.html
@@ -18,7 +18,8 @@
 ("Content"). Unless otherwise indicated below, the Content is provided to you 
 under the terms and conditions of the Eclipse Public License Version 1.0 
 ("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
+<A href="http://www.eclipse.org/org/documents/epl-v10.php">
+http://www.eclipse.org/org/documents/epl-v10.php</A>. 
 For purposes of the EPL, "Program" will mean the Content.</P>
 
 <P>If you did not receive this Content directly from the Eclipse Foundation, the 
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.dita
index 28d9abc..ae3564b 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/cwflow.dita
@@ -1,48 +1,53 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2005, v.4002-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2011, v.4002-->
 <!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN"
  "concept.dtd">
 <concept id="cwflow_wst" xml:lang="en-us">
 <title id="cwflow_title">Which server will start</title>
-<shortdesc id="cwflow_shortdesc"><ph id="cwflow_shortdesc_ph1">You can start
-the server automatically as part of running a selected resource on the server,
-or you can simply start the server without running resources on the server.
-For example, the server is automatically started when you right-click a project
-or an application resource in the Project Explorer view and select <menucascade>
-<uicontrol>Run As</uicontrol><uicontrol>Run on Server</uicontrol></menucascade>.
-If you want to start the server without running resources on the server, in
-the Servers view select a server and select the <b>Start the server</b></ph>  <image
-alt="This is an image of the Run on Server icon." href="../images/launch_run.gif">
-<alt>This is an image of the Run on Server icon</alt></image> <ph id="cwflow_shortdesc_ph2">icon,
-the  <b>Start the server in debug mode</b></ph>  <image alt="This is an image of the Debug on server icon."
-href="../images/launch_debug.gif"><alt>This is an image of the Debug on server
-icon.</alt></image><ph id="cwflow_shortdesc_ph3"> icon , or the  <uicontrol>Start
-the server in profiling mode</uicontrol></ph>  <image alt="This is an image of the Start the server in profiling mode icon."
-href="../images/launch_profile.gif"><alt>This is an image of the Start the
-server in profiling mode icon.</alt></image><ph id="cwflow_shortdesc_ph4"> icon.</ph></shortdesc>
+<shortdesc id="cwflow_shortdesc"><ph id="cwflow_shortdesc_ph1">You
+can start the server automatically as part of running a selected resource
+on the server, or you can simply start the server without running
+resources on the server. For example, the server is automatically
+started when you right-click a project or an application resource
+in the Project Explorer view and select <menucascade><uicontrol>Run
+As</uicontrol><uicontrol>Run on Server</uicontrol></menucascade>.
+If you want to start the server without running resources on the server,
+in the Servers view select a server and select the <b>Start the server</b
+></ph>  <image alt="Image of the Run on Server icon."
+href="../images/launch_run.gif"><alt>Image of the Run on Server icon</alt>
+</image> <ph id="cwflow_shortdesc_ph2">icon, the  <b>Start the server
+in debug mode</b></ph>  <image alt="Image of the Debug on server icon."
+href="../images/launch_debug.gif"><alt>Image of the Debug on server
+icon.</alt></image><ph id="cwflow_shortdesc_ph3"> icon , or the  <uicontrol
+>Start the server in profiling mode</uicontrol></ph>  <image
+alt="Image of the Start the server in profiling mode icon."
+href="../images/launch_profile.gif"><alt>Image of the Start the server
+in profiling mode icon.</alt></image><ph id="cwflow_shortdesc_ph4"
+> icon.</ph></shortdesc><?Pub Caret 573?>
 <prolog><metadata>
-<keywords id="index"><indexterm>servers<indexterm>starting</indexterm></indexterm>
-</keywords>
+<keywords id="index"><indexterm>servers<indexterm>starting</indexterm
+></indexterm></keywords>
 </metadata></prolog>
 <conbody>
-<p id="cwflow_p1">When you run a file or project, the Server Tools first verify
-that the servers and configurations for that particular resource are already
-set up and determines how many are defined. You are then prompted by the Run
-on Server dialog box to select a server.</p>
-<section id="cwflow_section1"><title>Run on Server</title><p>If this is the
-first time you are testing a file or project, you will be prompted to create
-a new server. The Run on Server dialog box presents you with two options for
-deciding which server to run:</p><ul>
-<li> <uicontrol>Choose an existing server</uicontrol> This list includes servers
-that may or may not have already been configured. If you choose a server that
-is not already configured, it will be configured automatically and might be
-restarted if the server is already running.</li>
-<li> <uicontrol>Manually define a server</uicontrol> This option will create
-a new server and server configuration before testing.</li>
-</ul><p>If this is the first time you are testing a file or project,  <uicontrol>Manually
-define a server</uicontrol> is selected for you by default. When you select
-the type of server and click  <uicontrol>Next</uicontrol>, a server will be
-automatically created for you and the server will start.</p></section>
+<p id="cwflow_p1">When you run a file or project, the Server Tools
+first verify that the servers and configurations for that particular
+resource are already set up and determines how many are defined. You
+are then prompted by the Run on Server dialog box to select a server.</p>
+<section id="cwflow_section1"><title>Run on Server</title><p>If this
+is the first time you are testing a file or project, you will be prompted
+to create a new server. The Run on Server dialog box presents you
+with two options for deciding which server to run:</p><ul>
+<li> <uicontrol>Choose an existing server</uicontrol> This list includes
+servers that may or may not have already been configured. If you choose
+a server that is not already configured, it will be configured automatically
+and might be restarted if the server is already running.</li>
+<li> <uicontrol>Manually define a server</uicontrol> This option will
+create a new server and server configuration before testing.</li>
+</ul><p>If this is the first time you are testing a file or project,
+ <uicontrol>Manually define a server</uicontrol> is selected for you
+by default. When you select the type of server and click  <uicontrol
+>Next</uicontrol>, a server will be automatically created for you
+and the server will start.</p></section>
 </conbody>
 </concept>
-<?Pub *0000003233?>
+<?Pub *0000003059?>
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 662db60..dfc7b63 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, 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 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 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))' />
@@ -35,8 +35,10 @@
 <span class="uicontrol">Run As</span> &gt; <span class="uicontrol">Run on Server</span></span>.
 If you want to start the server without running resources on the server, in
 the Servers view select a server and select the <strong>Start the server</strong></span>  <img src="../images/launch_run.gif" alt="This is an image of the Run on Server icon" /> <span id="cwflow_shortdesc_ph2"><a name="cwflow_shortdesc_ph2"><!-- --></a>icon,
-the  <strong>Start the server in debug mode</strong></span>  <img src="../images/launch_debug.gif" alt="This is an image of the Debug on server&#10;icon." /><span id="cwflow_shortdesc_ph3"><a name="cwflow_shortdesc_ph3"><!-- --></a> icon , or the  <span class="uicontrol">Start
-the server in profiling mode</span></span>  <img src="../images/launch_profile.gif" alt="This is an image of the Start the&#10;server in profiling mode icon." /><span id="cwflow_shortdesc_ph4"><a name="cwflow_shortdesc_ph4"><!-- --></a> icon.</span></p>
+the  <strong>Start the server in debug mode</strong></span>  <img src="../images/launch_debug.gif" 
+alt="This is an image of the Debug on server icon." /><span id="cwflow_shortdesc_ph3"><a name="cwflow_shortdesc_ph3"><!-- --></a> icon , or the  <span class="uicontrol">Start
+the server in profiling mode</span></span>  <img src="../images/launch_profile.gif" 
+ alt="This is an image of the Start the server in profiling mode icon." /><span id="cwflow_shortdesc_ph4"><a name="cwflow_shortdesc_ph4"><!-- --></a> icon.</span></p>
 
 <p id="cwflow_wst__cwflow_p1"><a name="cwflow_wst__cwflow_p1"><!-- --></a>When you run a file or project, the Server Tools first verify
 that the servers and configurations for that particular resource are already
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.dita
index ca6d292..9e72fe1 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.dita
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!--Arbortext, Inc., 1988-2009, v.4002-->
+<!--Arbortext, Inc., 1988-2011, v.4002-->
 <!DOCTYPE reference PUBLIC "-//OASIS//DTD DITA Reference//EN"
  "reference.dtd">
 <reference id="rwrcview_wst" xml:lang="en-us">
@@ -15,19 +15,19 @@
 the server from the workbench.</ph></shortdesc>
 <prolog><metadata>
 <keywords id="index"><indexterm
-keyref="rwrcview|1|serversmanagingusingtheServersview" status="new">servers<indexterm>managing
-using the Servers view</indexterm></indexterm><indexterm
-keyref="rwrcview|2|viewsServers" status="changed">views<indexterm>servers<indexterm>overview</indexterm></indexterm></indexterm>
+keyref="rwrcview|1|serversmanagingusingtheServersview" status="new"
+>servers<indexterm>managing using the Servers view</indexterm></indexterm>
+<indexterm keyref="rwrcview|2|viewsServers" status="changed">views<indexterm
+>servers<indexterm>overview</indexterm></indexterm></indexterm>
 </keywords>
 </metadata></prolog>
 <refbody>
-<section><p> <image alt="This is a screen capture of the Server view."
-href="../images/scpview.gif"><alt>This is a screen capture of the
-Server view.</alt></image> </p><p id="rwrcview_p2">Use the Servers
-view to perform the following tasks:</p><ul>
+<section><p> <image alt="Servers view." href="../images/scpview.gif">
+<alt>Servers view.</alt></image> </p><?Pub Caret 10?><p id="rwrcview_p2"
+>Use the Servers view to perform the following tasks:</p><ul>
 <li id="rwrcview_li1">Create a server</li>
 <li id="rwrcview_li2">Edit a server</li>
-<li id="rwrcview_li3">Delete a server</li><?Pub Caret -2?>
+<li id="rwrcview_li3">Delete a server</li>
 <li id="rwrcview_li4">Start a server in debug mode</li>
 <li id="rwrcview_li5">Start a server </li>
 <li id="rwrcview_li6">Restart a server in debug mode</li>
@@ -38,10 +38,12 @@
 <li id="rwrcview_li11b">Displaying or hiding the metadata of the server
 from the workbench</li>
 <li id="rwrcview_li12">Add and remove projects from a server</li>
+<li id="rwrcview_li13">Deactivate server</li>
+<li id="rwrcview_li14">Activate server</li>
 </ul></section>
-<section><title id="rwrcview_section_server_state_title">Server State</title><p
-id="rwrcview_rwrcview_section_server_state_p1">The Servers view displays
-the current state of all the servers.</p><p
+<section><title id="rwrcview_section_server_state_title">Server State</title
+><p id="rwrcview_rwrcview_section_server_state_p1">The Servers view
+displays the current state of all the servers.</p><p
 id="rwrcview_rwrcview_section_server_state_p2">The following table
 lists the possible states of the server:</p><table><title
 id="rwrcview_section_server_state_table_title">Description of the
@@ -77,17 +79,23 @@
 <entry>The workbench is in the process of connecting to the server
 and is ending the process on the server.</entry>
 </row>
+<row>
+<entry colname="COLSPEC0">Stopped</entry>
+<entry colname="COLSPEC1"><ph
+id="rwrcview_section_server_state_stopped_description">The server
+process has ended. Or the workbench is unable to connect to the server.</ph
+></entry>
+</row>
 <row id="rwrcview_section_server_state_stopped">
-<entry id="rwrcview_section_server_state_stopped_entry">Stopped</entry>
-<entry><ph id="rwrcview_section_server_state_stopped_description">The
-server process has ended. Or the workbench is unable to connect to
-the server.</ph></entry>
+<entry id="rwrcview_section_server_state_stopped_entry">Inactive</entry>
+<entry><ph id="rwrcview_section_server_state_stopped_description"
+>The server has been deactivated</ph></entry>
 </row>
 </tbody>
 </tgroup>
 </table></section>
-<section id="rwrcview_section_server_status"><title>Server Status</title><p>The
-Servers view also displays the current status of all the servers.
+<section id="rwrcview_section_server_status"><title>Server Status</title
+><p>The Servers view also displays the current status of all the servers.
 Depending on the state of the server and the preference options that
 are selected for that particular server, the workbench determines
 the server actions that may be taken. Use the status as an indicator
@@ -122,16 +130,17 @@
 The changed files need to be updated on the server.</entry>
 </row>
 <row>
-<entry>Restart and republish</entry>
-<entry>Either the server or the applications or both have changed.
-When the server is restarted, the changed files are also republished.</entry>
+<entry colname="COLSPEC0">Restart and republish</entry>
+<entry colname="COLSPEC1">Either the server or the applications or
+both have changed. When the server is restarted, the changed files
+are also republished.</entry>
 </row>
 </tbody>
 </tgroup>
 </table></section>
-<section id="rwrcview_section_project_state"><title>Project State</title><p>The
-Servers view might display the current state of the application is
-either started or stopped. When the Servers view does not display
+<section id="rwrcview_section_project_state"><title>Project State</title
+><p>The Servers view might display the current state of the application
+is either started or stopped. When the Servers view does not display
 a current state for the project, the workbench cannot retrieve the
 state of the project from the server or the server does not support
 this function.</p><p>If a project name appears in italic font style,
@@ -160,14 +169,14 @@
 </tbody>
 </tgroup>
 </table></p></section>
-<section id="rwrcview_section_project_status"><title>Project Status</title><p>The
-Servers view might display the current status of the application is
-either synchronized or republished. When the Servers view does not
-display a current status for the project, the workbench cannot retrieve
-the status of the project from the server, the server is stopped or
-the server does not support this function.</p><p id="rwrcview_p3a">The
-following table lists the possible project status:</p><table><title>Description
-of project status</title>
+<section id="rwrcview_section_project_status"><title>Project Status</title
+><p>The Servers view might display the current status of the application
+is either synchronized or republished. When the Servers view does
+not display a current status for the project, the workbench cannot
+retrieve the status of the project from the server, the server is
+stopped or the server does not support this function.</p><p
+id="rwrcview_p3a">The following table lists the possible project status:</p
+><table><title>Description of project status</title>
 <tgroup cols="2"><colspec colname="COLSPEC0"/><colspec colname="COLSPEC1"/>
 <thead>
 <row>
@@ -192,4 +201,4 @@
 </table></section>
 </refbody>
 </reference>
-<?Pub *0000007992?>
+<?Pub *0000008256?>
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 479dc49..dda84a4 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, 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 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 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))' />
@@ -37,7 +37,8 @@
 current status and state of the server; and the projects added to
 the server from the workbench.</span></p>
 
-<div class="section"><p> <img src="../images/scpview.gif" alt="This is a screen capture of the&#10;Server view." /> </p>
+<div class="section"><p> <img src="../images/scpview.gif" 
+alt="This is a screen capture of the Server view." /> </p>
 <p id="rwrcview_wst__rwrcview_p2"><a name="rwrcview_wst__rwrcview_p2"><!-- --></a>Use the Servers
 view to perform the following tasks:</p>
 <ul>
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 0c451c7..6cb2a04 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><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>
+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>
 <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 *0000004895?>
+<?Pub *0000004819?>
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 00d581e..64489a2 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, 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 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 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,17 +82,16 @@
 <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 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>
+<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>
 <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
+ <span class="uicontrol">Publish to the server</span></span> <img src="../images/launch_publish.gif" 
+alt="This is an image of the Publish toolbar icon." /> <span id="twpub_wst__twpub_steps_ph2"><a name="twpub_wst__twpub_steps_ph2"><!-- --></a>icon located
 on the toolbar.</span></li>
 
 <li><span id="twpub_wst__twpub_steps_step2"><a name="twpub_wst__twpub_steps_step2"><!-- --></a>Right-click the server and then select
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.dita
index be3e7e9..8188d29 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.dita
@@ -1,21 +1,24 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!--Arbortext, Inc., 1988-2009, v.4002-->
+<!--Arbortext, Inc., 1988-2011, v.4002-->
 <!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
  "task.dtd">
 <?Pub Sty _display FontColor="red"?>
+<?Pub Inc?>
 <task id="twsrtdbg_wst" xml:lang="en-us">
 <title id="twsrtdbg_title">Starting a server in debug mode</title>
 <shortdesc id="twsrtdbg_shortdesc">If you want to debug your projects
 while a server runs, you can start a server in debug mode.</shortdesc>
 <prolog><metadata>
 <keywords id="index"><indexterm>applications<indexterm>running on
-servers in debug mode</indexterm></indexterm><indexterm>projects<indexterm>running
-on servers in debug mode</indexterm></indexterm><indexterm>servers<indexterm>starting
-in debug mode</indexterm></indexterm></keywords>
+servers in debug mode</indexterm></indexterm><indexterm>projects<indexterm
+>running on servers in debug mode</indexterm></indexterm><indexterm
+>servers<indexterm>starting in debug mode</indexterm></indexterm>
+</keywords>
 </metadata></prolog>
 <taskbody>
 <prereq><b>Prerequisites:</b><ol>
-<li id="twsrtdbg_li1"><xref href="twcrtins.dita">Create a server.</xref></li>
+<li id="twsrtdbg_li1"><xref href="twcrtins.dita">Create a server.</xref
+></li>
 <li id="twsrtdbg_li2"><xref href="twaddprj.dita">Add a project to
 the server.</xref></li>
 <li id="twsrtdbg_li3">Edit the file you want to run and set breakpoints.</li>
@@ -29,18 +32,20 @@
 displayed in the Debug view.</p><p>To manually start the server in
 debug mode:</p><p> </p></context>
 <steps>
-<step id="twsrtdbg_step1"><cmd>In the Servers view ( <menucascade>
-<uicontrol>Window > Show View > Other > Server > Servers > OK</uicontrol>
+<step id="twsrtdbg_step1"><cmd>In the Servers view (<menucascade>
+<uicontrol>Window</uicontrol><uicontrol> Show View </uicontrol>
+<uicontrol>Other</uicontrol><uicontrol>Server</uicontrol><uicontrol
+>Servers</uicontrol><uicontrol>OK</uicontrol></menucascade> <menucascade>
 </menucascade>), right-click the server you want to start in debug
-mode.</cmd></step>
-<step><cmd><ph id="twsrtdbg_steps_ph1">In the pop-up menu select <uicontrol>Debug </uicontrol> </ph> <image
-alt="This is an image of the Start in debug mode icon."
-href="../images/launch_debug.gif"><alt>This is an image of the Start
-in debug mode icon</alt></image> . </cmd><info><ph
-id="twsrtdbg_steps_ph2">In the Servers view, the status of the server
-changes to <i>Debugging</i>, after the server is started in debug
-mode.</ph></info></step><?Pub Caret 104?>
+mode.</cmd></step><?Pub Caret 75?>
+<step><cmd><ph id="twsrtdbg_steps_ph1">In the pop-up menu select <uicontrol
+>Debug </uicontrol> </ph> <image
+alt="Image of the Start in debug mode icon."
+href="../images/launch_debug.gif"><alt>Image of the Start in debug
+mode icon</alt></image> . </cmd><info><ph id="twsrtdbg_steps_ph2"
+>In the Servers view, the status of the server changes to <i>Debugging</i
+>, after the server is started in debug mode.</ph></info></step>
 </steps>
 </taskbody>
 </task>
-<?Pub *0000002308?>
+<?Pub *0000002435?>
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 460f88b..7faa352 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, 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 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 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,7 +58,8 @@
 </span>), right-click the server you want to start in debug
 mode.</span></li>
 
-<li class="stepexpand"><span><span id="twsrtdbg_wst__twsrtdbg_steps_ph1"><a name="twsrtdbg_wst__twsrtdbg_steps_ph1"><!-- --></a>In the pop-up menu select <span class="uicontrol">Debug </span> </span> <img src="../images/launch_debug.gif" alt="This is an image of the Start&#10;in debug mode icon" /> . </span> <span id="twsrtdbg_wst__twsrtdbg_steps_ph2"><a name="twsrtdbg_wst__twsrtdbg_steps_ph2"><!-- --></a>In the Servers view, the status of the server
+<li class="stepexpand"><span><span id="twsrtdbg_wst__twsrtdbg_steps_ph1"><a name="twsrtdbg_wst__twsrtdbg_steps_ph1"><!-- --></a>In the pop-up menu select <span class="uicontrol">Debug </span> </span> <img src="../images/launch_debug.gif" 
+alt="This is an image of the Start in debug mode icon" /> . </span> <span id="twsrtdbg_wst__twsrtdbg_steps_ph2"><a name="twsrtdbg_wst__twsrtdbg_steps_ph2"><!-- --></a>In the Servers view, the status of the server
 changes to <em>Debugging</em>, after the server is started in debug
 mode.</span></li>
 
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 3e033c3..4e668b1 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 Servers view.</p><?Pub Caret 185?><p>To manually
-start a server:</p></context>
+is displayed in the  <uicontrol>Status</uicontrol> column of the Servers
+view.</p><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>
+</ul></info></step><?Pub Caret 34?>
 </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 *0000002707?>
+<?Pub *0000002751?>
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 2bf6ac7..026dcbd 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, 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 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 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 Servers view.</p>
-<p>To manually
-start a server:</p>
+is displayed in the  <span class="uicontrol">Status</span> column of 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/twstpins.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/twstpins.dita
index 4ca021b..e03985f 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/twstpins.dita
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/twstpins.dita
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!--Arbortext, Inc., 1988-2009, v.4002-->
+<!--Arbortext, Inc., 1988-2011, v.4002-->
 <!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
  "task.dtd">
 <task id="twstpins_wst" xml:lang="en-us">
@@ -7,15 +7,17 @@
 <shortdesc id="twstpins_shortdesc">You can stop the server from the
 Servers view.</shortdesc>
 <prolog><metadata>
-<keywords id="index"><indexterm>servers<indexterm>stopping</indexterm></indexterm>
-</keywords>
+<keywords id="index"><indexterm>servers<indexterm>stopping</indexterm
+></indexterm></keywords>
 </metadata></prolog>
 <taskbody>
 <context id="twstpins_context">To stop the server:</context>
 <steps>
-<step id="twstpins_step1"><cmd>In the Servers view ( <b>Window > Show
-View > Other > Server > Servers > OK</b>), select the server that
-you want to stop.</cmd></step>
+<step id="twstpins_step1"><cmd>In the Servers view ( <menucascade>
+<uicontrol></uicontrol><uicontrol>Window</uicontrol><uicontrol>Show
+View</uicontrol><uicontrol>Other</uicontrol><uicontrol>Server</uicontrol>
+<uicontrol>Servers</uicontrol></menucascade>and click <uicontrol>OK</uicontrol
+>, and select the server that you want to stop.</cmd></step>
 <step><cmd><ph id="twstpins_steps_ph1">Click the  <uicontrol>Stop
 the server</uicontrol></ph>  <image
 alt="This is an image of the Stop icon." href="../images/launch_stop.gif">
@@ -30,13 +32,13 @@
 </substep>
 <substep id="twstpins_steps_substep2"><cmd>In the Process view, select
 the server process that you want to stop.</cmd></substep>
-<substep><cmd><ph id="twstpins_steps_ph6">Click the  <uicontrol>Terminate</uicontrol></ph>  <image
-alt="This is an image of the Terminate icon."
-href="../images/launch_stop.gif"><alt>This is an image of the Terminate
-icon</alt></image> <ph id="twstpins_steps_ph7">icon in the toolbar.</ph></cmd>
-</substep>
+<substep><cmd><ph id="twstpins_steps_ph6">Click the  <uicontrol>Terminate</uicontrol
+></ph>  <image alt="Image of the Terminate icon."
+href="../images/launch_stop.gif"><alt>Image of the Terminate icon</alt>
+</image> <ph id="twstpins_steps_ph7"> icon in the toolbar.</ph></cmd>
+</substep><?Pub Caret 28?>
 </substeps>
-</step><?Pub Caret 71?>
+</step>
 </steps>
 <result id="twstpins_result"><note>When terminating a server, the
 server process will end and the server will not go through the normal
@@ -44,4 +46,4 @@
 servlet.</note></result>
 </taskbody>
 </task>
-<?Pub *0000002125?>
+<?Pub *0000002288?>
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 6b177a0..80cc538 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, 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 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 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))' />
@@ -51,7 +51,8 @@
 <li id="twstpins_wst__twstpins_steps_substep2"><a name="twstpins_wst__twstpins_steps_substep2"><!-- --></a><span>In the Process view, select
 the server process that you want to stop.</span></li>
 
-<li><span><span id="twstpins_wst__twstpins_steps_ph6"><a name="twstpins_wst__twstpins_steps_ph6"><!-- --></a>Click the  <span class="uicontrol">Terminate</span></span>  <img src="../images/launch_stop.gif" alt="This is an image of the Terminate&#10;icon" /> <span id="twstpins_wst__twstpins_steps_ph7"><a name="twstpins_wst__twstpins_steps_ph7"><!-- --></a>icon in the toolbar.</span></span>
+<li><span><span id="twstpins_wst__twstpins_steps_ph6"><a name="twstpins_wst__twstpins_steps_ph6"><!-- --></a>Click the  <span class="uicontrol">Terminate</span></span>  <img src="../images/launch_stop.gif" 
+alt="This is an image of the Terminate icon" /> <span id="twstpins_wst__twstpins_steps_ph7"><a name="twstpins_wst__twstpins_steps_ph7"><!-- --></a>icon in the toolbar.</span></span>
 </li>
 
 </ol>
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 f4cdf4a..eab4c26 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
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!--Arbortext, Inc., 1988-2009, v.4002-->
+<!--Arbortext, Inc., 1988-2011, v.4002-->
 <!DOCTYPE map PUBLIC "-//OASIS//DTD DITA Map//EN"
  "map.dtd">
 <?Pub Sty _display FontColor="red"?>
@@ -57,11 +57,10 @@
 <!--Creating-->
 <topicref href="topics/tcreate.dita" id="create_server" locktitle="yes"
 navtitle="Creating, editing and deleting servers">
-<topicref href="topics/twcrtins.dita" linking="targetonly"
-locktitle="yes" navtitle="Creating a server ">
+<topicref href="topics/twcrtins.dita" linking="none" locktitle="yes"
+navtitle="Creating a server ">
 <navref
-mapref="../org.eclipse.jst.server.ui.doc.user/tomcat_create.ditamap"/><?Pub
-Caret -2?>
+mapref="../org.eclipse.jst.server.ui.doc.user/tomcat_create.ditamap"/>
 <topicref href="topics/thttppreview.dita" locktitle="yes"
 navtitle="...HTTP Preview server"></topicref>
 <topicref href="topics/tj2eepreview.dita" locktitle="yes"
@@ -86,9 +85,11 @@
 </topicref>
 <topicref href="topics/twstpins.dita" locktitle="yes"
 navtitle="Stopping a server"></topicref>
+<topicref href="topics/tdeactivateactivate.dita"
+navtitle="Deactivate and activate server"></topicref>
 <topicref href="topics/ttimeout.dita"
 navtitle="Setting timeout on the start or stop of the server">
-</topicref>
+</topicref><?Pub Caret -2?>
 <topicref href="topics/twprefin.dita" locktitle="yes"
 navtitle="Setting a default server"></topicref>
 <topicref href="topics/tmetasrv.dita" locktitle="yes"
@@ -120,4 +121,4 @@
 </topicref>
 </topicref>
 </map>
-<?Pub *0000005024?>
+<?Pub *0000005121?>
