<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head>


<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>About</title>
</head><body lang="EN-US">
<h2>About This Content</h2>
 
<em>July 25, 2008</em></p>	
<h3>License</h3>

<p>The Eclipse Foundation makes available all content in this plug-in ("Content").  Unless otherwise 
indicated below, the Content is provided to you under the terms and conditions of the
Eclipse Public License Version 1.0 ("EPL").  A copy of the EPL is available 
at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
For purposes of the EPL, "Program" will mean the Content.</p>

<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
being redistributed by another party ("Redistributor") and different terms and conditions may
apply to your use of any object code in the Content.  Check the Redistributor's license that was 
provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
indicated below, the terms and conditions of the EPL still apply to any source code in the Content
and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>

		
		<h3>Third Party Content</h3>
		<p>The Content includes items that have been sourced from third parties as set out below. If you 
		did not receive this Content directly from the Eclipse Foundation, the following is provided 
		for informational purposes only, and you should look to the Redistributor's license for 
		terms and conditions of use.</p>
		<p><em>
		<br><br>
		<strong>OMG MOF 2.0 Specification (06-01-01)</strong> <br>
		<ul>
			<li><a href="http://www.omg.org/technology/documents/formal/mof.htm">MOF 2.0 main page</a></li>
			<li><a href="http://www.omg.org/docs/formal/06-01-01.pdf">MOF 2.0 specification</a></li>
			<li><a href="http://www.omg.org/">OMG site</a></li>
		</ul>
		<br>
		<strong>OMG OCL 2.0 specification (06-05-01)</strong> <br>
		<ul>
			<li><a href="http://www.omg.org/technology/documents/formal/ocl.htm">OCL 2.0 main page</a></li>
			<li><a href="http://www.omg.org/docs/formal/06-05-01.pdf">OCL 2.0 specification</a></li>
			<li><a href="http://www.omg.org/">OMG site</a></li>
		</ul>
		<br>
		<strong>OMG MTL 1.0 specification (08-01-16)</strong> <br>
		<ul>
			<li><a href="http://www.omg.org/spec/MOFM2T/1.0/">MTL 1.0 main page</a></li>
			<li><a href="http://www.omg.org/spec/MOFM2T/1.0/PDF">MTL 1.0 specification</a></li>
			<li><a href="http://www.omg.org/">OMG site</a></li>
		</ul>
		<br>
		</em></p>
		<p>A detailed list of fixes and clarifications with respect to those specifications may be found in the plug-in directly realizing them.</p>
</body></html>