<?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'

	#*****************************************************************************
	#
	# /components/transformations/index.php of Java Workflow Tooling (JWT)
	#
	# Author: 		Florian Lautenbacher
	# created:		2007-10-12
	#
	# Description: The Transformations 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)

	# End: page-specific settings
	#
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

<div id="midcolumn">
		<h1>Java Workflow Tooling (JWT)</h1>

		<table border="0">
			<td valign="top" >
				<div align="justify">
					<p>
						Currently there are already several transformations available: building on a transformation base plugin
						it is now possible to transform the JWT-model into <a href="http://www.eclipse.org/stp/bpmn/">BPMN</a>
						and vice versa, or export it to the STP Intermediate Model (IM) format,
						or to generate <a href="http://www.wfmc.org/standards/xpdl.htm">XPDL</a>-code. 
						These transformations are already part of JWT since version 0.5.
					</p>
					<p>
						In addition, we are currently working on new transformations such as from 
						from JWT to jBoss jBPM's<a href="http://www.jboss.org/jbossjbpm/">jPDL</a> format, etc.
						Testers are welcome !
					</p>
				</div>
			</td>
		</table>

		
		<div class="homeitem3col">
			<h3> JWT to BPMN (and vice versa)</h3>
			<p>
			The Business Process Modeling Notation (BPMN) is a standard of the <a href="http://www.bpmn.org/">Object Management Group (OMG)</a>.
			It allows to model business processes independently of their technical realization using several constructs. BPMN has currently version <a href="http://www.bpmn.org/Documents/BPMN%201-1%20Specification.pdf">1.1</a>,
			but version <a href="http://www.bpmn.org/Documents/BPMN%202-0%20RFP%2007-06-05.pdf">2.0</a> is already under development.
			The STP <a href="http://www.eclipse.org/stp/bpmn/">BPMN modeler</a> builds on BPMN 1.1 and using our transformations one can model a process in JWT and
			transform it into BPMN. A transformation the other way round is now also available.
			</p>
			<p>
			The following shows the same process in both modeling languages. First, we show the BPMN process model.
   			<div align="center">
   			  <img align="center" width=678 src="/jwt/images/BPMN-sample.png" border="0" alt="BPMN process"/>
   			</div>
   			</p>
   			<p>
			Exactly the same can also be modeled with JWT:
   			<div align="center">
   			  <img align="center" width=678 src="/jwt/images/JWT-sample.png" border="0" alt="JWT process"/>
   			</div>
   			</p>
		</div>	

		<div class="homeitem3col">
			<h3> JWT to STP-IM</h3>
			<p>
			<a href="http://wiki.eclipse.org/STP_Intermediate_Metamodel">STP-IM</a>, the Intermediate model of the <a href="http://www.eclipse.org/stp/">SOA Tools Platform</a> project allows
			the existing components of STP (such as editors for the service component architecture, the business process modeling notation, etc.) to be transformed into another.
			In order to be integrated with the STP components, there also exists a transformation from JWT to STP-IM.
			</p>
		</div>	

		<div class="homeitem3col">
			<h3> JWT to XPDL</h3>
			<p>
			Besides the above described model-to-model transformation, we also allow for model-to-text transformation. It is possible to
			transform the modeled JWT process into the <a href="http://www.wfmc.org/xpdl.html">XML Process Definition Language (XPDL)</a>.
			This cannot be shown graphically of course, you need to test it yourself! The generated code has been adapted to the process
			engine <a href="http://wiki.bonita.objectweb.org/xwiki/bin/view/Main/">Bonita</a>, but other process engines will be supported soon, too. 		
			</p>
		</div>	

		<div class="homeitem3col">
			<h3> JWT to jPDL</h3>
			<p>
			Also using model-to-text transformation, we're working with jBoss on testing a new transformation to the jPDL format, which allows to deploy workflows on the jBoss jBPM engine.
			</p>
		</div>	


		<hr class="clearer">	
</div>
	
	<div id="rightcolumn">
 	</div>

EOHTML;


	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
