<?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($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# /press/ese07/index.php of Java Workflow Tooling (JWT)
	#
	# Author: 		Florian Lautenbacher
	# created:		2007-10-12
	#
	# Description: The Eclipse summit Europe 2007 page of the Java Workflow Tooling project
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Eclipse Java Workflow Tooling (JWT)";
	$pageKeywords	= "JWT , Java Workflow Tooling Project, Workflow Editor, Workflow Administration and Monitoring, Eclipse";
	$pageAuthor		= "Florian Lautenbacher";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
	# $Nav->addNavSeparator("		Getting started", 	"/jwt/index.php");
	# $Nav->addCustomNav("		About JWT", 		"/jwt/about.php", "_blank", 3);
	# $Nav->addNavSeparator("		Development", 		"/jwt/index.php");
	# $Nav->addCustomNav("		Team/Committers", 	"/jwt/team.php", "_blank", 3);
	# $Nav->addCustomNav("		Wiki", 				"http://wiki.eclipse.org/index.php/Java_Workflow_Toolbox_Project", "_blank", 3);
	# $Nav->addCustomNav("		Newsgroup", 		"http://www.eclipse.org/newsportal/thread.php?group=eclipse.technology.jwt", "_blank", 3);
	# $Nav->addCustomNav("		Bugs", 				"http://bugs.eclipse.org/bugs/", "_blank", 3);

	# End: page-specific settings
	#
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

<div id="midcolumn">
		<h1>Java Workflow Tooling (JWT)</h1>

		<div class="homeitem3col">
			<h3> Eclipse Forum Europe 2009</h3>
			JWT will be presented at Eclipse Forum Europe 2009 in Mainz, Germany. See an abstract of this session <a href="http://it-republik.de/konferenzen/efe/sessions/?tid=1077#session-2">here</a>.
		</div>

		<div class="homeitem3col">
			<h3> EclipseCon 2009</h3>
			JWT will also be presented at EclipseCon 2009 in Santa Clara, CA, USA. See an abstract of this presentation <a href="http://www.eclipsecon.org/2009/sessions?id=292">here</a>.
		</div>

		<div class="homeitem3col">
			<h3> Eclipse Summit Europe 2008</h3>
			JWT was also presented during Eclipse Summit Europe in 2008: Marc Dutoo had the chance to talk 10 minutes
			about JWT in the session "STP News and Noteworthy" (thanks to Oisin Hurley!).
		</div>
		
		<div class="homeitem3col">
			<h3> Eclipse Summit Europe 2007</h3>
			At the 11th of October 2007 Florian Lautenbacher, one of the two project leads of the Java
			Workflow Tooling project, held a presentation about the plans in JWT at the <a href="http://www.eclipsecon.org/summiteurope2007/index.php?page=detail/&id=61">Eclipse Summit Europe 2007</a> 
			in Ludwigsburg, Germany.
			<br/>
			The presentation was a success with many questions afterwards. So it seems the Eclipse community
			is quite interested in the progress of our project.
			<br/>
			Please find the presentation <a href="EclipseSummitEurope2007_JWT_presentation.ppt">here</a>.
			The also shown screencast of the workflow editor can be viewed as a <a href="TripbookingExample.swf">flash movie</a>.
		</div>	
		<hr class="clearer">	
	</div>
	<div id="rightcolumn">		
    	 <div class="sideitem">
   			<h6>Incubation</h6>
   			<div align="center"><a href="/projects/what-is-incubation.php"><img 
        			align="center" src="/images/egg-incubation.png" 
        			border="0" alt="Incubation" /></a></div>
 		</div>       		
	</div>

EOHTML;


	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>