<?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>
		The <em>Java Workflow Tooling project (JWT)</em> aims to build design time, development 
		time and runtime workflow tools and to foster an ecosystem of interoperable BPM platforms.
		</p>
		<p>
 		See more about it at <a href="">Why JWT ?</a> and <a href="">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.gif" align="center" alt="screenshot" /></a>
		</p>
		</td></tr>
		</table>
		
		<!-- p>
		The <em>Java Workflow Tooling project (JWT)</em> aims to build design time, development 
		time and runtime workflow tools and to foster an ecosystem of interoperable BPM platforms.
		</p>
		<p>
 		See more about it at <a href="">Why JWT ?</a> and <a href="">JWT Ecosystem</a>.
		</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/technology/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="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.technology.jwt">Newsgroup</a> ( <a href="http://www.eclipse.org/newsportal/thread.php?group=eclipse.technology.jwt">browse</a> )</li>
				<li><a href="http://wiki.eclipse.org/JWT_CVS">Get the Source Code</a> ( <a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jwt/?root=Technology_Project">browse</a> )</li> 
				<li><a href="http://wiki.eclipse.org/JWT_Upcoming_Release">Upcoming Release Information</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/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 -->

   			<h6>Incubation</h6>
   			<div align="center">
   				<a href="/projects/what-is-incubation.php"><img align="center" src="http://www.eclipse.org/images/egg-incubation.png" border="0" alt="Incubation" /></a>
   			</div>
			<div align="center">  
		 		This project is in the 
		 		<a href="/projects/dev_process/validation-phase.php">Incubation Phase</a>
	       		</div>
 		</div>
 		
 		<div class="sideitem">
			<h6>What's new</h6>
			<ul>
				<li><strong>June, 2nd 2009:</strong>
				on June, the 24th, JWT will be available bundled in the yearly <a href="http://www.eclipse.org/galileo/">Eclipse 3.5 (Galileo)</a> release.
				<a href="http://www.eclipse.org/downloads/?tab=developer">Try it now</a> ! ( <a href="http://wiki.eclipse.org/JWT_NewNoteworthy_0_6">New features</a> )</a>
				</li>
				<li><strong>April, 23rd 2009:</strong> 			JWT was presented at Eclipse Forum Europe 2009 in Mainz, Germany. 
				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">1</a>,
				<a href="/jwt/press/efe09/02_ViewsExport.swf">2</a>,
				<a href="/jwt/press/efe09/03_Simulate.swf">3</a>,
				<a href="/jwt/press/efe09/04_DeployExecute.swf">4</a>).
				</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);
?>
