<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <title>Contribuer</title>


  <meta http-equiv="content-type" content="text/html; charset=UTF-8">

</head>


<body>
<h1 style="color: rgb(204, 102, 0);">Structure du projet</h1>


      
      
<h3>G&eacute;n&eacute;ralit&eacute;s</h3>


      
      
<p>OpenOffice.org est le nom du projet total et est
h&eacute;berg&eacute; dans sa version originale anglophone par la
SSII <a href="http://www.collab.net/" target="_blank">CollabNet</a>.

      </p>


      
      
<p>OpenOffice.org est&nbsp; projet que Sun a&nbsp; lanc&eacute; et
qui est
sponsoris&eacute; et &eacute;paul&eacute; dans sa progression.<br>


OpenOffice.org est le projet OpenSource au travers duquel Sun
Microsystems publie la technologie de sa suite bureautique StarOffice<sup>(tm)</sup>.

      </p>


      
      
      
<h4>Les trois grands axes du projet OpenOffice.org sont :</h4>


      
      
<ul type="square">
  <li>Codes sources t&eacute;l&eacute;chargeables et informations</li>
  <li>M&eacute;canismes de communication et de travail
communautaire pour le projet</li>
  <li> La structure de supervision appel&eacute;e "the
OpenOffice.org Community Council". </li>
</ul>


      
      
<p>Le projet OpenOffice.org &eacute;tablit les facilit&eacute;s
n&eacute;cessaires pour rendre cette technologie disponible &agrave;
la communaut&eacute; des d&eacute;veloppeurs.</p>


      
      
<p>Le site internationale OpenOffice.org propose des ressources
d'informations et des forums de discussions.</p>
<h4>Les principaux objectifs sont :</h4>


      
      
<ul type="square">
  <li>L'&eacute;tablissement de standards ouverts de formats de
fichiers bas&eacute;s sur XML li&eacute;s aux APIs</li>
  <li>
          
          
    <p>L'acc&egrave;s ouvert au code source via le gestionnaire
de versions CVS</p>


        </li>
</ul>


      <i style="font-weight: bold;">(Le site francophone
fr.openoffice.org relaie ces
informations &amp; forums, et propose d'autres ressources
sp&eacute;cifiques &agrave; la francophonie telles que des forums, des traductions,
une aide sp&eacute;cifique &agrave; la communaut&eacute; etc.)</i>
      
      
<p>La partie ci-dessous d&eacute;crit les directives concernant
les r&ocirc;les techniques et les responsabilit&eacute;s sur le
projet OpenOffice.org et sur le maniement du code source. Les
changements substantiels de ces directives n&eacute;cessitent
l'approbation d'une majorit&eacute; de 2/3 des responsables de
projets.</p>


      
      
<h3>R&ocirc;les et Responsabilit&eacute;s</h3>


      
      
<p>Ils sont bas&eacute;s sur le m&eacute;rite. Tout le monde peut
aider, quel que soit son r&ocirc;le. Ceux qui auront
&eacute;t&eacute; des contributeurs actifs de mani&egrave;re assidue
obtiennent le droit de remettre leur travail directement dans la
banque de code.</p>


      
      
<h4>Utilisateurs</h4>


      
      
<p>Un utilisateur est quelqu'un qui utilise le produit du
projet... Il ne contribue pas dans l'&eacute;criture du code, mais
il saura d&eacute;couvrir des bugs, faire des suggestions, etc. Il
est de loin l'acteur le plus important du projet parce que sans
utilisateurs, le projet n'aurait aucune raison d'&ecirc;tre. Quand un
utilisateur commence &agrave; contribuer au code ou &agrave; la
documentation, il devient de fait un d&eacute;veloppeur.</p>


      
      
<h4>D&eacute;veloppeurs</h4>


      
      
<p>Le d&eacute;veloppeur est celui qui &eacute;crit du code, de
la documentation, ou contribue positivement au projet d'une autre
mani&egrave;re. Une contribution de d&eacute;veloppeur est toujours
reconnue. Dans le code source, chaque d&eacute;veloppeur ayant
particip&eacute; &agrave; un fichier source peut ajouter son nom
&agrave; la liste des contributeurs pour ce fichier.</p>


      
      
<h4>Entrepreneurs</h4>


      
      
<p>Un d&eacute;veloppeur qui a contribu&eacute; de fa&ccedil;on
remarquable &agrave; un projet peut voir son statut promu au rang d'
"entrepreneur" pour ce projet. Un entrepreneur obtient les droits
d'acc&egrave;s en &eacute;criture sur la banque de code source (via
CVS).</p>


      
      
