<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="../../../development/news/new_and_noteworthy.xsl"?>
<release
	name="3.14"
	root="../../.."
>
	<header>
		 Here are some of the more noteworthy features available in WTP 3.14,
		 also available as part of the
		 <a href="https://wiki.eclipse.org/Category:SimRel-2019-06">2019-06</a>
		 <a href="https://wiki.eclipse.org/Simultaneous_Release">Simultaneous Release</a>
		 (June 19th, 2019).
		 <a href="http://download.eclipse.org/webtools/downloads/">Download</a>
				it now!
	</header>
	<component name="Faceted Project Framework">
		<item title="Java Facets">
			<description>Faceted projects can now specify that they use Java 12.
				Early Access is also included for setting a project to use Java 13.
			</description>
		</item>
	</component>
	<component name="Source Editing">
		<item title="More powerful navigation using the Quick Outline">
			<description>
				The XML, HTML, XML Schema, JSP, and XSL Editors now offer multiple
				configurations in their Quick Outline (by default,
				Ctrl/Cmd+O). The
				configurations can cycle between the original filtering on node
				names and additional filtering on the first lines of text and
				comment
				nodes, plus identifying <b>attribute values</b>. When editing HTML sources, for
				example, this secondary configuration can be used to quickly find an
				element by its "id" attribute value.
				<br />
				<br />
				<img
					src="qo.gif"
					alt="The Quick Outline cycling and filtering" />
			</description>
		</item>
		<item title="Comment and Text previews in the Outline View">
			<description>The XML, HTML, XML Schema, JSP, and XSL Editors now show
				the first few words of comments and uncommented text when
				identifying attributes are being shown for elements.
				<br />
				<br />
				<img
					src="ov.png"
					alt="Updated Outline View" />
			</description>
		</item>
	</component>
	<footer>
		Summaries for earlier releases:
		<ul>
			<li>
				<a
					href="../../../development/news/"
				>Full summaries for earlier milestones and releases.</a>
			</li>
		</ul>
	</footer>
</release>
