translator_nl.h

Go to the documentation of this file.
00001 /******************************************************************************
00002  *
00003  * $Id: translator_nl.h,v 1.22 2001/03/19 19:27:42 root Exp $
00004  *
00005  * Copyright (C) 1997-2008 by Dimitri van Heesch.
00006  *
00007  * Permission to use, copy, modify, and distribute this software and its
00008  * documentation under the terms of the GNU General Public License is hereby 
00009  * granted. No representations are made about the suitability of this software 
00010  * for any purpose. It is provided "as is" without express or implied warranty.
00011  * See the GNU General Public License for more details.
00012  *
00013  * Documents produced by Doxygen are derivative works derived from the
00014  * input used in their production; they are not affected by this license.
00015  *
00016  */
00017 
00018 #ifndef TRANSLATOR_NL_H
00019 #define TRANSLATOR_NL_H
00020 
00021 class TranslatorDutch : public Translator
00022 {
00023   public:
00024     QCString idLanguage()
00025     { return "dutch"; }
00040     QCString latexLanguageSupportCommand()
00041     {
00042       return "\\usepackage[dutch]{babel}\n";
00043     }
00045     QCString idLanguageCharset()
00046     {
00047       return "iso-8859-1";
00048     }
00049 
00050     QCString trRelatedFunctions()
00051     { return "Gerelateerde functies"; }
00052     QCString trRelatedSubscript()
00053     { return "(Merk op dat dit geen member functies zijn.)"; }
00054     QCString trDetailedDescription()
00055     { return "Gedetailleerde Beschrijving"; }
00056     QCString trMemberTypedefDocumentation()
00057     { return "Documentatie van type definitie members"; }
00058     QCString trMemberEnumerationDocumentation()
00059     { return "Documentatie van enumeratie members"; }
00060     QCString trMemberFunctionDocumentation()
00061     { return "Documentatie van functie members"; }
00062     QCString trMemberDataDocumentation()
00063     { return "Documentatie van data members"; }
00064     QCString trMore()
00065     { return "Meer..."; }
00066     QCString trListOfAllMembers()
00067     { return "Lijst van alle members."; }
00068     QCString trMemberList()
00069     { return "Member Lijst"; }
00070     QCString trThisIsTheListOfAllMembers()
00071     { return "Dit is de complete lijst van alle members voor"; }
00072     QCString trIncludingInheritedMembers()
00073     { return ", inclusief alle overgeërfde members."; }
00074     QCString trGeneratedAutomatically(const char *s)
00075     { QCString result="Automatisch gegenereerd door Doxygen"; 
00076       if (s) result+=(QCString)" voor "+s;
00077       result+=" uit de programmacode."; 
00078       return result;
00079     }
00080     QCString trEnumName()
00081     { return "enum naam"; }
00082     QCString trEnumValue()
00083     { return "enum waarde"; }
00084     QCString trDefinedIn()
00085     { return "gedefinieerd in"; }
00086     QCString trModules()
00087     { return "Modules"; }
00088     QCString trClassHierarchy()
00089     { return "Klasse Hiërarchie"; }
00090     QCString trCompoundList()
00091     { return "Klasse Lijst"; }
00092     QCString trFileList()
00093     { return "File Lijst"; }
00094     QCString trCompoundMembers()
00095     { return "Klasse Members"; }
00096     QCString trFileMembers()
00097     { return "File members"; }
00098     QCString trRelatedPages()
00099     { return "Gerelateerde pagina's"; }
00100     QCString trExamples()
00101     { return "Voorbeelden"; }
00102     QCString trSearch()
00103     { return "Zoeken"; }
00104     QCString trClassHierarchyDescription()
00105     { return "Deze inheritance lijst is min of meer alfabetisch "
00106              "gesorteerd:";
00107     }
00108     QCString trFileListDescription(bool extractAll)
00109     {
00110       QCString result="Hieronder volgt de lijst met alle ";
00111       if (!extractAll) result+="gedocumenteerde ";
00112       result+="files, elk met een korte beschrijving:";
00113       return result;
00114     }
00115     QCString trCompoundListDescription()
00116     { return "Hieronder volgen de klassen, structs en "
00117              "unions met voor elk een korte beschrijving:"; 
00118     }
00119     QCString trCompoundMembersDescription(bool extractAll)
00120     {
00121       QCString result="Hieronder volgt de lijst met alle ";
00122       if (!extractAll) result+="gedocumenteerde ";
00123       result+="klasse members met links naar ";
00124       if (!extractAll) result+="de klasse documentatie voor elke member:";
00125       else result+="de klassen waartoe ze behoren:";
00126       return result;
00127     }
00128     QCString trFileMembersDescription(bool extractAll)
00129     {
00130       QCString result="Hieronder volgt de lijst met alle ";
00131       if (!extractAll) result+="gedocumenteerde ";
00132       result+="file members met links naar ";
00133       if (extractAll) result+="de file documentatie voor elke member:";
00134       else result+="de files waartoe ze behoren:";
00135       return result;
00136     }
00137     QCString trExamplesDescription()
00138     { return "Hieronder volgt de lijst met alle voorbeelden:"; }
00139     QCString trRelatedPagesDescription()
00140     { return "Hieronder volgt de lijst met alle pagina's die gerelateerde documentatie bevatten:"; }
00141     QCString trModulesDescription()
00142     { return "Hieronder volgt de lijst met alle modules:"; }
00143 
00144     QCString trDocumentation()
00145     { return "Documentatie"; }
00146     QCString trModuleIndex()
00147     { return "Module Index"; }
00148     QCString trHierarchicalIndex()
00149     { return "Hiërarchische Index"; }
00150     QCString trCompoundIndex()
00151     { return "Klasse Index"; }
00152     QCString trFileIndex() 
00153     { return "File Index"; }
00154     QCString trModuleDocumentation()
00155     { return "Module Documentatie"; }
00156     QCString trClassDocumentation()
00157     { return "Klassen Documentatie"; }
00158     QCString trFileDocumentation()
00159     { return "File Documentatie"; }
00160     QCString trExampleDocumentation()
00161     { return "Documentatie van voorbeelden"; }
00162     QCString trPageDocumentation()
00163     { return "Documentatie van gerelateerde pagina's"; }
00164     QCString trReferenceManual()
00165     { return "Naslagwerk"; }
00166 
00167     QCString trDefines()
00168     { return "Defines"; }
00169     QCString trFuncProtos()
00170     { return "Functie Prototypes"; }
00171     QCString trTypedefs()
00172     { return "Typedefs"; }
00173     QCString trEnumerations()
00174     { return "Enumeraties"; }
00175     QCString trFunctions()
00176     { return "Functies"; }
00177     QCString trVariables()
00178     { return "Variabelen"; }
00179     QCString trEnumerationValues()
00180     { return "Enumeratie waarden"; }
00181     QCString trDefineDocumentation()
00182     { return "Documentatie van defines"; }
00183     QCString trFunctionPrototypeDocumentation()
00184     { return "Documentatie van functie Prototypes"; }
00185     QCString trTypedefDocumentation()
00186     { return "Documentatie van typedefs"; }
00187     QCString trEnumerationTypeDocumentation()
00188     { return "Documentatie van enumeratie types"; }
00189     QCString trEnumerationValueDocumentation()
00190     { return "Documentatie van enumeratie waarden"; }
00191     QCString trFunctionDocumentation()
00192     { return "Documentatie van functies"; }
00193     QCString trVariableDocumentation()
00194     { return "Documentatie van variabelen"; }
00195     QCString trCompounds()
00196     { return "Klassen"; }
00197     QCString trGeneratedAt(const char *date,const char *projName)
00198     { 
00199       QCString result=(QCString)"Gegenereerd op "+date;
00200       if (projName) result+=(QCString)" voor "+projName;
00201       result+=(QCString)" door";
00202       return result;
00203     }
00204     QCString trWrittenBy()
00205     {
00206       return "geschreven door";
00207     }
00208     QCString trClassDiagram(const char *clName)
00209     {
00210       return (QCString)"Klasse diagram voor "+clName;
00211     }
00212     QCString trForInternalUseOnly()
00213     { return "Alleen voor intern gebruik."; }
00214     QCString trWarning()
00215     { return "Waarschuwing"; }
00216     QCString trVersion()
00217     { return "Versie"; }
00218     QCString trDate()
00219     { return "Datum"; }
00220     QCString trReturns()
00221     { return "Retourneert"; }
00222     QCString trSeeAlso()
00223     { return "Zie ook"; }
00224     QCString trParameters()
00225     { return "Parameters"; }
00226     QCString trExceptions()
00227     { return "Excepties"; }
00228     QCString trGeneratedBy()
00229     { return "Gegenereerd door"; }
00230     
00232 // new since 0.49-990307 
00234     
00235     QCString trNamespaceList()
00236     { return "Namespace Lijst"; }
00237     QCString trNamespaceListDescription(bool extractAll)
00238     {
00239       QCString result="Hier is een lijst met alle ";
00240       if (!extractAll) result+="gedocumenteerde ";
00241       result+="namespaces met voor elk een korte beschrijving:";
00242       return result;
00243     }
00244     QCString trFriends()
00245     { return "Friends"; }
00246 
00248 // new since 0.49-990405
00250     
00251     QCString trRelatedFunctionDocumentation()
00252     { return "Documentatie van friends en gerelateerde functies"; }
00253     
00255 // new since 0.49-990425
00257 
00258     QCString trCompoundReference(const char *clName,
00259                                  ClassDef::CompoundType compType,
00260                                  bool isTemplate)
00261       // used as the title of the HTML page of a class/struct/union
00262     {
00263       QCString result=(QCString)clName;
00264       if (isTemplate) result+=" Template";
00265       switch(compType)
00266       {
00267         case ClassDef::Class:  result+=" Class"; break;
00268         case ClassDef::Struct: result+=" Struct"; break;
00269         case ClassDef::Union:  result+=" Union"; break;
00270         case ClassDef::Interface:  result+=" Interface"; break;
00271         case ClassDef::Protocol:  result+=" Protocol"; break;
00272         case ClassDef::Category:  result+=" Category"; break;
00273         case ClassDef::Exception:  result+=" Exception"; break;
00274       }
00275       result+=" Referentie";
00276       return result;
00277     }
00278     QCString trFileReference(const char *fileName)
00279       // used as the title of the HTML page of a file
00280     {
00281       QCString result=fileName;
00282       result+=" File Referentie"; 
00283       return result;
00284     }
00285     QCString trNamespaceReference(const char *namespaceName)
00286       // used as the title of the HTML page of a namespace
00287     {
00288       QCString result=namespaceName;
00289       result+=" Namespace Referentie";
00290       return result;
00291     }
00292     
00293     // these are for the member sections of a class, struct or union 
00294     QCString trPublicMembers()
00295     { return "Public Members"; }
00296     QCString trPublicSlots()
00297     { return "Public Slots"; }
00298     QCString trSignals()
00299     { return "Signals"; }
00300     QCString trStaticPublicMembers()
00301     { return "Static Public Members"; }
00302     QCString trProtectedMembers()
00303     { return "Protected Members"; }
00304     QCString trProtectedSlots()
00305     { return "Protected Slots"; }
00306     QCString trStaticProtectedMembers()
00307     { return "Static Protected Members"; }
00308     QCString trPrivateMembers()
00309     { return "Private Members"; }
00310     QCString trPrivateSlots()
00311     { return "Private Slots"; }
00312     QCString trStaticPrivateMembers()
00313     { return "Static Private Members"; }
00314     // end of member sections 
00315     
00316     QCString trWriteList(int numEntries)
00317     {
00318       // this function is used to produce a comma-separated list of items.
00319       // use generateMarker(i) to indicate where item i should be put.
00320       QCString result;
00321       int i;
00322       // the inherits list contain `numEntries' classes
00323       for (i=0;i<numEntries;i++) 
00324       {
00325         // use generateMarker to generate placeholders for the class links!
00326         result+=generateMarker(i); // generate marker for entry i in the list 
00327                                    // (order is left to right)
00328         
00329         if (i!=numEntries-1)  // not the last entry, so we need a separator
00330         {
00331           if (i<numEntries-2) // not the fore last entry 
00332             result+=", ";
00333           else                // the fore last entry
00334             result+=" en ";
00335         }
00336       }
00337       return result; 
00338     }
00339     
00340     QCString trInheritsList(int numEntries)
00341       // used in class documentation to produce a list of base classes,
00342       // if class diagrams are disabled.
00343     {
00344       return "Erft over van "+trWriteList(numEntries)+".";
00345     }
00346     QCString trInheritedByList(int numEntries)
00347       // used in class documentation to produce a list of super classes,
00348       // if class diagrams are disabled.
00349     {
00350       return "Wordt overge&euml;rfd door "+trWriteList(numEntries)+".";
00351     }
00352     QCString trReimplementedFromList(int numEntries)
00353       // used in member documentation blocks to produce a list of 
00354       // members that are hidden by this one.
00355     {
00356       return "Nieuwe implementatie van "+trWriteList(numEntries)+".";
00357     }
00358     QCString trReimplementedInList(int numEntries)
00359     {
00360       // used in member documentation blocks to produce a list of
00361       // all member that overwrite the implementation of this member.
00362       return "Opnieuw ge&iuml;mplementeerd in "+trWriteList(numEntries)+".";
00363     }
00364 
00365     QCString trNamespaceMembers()
00366       // This is put above each page as a link to all members of namespaces.
00367     { return "Namespace Members"; }
00368     QCString trNamespaceMemberDescription(bool extractAll)
00369       // This is an introduction to the page with all namespace members
00370     { 
00371       QCString result="Hier is een lijst van alle ";
00372       if (!extractAll) result+="gedocumenteerde ";
00373       result+="namespace members met links naar ";
00374       if (extractAll) 
00375         result+="de namespace documentatie voor iedere member:";
00376       else 
00377         result+="de namespaces waartoe ze behoren:";
00378       return result;
00379     }
00380     QCString trNamespaceIndex()
00381       // This is used in LaTeX as the title of the chapter with the 
00382       // index of all namespaces.
00383     { return "Namespace Index"; }
00384     QCString trNamespaceDocumentation()
00385       // This is used in LaTeX as the title of the chapter containing
00386       // the documentation of all namespaces.
00387     { return "Namespace Documentatie"; }
00388 
00390 // new since 0.49-990522
00392 
00396     QCString trNamespaces()
00397     {
00398       return "Namespaces";
00399     }
00400 
00402 // new since 0.49-990728
00404 
00408     QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
00409         bool single)
00410     { // here s is one of " Class", " Struct" or " Union"
00411       // single is true implies a single file
00412       QCString result=(QCString)"De documentatie voor ";
00413       switch(compType)
00414       {
00415         case ClassDef::Class:      result+="deze klasse"; break;
00416         case ClassDef::Struct:     result+="deze struct"; break;
00417         case ClassDef::Union:      result+="deze union"; break;
00418         case ClassDef::Interface:  result+="dit interface"; break;
00419         case ClassDef::Protocol:   result+="dit protocol"; break;
00420         case ClassDef::Category:   result+="deze categorie"; break;
00421         case ClassDef::Exception:  result+="deze exceptie"; break;
00422       }
00423       result+=" is gegenereerd op grond van de volgende file";
00424       if (single) result+=":"; else result+="s:";
00425       return result;
00426     }
00427 
00431     QCString trAlphabeticalList()
00432     { return "Alphabetical List"; }
00433 
00435 // new since 0.49-990901
00437 
00439     QCString trReturnValues()
00440     { return "Retour waarden"; }
00441 
00444     QCString trMainPage()
00445     { return "Hoofd Pagina"; }
00446 
00450     QCString trPageAbbreviation()
00451     { return "p."; }
00452 
00454 // new since 0.49-991106
00456 
00457     QCString trDefinedAtLineInSourceFile()
00458     {
00459       return "De definitie bevindt zich op regel @0 in de file @1.";
00460     }
00461     QCString trDefinedInSourceFile()
00462     {
00463       return "De definitie bevindt zich in de file @0.";
00464     }
00465 
00467 // new since 0.49-991205
00469 
00470     QCString trDeprecated()
00471     {
00472       return "Verouderd";
00473     }
00474 
00476 // new since 1.0.0
00478 
00480     QCString trCollaborationDiagram(const char *clName)
00481     {
00482       return (QCString)"Collaboratie diagram voor "+clName+":";
00483     }
00485     QCString trInclDepGraph(const char *fName)
00486     {
00487       return (QCString)"Include afhankelijkheidsgraaf voor "+fName+":";
00488     }
00490     QCString trConstructorDocumentation()
00491     {
00492       return "Constructor & Destructor Documentatie"; 
00493     }
00495     QCString trGotoSourceCode()
00496     {
00497       return "Ga naar de bron code van deze file.";
00498     }
00500     QCString trGotoDocumentation()
00501     {
00502       return "Ga naar de documentatie van deze file.";
00503     }
00505     QCString trPrecondition()
00506     {
00507       return "Preconditie";
00508     }
00510     QCString trPostcondition()
00511     {
00512       return "Postconditie";
00513     }
00515     QCString trInvariant()
00516     {
00517       return "Invariant";
00518     }
00520     QCString trInitialValue()
00521     {
00522       return "Initi&euml;le waarde:";
00523     }
00525     QCString trCode()
00526     {
00527       return "code";
00528     }
00529     QCString trGraphicalHierarchy()
00530     {
00531       return "Grafische Klasse Hi&euml;rarchie";
00532     }
00533     QCString trGotoGraphicalHierarchy()
00534     {
00535       return "Ga naar de grafische klasse hi&euml;rarchie";
00536     }
00537     QCString trGotoTextualHierarchy()
00538     {
00539       return "Ga naar de tekstuele klasse hi&euml;rarchie";
00540     }
00541     QCString trPageIndex()
00542     {
00543       return "Pagina Index";
00544     }
00545 
00547 // new since 1.1.0
00549     
00550     QCString trNote()
00551     {
00552       return "Noot";
00553     }
00554     QCString trPublicTypes()
00555     {
00556       return "Public Typen";
00557     }
00558     QCString trPublicAttribs()
00559     {
00560       return "Public Attributen";
00561     }
00562     QCString trStaticPublicAttribs()
00563     {
00564       return "Static Public Attributen";
00565     }
00566     QCString trProtectedTypes()
00567     {
00568       return "Protected Typen";
00569     }
00570     QCString trProtectedAttribs()
00571     {
00572       return "Protected Attributen";
00573     }
00574     QCString trStaticProtectedAttribs()
00575     {
00576       return "Static Protected Attributen";
00577     }
00578     QCString trPrivateTypes()
00579     {
00580       return "Private Typen";
00581     }
00582     QCString trPrivateAttribs()
00583     {
00584       return "Private Attributen";
00585     }
00586     QCString trStaticPrivateAttribs()
00587     {
00588       return "Static Private Attributen";
00589     }
00590 
00591 
00593 // new since 1.1.3
00595 
00597     QCString trTodo()
00598     {
00599       return "Todo";
00600     }
00602     QCString trTodoList()
00603     {
00604       return "Todo Lijst";
00605     }
00606 
00608 // new since 1.1.4
00610 
00611     QCString trReferencedBy()
00612     {
00613       return "Wordt aangeroepen door";
00614     }
00615     QCString trRemarks()
00616     {
00617       return "Opmerkingen";
00618     }
00619     QCString trAttention()
00620     {
00621       return "Attentie";
00622     }
00623     QCString trInclByDepGraph()
00624     {
00625       return "Deze graaf geeft aan welke files direct of "
00626              "indirect afhankelijk zijn van deze file:";
00627     }
00628     QCString trSince()
00629     {
00630       return "Sinds";
00631     }
00632     
00634 // new since 1.1.5
00636 
00638     QCString trLegendTitle()
00639     {
00640       return "Graaf Legenda";
00641     }
00643     QCString trLegendDocs()
00644     {
00645       return 
00646         "Deze pagina legt uit hoe de grafen die gegenereerd worden door doxygen "
00647         "ge&iuml;nterpreteerd dienen te worden.<p>\n"
00648         "Beschouw het volgende voorbeeld:\n"
00649         "\\code\n"
00650         "/*! Onzichtbare klasse vanwege afkappen van de graaf */\n"
00651         "class Invisible { };\n\n"
00652         "/*! Afgekapte klasse, overervingsrelatie is verborgen */\n"
00653         "class Truncated : public Invisible { };\n\n"
00654         "/* Klasse is niet gedocumenteerd met doxygen commentaar */\n"
00655         "class Undocumented { };\n\n"
00656         "/*! Klasse met public inheritance */\n"
00657         "class PublicBase : public Truncated { };\n\n"
00658         "/*! A template class */\n"
00659         "template<class T> class Templ { };\n\n"
00660         "/*! Klasse met protected inheritance */\n"
00661         "class ProtectedBase { };\n\n"
00662         "/*! Klasse met private inheritance */\n"
00663         "class PrivateBase { };\n\n"
00664         "/*! Klasse die wordt gebruikt door de klasse Inherited */\n"
00665         "class Used { };\n\n"
00666         "/*! Super klasse die overerft van een aantal andere klassen */\n"
00667         "class Inherited : public PublicBase,\n"
00668         "                  protected ProtectedBase,\n"
00669         "                  private PrivateBase,\n"
00670         "                  public Undocumented,\n"
00671         "                  public Templ<int>\n"
00672         "{\n"
00673         "  private:\n"
00674         "    Used *m_usedClass;\n"
00675         "};\n"
00676         "\\endcode\n"
00677         "Als de \\c MAX_DOT_GRAPH_HEIGHT tag in the configuratie file "
00678         "op 200 gezet is, zal het bestaande voorbeeld resulteren in de volgende graaf:"
00679         "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
00680         "<p>\n"
00681         "De rechthoeken in the bovenstaande graaf hebben de volgende betekenis:\n"
00682         "<ul>\n"
00683         "<li>Een gevulde grijze rechthoek representeert de structure of klasse waarvoor "
00684         "de graaf is gegeneerd.\n"
00685         "<li>Een rechthoek met een zwarte rand representeert een gedocumenteerde structure of klasse.\n"
00686         "<li>Een rechthoek met een grijze rand representeert een ongedocumenteerde structure of klasse.\n"
00687         "<li>Een rechthoek met een rode rand representeert een gedocumenteerde structure or klasse waarvoor\n"
00688         "niet alle overervings- of gebruiksrelaties konden worden getoond. Een graaf wordt "
00689         "afgekapt als hij niet past binnen de gespecificeerde grenzen."
00690         "</ul>\n"
00691         "De pijlen hebben de volgende betekenis:\n"
00692         "<ul>\n"
00693         "<li>Een donkerblauwe pijl visualizeert een public inheritance "
00694         "relatie tussen twee klassen.\n"
00695         "<li>Een donkergroene pijl wordt gebruikt voor protected inheritance.\n"
00696         "<li>Een donkerrode pijl wordt gebruikt voor private inheritance.\n"
00697         "<li>Een paars gestippelde pijl wordt gebruikt indien een klasse bevat is of gebruikt wordt "
00698         "door een andere klasse. De pijl is gelabeled met de variable(n) "
00699         "die toegang geven tot de aangewezen klasse of structure. \n"
00700         "<li>Een geel gestippelde pijl wordt gebruikt om een relatie tussen een \n"
00701         "template instantie en een template klasse aan te geven. De pijl is gelabeld met \n"
00702         "template parameters van de instantie.\n"
00703         "</ul>\n";
00704     }
00706     QCString trLegend()
00707     {
00708       return "legenda";
00709     }
00710 
00712 // new since 1.2.0
00714     
00716     QCString trTest()
00717     {
00718       return "Test";
00719     }
00721     QCString trTestList()
00722     {
00723       return "Test Lijst";
00724     }
00725 
00727 // new since 1.2.1
00729 
00731     QCString trDCOPMethods()
00732     {
00733       return "DCOP Methoden";
00734     }
00735 
00737 // new since 1.2.2
00739 
00741     QCString trProperties()
00742     {
00743       return "Properties";
00744     }
00746     QCString trPropertyDocumentation()
00747     {
00748       return "Property Documentatie";
00749     }
00750     
00752 // new since 1.2.4
00754 
00756     QCString trClasses()
00757     {
00758       return "Klassen";
00759     }
00761     QCString trPackage(const char *name)
00762     {
00763       return (QCString)"Package "+name;
00764     }
00766     QCString trPackageList()
00767     {
00768       return "Package Lijst";
00769     }
00771     QCString trPackageListDescription()
00772     {
00773       return "Hier volgen de packages, elk met een korte beschrijving (indien aanwezig):";
00774     }
00776     QCString trPackages()
00777     {
00778       return "Packages";
00779     }
00781     QCString trDefineValue()
00782     {
00783       return "Waarde:";
00784     }
00785     
00787 // new since 1.2.5
00789     
00791     QCString trBug()
00792     {
00793       return "Bug";
00794     }
00796     QCString trBugList()
00797     {
00798       return "Bug Lijst";
00799     }
00800 
00802 // new since 1.2.6
00804 
00830     virtual QCString trRTFansicp()
00831     {
00832       return "1252";
00833     }
00834     
00835 
00839     virtual QCString trRTFCharSet()
00840     {
00841       return "0";
00842     }
00843 
00845     virtual QCString trRTFGeneralIndex()
00846     {
00847       return "Index";
00848     }
00849    
00854     virtual QCString trClass(bool first_capital, bool singular)
00855     { 
00856       QCString result((first_capital ? "Klasse" : "klass"));
00857       if (!singular)  result+="n";
00858       return result; 
00859     }
00860 
00865     virtual QCString trFile(bool first_capital, bool singular)
00866     { 
00867       QCString result((first_capital ? "File" : "file"));
00868       if (!singular)  result+="s";
00869       return result; 
00870     }
00871 
00876     virtual QCString trNamespace(bool first_capital, bool singular)
00877     { 
00878       QCString result((first_capital ? "Namespace" : "namespace"));
00879       if (!singular)  result+="s";
00880       return result; 
00881     }
00882 
00887     virtual QCString trGroup(bool first_capital, bool singular)
00888     { 
00889       QCString result((first_capital ? "Groep" : "groep"));
00890       if (!singular)  result+="en";
00891       return result; 
00892     }
00893 
00898     virtual QCString trPage(bool first_capital, bool singular)
00899     { 
00900       QCString result((first_capital ? "Pagina" : "pagina"));
00901       if (!singular)  result+="s";
00902       return result; 
00903     }
00904 
00909     virtual QCString trMember(bool first_capital, bool singular)
00910     { 
00911       QCString result((first_capital ? "Member" : "member"));
00912       if (!singular)  result+="s";
00913       return result; 
00914     }
00915    
00920     virtual QCString trGlobal(bool first_capital, bool singular)
00921     { 
00922       QCString result((first_capital ? "Globale member" : "globale member"));
00923       if (!singular)  result+="s";
00924       return result; 
00925     }
00926 
00928 // new since 1.2.7
00930 
00933     virtual QCString trAuthor(bool first_capital, bool singular)
00934     {                                                                         
00935       QCString result((first_capital ? "Auteur" : "auteur"));
00936       if (!singular)  result+="s";
00937       return result; 
00938     }
00939 
00941 // new since 1.2.11
00943 
00946     virtual QCString trReferences()
00947     {
00948       return "Gebruikt";
00949     }
00950 
00952 // new since 1.2.13
00954 
00958     virtual QCString trImplementedFromList(int numEntries)
00959     {
00960       return "Implementeert "+trWriteList(numEntries)+".";
00961     }
00962 
00966     virtual QCString trImplementedInList(int numEntries)
00967     {
00968       return "Wordt ge&iuml;mplementeerd door "+trWriteList(numEntries)+".";
00969     }
00970 
00972 // new since 1.2.16
00974 
00975     virtual QCString trRTFTableOfContents()
00976     { return "Inhoudsopgave"; }
00977 
00979 // new since 1.2.17
00981 
00985     virtual QCString trDeprecatedList()
00986     {
00987       return "Deprecated Lijst";
00988     }
00989 
00991 // new since 1.2.18
00993 
00996     virtual QCString trEvents()
00997     {
00998       return "Events";
00999     }
01001     virtual QCString trEventDocumentation()
01002     {
01003       return "Event Documentatie";
01004     }
01005 
01007 // new since 1.3
01009 
01012     virtual QCString trPackageTypes()
01013     { 
01014       return "Package Types";
01015     }
01019     virtual QCString trPackageMembers()
01020     { 
01021       return "Package Functies";
01022     }
01026     virtual QCString trStaticPackageMembers()
01027     { 
01028       return "Statische Package Functies";
01029     }
01033     virtual QCString trPackageAttribs()
01034     { 
01035       return "Package Attributen";
01036     }
01040     virtual QCString trStaticPackageAttribs()
01041     { 
01042       return "Statische Package Attributen";
01043     }
01044 
01046 // new since 1.3.1
01048 
01052     virtual QCString trAll()
01053     {
01054       return "Alle";
01055     }
01057     virtual QCString trCallGraph()
01058     {
01059       return "Hier is de call graaf voor deze functie:";
01060     }
01061 
01063 // new since 1.3.3
01065 
01069     virtual QCString trSearchForIndex()
01070     {
01071       return "Zoek naar";
01072     }
01076     virtual QCString trSearchResultsTitle()
01077     {
01078       return "Zoek Resultaten";
01079     }
01088     virtual QCString trSearchResults(int numDocuments)
01089     {
01090       if (numDocuments==0)
01091       {
01092         return "Helaas, er zijn geen documenten gevonden die aan de zoekopdracht voldoen.";
01093       }
01094       else if (numDocuments==1)
01095       {
01096         return "Er is <b>1</b> document gevonden dat aan de zoekopdracht voldoet.";
01097       }
01098       else 
01099       {
01100         return "Er zijn <b>$num</b> documenten gevonden die aan de zoekopdracht voldoen. "
01101                "De beste resultaten worden eerst getoond.";
01102       }
01103     }
01107     virtual QCString trSearchMatches()
01108     {
01109       return "Gevonden:";
01110     }
01111 
01113 // new since 1.3.8
01115 
01118     virtual QCString trSourceFile(QCString& filename)
01119     {
01120       return filename + " Bron Bestand";
01121     }
01122 
01124 // new since 1.3.9
01126 
01130     virtual QCString trDirIndex()
01131     { return "Directory Hi&euml;rarchie"; }
01132 
01136     virtual QCString trDirDocumentation()
01137     { return "Directory Documentatie"; }
01138 
01142     virtual QCString trDirectories()
01143     { return "Directories"; }
01144 
01148     virtual QCString trDirDescription()
01149     { return "Deze directory hi&euml;rarchie is min of meer alfabetisch "
01150              "gesorteerd:";
01151     }
01152 
01156     virtual QCString trDirReference(const char *dirName)
01157     { QCString result=dirName; result+=" Directory Referentie"; return result; }
01158 
01162     virtual QCString trDir(bool first_capital, bool singular)
01163     { 
01164       QCString result((first_capital ? "Director" : "director"));
01165       if (singular) result+="y"; else result+="ies";
01166       return result; 
01167     }
01168 
01170 // new since 1.4.1
01172 
01176     virtual QCString trOverloadText()
01177     {
01178       return "Deze functie is overloaded en is beschikbaar gemaakt om het "
01179              "gebruik te vergemakkelijken. Ze verschilt alleen van de "
01180              "bovenstaande functie wat betreft de parameterlijst.";
01181     }
01182 
01184 // new since 1.4.6
01186 
01188     virtual QCString trCallerGraph()
01189     {
01190       return "Hier is de caller graaf voor deze functie:";
01191     }
01192     
01194     virtual QCString trMemberFunctionDocumentationFortran()
01195     { return "Member Function/Subroutine Documentation"; }
01196 
01198 // new since 1.5.4 (mainly for Fortran)
01200 
01202     virtual QCString trCompoundListFortran()
01203     { return "Lijst met data types"; }
01204 
01206     virtual QCString trCompoundMembersFortran()
01207     { return "Data velden"; }
01208 
01210     virtual QCString trCompoundListDescriptionFortran()
01211     { return "Hieronder volgen de data types elk een korte beschrijving:"; }
01212 
01214     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
01215     {
01216       QCString result="Hieronder volgt de lijst met alle ";
01217       if (!extractAll) result+="gedocumenteerde ";
01218       result+="data types met links naar ";
01219       if (!extractAll) result+="de klasse documentatie voor elke member:";
01220       else result+="de klassen waartoe ze behoren:";
01221       return result;
01222     }
01223 
01227     virtual QCString trCompoundIndexFortran()
01228     { return "Data Type Index"; }
01229 
01233     virtual QCString trTypeDocumentation()
01234     { return "Data Type Documentatie"; }
01235 
01239     virtual QCString trSubprograms()
01240     { return "Functies/Subroutines"; }
01241 
01245     virtual QCString trSubprogramDocumentation()
01246     { return "Functie/Subroutine Documentatie"; }
01247 
01251      virtual QCString trDataTypes()
01252     { return "Data Types"; }
01253     
01255     virtual QCString trModulesList()
01256     { return "Module Lijst"; }
01257 
01259     virtual QCString trModulesListDescription(bool extractAll)
01260     {
01261       QCString result="Hieronder volgt de lijst met alle ";
01262       if (!extractAll) result+="gedocumenteerde ";
01263       result+="modulen, elk met een korte beschrijving:";
01264       return result;
01265     }
01266 
01268     virtual QCString trCompoundReferenceFortran(const char *clName,
01269                                     ClassDef::CompoundType compType,
01270                                     bool isTemplate)
01271     {
01272       QCString result=(QCString)clName;
01273       switch(compType)
01274       {
01275         case ClassDef::Class:      result+=" Module"; break;
01276         case ClassDef::Struct:     result+=" Type"; break;
01277         case ClassDef::Union:      result+=" Union"; break;
01278         case ClassDef::Interface:  result+=" Interface"; break;
01279         case ClassDef::Protocol:   result+=" Protocol"; break;
01280         case ClassDef::Category:   result+=" Category"; break;
01281         case ClassDef::Exception:  result+=" Exception"; break;
01282       }
01283       if (isTemplate) result+=" Template";
01284       result+=" Referentie";
01285       return result;
01286     }
01288     virtual QCString trModuleReference(const char *namespaceName)
01289     {
01290       QCString result=namespaceName;
01291       result+=" Module Referentie";        
01292       return result;
01293     }
01294     
01296     virtual QCString trModulesMembers()
01297     { return "Module Members"; }
01298 
01300     virtual QCString trModulesMemberDescription(bool extractAll)
01301     { 
01302       QCString result="Hier is een lijst van alle ";
01303       if (!extractAll) result+="gedocumenteerde ";
01304       result+="module members met links naar ";
01305       if (extractAll) 
01306         result+="de module documentatie voor iedere member:";
01307       else 
01308         result+="de module waartoe ze behoren:";
01309       return result;
01310     }
01311 
01315     virtual QCString trModulesIndex()
01316     { return "Module Index"; }
01317     
01322     virtual QCString trModule(bool first_capital, bool singular)
01323     {       
01324       QCString result((first_capital ? "Module" : "module"));
01325       if (!singular)  result+="n";
01326       return result; 
01327     }
01331     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
01332         bool single)
01333     { // here s is one of " Class", " Struct" or " Union"
01334       // single is true implies a single file
01335       QCString result=(QCString)"De documentatie voor ";
01336       switch(compType)
01337       {
01338         case ClassDef::Class:      result+="deze module"; break;
01339         case ClassDef::Struct:     result+="dit type"; break;
01340         case ClassDef::Union:      result+="deze union"; break;
01341         case ClassDef::Interface:  result+="dit interface"; break;
01342         case ClassDef::Protocol:   result+="dit protocol"; break;
01343         case ClassDef::Category:   result+="deze category"; break;
01344         case ClassDef::Exception:  result+="deze exception"; break;
01345       }
01346       result+=" is gegenereerd op grond van de volgende file";
01347       if (single) result+=":"; else result+="s:";
01348       return result;
01349     }
01354     virtual QCString trType(bool first_capital, bool singular)
01355     { 
01356       QCString result((first_capital ? "Type" : "type"));
01357       if (!singular)  result+="s";
01358       return result; 
01359     }
01364     virtual QCString trSubprogram(bool first_capital, bool singular)
01365     { 
01366       QCString result((first_capital ? "Subprogramma" : "subprogramma"));
01367       if (!singular)  result+="s";
01368       return result; 
01369     }
01370 
01372     virtual QCString trTypeConstraints()
01373     {
01374       return "Type Beperkingen";
01375     }
01376 };
01377 
01378 #endif



Generated on Mon Mar 31 10:58:47 2008 by  doxygen 1.5.1