<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
<html>
<head>
<meta http-equiv=Content-Type content="text/html; charset=utf-8">
<title>Contrat d'utilisation du logiciel d'Eclipse.org</title>
</head>

<body lang="FR-FR" link=blue vlink=purple>
<h2>Contrat d'utilisation du logiciel de la fondation Eclipse</h2>
<p>17 mars 2005</p>

<h3>Utilisation du contenu</h3>

<p>LA FONDATION ECLIPSE FOURNIT DES LOGICIELS, DE LA DOCUMENTATION, DES INFORMATIONS ET/OU D'AUTRES DOCUMENTS DESTINES A DES PROJETS A SOURCE OUVERTE (COLLECTIVEMENT &quot;CONTENU&quot;). L'UTILISATION DU CONTENU EST REGI PAR LES TERMES ET CONDITIONS DE CE CONTRAT ET/OU LES TERMES ET CONDITIONS DES CONTRATS DE LICENCE OU DES MODALITES INDIQUEES OU REFERENCEES CI-DESSOUS. EN UTILISANT LE CONTENU, VOUS ACCEPTEZ QUE VOTRE UTILISATION DU CONTENU SOIT REGIE PAR CE CONTRAT ET/OU LES TERMES ET CONDITIONS DE TOUT CONTRAT DE LICENCE APPLICABLE OU DE TOUTE MODALITE INDIQUEE OU REFERENCEE CI-DESSOUS. SI VOUS N'ACCEPTEZ PAS LES TERMES ET CONDITIONS DE CE CONTRAT ET LES TERMES ET CONDITIONS DE TOUT CONTRAT DE LICENCE APPLICABLE OU DES MODALITES INDIQUEES OU REFERENCEES CI-DESSOUS, N'UTILISEZ PAS LE CONTENU.</p>
   
<h3>Licences applicables</h3>   
   
<p>Sauf indication contraire, tout contenu mis à disposition par la Fondation Eclipse vous est fourni conformément aux termes et conditions d'Eclipse Public License Version 1.0
   (&quot;EPL&quot;). Une copie de l'EPL est fournie avec ce contenu, vous pouvez également la consulter à l'adresse suivante : <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
Dans le cadre de l'EPL, le terme &quot;Programme&quot; signifie "Contenu".</p>

<p>Le contenu inclut, sans s'y limiter, le code source, le code objet, la documentation et les autres fichiers figurant dans le référentiel (&quot;Référentiel&quot;) CVS du site Eclipse.org et dans les modules CVS
(&quot;Modules&quot;) et mis à disposition sous forme d'archives téléchargeables (&quot;Téléchargements&quot;).</p>
   
<ul>
	<li>Le contenu peut être structuré et mis en forme dans des modules pour faciliter la livraison, le développement et la mise à niveau du contenu. Des modules classiques peuvent inclure des plug-ins (&quot;Plug-ins&quot;), des fragments de plug-in (&quot;Fragments&quot;) ainsi que des fonctions (&quot;Fonctions&quot;).</li>
	<li>Chaque plug-in ou fragment peut être mis en forme en tant que sous-répertoire ou JAR (Archive Java&trade;) dans un répertoire dénommé &quot;plug-ins&quot;.</li>
	<li>Une fonction regroupe un ou plusieurs plug-ins et/ou des fragments et des documents associés. Chaque fonction peut être mise en forme en tant que sous-répertoire dans un répertoire dénommé &quot;fonctions&quot;. Dans une fonction, les fichiers dénommés &quot;feature.xml&quot; peuvent contenir une liste des noms et numéros de version des plug-ins
      et/ou des fragments associés à cette fonction.</li>
	<li>Les fonctions peuvent également inclure d'autres fonctions (&quot;Fonctions incluses&quot;). Dans une fonction, les fichiers dénommés &quot;feature.xml&quot; peuvent contenir une liste des noms et numéros de version des fonctions incluses.</li>
</ul>   
 