<p>Un autre entrepreneur peut proposer un d&eacute;veloppeur
comme entrepreneur. Le responsable d'un projet nomme alors le
d&eacute;veloppeur "entrepreneur" et lui donne les droits
d'acc&egrave;s en &eacute;criture &agrave; la banque de code source du
projet.</p>


      
      
<p>Il se peut qu'un entrepreneur devienne inactif pour de
multiples raisons. Un entrepreneur inactif depuis plus de 6 mois
peut perdre son statut. Dans ce cas, le responsable du projet peut
lui retirer les droits d'acc&egrave;s en &eacute;criture sur la
banque de la communaut&eacute;.</p>


      
      
<p>Un changement de code publi&eacute; peut &ecirc;tre
supprim&eacute; si c'est demand&eacute; par le responsable du projet
ou la majorit&eacute; des autres responsables de projets et si ses
cons&eacute;quences ne peuvent pas &ecirc;tre imm&eacute;diatement
corrig&eacute;es par la publication d'un correctif type "bug fix". Le
probl&egrave;me doit &ecirc;tre r&eacute;solu avant que le
changement puisse &ecirc;tre inclus dans une construction (un 'build')
publique.</p>


      
      
<h4>Responsables de projets</h4>


      
      
<p>Un entrepreneur de longue date avec une implication encore
actuelle dans le d&eacute;veloppement de code, une profonde
connaissance de la mati&egrave;re en question sur OpenOffice.org et
une habilet&eacute; r&eacute;elle et &eacute;prouv&eacute;e dans la
direction d'&eacute;quipe peut &ecirc;tre nomm&eacute; responsable de
projet.</p>


      
      
<p>Un responsable de projet donne les directives pour son projet
dans son domaine au sein du projet OpenOffice.org.</p>


      
      
<p>Il doit sp&eacute;cialement veiller &agrave; ce que les
questions sur son projet soient r&eacute;pondues et &agrave; ce que
les contributions et publications soient trait&eacute;es.</p>


      
      
<p>Nomm&eacute; par les entrepreneurs un candidat doit &ecirc;tre
approuv&eacute; par une majorit&eacute; aux 2/3 des responsables de
projets pour devenir lui-m&ecirc;me le responsable d'un nouveau
projet ou d'un projet existant sans responsable.</p>


      
      
<p>La perte du statut de responsable de projet peut non seulement
intervenir dans le cas d'une inactivit&eacute; sur le projet (comme
pour les entrepreneurs) mais aussi pour d&eacute;faut de prises de
responsabilit&eacute;s dans le projet dont le responsable a la
charge. Une majorit&eacute; de 2/3 des autres responsables de projets
peut r&eacute;voquer un statut de responsable de projet.</p>


      
      
<p>Une liste des responsables de projets actuels peut &ecirc;tre
consult&eacute;e <a href="http://projects.openoffice.org/index.html" target="_blank">ici.</a></p>


      
      
<h2>Sources</h2>


      
      
<p>Le code source est conserv&eacute; dans une banque
d'informations partag&eacute;e utilisant le syst&egrave;me CVS.</p>


      
      
<p>Seuls les entrepreneurs peuvent &eacute;crire dans cette
banque, mais tout le monde y a acc&egrave;s en lecture via CVS avec
le <a href="http://development.openoffice.org/#CVS" target="_blank">frontal
web</a>.</p>


      
      
<p>Tous les codes source remis au projet doivent &ecirc;tre
couverts par la <a href="http://www.openoffice.org/license.html">licences
LGPL</a></p>


      
      
<p>Les fichiers dans la banque doivent contenir un en-t&ecirc;te
conforme au <a href="http://www.openoffice.org/dev_docs/source/templates/code" target="_blank">mod&egrave;le de code OpenOffice.org</a> et aux <a href="http://www.openoffice.org/dev_docs/source/templates/makefile" target="_blank">makefiles</a>.</p>


      
      
<p>Les d&eacute;veloppeurs de code source sup&eacute;rieur
&agrave; 10 lignes doivent avoir sign&eacute; <a href="http://www.openoffice.org/licenses/jca.pdf" target="_blank">le
formulaire de copyright</a> avant que leur contribution puisse
&ecirc;tre publi&eacute;e dans la banque.</p>


      
      
<p>Les patches et impl&eacute;mentations de
fonctionnalit&eacute;s sans contestation peuvent &ecirc;tre soumis sans
discussion ou annonce pr&eacute;alable. Les changements discutables
et les grandes remises en question doivent &eacute;videmment &ecirc;tre discut&eacute;s
avant d'&ecirc;tre publi&eacute;s.</p>


      
      
<p>Chaque changement qui affecterait la s&eacute;mantique d'une
API existante, d'une donn&eacute;e de configuration, d'un format de
fichier ou autres champs d'importance doit &ecirc;tre
approuv&eacute;. Un responsable de projet peut approuver un
changement dans son propre projet sans c&eacute;r&eacute;monie particuli&egrave;re.</p>


      
      
