<?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/index.php of Java Workflow Tooling (JWT)
	#
	# Author: 		Florian Lautenbacher
	# created:		2007-10-12
	#
	# Description: The Eclipse Java Workflow Tooling Press 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.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 Con Europe 2012</h3>
			At Eclipse Con Europe 2012 in Ludwigsburg, we presented in the SOA Symposium track <a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-models-as-operational-documentation">Models as Operational Documentations</a>, or how design-time JWT workflow models can get a new life at operation time thanks to EMF to CMIS export, and how we can combine<a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-talend-with-easysoa">Talend with EasySOA</a> and at a wider level SOA architecture repositories with middleware runtime registries.
		</div>

		<div class="homeitem3col">
			<h3> Eclipse DemoCamp Grenoble 2012</h3>
			Workflow models can have a life after design time: as published documentation. The <a href="http://www.easysoa.org/2012/06/publishing-models-documentation-at-eclipse-juno-democamp-grenoble/">EasySOA</a> team <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-2012ecmv05pub">illustrated as much</a> for JWT at the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Juno_2012/Grenoble">Eclipse DemoCamp Grenoble 2012</a> using a prototype EMF to <a href="https://www.oasis-open.org/committees/cmis/">CMIS</a> export. We also told the educative technical & IP tale of bringing SVG export to JWT (<a href="GEF SVG export in JWT, a newcomer’s rocky ride to Eclipse ">slides</a>).
		</div>

		<div class="homeitem3col">
			<h3> Eclipse DemoCamp Grenoble 2011</h3>
			At the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Indigo_2011/Grenoble">Eclipse DemoCamp Grenoble 2011</a>, we gave a glimpse of our ongoing work with the <a href="http://www.github.com/easysoa">EasySOA</a> community to allow for <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-eclipse-to-easysoa-core">Collaborative SOA from Eclipse to EasySOA Core</a>.
		</div>

		<div class="homeitem3col">
			<h3> Eclipse Con 2010</h3>
			In <a href="http://www.slideshare.net/mdutoo/eclipsecon2010-painless-metamodel-evolution">Painless (?) Metamodel Evolution</a> (<a href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1207">original submission</a>), we presented our ATL-based converter during the Eclipse Con in Santa Clara.
			The presentation can be downloaded on <a href="http://www.slideshare.net/mdutoo/eclipse-summit-2009-aspect-oriented-modeling">SlideShare</a>.
		</div>

		<div class="homeitem3col">
			<h3> Eclipse Summit Europe 2009</h3>
			We presented our <a href="http://www.slideshare.net/mdutoo/eclipse-summit-2009-aspect-oriented-modeling">aspect-oriented extension mechanism</a> (<a href="http://www.eclipsecon.org/summiteurope2009/sessions?id=935">original submission</a>) i.e. the JWT configuration models during the Eclipse Summit in Ludwigsburg.
			The presentation can be downloaded on <a href="http://www.slideshare.net/mdutoo/eclipse-summit-2009-aspect-oriented-modeling">SlideShare</a>.
		</div>

		<div class="homeitem3col">
			<h3> Eclipse Forum Europe 2009</h3>
			JWT was 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>.
			Please find the <a href="/jwt/press/efe09/ExecuteYourProcesses_EFE09_final.pdf">presentation</a> and the shown screencasts (
			<a href="/jwt/press/efe09/01_FromBPMN2JWT.swf">From BPMN to JWT</a>,
			<a href="/jwt/press/efe09/02_ViewsExport.swf">Show different views and export</a>,
			<a href="/jwt/press/efe09/03_Simulate.swf">Simulate the process</a>,
			<a href="/jwt/press/efe09/04_DeployExecute.swf">Deploy and finally execute it</a>).
		</div>

		<div class="homeitem3col">
			<h3> EclipseCon 2009</h3>
			JWT was 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>
			and the presentation <a href="/jwt/press/eclipsecon09/EclipseCon09Presentation.ppt">here</a>.
			The also shown screencast can be viewed as a <a href="/jwt/press/eclipsecon09/EclipseCon09Example.swf">flash movie</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="/jwt/press/ese07/EclipseSummitEurope2007_JWT_presentation.ppt">here</a>.
			The also shown screencast of the workflow editor can be viewed as a <a href="/jwt/press/ese07/TripbookingExample.swf">flash movie</a>.
		</div>	
		
		<div class="homeitem3col">
			<h3> More</h3>
			On the wiki, you can find <a href="http://wiki.eclipse.org/JWT_Press">additional presentations and articles</a>.
		</div>
		<hr class="clearer">	
	</div>
	<div id="rightcolumn">		
  	</div>

EOHTML;


	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
