<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"> This project was just provisioned.  You can see the proposal 
<a href="/proposals/mangrove">here</a>. 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>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="/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>
		<li><a href="http://dev.eclipse.org/svnroot/stp/org.eclipse.stp.intermediate-model/org.eclipse.stp.model/">Browse STP-IM Source</a> (to be transferred soon to Mangrove's CVS)</li>
	</ul>
</div>

</div>