<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="../new_and_noteworthy.xsl"?>
<release name="2.0 M5" root="../../..">
	<!--
		<component name="component name, such as JEE 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 of the UI</description>
		</item>
		</component>
	-->
	<component name="Java EE Tools">
		<item title="Java Enterprise Edition 5 Facets">
			<description>
				New versions of the EAR, Web, Application Client, and
				EJB facets have been added. These versions have been
				created to enable developing applications for the Java
				Platform, Enterprise Edition 5.
				<br />
				<br />
				<img src="jee/Image2.png"
					alt="New EAR Application Project Wizard showing new Facet" />
			</description>
		</item>
	</component>
	<component name="JSP">
		<item title="New JSP Content validator">
			<description>
				There is now a separate validator for JSP content versus
				just using the validator of the embedded content type
				within JSP. For example, users are now able to enable
				HTML Syntax validation in their HTML files while
				disabling JSP content validation (for example HTML
				content within a JSP file).
				<br />
				<br />
				<img src="jee/jspcontentvalidator.png"
					alt="The new validator in the Validation preference page" />
			</description>
		</item>
	</component>
</release>
