<?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'

	#*****************************************************************************
	#
	# index.php of Java Workflow Tooling (JWT)
	#
	# Author: 		Florian Lautenbacher
	# created:		2007-02-26
	# last changed: 2009-05-25
	#
	# Description: The start 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)
	# Reiniting navbar content (suppresses generic Eclipse links Committers, Newsgroups, Bugs, Articles) :
	# $Nav->setLinkList( array() );

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

	<div id="midcolumn">
		<h1>Java Workflow Tooling (JWT)</h1>
		
		<table>
		<tr><td>
		<p>
		Eclipse SOA's <em> Java Workflow Tooling project (JWT)</em> provides design time, development 
		time and runtime workflow tools. It also fosters <b>interoperability</b> between Business Process Management (<b>BPM</b>) platforms
		and <b>integration</b> in Information Systems thanks to Service Oriented Architecture (<b>SOA</b>).
		</p>

		<p>
 		See more about it at <a href="/jwt/pages/about.php">Why JWT ?</a> and <a href="http://wiki.eclipse.org/JWT_Downloads#Other_products_based_on_JWT">JWT Ecosystem</a>.
		</p>
		</td><td>
		<p>
		<a href="/jwt/images/jwt_screenshot.gif"><img style="width: 141px; height: 100px;" src="/jwt/images/jwt_screenshot_small.gif" align="center" alt="screenshot" /></a>
		</p>
		</td></tr>
		</table>
		
		<!-- p>
		<b>JWT, why ?</b> Business Process Management (BPM) is at the crossroads of business, middleware and integration, so it really shouldn't lock up the options of its actors. That's why JWT-modeled processes can look the way the analyst wants, hold any implementation information the developer adds in, and be deployed to the runtime platform of choice.	
		</p>
		<p>
		<b>JWT, how ?</b> By providing a flexible framework allowing extensible views, model and transformations, that communities and vendors can build on. JWT comes with several built-in extensions like UML Activity Diagram or Event-driven Process Chains (EPC) views, BPMN interoperability, code generation (e.g. XPDL, or WSBPEL-code in the AgilPro integration, but also HTML documentation). There are actually already a few solutions that integrate JWT, such as the SOA-focused Scarbo of the OW2 consortium, or AgilPro in SourceForge.
		</p -->

		<!-- p>
		The <em>Java Workflow Tooling project (JWT)</em> aims to build design time, development 
		time and runtime workflow tools in order to provide a complete, flexible, 
		interoperable <b>Business Process Management (BPM)</b> platform.
		</p>
		
		<table>
		<tr><td>
		<p>
		This is achieved through an extensible architecture allowing to support many 
		different BP representations, format languages and execution engines. The set 
		of JWT tools is meant to allow for "Distribution"-like releases with specific 
		extensions targeting specific platforms or problems, e.g. JWT for SOA. The 
		mission and philosophy of JWT makes it natural complement to other Eclipse 
		projects, such as the friend <a href="http://www.eclipse.org/stp/">SOA Tools Platform Project</a>.
		</p>
		<p>
		Watch our <a href="/jwt/press/eclipsecon09/EclipseCon09Example.swf">demo movie</a> to get a quick overview!
		</p>
		</td><td>
		<p>
		##
		<a href="/jwt/images/jwt_screenshot.gif"><img style="width: 141px; height: 100px;" src="/jwt/images/jwt_screenshot.gif" align="center" alt="screenshot" /></a>
		##
		</p>
		</td></tr>
		</table -->

		<hr class="clearer" />
		
		<div class="homeitem">
			<h3>Getting Started</h3>
			<img align="right" src="/jwt/images/item_download.gif" alt="Getting Started" />
			<ul>
				<li><a href="/jwt/press/eclipsecon09/EclipseCon09Example.swf">Screencast</a></li> 
				<li><a href="/jwt/download.php">Download</a> ( <a href="http://download.eclipse.org/jwt/update-site/">update site</a> ) </li> 
				<li><a href="http://wiki.eclipse.org/JWT_Tutorial">Tutorial</a></li> 
			</ul>
		</div>

		<hr class="clearer" />
		
		<div class="homeitem">
			<h3>Documentation</h3>
			<img align="right" src="/jwt/images/item_documentation.gif" alt="Documentation" />
			<ul>
				<li><a href="/jwt/components/index.php">Overview of JWT Components and Features</a></li>

				<li><a href="http://wiki.eclipse.org/JWT_FAQ">Frequently Asked Questions (FAQ)</a></li> 
				<li><a href="http://wiki.eclipse.org/JWT_Extensions">How to Extend JWT through Plugins</a></li> 
				<li>And more on the <a href="http://wiki.eclipse.org/Java_Workflow_Tooling_Project">Wiki</a></li> 
			</ul>
		</div>

		<hr class="clearer" />

		<div class="homeitem">
			<h3>Community and Development</h3>
			<img align="right" src="/jwt/images/item_community.gif" alt="community" />
			<ul>
				<li><a href="http://www.eclipse.org/projects/project-plan.php?projectid=soa.jwt">Roadmap</a></li> 
				<li><a href="https://dev.eclipse.org/mailman/listinfo/jwt-dev">Mailing List</a> (<a href="http://dev.eclipse.org/mhonarc/lists/jwt-dev/maillist.html">Archive</a>) and <a href="news://news.eclipse.org/eclipse.soa.jwt">Newsgroup</a> ( <a href="http://www.eclipse.org/newsportal/thread.php?group=eclipse.jwt">browse</a> )</li>
				<li><a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&email1=&emailtype1=substring&emailassigned_to1=1&email2=&emailtype2=substring&emailreporter2=1&bugidtype=include&bug_id=&changedin=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&product=JWT&short_desc=&short_desc_type=allwordssubstr&long_desc=&long_desc_type=allwordssubstr&keywords=&keywords_type=anywords&field0-0-0=noop&type0-0-0=noop&value0-0-0=&cmdtype=doit&order=Reuse+same+sort+as+last+time">Open Bugs and Requests</a> (<a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=JWT">Ask for a Feature or Report Bug</a>)</li> 
				<li><a href="http://wiki.eclipse.org/JWT_SVN">Get the Source Code</a> ( <a href="http://dev.eclipse.org/viewcvs/index.cgi/?root=SOA_JWT">browse</a> )</li> 
				<li><a href="http://wiki.eclipse.org/index.php/JWT_DeveloperFAQ">Developer FAQ</a></li>
			</ul>
		</div>
				
		<hr class="clearer">
			
	</div>
	
	<div id="rightcolumn">	

 		<div class="sideitem">
 			<h6>New to JWT?</h6>
 			<ul>
 				<li><a href="http://wiki.eclipse.org/Why_use_JWT">Why Use JWT ?</a></li>
 				<li><a href="/jwt/press/index.php">JWT In The Press</a></li>
 			</ul>
 		</div>
	
		<!--
    	<div class="sideitem">
	 		 div class="sideitem">
				<a href="/jwt/images/jwt_screenshot.gif"><img style="width: 239px; height: 170px;" src="/jwt/images/jwt_screenshot.gif" align="center" alt="screenshot" /></a>
	 		</div> 

   		</div-->
 		
 		<div class="sideitem">
			<h6>What's new</h6>
			<ul>
				<li><strong>June, 22nd 2011:</strong>
				Indigo is here! And with it, the brand new Java Workflow Tooling 1.1 with lots of bugfixes to improve your JWT experience.
				To install, just navigate to the SOA category in the Indigo update site and select JWT.   
				</li>		
				<li><strong>November, 24th 2010:</strong>
				JWT-integrating <a href="http://wiki.scarbo.ow2.org/xwiki/bin/view/OW2+Scarbo+1/2+Release+notes">OW2 Scarbo 1.2</a> is out ! Presented at the <a href="http://www.ow2.org/view/Events2010AnnualConference/">OW2 Conference 2010</a>, it gathers improvements garnered in production environments, and builds on the newly enriched <a href="http://wiki.eclipse.org/JWT_Monitoring#Workflow_State_Model">JWT WorkflowService query API</a>.
				</li>	
				<li><strong>July, 1st 2010:</strong>
				Java Workflow Tooling has graduated to version 1.0! The new version is available from the official update site.  
				</li>		
				<li><strong>June, 24th 2010:</strong>
				HELIOS! It's out and JWT is again included in the Helios repositories (can be found in the SOA category).
				Also, the JWT project will graduate to 1.0 in the next days!  
				</li>		
				<li><strong>March, 24th 2010:</strong>
				EclipseCon presentation <a href="http://www.slideshare.net/mdutoo/eclipsecon2010-painless-metamodel-evolution">slides</a>
				</li>		
				<li><strong>March, 17th 2010:</strong>
				Project leads Marc Dutoo and Christian Saad will be co-presenters at the EclipseCon 2010 <a href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1207">Painless (?) Metamodel Evolution</a>.
				</li>		
				<li><strong>March, 17th 2010:</strong>
				The move review to include JWT in Eclipse SOA was successful.   
				</li>
			    <li><a href="/jwt/newsarchive.php">News archive</a>
			    </li>
			</ul>
		</div>
 		 		
	</div>

EOHTML;

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