<?xml version="1.0" encoding="utf-8"?>
<sections title="Template for Phoenix style main page"
	subtitle="subtitle goes here">
	<section class="infobox" name="Right side infobox">
		<item title="title and link" link="http://www.eclipse.org/ ">
			Descriptive content under the link.
		</item>
		<item title="Go to anchor section" link="#anchorsection" />
		<item>
			<a href="http://download.eclipse.org/">Item content only</a>
		</item>
	</section>
	<section class="infobox" name="Box two">
		<description>Optional description for this box</description>
		<item title="title and link no content"
			link="http://www.eclipse.org/" />
		<item title="Item two" link="http://www.eclipse.org/" />
		<item title="Title only is a subheader" />
		<item>
			<a href="http://www.eclipse.org/">href</a>
			and some descriptive text in the same item.
		</item>
		<item>
			<a href="http://www.eclipse.org/">Another</a>
			Item
		</item>
		<item title="Subheader 2" />
		<item>
			<a href="http://ws.apache.org/axis/">Axis</a>
		</item>
		<item>
			<a href="http://www.eclipse.org/">Eclipse</a>
		</item>
	</section>
	<section class="main" name="Main section one">
		<description>
			Optional description - Lorem ipsum dolor sit amet,
			consectetuer adipiscing elit. Etiam at ante. Phasellus non
			augue. Sed aliquet sagittis massa. Morbi varius nulla vel
			quam interdum hendrerit. Etiam vel felis. Integer ultrices
			tincidunt mi.
		</description>
		<section name="Name and link attributes"
			link="http://www.eclipse.org">
			Nullam convallis nunc eu purus congue lobortis. Donec eget
			elit et enim interdum sodales. Praesent venenatis enim ac
			ante. Nulla a risus. Nulla sit amet enim vel ipsum sodales
			iaculis. Fusce pharetra sapien vitae pede. Suspendisse
			potenti.
		</section>
		<section name="Title and no link">
			Pellentesque cursus est a magna. Aenean bibendum magna sit
			amet enim. Donec accumsan. Duis a urna. Aliquam vel diam
			eget nulla tempor viverra. Aliquam lobortis, pede ut dapibus
			scelerisque, sem leo auctor erat, eu malesuada magna magna
			et dolor. Donec lorem. Morbi vulputate tellus eget ligula.
			Aliquam quis felis quis massa faucibus dapibus. Quisque a
			arcu. Nullam est sem, adipiscing vitae, interdum sed,
			accumsan ut, elit. In sed neque.
		</section>
		<section>
			Section with no title and no link attribute just html
			content.
		</section>
	</section>
	<section class="main" name="Section with anchor"
		anchor="anchorsection">
		<section name="Duis id justo" link="http://www.eclipse.org">
			Vivamus
			<a href="http://www.eclipse.org">luctus</a>
			tellus in velit. Pellentesque ut
			<a href="http://www.eclipse.org">dui</a>
			. Aliquam malesuada augue vel lorem.
		</section>
		<section name="Integer in velit"
			link="http://www.eclipse.org">
			Nam dignissim. Etiam aliquet, orci sed imperdiet fermentum ,
			massa neque venenatis tellus, at fringilla elit massa a
			nisl. Integer et arcu vitae diam tincidunt interdum. Sed
			tristique erat sed odio. Integer vel pede vitae orci porta
			iaculis. Nulla diam magna, iaculis in, vestibulum vel,
			mollis a, mauris.
		</section>
		<section name="Aliquam enim nibh"
			link="http://www.eclipse.org">
			Aliquam enim nibh, porttitor ac, porttitor at, tincidunt
			lacinia, leo. Nam aliquam auctor odio. Praesent hendrerit
			aliquet velit. Aliquam fringilla, odio vel tincidunt
			condimentum, arcu nibh lobortis neque, a interdum purus eros
			sed turpis. Nunc libero. Nam porta augue quis magna. Sed
			consequat. Nam feugiat sodales nibh. Donec vel neque. Donec
			sollicitudin. Donec fringilla tempor leo. Vivamus enim
			justo, consectetuer eget, semper vulputate, dignissim sit
			amet, ligula. Cras eget velit vel metus imperdiet tincidunt.
			Mauris lacinia, libero id vulputate eleifend, tortor est
			molestie lacus, quis molestie eros sapien in ligula.
		</section>
	</section>
	<section class="main" name="Filler text">
		<description>
			<p>
				Maecenas adipiscing nisi vel enim. Suspendisse potenti.
				Fusce urna urna, aliquam quis, faucibus id, aliquet ac,
				tellus. Etiam vulputate diam ac massa. Praesent
				consequat lacus id erat. Praesent lobortis, magna in
				luctus sagittis, ipsum massa dignissim enim, vel nonummy
				quam nisi at nisl. Duis faucibus, ipsum a cursus
				placerat, eros nunc rutrum sem, nec aliquet quam nunc
				nec urna. Nulla porta venenatis felis. Proin varius
				diam. Donec tempor justo bibendum erat pharetra luctus.
				Nullam varius felis. Fusce suscipit, magna varius
				sodales accumsan, augue dolor congue dui, eget fermentum
				arcu lorem quis est. Pellentesque nec nisi ut est mattis
				interdum. Aliquam magna. Praesent sapien turpis,
				suscipit quis, sagittis sit amet, iaculis ac, velit.
				Vivamus vitae felis vitae erat sodales malesuada. In id
				odio.
			</p>
			<p>
				Phasellus tincidunt, massa eu cursus tempus, enim ipsum
				aliquam sapien, ac euismod felis quam sit amet eros. Sed
				sed pede nec magna pulvinar aliquam. Nunc vehicula
				elementum odio. Proin vehicula. Pellentesque aliquet.
				Donec vitae neque at tortor lacinia tincidunt. In varius
				sodales turpis. Morbi erat. Donec eget turpis. Vivamus
				at justo. Praesent eu est. Donec ut est.
			</p>
			<p>
				Donec purus neque, venenatis quis, mollis sit amet,
				dignissim ut, lacus. Nullam felis urna, bibendum nec,
				imperdiet id, euismod eu, sapien. Mauris neque purus,
				tincidunt eget, adipiscing ac, fermentum dignissim,
				turpis. Nunc ullamcorper, lorem at suscipit ultricies,
				urna arcu porta magna, quis blandit erat lorem sed enim.
				Praesent ipsum. Nulla turpis erat, ornare eu, auctor at,
				pulvinar et, ante. Phasellus quam. Pellentesque
				ultricies aliquet pede. Phasellus vehicula purus sit
				amet pede. Curabitur nec sapien. Curabitur facilisis.
				Etiam quis enim eget ante suscipit egestas. Praesent
				ullamcorper risus ut nibh. Mauris metus.
			</p>
			<p>
				Pellentesque massa. Morbi porta posuere purus. Nulla
				blandit nulla. Donec iaculis ante vestibulum massa.
				Donec enim dui, consequat in, vestibulum ac, bibendum
				sit amet, arcu. Duis egestas purus a arcu. Morbi
				consectetuer, enim tristique feugiat porta, massa metus
				pellentesque nisl, non vulputate sem ante et sapien.
				Etiam et nulla id lacus sodales condimentum. Aenean
				fringilla metus sed nulla vestibulum elementum. Fusce
				consectetuer velit vel diam. Sed vitae ipsum et nisi
				aliquam sollicitudin. Suspendisse sit amet massa eu
				augue ullamcorper ultrices. Vivamus at velit et sem
				commodo tempus. Praesent convallis sagittis dui.
				Pellentesque posuere hendrerit tellus. Nam mauris felis,
				hendrerit quis, lacinia ac, fermentum non, odio.
			</p>
			<p>
				Sed feugiat rhoncus velit. Ut sem libero, aliquam id,
				ultricies non, convallis ullamcorper, odio. Aenean augue
				erat, fermentum tempor, rhoncus nec, ultricies quis,
				nisl. Vivamus pretium sagittis ligula. Maecenas quis
				nibh. Suspendisse potenti. Donec vehicula pede vel diam.
				Lorem ipsum dolor sit amet, consectetuer adipiscing
				elit. Suspendisse non tortor. Quisque lectus est, mattis
				sit amet, pretium at, suscipit nec, turpis. Suspendisse
				potenti. Sed molestie aliquam quam. Suspendisse ac erat
				in metus volutpat ultricies. Etiam non ligula. Mauris
				luctus euismod turpis. Etiam tempus consequat lectus.
				Class aptent taciti sociosqu ad litora torquent per
				conubia nostra, per inceptos hymenaeos. Proin ultrices
				elit.
			</p>
			<p>
				Etiam sit amet nisl eget odio mattis accumsan. Morbi
				sollicitudin, mauris nec adipiscing porta, nisi eros
				imperdiet nisl, in ornare elit tortor id leo.
				Pellentesque vitae massa. Donec augue dolor, vehicula
				in, condimentum at, adipiscing non, lectus. Nam quis
				leo. Mauris at enim quis lacus suscipit malesuada. Fusce
				tincidunt facilisis ipsum. Sed pretium aliquet orci.
				Suspendisse mattis laoreet metus. Fusce auctor bibendum
				magna. Fusce quis velit. Aliquam ullamcorper. Nulla
				vehicula libero ac tellus elementum sagittis. Quisque
				sed arcu eget velit lacinia feugiat.
			</p>
		</description>
	</section>
</sections>
