<?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, 24th 2015:</strong>
				JWT 1.5 has been released, along with the latest <a href="http://www.eclipse.org/mars/">Eclipse Mars</a> yearly release that it has been upgraded to.</a>.
				</li>
				<li><strong>June, 25th 2014:</strong>
				JWT 1.4 has been released, along with the latest <a href="http://www.eclipse.org/luna/">Eclipse Luna</a> yearly release, with a special focus on stability.</a>.
				</li>
				<li><strong>June, 26th 2013:</strong>
				JWT 1.3 has been released, along with the latest <a href="http://www.eclipse.org/kepler/">Eclipse Kepler</a> yearly release. One good news following the other, it provides <a href="http://wiki.eclipse.org/JWT_NewNoteworthy_1_3">the most expected BPMN view</a>!
				</li>
				<li><strong>March, 25rd 2013:</strong>
				At Eclipse Con US 2013 in Boston, a few <a href="http://fr.slideshare.net/marcgille7/soa-symposium-eclipse-con-2013">slides</a> (35-37) about JWT integration with the <a href="http://www.easysoa.org">EasySOA Registry service-oriented governance solution</a> (<a href="http://www.easysoa.org/2013/04/eclipse-soa-at-eclipse-con-us-with-a-hint-of-easysoa/">report</a>) were shown in the <a href="http://www.eclipsecon.org/2013/sessions/soa-track">SOA Symposium</a> presented by Marc Gille (Sungard, Stardust BPM), Adrian Mos (Xerox, Mangrove) and Bob Brodt (Red Hat, BPMN2 modeler).

, we furthered our <a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-models-as-operational-documentation">Models as Operational Documentations</a> showcase, and demonstrated integration of <a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-talend-with-easysoa">Talend with EasySOA</a> and at a wider level of SOA design-time and runtime registries.
				</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);
?>