<p>Les termes et conditions régissant les plug-ins et les fragments doivent figurer dans les fichiers dénommés &quot;about.html&quot; (&quot;A propos de&quot;). Les termes et conditions régissant les fonctions et
les fonctions incluses doivent figurer dans les fichiers dénommés &quot;license.html&quot; (&quot;Licences des fonctions&quot;). Les informations produit (A propos de) et les licences des fonctions peuvent se trouver dans n'importe quel répertoire de téléchargement ou de module
y compris, mais non limité aux emplacements suivants :</p>

<ul>
	<li>Le répertoire de niveau supérieur (racine)</li>
	<li>Les répertoires de plug-ins et de fragments</li>
	<li>Les plug-ins et les fragments internes mis en forme en tant que JAR (archives Java)</li>
	<li>Les sous-répertoires du répertoire dénommé &quot;src&quot; de certains plug-ins</li>
	<li>Les répertoires de fonctions</li>
</ul>
		
<p>Remarque : si une fonction fournie par la Fondation Eclipse est installée à l'aide du gestionnaire de mise à jour d'Eclipse, vous devez accepter la licence (&quot;Licence de mise à jour de la fonction&quot;) lors du
processus d'installation. Si la fonction contient des fonctions incluses, la licence de mise à jour de la fonction doit vous fournir les termes et conditions régissant les fonctions incluses ou vous informer de l'endroit où ils se trouvent. Les licences de mise à jour de la fonction se trouvent dans la propriété &quot;licence&quot; des fichiers dénommés &quot;feature.properties&quot; figurant dans une fonction.
De telles informations produit (A propos de), licences de fonctions et licences de mises à jour de la fonction contiennent les termes et conditions (ou les références aux dits termes et conditions) qui régissent votre utilisation du contenu associé dans ce répertoire.</p>

<p>LES INFORMATIONS PRODUIT (A PROPOS DE), LES LICENCES DE FONCTIONS ET LES LICENCES DE MISES A JOUR DE LA FONCTION PEUVENT SE REFERER A L'EPL OU A D'AUTRES CONTRATS DE LICENCE, MODALITES OU TERMES ET CONDITIONS. CERTAINS DE CES AUTRES CONTRATS DE LICENCE PEUVENT INCLURE (MAIS SANS S'Y LIMITER) :</p>

<ul>
	<li>Common Public License Version 1.0 (disponible à l'adresse suivante : <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
	<li>Apache Software License 1.1 (disponible à l'adresse suivante : <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
	<li>Apache Software License 2.0 (disponible à l'adresse suivante : <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
	<li>IBM Public License 1.0 (disponible à l'adresse suivante : <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
	<li>Metro Link Public License 1.00 (disponible à l'adresse suivante : <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
	<li>Mozilla Public License Version 1.1 (disponible à l'adresse suivante : <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
</ul>

<p>IL EST DE VOTRE RESPONSABILITE DE LIRE ET D'ACCEPTER L'ENSEMBLE DE CES TERMES ET CONDITIONS AVANT D'UTILISER LE CONTENU. Si aucune information produit (A propos de), licence de fonction ou licence de mise à jour de la fonction n'est fournie,
contactez la Fondation Eclipse pour déterminer quels termes et conditions régissent ce contenu précis.</p>

<h3>Cryptographie</h3>

<p>Le contenu peut inclure un logiciel de cryptage. Le pays dans lequel vous vous trouvez actuellement peut être soumis à des restrictions d'importation, de possession, d'utilisation et/ou de réexportation vers un autre pays du logiciel de cryptage. AVANT d'utiliser un logiciel de cryptage, vérifiez si la loi nationale, les règles et les politiques en vigueur, relatives à l'importation, la possession ou l'utilisation et la réexportation du logiciel de cryptage l'autorisent.</p>
   
<small>Java ainsi que toutes les marques incluant Java sont des marques de Sun Microsystems, Inc. aux Etats-Unis, et/ou dans certains autres pays.</small> 
</body>
</html>
