Chameleon

Chameleon Svn Source Tree

Root/branches/xZenu/src/util/doxygen/src/translator_nl.h

Source at commit 1322 created 12 years 8 months ago.
By meklort, Add doxygen to utils folder
1/******************************************************************************␊
2 *␊
3 * $Id: translator_nl.h,v 1.22 2001/03/19 19:27:42 root Exp $␊
4 *␊
5 * Copyright (C) 1997-2011 by Dimitri van Heesch.␊
6 *␊
7 * Permission to use, copy, modify, and distribute this software and its␊
8 * documentation under the terms of the GNU General Public License is hereby ␊
9 * granted. No representations are made about the suitability of this software ␊
10 * for any purpose. It is provided "as is" without express or implied warranty.␊
11 * See the GNU General Public License for more details.␊
12 *␊
13 * Documents produced by Doxygen are derivative works derived from the␊
14 * input used in their production; they are not affected by this license.␊
15 *␊
16 */␊
17␊
18#ifndef TRANSLATOR_NL_H␊
19#define TRANSLATOR_NL_H␊
20␊
21class TranslatorDutch : public Translator␊
22{␊
23 public:␊
24 QCString idLanguage()␊
25 { return "dutch"; }␊
26 /*! Used to get the LaTeX command(s) for the language support. ␊
27 * This method should return string with commands that switch␊
28 * LaTeX to the desired language. For example ␊
29 * <pre>"\\usepackage[german]{babel}\n"␊
30 * </pre>␊
31 * or␊
32 * <pre>"\\usepackage{polski}\n"␊
33 * "\\usepackage[latin2]{inputenc}\n"␊
34 * "\\usepackage[T1]{fontenc}\n"␊
35 * </pre>␊
36 */␊
37 QCString latexLanguageSupportCommand()␊
38 {␊
39 return "\\usepackage[dutch]{babel}\n";␊
40 }␊
41 /*! return the language charset. This will be used for the HTML output */␊
42 QCString idLanguageCharset()␊
43 {␊
44 return "iso-8859-1";␊
45 }␊
46␊
47 QCString trRelatedFunctions()␊
48 { return "Gerelateerde functies"; }␊
49 QCString trRelatedSubscript()␊
50 { return "(Merk op dat dit geen member functies zijn.)"; }␊
51 QCString trDetailedDescription()␊
52 { return "Gedetailleerde Beschrijving"; }␊
53 QCString trMemberTypedefDocumentation()␊
54 { return "Documentatie van type definitie members"; }␊
55 QCString trMemberEnumerationDocumentation()␊
56 { return "Documentatie van enumeratie members"; }␊
57 QCString trMemberFunctionDocumentation()␊
58 { return "Documentatie van functie members"; }␊
59 QCString trMemberDataDocumentation()␊
60 { return "Documentatie van data members"; }␊
61 QCString trMore()␊
62 { return "Meer..."; }␊
63 QCString trListOfAllMembers()␊
64 { return "Lijst van alle members."; }␊
65 QCString trMemberList()␊
66 { return "Member Lijst"; }␊
67 QCString trThisIsTheListOfAllMembers()␊
68 { return "Dit is de complete lijst van alle members voor"; }␊
69 QCString trIncludingInheritedMembers()␊
70 { return ", inclusief alle overge&euml;rfde members."; }␊
71 QCString trGeneratedAutomatically(const char *s)␊
72 { QCString result="Automatisch gegenereerd door Doxygen"; ␊
73 if (s) result+=(QCString)" voor "+s;␊
74 result+=" uit de programmatekst."; ␊
75 return result;␊
76 }␊
77 QCString trEnumName()␊
78 { return "enum naam"; }␊
79 QCString trEnumValue()␊
80 { return "enum waarde"; }␊
81 QCString trDefinedIn()␊
82 { return "gedefinieerd in"; }␊
83 QCString trModules()␊
84 { return "Modules"; }␊
85 QCString trClassHierarchy()␊
86 { return "Klasse Hi&euml;rarchie"; }␊
87 QCString trCompoundList()␊
88 { return "Klasse Lijst"; }␊
89 QCString trFileList()␊
90 { return "Bestandslijst"; }␊
91 QCString trCompoundMembers()␊
92 { return "Klasse Members"; }␊
93 QCString trFileMembers()␊
94 { return "Bestand members"; }␊
95 QCString trRelatedPages()␊
96 { return "Gerelateerde pagina's"; }␊
97 QCString trExamples()␊
98 { return "Voorbeelden"; }␊
99 QCString trSearch()␊
100 { return "Zoeken"; }␊
101 QCString trClassHierarchyDescription()␊
102 { return "Deze inheritance lijst is min of meer alfabetisch "␊
103 "gesorteerd:";␊
104 }␊
105 QCString trFileListDescription(bool extractAll)␊
106 {␊
107 QCString result="Hieronder volgt de lijst met alle ";␊
108 if (!extractAll) result+="gedocumenteerde ";␊
109 result+="bestanden, elk met een korte beschrijving:";␊
110 return result;␊
111 }␊
112 QCString trCompoundListDescription()␊
113 { return "Hieronder volgen de klassen, structs en "␊
114 "unions met voor elk een korte beschrijving:"; ␊
115 }␊
116 QCString trCompoundMembersDescription(bool extractAll)␊
117 {␊
118 QCString result="Hieronder volgt de lijst met alle ";␊
119 if (!extractAll) result+="gedocumenteerde ";␊
120 result+="klasse members met links naar ";␊
121 if (!extractAll) result+="de klasse documentatie voor elke member:";␊
122 else result+="de klassen waartoe ze behoren:";␊
123 return result;␊
124 }␊
125 QCString trFileMembersDescription(bool extractAll)␊
126 {␊
127 QCString result="Hieronder volgt de lijst met alle ";␊
128 if (!extractAll) result+="gedocumenteerde ";␊
129 result+="bestand members met links naar ";␊
130 if (extractAll) result+="de bestand's documentatie voor elke member:";␊
131 else result+="de bestanden waartoe ze behoren:";␊
132 return result;␊
133 }␊
134 QCString trExamplesDescription()␊
135 { return "Hieronder volgt de lijst met alle voorbeelden:"; }␊
136 QCString trRelatedPagesDescription()␊
137 { return "Hieronder volgt de lijst met alle pagina's die gerelateerde documentatie bevatten:"; }␊
138 QCString trModulesDescription()␊
139 { return "Hieronder volgt de lijst met alle modules:"; }␊
140␊
141 QCString trDocumentation()␊
142 { return "Documentatie"; }␊
143 QCString trModuleIndex()␊
144 { return "Module Index"; }␊
145 QCString trHierarchicalIndex()␊
146 { return "Hi&euml;rarchische Index"; }␊
147 QCString trCompoundIndex()␊
148 { return "Klasse Index"; }␊
149 QCString trFileIndex() ␊
150 { return "Bestand Index"; }␊
151 QCString trModuleDocumentation()␊
152 { return "Module Documentatie"; }␊
153 QCString trClassDocumentation()␊
154 { return "Klassen Documentatie"; }␊
155 QCString trFileDocumentation()␊
156 { return "Bestand Documentatie"; }␊
157 QCString trExampleDocumentation()␊
158 { return "Documentatie van voorbeelden"; }␊
159 QCString trPageDocumentation()␊
160 { return "Documentatie van gerelateerde pagina's"; }␊
161 QCString trReferenceManual()␊
162 { return "Naslagwerk"; }␊
163␊
164 QCString trDefines()␊
165 { return "Defines"; }␊
166 QCString trFuncProtos()␊
167 { return "Functie Prototypes"; }␊
168 QCString trTypedefs()␊
169 { return "Typedefs"; }␊
170 QCString trEnumerations()␊
171 { return "Enumeraties"; }␊
172 QCString trFunctions()␊
173 { return "Functies"; }␊
174 QCString trVariables()␊
175 { return "Variabelen"; }␊
176 QCString trEnumerationValues()␊
177 { return "Enumeratie waarden"; }␊
178 QCString trDefineDocumentation()␊
179 { return "Documentatie van defines"; }␊
180 QCString trFunctionPrototypeDocumentation()␊
181 { return "Documentatie van functie Prototypes"; }␊
182 QCString trTypedefDocumentation()␊
183 { return "Documentatie van typedefs"; }␊
184 QCString trEnumerationTypeDocumentation()␊
185 { return "Documentatie van enumeratie types"; }␊
186 QCString trEnumerationValueDocumentation()␊
187 { return "Documentatie van enumeratie waarden"; }␊
188 QCString trFunctionDocumentation()␊
189 { return "Documentatie van functies"; }␊
190 QCString trVariableDocumentation()␊
191 { return "Documentatie van variabelen"; }␊
192 QCString trCompounds()␊
193 { return "Klassen"; }␊
194 QCString trGeneratedAt(const char *date,const char *projName)␊
195 { ␊
196 QCString result=(QCString)"Gegenereerd op "+date;␊
197 if (projName) result+=(QCString)" voor "+projName;␊
198 result+=(QCString)" door";␊
199 return result;␊
200 }␊
201 QCString trWrittenBy()␊
202 {␊
203 return "geschreven door";␊
204 }␊
205 QCString trClassDiagram(const char *clName)␊
206 {␊
207 return (QCString)"Klasse diagram voor "+clName;␊
208 }␊
209 QCString trForInternalUseOnly()␊
210 { return "Alleen voor intern gebruik."; }␊
211 QCString trWarning()␊
212 { return "Waarschuwing"; }␊
213 QCString trVersion()␊
214 { return "Versie"; }␊
215 QCString trDate()␊
216 { return "Datum"; }␊
217 QCString trReturns()␊
218 { return "Retourneert"; }␊
219 QCString trSeeAlso()␊
220 { return "Zie ook"; }␊
221 QCString trParameters()␊
222 { return "Parameters"; }␊
223 QCString trExceptions()␊
224 { return "Excepties"; }␊
225 QCString trGeneratedBy()␊
226 { return "Gegenereerd door"; }␊
227 ␊
228//////////////////////////////////////////////////////////////////////////␊
229// new since 0.49-990307 ␊
230//////////////////////////////////////////////////////////////////////////␊
231 ␊
232 QCString trNamespaceList()␊
233 { return "Namespace Lijst"; }␊
234 QCString trNamespaceListDescription(bool extractAll)␊
235 {␊
236 QCString result="Hier is een lijst met alle ";␊
237 if (!extractAll) result+="gedocumenteerde ";␊
238 result+="namespaces met voor elk een korte beschrijving:";␊
239 return result;␊
240 }␊
241 QCString trFriends()␊
242 { return "Friends"; }␊
243␊
244//////////////////////////////////////////////////////////////////////////␊
245// new since 0.49-990405␊
246//////////////////////////////////////////////////////////////////////////␊
247 ␊
248 QCString trRelatedFunctionDocumentation()␊
249 { return "Documentatie van friends en gerelateerde functies"; }␊
250 ␊
251//////////////////////////////////////////////////////////////////////////␊
252// new since 0.49-990425␊
253//////////////////////////////////////////////////////////////////////////␊
254␊
255 QCString trCompoundReference(const char *clName,␊
256 ClassDef::CompoundType compType,␊
257 bool isTemplate)␊
258 // used as the title of the HTML page of a class/struct/union␊
259 {␊
260 QCString result=(QCString)clName;␊
261 if (isTemplate) result+=" Template";␊
262 switch(compType)␊
263 {␊
264 case ClassDef::Class: result+=" Class"; break;␊
265 case ClassDef::Struct: result+=" Struct"; break;␊
266 case ClassDef::Union: result+=" Union"; break;␊
267 case ClassDef::Interface: result+=" Interface"; break;␊
268 case ClassDef::Protocol: result+=" Protocol"; break;␊
269 case ClassDef::Category: result+=" Category"; break;␊
270 case ClassDef::Exception: result+=" Exception"; break;␊
271 }␊
272 result+=" Referentie";␊
273 return result;␊
274 }␊
275 QCString trFileReference(const char *fileName)␊
276 // used as the title of the HTML page of a file␊
277 {␊
278 QCString result=fileName;␊
279 result+=" Bestand Referentie"; ␊
280 return result;␊
281 }␊
282 QCString trNamespaceReference(const char *namespaceName)␊
283 // used as the title of the HTML page of a namespace␊
284 {␊
285 QCString result=namespaceName;␊
286 result+=" Namespace Referentie";␊
287 return result;␊
288 }␊
289 ␊
290 // these are for the member sections of a class, struct or union ␊
291 QCString trPublicMembers()␊
292 { return "Public Members"; }␊
293 QCString trPublicSlots()␊
294 { return "Public Slots"; }␊
295 QCString trSignals()␊
296 { return "Signals"; }␊
297 QCString trStaticPublicMembers()␊
298 { return "Static Public Members"; }␊
299 QCString trProtectedMembers()␊
300 { return "Protected Members"; }␊
301 QCString trProtectedSlots()␊
302 { return "Protected Slots"; }␊
303 QCString trStaticProtectedMembers()␊
304 { return "Static Protected Members"; }␊
305 QCString trPrivateMembers()␊
306 { return "Private Members"; }␊
307 QCString trPrivateSlots()␊
308 { return "Private Slots"; }␊
309 QCString trStaticPrivateMembers()␊
310 { return "Static Private Members"; }␊
311 // end of member sections ␊
312 ␊
313 QCString trWriteList(int numEntries)␊
314 {␊
315 // this function is used to produce a comma-separated list of items.␊
316 // use generateMarker(i) to indicate where item i should be put.␊
317 QCString result;␊
318 int i;␊
319 // the inherits list contain `numEntries' classes␊
320 for (i=0;i<numEntries;i++) ␊
321 {␊
322 // use generateMarker to generate placeholders for the class links!␊
323 result+=generateMarker(i); // generate marker for entry i in the list ␊
324 // (order is left to right)␊
325 ␊
326 if (i!=numEntries-1) // not the last entry, so we need a separator␊
327 {␊
328 if (i<numEntries-2) // not the fore last entry ␊
329 result+=", ";␊
330 else // the fore last entry␊
331 result+=" en ";␊
332 }␊
333 }␊
334 return result; ␊
335 }␊
336 ␊
337 QCString trInheritsList(int numEntries)␊
338 // used in class documentation to produce a list of base classes,␊
339 // if class diagrams are disabled.␊
340 {␊
341 return "Erft over van "+trWriteList(numEntries)+".";␊
342 }␊
343 QCString trInheritedByList(int numEntries)␊
344 // used in class documentation to produce a list of super classes,␊
345 // if class diagrams are disabled.␊
346 {␊
347 return "Wordt overge&euml;rfd door "+trWriteList(numEntries)+".";␊
348 }␊
349 QCString trReimplementedFromList(int numEntries)␊
350 // used in member documentation blocks to produce a list of ␊
351 // members that are hidden by this one.␊
352 {␊
353 return "Nieuwe implementatie van "+trWriteList(numEntries)+".";␊
354 }␊
355 QCString trReimplementedInList(int numEntries)␊
356 {␊
357 // used in member documentation blocks to produce a list of␊
358 // all member that overwrite the implementation of this member.␊
359 return "Opnieuw ge&iuml;mplementeerd in "+trWriteList(numEntries)+".";␊
360 }␊
361␊
362 QCString trNamespaceMembers()␊
363 // This is put above each page as a link to all members of namespaces.␊
364 { return "Namespace Members"; }␊
365 QCString trNamespaceMemberDescription(bool extractAll)␊
366 // This is an introduction to the page with all namespace members␊
367 { ␊
368 QCString result="Hier is een lijst van alle ";␊
369 if (!extractAll) result+="gedocumenteerde ";␊
370 result+="namespace members met links naar ";␊
371 if (extractAll) ␊
372 result+="de namespace documentatie voor iedere member:";␊
373 else ␊
374 result+="de namespaces waartoe ze behoren:";␊
375 return result;␊
376 }␊
377 QCString trNamespaceIndex()␊
378 // This is used in LaTeX as the title of the chapter with the ␊
379 // index of all namespaces.␊
380 { return "Namespace Index"; }␊
381 QCString trNamespaceDocumentation()␊
382 // This is used in LaTeX as the title of the chapter containing␊
383 // the documentation of all namespaces.␊
384 { return "Namespace Documentatie"; }␊
385␊
386//////////////////////////////////////////////////////////////////////////␊
387// new since 0.49-990522␊
388//////////////////////////////////////////////////////////////////////////␊
389␊
390 /*! This is used in the documentation before the list of all␊
391 * namespaces in a file.␊
392 */␊
393 QCString trNamespaces()␊
394 {␊
395 return "Namespaces";␊
396 }␊
397␊
398//////////////////////////////////////////////////////////////////////////␊
399// new since 0.49-990728␊
400//////////////////////////////////////////////////////////////////////////␊
401␊
402 /*! This is put at the bottom of a class documentation page and is␊
403 * followed by a list of files that were used to generate the page.␊
404 */␊
405 QCString trGeneratedFromFiles(ClassDef::CompoundType compType,␊
406 bool single)␊
407 { // here s is one of " Class", " Struct" or " Union"␊
408 // single is true implies a single file␊
409 QCString result=(QCString)"De documentatie voor ";␊
410 switch(compType)␊
411 {␊
412 case ClassDef::Class: result+="deze klasse"; break;␊
413 case ClassDef::Struct: result+="deze struct"; break;␊
414 case ClassDef::Union: result+="deze union"; break;␊
415 case ClassDef::Interface: result+="dit interface"; break;␊
416 case ClassDef::Protocol: result+="dit protocol"; break;␊
417 case ClassDef::Category: result+="deze categorie"; break;␊
418 case ClassDef::Exception: result+="deze exceptie"; break;␊
419 }␊
420 result+=" is gegenereerd op grond van het volgende bestand";␊
421 if (single) result+=":"; else result+="s:";␊
422 return result;␊
423 }␊
424␊
425 /*! This is in the (quick) index as a link to the alphabetical compound␊
426 * list.␊
427 */␊
428 QCString trAlphabeticalList()␊
429 { return "Alphabetical List"; }␊
430␊
431//////////////////////////////////////////////////////////////////////////␊
432// new since 0.49-990901␊
433//////////////////////////////////////////////////////////////////////////␊
434␊
435 /*! This is used as the heading text for the retval command. */␊
436 QCString trReturnValues()␊
437 { return "Retour waarden"; }␊
438␊
439 /*! This is in the (quick) index as a link to the main page (index.html)␊
440 */␊
441 QCString trMainPage()␊
442 { return "Hoofd Pagina"; }␊
443␊
444 /*! This is used in references to page that are put in the LaTeX ␊
445 * documentation. It should be an abbreviation of the word page.␊
446 */␊
447 QCString trPageAbbreviation()␊
448 { return "p."; }␊
449␊
450//////////////////////////////////////////////////////////////////////////␊
451// new since 0.49-991106␊
452//////////////////////////////////////////////////////////////////////////␊
453␊
454 QCString trDefinedAtLineInSourceFile()␊
455 {␊
456 return "De definitie bevindt zich op regel @0 in het bestand @1.";␊
457 }␊
458 QCString trDefinedInSourceFile()␊
459 {␊
460 return "De definitie bevindt zich in het bestand @0.";␊
461 }␊
462␊
463//////////////////////////////////////////////////////////////////////////␊
464// new since 0.49-991205␊
465//////////////////////////////////////////////////////////////////////////␊
466␊
467 QCString trDeprecated()␊
468 {␊
469 return "Verouderd";␊
470 }␊
471␊
472//////////////////////////////////////////////////////////////////////////␊
473// new since 1.0.0␊
474//////////////////////////////////////////////////////////////////////////␊
475␊
476 /*! this text is put before a collaboration diagram */␊
477 QCString trCollaborationDiagram(const char *clName)␊
478 {␊
479 return (QCString)"Collaboratie diagram voor "+clName+":";␊
480 }␊
481 /*! this text is put before an include dependency graph */␊
482 QCString trInclDepGraph(const char *fName)␊
483 {␊
484 return (QCString)"Include afhankelijkheidsgraaf voor "+fName+":";␊
485 }␊
486 /*! header that is put before the list of constructor/destructors. */␊
487 QCString trConstructorDocumentation()␊
488 {␊
489 return "Constructor & Destructor Documentatie"; ␊
490 }␊
491 /*! Used in the file documentation to point to the corresponding sources. */␊
492 QCString trGotoSourceCode()␊
493 {␊
494 return "Ga naar de broncode van dit bestand.";␊
495 }␊
496 /*! Used in the file sources to point to the corresponding documentation. */␊
497 QCString trGotoDocumentation()␊
498 {␊
499 return "Ga naar de documentatie van dit bestand.";␊
500 }␊
501 /*! Text for the \\pre command */␊
502 QCString trPrecondition()␊
503 {␊
504 return "Preconditie";␊
505 }␊
506 /*! Text for the \\post command */␊
507 QCString trPostcondition()␊
508 {␊
509 return "Postconditie";␊
510 }␊
511 /*! Text for the \\invariant command */␊
512 QCString trInvariant()␊
513 {␊
514 return "Invariant";␊
515 }␊
516 /*! Text shown before a multi-line variable/enum initialization */␊
517 QCString trInitialValue()␊
518 {␊
519 return "Initi&euml;le waarde:";␊
520 }␊
521 /*! Text used the source code in the file index */␊
522 QCString trCode()␊
523 {␊
524 return "code";␊
525 }␊
526 QCString trGraphicalHierarchy()␊
527 {␊
528 return "Grafische Klasse Hi&euml;rarchie";␊
529 }␊
530 QCString trGotoGraphicalHierarchy()␊
531 {␊
532 return "Ga naar de grafische klasse hi&euml;rarchie";␊
533 }␊
534 QCString trGotoTextualHierarchy()␊
535 {␊
536 return "Ga naar de tekstuele klasse hi&euml;rarchie";␊
537 }␊
538 QCString trPageIndex()␊
539 {␊
540 return "Pagina Index";␊
541 }␊
542␊
543//////////////////////////////////////////////////////////////////////////␊
544// new since 1.1.0␊
545//////////////////////////////////////////////////////////////////////////␊
546 ␊
547 QCString trNote()␊
548 {␊
549 return "Noot";␊
550 }␊
551 QCString trPublicTypes()␊
552 {␊
553 return "Public Typen";␊
554 }␊
555 QCString trPublicAttribs()␊
556 {␊
557 return "Public Attributen";␊
558 }␊
559 QCString trStaticPublicAttribs()␊
560 {␊
561 return "Static Public Attributen";␊
562 }␊
563 QCString trProtectedTypes()␊
564 {␊
565 return "Protected Typen";␊
566 }␊
567 QCString trProtectedAttribs()␊
568 {␊
569 return "Protected Attributen";␊
570 }␊
571 QCString trStaticProtectedAttribs()␊
572 {␊
573 return "Static Protected Attributen";␊
574 }␊
575 QCString trPrivateTypes()␊
576 {␊
577 return "Private Typen";␊
578 }␊
579 QCString trPrivateAttribs()␊
580 {␊
581 return "Private Attributen";␊
582 }␊
583 QCString trStaticPrivateAttribs()␊
584 {␊
585 return "Static Private Attributen";␊
586 }␊
587␊
588␊
589//////////////////////////////////////////////////////////////////////////␊
590// new since 1.1.3␊
591//////////////////////////////////////////////////////////////////////////␊
592␊
593 /*! Used as a marker that is put before a todo item */␊
594 QCString trTodo()␊
595 {␊
596 return "Todo";␊
597 }␊
598 /*! Used as the header of the todo list */␊
599 QCString trTodoList()␊
600 {␊
601 return "Todo Lijst";␊
602 }␊
603␊
604//////////////////////////////////////////////////////////////////////////␊
605// new since 1.1.4␊
606//////////////////////////////////////////////////////////////////////////␊
607␊
608 QCString trReferencedBy()␊
609 {␊
610 return "Wordt aangeroepen door";␊
611 }␊
612 QCString trRemarks()␊
613 {␊
614 return "Opmerkingen";␊
615 }␊
616 QCString trAttention()␊
617 {␊
618 return "Attentie";␊
619 }␊
620 QCString trInclByDepGraph()␊
621 {␊
622 return "Deze graaf geeft aan welke bestanden direct of "␊
623 "indirect afhankelijk zijn van dit bestand:";␊
624 }␊
625 QCString trSince()␊
626 {␊
627 return "Sinds";␊
628 }␊
629 ␊
630//////////////////////////////////////////////////////////////////////////␊
631// new since 1.1.5␊
632//////////////////////////////////////////////////////////////////////////␊
633␊
634 /*! title of the graph legend page */␊
635 QCString trLegendTitle()␊
636 {␊
637 return "Graaf Legenda";␊
638 }␊
639 /*! page explaining how the dot graph's should be interpreted */␊
640 QCString trLegendDocs()␊
641 {␊
642 return ␊
643 "Deze pagina legt uit hoe de grafen die gegenereerd worden door doxygen "␊
644 "ge&iuml;nterpreteerd dienen te worden.<p>\n"␊
645 "Beschouw het volgende voorbeeld:\n"␊
646 "\\code\n"␊
647 "/*! Onzichtbare klasse vanwege afkappen van de graaf */\n"␊
648 "class Invisible { };\n\n"␊
649 "/*! Afgekapte klasse, overervingsrelatie is verborgen */\n"␊
650 "class Truncated : public Invisible { };\n\n"␊
651 "/* Klasse is niet gedocumenteerd met doxygen commentaar */\n"␊
652 "class Undocumented { };\n\n"␊
653 "/*! Klasse met public inheritance */\n"␊
654 "class PublicBase : public Truncated { };\n\n"␊
655 "/*! A template class */\n"␊
656 "template<class T> class Templ { };\n\n"␊
657 "/*! Klasse met protected inheritance */\n"␊
658 "class ProtectedBase { };\n\n"␊
659 "/*! Klasse met private inheritance */\n"␊
660 "class PrivateBase { };\n\n"␊
661 "/*! Klasse die wordt gebruikt door de klasse Inherited */\n"␊
662 "class Used { };\n\n"␊
663 "/*! Super klasse die overerft van een aantal andere klassen */\n"␊
664 "class Inherited : public PublicBase,\n"␊
665 " protected ProtectedBase,\n"␊
666 " private PrivateBase,\n"␊
667 " public Undocumented,\n"␊
668 " public Templ<int>\n"␊
669 "{\n"␊
670 " private:\n"␊
671 " Used *m_usedClass;\n"␊
672 "};\n"␊
673 "\\endcode\n"␊
674 "Dit voorbeeld zal resulteren in de volgende graaf:"␊
675 "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"␊
676 "<p>\n"␊
677 "De rechthoeken in the bovenstaande graaf hebben de volgende betekenis:\n"␊
678 "<ul>\n"␊
679 "<li>Een gevulde grijze rechthoek representeert de structure of klasse waarvoor "␊
680 "de graaf is gegeneerd.\n"␊
681 "<li>Een rechthoek met een zwarte rand representeert een gedocumenteerde structure of klasse.\n"␊
682 "<li>Een rechthoek met een grijze rand representeert een ongedocumenteerde structure of klasse.\n"␊
683 "<li>Een rechthoek met een rode rand representeert een gedocumenteerde structure or klasse waarvoor\n"␊
684 "niet alle overervings- of gebruiksrelaties konden worden getoond. Een graaf wordt "␊
685 "afgekapt als hij niet past binnen de gespecificeerde grenzen."␊
686 "</ul>\n"␊
687 "De pijlen hebben de volgende betekenis:\n"␊
688 "<ul>\n"␊
689 "<li>Een donkerblauwe pijl visualizeert een public inheritance "␊
690 "relatie tussen twee klassen.\n"␊
691 "<li>Een donkergroene pijl wordt gebruikt voor protected inheritance.\n"␊
692 "<li>Een donkerrode pijl wordt gebruikt voor private inheritance.\n"␊
693 "<li>Een paars gestippelde pijl wordt gebruikt indien een klasse bevat is of gebruikt wordt "␊
694 "door een andere klasse. De pijl is gelabeled met de variable(n) "␊
695 "die toegang geven tot de aangewezen klasse of structure. \n"␊
696 "<li>Een geel gestippelde pijl wordt gebruikt om een relatie tussen een \n"␊
697 "template instantie en een template klasse aan te geven. De pijl is gelabeld met \n"␊
698 "template parameters van de instantie.\n"␊
699 "</ul>\n";␊
700 }␊
701 /*! text for the link to the legend page */␊
702 QCString trLegend()␊
703 {␊
704 return "legenda";␊
705 }␊
706␊
707//////////////////////////////////////////////////////////////////////////␊
708// new since 1.2.0␊
709//////////////////////////////////////////////////////////////////////////␊
710 ␊
711 /*! Used as a marker that is put before a test item */␊
712 QCString trTest()␊
713 {␊
714 return "Test";␊
715 }␊
716 /*! Used as the header of the test list */␊
717 QCString trTestList()␊
718 {␊
719 return "Test Lijst";␊
720 }␊
721␊
722//////////////////////////////////////////////////////////////////////////␊
723// new since 1.2.1␊
724//////////////////////////////////////////////////////////////////////////␊
725␊
726 /*! Used as a section header for KDE-2 IDL methods */␊
727 QCString trDCOPMethods()␊
728 {␊
729 return "DCOP Methoden";␊
730 }␊
731␊
732//////////////////////////////////////////////////////////////////////////␊
733// new since 1.2.2␊
734//////////////////////////////////////////////////////////////////////////␊
735␊
736 /*! Used as a section header for IDL properties */␊
737 QCString trProperties()␊
738 {␊
739 return "Properties";␊
740 }␊
741 /*! Used as a section header for IDL property documentation */␊
742 QCString trPropertyDocumentation()␊
743 {␊
744 return "Property Documentatie";␊
745 }␊
746 ␊
747//////////////////////////////////////////////////////////////////////////␊
748// new since 1.2.4␊
749//////////////////////////////////////////////////////////////////////////␊
750␊
751 /*! Used for Java classes in the summary section of Java packages */␊
752 QCString trClasses()␊
753 {␊
754 return "Klassen";␊
755 }␊
756 /*! Used as the title of a Java package */␊
757 QCString trPackage(const char *name)␊
758 {␊
759 return (QCString)"Package "+name;␊
760 }␊
761 /*! Title of the package index page */␊
762 QCString trPackageList()␊
763 {␊
764 return "Package Lijst";␊
765 }␊
766 /*! The description of the package index page */␊
767 QCString trPackageListDescription()␊
768 {␊
769 return "Hier volgen de packages, elk met een korte beschrijving (indien aanwezig):";␊
770 }␊
771 /*! The link name in the Quick links header for each page */␊
772 QCString trPackages()␊
773 {␊
774 return "Packages";␊
775 }␊
776 /*! Text shown before a multi-line define */␊
777 QCString trDefineValue()␊
778 {␊
779 return "Waarde:";␊
780 }␊
781 ␊
782//////////////////////////////////////////////////////////////////////////␊
783// new since 1.2.5␊
784//////////////////////////////////////////////////////////////////////////␊
785 ␊
786 /*! Used as a marker that is put before a \\bug item */␊
787 QCString trBug()␊
788 {␊
789 return "Bug";␊
790 }␊
791 /*! Used as the header of the bug list */␊
792 QCString trBugList()␊
793 {␊
794 return "Bug Lijst";␊
795 }␊
796␊
797//////////////////////////////////////////////////////////////////////////␊
798// new since 1.2.6␊
799//////////////////////////////////////////////////////////////////////////␊
800␊
801 /*! Used as ansicpg for RTF file ␊
802 * ␊
803 * The following table shows the correlation of Charset name, Charset Value and ␊
804 * <pre>␊
805 * Codepage number:␊
806 * Charset Name Charset Value(hex) Codepage number␊
807 * ------------------------------------------------------␊
808 * DEFAULT_CHARSET 1 (x01)␊
809 * SYMBOL_CHARSET 2 (x02)␊
810 * OEM_CHARSET 255 (xFF)␊
811 * ANSI_CHARSET 0 (x00) 1252␊
812 * RUSSIAN_CHARSET 204 (xCC) 1251␊
813 * EE_CHARSET 238 (xEE) 1250␊
814 * GREEK_CHARSET 161 (xA1) 1253␊
815 * TURKISH_CHARSET 162 (xA2) 1254␊
816 * BALTIC_CHARSET 186 (xBA) 1257␊
817 * HEBREW_CHARSET 177 (xB1) 1255␊
818 * ARABIC _CHARSET 178 (xB2) 1256␊
819 * SHIFTJIS_CHARSET 128 (x80) 932␊
820 * HANGEUL_CHARSET 129 (x81) 949␊
821 * GB2313_CHARSET 134 (x86) 936␊
822 * CHINESEBIG5_CHARSET 136 (x88) 950␊
823 * </pre>␊
824 * ␊
825 */␊
826 virtual QCString trRTFansicp()␊
827 {␊
828 return "1252";␊
829 }␊
830 ␊
831␊
832 /*! Used as ansicpg for RTF fcharset ␊
833 * \see trRTFansicp() for a table of possible values.␊
834 */␊
835 virtual QCString trRTFCharSet()␊
836 {␊
837 return "0";␊
838 }␊
839␊
840 /*! Used as header RTF general index */␊
841 virtual QCString trRTFGeneralIndex()␊
842 {␊
843 return "Index";␊
844 }␊
845 ␊
846 /*! This is used for translation of the word that will possibly␊
847 * be followed by a single name or by a list of names ␊
848 * of the category.␊
849 */␊
850 virtual QCString trClass(bool first_capital, bool singular)␊
851 { ␊
852 QCString result((first_capital ? "Klasse" : "klass"));␊
853 if (!singular) result+="n";␊
854 return result; ␊
855 }␊
856␊
857 /*! This is used for translation of the word that will possibly␊
858 * be followed by a single name or by a list of names ␊
859 * of the category.␊
860 */␊
861 virtual QCString trFile(bool first_capital, bool singular)␊
862 { ␊
863 QCString result((first_capital ? "Bestand" : "bestand"));␊
864 if (!singular) result+="en";␊
865 return result; ␊
866 }␊
867␊
868 /*! This is used for translation of the word that will possibly␊
869 * be followed by a single name or by a list of names ␊
870 * of the category.␊
871 */␊
872 virtual QCString trNamespace(bool first_capital, bool singular)␊
873 { ␊
874 QCString result((first_capital ? "Namespace" : "namespace"));␊
875 if (!singular) result+="s";␊
876 return result; ␊
877 }␊
878␊
879 /*! This is used for translation of the word that will possibly␊
880 * be followed by a single name or by a list of names ␊
881 * of the category.␊
882 */␊
883 virtual QCString trGroup(bool first_capital, bool singular)␊
884 { ␊
885 QCString result((first_capital ? "Groep" : "groep"));␊
886 if (!singular) result+="en";␊
887 return result; ␊
888 }␊
889␊
890 /*! This is used for translation of the word that will possibly␊
891 * be followed by a single name or by a list of names ␊
892 * of the category.␊
893 */␊
894 virtual QCString trPage(bool first_capital, bool singular)␊
895 { ␊
896 QCString result((first_capital ? "Pagina" : "pagina"));␊
897 if (!singular) result+="s";␊
898 return result; ␊
899 }␊
900␊
901 /*! This is used for translation of the word that will possibly␊
902 * be followed by a single name or by a list of names ␊
903 * of the category.␊
904 */␊
905 virtual QCString trMember(bool first_capital, bool singular)␊
906 { ␊
907 QCString result((first_capital ? "Member" : "member"));␊
908 if (!singular) result+="s";␊
909 return result; ␊
910 }␊
911 ␊
912 /*! This is used for translation of the word that will possibly␊
913 * be followed by a single name or by a list of names ␊
914 * of the category.␊
915 */␊
916 virtual QCString trGlobal(bool first_capital, bool singular)␊
917 { ␊
918 QCString result((first_capital ? "Globale member" : "globale member"));␊
919 if (!singular) result+="s";␊
920 return result; ␊
921 }␊
922␊
923//////////////////////////////////////////////////////////////////////////␊
924// new since 1.2.7␊
925//////////////////////////////////////////////////////////////////////////␊
926␊
927 /*! This text is generated when the \\author command is used and␊
928 * for the author section in man pages. */␊
929 virtual QCString trAuthor(bool first_capital, bool singular)␊
930 { ␊
931 QCString result((first_capital ? "Auteur" : "auteur"));␊
932 if (!singular) result+="s";␊
933 return result; ␊
934 }␊
935␊
936//////////////////////////////////////////////////////////////////////////␊
937// new since 1.2.11␊
938//////////////////////////////////////////////////////////////////////////␊
939␊
940 /*! This text is put before the list of members referenced by a member␊
941 */␊
942 virtual QCString trReferences()␊
943 {␊
944 return "Gebruikt";␊
945 }␊
946␊
947//////////////////////////////////////////////////////////////////////////␊
948// new since 1.2.13␊
949//////////////////////////////////////////////////////////////////////////␊
950␊
951 /*! used in member documentation blocks to produce a list of ␊
952 * members that are implemented by this one.␊
953 */␊
954 virtual QCString trImplementedFromList(int numEntries)␊
955 {␊
956 return "Implementeert "+trWriteList(numEntries)+".";␊
957 }␊
958␊
959 /*! used in member documentation blocks to produce a list of␊
960 * all members that implementation this member.␊
961 */␊
962 virtual QCString trImplementedInList(int numEntries)␊
963 {␊
964 return "Wordt ge&iuml;mplementeerd door "+trWriteList(numEntries)+".";␊
965 }␊
966␊
967//////////////////////////////////////////////////////////////////////////␊
968// new since 1.2.16␊
969//////////////////////////////////////////////////////////////////////////␊
970␊
971 virtual QCString trRTFTableOfContents()␊
972 { return "Inhoudsopgave"; }␊
973␊
974//////////////////////////////////////////////////////////////////////////␊
975// new since 1.2.17␊
976//////////////////////////////////////////////////////////////////////////␊
977␊
978 /*! Used as the header of the list of item that have been ␊
979 * flagged deprecated ␊
980 */␊
981 virtual QCString trDeprecatedList()␊
982 {␊
983 return "Deprecated Lijst";␊
984 }␊
985␊
986//////////////////////////////////////////////////////////////////////////␊
987// new since 1.2.18␊
988//////////////////////////////////////////////////////////////////////////␊
989␊
990 /*! Used as a header for a section of events found in a C# program␊
991 */␊
992 virtual QCString trEvents()␊
993 {␊
994 return "Events";␊
995 }␊
996 /*! Header used for the documentation section of a class' events. */␊
997 virtual QCString trEventDocumentation()␊
998 {␊
999 return "Event Documentatie";␊
1000 }␊
1001␊
1002//////////////////////////////////////////////////////////////////////////␊
1003// new since 1.3␊
1004//////////////////////////////////////////////////////////////////////////␊
1005␊
1006 /*! Used as a heading for a list of Java class types with package scope.␊
1007 */␊
1008 virtual QCString trPackageTypes()␊
1009 { ␊
1010 return "Package Types";␊
1011 }␊
1012 /*! Used as a heading for a list of Java class functions with package ␊
1013 * scope. ␊
1014 */␊
1015 virtual QCString trPackageMembers()␊
1016 { ␊
1017 return "Package Functies";␊
1018 }␊
1019 /*! Used as a heading for a list of static Java class functions with ␊
1020 * package scope.␊
1021 */␊
1022 virtual QCString trStaticPackageMembers()␊
1023 { ␊
1024 return "Statische Package Functies";␊
1025 }␊
1026 /*! Used as a heading for a list of Java class variables with package ␊
1027 * scope.␊
1028 */␊
1029 virtual QCString trPackageAttribs()␊
1030 { ␊
1031 return "Package Attributen";␊
1032 }␊
1033 /*! Used as a heading for a list of static Java class variables with ␊
1034 * package scope.␊
1035 */␊
1036 virtual QCString trStaticPackageAttribs()␊
1037 { ␊
1038 return "Statische Package Attributen";␊
1039 }␊
1040␊
1041//////////////////////////////////////////////////////////////////////////␊
1042// new since 1.3.1␊
1043//////////////////////////////////////////////////////////////////////////␊
1044␊
1045 /*! Used in the quick index of a class/file/namespace member list page ␊
1046 * to link to the unfiltered list of all members.␊
1047 */␊
1048 virtual QCString trAll()␊
1049 {␊
1050 return "Alle";␊
1051 }␊
1052 /*! Put in front of the call graph for a function. */␊
1053 virtual QCString trCallGraph()␊
1054 {␊
1055 return "Hier is de call graaf voor deze functie:";␊
1056 }␊
1057␊
1058//////////////////////////////////////////////////////////////////////////␊
1059// new since 1.3.3␊
1060//////////////////////////////////////////////////////////////////////////␊
1061␊
1062 /*! When the search engine is enabled this text is put in the index ␊
1063 * of each page before the search field. ␊
1064 */␊
1065 virtual QCString trSearchForIndex()␊
1066 {␊
1067 return "Zoek naar";␊
1068 }␊
1069 /*! This string is used as the title for the page listing the search␊
1070 * results.␊
1071 */␊
1072 virtual QCString trSearchResultsTitle()␊
1073 {␊
1074 return "Zoek Resultaten";␊
1075 }␊
1076 /*! This string is put just before listing the search results. The␊
1077 * text can be different depending on the number of documents found.␊
1078 * Inside the text you can put the special marker $num to insert␊
1079 * the number representing the actual number of search results.␊
1080 * The @a numDocuments parameter can be either 0, 1 or 2, where the ␊
1081 * value 2 represents 2 or more matches. HTML markup is allowed inside␊
1082 * the returned string.␊
1083 */␊
1084 virtual QCString trSearchResults(int numDocuments)␊
1085 {␊
1086 if (numDocuments==0)␊
1087 {␊
1088 return "Helaas, er zijn geen documenten gevonden die aan de zoekopdracht voldoen.";␊
1089 }␊
1090 else if (numDocuments==1)␊
1091 {␊
1092 return "Er is <b>1</b> document gevonden dat aan de zoekopdracht voldoet.";␊
1093 }␊
1094 else ␊
1095 {␊
1096 return "Er zijn <b>$num</b> documenten gevonden die aan de zoekopdracht voldoen. "␊
1097 "De beste resultaten worden eerst getoond.";␊
1098 }␊
1099 }␊
1100 /*! This string is put before the list of matched words, for each search ␊
1101 * result. What follows is the list of words that matched the query.␊
1102 */␊
1103 virtual QCString trSearchMatches()␊
1104 {␊
1105 return "Gevonden:";␊
1106 }␊
1107␊
1108//////////////////////////////////////////////////////////////////////////␊
1109// new since 1.3.8␊
1110//////////////////////////////////////////////////////////////////////////␊
1111␊
1112 /*! This is used in HTML as the title of page with source code for file filename␊
1113 */␊
1114 virtual QCString trSourceFile(QCString& filename)␊
1115 {␊
1116 return filename + " Bron Bestand";␊
1117 }␊
1118␊
1119//////////////////////////////////////////////////////////////////////////␊
1120// new since 1.3.9␊
1121//////////////////////////////////////////////////////////////////////////␊
1122␊
1123 /*! This is used as the name of the chapter containing the directory␊
1124 * hierarchy.␊
1125 */␊
1126 virtual QCString trDirIndex()␊
1127 { return "Folder Hi&euml;rarchie"; }␊
1128␊
1129 /*! This is used as the name of the chapter containing the documentation␊
1130 * of the directories.␊
1131 */␊
1132 virtual QCString trDirDocumentation()␊
1133 { return "Folder Documentatie"; }␊
1134␊
1135 /*! This is used as the title of the directory index and also in the␊
1136 * Quick links of a HTML page, to link to the directory hierarchy.␊
1137 */␊
1138 virtual QCString trDirectories()␊
1139 { return "Folders"; }␊
1140␊
1141 /*! This returns a sentences that introduces the directory hierarchy. ␊
1142 * and the fact that it is sorted alphabetically per level␊
1143 */␊
1144 virtual QCString trDirDescription()␊
1145 { return "Deze folder hi&euml;rarchie is min of meer alfabetisch "␊
1146 "gesorteerd:";␊
1147 }␊
1148␊
1149 /*! This returns the title of a directory page. The name of the␊
1150 * directory is passed via \a dirName.␊
1151 */␊
1152 virtual QCString trDirReference(const char *dirName)␊
1153 { QCString result=dirName; result+=" Folder Referentie"; return result; }␊
1154␊
1155 /*! This returns the word directory with or without starting capital␊
1156 * (\a first_capital) and in sigular or plural form (\a singular).␊
1157 */␊
1158 virtual QCString trDir(bool first_capital, bool singular)␊
1159 { ␊
1160 QCString result((first_capital ? "Folder" : "folder"));␊
1161 if (!singular) result+="s";␊
1162 return result; ␊
1163 }␊
1164␊
1165//////////////////////////////////////////////////////////////////////////␊
1166// new since 1.4.1␊
1167//////////////////////////////////////////////////////////////////////////␊
1168␊
1169 /*! This text is added to the documentation when the \\overload command␊
1170 * is used for a function.␊
1171 */␊
1172 virtual QCString trOverloadText()␊
1173 {␊
1174 return "Deze functie is overloaded en is beschikbaar gemaakt om het "␊
1175 "gebruik te vergemakkelijken. Ze verschilt alleen van de "␊
1176 "bovenstaande functie wat betreft de parameterlijst.";␊
1177 }␊
1178␊
1179//////////////////////////////////////////////////////////////////////////␊
1180// new since 1.4.6␊
1181//////////////////////////////////////////////////////////////////////////␊
1182␊
1183 /*! Put in front of the call graph for a function. */␊
1184 virtual QCString trCallerGraph()␊
1185 {␊
1186 return "Hier is de caller graaf voor deze functie:";␊
1187 }␊
1188 ␊
1189 /*! header that is put before the list of member subprograms (Fortran). */␊
1190 virtual QCString trMemberFunctionDocumentationFortran()␊
1191 { return "Member Functie/Subroutine Documentatie"; }␊
1192␊
1193//////////////////////////////////////////////////////////////////////////␊
1194// new since 1.5.4 (mainly for Fortran)␊
1195//////////////////////////////////////////////////////////////////////////␊
1196␊
1197 /*! This is put above each page as a link to the list of annotated data types (Fortran). */ ␊
1198 virtual QCString trCompoundListFortran()␊
1199 { return "Lijst met data types"; }␊
1200␊
1201 /*! This is put above each page as a link to all members of compounds (Fortran). */␊
1202 virtual QCString trCompoundMembersFortran()␊
1203 { return "Data velden"; }␊
1204␊
1205 /*! This is an introduction to the annotated compound list (Fortran). */␊
1206 virtual QCString trCompoundListDescriptionFortran()␊
1207 { return "Hieronder volgen de data types elk een korte beschrijving:"; }␊
1208␊
1209 /*! This is an introduction to the page with all data types (Fortran). */␊
1210 virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)␊
1211 {␊
1212 QCString result="Hieronder volgt de lijst met alle ";␊
1213 if (!extractAll) result+="gedocumenteerde ";␊
1214 result+="data types met links naar ";␊
1215 if (!extractAll) result+="de klasse documentatie voor elke member:";␊
1216 else result+="de klassen waartoe ze behoren:";␊
1217 return result;␊
1218 }␊
1219␊
1220 /*! This is used in LaTeX as the title of the chapter with the ␊
1221 * annotated compound index (Fortran).␊
1222 */␊
1223 virtual QCString trCompoundIndexFortran()␊
1224 { return "Data Type Index"; }␊
1225␊
1226 /*! This is used in LaTeX as the title of the chapter containing␊
1227 * the documentation of all data types (Fortran).␊
1228 */␊
1229 virtual QCString trTypeDocumentation()␊
1230 { return "Data Type Documentatie"; }␊
1231␊
1232 /*! This is used in the documentation of a file as a header before the ␊
1233 * list of (global) subprograms (Fortran).␊
1234 */␊
1235 virtual QCString trSubprograms()␊
1236 { return "Functies/Subroutines"; }␊
1237␊
1238 /*! This is used in the documentation of a file/namespace before the list ␊
1239 * of documentation blocks for subprograms (Fortran)␊
1240 */␊
1241 virtual QCString trSubprogramDocumentation()␊
1242 { return "Functie/Subroutine Documentatie"; }␊
1243␊
1244 /*! This is used in the documentation of a file/namespace/group before ␊
1245 * the list of links to documented compounds (Fortran)␊
1246 */␊
1247 virtual QCString trDataTypes()␊
1248 { return "Data Types"; }␊
1249 ␊
1250 /*! used as the title of page containing all the index of all modules (Fortran). */␊
1251 virtual QCString trModulesList()␊
1252 { return "Module Lijst"; }␊
1253␊
1254 /*! used as an introduction to the modules list (Fortran) */␊
1255 virtual QCString trModulesListDescription(bool extractAll)␊
1256 {␊
1257 QCString result="Hieronder volgt de lijst met alle ";␊
1258 if (!extractAll) result+="gedocumenteerde ";␊
1259 result+="modulen, elk met een korte beschrijving:";␊
1260 return result;␊
1261 }␊
1262␊
1263 /*! used as the title of the HTML page of a module/type (Fortran) */␊
1264 virtual QCString trCompoundReferenceFortran(const char *clName,␊
1265 ClassDef::CompoundType compType,␊
1266 bool isTemplate)␊
1267 {␊
1268 QCString result=(QCString)clName;␊
1269 switch(compType)␊
1270 {␊
1271 case ClassDef::Class: result+=" Module"; break;␊
1272 case ClassDef::Struct: result+=" Type"; break;␊
1273 case ClassDef::Union: result+=" Union"; break;␊
1274 case ClassDef::Interface: result+=" Interface"; break;␊
1275 case ClassDef::Protocol: result+=" Protocol"; break;␊
1276 case ClassDef::Category: result+=" Category"; break;␊
1277 case ClassDef::Exception: result+=" Exception"; break;␊
1278 }␊
1279 if (isTemplate) result+=" Template";␊
1280 result+=" Referentie";␊
1281 return result;␊
1282 }␊
1283 /*! used as the title of the HTML page of a module (Fortran) */␊
1284 virtual QCString trModuleReference(const char *namespaceName)␊
1285 {␊
1286 QCString result=namespaceName;␊
1287 result+=" Module Referentie"; ␊
1288 return result;␊
1289 }␊
1290 ␊
1291 /*! This is put above each page as a link to all members of modules. (Fortran) */␊
1292 virtual QCString trModulesMembers()␊
1293 { return "Module Members"; }␊
1294␊
1295 /*! This is an introduction to the page with all modules members (Fortran) */␊
1296 virtual QCString trModulesMemberDescription(bool extractAll)␊
1297 { ␊
1298 QCString result="Hier is een lijst van alle ";␊
1299 if (!extractAll) result+="gedocumenteerde ";␊
1300 result+="module members met links naar ";␊
1301 if (extractAll) ␊
1302 result+="de module documentatie voor iedere member:";␊
1303 else ␊
1304 result+="de module waartoe ze behoren:";␊
1305 return result;␊
1306 }␊
1307␊
1308 /*! This is used in LaTeX as the title of the chapter with the ␊
1309 * index of all modules (Fortran).␊
1310 */␊
1311 virtual QCString trModulesIndex()␊
1312 { return "Module Index"; }␊
1313 ␊
1314 /*! This is used for translation of the word that will possibly␊
1315 * be followed by a single name or by a list of names ␊
1316 * of the category.␊
1317 */␊
1318 virtual QCString trModule(bool first_capital, bool singular)␊
1319 { ␊
1320 QCString result((first_capital ? "Module" : "module"));␊
1321 if (!singular) result+="n";␊
1322 return result; ␊
1323 }␊
1324 /*! This is put at the bottom of a module documentation page and is␊
1325 * followed by a list of files that were used to generate the page.␊
1326 */␊
1327 virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,␊
1328 bool single)␊
1329 { // here s is one of " Class", " Struct" or " Union"␊
1330 // single is true implies a single file␊
1331 QCString result=(QCString)"De documentatie voor ";␊
1332 switch(compType)␊
1333 {␊
1334 case ClassDef::Class: result+="deze module"; break;␊
1335 case ClassDef::Struct: result+="dit type"; break;␊
1336 case ClassDef::Union: result+="deze union"; break;␊
1337 case ClassDef::Interface: result+="dit interface"; break;␊
1338 case ClassDef::Protocol: result+="dit protocol"; break;␊
1339 case ClassDef::Category: result+="deze category"; break;␊
1340 case ClassDef::Exception: result+="deze exception"; break;␊
1341 }␊
1342 result+=" is gegenereerd op grond van het volgende bestand";␊
1343 if (single) result+=":"; else result+="s:";␊
1344 return result;␊
1345 }␊
1346 /*! This is used for translation of the word that will possibly␊
1347 * be followed by a single name or by a list of names ␊
1348 * of the category.␊
1349 */␊
1350 virtual QCString trType(bool first_capital, bool singular)␊
1351 { ␊
1352 QCString result((first_capital ? "Type" : "type"));␊
1353 if (!singular) result+="s";␊
1354 return result; ␊
1355 }␊
1356 /*! This is used for translation of the word that will possibly␊
1357 * be followed by a single name or by a list of names ␊
1358 * of the category.␊
1359 */␊
1360 virtual QCString trSubprogram(bool first_capital, bool singular)␊
1361 { ␊
1362 QCString result((first_capital ? "Subprogramma" : "subprogramma"));␊
1363 if (!singular) result+="s";␊
1364 return result; ␊
1365 }␊
1366␊
1367 /*! C# Type Contraint list */␊
1368 virtual QCString trTypeConstraints()␊
1369 {␊
1370 return "Type Beperkingen";␊
1371 }␊
1372␊
1373//////////////////////////////////////////////////////////////////////////␊
1374// new since 1.6.0␊
1375//////////////////////////////////////////////////////////////////////////␊
1376␊
1377 /*! directory relation for \a name */␊
1378 virtual QCString trDirRelation(const char *name)␊
1379 {␊
1380 return QCString(name)+" Relatie";␊
1381 }␊
1382␊
1383 /*! Loading message shown when loading search results */␊
1384 virtual QCString trLoading()␊
1385 {␊
1386 return "Laden...";␊
1387 }␊
1388␊
1389 /*! Label used for search results in the global namespace */␊
1390 virtual QCString trGlobalNamespace()␊
1391 {␊
1392 return "Globale Namespace";␊
1393 }␊
1394␊
1395 /*! Message shown while searching */␊
1396 virtual QCString trSearching()␊
1397 {␊
1398 return "Zoeken...";␊
1399 }␊
1400␊
1401 /*! Text shown when no search results are found */␊
1402 virtual QCString trNoMatches()␊
1403 {␊
1404 return "Niets gevonden";␊
1405 }␊
1406␊
1407//////////////////////////////////////////////////////////////////////////␊
1408// new since 1.6.3 (missing items for the directory pages)␊
1409//////////////////////////////////////////////////////////////////////////␊
1410␊
1411 /*! introduction text for the directory dependency graph */␊
1412 virtual QCString trDirDependency(const char *name)␊
1413 {␊
1414 return (QCString)"Folder afhankelijkheidsgraaf voor "+name;␊
1415 }␊
1416␊
1417 /*! when clicking a directory dependency label, a page with a␊
1418 * table is shown. The heading for the first column mentions the␊
1419 * source file that has a relation to another file.␊
1420 */␊
1421 virtual QCString trFileIn(const char *name)␊
1422 {␊
1423 return (QCString)"Bestand in "+name;␊
1424 }␊
1425␊
1426 /*! when clicking a directory dependency label, a page with a␊
1427 * table is shown. The heading for the second column mentions the␊
1428 * destination file that is included.␊
1429 */␊
1430 virtual QCString trIncludesFileIn(const char *name)␊
1431 {␊
1432 return (QCString)"Includeert bestand in "+name;␊
1433 }␊
1434 virtual QCString trDateTime(int year,int month,int day,int dayOfWeek,␊
1435 int hour,int minutes,int seconds,␊
1436 bool includeTime)␊
1437 {␊
1438 static const char *days[] = { "Ma","Di","Wo","Do","Vr","Za","Zo" };␊
1439 static const char *months[] = { "Jan","Feb","Maa","Apr","Mei","Jun","Jul","Aug","Sep","Okt","Nov","Dec" };␊
1440 QCString sdate;␊
1441 sdate.sprintf("%s %d %s %d",days[dayOfWeek-1],day,months[month-1],year);␊
1442 if (includeTime)␊
1443 {␊
1444 QCString stime;␊
1445 stime.sprintf(" %.2d:%.2d:%.2d",hour,minutes,seconds);␊
1446 sdate+=stime;␊
1447 }␊
1448 return sdate;␊
1449 }␊
1450␊
1451␊
1452␊
1453␊
1454};␊
1455␊
1456#endif␊
1457

Archive Download this file

Revision: 1322