translator_fr.h

Go to the documentation of this file.

/******************************************************************************
 *
 * 
 *
 * Copyright (C) 1997-2008 by Dimitri van Heesch.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation under the terms of the GNU General Public License is hereby 
 * granted. No representations are made about the suitability of this software 
 * for any purpose. It is provided "as is" without express or implied warranty.
 * See the GNU General Public License for more details.
 *
 * Documents produced by Doxygen are derivative works derived from the
 * input used in their production; they are not affected by this license.
 *
 * The translation into French was provided by
 *   Christophe Bordeux (bordeux@lig.di.epfl.ch)
 *   and after version 1.2.0 by Xavier Outhier (xouthier@yahoo.fr)
 *   member of the non for profit association D2SET (http://d2set.free.fr)
 */

/******************************************************************************
 * History of content
 *
 *   Date       | Description
 *  ============+=============================================================
 *  2001-11-22  | Removed obsolet methods:
 *              |  QCString latexBabelPackage()
 *              |  QCString trAuthor()
 *              |  QCString trAuthors()
 *              |  QCString trFiles()
 *              |  QCString trIncludeFile()
 *              |  QCString trVerbatimText(const char *f)
 * -------------+------------------------------------------------------------
 *  2002-01-23  | Update for new since 1.2.13
 * -------------+------------------------------------------------------------
 *  2002-07-11  | Update for new since 1.2.16
 * -------------+------------------------------------------------------------
 *  2002-09-24  | Update for new since 1.2.17
 * -------------+------------------------------------------------------------
 *  2002-10-22  | Update for new since 1.2.18
 * -------------+------------------------------------------------------------
 *  2003-02-04  | Corrected typo. Thanks to Bertrand M. :)
 * -------------+------------------------------------------------------------
 *  2003-03-29  | Update for new since 1.3
 * -------------+------------------------------------------------------------
 *  2003-03-29  | Changed fonction into m�thode. 
 * -------------+------------------------------------------------------------
 *  2003-06-06  | Fixed code page problem appeared between 1.42 and 1.43 in CVS
 * -------------+------------------------------------------------------------
 *  2003-06-10  | Update for new since 1.3.1
 * -------------+------------------------------------------------------------
 *  2003-09-12  | Update for new since 1.3.3
 * -------------+------------------------------------------------------------
 *  2004-04-30  | Updates by Jacques Bouchard <jacques.bouchard@noos.fr>:
 *              | - spaces between ':' removed (should be added by the renderer)
 *              | - missing spaces added
 *              | - missing tests for OPTIMIZE_OUTPUT_FOR_C added
 *              | - translations corrected
 *              | - translator_fr.h now conforms exactly to translator_en.h
 *              |   (try: gvim -d translator_en.h translator_fr.h)
 * -------------+------------------------------------------------------------
 *  2005-07-12  | Update for new since 1.4.1
 * -------------+------------------------------------------------------------
 *  2005-10-09  | Update for new since 1.4.6
 *              |   Added virtual QCString trCallerGraph()
 *              |   Removed virtual QCString trHeaderFilesDescription()
 *              |   Removed virtual QCString trField(bool first_capital, bool singular)
 *              |   Removed virtual QCString trPackageDocumentation()
 *              |   Removed virtual QCString trSources()
 *              |   Removed virtual QCString trReimplementedForInternalReasons()
 *              |   Removed virtual QCString trInterfaces()
 *              |   Removed virtual QCString trHeaderFiles()
 *              |   Removed virtual QCString trBugsAndLimitations()
 *              |   Removed virtual QCString trNoDescriptionAvailable()
 *              |   Corrected some misspelling thanx to Christophe C.
 * -------------+------------------------------------------------------------
 */ 
#ifndef TRANSLATOR_FR_H
#define TRANSLATOR_FR_H

// When defining a translator class for the new language, follow
// the description in the documentation.  One of the steps says
// that you should copy the translator_en.h (this) file to your
// translator_xx.h new file.  Your new language should use the
// Translator class as the base class.  This means that you need to
// implement exactly the same (pure virtual) methods as the
// TranslatorEnglish does.  Because of this, it is a good idea to
// start with the copy of TranslatorEnglish and replace the strings
// one by one.
//
// It is not necessary to include "translator.h" or
// "translator_adapter.h" here.  The files are included in the
// language.cpp correctly.  Not including any of the mentioned
// files frees the maintainer from thinking about whether the
// first, the second, or both files should be included or not, and
// why.  This holds namely for localized translators because their
// base class is changed occasionaly to adapter classes when the
// Translator class changes the interface, or back to the
// Translator class (by the local maintainer) when the localized
// translator is made up-to-date again.

