<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include("_projectCommon.php");    # All on the same line to unclutter the user's desktop'

	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Helios Demos";
	$pageKeywords	= "eclipse, helios, demo, video, release";
	$pageAuthor		= "Lynn Gayowski";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank)
	# $Nav->addCustomNav("My Link", "mypage.php", "_self");
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank");

	# End: page-specific settings
	#
	
	# Paste your HTML content between the EOHTML markers!	

ob_start();
?>		

<style type="text/css">
.switchcontent{display:none;}
</style>

<script type="text/javascript">
function switchMenu(obj) {
	var el = document.getElementById(obj);
	el.style.display = ( el.style.display != "block" )? 'block':'none' 
}
</script>	
	
	<style>
		.paddedlist li {	padding-bottom:7px;	}
		td a { color:#000; }		
		.title { font-size:14px; color:#7036be; }
		.timezone { font-size:10px; text-decoration:underline; }
	</style>	

	<div id="maincontent">
	<div id="fullcolumn">
	<div id="midcolumn">
	
		<h1><?= $pageTitle ?></h1>

      	<p>
		Some of the projects involved in the Helios release have created demos to show their new features.
		Click the titles below to see video highlights of what's new in Helios.
      	</p>

		<h3><a href="http://live.eclipse.org/node/932" target="blank">Dali Java Persistence Tools</a></h3>
		<p><b>Neil Hauge, Oracle</b><br>
		18:19 minutes</p>
		<p>Dali Java Persistence Tools simplify the development of Java SE, EE and OSGi bundle applications
		that use the Java Persistence API (JPA) to interact with relational data. Dali has added
		comprehensive JPA 2.0 support to the existing JPA 1.0 support in Helios, as well as specific support
		for the EclipseLink 2.1 Helios release. This demo will show some highlights of the new features
		available now in the Helios release.</p>
      	
		<h3><a href="http://live.eclipse.org/node/912" target="blank">Eclipse Communication Framework (ECF)</a></h3>
		<p><b>Wim Jongman, Industrial TSI</b><br>
		19:37 minutes</p>
		<p>The Eclipse Communication Framework (ECF) is a framework for supporting the development of
		distributed Eclipse-based tools and applications. It can be used to create other plugins, tools or
		full Eclipse RCP applications that require asynchronous point-to-point or publish-and-subscribe
		messaging. This demos hows what's new in ECF for Eclipse 3.6, the Helios release.</p>

		<h3><a href="http://live.eclipse.org/node/908" target="blank">Java Devlopment Tools (JDT)</a></h3>
		<p><b>Deepak Azad, IBM</b><br>
		09:29 minutes</p>
		<p>The Java Development Tools (JDT) project provides the tool plug-ins that implement a Java IDE
		supporting the development of any Java application, including Eclipse plug-ins. It adds a Java
		project nature and Java perspective to the Eclipse Workbench as well as a number of views,
		editors, wizards, builders and code merging and refactoring tools. The JDT project allows Eclipse
		to be a development environment for itself. This video shows just a part of all the new stuff
		within JDT for Helios.</p>
		
		<h3><a href="http://live.eclipse.org/node/911" target="blank">Javaserver Faces (JSF) Tools</a></h3>
		<p><b>Cameron Bateman, Oracle</b><br>
		20:53 minutes</p>
		<p>The Javaserver Faces (JSF) Tools project adds comprehensive support to the Eclipse Web Tools
		Platform project to simplify development and deployment of JSF applications. The project provides
		an extensible tooling infrastructure and exemplary tools for building JSF-based, web-enabled
		applications. This demo previews new features in the Eclipse 3.6 Helios release and shows how
		to use them to build a JSF application.</p>

		<h3><a href="http://live.eclipse.org/node/909" target="blank">PHP Devlopment Tools (PDT)</a></h3>
		<p><b>Roy Ganor, Zend</b><br>
		11:54 minutes</p>
		<p>Summarizing a great year for both the Eclipse and PHP communities, the Eclipse PHP Development
		Tools (PDT) project provides even more source editing features for the PHP developers such as new
		template content assist and advanced syntax coloring. Our focus on quality has proven to be
		immensely successful. With over 400 issues fixed and over 50 enhancements contributed by the
		community, PDT is more stable than ever.</p>

		<h3><a href="http://live.eclipse.org/node/904" target="blank">Rich Ajax Platform (RAP)</a></h3>
		<p><b>RAP Team</b><br>
		04:15 minutes</p>
		<p>This video shows what's new in RAP 1.3, which is shipped within the Eclipse Helios (3.6)
		release train. What's shown in the video is just a part of all the new stuff within RAP 1.3.
		Visit the project's website for more information: <a href="http://eclipse.org/rap" target="blank">http://eclipse.org/rap</a>.</p>

		<h3><a href="http://live.eclipse.org/node/928" target="blank">Sequoyah</a></h3>
		<p><b>Marcel Gorri, Motorola</b><br>
		07:57 minutes</p>
		<p>The purpose of the Sequoyah project is to be focused on the needs of all mobile developers.
		Inheriting components from the TmL, MTJ and Pulsar projects, Sequoyah intends to remove the
		artificial barriers of Linux and Java in order to provide a home for all Eclipse mobile developers.
		Join the Sequoyah team for an overview of the new features in the project for the Eclipse Helios
		release.</p>

 	<br><br>
	</div>
	</div>
</div>

<?php
	$html = ob_get_contents();
	ob_end_clean();

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
