<?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'
/*******************************************************************************
 * Copyright (c) 2010 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors: Adrian Mos
 *    
 *******************************************************************************/

	$pageTitle 		= "Mangrove Editor - Connect your BPM and SOA Visually";
	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');

	$html  = <<<EOHTML
<div id="midcolumn">
<h2>$pageTitle</h2>
<p>The new Mangrove Editor is almost ready! It allows graphical editing of the contents of your Mangrove instance. You can:
	<ul>
		<li>Inspect the SOA and BPM artifacts you have built in the workspace using Eclipse SOA editors</li>
		<li>Create, Update or Delete elements such as business processes, activities and services</li>
		<li>Connect to your SOA repository to get the most commonly used services that make sens in your workspace and have them available in the Mangrove palette</li>
	</ul>
	
To get a glimpse of the functionalities of the new editor, read the scenario below.	
	
<h3>Mangrove Editor Usage Scenario</h3>
This scenario involves the following steps:
	<ol>
		<li>Creation of a simple process in BPMN</li>
		<li>Generation and visualization of the corresponding Mangrove instance in the Mangrove Editor</li>
		<li>Adding services to the diagram from the Mangrove Editor palette</li>
		<li>Connecting process steps to services</li>
	</ol>

<h3>Simple Process in BPMN</h3>
<img src="images/travel-bpmn.JPG" style="float: left; margin-right: 8px;"/>

<h3>Generation and Visualization of the Mangrove Instance</h3>
<img src="images/mangrove-editor-services-empty.JPG" style="float: left; margin-right: 8px;"/>

<h3>Adding Services</h3>
Using an external wizard (not shown), the Mangrove palette can be enriched to contain services from the SOA repository that are widely used in the workspace. The tooltips associated to the service entries in the palette show their repository (or public) location.

<img src="images/palette.JPG" style="float: left; margin-right: 8px;"/>

They can then be added to the actual Mangrove diagram, making them available for connections with business process' steps.

<img src="images/mangrove-editor-added-services.JPG" style="float: left; margin-right: 8px;"/>

<h3>Connecting Process Steps to Services</h3>
Once the services are available in the diagram, they can be connected to the appropriate process activities. This would ensure they are visible in all the appropriate editors (BPMN, SCA or others) that need to be aware of these connections. 
<img src="images/mangrove-editor-added-service-connections.JPG" style="float: left; margin-right: 8px;"/>


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