mods for doxygen-0.49-990728

1 files changed, 126 insertions, 126 deletions

diff --git a/src/translator_nl.h b/src/translator_nl.h
index c9a96bc..f5ceea9 100644
--- a/src/translator_nl.h
+++ b/src/translator_nl.h
@@ -17,253 +17,253 @@
 #ifndef TRANSLATOR_NL_H
 #define TRANSLATOR_NL_H
 
-#include <qstring.h>
+#include "translator.h"
 
 class TranslatorDutch : public Translator
 {
   public:
-    QString latexBabelPackage()
+    QCString latexBabelPackage()
     { return "dutch"; }
-    QString trRelatedFunctions()
+    QCString trRelatedFunctions()
     { return "Gerelateerde functies"; }
-    QString trRelatedSubscript()
+    QCString trRelatedSubscript()
     { return "(Merk op dat dit geen member functies zijn.)"; }
-    QString trDetailedDescription()
+    QCString trDetailedDescription()
     { return "Gedetaileerde Beschrijving"; }
-    QString trMemberTypedefDocumentation()
+    QCString trMemberTypedefDocumentation()
     { return "Documentatie van type definitie members"; }
-    QString trMemberEnumerationDocumentation()
+    QCString trMemberEnumerationDocumentation()
     { return "Documentatie van enumeratie members"; }
-    QString trEnumerationValueDocumentation()
+    QCString trEnumerationValueDocumentation()
     { return "Documentatie van enumeratie waarden"; }
-    QString trMemberFunctionDocumentation()
+    QCString trMemberFunctionDocumentation()
     { return "Documentatie van functie members"; }
-    QString trMemberDataDocumentation()
+    QCString trMemberDataDocumentation()
     { return "Documentatie van data members"; }
-    QString trGeneratedFrom(const char *s,bool single)
+    QCString trGeneratedFrom(const char *s,bool single)
     { 
-      QString result=(QString)"De documentatie voor deze"+s+
+      QCString result=(QCString)"De documentatie voor deze"+s+
                      " is gegenereerd op grond van de volgende file";
       if (single) result+=":";   else result+="s:";
       return result;
     }
-    QString trMore()
+    QCString trMore()
     { return "Meer..."; }
-    QString trListOfAllMembers()
+    QCString trListOfAllMembers()
     { return "Lijst van alle members."; }
-    QString trMemberList()
+    QCString trMemberList()
     { return "Member Lijst"; }
-    QString trThisIsTheListOfAllMembers()
+    QCString trThisIsTheListOfAllMembers()
     { return "Dit is de complete lijst van alle members voor"; }
-    QString trIncludingInheritedMembers()
+    QCString trIncludingInheritedMembers()
     { return ", inclusief alle overge&euml;rfde members."; }
-    QString trGeneratedAutomatically(const char *s)
-    { QString result="Automatisch gegenereerd door Doxygen"; 
-      if (s) result+=(QString)" voor "+s;
+    QCString trGeneratedAutomatically(const char *s)
+    { QCString result="Automatisch gegenereerd door Doxygen"; 
+      if (s) result+=(QCString)" voor "+s;
       result+=" uit de programmacode."; 
       return result;
     }
-    QString trEnumName()
+    QCString trEnumName()
     { return "enum naam"; }
-    QString trEnumValue()
+    QCString trEnumValue()
     { return "enum waarde"; }
-    QString trDefinedIn()
+    QCString trDefinedIn()
     { return "gedefinieerd in"; }
-    QString trVerbatimText(const char *f)
-    { return (QString)"Dit is de letterlijke tekst van de include file "+f+"."; }
-    QString trModules()
+    QCString trVerbatimText(const char *f)
+    { return (QCString)"Dit is de letterlijke tekst van de include file "+f+"."; }
+    QCString trModules()
     { return "Modules"; }
-    QString trClassHierarchy()
+    QCString trClassHierarchy()
     { return "Klasse Hi&euml;rarchie"; }
-    QString trCompoundList()
+    QCString trCompoundList()
     { return "Compound Lijst"; }
-    QString trFileList()
+    QCString trFileList()
     { return "File Lijst"; }
-    QString trHeaderFiles()
+    QCString trHeaderFiles()
     { return "Header Lijst"; }
-    QString trCompoundMembers()
+    QCString trCompoundMembers()
     { return "Compound Members"; }
-    QString trFileMembers()
+    QCString trFileMembers()
     { return "File members"; }
-    QString trRelatedPages()
+    QCString trRelatedPages()
     { return "Gerelateerde pagina's"; }
-    QString trExamples()
+    QCString trExamples()
     { return "Voorbeelden"; }
-    QString trSearch()
+    QCString trSearch()
     { return "Zoeken"; }
-    QString trClassHierarchyDescription()
+    QCString trClassHierarchyDescription()
     { return "Deze inheritance lijst is min of meer alfabetisch "
              "gesorteerd:";
     }
-    QString trFileListDescription(bool extractAll)
+    QCString trFileListDescription(bool extractAll)
     {
-      QString result="Hieronder volgt de lijst met alle ";
+      QCString result="Hieronder volgt de lijst met alle ";
       if (!extractAll) result+="gedocumenteerde ";
       result+="files, elk met een korte beschrijving:";
       return result;
     }
-    QString trCompoundListDescription()
+    QCString trCompoundListDescription()
     { return "Hieronder volgen de klassen, structs en "
              "unions met voor elk een korte beschrijving:"; 
     }
-    QString trCompoundMembersDescription(bool extractAll)
+    QCString trCompoundMembersDescription(bool extractAll)
     {
-      QString result="Hieronder volgt de lijst met alle ";
+      QCString result="Hieronder volgt de lijst met alle ";
       if (!extractAll) result+="gedocumenteerde ";
       result+="klasse members met links naar ";
       if (extractAll) result+="de klasse documentatie voor elke member:";
       else result+="de klassen waartoe ze behoren:";
       return result;
     }
-    QString trFileMembersDescription(bool extractAll)
+    QCString trFileMembersDescription(bool extractAll)
     {
-      QString result="Hieronder volgt de lijst met alle ";
+      QCString result="Hieronder volgt de lijst met alle ";
       if (!extractAll) result+="gedocumenteerde ";
       result+="file members met links naar ";
       if (extractAll) result+="de file documentatie voor elke member:";
       else result+="de files waartoe ze behoren:";
       return result;
     }
-    QString trHeaderFilesDescription()
+    QCString trHeaderFilesDescription()
     { return "Hieronder volgen de header files die de API vormen:"; }
-    QString trExamplesDescription()
+    QCString trExamplesDescription()
     { return "Hieronder volgt de lijst met alle voorbeelden:"; }
-    QString trRelatedPagesDescription()
+    QCString trRelatedPagesDescription()
     { return "Hieronder volgt de lijst met alle pagina's die gerelateerde documentatie bevatten:"; }
-    QString trModulesDescription()
+    QCString trModulesDescription()
     { return "Hieronder volgt de lijst met alle modules:"; }
-    QString trNoDescriptionAvailable()
+    QCString trNoDescriptionAvailable()
     { return "Geen korte beschrijving beschikbaar"; }
 
-    QString trDocumentation()
+    QCString trDocumentation()
     { return "Documentatie"; }
-    QString trModuleIndex()
+    QCString trModuleIndex()
     { return "Module Index"; }
-    QString trHierarchicalIndex()
+    QCString trHierarchicalIndex()
     { return "Hi&euml;rarchische Index"; }
-    QString trCompoundIndex()
+    QCString trCompoundIndex()
     { return "Compound Index"; }
-    QString trFileIndex() 
+    QCString trFileIndex() 
     { return "File Index"; }
-    QString trModuleDocumentation()
+    QCString trModuleDocumentation()
     { return "Module Documentatie"; }
-    QString trClassDocumentation()
+    QCString trClassDocumentation()
     { return "Klasse Documentatie"; }
-    QString trFileDocumentation()
+    QCString trFileDocumentation()
     { return "File Documentatie"; }
-    QString trExampleDocumentation()
+    QCString trExampleDocumentation()
     { return "Documentatie van voorbeelden"; }
-    QString trPageDocumentation()
+    QCString trPageDocumentation()
     { return "Documentatie van gerelateerde pagina's"; }
-    QString trReferenceManual()
+    QCString trReferenceManual()
     { return "Naslagwerk"; }
 
-    QString trDefines()
+    QCString trDefines()
     { return "Defines"; }
-    QString trFuncProtos()
+    QCString trFuncProtos()
     { return "Functie Prototypes"; }
-    QString trTypedefs()
+    QCString trTypedefs()
     { return "Typedefs"; }
-    QString trEnumerations()
+    QCString trEnumerations()
     { return "Enumeraties"; }
-    QString trFunctions()
+    QCString trFunctions()
     { return "Functies"; }
-    QString trVariables()
+    QCString trVariables()
     { return "Variabelen"; }
-    QString trEnumerationValues()
+    QCString trEnumerationValues()
     { return "Enumeratie waarden"; }
-    QString trAuthor()
+    QCString trAuthor()
     { return "auteur"; }
-    QString trDefineDocumentation()
+    QCString trDefineDocumentation()
     { return "Documentatie van defines"; }
-    QString trFunctionPrototypeDocumentation()
+    QCString trFunctionPrototypeDocumentation()
     { return "Documentatie van functie Prototypes"; }
-    QString trTypedefDocumentation()
+    QCString trTypedefDocumentation()
     { return "Documentatie van typedefs"; }
-    QString trEnumerationTypeDocumentation()
+    QCString trEnumerationTypeDocumentation()
     { return "Documentatie van enumeratie types"; }
-    QString trFunctionDocumentation()
+    QCString trFunctionDocumentation()
     { return "Documentatie van functies"; }
-    QString trVariableDocumentation()
+    QCString trVariableDocumentation()
     { return "Documentatie van variabelen"; }
-    QString trCompounds()
+    QCString trCompounds()
     { return "Compounds"; }
-    QString trFiles()
+    QCString trFiles()
     { return "Files"; }
-    QString trGeneratedAt(const char *date,const char *projName)
+    QCString trGeneratedAt(const char *date,const char *projName)
     { 
-      QString result=(QString)"Gegenereerd op "+date;
-      if (projName) result+=(QString)" voor "+projName;
-      result+=(QString)" door";
+      QCString result=(QCString)"Gegenereerd op "+date;
+      if (projName) result+=(QCString)" voor "+projName;
+      result+=(QCString)" door";
       return result;
     }
-    QString trWrittenBy()
+    QCString trWrittenBy()
     {
       return "geschreven door";
     }
-    QString trClassDiagram(const char *clName)
+    QCString trClassDiagram(const char *clName)
     {
-      return (QString)"Klasse diagram voor "+clName;
+      return (QCString)"Klasse diagram voor "+clName;
     }
-    QString trForInternalUseOnly()
+    QCString trForInternalUseOnly()
     { return "Alleen voor intern gebruik."; }
-    QString trReimplementedForInternalReasons()
+    QCString trReimplementedForInternalReasons()
     { return "Om interne rederene opnieuwd ge&iuml;mplemented; "
              "de API wordt er niet door be&iuml;nvloed."; 
     }
-    QString trWarning()
+    QCString trWarning()
     { return "Waarschuwing"; }
-    QString trBugsAndLimitations()
+    QCString trBugsAndLimitations()
     { return "Fouten en beperkingen"; }
-    QString trVersion()
+    QCString trVersion()
     { return "Versie"; }
-    QString trDate()
+    QCString trDate()
     { return "Datum"; }
-    QString trAuthors()
+    QCString trAuthors()
     { return "Auteur(s)"; }
-    QString trReturns()
+    QCString trReturns()
     { return "Retourneerd"; }
-    QString trSeeAlso()
+    QCString trSeeAlso()
     { return "Zie ook"; }
-    QString trParameters()
+    QCString trParameters()
     { return "Parameters"; }
-    QString trExceptions()
+    QCString trExceptions()
     { return "Excepties"; }
-    QString trGeneratedBy()
+    QCString trGeneratedBy()
     { return "Gegenereerd door"; }
     
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990307 
 //////////////////////////////////////////////////////////////////////////
     
-    QString trNamespaceList()
+    QCString trNamespaceList()
     { return "Namespace Lijst"; }
-    QString trNamespaceListDescription(bool extractAll)
+    QCString trNamespaceListDescription(bool extractAll)
     {
-      QString result="Hier is een lijst met alle ";
+      QCString result="Hier is een lijst met alle ";
       if (!extractAll) result+="gedocumenteerde ";
       result+="namespaces met voor elk een korte beschrijving:";
       return result;
     }
-    QString trFriends()
+    QCString trFriends()
     { return "Friends"; }
 
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990405
 //////////////////////////////////////////////////////////////////////////
     
-    QString trRelatedFunctionDocumentation()
+    QCString trRelatedFunctionDocumentation()
     { return "Documentatie van friends en gerelateerde functies"; }
     
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990425
 //////////////////////////////////////////////////////////////////////////
 
-    virtual QString trCompoundReference(const char *clName,
+    virtual QCString trCompoundReference(const char *clName,
                                     ClassDef::CompoundType compType)
       // used as the title of the HTML page of a class/struct/union
     {
-      QString result=(QString)clName+" ";
+      QCString result=(QCString)clName+" ";
       switch(compType)
       {
         case ClassDef::Class:  result+=" Class"; break;
@@ -273,49 +273,49 @@ class TranslatorDutch : public Translator
       result+=" Referentie";
       return result;
     }
-    virtual QString trFileReference(const char *fileName)
+    virtual QCString trFileReference(const char *fileName)
       // used as the title of the HTML page of a file
     {
-      QString result=fileName;
+      QCString result=fileName;
       result+=" File Referentie"; 
       return result;
     }
-    virtual QString trNamespaceReference(const char *namespaceName)
+    virtual QCString trNamespaceReference(const char *namespaceName)
       // used as the title of the HTML page of a namespace
     {
-      QString result=namespaceName;
+      QCString result=namespaceName;
       result+=" Namespace Referentie";
       return result;
     }
     
     // these are for the member sections of a class, struct or union 
-    virtual QString trPublicMembers()
+    virtual QCString trPublicMembers()
     { return "Public Members"; }
-    virtual QString trPublicSlots()
+    virtual QCString trPublicSlots()
     { return "Public Slots"; }
-    virtual QString trSignals()
+    virtual QCString trSignals()
     { return "Signals"; }
-    virtual QString trStaticPublicMembers()
+    virtual QCString trStaticPublicMembers()
     { return "Static Public Members"; }
-    virtual QString trProtectedMembers()
+    virtual QCString trProtectedMembers()
     { return "Protected Members"; }
-    virtual QString trProtectedSlots()
+    virtual QCString trProtectedSlots()
     { return "Protected Slots"; }
-    virtual QString trStaticProtectedMembers()
+    virtual QCString trStaticProtectedMembers()
     { return "Static Protected Members"; }
-    virtual QString trPrivateMembers()
+    virtual QCString trPrivateMembers()
     { return "Private Members"; }
-    virtual QString trPrivateSlots()
+    virtual QCString trPrivateSlots()
     { return "Private Slots"; }
-    virtual QString trStaticPrivateMembers()
+    virtual QCString trStaticPrivateMembers()
     { return "Static Private Members"; }
     // end of member sections 
     
-    virtual QString trWriteList(int numEntries)
+    virtual QCString trWriteList(int numEntries)
     {
       // this function is used to produce a comma-separated list of items.
       // use generateMarker(i) to indicate where item i should be put.
-      QString result;
+      QCString result;
       int i;
       // the inherits list contain `numEntries' classes
       for (i=0;i<numEntries;i++) 
@@ -335,38 +335,38 @@ class TranslatorDutch : public Translator
       return result; 
     }
     
-    virtual QString trInheritsList(int numEntries)
+    virtual QCString trInheritsList(int numEntries)
       // used in class documentation to produce a list of base classes,
       // if class diagrams are disabled.
     {
       return "Erft over van "+trWriteList(numEntries)+".";
     }
-    virtual QString trInheritedByList(int numEntries)
+    virtual QCString trInheritedByList(int numEntries)
       // used in class documentation to produce a list of super classes,
       // if class diagrams are disabled.
     {
       return "Wordt overge&euml;rfd door "+trWriteList(numEntries)+".";
     }
-    virtual QString trReimplementedFromList(int numEntries)
+    virtual QCString trReimplementedFromList(int numEntries)
       // used in member documentation blocks to produce a list of 
       // members that are hidden by this one.
     {
       return "Nieuwe implementatie van "+trWriteList(numEntries)+".";
     }
-    virtual QString trReimplementedInList(int numEntries)
+    virtual QCString trReimplementedInList(int numEntries)
     {
       // used in member documentation blocks to produce a list of
       // all member that overwrite the implementation of this member.
       return "Opnieuw ge&iuml;mplementeerd in "+trWriteList(numEntries)+".";
     }
 
-    virtual QString trNamespaceMembers()
+    virtual QCString trNamespaceMembers()
       // This is put above each page as a link to all members of namespaces.
     { return "Namespace Members"; }
-    virtual QString trNamespaceMemberDescription(bool extractAll)
+    virtual QCString trNamespaceMemberDescription(bool extractAll)
       // This is an introduction to the page with all namespace members
     { 
-      QString result="Hier is een lijst van alle ";
+      QCString result="Hier is een lijst van alle ";
       if (!extractAll) result+="gedocumenteerde ";
       result+="namespace members met links naar ";
       if (extractAll) 
@@ -375,11 +375,11 @@ class TranslatorDutch : public Translator
         result+="de namespaces waartoe ze behoren:";
       return result;
     }
-    virtual QString trNamespaceIndex()
+    virtual QCString trNamespaceIndex()
       // This is used in LaTeX as the title of the chapter with the 
       // index of all namespaces.
     { return "Namespace Index"; }
-    virtual QString trNamespaceDocumentation()
+    virtual QCString trNamespaceDocumentation()
       // This is used in LaTeX as the title of the chapter containing
       // the documentation of all namespaces.
     { return "Namespace Documentatie"; }