<dl>
  <dt>Il y a trois types de changement :</dt>
</dl>


      
      
<table border="0" cellpadding="2" cellspacing="0">


        <tbody>


          <tr valign="top">


            <td bgcolor="#ffffff" width="120">
            
            
      <p><b>Info</b></p>


            </td>


            <td bgcolor="#ffffff" width="500">
            
            
      <p>Notice d'information au sujet du changement d'une API.
Pas d'action particuli&egrave;re n&eacute;cessaire.</p>


            </td>


          </tr>


          <tr valign="top">


            <td bgcolor="#ffffff" width="120">
            
            
      <p><b>recommended</b></p>


            </td>


            <td bgcolor="#ffffff" width="500">
            
            
      <p>Utiliser la nouvelle API le plus t&ocirc;t possible.
L'ancienne est obsol&egrave;te et dispara&icirc;tra assez vite. Les
nouveaux codes doivent toujours utiliser la nouvelle API.</p>


            </td>


          </tr>


          <tr valign="top">


            <td bgcolor="#ffffff" width="120">
            
            
      <p><b>required</b></p>


            </td>


            <td bgcolor="#ffffff" width="500">
            
            
      <p>Ne pas se conformer &agrave; la nouvelle API
compromettra la construction ou causera des probl&egrave;mes
d'ex&eacute;cution. L'action du d&eacute;veloppeur est
oblig&eacute;e.</p>


            </td>


          </tr>


        
        
  </tbody>
      
      
</table>


      
      
<p>Les propositions de changements entre projets du type
"recommended" ou "required" doivent &ecirc;tre publi&eacute;es avec
la date sugg&eacute;r&eacute;e sur le forum de discussion
du module sp&eacute;cifique au minimum une semaine avant le changement.
Pendant cette
p&eacute;riode les projets concern&eacute;s doivent se pr&eacute;parer pour que la
construction suivante n'&eacute;choue pas. Ils sont
responsables de l'application du changement dans leur projet, pas le
demandeur du changement. Au bout de deux semaines de discussion sur
l'annonce de changement, les responsables peuvent d&eacute;cider par
vote majoritaire de l'opportunit&eacute; d'annulation du changement.</p>


      
      
<p>Un changement d&eacute;j&agrave; publi&eacute; dans la banque
peut &ecirc;tre supprim&eacute; si cela est demand&eacute; par le
responsable du projet ou la majorit&eacute; des responsables des
autres projets et si ses cons&eacute;quences ne peuvent &ecirc;tre
imm&eacute;diatement corrig&eacute;es par la soumission d'un
correctif. Le probl&egrave;me doit &ecirc;tre corrig&eacute; avant
que le changement puisse &ecirc;tre inclus dans une construction
publique.</p>


      
      
<h3>Note importante sur le site fr.openoffice.org</h3>


      
      
<p>Ce site n'est pas un miroir du site OpenOffice.org, ni sa
traduction compl&egrave;te, mais une partie int&eacute;grante du site du
projet OpenOffice.org dans votre langue de pr&eacute;dilection. Il
existe pour vous permettre de d&eacute;couvrir et de participer au
projet OpenOffice.org dans les meilleures conditions, mais il ne
saurait se substituer aux &eacute;l&eacute;ments dynamiques du site
OpenOffice.org en langue anglaise tels que le frontal CVS, les
discussions de d&eacute;veloppeurs sur les projets en cours, etc.
L'anglais est effectivement utilis&eacute; dans le projet
OpenOffice.org pour faciliter l'&eacute;change entre
d&eacute;veloppeurs de langues natales diff&eacute;rentes.</p>


      
      
<p>Vous pouvez utiliser le forum et autres ressources
propos&eacute;es sur cette partie de OpenOffice.org pour faire part
de vos suggestions, demander des pr&eacute;cisions, proposer votre
aide &agrave; la communaut&eacute; etc... Mais il est important que
vous notiez que pour participer en tant que d&eacute;veloppeur,
entrepreneur ou responsable de projet OpenOffice.org, il vous sera
indispensable de travailler directement sur les ressources en anglais
du site www.OpenOffice.org.

      </p>


      
      Pour aller plus loin et savoir o&ugrave; et comment contribuer dans
un projet d&eacute;termin&eacute;, acc&eacute;dez &agrave; la page <a href="Contribuer/index_contrib.htm">index des contributions</a><br>
<br>
<div style="text-align: right;"><small>OpenOffice.org native tongue concept and
francophone
project are built for you with pride by Guy Capra (Alomphega)</small>
</div>
</body>
</html>
