initial version

1 files changed, 270 insertions, 0 deletions

diff --git a/src/translator_fr.h b/src/translator_fr.h
new file mode 100644
index 0000000..cd78053
--- /dev/null
+++ b/src/translator_fr.h
@@ -0,0 +1,270 @@
+/******************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 1997-1999 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.
+ *
+ * All output generated with Doxygen is not covered by this license.
+ *
+ */
+
+#ifndef TRANSLATOR_FR_H
+#define TRANSLATOR_FR_H
+
+#include <qstring.h>
+
+class TranslatorFrench : public Translator
+{
+  public:
+    QString latexBabelPackage()
+    { return "french"; }
+    QString trInherits()
+    { return "Hérite de"; }
+    QString trAnd()
+    { return "et"; }
+    QString trInheritedBy()
+    { return "Dérivée par"; }
+    QString trRelatedFunctions()
+    { return "Fonctions associées"; }
+    QString trRelatedSubscript()
+    { return "(Noter que ces fonctions ne sont pas des méthodes de la classe)"; }
+    QString trDetailedDescription()
+    { return "Description détaillée"; }
+    QString trMemberTypedefDocumentation()
+    { return "Documentation des types imbriqués"; }
+    QString trMemberEnumerationDocumentation()
+    { return "Documentation des énumérations imbriqués"; }
+    QString trMemberFunctionDocumentation()
+    { return "Documentation des méthodes"; }
+    QString trMemberDataDocumentation()
+    { return "Documentation des données imbriqués"; }
+    QString trGeneratedFrom(const char *s,bool single)
+    { 
+      QString result=(QString)"La documentation pour cette"+s+
+                     " a été générée à partir ";
+      if (single) result+="du fichier suivant:";   
+      else result+="des fichiers suivants:";
+      return result;
+    }
+    QString trMore()
+    { return "Plus de détails..."; }
+    QString trReference()
+    { return "Référence"; }
+    QString trListOfAllMembers()
+    { return "Liste de tous les membres"; }
+    QString trMemberList()
+    { return "Liste des membres"; }
+    QString trThisIsTheListOfAllMembers()
+    { return "Ceci est la liste complète des membres de"; }
+    QString trIncludingInheritedMembers()
+    { return "y compris des membres des classes héritées."; }
+    QString trGeneratedAutomatically(const char *s)
+    { QString result="Généré automatiquement par Doxygen"; 
+      if (s) result+=(QString)" pour "+s;
+      result+=" à partir du code source."; 
+      return result;
+    }
+    QString trEnumName()
+    { return "énumération"; }
+    QString trEnumValue()
+    { return "élément d'une énumération"; }
+    QString trDefinedIn()
+    { return "défini dans"; }
+    QString trIncludeFile()
+    { return "Fichier inclu"; }
+    QString trVerbatimText(const char *f)
+    { return (QString)"Ce texte provient du fichier inclu "+f+"."; }
+
+
+    QString trModules()
+    { return "Modules"; }
+    QString trClassHierarchy()
+    { return "Hiérarchie des classes"; }
+    QString trCompoundList()
+    { return "Liste des composants"; }
+    QString trFileList()
+    { return "Liste des fichiers"; }
+    QString trHeaderFiles()
+    { return "Fichiers d'entête"; }
+    QString trCompoundMembers()
+    { return "Composants"; }
+    QString trFileMembers()
+    { return "Déclarations"; }
+    QString trRelatedPages()
+    { return "Pages associées"; }
+    QString trExamples()
+    { return "Exemples"; }
+    QString trSearch()
+    { return "Recherche"; }
+    QString trClassHierarchyDescription()
+    { return "Cette liste d'héritage est, autant que possible, "
+	"classée par ordre alphabétique"; }
+    QString trFileListDescription(bool extractAll)
+    {
+      QString result="Liste de tous les fichiers ";
+      if (!extractAll) result+="documentés ";
+      result+="avec une brève description :";
+      return result;
+    }
+    QString trCompoundListDescription()
+    { return "Liste des classes, des strutures et des unions "
+	"avec une brève description :"; 
+    }
+    QString trCompoundMembersDescription(bool extractAll)
+    {
+      QString result="Liste de tous les membres de classe ";
+      if (!extractAll) result+="documentés ";
+      result+="avec les liens vers ";
+      if (extractAll) result+="la documentation de la classe correspondante :";
+      else result+="les classes auxquelles ils appartiennent :";
+      return result;
+    }
+    QString trFileMembersDescription(bool extractAll)
+    {
+      QString result="Liste de toutes les déclarations";
+      if (!extractAll) result+="documentées ";
+      result+="avec liens sur ";
+      if (extractAll) result+="la documentation du fichier correspondant "
+			"pour chacune :";
+      else result+="les fichiers dans lesquels elles sont définies :";
+      return result;
+    }
+    QString trHeaderFilesDescription()
+    { return "Liste de tous les fichiers d'entête constituant "
+	"l'interface de programmation :"; }
+    QString trExamplesDescription()
+    { return "Liste de tous les exemples :"; }
+    QString trRelatedPagesDescription()
+    { return "Liste de toutes les pages de documentation associées :"; }
+    QString trModulesDescription()
+    { return "Liste de tous les modules"; }
+    QString trNoDescriptionAvailable()
+    { return "Aucune description n'est disponible"; }
+
+    QString trDocumentation()
+    { return "Documentation"; }
+    QString trModuleIndex()
+    { return "Index des modules"; }
+    QString trHierarchicalIndex()
+    { return "Index hiérarchique"; }
+    QString trCompoundIndex()
+    { return "Index des composants"; }
+    QString trFileIndex() 
+    { return "Index des fichiers"; }
+    QString trModuleDocumentation()
+    { return "Documentation du module"; }
+    QString trClassDocumentation()
+    { return "Documentation de la classe"; }
+    QString trFileDocumentation()
+    { return "Documentation du fichier"; }
+    QString trExampleDocumentation()
+    { return "Documentation de l'exemple"; }
+    QString trPageDocumentation()
+    { return "Documentation de la page"; }
+    QString trReferenceManual()
+    { return "Manuel de référence"; }
+
+    QString trDefines()
+    { return "Définitions des macros"; }
+    QString trFuncProtos()
+    { return "Prototypes des fonctions"; }
+    QString trTypedefs()
+    { return "Définitions des types"; }
+    QString trEnumerations()
+    { return "Enumérations"; }
+    QString trFunctions()
+    { return "Fonctions"; }
+    QString trVariables()
+    { return "Variables"; }
+    QString trEnumerationValues()
+    { return "Eléments énumérés"; }
+    QString trReimplementedFrom()
+    { return "Redéfini à partir de"; }
+    QString trReimplementedIn()
+    { return "Redéfini dans"; }
+    QString trAuthor()
+    { return "Auteur"; }
+    QString trDefineDocumentation()
+    { return "Documentation de la macro"; }
+    QString trFunctionPrototypeDocumentation()
+    { return "Documentation du prototype de la fonction"; }
+    QString trTypedefDocumentation()
+    { return "Documentation du type"; }
+    QString trEnumerationTypeDocumentation()
+    { return "Documentation du type de l'énumeration"; }
+    QString trEnumerationValueDocumentation()
+    { return "Documentation de l'élément de l'énumeration"; }
+    QString trFunctionDocumentation()
+    { return "Documentation de la fonction"; }
+    QString trVariableDocumentation()
+    { return "Documentation de la variable"; }
+    QString trCompounds()
+    { return "Composants"; }
+    QString trFiles()
+    { return "Fichiers"; }
+    QString trGeneratedAt(const char *date,const char *projName)
+    { 
+      QString result=(QString)"Généré le "+date;
+      if (projName) result+=(QString)" pour "+projName;
+      result+=(QString)" par ";
+      return result;
+    }
+    QString trWrittenBy()
+    {
+      return "écrit par";
+    }
+    QString trClassDiagram(const char *clName)
+    {
+      return (QString)"Graphe d'héritage de la classe "+clName;
+    }
+    QString trForInternalUseOnly()
+    { return "A usage interne uniquement."; }
+    QString trReimplementedForInternalReasons()
+    { return "Redéfini pour des raisons internes; "
+             "l'interface n'est pas modifiée"; 
+    }
+    QString trWarning()
+    { return "Avertissement"; }
+    QString trBugsAndLimitations()
+    { return "Bogues et limitations"; }
+    QString trVersion()
+    { return "Version"; }
+    QString trDate()
+    { return "Date"; }
+    QString trAuthors()
+    { return "Auteur(s)"; }
+    QString trReturns()
+    { return "Renvoie"; }
+    QString trSeeAlso()
+    { return "Voir également"; }
+    QString trParameters()
+    { return "Paramètres"; }
+    QString trExceptions()
+    { return "Exceptions"; }
+    QString trGeneratedBy()
+    { return "Généré par"; }
+
+    // new since 0.49-990307
+    
+    virtual QString trNamespaces()
+    { return "Namespaces"; }
+    virtual QString trNamespaceList()
+    { return "List des Namespaces"; }
+    virtual QString trNamespaceListDescription(bool extractAll)
+    {
+      QString result="Liste de tous les namespaces ";
+      if (!extractAll) result+="documentés ";
+      result+="avec une brève description :";
+      return result;
+    }
+    virtual QString trFriends()
+    { return "Friends"; }
+};
+
+#endif