<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="../new_and_noteworthy.xsl"?>
<release
	name="3.0 M4"
	root="../../..">
	<!--
		<component name="component name, such as Server Tools">
		<item title="item title can go here">
			<title>item title can also go here</title>
		<description>description of this new feature, preferably with cropped .pngs (800px wide or less) of the UI</description>
		</item>
		</component>
	-->
	<component name="Server Tools">
		<item title="Servers View context menu improvements">
			<description>
				The context menu of the Server view has been updated to contain
				key bindings shortcuts for actions that are common to the Eclipse 
				Platform. 
				<br />
				<br />
				<br />
			</description>
		</item>
		<item title="Servers View tooltips">
			<description>
				We have added tooltips to the Servers view. The default tooltips will display the vendor of 
				the server and the number of modules it contains.
				<br />
				This is only the default behavior.  Adopters can extend this functionality using the org.eclipse.wst.server.ui.serverToolTip extension point.
				<br />
				<br />
				<br /> 
			<img src="server/ServerTooltip.png" alt="Tooltips"/>
			</description>
		</item>
		<item title="Server Automatic Publishing setting">
			<description>
				Simplified UI for Automatic Publishing settings, by providing one time for all types 
				of servers, local and remote. The initial value is provided by the server adopter.				
				<br />
				In addition to simplifying the UI, the settings are now stored only in the server object 
				and will get carried between workspaces when sharing .server files.
				<br />
				<br />
				<br /> 
			<img src="server/SimplerAutoPublish1.png" alt="Automatic Publishing setting"/>
			</description>
		</item>
		<item title="Tooltip for spinners">
			<description>
				Tooltips for spinners now provide aid in converting seconds to minutes when appropriate
				<br />
				<br />
				<br /> 
			<img src="server/Spinners.png" alt="Seconds to minutes spinners"/>
			</description>
		</item>
		<item title="Cleanup of the Server Preferences dialog">
			<description> 
				Many of the option in the Preferences dialog have been moved to other location. Some have 
				been moved into Server editor others are now implicit action. As a result the Preferences 
				for servers have now been minimized. 
				<br />
				<br />
				<br /> 
			</description>
		</item>
	</component>
</release>
