<html>
<head>
<title>About</title>
<style type="text/css">
p, table, td, th { font-family: arial, helvetica, geneva; font-size: 10pt}
pre { font-family: "Courier New", Courier, mono; font-size: 10pt}
h2 { font-family: arial, helvetica, geneva; font-size: 18pt; font-weight: bold ; line-height: 14px}
code { font-family: "Courier New", Courier, mono; font-size: 10pt}
sup { font-family: arial,helvetica,geneva; font-size: 10px}
h3 { font-family: arial, helvetica, geneva; font-size: 14pt; font-weight: bold}
li { font-family: arial, helvetica, geneva; font-size: 10pt}
h1 { font-family: arial, helvetica, geneva; font-size: 28px; font-weight: bold}
body { font-family: arial, helvetica, geneva; font-size: 10pt; clip: rect(   ); margin-top: 5mm; margin-left: 3mm}
</style>
</head>
<body lang="EN-US" link="blue" vlink="purple">
<table border="0" cellspacing="5" cellpadding="2" width="100%" >
  <tr> 
    <td align="LEFT" valign="TOP" colspan="2" bgcolor="#0080C0"><b><font color="#FFFFFF">About This Content</font></b></td>
  </tr>
  <tr> 
    <td> 
<p>11th December, 2001</p>	
<h3>License</h3>
<p>Eclipse.org makes available all content in this plug-in &quot;Content&quot;.  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
<a href="http://www.eclipse.org/legal/cpl-v05.html">Common Public License Version 0.5</a> &quot;CPL&quot;.  For purposes of the CPL, &quot;Program&quot; will mean the Content.</p>

<h3>Third Party Content</h3>

<p>The Content includes items that have been sourced from third parties as follows:</p>

<p><b>Ant 1.4.1</b></p>
<p>The plug-in is based on software developed by The Apache Software Foundation as part of the Jakarta project.</p>
 
<p>The class PServerConnection &quot;Ant Derivative Work&quot; contained in teamcvs.jar and teamcvssrc.zip is based on Ant code.</p>

<p>The Ant Derivative Work is:</p>

<blockquote>Copyright (c) 1999 The Apache Software Foundation. All rights reserved.</blockquote>

<p>Your use of the Ant Derivative Work, is subject to the terms and conditions of the
<a href="http://jakarta.apache.org/ant/manual/LICENSE">Apache Software License 1.1</a>.
More specifically:</p>
<blockquote>
	1. Redistributions of source code must retain the above copyright notice, this list of<br />
	conditions and the following disclaimer.<br />
<br />
	2. Redistributions in binary form must reproduce the above copyright notice, this list of<br />
	conditions and the following disclaimer in the documentation and/or other materials<br />
	provided with the distribution.<br />
<br />
	3. The end-user documentation included with the redistribution, if any, must include the<br />
	following acknowledgment:<br />
	<blockquote>
		&quot;This product includes software developed by the Apache Software Foundation<br />
		(<a href="http://www.apache.org/">http://www.apache.org/</a>).&quot;
	</blockquote>
	Alternately, this acknowledgment may appear in the software itself, if and wherever such<br />
	third-party acknowledgments normally appear.<br />
<br />
	4. The names &quot;Ant&quot; and &quot;Apache Software Foundation&quot; must not be used to endorse or<br />
	promote products derived from this software without prior written permission. For written<br />
	permission, please contact <a href="mailto:apache@apache.org">apache@apache.org</a>.<br />
<br />
	5. Products derived from this software may not be called &quot;Apache&quot;, nor may &quot;Apache&quot; appear<br />
	in their name, without prior written permission of the Apache Software Foundation.<br />
<br />
	THIS SOFTWARE IS PROVIDED &quot;AS IS&quot; AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT<br />
	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR<br />
	PURPOSE ARE	DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR ITS<br />
	CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR<br />
	CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR<br />
	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON<br />
	ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,	OR TORT (INCLUDING<br />
	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT	OF THE USE OF THIS SOFTWARE, EVEN IF<br />
	ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
</blockquote>

<h3>Contributions</h3>

<p>If this Content is licensed to you under the terms and conditions of the CPL, any Contributions, as defined in the CPL, uploaded, submitted, or otherwise
made available to Eclipse.org, members of Eclipse.org and/or the host of Eclipse.org web site, by you that relate to such
Content are provided under the terms and conditions of the CPL and can be made available to others under the terms of the CPL.</p>

<p>If this Content is licensed to you under license terms and conditions other than the CPL &quot;Other License&quot;, any modifications, enhancements and/or
other code and/or documentation &quot;Modifications&quot; uploaded, submitted, or otherwise made available to Eclipse.org, members of Eclipse.org and/or the
host of Eclipse.org, by you that relate to such Content are provided under terms and conditions of the Other License and can be made available
to others under the terms of the Other License.  In addition, with regard to Modifications for which you are the copyright holder, you are also
providing the Modifications under the terms and conditions of the CPL and such Modifications can be made available to others under the terms of
the CPL.</p>
</td></tr></table>
</body>
</html>