<?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 In Action";
	$pageKeywords	= "eclipse, helios, action, webinar, release, virtual conference";
	$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>
		On June 24, the Eclipse Foundation is presenting Helios In Action - a virtual
      	conference where you can interact with project leads involved in the release and see
      	demos of the new features. The annual simultaneous release has now grown to 39 projects
      	with over 33 million lines of code, contributed by committers around the world.  With such
      	a large global community, Eclipse wants to bring Helios to you!
      	</p>

      	<p> 
      	<a href="http://eclipse.org/go/heliosinaction" target="blank">
      	<img src="images/button_register.gif" style="padding-right: 25px;" alt="Register" border="0"></a>
      	</p>

 		<p>Helios In Action is free to attend and registering gets you into all 8 sessions:</p>

		<table cellspacing=2>

			<tr>
				<td width="35%">
					<a class="title" href="javascript:switchMenu('linux');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					Linux Tools</a><br>
					Andrew Overholt (Red Hat)
				</td>
				<td width="26%">
					10:00am EDT / 4:00pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=14&min=0&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">
					<div id="linux" class="switchcontent">
					The Linux Tools project aims to bring a full-featured C and C++ IDE to Linux developers. It
					builds on the source editing and debugging features of the CDT and integrates popular
					native development tools such as the GNU Autotools, Valgrind, OProfile, RPM, SystemTap,
					GCov, GProf and LTTng. Current projects include Autotools build integration, a Valgrind
					heap usage analysis tool and an OProfile call profiling tool. It also has projects
					implementing LTTng trace viewers and analyzers.
					<br><br>
					Linux Tools also provides a place for Linux distributions to collaboratively overcome issues
					surrounding distribution packaging of Eclipse technology. The project produces both best
					practices and tools related to packaging. Since the 0.3.0 release, one of the features is
					a source archive of the Eclipse SDK that can be used by all Linux distributions building
					and distributing it. 
					</div>
				</td>
			</tr>

			<tr>
				<td>
					<a  class="title" href="javascript:switchMenu('emf');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					EMF Code Generation Capabiities</a><br>
					Kenn Hussey (Cloudsmith)
				</td>
				<td>
					10:30am EDT / 4:30pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=14&min=30&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">													
					<div id="emf" class="switchcontent">
					The EMF code generation facility is capable of generating everything needed to build a
					complete editor for an EMF model. It includes a GUI from which generation options can be
					specified, and generators can be invoked. The generation facility leverages the JDT
					(Java Development Tooling) component of Eclipse.
					<br><br>
					Three levels of code generation are supported: model, adapters and editor. All generators
					support regeneration of code while preserving user modifications. The generators can be
					invoked either through the GUI or headless from a command line.	
					<br><br>	
					</div>
				</td>
			</tr>			

			<tr>
				<td>
					<a  class="title"href="javascript:switchMenu('egit');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					Eclipse Git Team Provider</a><br>
					Chris Aniszczyk (Red Hat)				
				</td>
				<td>
					11:00am EDT / 5:00pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=15&min=00&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">													
					<div id="egit" class="switchcontent">
					EGit is an Eclipse Team provider for the Git version control system. Git is a distributed
					SCM, which means every developer has a full copy of all history of every revision of the
					code, making queries against the history very fast and versatile. 
					<br><br>
					The EGit project is implementing Eclipse tooling on top of the JGit Java implementation of
					Git. 
					<br><br>
					</div>
				</td>
			</tr>

			<tr>
				<td>
					<a class="title" href="javascript:switchMenu('jsdt');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					JavaScript Development Tools</a><br>
					Simon Kaegi (IBM)
				</td>
				<td>
					11:30am EDT / 5:30pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=15&min=30&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">													
					<div id="jsdt" class="switchcontent">
					With the advent of Web 2.0, JavaScript have become central in the creation of a richer user
					experience on the Web. Its use has shifted from the creation of simple functions and events
					handlers to the creation of complex Web Application frameworks. Such complexity made it crucial
					that a more sophisticated set of tools become available on Eclipse.
					<br><br>
					JSDT's goal is to develop an IDE for JavaScript applications, with full support for editing, search,
					and refactoring. The functionality of the JavaScript Development Tools is heavily based on the
					functionality of the Java Development Tools, but since JavaScript is not a fully typed or
					class-based language, it is not possible to provide 100% of the JDT functionality. JSDT is
					extensible in that it can be (is) plugged into the HTML and JSP editors within WTP as well as being
					architected with pluggable type inference and completion proposals in mind. The inference engine is
					used to determine type and class structures from the JavaScript code, enabling as much of the JDT
					equivalent functionality as possible, while still allowing adopters to contribute to the process for
					atypical or extended scenarios. 
					<br><br>
					</div>
				</td>
			</tr>

			<tr>
				<td>
					<a  class="title" href="javascript:switchMenu('javaee');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					Java EE Standards Support from Web Tools</a><br>
					Naci Dai (eteration)
				</td>
				<td>
					12:00pm EDT / 6:00pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=16&min=00&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">													
					<div id="javaee" class="switchcontent">
					The Web Tool Platform (WTP) project provides extensible frameworks and exemplary tools
					to build Web and Java EE applications.  For Helios, the Web Tools Platform will be
					up-to-date with supporting the latest Java EE 6 specification.  Join this session to
					see what's newly available for Java EE development.
					<br><br>
					</div>
				</td>
			</tr>

			<tr>
				<td>
					<a class="title" href="javascript:switchMenu('mpc');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					Marketplace Client & p2 Discovery Connector</a><br>
					Mik Kersten (Tasktop Technologies)
				</td>
				<td>
					12:30pm EDT / 6:30pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=16&min=30&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">													
					<div id="mpc" class="switchcontent">
					The Eclipse community has hundreds, if not thousands, of third-party plugins that users can
					add to their Eclipse installation. Unfortunately, there is not easy way to discover and
					install these solutions from within Eclipse.
					<br><br>
					The Eclipse Foundation has recently launched a new website, called Eclipse Marketplace, that
					provides a listing of Eclipse-based solutions. The listings allow each solution provider to
					specify a p2 update site for their solution. MPC provides a tight install integration
					between the Eclipse workspace and Eclipse Marketplace, plus other third party solution
					listings.  	 
					<br><br>
					</div>
				</td>
			</tr>

			<tr>
				<td>
					<a class="title" href="javascript:switchMenu('modeling');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					Modeling</a><br>
					Ed Merks
				</td>
				<td>
					1:00pm EDT / 7:00pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=17&min=00&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">													
					<div id="modeling" class="switchcontent">
					The Eclipse Modeling Project is one of the most active projects within the Eclipse
					community. Ed Merks, lead of the Modeling project, will present some of the new features
					the Helios release is providing and will provide demos and real-world examples to help you
					discover modeling tools you can use. 	 
					<br><br>
					</div>
				</td>
			</tr>

			<tr>
				<td>
					<a class="title" href="javascript:switchMenu('runtime');" title="Description">
					<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
					Eclipse Runtime (RT)</a><br>
					Jeff McAffer (EclipseSource)
				</td>
				<td>
					1:30pm EDT / 7:30pm CEST<br>
					<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=6&day=24&year=2010&hour=17&min=30&sec=0&p1=0">Convert to other time zones</a></span>
				</td>
			</tr>
			<tr>
				<td colspan="2">													
					<div id="runtime" class="switchcontent">
					With the Eclipse community expanding its offerings in the Runtime space (EclipseRT),
					many developers are interested in figuring out what this means and how they can
					leverage EclipseRT projects like Equinox, Jetty and EclipseLink. Join Jeff McAffer,
					the RT PMC and Equinox co-lead, for a review of EclipseRT projects and the new
					features they bring to Helios.  	
 					<br><br>
					</div>
				</td>
			</tr>
						
		</table>	 			
 		
 		<p>To attend, register at <a href="http://eclipse.org/go/heliosinaction" target="blank">
 		http://eclipse.org/go/heliosinaction</a>.</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);
?>
