<div id="bigbuttons">
<h3>Primary Links</h3>
<ul>
	<li><a id="buttonDownload" href="download.php" title="Download">Eclipse
	Distribution, Update Site, Dropins</a></li>
	<li><a id="buttonDocumentation" href="documentation.php"
		title="Documentation">Tutorials, Examples, Videos, Reference Documentation</a></li>
	<li><a id="buttonSupport" href="midcolumn_example.php" title="Download">Bug
	Tracker, Newsgroup, Professional Support</a></li>
	<li><a id="buttonInvolved" href="getting_involved.php" title="Getting Involved">CVS,
	Workspace Setup, Wiki, Committers</a></li>
</ul>
</div>

<div id="midcolumn">
<h3>Mangrove - SOA Modeling Framework</h3>
<div id="introText">

<p class="left">Mangrove is a framework for integrating design and runtime artifacts that are being 
created or used in different Eclipse editors and runtimes related to SOA. It is a subproject of the  
<a href="/soa">SOA top-level project</a>.</p>

<p class="right"> The video below illustrates some of the functionality available in Mangrove. 
A comprehensive tutorial will be posted on this website soon. 
</p>

</div>

 

<div id="screencast">
<object width="640" height="480"><param name="allowfullscreen" value="true" /><param name="allowscriptaccess" value="always" /><param name="movie" value="http://vimeo.com/moogaloop.swf?clip_id=12236080&amp;server=vimeo.com&amp;show_title=1&amp;show_byline=1&amp;show_portrait=0&amp;color=&amp;fullscreen=1" /><embed src="http://vimeo.com/moogaloop.swf?clip_id=12236080&amp;server=vimeo.com&amp;show_title=1&amp;show_byline=1&amp;show_portrait=0&amp;color=&amp;fullscreen=1" type="application/x-shockwave-flash" allowfullscreen="true" allowscriptaccess="always" width="640" height="480"></embed></object><p><a href="http://vimeo.com/12236080">Connecting BPMN and SCA with Mangrove</a> from <a href="http://vimeo.com/user3956062">Adrian Mos</a> on <a href="http://vimeo.com">Vimeo</a>.</p>
</div>


</div>

<div id="rightcolumn">


<div id="headlines">
<h3>New and Noteworthy</h3>
<p>A lot of exciting things are in the works for Mangrove, including features related to BPM governance. Stay tuned!</p> 
<p>DSL Connectivity through Mangrove was presented at EclipseCON Europe during the <a href="http://www.eclipsecon.org/europe2012/sessions/soa-track-mutiple-sessions">SOA Symposium</a>. Slides available soon.</p>
<p>The new <a href="editor.php">Mangrove Editor</a> is almost finished. You can use it to view and edit the contents of your Mangrove instance!</p>
<p>Mangrove was presented at <a href="http://www.eclipsecon.org/2010/">EclipseCON 2010</a>. Check out the <a href="http://www.eclipsecon.org/2010/sessions/?page=sessions&id=1184">Mangrove overview presentation</a> 
and the overall <a href="http://www.eclipsecon.org/2010/sessions/?page=sessions&id=1180">Eclipse SOA project presentation</a>.</p>
</div>

<div id="headlines">
<h3>Mangrove on the Web</h3>
<p>An interview about Mangrove has been posted <a href="http://www.thebitsource.com/programming-software-development/the-eclipse-mangrove-soa-modeling-framework/">on TheBitsource.com</a>.</p>
</div>

<div id="headlines">
<h3>Eclipse Live Webinar</h3>
<img src="images/iconWebinar.gif" style="float: left; margin-right: 8px;"/>
<p>
	<a href="http://live.eclipse.org/node/505" style="display: block;">
		Bridging SOA Editors in Eclipse STP with the Intermediate Model<br/>
	</a>
This older but still very relevant webinar presents the precursor of Mangrove, the STP Intermediate Model. It starts with an overview of the 
project and then continues with a practical demonstration of how it can be leveraged when developing SOA elements with several STP editors.
</p>
</div>

<div id="headlines">
<h3>Useful Links</h6>
	<ul>
		<li><a href="http://dev.eclipse.org/svnroot/soa/org.eclipse.mangrove/">Browse Mangrove Sources</a></li>
		<li><a href="/projects/project_summary.php?projectid=soa.mangrove">About This Project</a></li>
		<li><a href="http://wiki.eclipse.org/STP_Intermediate_Metamodel">Older STP-IM wiki</a></li>
	</ul>
</div>

</div>