diff --git a/docs/org.eclipse.wst.server.ui.doc.user/DocBuild.xml b/docs/org.eclipse.wst.server.ui.doc.user/DocBuild.xml
deleted file mode 100644
index 93150ff..0000000
--- a/docs/org.eclipse.wst.server.ui.doc.user/DocBuild.xml
+++ /dev/null
@@ -1,66 +0,0 @@
-<?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-01-09 Kate Price <katep@ca.ibm.com>
-	- modified for new DITA-OT version
-	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.6.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">
-	     <help.buildHelpIndex manifest="plugin.xml" destination="."/>
-	</target>
-</project>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/build.properties b/docs/org.eclipse.wst.server.ui.doc.user/build.properties
index df0017a..33819b8 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/build.properties
+++ b/docs/org.eclipse.wst.server.ui.doc.user/build.properties
@@ -9,6 +9,5 @@
 src.includes = *.maplist,\
                *.ditamap,\
                topics/*.dita
-bin.excludes = DocBuild.xml,\
-               myPlugin*.xml
+bin.excludes = myPlugin*.xml
                
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/images/scpview_no_decor.gif b/docs/org.eclipse.wst.server.ui.doc.user/images/scpview_no_decor.gif
new file mode 100644
index 0000000..8b5294a
--- /dev/null
+++ b/docs/org.eclipse.wst.server.ui.doc.user/images/scpview_no_decor.gif
Binary files differ
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/index/_13.cfs b/docs/org.eclipse.wst.server.ui.doc.user/index/_13.cfs
deleted file mode 100644
index 7996c3f..0000000
--- a/docs/org.eclipse.wst.server.ui.doc.user/index/_13.cfs
+++ /dev/null
Binary files differ
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
new file mode 100644
index 0000000..0a5167d
--- /dev/null
+++ 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 6599ca2..d0569c3 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 12 17:20:26 EDT 2010
+#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
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 5b66a06..f7014e2 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 12 17:20:26 EDT 2010
+#Wed May 19 16:20:46 EDT 2010
 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 b116179..36a6885 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,37 +1,39 @@
 #This is a generated file; do not edit.
-#Wed May 12 17:20:26 EDT 2010
-/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twedtins.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twremprj.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/thttppreview.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/raccessserver.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/cwflow.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twaddprj.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twprefin.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twstpins.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tcreate.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tmetasrv.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tj2eepreview.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/testing.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tmonitorport.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tj2ee.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/cwres.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tprefaud.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twmanage.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tdebug.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/rwtcpvw.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tclean.html=0
+#Wed May 19 16:20:46 EDT 2010
 /org.eclipse.wst.server.ui.doc.user/topics/tservlet.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twpub.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twinstprf.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twsrvprf.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twaddprj.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tdecor.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/cwres.html=0
 /org.eclipse.wst.server.ui.doc.user/topics/twdelins.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twsrtdbg.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twmanage.html=0
 /org.eclipse.wst.server.ui.doc.user/topics/tdbgjsp.html=0
-/org.eclipse.wst.server.ui.doc.user/topics/tpublish.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tmonitorport.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twtcpprf.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twprefin.html=0
 /org.eclipse.wst.server.ui.doc.user/topics/cwover.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/cwflow.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tdebug.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/raccessserver.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twlaunchpref.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tpublish.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twstpins.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twsrvprf.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/rwtcpvw.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tprefaud.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twremprj.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/rwrcview.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twpub.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tj2eepreview.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twinstprf.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twedtins.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twsrtins.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/twcrtins.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/thttppreview.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tj2ee.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tcreate.html=0
 /org.eclipse.wst.server.ui.doc.user/topics/tpref.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tclean.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/tmetasrv.html=0
+/org.eclipse.wst.server.ui.doc.user/topics/testing.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 f0d4f3f..de0c19e 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 22a7a99..0fed91f 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/myplugin.xml
+++ b/docs/org.eclipse.wst.server.ui.doc.user/myplugin.xml
@@ -22,7 +22,5 @@
       point="org.eclipse.help.index">
       <index file="org.eclipse.wst.server.ui.doc.userindex.xml"/>
 </extension>
-         <extension point="org.eclipse.help.base.luceneSearchParticipants">
-      <binding participantId="org.eclipse.help.base.xhtml"/>
-   </extension>
+
 </plugin>
\ No newline at end of file
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 22a7a99..0fed91f 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/plugin.xml
+++ b/docs/org.eclipse.wst.server.ui.doc.user/plugin.xml
@@ -22,7 +22,5 @@
       point="org.eclipse.help.index">
       <index file="org.eclipse.wst.server.ui.doc.userindex.xml"/>
 </extension>
-         <extension point="org.eclipse.help.base.luceneSearchParticipants">
-      <binding participantId="org.eclipse.help.base.xhtml"/>
-   </extension>
+
 </plugin>
\ No newline at end of file
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 aa8411e..d5f5654 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
@@ -61,7 +61,6 @@
 
 </div>
 
-<div />
 
 </body>
 </html>
\ No newline at end of file
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 b99b5f0..3c4b8a8 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
@@ -13,6 +13,7 @@
 <meta name="description" content="The Servers view (similar to the one shown below) allows you to manage the servers. This view displays a list of all your servers and projects that are associated with that server. A project displays under a server when a project from the workbench is added to the server. You can use this view to start, start in debug mode, restart, or stop the servers. In addition, you can use the Servers view to determine the current status and state of the server; and the projects added to the server from the workbench." />
 <meta content="servers, managing using the Servers view, views, overview" name="DC.subject" />
 <meta content="servers, managing using the Servers view, views, overview" name="keywords" />
+<meta scheme="URI" name="DC.Relation" content="../topics/tdecor.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="rwrcview_wst" name="DC.Identifier" />
 <meta content="en-us" name="DC.Language" />
@@ -298,6 +299,10 @@
 
 </div>
 
+<div><div class="reltasks"><strong>Related tasks</strong><br />
+<div><a href="../topics/tdecor.html" title="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.">Showing the state and status in the Servers view</a></div>
+</div>
+</div>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.dita
new file mode 100644
index 0000000..c9c88c8
--- /dev/null
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.dita
@@ -0,0 +1,32 @@
+<?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="tdecor_wst" xml:lang="en-us">
+<title id="title">Showing the state and status in the Servers view</title>
+<shortdesc id="shortdesc">When the <uicontrol>Server State Decorator</uicontrol> 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.</shortdesc>
+<prolog><metadata>
+<keywords id="index"><indexterm>servers<indexterm>decorator</indexterm></indexterm><indexterm>decorator<indexterm>server</indexterm></indexterm></keywords>
+</metadata></prolog>
+<taskbody>
+<context id="context"><ph id="ph1">For more detail about the state and status of the server and its project, refer to the <i>Servers view</i> topic, a link is provided at the bottom of this topic.</ph><table id="table"><title id="table_title">The following is the Servers view showing or hiding the Server State decorator: </title>
+<tgroup cols="2"><colspec colname="col1"/><colspec colname="col2"/>
+<thead>
+<row valign="bottom">
+<entry colname="col1" id="table_col1">Showing the Server State decorator</entry>
+<entry colname="col2" id="table_col2">Hiding the Server State decorator</entry>
+</row>
+</thead>
+<tbody>
+<row>
+<entry colname="col1"><image href="../images/scpview.gif"><alt>This is an image of the Servers view showing the Server State decorator.</alt></image><p><ph id="ph2">When the <uicontrol>Server State Decorator</uicontrol> preference is enabled, the Servers view shows the label decorations that indicate the state and status of the server and its projects. </ph> In this example, the Servers view shows the state of the Tomcat server is started and the status is synchronized. In addition, the status of the HelloWorld project is synchronized with the server.</p></entry>
+<entry colname="col2"><image href="../images/scpview_no_decor.gif"><alt>This is an image of the Servers view hiding the Server State decorator.</alt></image><p><ph id="ph3">When the <uicontrol>Server State Decorator</uicontrol> preference is cleared, the state and status of the server and its projects does not display in the Servers view.</ph></p></entry>
+</row>
+</tbody>
+</tgroup>
+</table><ph id="ph4">To enable the server status decorator:</ph></context>
+<steps id="steps">
+<step><cmd>Open the Label Decorations preference page<ph id="steps_ph5">: Click <menucascade><uicontrol>Window</uicontrol><uicontrol>Preferences</uicontrol></menucascade>, expand <menucascade><uicontrol>General </uicontrol><uicontrol>Appearance</uicontrol></menucascade>, and click <uicontrol> Label Decorations</uicontrol>.</ph></cmd></step>
+<step><cmd id="steps_cmd2">To show or hide the state and status of the server from the Servers view, select or clear the <uicontrol>Server State Decorator</uicontrol> check box.</cmd><info id="step2_info"> By default, this check box is selected.</info></step>
+</steps>
+</taskbody>
+</task>
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
new file mode 100644
index 0000000..d9b66cc
--- /dev/null
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/tdecor.html
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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 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="Showing the state and status in the Servers view" />
+<meta name="abstract" content="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." />
+<meta name="description" content="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." />
+<meta content="servers, decorator, server" name="DC.subject" />
+<meta content="servers, decorator, server" name="keywords" />
+<meta scheme="URI" name="DC.Relation" content="../topics/rwrcview.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/tpref.html" />
+<meta content="XHTML" name="DC.Format" />
+<meta content="tdecor_wst" name="DC.Identifier" />
+<meta content="en-us" name="DC.Language" />
+<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
+<title>Showing the state and status in the Servers view</title>
+</head>
+<body id="tdecor_wst"><a name="tdecor_wst"><!-- --></a>
+
+
+<h1 class="topictitle1">Showing the state and status in the Servers view</h1>
+
+
+
+<div><p>When the <span class="uicontrol">Server State Decorator</span> 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.</p>
+
+<div class="section" id="tdecor_wst__context"><a name="tdecor_wst__context"><!-- --></a><span id="tdecor_wst__ph1"><a name="tdecor_wst__ph1"><!-- --></a>For more detail about the state and status of the server and its project, refer to the <em>Servers view</em> topic, a link is provided at the bottom of this topic.</span>
+<div class="tablenoborder"><a name="tdecor_wst__table"><!-- --></a><table summary="" cellspacing="0" cellpadding="4" id="tdecor_wst__table" frame="border" border="1" rules="all"><caption>Table 1. The following is the Servers view showing or hiding the Server State decorator: </caption>
+<thead align="left">
+<tr valign="bottom">
+<th valign="bottom" id="N10083">Showing the Server State decorator</th>
+
+<th valign="bottom" id="N1008B">Hiding the Server State decorator</th>
+
+</tr>
+
+</thead>
+
+<tbody>
+<tr>
+<td valign="top" headers="N10083 "><img src="../images/scpview.gif" alt="This is an image of the Servers view showing the Server State decorator." /><p><span id="tdecor_wst__ph2"><a name="tdecor_wst__ph2"><!-- --></a>When the <span class="uicontrol">Server State Decorator</span> preference is enabled, the Servers view shows the label decorations that indicate the state and status of the server and its projects. </span> In this example, the Servers view shows the state of the Tomcat server is started and the status is synchronized. In addition, the status of the HelloWorld project is synchronized with the server.</p>
+</td>
+
+<td valign="top" headers="N1008B "><img src="../images/scpview_no_decor.gif" alt="This is an image of the Servers view hiding the Server State decorator." /><p><span id="tdecor_wst__ph3"><a name="tdecor_wst__ph3"><!-- --></a>When the <span class="uicontrol">Server State Decorator</span> preference is cleared, the state and status of the server and its projects does not display in the Servers view.</span></p>
+</td>
+
+</tr>
+
+</tbody>
+
+</table>
+</div>
+<span id="tdecor_wst__ph4"><a name="tdecor_wst__ph4"><!-- --></a>To enable the server status decorator:</span></div>
+
+<a name="tdecor_wst__steps"><!-- --></a><ol id="tdecor_wst__steps">
+<li class="stepexpand"><span>Open the Label Decorations preference page<span id="tdecor_wst__steps_ph5"><a name="tdecor_wst__steps_ph5"><!-- --></a>: Click <span class="menucascade"><span class="uicontrol">Window</span> &gt; <span class="uicontrol">Preferences</span></span>, expand <span class="menucascade"><span class="uicontrol">General </span> &gt; <span class="uicontrol">Appearance</span></span>, and click <span class="uicontrol"> Label Decorations</span>.</span></span></li>
+
+<li class="stepexpand"><span id="tdecor_wst__steps_cmd2"><a name="tdecor_wst__steps_cmd2"><!-- --></a>To show or hide the state and status of the server from the Servers view, select or clear the <span class="uicontrol">Server State Decorator</span> check box.</span>  By default, this check box is selected.</li>
+
+</ol>
+
+</div>
+
+<div>
+<div class="familylinks">
+<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/tpref.html" title="The server tools allow you to define the following preferences:">Defining server preferences</a></div>
+</div>
+<div class="relref"><strong>Related reference</strong><br />
+<div><a href="../topics/rwrcview.html" title="The Servers view (similar to the one shown below) allows you to manage the servers. This view displays a list of all your servers and projects that are associated with that server. A project displays under a server when a project from the workbench is added to the server. You can use this view to start, start in debug mode, restart, or stop the servers. In addition, you can use the Servers view to determine the current status and state of the server; and the projects added to the server from the workbench.">Servers view</a></div>
+</div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tlimits.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/tlimits.dita
deleted file mode 100644
index 29448a8..0000000
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tlimits.dita
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--Arbortext, Inc., 1988-2005, v.4002-->
-<!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
- "task.dtd">
-<task id="tlimits_wst" xml:lang="en-us">
-<title id="title">Limitations and restrictions</title>
-<shortdesc id="shortdesc">This section describes known server
-tools limitations and problems along with their solutions.</shortdesc>
-<taskbody>
-<context></context>
-</taskbody>
-</task>
-<?Pub *0000000465?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/tlimits.html b/docs/org.eclipse.wst.server.ui.doc.user/topics/tlimits.html
deleted file mode 100644
index 2ef3cbe..0000000
--- a/docs/org.eclipse.wst.server.ui.doc.user/topics/tlimits.html
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<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 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="Limitations and restrictions" />
-<meta name="abstract" content="This section describes known server tools limitations and problems along with their solutions." />
-<meta name="description" content="This section describes known server tools limitations and problems along with their solutions." />
-<meta content="XHTML" name="DC.Format" />
-<meta content="tlimits_wst" name="DC.Identifier" />
-<meta content="en-us" name="DC.Language" />
-<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
-<title>Limitations and restrictions</title>
-</head>
-<body id="tlimits_wst"><a name="tlimits_wst"><!-- --></a>
-
-
-<h1 class="topictitle1">Limitations and restrictions</h1>
-
-
-<div><p>This section describes known server
-tools limitations and problems along with their solutions.</p>
-
-<div class="section" />
-
-</div>
-
-<div />
-
-</body>
-</html>
\ No newline at end of file
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 454e95d..385d947 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
@@ -18,6 +18,7 @@
 <meta scheme="URI" name="DC.Relation" content="../topics/twlaunchpref.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twinstprf.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twtcpprf.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/tdecor.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="tpref_wst" name="DC.Identifier" />
 <meta content="en-us" name="DC.Language" />
@@ -47,6 +48,8 @@
 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>
+<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>
 </div>
 
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.dita b/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.dita
new file mode 100644
index 0000000..e54090e
--- /dev/null
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.dita
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--Arbortext, Inc., 1988-2009, v.4002-->
+<!DOCTYPE task PUBLIC "-//OASIS//DTD DITA Task//EN"
+ "task.dtd">
+<?Pub Sty _display FontColor="red"?>
+<?Pub Inc?>
+<task id="ttimeout_wst" xml:lang="en-us">
+<title id="title">Setting timeout on the start or stop of the server</title>
+<shortdesc id="shortdesc">You can specify the length of time you can
+wait, before the workbench cancels the process to start or stop the
+server.</shortdesc>
+<prolog><metadata>
+<keywords id="index"><indexterm>starting servers<indexterm>timeout</indexterm></indexterm>
+<indexterm>stopping servers<indexterm>timeout</indexterm></indexterm>
+</keywords>
+</metadata></prolog>
+<taskbody>
+<context id="context"><p><note type="tip"> If you have a fast processing
+machine, you can try to set a short timeout interval.  If you have
+a slow processing machine, you can try to set a long timeout interval.</note></p>To
+set the timeout for starting or stopping the server:</context>
+<steps id="steps">
+<step><cmd>In the Servers view, right-click the server you want to
+modify its timeout and select <uicontrol>Open</uicontrol>. </cmd><info>The
+server editor opens.</info></step>
+<step><cmd>Under the <uicontrol>Timeouts</uicontrol> section, you
+have the following options:</cmd>
+<choices>
+<choice>Use the <uicontrol>Start</uicontrol> controls to specify the
+number of seconds allowed to elapse, before the workbench cancels
+the process to start the server.</choice>
+<choice>Use the <uicontrol>Stop</uicontrol> controls to specify the
+number of seconds allowed to elapse, before the workbench prompts
+you for an action. The prompt requests from you to either click <uicontrol>OK</uicontrol> to
+end the server or click <uicontrol>Cancel</uicontrol> to continue
+waiting for the server to stop. See the below <i>Results</i> section,
+for the text of the prompt.</choice>
+</choices>
+</step>
+</steps>
+<result><b>Results</b><!--Added the "Results" title because WTP does not auto-generate the titles.--><p
+id="result_p1">If the timeout interval for starting the server has
+elapsed, the workbench displays the following message:<msgblock>Server <varname>server_name</varname> was unable to start within <varname>x</varname> seconds.  If the server requires more time, try increasing the timeout in the server editor.</msgblock>Where <varname>server_name</varname> is
+the name of the server to identify its entry in the Servers view and <varname>x</varname> is
+the number of seconds specified in the <uicontrol>Start</uicontrol> control.</p><p
+id="result_p2">If the timeout interval for stopping the server has
+elapsed, the workbench displays the following prompt: <msgblock>Terminate Server
+Server <varname>server_name</varname> is not responding.  Do you want to terminate this server?  Click OK to terminate the server or click Cancel to continue waiting.</msgblock></p><note
+id="result_tip" type="tip">If you are frequently encountering any
+of these messages, try following the steps in this topic to set longer
+timeout intervals. This may help resolve the messages.</note><?Pub
+Caret 0?></result>
+</taskbody>
+</task>
+<?Pub *0000003131?>
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
new file mode 100644
index 0000000..6d02a0b
--- /dev/null
+++ b/docs/org.eclipse.wst.server.ui.doc.user/topics/ttimeout.html
@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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 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="Setting timeout on the start or stop of the server" />
+<meta name="abstract" content="You can specify the length of time you can wait, before the workbench cancels the process to start or stop the server." />
+<meta name="description" content="You can specify the length of time you can wait, before the workbench cancels the process to start or stop the server." />
+<meta content="starting servers, timeout, stopping servers" name="DC.subject" />
+<meta content="starting servers, timeout, stopping servers" name="keywords" />
+<meta scheme="URI" name="DC.Relation" content="../topics/twstpins.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/twsrtins.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/twmanage.html" />
+<meta content="XHTML" name="DC.Format" />
+<meta content="ttimeout_wst" name="DC.Identifier" />
+<meta content="en-us" name="DC.Language" />
+<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
+<title>Setting timeout on the start or stop of the server</title>
+</head>
+<body id="ttimeout_wst"><a name="ttimeout_wst"><!-- --></a>
+
+
+<h1 class="topictitle1">Setting timeout on the start or stop of the server</h1>
+
+
+
+<div><p>You can specify the length of time you can
+wait, before the workbench cancels the process to start or stop the
+server.</p>
+
+<div class="section" id="ttimeout_wst__context"><a name="ttimeout_wst__context"><!-- --></a><div class="p"><div class="tip"><span class="tiptitle">Tip:</span>  If you have a fast processing
+machine, you can try to set a short timeout interval.  If you have
+a slow processing machine, you can try to set a long timeout interval.</div>
+</div>
+To
+set the timeout for starting or stopping the server:</div>
+
+<a name="ttimeout_wst__steps"><!-- --></a><ol id="ttimeout_wst__steps">
+<li class="stepexpand"><span>In the Servers view, right-click the server you want to
+modify its timeout and select <span class="uicontrol">Open</span>. </span> The
+server editor opens.</li>
+
+<li class="stepexpand"><span>Under the <span class="uicontrol">Timeouts</span> section, you
+have the following options:</span>
+<ul>
+<li>Use the <span class="uicontrol">Start</span> controls to specify the
+number of seconds allowed to elapse, before the workbench cancels
+the process to start the server.</li>
+
+<li>Use the <span class="uicontrol">Stop</span> controls to specify the
+number of seconds allowed to elapse, before the workbench prompts
+you for an action. The prompt requests from you to either click <span class="uicontrol">OK</span> to
+end the server or click <span class="uicontrol">Cancel</span> to continue
+waiting for the server to stop. See the below <em>Results</em> section,
+for the text of the prompt.</li>
+
+</ul>
+
+</li>
+
+</ol>
+
+<div class="section"><strong>Results</strong><div class="p" id="ttimeout_wst__result_p1"><a name="ttimeout_wst__result_p1"><!-- --></a>If the timeout interval for starting the server has
+elapsed, the workbench displays the following message:<pre>Server <var class="varname">server_name</var> was unable to start within <var class="varname">x</var> seconds.  If the server requires more time, try increasing the timeout in the server editor.</pre>
+Where <var class="varname">server_name</var> is
+the name of the server to identify its entry in the Servers view and <var class="varname">x</var> is
+the number of seconds specified in the <span class="uicontrol">Start</span> control.</div>
+<div class="p" id="ttimeout_wst__result_p2"><a name="ttimeout_wst__result_p2"><!-- --></a>If the timeout interval for stopping the server has
+elapsed, the workbench displays the following prompt: <pre>Terminate Server
+Server <var class="varname">server_name</var> is not responding.  Do you want to terminate this server?  Click OK to terminate the server or click Cancel to continue waiting.</pre>
+</div>
+<div class="tip" id="ttimeout_wst__result_tip"><a name="ttimeout_wst__result_tip"><!-- --></a><span class="tiptitle">Tip:</span> If you are frequently encountering any
+of these messages, try following the steps in this topic to set longer
+timeout intervals. This may help resolve the messages.</div>
+</div>
+
+</div>
+
+<div>
+<div class="familylinks">
+<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/twmanage.html" title="You can use the server tools views to manage servers. The following tasks may be included as part of the development path:">Managing servers</a></div>
+</div>
+<div class="reltasks"><strong>Related tasks</strong><br />
+<div><a href="../topics/twstpins.html" title="You can stop the server from the Servers view.">Stopping a server</a></div>
+<div><a href="../topics/twsrtins.html" title="When you are ready to test your projects, you must start a server. In some situations, listed below, the server tools start a server for you automatically. For more information on which test server will start, refer to the list of related topics at the end of this topic.">Starting a server</a></div>
+</div>
+</div>
+
+</body>
+</html>
\ No newline at end of file
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 35592f7..b1a50a7 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
@@ -13,6 +13,7 @@
 <meta name="description" content="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." />
 <meta content="preferences, installed server runtime environments, defining, servers, runtime environment, runtime environments, workbench, server runtime environment, applications, defining server runtime environment, server runtime environments" name="DC.subject" />
 <meta content="preferences, installed server runtime environments, defining, servers, runtime environment, runtime environments, workbench, server runtime environment, applications, defining server runtime environment, server runtime environments" name="keywords" />
+<meta scheme="URI" name="DC.Relation" content="../topics/tpref.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="twinstprf_wst" name="DC.Identifier" />
 <meta content="en-us" name="DC.Language" />
@@ -172,6 +173,11 @@
 
 </div>
 
+<div>
+<div class="familylinks">
+<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/tpref.html" title="The server tools allow you to define the following preferences:">Defining server preferences</a></div>
+</div>
+</div>
 
 </body>
 </html>
\ No newline at end of file
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 d82cd4f..9ef50fa 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
@@ -17,6 +17,7 @@
 <meta scheme="URI" name="DC.Relation" content="../topics/twremprj.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twsrtins.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twstpins.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/ttimeout.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twprefin.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/tmetasrv.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/tclean.html" />
@@ -47,6 +48,8 @@
 When you are ready to test your projects, you must start a server. In some situations, listed below, the server tools start a server for you automatically. For more information on which test server will start, refer to the list of related topics at the end of this topic.</li>
 <li class="ulchildlink"><strong><a href="../topics/twstpins.html">Stopping a server</a></strong><br />
 You can stop the server from the Servers view.</li>
+<li class="ulchildlink"><strong><a href="../topics/ttimeout.html">Setting timeout on the start or stop of the server</a></strong><br />
+You can specify the length of time you can wait, before the workbench cancels the process to start or stop the server.</li>
 <li class="ulchildlink"><strong><a href="../topics/twprefin.html">Setting a default server</a></strong><br />
 A default server is the server that you want to use when a project has more than one server defined.</li>
 <li class="ulchildlink"><strong><a href="../topics/tmetasrv.html">Displaying or hiding the metadata of the server</a></strong><br />
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 5874389..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
@@ -51,9 +51,11 @@
 the server only after the full time interval has passed.  If you set
 the publishing interval to 0 seconds, an immediate publish should
 happen after changes on a file are saved.</li>
-</ul></p><?Pub Caret -1?><p id="twpub_auto3">In the workbench, the
-default setting is the <b>Automatically publish when resources change</b> option
-is enabled with a value set in the publishing interval.</p><b
+</ul></p><p id="twpub_auto3">In the workbench, the default setting
+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
@@ -76,4 +78,4 @@
 by the server.</p></result>
 </taskbody>
 </task>
-<?Pub *0000004683?>
+<?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 d062003..c60979f 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
@@ -76,9 +76,12 @@
 
 </ul>
 </div>
-<p id="twpub_wst__twpub_auto3"><a name="twpub_wst__twpub_auto3"><!-- --></a>In the workbench, the
-default setting is the <strong>Automatically publish when resources change</strong> option
-is enabled with a value set in the publishing interval.</p>
+<p id="twpub_wst__twpub_auto3"><a name="twpub_wst__twpub_auto3"><!-- --></a>In the workbench, the default setting
+is the <strong>Automatically publish when resources change</strong> option is
+enabled with a value set in the publishing interval.</p>
+<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
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 a476470..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
@@ -30,7 +30,7 @@
 <step><cmd>In the Servers view, right-click the server you want to
 start.</cmd></step>
 <step><cmd>Select  <uicontrol>Start</uicontrol>. </cmd><info>The following
-things happen:<ul>
+events happen:<ul>
 <li>If you have selected the  <uicontrol>Automatically publish when
 starting servers</uicontrol> check box on the Server preferences page
 (<menucascade><uicontrol>Window</uicontrol><uicontrol> Preferences</uicontrol>
@@ -42,13 +42,12 @@
 <li>A Console view opens in the workbench. It will take a minute to
 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><?Pub
-Caret 7?>
-</ul></info></step>
+<li>In the Servers view, the status of the server changes to  <systemoutput>Started</systemoutput>.</li>
+</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 *0000002750?>
+<?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 bd9839b..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
@@ -14,6 +14,7 @@
 <meta content="applications, starting servers for testing, projects, starting servers for testing, servers, starting for testing" name="DC.subject" />
 <meta content="applications, starting servers for testing, projects, starting servers for testing, servers, starting for testing" name="keywords" />
 <meta scheme="URI" name="DC.Relation" content="../topics/cwflow.html" />
+<meta scheme="URI" name="DC.Relation" content="../topics/ttimeout.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twmanage.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="twsrtins_wst" name="DC.Identifier" />
@@ -55,7 +56,7 @@
 start.</span></li>
 
 <li class="stepexpand"><span>Select  <span class="uicontrol">Start</span>. </span> The following
-things happen:<ul>
+events happen:<ul>
 <li>If you have selected the  <span class="uicontrol">Automatically publish when
 starting servers</span> check box on the Server preferences page
 (<span class="menucascade"><span class="uicontrol">Window</span> &gt; <span class="uicontrol"> Preferences</span>
@@ -90,6 +91,9 @@
 <div class="relconcepts"><strong>Related concepts</strong><br />
 <div><a href="../topics/cwflow.html" title="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 Run As &gt; Run on Server. If you want to start the server without running resources on the server, in the Servers view select a server and select the Start the server This is an image of the Run on Server icon icon, the Start the server in debug mode This is an image of the Debug on server icon. icon , or the Start the server in profiling mode This is an image of the Start the server in profiling mode icon. icon.">Which server will start</a></div>
 </div>
+<div class="reltasks"><strong>Related tasks</strong><br />
+<div><a href="../topics/ttimeout.html" title="You can specify the length of time you can wait, before the workbench cancels the process to start or stop the server.">Setting timeout on the start or stop of the server</a></div>
+</div>
 </div>
 
 </body>
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 2218c48..bccb0df 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
@@ -13,6 +13,7 @@
 <meta name="description" content="You can stop the server from the Servers view." />
 <meta content="servers, stopping" name="DC.subject" />
 <meta content="servers, stopping" name="keywords" />
+<meta scheme="URI" name="DC.Relation" content="../topics/ttimeout.html" />
 <meta scheme="URI" name="DC.Relation" content="../topics/twmanage.html" />
 <meta content="XHTML" name="DC.Format" />
 <meta content="twstpins_wst" name="DC.Identifier" />
@@ -71,6 +72,9 @@
 <div class="familylinks">
 <div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/twmanage.html" title="You can use the server tools views to manage servers. The following tasks may be included as part of the development path:">Managing servers</a></div>
 </div>
+<div class="reltasks"><strong>Related tasks</strong><br />
+<div><a href="../topics/ttimeout.html" title="You can specify the length of time you can wait, before the workbench cancels the process to start or stop the server.">Setting timeout on the start or stop of the server</a></div>
+</div>
 </div>
 
 </body>
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 1eb9218..e1ade20 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
@@ -4,17 +4,19 @@
  "map.dtd">
 <?Pub Sty _display FontColor="red"?>
 <map title="Testing and publishing applications" xml:lang="en-us">
+<!--Introduction-->
 <topicref href="topics/cwover.dita" linking="normal" locktitle="yes"
 navtitle="Testing and publishing on your server" scope="peer">
 <topicref href="topics/rwrcview.dita" locktitle="yes"
 navtitle="Servers view">
 <topicref href="topics/raccessserver.dita"
 navtitle="Keyboard shortcuts for Server Tools"></topicref>
-</topicref><?Pub Caret -2?>
+</topicref>
 <topicref href="topics/cwres.dita" locktitle="yes"
 navtitle="Resources used by the Server Tools"></topicref>
 <topicref href="topics/cwflow.dita" locktitle="yes"
 navtitle="Which server will start"></topicref>
+<!--Testing-->
 <topicref href="topics/tj2ee.dita" id="testing" linking="normal"
 locktitle="yes" navtitle="Testing applications on a server">
 <topicref href="topics/testing.dita" locktitle="yes"
@@ -24,6 +26,7 @@
 <topicref href="topics/tj2eepreview.dita" locktitle="yes"
 navtitle="Testing on a J2EE Preview server"></topicref>
 </topicref>
+<!--Debugging-->
 <topicref href="topics/tdebug.dita" id="debug_server"
 navtitle="Debugging applications on a server">
 <topicref href="topics/tservlet.dita"
@@ -45,11 +48,13 @@
 </topicmeta>
 </topicref>
 </topicref>
+<!--Publishing-->
 <topicref href="topics/tpublish.dita" id="publish_server" locktitle="yes"
 navtitle="Publishing applications to a server">
 <topicref href="topics/twpub.dita" locktitle="yes"
 navtitle="Publishing your application"></topicref>
 </topicref>
+<!--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"
@@ -66,6 +71,7 @@
 <topicref href="topics/twdelins.dita" locktitle="yes"
 navtitle="Deleting a server"></topicref>
 </topicref>
+<!--Managing-->
 <topicref href="topics/twmanage.dita" id="manage_server" locktitle="yes"
 navtitle="Managing servers ">
 <topicref href="topics/twaddprj.dita" locktitle="yes"
@@ -78,7 +84,10 @@
 navtitle="Starting a server in debug mode"></topicref>
 </topicref>
 <topicref href="topics/twstpins.dita" locktitle="yes"
-navtitle="Stopping a server"></topicref>
+navtitle="Stopping a server"></topicref><?Pub Caret -2?>
+<topicref href="topics/ttimeout.dita"
+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>
 <topicref href="topics/tmetasrv.dita" locktitle="yes"
@@ -86,6 +95,7 @@
 <topicref href="topics/tclean.dita" locktitle="yes"
 navtitle="Cleaning projects published on the server"></topicref>
 </topicref>
+<!--Preferences-->
 <topicref href="topics/tpref.dita" id="pref_server" locktitle="yes"
 navtitle="Defining server preferences">
 <topicref href="topics/twsrvprf.dita" locktitle="yes"
@@ -104,7 +114,9 @@
 <topicref href="topics/rwtcpvw.dita" linking="sourceonly" locktitle="yes"
 navtitle="TCP/IP Monitor view"></topicref>
 </topicref>
+<topicref href="topics/tdecor.dita"
+navtitle="Showing the state and status in the Servers view"></topicref>
 </topicref>
 </topicref>
 </map>
-<?Pub *0000004676?>
+<?Pub *0000005018?>
diff --git a/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.xml b/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.xml
index f432457..571af2a 100644
--- a/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.xml
+++ b/docs/org.eclipse.wst.server.ui.doc.user/wtp_main_toc.xml
@@ -38,6 +38,7 @@
 <topic label="Starting a server in debug mode" href="topics/twsrtdbg.html"/>
 </topic>
 <topic label="Stopping a server" href="topics/twstpins.html"/>
+<topic label="Setting timeout on the start or stop of the server" href="topics/ttimeout.html"/>
 <topic label="Setting a default server" href="topics/twprefin.html"/>
 <topic label="Displaying or hiding the metadata of the server" href="topics/tmetasrv.html"/>
 <topic label="Cleaning projects published on the server" href="topics/tclean.html"/>
@@ -52,6 +53,7 @@
 <topic label="Defining the TCP/IP Monitor preferences" href="topics/twtcpprf.html">
 <topic label="TCP/IP Monitor view" href="topics/rwtcpvw.html"/>
 </topic>
+<topic label="Showing the state and status in the Servers view" href="topics/tdecor.html"/>
 </topic>
 </topic>
 </toc>
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 f05990d..f2ffc22 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
@@ -11,6 +11,7 @@
 <relcolspec type="reference"></relcolspec>
 <relcolspec></relcolspec>
 </relheader>
+<!--Related links at the bottom of each topic.-->
 <relrow>
 <relcell>
 <topicref href="topics/cwflow.dita"
@@ -88,7 +89,42 @@
 <relrow>
 <relcell></relcell>
 <relcell>
+<topicref href="topics/tdecor.dita"
+navtitle="Enabling the server state decorator"></topicref>
+</relcell>
+<relcell>
+<topicref href="topics/rwrcview.dita" navtitle="Severs view"></topicref>
+</relcell>
+<relcell></relcell>
+</relrow>
+<relrow>
+<relcell></relcell>
+<relcell collection-type="family">
+<topicref href="topics/ttimeout.dita"
+navtitle="Setting timeout on the start or stop of the server">
+</topicref>
+<topicref href="topics/twstpins.dita" locktitle="yes"
+navtitle="Stopping a server"></topicref>
+</relcell>
+<relcell></relcell>
+<relcell></relcell>
+</relrow>
+<relrow>
+<relcell></relcell>
+<relcell collection-type="family">
+<topicref href="topics/ttimeout.dita"
+navtitle="Setting timeout on the start or stop of the server">
+</topicref>
+<topicref href="topics/twsrtins.dita" locktitle="yes"
+navtitle="Starting a server"></topicref>
+</relcell>
+<relcell></relcell>
+<relcell></relcell>
+</relrow>
 <!--Testing-->
+<relrow>
+<relcell></relcell>
+<relcell>
 <topicref href="topics/tj2ee.dita"
 navtitle="Testing applications on a server">
 <topicref href="topics/testing.dita"
@@ -133,7 +169,7 @@
 <topicref href="topics/tdbgjsp.dita"
 navtitle="Debugging a JSP file on a server"></topicref>
 <topicref href="topics/tmonitorport.dita"
-navtitle="Monitoring server ports"></topicref><?Pub Caret -1?>
+navtitle="Monitoring server ports"></topicref>
 </topicref>
 </relcell>
 <relcell></relcell>
@@ -182,8 +218,11 @@
 navtitle="Starting a server"></topicref>
 <topicref href="topics/twstpins.dita" locktitle="yes"
 navtitle="Stopping a server"></topicref>
+<topicref href="topics/ttimeout.dita"
+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>
+navtitle="Setting a default server"></topicref><?Pub Caret -2?>
 <topicref href="topics/tmetasrv.dita" locktitle="yes"
 navtitle="Displaying or hiding the metadata of the server"></topicref>
 <topicref href="topics/tclean.dita" locktitle="yes"
@@ -205,8 +244,7 @@
 <topicref href="topics/twlaunchpref.dita"
 navtitle="Defining the launching preferences"></topicref>
 <topicref href="topics/twinstprf.dita"
-navtitle="Defining the server runtime environments preferences"
-scope="peer">
+navtitle="Defining the server runtime environments preferences">
 <topicmeta>
 <shortdesc>Using the Preferences page, you can direct the workbench
 to use a specific runtime environment of an application server for
@@ -215,11 +253,27 @@
 </topicref>
 <topicref href="topics/twtcpprf.dita"
 navtitle="Defining the TCP/IP Monitor preferences"></topicref>
+<topicref href="topics/tdecor.dita"
+navtitle="Enabling server state decorator"></topicref>
 </topicref>
 </relcell>
 <relcell></relcell>
 <relcell></relcell>
 </relrow>
+<!--Local build purpose-->
+<relrow>
+<relcell>
+<topicref href="topics/cwover.dita" linking="none"></topicref>
+</relcell>
+<relcell>
+<topicref href="topics/twsrtdbg.dita" linking="none"></topicref>
+</relcell>
+<relcell>
+<topicref href="topics/raccessserver.dita" linking="none"></topicref>
+<topicref href="topics/rwrcview.dita" linking="none"></topicref>
+</relcell>
+<relcell></relcell>
+</relrow>
 </reltable>
 </map>
-<?Pub *0000007218?>
+<?Pub *0000008786?>
diff --git a/docs/org.eclipse.wst.server.ui.infopop/STuiContexts.xml b/docs/org.eclipse.wst.server.ui.infopop/STuiContexts.xml
index b579cf2..b7837f0 100644
--- a/docs/org.eclipse.wst.server.ui.infopop/STuiContexts.xml
+++ b/docs/org.eclipse.wst.server.ui.infopop/STuiContexts.xml
@@ -78,14 +78,14 @@
 </context>
 
 <context id="spge0026">
-<description>This is the length of time the workbench is going to wait for the server to start.
-<b>Tip</b>:  If you have a fast processing machine, you can try specifying a shorter timeout interval.  If you have a slow processing machine, you can try specifying a longer timeout interval.
+<description>Specify the number of seconds allowed to elapse, before the workbench cancels the process to start the server. 
+<b>Tip</b>:  If you have a fast processing machine, you can try to set a short timeout interval. If you have a slow processing machine, you can try to set a long timeout interval.
 </description>
 </context>
 
 <context id="spge0027">
-<description>This is the length of time the workbench is going to wait for the stop signal from the server.
-<b>Tip</b>:  If you have a fast processing machine, you can try specifying a shorter timeout interval.  If you have a slow processing machine, you can try specifying a longer timeout interval.
+<description>Specify the number of seconds allowed to elapse, before the workbench prompts you for an action. The prompt requests from you to either click <b>OK</b> to end the server or click <b>Cancel</b> to continue waiting for the server to stop.   
+<b>Tip</b>:  If you have a fast processing machine, you can try to set a short timeout interval. If you have a slow processing machine, you can try to set a long timeout interval.
 </description>
 </context>
 
@@ -243,13 +243,11 @@
 </context>
 
 <context id="seop0012">
-<description>Specifies the workbench to issue a publish after changes on a file that is associated to the server are saved and a full time interval has passed in the <b>Publishing
-interval</b> setting.</description>
+<description>Specifies the workbench to issue a publish after changes on a file that is associated to the server are saved and a full time interval has passed in the <b>Publishing interval</b> setting.</description>
 </context>
 
 <context id="seop0014">
-<description>Specifies the workbench to issue a publish after changes on a file that requires a build and is associated to the server are saved, and a full time interval has passed in the <b>Publishing
-interval</b> setting.</description>
+<description>Specifies the workbench to issue a publish after changes on a file that requires a build and is associated to the server are saved, and a full time interval has passed in the <b>Publishing interval</b> setting.</description>
 </context>
 
 <context id="seop0016">
@@ -258,7 +256,12 @@
 </context>
 
 <context id="seop0018">
-<description>Specifies the number of <i>seconds</i> that needs to pass before the workbench calls a publish to happen on the server. However, if you make a subsequent change to the files before this time interval has completed, the publish is delayed as the timer is reset. The workbench makes a publish to the server only after the full time interval has passed.  If you set the publishing interval to 0 seconds, an immediate publish should happen after changes on a file are saved.
+<description>Specifies the number of <b>seconds</b> that needs to pass before the workbench calls a publish to happen on the server. However, if you make a subsequent change to the files before this time interval has completed, the publish is delayed as the timer is reset. The workbench makes a publish to the server only after the full time interval has passed.  If you set the publishing interval to 0 seconds, an immediate publish should happen after changes on a file are saved.
+</description>
+</context>
+
+<context id="seop0020">
+<description>Select the tasks you want to run during publishing.
 </description>
 </context>
 
@@ -284,4 +287,4 @@
 </description>
 </context>
 
-</contexts>
\ No newline at end of file
+</contexts>
diff --git a/docs/org.eclipse.wst.server.ui.infopop/plugin.xml b/docs/org.eclipse.wst.server.ui.infopop/plugin.xml
index e156aa0..923bc30 100644
--- a/docs/org.eclipse.wst.server.ui.infopop/plugin.xml
+++ b/docs/org.eclipse.wst.server.ui.infopop/plugin.xml
@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.3"?>
+<?eclipse version="3.6"?>
 <?NLS TYPE="org.eclipse.help.contexts"?> 
 
 <!-- /*******************************************************************************
- * Copyright (c) 2000, 2008 IBM Corporation and others.
+ * Copyright (c) 2000, 20010 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