class TranslatorFrench : public TranslatorAdapter_1_5_4
{
   public:
   
    // --- Language control methods -------------------
    
       virtual QCString idLanguage()
      { 
         return "french"; }
   
       virtual QCString latexLanguageSupportCommand()
      {
         return "\\usepackage[french]{babel}\n";
      }
   
       virtual QCString idLanguageCharset()
      {
         return "iso-8859-1";
      }
   
    // --- Language translation methods -------------------
   
       virtual QCString trRelatedFunctions()
      { 
         return "Fonctions associ�es"; }
   
       virtual QCString trRelatedSubscript()
      { 
         return "(Noter que ce ne sont pas des fonctions membres)"; }
   
       virtual QCString trDetailedDescription()
      { 
         return "Description d�taill�e"; }
   
       virtual QCString trMemberTypedefDocumentation()
      { 
         return "Documentation des d�finition de type membres"; }
    
       virtual QCString trMemberEnumerationDocumentation()
      { 
         return "Documentation des �num�rations membres"; }
    
       virtual QCString trMemberFunctionDocumentation()
      { 
         return "Documentation des fonctions membres"; }
    
       virtual QCString trMemberDataDocumentation()
      { 
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Documentation des champs"; 
         }
         else
         {
            return "Documentation des donn�es membres";
         }
      }
   
       virtual QCString trMore()
      { 
         return "Plus de d�tails..."; }
   
       virtual QCString trListOfAllMembers()
      { 
         return "Liste de tous les membres"; }
   
       virtual QCString trMemberList()
      { 
         return "Liste des membres"; }
   
       virtual QCString trThisIsTheListOfAllMembers()
      { 
         return "Liste compl�te des membres de "; }
   
       virtual QCString trIncludingInheritedMembers()
      { 
         return ", y compris les membres h�rit�s :"; }
    
       virtual QCString trGeneratedAutomatically(const char *s)
      { QCString result="G�n�r� automatiquement par Doxygen"; 
         if (s) result+=(QCString)" pour "+s;
         result+=" � partir du code source."; 
         return result;
      }
   
       virtual QCString trEnumName()
      { 
         return "�num�ration"; }
    
       virtual QCString trEnumValue()
      { 
         return "valeur �num�r�e"; }
    
       virtual QCString trDefinedIn()
      { 
         return "d�fini dans"; }
   
    // quick reference sections
   
       virtual QCString trModules()
      { 
         return "Modules"; }
    
       virtual QCString trClassHierarchy()
      { 
         return "Hi�rarchie des classes"; }
    
       virtual QCString trCompoundList()
      { 
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Structures de donn�es";
         }
         else
         {
            return "Liste des classes"; 
         }
      }
    
       virtual QCString trFileList()
      { 
         return "Liste des fichiers"; }
   
       virtual QCString trCompoundMembers()
      { 
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Champs de donn�e"; 
         }
         else
         {
            return "Membres de classe"; 
         }
      }
   
       virtual QCString trFileMembers()
      { 
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Port�e globale"; 
         }
         else
         {
            return "Membres de fichier"; 
         }
      }
   
       virtual QCString trRelatedPages()
      { 
         return "Pages associ�es"; }
   
       virtual QCString trExamples()
      { 
         return "Exemples"; }
   
       virtual QCString trSearch()
      { 
         return "Recherche"; }
   
       virtual QCString trClassHierarchyDescription()
      { 
         return "Cette liste d'h�ritage est class�e "
             "approximativement par ordre alphab�tique :";
      }
   
       virtual QCString trFileListDescription(bool extractAll)
      {
         QCString result="Liste de tous les fichiers ";
         if (!extractAll) result+="document�s ";
         result+="avec une br�ve description :";
         return result;
      }
   
       virtual QCString trCompoundListDescription()
      {
      
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Liste des structures de donn�es avec une br�ve description :"; 
         }
         else
         {
            return "Liste des classes, structures, "
               "unions et interfaces avec une br�ve description :"; 
         }
      }
   
       virtual QCString trCompoundMembersDescription(bool extractAll)
      {
         QCString result="Liste de tous les ";
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            result+="champs de structure et d'union ";
         }
         else
         {
            result+="membres de classe ";
         }
         if (!extractAll)
         {
            result+="document�s ";
         }
         result+="avec liens vers ";
         if (!extractAll) 
         {
            if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
            {
               result+="la documentation de structure/union de chaque champ :";
            }
            else
            {
               result+="la documentation de classe de chaque membre :";
            }
         }
         else 
         {
            if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
            {
               result+="les structures/unions auxquelles ils appartiennent :";
            }
            else
            {
               result+="les classes auxquelles ils appartiennent :";
            }
         }
         return result;
      }
   
       virtual QCString trFileMembersDescription(bool extractAll)
      {
         QCString result="Liste ";
      
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            result+="des fonctions, variables, macros, enum�rations, et d�finitions de type ";
         }
         else
         {
            result+="de tous les membres de fichier ";
         }
         if (!extractAll) result+="document�s ";
         result+="avec liens vers ";
         if (extractAll) 
            result+="les fichiers auxquels ils appartiennent :";
         else 
            result+="la documentation :";
         return result;
      }
   
       virtual QCString trExamplesDescription()
      { 
         return "Liste de tous les exemples :"; }
   
       virtual QCString trRelatedPagesDescription()
      { 
         return "Liste de toutes les pages de documentation associ�es :"; }
   
       virtual QCString trModulesDescription()
      { 
         return "Liste de tous les modules :"; }
   
       virtual QCString trDocumentation()
      { 
         return "Documentation"; }
   
       virtual QCString trModuleIndex()
      { 
         return "Index des modules"; }
   
       virtual QCString trHierarchicalIndex()
      { 
         return "Index hi�rarchique"; }
   
       virtual QCString trCompoundIndex()
      {
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         { 
            return "Index des structures de donn�es";
         }
         else
         {
            return "Index des classes"; 
         }
      }
   
       virtual QCString trFileIndex() 
      { 
         return "Index des fichiers"; }
   
       virtual QCString trModuleDocumentation()
      { 
         return "Documentation des modules"; }
   
       virtual QCString trClassDocumentation()
      { 
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Documentation des structures de donn�es"; 
         }
         else
         {
            return "Documentation des classes"; 
         }
      }
   
       virtual QCString trFileDocumentation()
      { 
         return "Documentation des fichiers"; }
   
       virtual QCString trExampleDocumentation()
      { 
         return "Documentation des exemples"; }
   
       virtual QCString trPageDocumentation()
      { 
         return "Documentation des pages associ�es"; }
   
       virtual QCString trReferenceManual()
      { 
         return "Manuel de r�f�rence"; }
    
       virtual QCString trDefines()
      { 
         return "Macros"; }
   
       virtual QCString trFuncProtos()
      { 
         return "Prototypes de fonction"; }
   
       virtual QCString trTypedefs()
      { 
         return "D�finition de type"; }
   
       virtual QCString trEnumerations()
      { 
         return "�num�rations"; }
   
       virtual QCString trFunctions()
      { 
         return "Fonctions"; }
   
       virtual QCString trVariables()
      { 
         return "Variables"; }
   
       virtual QCString trEnumerationValues()
      { 
         return "Valeurs �num�r�es"; }
    
       virtual QCString trDefineDocumentation()
      { 
         return "Documentation des macros"; }
   
       virtual QCString trFunctionPrototypeDocumentation()
      { 
         return "Documentation des prototypes de fonction"; }
   
       virtual QCString trTypedefDocumentation()
      { 
         return "Documentation des d�finition de type"; }
   
       virtual QCString trEnumerationTypeDocumentation()
      { return "Documentation du type de l'�num�ration"; }
   
       virtual QCString trFunctionDocumentation()
      { 
         return "Documentation des fonctions"; }
   
       virtual QCString trVariableDocumentation()
      { 
         return "Documentation des variables"; }
   
       virtual QCString trCompounds()
      { 
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Structures de donn�es"; 
         }
         else
         {
            return "Classes"; 
         }
      }
   
       virtual QCString trGeneratedAt(const char *date,const char *projName)
      { 
         QCString result=(QCString)"G�n�r� le "+date;
         if (projName) result+=(QCString)" pour "+projName;
         result+=(QCString)" par";
         return result;
      }
       virtual QCString trWrittenBy()
      {
         return "�crit par";
      }
   
       virtual QCString trClassDiagram(const char *clName)
      {
         return (QCString)"Graphe d'h�ritage de "+clName+":";
      }
    
       virtual QCString trForInternalUseOnly()
      { 
         return "� usage interne uniquement."; }
   
       virtual QCString trWarning()
      { 
         return "Avertissement"; }
   
       virtual QCString trVersion()
      { 
         return "Version"; }
   
       virtual QCString trDate()
      { 
         return "Date"; }
   
       virtual QCString trReturns()
      { 
         return "Renvoie"; }
   
       virtual QCString trSeeAlso()
      { 
         return "Voir �galement"; }
   
       virtual QCString trParameters()
      { 
         return "Param�tres"; }
   
       virtual QCString trExceptions()
      { 
         return "Exceptions"; }
    
       virtual QCString trGeneratedBy()
      { 
         return "G�n�r� par"; }
   
   // new since 0.49-990307
   
       virtual QCString trNamespaceList()
      { 
         return "Liste des espaces de nommage"; }
   
       virtual QCString trNamespaceListDescription(bool extractAll)
      {
         QCString result="Liste de tous les espaces de nommage ";
         if (!extractAll) result+="document�s ";
         result+="avec une br�ve description:";
         return result;
      }
   
       virtual QCString trFriends()
      { 
         return "Amis"; }
    
   // new since 0.49-990405
    
       virtual QCString trRelatedFunctionDocumentation()
      { 
         return "Documentation des fonctions amies et associ�es"; }
    
   // new since 0.49-990425
   
       virtual QCString trCompoundReference(const char *clName,
                                    ClassDef::CompoundType compType,
                                    bool isTemplate)
      {
         QCString result="R�f�rence de ";
         switch(compType)
         {
            case ClassDef::Class:      result+="la classe "; 
               break;
            case ClassDef::Struct:     result+="la structure "; 
               break;
            case ClassDef::Union:      result+="l'union "; 
               break;
            case ClassDef::Interface:  result+="l'interface "; 
               break;
            case ClassDef::Protocol:   result+="le protocol "; 
               break; 
            case ClassDef::Category:   result+="la cat�gorie "; 
               break; 
            case ClassDef::Exception:  result+="l'exception "; 
               break;
         }
         result+=(QCString)clName;
         if (isTemplate) result+=" (mod�le)";
         return result;
      }
   
       virtual QCString trFileReference(const char *fileName)
      {
         QCString result= "R�f�rence du fichier ";
         result+=fileName;
         return result;
      }
   
       virtual QCString trNamespaceReference(const char *namespaceName)
      {
         QCString result= "R�f�rence de l'espace de nommage ";
         result+=namespaceName;
         return result;
      }
    
       virtual QCString trPublicMembers()
      { 
         return "Fonctions membres publiques"; }
       virtual QCString trPublicSlots()
      { 
         return "Connecteurs publics"; }
       virtual QCString trSignals()
      { 
         return "Signaux"; }
       virtual QCString trStaticPublicMembers()
      { 
         return "Fonctions membres publiques statiques"; }
       virtual QCString trProtectedMembers()
      { 
         return "Fonctions membres prot�g�es"; }
       virtual QCString trProtectedSlots()
      { 
         return "Connecteurs prot�g�s"; }
       virtual QCString trStaticProtectedMembers()
      { 
         return "Fonctions membres prot�g�es statiques"; }
       virtual QCString trPrivateMembers()
      { 
         return "Fonctions membres priv�es"; }
       virtual QCString trPrivateSlots()
      { 
         return "Connecteurs priv�s"; }
       virtual QCString trStaticPrivateMembers()
      { 
         return "Fonctions membres priv�es statiques"; }
    
       virtual QCString trWriteList(int numEntries)
      {
         QCString result;
         int i;
      // the inherits list contain `numEntries' classes
         for (i=0;i<numEntries;i++) 
         {
         // use generateMarker to generate placeholders for the class links!
            result+=generateMarker(i); // generate marker for entry i in the list
                                   // (order is left to right)
         
            if (i!=numEntries-1)  // not the last entry, so we need a separator
            {
               if (i<numEntries-2) // not the fore last entry
                  result+=", ";
               else                // the fore last entry
                  result+=", et ";
            }
         }
         return result; 
      }
    
       virtual QCString trInheritsList(int numEntries)
      {
         return "Est d�riv�e de "+trWriteList(numEntries)+".";
      }
   
       virtual QCString trInheritedByList(int numEntries)
      {
         return "D�riv�e par "+trWriteList(numEntries)+".";
      }
   
       virtual QCString trReimplementedFromList(int numEntries)
      {
         return "R�impl�ment�e � partir de "+trWriteList(numEntries)+".";
      }
   
       virtual QCString trReimplementedInList(int numEntries)
      {
         return "R�impl�ment�e dans "+trWriteList(numEntries)+".";
      }
   
       virtual QCString trNamespaceMembers()
      { 
         return "Membres de l'espace de nommage"; }
   
       virtual QCString trNamespaceMemberDescription(bool extractAll)
      { 
         QCString result="Liste de tous les membres des espaces de nommage ";
         if (!extractAll) result+="document�s ";
         result+="avec liens vers ";
         if (extractAll) 
            result+="la documentation de namespace de chaque membre :";
         else 
            result+="les espaces de nommage auxquels ils appartiennent :";
         return result;
      }
       virtual QCString trNamespaceIndex()
      { 
         return "Index des espaces de nommage"; }
   
       virtual QCString trNamespaceDocumentation()
      { 
         return "Documentation des espaces de nommage"; }
   
   // new since 0.49-990522
   
       virtual QCString trNamespaces()
      { 
         return "Espaces de nommage"; }
   
   // new since 0.49-990728
   
       virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
        bool single)
      { // here s is one of " Class", " Struct" or " Union"
      // single is true implies a single file
         bool female = true;
         QCString result=(QCString)"La documentation de ";
         switch(compType)
         {
            case ClassDef::Class:      result+="cette classe"; 
               break;
            case ClassDef::Struct:     result+="cette structure"; 
               break;
            case ClassDef::Union:      result+="cette union"; 
               break;
            case ClassDef::Interface:  result+="cette interface"; 
               break;
            case ClassDef::Protocol:   result+="ce protocol"; 
               female = false;
               break; 
            case ClassDef::Category:   result+="cette cat�gorie"; 
               break; 
            case ClassDef::Exception:  result+="cette exception"; 
               break;
         }
         if (female) result+= " a �t� g�n�r�e � partir ";
         else result+=" a �t� g�n�r� � partir ";
         if (single) result+="du fichier suivant :"; 
         else result+="des fichiers suivants :";
         return result;
      }
   
       virtual QCString trAlphabeticalList()
      { 
         return "Liste alphab�tique"; }
   
   // new since 0.49-990901
   
       virtual QCString trReturnValues()
      { 
         return "Valeurs retourn�es"; }
   
       virtual QCString trMainPage()
      { 
         return "Page principale"; }
   
       virtual QCString trPageAbbreviation()
      { 
         return "p."; }
   
   // new since 0.49-991003
   
       virtual QCString trDefinedAtLineInSourceFile()
      {
         return "D�finition � la ligne @0 du fichier @1.";
      }
       virtual QCString trDefinedInSourceFile()
      {
         return "D�finition dans le fichier @0.";
      }
   
   // new since 0.49-991205
   
       virtual QCString trDeprecated()
      {
         return "Obsol�te";
      }
   
   // new since 1.0.0
   
       virtual QCString trCollaborationDiagram(const char *clName)
      {
         return (QCString)"Graphe de collaboration de "+clName+":";
      }
       virtual QCString trInclDepGraph(const char *fName)
      {
         return (QCString)"Graphe des d�pendances par inclusion de "+fName+":";
      }
       virtual QCString trConstructorDocumentation()
      {
         return "Documentation des constructeurs et destructeur"; 
      }
       virtual QCString trGotoSourceCode()
      {
         return "Aller au code source de ce fichier.";
      }
       virtual QCString trGotoDocumentation()
      {
         return "Aller � la documentation de ce fichier.";
      }
       virtual QCString trPrecondition()
      {
         return "Pr�condition";
      }
       virtual QCString trPostcondition()
      {
         return "Postcondition";
      }
       virtual QCString trInvariant()
      {
         return "Invariant";
      }
       virtual QCString trInitialValue()
      {
         return "Valeur initiale :";
      }
       virtual QCString trCode()
      {
         return "code";
      }
       virtual QCString trGraphicalHierarchy()
      {
         return "Graphe hi�rarchique des classes";
      }
       virtual QCString trGotoGraphicalHierarchy()
      {
         return "Aller au graphe hi�rarchique des classes";
      }
       virtual QCString trGotoTextualHierarchy()
      {
         return "Aller � la hi�rarchie des classes en mode texte";
      }
       virtual QCString trPageIndex()
      {
         return "Index des pages";
      }
   
   // new since 1.1.0
    
       virtual QCString trNote()
      {
         return "Note";
      }
       virtual QCString trPublicTypes()
      {
         return "Types publics";
      }
       virtual QCString trPublicAttribs()
      {
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Champs de donn�es";
         }
         else
         {
            return "Attributs publics";
         }
      }
       virtual QCString trStaticPublicAttribs()
      {
         return "Attributs publics statiques";
      }
       virtual QCString trProtectedTypes()
      {
         return "Types prot�g�s";
      }
       virtual QCString trProtectedAttribs()
      {
         return "Attributs prot�g�s";
      }
       virtual QCString trStaticProtectedAttribs()
      {
         return "Attributs prot�g�s statiques";
      }
       virtual QCString trPrivateTypes()
      {
         return "Types priv�s";
      }
       virtual QCString trPrivateAttribs()
      {
         return "Attributs priv�s";
      }
       virtual QCString trStaticPrivateAttribs()
      {
         return "Attributs priv�s statiques";
      }
   
   // new since 1.1.3
   
       virtual QCString trTodo()
      {
         return "� faire";
      }
       virtual QCString trTodoList()
      {
         return "Liste des choses � faire";
      }
   
   // new since 1.1.4
   
       virtual QCString trReferencedBy()
      {
         return "R�f�renc� par";
      }
       virtual QCString trRemarks()
      {
         return "Remarques";
      }
       virtual QCString trAttention()
      {
         return "Attention";
      }
       virtual QCString trInclByDepGraph()
      {
         return "Ce graphe montre quels fichiers incluent directement "
             "ou indirectement ce fichier :";
      }
       virtual QCString trSince()
      {
         return "Depuis";
      }
    
   // new since 1.1.5
   
       virtual QCString trLegendTitle()
      {
         return "L�gende du graphe";
      }
       virtual QCString trLegendDocs()
      {
         return 
            "Cette page explique comment interpr�ter les graphes g�n�r�s "
            "par doxygen.<p>\n"
            "Consid�rez l'exemple suivant :\n"
            "\\code\n"
            "/*! Classe invisible � cause d'une troncature */\n"
            "class Invisible { };\n\n"
            "/*! Classe tronqu�e, la relation d'h�ritage est masqu�e */\n"
            "class Truncated : public Invisible { };\n\n"
            "/*! Classe non document�e avec des commentaires Doxygen */\n"
            "class Undocumented { };\n\n"
            "/*! Classe d�riv�e par h�ritage public */\n"
            "class PublicBase : public Truncated { };\n\n"
            "/*! Un mod�le de classe */\n"
            "template<class T> class Templ { };\n\n"
            "/*! Classe d�riv�e par h�ritage prot�g� */\n"
            "class ProtectedBase { };\n\n"
            "/*! Classe d�riv�e par h�ritage priv� */\n"
            "class PrivateBase { };\n\n"
            "/*! Classe utilis�e par la classe d�riv�e */\n"
            "class Used { };\n\n"
            "/*! Super-classe qui h�rite de plusieurs autres classes */\n"
            "class Inherited : public PublicBase,\n"
            "                  protected ProtectedBase,\n"
            "                  private PrivateBase,\n"
            "                  public Undocumented,\n"
            "                  public Templ<int>\n"
            "{\n"
            "  private:\n"
            "    Used *m_usedClass;\n"
            "};\n"
            "\\endcode\n"
            "Si la valeur 240 est attribu�e au tag \\c MAX_DOT_GRAPH_HEIGHT "
            "du fichier de configuration, cela g�n�rera le graphe suivant :"
            "<p><center><img alt=\"\" src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
            "<p>\n"
            "Les rectangles du graphe ci-dessus ont la signification suivante :\n"
            "<ul>\n"
            "<li>Un rectangle plein noir repr�sente la structure ou la classe pour laquelle "
            "le graphe est g�n�r�.\n"
            "<li>Un rectangle avec un bord noir indique une classe ou une structure document�e.\n"
            "<li>Un rectangle avec un bord gris indique une classe ou une structure non document�e.\n"
            "<li>Un rectangle avec un bord rouge indique une structure ou une classe document�e\n"
            "pour laquelle des relations d'h�ritage ou de collaboration manquent. Un graphe est "
            "tronqu� s'il n'entre pas dans les limites sp�cifi�es."
            "</ul>\n"
            "Les fl�ches ont la signification suivante :\n"
            "<ul>\n"
            "<li>Une fl�che bleu fonc� est utilis�e pour visualiser une relation d'h�ritage public "
            "entre deux classes.\n"
            "<li>Une fl�che vert fonc� est utilis�e pour une relation d'h�ritage prot�g�.\n"
            "<li>Une fl�che rouge fonc� est utilis�e pour une relation d'h�ritage priv�.\n"
            "<li>Une fl�che violette en pointill�s est utilis�e si une classe est contenue ou "
            "utilis�e par une autre classe. La fl�che est �tiquet�e avec la ou les variable(s) "
            "qui permettent d'acc�der � la classe ou structure point�e. \n"
            "<li>Une fl�che verte en pointill�s indique une relation entre une classe instanci�e et "
            "le mod�le de classe utilis�. La fl�che est �tiquet�e avec "
            "les param�tres de mod�le de la classe instanci�e.\n"
            "</ul>\n";
      }
       virtual QCString trLegend()
      {
         return "l�gende";
      }
   
   // new since 1.2.0
    
       virtual QCString trTest()
      {
         return "Test";
      }
       virtual QCString trTestList()
      {
         return "Liste des tests";
      }
   
   // new since 1.2.1
   
       virtual QCString trDCOPMethods()
      {
         return "Fonctions membres DCOP";
      }
   
   // new since 1.2.2
   
       virtual QCString trProperties()
      {
         return "Propri�t�s";
      }
       virtual QCString trPropertyDocumentation()
      {
         return "Documentation des propri�t�s";
      }
   
   // new since 1.2.4
   
       virtual QCString trClasses()
      {
         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
         {
            return "Structures de donn�es";
         }
         else
         {
            return "Classes";
         }
      }
       virtual QCString trPackage(const char *name)
      {
         return (QCString)"Paquetage "+name;
      }
       virtual QCString trPackageList()
      {
         return "Liste des paquetages";
      }
       virtual QCString trPackageListDescription()
      {
         return "Liste des paquetages avec une br�ve description (si disponible) :";
      }
       virtual QCString trPackages()
      {
         return "Paquetages";
      }

       virtual QCString trDefineValue()
      {
         return "Valeur :";
      }
    
   // new since 1.2.5
    
       virtual QCString trBug()
      {
         return "Bogue";
      }
       virtual QCString trBugList()
      {
         return "Liste des bogues";
      }
   
   // new since 1.2.6
   
       virtual QCString trRTFansicp()
      {
         return "1252";
      }
    
   
       virtual QCString trRTFCharSet()
      {
         return "0";
      }
   
       virtual QCString trRTFGeneralIndex()
      {
         return "Index";
      }
   
       virtual QCString trClass(bool first_capital, bool singular)
      { 
         QCString result((first_capital ? "Classe" : "classe"));
         if (!singular)  result+="s";
         return result; 
      }
   
       virtual QCString trFile(bool first_capital, bool singular)
      { 
         QCString result((first_capital ? "Fichier" : "fichier"));
         if (!singular)  result+="s";
         return result; 
      }
   
       virtual QCString trNamespace(bool first_capital, bool singular)
      { 
         QCString result((first_capital ? "Espace" : "espace"));
         if (!singular)  result+="s";
         result+=" de nommage";
         return result; 
      }
   
       virtual QCString trGroup(bool first_capital, bool singular)
      { 
         QCString result((first_capital ? "Groupe" : "groupe"));
         if (!singular)  result+="s";
         return result; 
      }
   
       virtual QCString trPage(bool first_capital, bool singular)
      { 
         QCString result((first_capital ? "Page" : "page"));
         if (!singular)  result+="s";
         return result; 
      }
   
       virtual QCString trMember(bool first_capital, bool singular)
      { 
         QCString result((first_capital ? "Membre" : "membre"));
         if (!singular)  result+="s";
         return result; 
      }
   
       virtual QCString trGlobal(bool first_capital, bool singular)
      { 
         QCString result((first_capital ? "Global(e)" : "global(e)"));
         if (!singular)  result+="s";
         return result; 
      }
   
   // new since 1.2.7
   
       virtual QCString trAuthor(bool first_capital, bool singular)
      {                                                                         
         QCString result((first_capital ? "Auteur" : "auteur"));
         if (!singular)  result+="s";
         return result; 
      }
   
   // new since 1.2.11
   
       virtual QCString trReferences()
      {
         return "R�f�rences";
      }
   
   // new since 1.2.13
   
       virtual QCString trImplementedFromList(int numEntries)
      {
         return "Impl�mente "+trWriteList(numEntries)+".";
      }
   
       virtual QCString trImplementedInList(int numEntries)
      {
         return "Impl�ment� dans "+trWriteList(numEntries)+".";
      }
   
   // new since 1.2.16
   
       virtual QCString trRTFTableOfContents()
      {
         return "Table des mati�res";
      }
   
   // new since 1.2.17
   
       virtual QCString trDeprecatedList()
      {
         return "Liste des �l�ments obsol�tes";
      }
   
   // new since 1.2.18
   
       virtual QCString trEvents()
      {
         return "�v�nements";
      }
       virtual QCString trEventDocumentation()
      {
         return "Documentation des �v�nements";
      }
   
   // new since 1.3
   
       virtual QCString trPackageTypes()
      { 
         return "Types de paquetage";
      }
       virtual QCString trPackageMembers()
      { 
         return "Fonctions de paquetage";
      }
       virtual QCString trStaticPackageMembers()
      { 
         return "Fonctions statiques de paquetage";
      }
       virtual QCString trPackageAttribs()
      { 
         return "Attributs de paquetage";
      }
       virtual QCString trStaticPackageAttribs()
      { 
         return "Attributs statiques de paquetage";
      }
   
   // new since 1.3.1
   
       virtual QCString trAll()
      {
         return "Tout";
      }
       virtual QCString trCallGraph()
      {
         return "Voici le graphe d'appel pour cette fonction :";
      }
   
   // new since 1.3.3
   
       virtual QCString trSearchForIndex()
      {
         return "Rechercher";
      }
       virtual QCString trSearchResultsTitle()
      {
         return "R�sultats de la recherche";
      }
       virtual QCString trSearchResults(int numDocuments)
      {
         if (numDocuments==0)
         {
            return "D�sol� aucun document ne correspond � votre requ�te.";
         }
         else if (numDocuments==1)
         {
            return "Trouv� <b>1</b> document correspondant � votre requ�te.";
         }
         else 
         {
            return "Trouv�  <b>$num</b> documents correspondant � votre requ�te. "
               "Class� par ordre de pertinence d�croissant.";
         }
      }
       virtual QCString trSearchMatches()
      {
         return "Correspondances :";
      }
   
   // new since 1.3.8
   
       virtual QCString trSourceFile(QCString& filename)
      {
         return " Fichier source de " + filename;
      }
   
   // new since 1.3.9
   
       virtual QCString trDirIndex()
      { 
         return "Hi�rarchie de r�pertoires"; }
   
       virtual QCString trDirDocumentation()
      { 
         return "Documentation des r�pertoires"; }
   
       virtual QCString trDirectories()
      { 
         return "R�pertoires"; }
   
       virtual QCString trDirDescription()
      { 
         return "Cette hi�rarchie de r�pertoire est tri�e approximativement, "
              "mais pas compl�tement, par ordre alphab�tique :";
      }
   
       virtual QCString trDirReference(const char *dirName)
      { 
         QCString  result="R�pertoire de r�f�rence de "; result+=dirName; 
         return result; 
      }
   
       virtual QCString trDir(bool first_capital, bool singular)
      {
         QCString result((first_capital ? "R�pertoire" : "r�pertoire"));
         if (singular) result+=""; 
         else result+="s";
         return result;
      }
   
   // new since 1.4.1
   
       virtual QCString trOverloadText()
      {
         return "Ceci est une fonction membre surcharg�e, "
              "propos�e par commodit�. Elle diff�re de la fonction "
              "ci-dessus uniquement par le(s) argument(s) qu'elle accepte.";
      }

    // new since 1.4.6

    virtual QCString trCallerGraph()
    {
      return "Voici le graphe d'appel pour cette fonction :";
    }

    virtual QCString trEnumerationValueDocumentation()
    { return "Documentation des �num�rations"; }
};

#endif

---

• ソフトウェア開発
• ホームページ制作
• Tcl版
• STLport版
• Dradnats C++ Library
• 要約文庫