doxygen
translator_en.h
1 /******************************************************************************
2  *
3  *
4  *
5  * Copyright (C) 1997-2015 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_EN_H
19 #define TRANSLATOR_EN_H
20 
44 {
45  public:
46 
47  // --- Language control methods -------------------
48 
55  QCString idLanguage() override
56  { return "english"; }
57 
73  {
74  return "";
75  }
76 
77  QCString trISOLang() override
78  {
79  return "en-US";
80  }
81 
83  {
84  return "0x409 English (United States)";
85  }
86  // --- Language translation methods -------------------
87 
90  { return "Related Functions"; }
91 
94  { return "(Note that these are not member functions.)"; }
95 
98  { return "Detailed Description"; }
99 
101  QCString trDetails() override
102  { return "Details"; }
103 
106  { return "Member Typedef Documentation"; }
107 
110  { return "Member Enumeration Documentation"; }
111 
114  {
115  if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
116  {
117  return "Member Function/Procedure/Process Documentation";
118  }
119  else
120  {
121  return "Member Function Documentation";
122  }
123  }
124 
127  {
128  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
129  {
130  return "Field Documentation";
131  }
132  else
133  {
134  return "Member Data Documentation";
135  }
136  }
137 
139  QCString trMore() override
140  { return "More..."; }
141 
144  { return "List of all members"; }
145 
148  { return "Member List"; }
149 
152  { return "This is the complete list of members for"; }
153 
156  { return ", including all inherited members."; }
157 
162  { QCString result="Generated automatically by Doxygen";
163  if (!s.isEmpty()) result+=" for "+s;
164  result+=" from the source code.";
165  return result;
166  }
167 
169  QCString trEnumName() override
170  { return "enum name"; }
171 
174  { return "enum value"; }
175 
178  { return "defined in"; }
179 
180  // quick reference sections
181 
185  QCString trModules() override
186  { return "Modules"; }
187 
190  { return "Class Hierarchy"; }
191 
194  {
195  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
196  {
197  return "Data Structures";
198  }
199  else
200  {
201  return "Class List";
202  }
203  }
204 
206  QCString trFileList() override
207  { return "File List"; }
208 
211  {
212  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
213  {
214  return "Data Fields";
215  }
216  else
217  {
218  return "Class Members";
219  }
220  }
221 
224  {
225  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
226  {
227  return "Globals";
228  }
229  else
230  {
231  return "File Members";
232  }
233  }
234 
237  { return "Related Pages"; }
238 
240  QCString trExamples() override
241  { return "Examples"; }
242 
244  QCString trSearch() override
245  { return "Search"; }
246 
249  {
250  if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
251  {
252  return "Here is a hierarchical list of all entities:";
253  }
254  else
255  {
256  return "This inheritance list is sorted roughly, "
257  "but not completely, alphabetically:";
258  }
259  }
260 
262  QCString trFileListDescription(bool extractAll) override
263  {
264  QCString result="Here is a list of all ";
265  if (!extractAll) result+="documented ";
266  result+="files with brief descriptions:";
267  return result;
268  }
269 
272  {
273 
274  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
275  {
276  return "Here are the data structures with brief descriptions:";
277  }
278  else if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
279  {
280  return "Here are the classes with brief descriptions:";
281  }
282  else
283  {
284  return "Here are the classes, structs, "
285  "unions and interfaces with brief descriptions:";
286  }
287  }
288 
290  QCString trCompoundMembersDescription(bool extractAll) override
291  {
292  QCString result="Here is a list of all ";
293  if (!extractAll)
294  {
295  result+="documented ";
296  }
297  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
298  {
299  result+="struct and union fields";
300  }
301  else
302  {
303  result+="class members";
304  }
305  result+=" with links to ";
306  if (!extractAll)
307  {
308  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
309  {
310  result+="the struct/union documentation for each field:";
311  }
312  else
313  {
314  result+="the class documentation for each member:";
315  }
316  }
317  else
318  {
319  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
320  {
321  result+="the structures/unions they belong to:";
322  }
323  else
324  {
325  result+="the classes they belong to:";
326  }
327  }
328  return result;
329  }
330 
332  QCString trFileMembersDescription(bool extractAll) override
333  {
334  QCString result="Here is a list of all ";
335  if (!extractAll) result+="documented ";
336 
337  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
338  {
339  result+="functions, variables, defines, enums, and typedefs";
340  }
341  else
342  {
343  result+="file members";
344  }
345  result+=" with links to ";
346  if (extractAll)
347  result+="the files they belong to:";
348  else
349  result+="the documentation:";
350  return result;
351  }
352 
355  { return "Here is a list of all examples:"; }
356 
359  { return "Here is a list of all related documentation pages:"; }
360 
363  { return "Here is a list of all modules:"; }
364 
365  // index titles (the project name is prepended for these)
366 
369  { return "Documentation"; }
370 
375  { return "Module Index"; }
376 
381  { return "Hierarchical Index"; }
382 
387  {
388  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
389  {
390  return "Data Structure Index";
391  }
392  else
393  {
394  return "Class Index";
395  }
396  }
397 
402  { return "File Index"; }
403 
408  { return "Module Documentation"; }
409 
414  {
415  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
416  {
417  return "Data Structure Documentation";
418  }
419  else if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
420  {
421  return trDesignUnitDocumentation();
422  }
423  else
424  {
425  return "Class Documentation";
426  }
427  }
428 
433  { return "File Documentation"; }
434 
437  { return "Reference Manual"; }
438 
442  QCString trDefines() override
443  { return "Macros"; }
444 
448  QCString trTypedefs() override
449  { return "Typedefs"; }
450 
455  { return "Enumerations"; }
456 
461  { return "Functions"; }
462 
467  { return "Variables"; }
468 
473  { return "Enumerator"; }
474 
479  { return "Macro Definition Documentation"; }
480 
485  { return "Typedef Documentation"; }
486 
491  { return "Enumeration Type Documentation"; }
492 
497  { return "Function Documentation"; }
498 
503  { return "Variable Documentation"; }
504 
509  {
510  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
511  {
512  return "Data Structures";
513  }
514  else
515  {
516  return "Classes";
517  }
518  }
519 
523  QCString trGeneratedAt(const QCString &date,const QCString &projName) override
524  {
525  QCString result="Generated on "+date;
526  if (!projName.isEmpty()) result+=" for "+projName;
527  result+=" by";
528  return result;
529  }
530 
532  QCString trClassDiagram(const QCString &clName) override
533  {
534  return "Inheritance diagram for "+clName+":";
535  }
536 
538  QCString trWarning() override
539  { return "Warning"; }
540 
542  QCString trVersion() override
543  { return "Version"; }
544 
546  QCString trDate() override
547  { return "Date"; }
548 
550  QCString trReturns() override
551  { return "Returns"; }
552 
554  QCString trSeeAlso() override
555  { return "See also"; }
556 
559  { return "Parameters"; }
560 
563  { return "Exceptions"; }
564 
567  { return "Generated by"; }
568 
570 // new since 0.49-990307
572 
575  { return "Namespace List"; }
576 
578  QCString trNamespaceListDescription(bool extractAll) override
579  {
580  QCString result="Here is a list of all ";
581  if (!extractAll) result+="documented ";
582  result+="namespaces with brief descriptions:";
583  return result;
584  }
585 
589  QCString trFriends() override
590  { return "Friends"; }
591 
593 // new since 0.49-990405
595 
600  { return "Friends And Related Function Documentation"; }
601 
603 // new since 0.49-990425
605 
608  ClassDef::CompoundType compType,
609  bool isTemplate) override
610  {
611  QCString result=clName;
612  switch(compType)
613  {
614  case ClassDef::Class: result+=" Class"; break;
615  case ClassDef::Struct: result+=" Struct"; break;
616  case ClassDef::Union: result+=" Union"; break;
617  case ClassDef::Interface: result+=" Interface"; break;
618  case ClassDef::Protocol: result+=" Protocol"; break;
619  case ClassDef::Category: result+=" Category"; break;
620  case ClassDef::Exception: result+=" Exception"; break;
621  default: break;
622  }
623  if (isTemplate) result+=" Template";
624  result+=" Reference";
625  return result;
626  }
627 
629  QCString trFileReference(const QCString &fileName) override
630  {
631  QCString result=fileName;
632  result+=" File Reference";
633  return result;
634  }
635 
637  QCString trNamespaceReference(const QCString &namespaceName) override
638  {
639  QCString result=namespaceName;
640  result+=" Namespace Reference";
641  return result;
642  }
643 
644  QCString trPublicMembers() override
645  { return "Public Member Functions"; }
646  QCString trPublicSlots() override
647  { return "Public Slots"; }
648  QCString trSignals() override
649  { return "Signals"; }
650  QCString trStaticPublicMembers() override
651  { return "Static Public Member Functions"; }
652  QCString trProtectedMembers() override
653  { return "Protected Member Functions"; }
654  QCString trProtectedSlots() override
655  { return "Protected Slots"; }
656  QCString trStaticProtectedMembers() override
657  { return "Static Protected Member Functions"; }
658  QCString trPrivateMembers() override
659  { return "Private Member Functions"; }
660  QCString trPrivateSlots() override
661  { return "Private Slots"; }
662  QCString trStaticPrivateMembers() override
663  { return "Static Private Member Functions"; }
664 
668  QCString trWriteList(int numEntries) override
669  {
670  QCString result;
671  int i;
672  // the inherits list contain `numEntries' classes
673  for (i=0;i<numEntries;i++)
674  {
675  // use generateMarker to generate placeholders for the class links!
676  result+=generateMarker(i); // generate marker for entry i in the list
677  // (order is left to right)
678 
679  if (i!=numEntries-1) // not the last entry, so we need a separator
680  {
681  if (i<numEntries-2) // not the fore last entry
682  result+=", ";
683  else // the fore last entry
684  result+=", and ";
685  }
686  }
687  return result;
688  }
689 
693  QCString trInheritsList(int numEntries) override
694  {
695  return "Inherits "+trWriteList(numEntries)+".";
696  }
697 
701  QCString trInheritedByList(int numEntries) override
702  {
703  return "Inherited by "+trWriteList(numEntries)+".";
704  }
705 
709  QCString trReimplementedFromList(int numEntries) override
710  {
711  return "Reimplemented from "+trWriteList(numEntries)+".";
712  }
713 
717  QCString trReimplementedInList(int numEntries) override
718  {
719  return "Reimplemented in "+trWriteList(numEntries)+".";
720  }
721 
724  { return "Namespace Members"; }
725 
727  QCString trNamespaceMemberDescription(bool extractAll) override
728  {
729  QCString result="Here is a list of all ";
730  if (!extractAll) result+="documented ";
731  result+="namespace members with links to ";
732  if (extractAll)
733  result+="the namespace documentation for each member:";
734  else
735  result+="the namespaces they belong to:";
736  return result;
737  }
742  { return "Namespace Index"; }
743 
748  { return "Namespace Documentation"; }
749 
751 // new since 0.49-990522
753 
758  { return "Namespaces"; }
759 
761 // new since 0.49-990728
763 
768  bool single) override
769  { // single is true implies a single file
770  bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
771  QCString result="The documentation for this ";
772  switch(compType)
773  {
774  case ClassDef::Class: result+=vhdlOpt?"design unit":"class"; break;
775  case ClassDef::Struct: result+="struct"; break;
776  case ClassDef::Union: result+="union"; break;
777  case ClassDef::Interface: result+="interface"; break;
778  case ClassDef::Protocol: result+="protocol"; break;
779  case ClassDef::Category: result+="category"; break;
780  case ClassDef::Exception: result+="exception"; break;
781  default: break;
782  }
783  result+=" was generated from the following file";
784  if (single) result+=":"; else result+="s:";
785  return result;
786  }
787 
789 // new since 0.49-990901
791 
794  { return "Return values"; }
795 
798  QCString trMainPage() override
799  { return "Main Page"; }
800 
805  { return "p."; }
806 
808 // new since 0.49-991003
810 
811  QCString trDefinedAtLineInSourceFile() override
812  {
813  return "Definition at line @0 of file @1.";
814  }
815  QCString trDefinedInSourceFile() override
816  {
817  return "Definition in file @0.";
818  }
819 
821 // new since 0.49-991205
823 
824  QCString trDeprecated() override
825  {
826  return "Deprecated";
827  }
828 
830 // new since 1.0.0
832 
834  QCString trCollaborationDiagram(const QCString &clName) override
835  {
836  return "Collaboration diagram for "+clName+":";
837  }
839  QCString trInclDepGraph(const QCString &fName) override
840  {
841  return "Include dependency graph for "+fName+":";
842  }
845  {
846  return "Constructor & Destructor Documentation";
847  }
850  {
851  return "Go to the source code of this file.";
852  }
855  {
856  return "Go to the documentation of this file.";
857  }
860  {
861  return "Precondition";
862  }
865  {
866  return "Postcondition";
867  }
870  {
871  return "Invariant";
872  }
875  {
876  return "Initial value:";
877  }
879  QCString trCode() override
880  {
881  return "code";
882  }
883  QCString trGraphicalHierarchy() override
884  {
885  return "Graphical Class Hierarchy";
886  }
887  QCString trGotoGraphicalHierarchy() override
888  {
889  return "Go to the graphical class hierarchy";
890  }
891  QCString trGotoTextualHierarchy() override
892  {
893  return "Go to the textual class hierarchy";
894  }
895  QCString trPageIndex() override
896  {
897  return "Page Index";
898  }
899 
901 // new since 1.1.0
903 
904  QCString trNote() override
905  {
906  return "Note";
907  }
908  QCString trPublicTypes() override
909  {
910  return "Public Types";
911  }
912  QCString trPublicAttribs() override
913  {
914  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
915  {
916  return "Data Fields";
917  }
918  else
919  {
920  return "Public Attributes";
921  }
922  }
923  QCString trStaticPublicAttribs() override
924  {
925  return "Static Public Attributes";
926  }
927  QCString trProtectedTypes() override
928  {
929  return "Protected Types";
930  }
931  QCString trProtectedAttribs() override
932  {
933  return "Protected Attributes";
934  }
935  QCString trStaticProtectedAttribs() override
936  {
937  return "Static Protected Attributes";
938  }
939  QCString trPrivateTypes() override
940  {
941  return "Private Types";
942  }
943  QCString trPrivateAttribs() override
944  {
945  return "Private Attributes";
946  }
947  QCString trStaticPrivateAttribs() override
948  {
949  return "Static Private Attributes";
950  }
951 
953 // new since 1.1.3
955 
957  QCString trTodo() override
958  {
959  return "Todo";
960  }
962  QCString trTodoList() override
963  {
964  return "Todo List";
965  }
966 
968 // new since 1.1.4
970 
971  QCString trReferencedBy() override
972  {
973  return "Referenced by";
974  }
975  QCString trRemarks() override
976  {
977  return "Remarks";
978  }
979  QCString trAttention() override
980  {
981  return "Attention";
982  }
983  QCString trInclByDepGraph() override
984  {
985  return "This graph shows which files directly or "
986  "indirectly include this file:";
987  }
988  QCString trSince() override
989  {
990  return "Since";
991  }
992 
994 // new since 1.1.5
996 
999  {
1000  return "Graph Legend";
1001  }
1006  {
1007  return
1008  "This page explains how to interpret the graphs that are generated "
1009  "by doxygen.<p>\n"
1010  "Consider the following example:\n"
1011  "\\code\n"
1012  "/*! Invisible class because of truncation */\n"
1013  "class Invisible { };\n\n"
1014  "/*! Truncated class, inheritance relation is hidden */\n"
1015  "class Truncated : public Invisible { };\n\n"
1016  "/* Class not documented with doxygen comments */\n"
1017  "class Undocumented { };\n\n"
1018  "/*! Class that is inherited using public inheritance */\n"
1019  "class PublicBase : public Truncated { };\n\n"
1020  "/*! A template class */\n"
1021  "template<class T> class Templ { };\n\n"
1022  "/*! Class that is inherited using protected inheritance */\n"
1023  "class ProtectedBase { };\n\n"
1024  "/*! Class that is inherited using private inheritance */\n"
1025  "class PrivateBase { };\n\n"
1026  "/*! Class that is used by the Inherited class */\n"
1027  "class Used { };\n\n"
1028  "/*! Super class that inherits a number of other classes */\n"
1029  "class Inherited : public PublicBase,\n"
1030  " protected ProtectedBase,\n"
1031  " private PrivateBase,\n"
1032  " public Undocumented,\n"
1033  " public Templ<int>\n"
1034  "{\n"
1035  " private:\n"
1036  " Used *m_usedClass;\n"
1037  "};\n"
1038  "\\endcode\n"
1039  "This will result in the following graph:"
1040  "<p><center><img alt=\"\" src=\"graph_legend."+getDotImageExtension()+"\"></center></p>\n"
1041  "<p>\n"
1042  "The boxes in the above graph have the following meaning:\n"
1043  "</p>\n"
1044  "<ul>\n"
1045  "<li>%A filled gray box represents the struct or class for which the "
1046  "graph is generated.</li>\n"
1047  "<li>%A box with a black border denotes a documented struct or class.</li>\n"
1048  "<li>%A box with a gray border denotes an undocumented struct or class.</li>\n"
1049  "<li>%A box with a red border denotes a documented struct or class for"
1050  "which not all inheritance/containment relations are shown. %A graph is "
1051  "truncated if it does not fit within the specified boundaries.</li>\n"
1052  "</ul>\n"
1053  "<p>\n"
1054  "The arrows have the following meaning:\n"
1055  "</p>\n"
1056  "<ul>\n"
1057  "<li>%A blue arrow is used to visualize a public inheritance "
1058  "relation between two classes.</li>\n"
1059  "<li>%A dark green arrow is used for protected inheritance.</li>\n"
1060  "<li>%A dark red arrow is used for private inheritance.</li>\n"
1061  "<li>%A purple dashed arrow is used if a class is contained or used "
1062  "by another class. The arrow is labelled with the variable(s) "
1063  "through which the pointed class or struct is accessible.</li>\n"
1064  "<li>%A yellow dashed arrow denotes a relation between a template instance and "
1065  "the template class it was instantiated from. The arrow is labelled with "
1066  "the template parameters of the instance.</li>\n"
1067  "</ul>\n";
1068  }
1070  QCString trLegend() override
1071  {
1072  return "legend";
1073  }
1074 
1076 // new since 1.2.0
1078 
1080  QCString trTest() override
1081  {
1082  return "Test";
1083  }
1086  {
1087  return "Test List";
1088  }
1089 
1091 // new since 1.2.2
1093 
1096  {
1097  return "Properties";
1098  }
1101  {
1102  return "Property Documentation";
1103  }
1104 
1106 // new since 1.2.4
1108 
1110  QCString trClasses() override
1111  {
1112  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
1113  {
1114  return "Data Structures";
1115  }
1116  else
1117  {
1118  return "Classes";
1119  }
1120  }
1122  QCString trPackage(const QCString &name) override
1123  {
1124  return "Package "+name;
1125  }
1128  {
1129  return "Here are the packages with brief descriptions (if available):";
1130  }
1133  {
1134  return "Packages";
1135  }
1138  {
1139  return "Value:";
1140  }
1141 
1143 // new since 1.2.5
1145 
1147  QCString trBug() override
1148  {
1149  return "Bug";
1150  }
1152  QCString trBugList() override
1153  {
1154  return "Bug List";
1155  }
1156 
1158 // new since 1.2.6
1160 
1187  {
1188  return "1252";
1189  }
1190 
1191 
1196  {
1197  return "0";
1198  }
1199 
1202  {
1203  return "Index";
1204  }
1205 
1210  QCString trClass(bool first_capital, bool singular) override
1211  {
1212  QCString result((first_capital ? "Class" : "class"));
1213  if (!singular) result+="es";
1214  return result;
1215  }
1216 
1221  QCString trFile(bool first_capital, bool singular) override
1222  {
1223  QCString result((first_capital ? "File" : "file"));
1224  if (!singular) result+="s";
1225  return result;
1226  }
1227 
1232  QCString trNamespace(bool first_capital, bool singular) override
1233  {
1234  QCString result((first_capital ? "Namespace" : "namespace"));
1235  if (!singular) result+="s";
1236  return result;
1237  }
1238 
1243  QCString trGroup(bool first_capital, bool singular) override
1244  {
1245  QCString result((first_capital ? "Module" : "module"));
1246  if (!singular) result+="s";
1247  return result;
1248  }
1249 
1254  QCString trPage(bool first_capital, bool singular) override
1255  {
1256  QCString result((first_capital ? "Page" : "page"));
1257  if (!singular) result+="s";
1258  return result;
1259  }
1260 
1265  QCString trMember(bool first_capital, bool singular) override
1266  {
1267  QCString result((first_capital ? "Member" : "member"));
1268  if (!singular) result+="s";
1269  return result;
1270  }
1271 
1276  QCString trGlobal(bool first_capital, bool singular) override
1277  {
1278  QCString result((first_capital ? "Global" : "global"));
1279  if (!singular) result+="s";
1280  return result;
1281  }
1282 
1284 // new since 1.2.7
1286 
1289  QCString trAuthor(bool first_capital, bool singular) override
1290  {
1291  QCString result((first_capital ? "Author" : "author"));
1292  if (!singular) result+="s";
1293  return result;
1294  }
1295 
1297 // new since 1.2.11
1299 
1303  {
1304  return "References";
1305  }
1306 
1308 // new since 1.2.13
1310 
1314  QCString trImplementedFromList(int numEntries) override
1315  {
1316  return "Implements "+trWriteList(numEntries)+".";
1317  }
1318 
1322  QCString trImplementedInList(int numEntries) override
1323  {
1324  return "Implemented in "+trWriteList(numEntries)+".";
1325  }
1326 
1328 // new since 1.2.16
1330 
1335  {
1336  return "Table of Contents";
1337  }
1338 
1340 // new since 1.2.17
1342 
1347  {
1348  return "Deprecated List";
1349  }
1350 
1352 // new since 1.2.18
1354 
1358  QCString trEvents() override
1359  {
1360  return "Events";
1361  }
1364  {
1365  return "Event Documentation";
1366  }
1367 
1369 // new since 1.3
1371 
1375  {
1376  return "Package Types";
1377  }
1382  {
1383  return "Package Functions";
1384  }
1385  QCString trPackageMembers() override
1386  {
1387  return "Package Members";
1388  }
1393  {
1394  return "Static Package Functions";
1395  }
1400  {
1401  return "Package Attributes";
1402  }
1407  {
1408  return "Static Package Attributes";
1409  }
1410 
1412 // new since 1.3.1
1414 
1418  QCString trAll() override
1419  {
1420  return "All";
1421  }
1424  {
1425  return "Here is the call graph for this function:";
1426  }
1427 
1429 // new since 1.3.3
1431 
1436  {
1437  return "Search Results";
1438  }
1447  QCString trSearchResults(int numDocuments) override
1448  {
1449  if (numDocuments==0)
1450  {
1451  return "Sorry, no documents matching your query.";
1452  }
1453  else if (numDocuments==1)
1454  {
1455  return "Found <b>1</b> document matching your query.";
1456  }
1457  else
1458  {
1459  return "Found <b>$num</b> documents matching your query. "
1460  "Showing best matches first.";
1461  }
1462  }
1467  {
1468  return "Matches:";
1469  }
1470 
1472 // new since 1.3.8
1474 
1477  QCString trSourceFile(const QCString& filename) override
1478  {
1479  return filename + " Source File";
1480  }
1481 
1483 // new since 1.3.9
1485 
1490  { return "Directory Hierarchy"; }
1491 
1496  { return "Directory Documentation"; }
1497 
1502  { return "Directories"; }
1503 
1507  QCString trDirReference(const QCString &dirName) override
1508  { QCString result=dirName; result+=" Directory Reference"; return result; }
1509 
1513  QCString trDir(bool first_capital, bool singular) override
1514  {
1515  QCString result((first_capital ? "Director" : "director"));
1516  if (singular) result+="y"; else result+="ies";
1517  return result;
1518  }
1519 
1521 // new since 1.4.1
1523 
1528  {
1529  return "This is an overloaded member function, "
1530  "provided for convenience. It differs from the above "
1531  "function only in what argument(s) it accepts.";
1532  }
1533 
1535 // new since 1.4.6
1537 
1540  {
1541  return "Here is the caller graph for this function:";
1542  }
1543 
1548  { return "Enumerator Documentation"; }
1549 
1551 // new since 1.5.4 (mainly for Fortran)
1553 
1556  { return "Member Function/Subroutine Documentation"; }
1557 
1560  { return "Data Types List"; }
1561 
1564  { return "Data Fields"; }
1565 
1568  { return "Here are the data types with brief descriptions:"; }
1569 
1572  {
1573  QCString result="Here is a list of all ";
1574  if (!extractAll)
1575  {
1576  result+="documented ";
1577  }
1578  result+="data types members";
1579  result+=" with links to ";
1580  if (!extractAll)
1581  {
1582  result+="the data structure documentation for each member";
1583  }
1584  else
1585  {
1586  result+="the data types they belong to:";
1587  }
1588  return result;
1589  }
1590 
1595  { return "Data Type Index"; }
1596 
1601  { return "Data Type Documentation"; }
1602 
1607  { return "Functions/Subroutines"; }
1608 
1613  { return "Function/Subroutine Documentation"; }
1614 
1619  { return "Data Types"; }
1620 
1623  { return "Modules List"; }
1624 
1626  QCString trModulesListDescription(bool extractAll) override
1627  {
1628  QCString result="Here is a list of all ";
1629  if (!extractAll) result+="documented ";
1630  result+="modules with brief descriptions:";
1631  return result;
1632  }
1633 
1636  ClassDef::CompoundType compType,
1637  bool isTemplate) override
1638  {
1639  QCString result=clName;
1640  switch(compType)
1641  {
1642  case ClassDef::Class: result+=" Module"; break;
1643  case ClassDef::Struct: result+=" Type"; break;
1644  case ClassDef::Union: result+=" Union"; break;
1645  case ClassDef::Interface: result+=" Interface"; break;
1646  case ClassDef::Protocol: result+=" Protocol"; break;
1647  case ClassDef::Category: result+=" Category"; break;
1648  case ClassDef::Exception: result+=" Exception"; break;
1649  default: break;
1650  }
1651  if (isTemplate) result+=" Template";
1652  result+=" Reference";
1653  return result;
1654  }
1656  QCString trModuleReference(const QCString &namespaceName) override
1657  {
1658  QCString result=namespaceName;
1659  result+=" Module Reference";
1660  return result;
1661  }
1662 
1665  { return "Module Members"; }
1666 
1668  QCString trModulesMemberDescription(bool extractAll) override
1669  {
1670  QCString result="Here is a list of all ";
1671  if (!extractAll) result+="documented ";
1672  result+="module members with links to ";
1673  if (extractAll)
1674  {
1675  result+="the module documentation for each member:";
1676  }
1677  else
1678  {
1679  result+="the modules they belong to:";
1680  }
1681  return result;
1682  }
1683 
1688  { return "Modules Index"; }
1689 
1694  QCString trModule(bool first_capital, bool singular) override
1695  {
1696  QCString result((first_capital ? "Module" : "module"));
1697  if (!singular) result+="s";
1698  return result;
1699  }
1700 
1705  bool single) override
1706  {
1707  // single is true implies a single file
1708  QCString result="The documentation for this ";
1709  switch(compType)
1710  {
1711  case ClassDef::Class: result+="module"; break;
1712  case ClassDef::Struct: result+="type"; break;
1713  case ClassDef::Union: result+="union"; break;
1714  case ClassDef::Interface: result+="interface"; break;
1715  case ClassDef::Protocol: result+="protocol"; break;
1716  case ClassDef::Category: result+="category"; break;
1717  case ClassDef::Exception: result+="exception"; break;
1718  default: break;
1719  }
1720  result+=" was generated from the following file";
1721  if (single) result+=":"; else result+="s:";
1722  return result;
1723  }
1724 
1729  QCString trType(bool first_capital, bool singular) override
1730  {
1731  QCString result((first_capital ? "Type" : "type"));
1732  if (!singular) result+="s";
1733  return result;
1734  }
1735 
1740  QCString trSubprogram(bool first_capital, bool singular) override
1741  {
1742  QCString result((first_capital ? "Subprogram" : "subprogram"));
1743  if (!singular) result+="s";
1744  return result;
1745  }
1746 
1749  {
1750  return "Type Constraints";
1751  }
1752 
1754 // new since 1.6.0 (mainly for the new search engine)
1756 
1758  QCString trDirRelation(const QCString &name) override
1759  {
1760  return name+" Relation";
1761  }
1762 
1764  QCString trLoading() override
1765  {
1766  return "Loading...";
1767  }
1768 
1771  {
1772  return "Global Namespace";
1773  }
1774 
1777  {
1778  return "Searching...";
1779  }
1780 
1783  {
1784  return "No Matches";
1785  }
1786 
1788 // new since 1.6.3 (missing items for the directory pages)
1790 
1795  QCString trFileIn(const QCString &name) override
1796  {
1797  return "File in "+name;
1798  }
1799 
1804  QCString trIncludesFileIn(const QCString &name) override
1805  {
1806  return "Includes file in "+name;
1807  }
1808 
1819  QCString trDateTime(int year,int month,int day,int dayOfWeek,
1820  int hour,int minutes,int seconds,
1821  DateTimeType includeTime) override
1822  {
1823  static const char *days[] = { "Mon","Tue","Wed","Thu","Fri","Sat","Sun" };
1824  static const char *months[] = { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
1825  QCString sdate;
1826  if (includeTime == DateTimeType::DateTime || includeTime == DateTimeType::Date)
1827  {
1828  sdate.sprintf("%s %s %d %d",days[dayOfWeek-1],months[month-1],day,year);
1829  }
1830  if (includeTime == DateTimeType::DateTime) sdate += " ";
1831  if (includeTime == DateTimeType::DateTime || includeTime == DateTimeType::Time)
1832  {
1833  QCString stime;
1834  stime.sprintf("%.2d:%.2d:%.2d",hour,minutes,seconds);
1835  sdate+=stime;
1836  }
1837  return sdate;
1838  }
1839  QCString trDayOfWeek(int dayOfWeek, bool, bool full) override
1840  {
1841  static const char *days_short[] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
1842  static const char *days_full[] = { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };
1843  return full? days_full[dayOfWeek-1] : days_short[dayOfWeek-1];
1844  }
1845  QCString trMonth(int month, bool, bool full) override
1846  {
1847  static const char *months_short[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
1848  static const char *months_full[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
1849  return full? months_full[month-1] : months_short[month-1];
1850  }
1851  QCString trDayPeriod(bool period) override
1852  {
1853  static const char *dayPeriod[] = { "AM", "PM" };
1854  return dayPeriod[period?1:0];
1855  }
1856 
1858 // new since 1.7.5
1860 
1863  { return "Bibliography"; }
1864 
1867  { return "Copyright"; }
1868 
1870  QCString trDirDepGraph(const QCString &name) override
1871  { return "Directory dependency graph for "+name+":"; }
1872 
1874 // new since 1.8.0
1876 
1879  { return "detail level"; }
1880 
1883  { return "Template Parameters"; }
1884 
1886  QCString trAndMore(const QCString &number) override
1887  { return "and "+number+" more..."; }
1888 
1890  QCString trEnumGeneratedFromFiles(bool single) override
1891  { QCString result = "The documentation for this enum was generated from the following file";
1892  if (!single) result += "s";
1893  result+=":";
1894  return result;
1895  }
1896 
1898  QCString trEnumReference(const QCString &name) override
1899  { return name+" Enum Reference"; }
1900 
1902  QCString trInheritedFrom(const QCString &members,const QCString &what) override
1903  { return members+" inherited from "+what; }
1904 
1909  { return "Additional Inherited Members"; }
1910 
1912 // new since 1.8.2
1914 
1920  {
1921  QCString opt = enable ? "enable" : "disable";
1922  return "click to "+opt+" panel synchronisation";
1923  }
1924 
1930  {
1931  return "Provided by category @0.";
1932  }
1933 
1939  {
1940  return "Extends class @0.";
1941  }
1942 
1947  {
1948  return "Class Methods";
1949  }
1950 
1955  {
1956  return "Instance Methods";
1957  }
1958 
1962  {
1963  return "Method Documentation";
1964  }
1965 
1967 // new since 1.8.4
1969 
1972  { return "Exported Interfaces"; }
1973 
1976  { return "Included Services"; }
1977 
1980  { return "Constant Groups"; }
1981 
1983  QCString trConstantGroupReference(const QCString &namespaceName) override
1984  {
1985  QCString result=namespaceName;
1986  result+=" Constant Group Reference";
1987  return result;
1988  }
1990  QCString trServiceReference(const QCString &sName) override
1991  {
1992  QCString result=sName;
1993  result+=" Service Reference";
1994  return result;
1995  }
1997  QCString trSingletonReference(const QCString &sName) override
1998  {
1999  QCString result=sName;
2000  result+=" Singleton Reference";
2001  return result;
2002  }
2005  {
2006  // single is true implies a single file
2007  QCString result="The documentation for this service "
2008  "was generated from the following file";
2009  if (single) result+=":"; else result+="s:";
2010  return result;
2011  }
2014  {
2015  // single is true implies a single file
2016  QCString result="The documentation for this singleton "
2017  "was generated from the following file";
2018  if (single) result+=":"; else result+="s:";
2019  return result;
2020  }
2021 
2023 // new since 1.8.15
2025 
2028  { return "Design Unit Hierarchy"; }
2031  { return "Design Unit List"; }
2034  { return "Design Unit Members"; }
2037  {
2038  return "Here is a list of all design unit members with links to "
2039  "the Entities they belong to:";
2040  }
2043  { return "Design Unit Index"; }
2046  { return "Design Units"; }
2049  { return "Functions/Procedures/Processes"; }
2051  QCString trVhdlType(VhdlSpecifier type,bool single) override
2052  {
2053  switch(type)
2054  {
2055  case VhdlSpecifier::LIBRARY:
2056  if (single) return "Library";
2057  else return "Libraries";
2058  case VhdlSpecifier::PACKAGE:
2059  if (single) return "Package";
2060  else return "Packages";
2061  case VhdlSpecifier::SIGNAL:
2062  if (single) return "Signal";
2063  else return "Signals";
2064  case VhdlSpecifier::COMPONENT:
2065  if (single) return "Component";
2066  else return "Components";
2067  case VhdlSpecifier::CONSTANT:
2068  if (single) return "Constant";
2069  else return "Constants";
2070  case VhdlSpecifier::ENTITY:
2071  if (single) return "Entity";
2072  else return "Entities";
2073  case VhdlSpecifier::TYPE:
2074  if (single) return "Type";
2075  else return "Types";
2076  case VhdlSpecifier::SUBTYPE:
2077  if (single) return "Subtype";
2078  else return "Subtypes";
2079  case VhdlSpecifier::FUNCTION:
2080  if (single) return "Function";
2081  else return "Functions";
2082  case VhdlSpecifier::RECORD:
2083  if (single) return "Record";
2084  else return "Records";
2085  case VhdlSpecifier::PROCEDURE:
2086  if (single) return "Procedure";
2087  else return "Procedures";
2088  case VhdlSpecifier::ARCHITECTURE:
2089  if (single) return "Architecture";
2090  else return "Architectures";
2091  case VhdlSpecifier::ATTRIBUTE:
2092  if (single) return "Attribute";
2093  else return "Attributes";
2094  case VhdlSpecifier::PROCESS:
2095  if (single) return "Process";
2096  else return "Processes";
2097  case VhdlSpecifier::PORT:
2098  if (single) return "Port";
2099  else return "Ports";
2100  case VhdlSpecifier::USE:
2101  if (single) return "use clause";
2102  else return "Use Clauses";
2103  case VhdlSpecifier::GENERIC:
2104  if (single) return "Generic";
2105  else return "Generics";
2106  case VhdlSpecifier::PACKAGE_BODY:
2107  return "Package Body";
2108  case VhdlSpecifier::UNITS:
2109  return "Units";
2110  case VhdlSpecifier::SHAREDVARIABLE:
2111  if (single) return "Shared Variable";
2112  else return "Shared Variables";
2113  case VhdlSpecifier::VFILE:
2114  if (single) return "File";
2115  else return "Files";
2116  case VhdlSpecifier::GROUP:
2117  if (single) return "Group";
2118  else return "Groups";
2119  case VhdlSpecifier::INSTANTIATION:
2120  if (single) return "Instantiation";
2121  else return "Instantiations";
2122  case VhdlSpecifier::ALIAS:
2123  if (single) return "Alias";
2124  else return "Aliases";
2125  case VhdlSpecifier::CONFIG:
2126  if (single) return "Configuration";
2127  else return "Configurations";
2128  case VhdlSpecifier::MISCELLANEOUS:
2129  return "Miscellaneous";
2130  case VhdlSpecifier::UCF_CONST:
2131  return "Constraints";
2132  default:
2133  return "Class";
2134  }
2135  }
2136  QCString trCustomReference(const QCString &name) override
2137  { return name+" Reference"; }
2138 
2139  /* Slice */
2140  QCString trConstants() override
2141  {
2142  return "Constants";
2143  }
2144  QCString trConstantDocumentation() override
2145  {
2146  return "Constant Documentation";
2147  }
2148  QCString trSequences() override
2149  {
2150  return "Sequences";
2151  }
2152  QCString trSequenceDocumentation() override
2153  {
2154  return "Sequence Documentation";
2155  }
2156  QCString trDictionaries() override
2157  {
2158  return "Dictionaries";
2159  }
2160  QCString trDictionaryDocumentation() override
2161  {
2162  return "Dictionary Documentation";
2163  }
2164  QCString trSliceInterfaces() override
2165  {
2166  return "Interfaces";
2167  }
2168  QCString trInterfaceIndex() override
2169  {
2170  return "Interface Index";
2171  }
2172  QCString trInterfaceList() override
2173  {
2174  return "Interface List";
2175  }
2176  QCString trInterfaceListDescription() override
2177  {
2178  return "Here are the interfaces with brief descriptions:";
2179  }
2180  QCString trInterfaceHierarchy() override
2181  {
2182  return "Interface Hierarchy";
2183  }
2184  QCString trInterfaceHierarchyDescription() override
2185  {
2186  return "This inheritance list is sorted roughly, but not completely, alphabetically:";
2187  }
2188  QCString trInterfaceDocumentation() override
2189  {
2190  return "Interface Documentation";
2191  }
2192  QCString trStructs() override
2193  {
2194  return "Structs";
2195  }
2196  QCString trStructIndex() override
2197  {
2198  return "Struct Index";
2199  }
2200  QCString trStructList() override
2201  {
2202  return "Struct List";
2203  }
2204  QCString trStructListDescription() override
2205  {
2206  return "Here are the structs with brief descriptions:";
2207  }
2208  QCString trStructDocumentation() override
2209  {
2210  return "Struct Documentation";
2211  }
2212  QCString trExceptionIndex() override
2213  {
2214  return "Exception Index";
2215  }
2216  QCString trExceptionList() override
2217  {
2218  return "Exception List";
2219  }
2220  QCString trExceptionListDescription() override
2221  {
2222  return "Here are the exceptions with brief descriptions:";
2223  }
2224  QCString trExceptionHierarchy() override
2225  {
2226  return "Exception Hierarchy";
2227  }
2228  QCString trExceptionHierarchyDescription() override
2229  {
2230  return "This inheritance list is sorted roughly, but not completely, alphabetically:";
2231  }
2232  QCString trExceptionDocumentation() override
2233  {
2234  return "Exception Documentation";
2235  }
2236  QCString trCompoundReferenceSlice(const QCString &clName, ClassDef::CompoundType compType, bool isLocal) override
2237  {
2238  QCString result=clName;
2239  if (isLocal) result+=" Local";
2240  switch(compType)
2241  {
2242  case ClassDef::Class: result+=" Class"; break;
2243  case ClassDef::Struct: result+=" Struct"; break;
2244  case ClassDef::Union: result+=" Union"; break;
2245  case ClassDef::Interface: result+=" Interface"; break;
2246  case ClassDef::Protocol: result+=" Protocol"; break;
2247  case ClassDef::Category: result+=" Category"; break;
2248  case ClassDef::Exception: result+=" Exception"; break;
2249  default: break;
2250  }
2251  result+=" Reference";
2252  return result;
2253  }
2254  QCString trOperations() override
2255  {
2256  return "Operations";
2257  }
2258  QCString trOperationDocumentation() override
2259  {
2260  return "Operation Documentation";
2261  }
2262  QCString trDataMembers() override
2263  {
2264  return "Data Members";
2265  }
2266  QCString trDataMemberDocumentation() override
2267  {
2268  return "Data Member Documentation";
2269  }
2270 
2272 // new since 1.8.19
2274 
2277  { return "Design Unit Documentation"; }
2278 
2280 // new since 1.9.2
2282 
2284  QCString trConcept(bool first_capital, bool singular) override
2285  {
2286  QCString result((first_capital ? "Concept" : "concept"));
2287  if (!singular) result+="s";
2288  return result;
2289  }
2291  QCString trConceptReference(const QCString &conceptName) override
2292  {
2293  QCString result=conceptName;
2294  result+=" Concept Reference";
2295  return result;
2296  }
2297 
2300  { return "Concept List"; }
2301 
2304  { return "Concept Index"; }
2305 
2308  { return "Concept Documentation"; }
2309 
2311  QCString trConceptListDescription(bool extractAll) override
2312  {
2313  QCString result="Here is a list of all ";
2314  if (!extractAll) result+="documented ";
2315  result+="concepts with brief descriptions:";
2316  return result;
2317  }
2318 
2321  {
2322  return "Concept definition";
2323  }
2324 
2326 // new since 1.9.4
2328 
2329  QCString trPackageList() override
2330  { return "Package List"; }
2331 
2333 // new since 1.9.6
2335 
2340  { return "Flowchart:"; }
2341 
2347 // new since 1.9.7
2350 
2355  { return "Related Symbols"; }
2356 
2362  { return "(Note that these are not member symbols.)"; }
2363 
2370  { return "Friends And Related Symbol Documentation"; }
2371 
2374  {
2375  QCString result;
2376  switch(compType)
2377  {
2378  case ClassDef::Class:
2379  if (lang == SrcLangExt::Fortran) trType(true,true);
2380  else result=trClass(true,true);
2381  break;
2382  case ClassDef::Struct: result="Struct"; break;
2383  case ClassDef::Union: result="Union"; break;
2384  case ClassDef::Interface: result="Interface"; break;
2385  case ClassDef::Protocol: result="Protocol"; break;
2386  case ClassDef::Category: result="Category"; break;
2387  case ClassDef::Exception: result="Exception"; break;
2388  case ClassDef::Service: result="Service"; break;
2389  case ClassDef::Singleton: result="Singleton"; break;
2390  default: break;
2391  }
2392  return result;
2393  }
2394 
2395  QCString trFileMembersDescriptionTotal(FileMemberHighlight::Enum hl) override
2396  {
2397  bool extractAll = Config_getBool(EXTRACT_ALL);
2398  QCString result="Here is a list of all ";
2399  if (!extractAll) result+="documented ";
2400 
2401  switch (hl)
2402  {
2403  case FileMemberHighlight::All:
2404  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
2405  {
2406  result+="functions, variables, defines, enums, and typedefs";
2407  }
2408  else
2409  {
2410  result+="file members";
2411  }
2412  break;
2413  case FileMemberHighlight::Functions:
2414  result+="functions";
2415  break;
2416  case FileMemberHighlight::Variables:
2417  result+="variables";
2418  break;
2419  case FileMemberHighlight::Typedefs:
2420  result+="typedefs";
2421  break;
2422  case FileMemberHighlight::Sequences:
2423  result+="sequences";
2424  break;
2425  case FileMemberHighlight::Dictionaries:
2426  result+="dictionaries";
2427  break;
2428  case FileMemberHighlight::Enums:
2429  result+="enums";
2430  break;
2431  case FileMemberHighlight::EnumValues:
2432  result+="enum values";
2433  break;
2434  case FileMemberHighlight::Defines:
2435  result+="macros";
2436  break;
2437  case FileMemberHighlight::Total: // for completeness
2438  break;
2439  }
2440  result+=" with links to ";
2441  if (extractAll)
2442  result+="the files they belong to:";
2443  else
2444  result+="the documentation:";
2445  return result;
2446  }
2447  QCString trCompoundMembersDescriptionTotal(ClassMemberHighlight::Enum hl) override
2448  {
2449  bool extractAll = Config_getBool(EXTRACT_ALL);
2450  QCString result="Here is a list of all ";
2451  if (!extractAll)
2452  {
2453  result+="documented ";
2454  }
2455 
2456  switch (hl)
2457  {
2458  case ClassMemberHighlight::All:
2459  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
2460  {
2461  result+="struct and union fields";
2462  }
2463  else
2464  {
2465  result+="class members";
2466  }
2467  break;
2468  case ClassMemberHighlight::Functions:
2469  result+="functions";
2470  break;
2471  case ClassMemberHighlight::Variables:
2472  result+="variables";
2473  break;
2474  case ClassMemberHighlight::Typedefs:
2475  result+="typedefs";
2476  break;
2477  case ClassMemberHighlight::Enums:
2478  result+="enums";
2479  break;
2480  case ClassMemberHighlight::EnumValues:
2481  result+="enum values";
2482  break;
2483  case ClassMemberHighlight::Properties:
2484  result+="properties";
2485  break;
2486  case ClassMemberHighlight::Events:
2487  result+="events";
2488  break;
2489  case ClassMemberHighlight::Related:
2490  result+="related symbols";
2491  break;
2492  case ClassMemberHighlight::Total: // for completeness
2493  break;
2494  }
2495  result+=" with links to ";
2496  if (!extractAll)
2497  {
2498  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
2499  {
2500  result+="the struct/union documentation for each field:";
2501  }
2502  else
2503  {
2504  result+="the class documentation for each member:";
2505  }
2506  }
2507  else
2508  {
2509  if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
2510  {
2511  result+="the structures/unions they belong to:";
2512  }
2513  else
2514  {
2515  result+="the classes they belong to:";
2516  }
2517  }
2518  return result;
2519  }
2520  QCString trNamespaceMembersDescriptionTotal(NamespaceMemberHighlight::Enum hl) override
2521  {
2522  bool extractAll = Config_getBool(EXTRACT_ALL);
2523  QCString result="Here is a list of all ";
2524  if (!extractAll) result+="documented ";
2525  result+="namespace ";
2526  QCString singularResult = "";
2527  QCString pluralResult = "";
2528  switch (hl)
2529  {
2530  case NamespaceMemberHighlight::All:
2531  singularResult="member";
2532  break;
2533  case NamespaceMemberHighlight::Functions:
2534  singularResult="function";
2535  break;
2536  case NamespaceMemberHighlight::Variables:
2537  singularResult="variable";
2538  break;
2539  case NamespaceMemberHighlight::Typedefs:
2540  singularResult="typedef";
2541  break;
2542  case NamespaceMemberHighlight::Sequences:
2543  singularResult="sequence";
2544  break;
2545  case NamespaceMemberHighlight::Dictionaries:
2546  singularResult="dictionary";
2547  pluralResult="dictionaries";
2548  break;
2549  case NamespaceMemberHighlight::Enums:
2550  singularResult="enum";
2551  break;
2552  case NamespaceMemberHighlight::EnumValues:
2553  singularResult="enum value";
2554  break;
2555  case NamespaceMemberHighlight::Total: // for completeness
2556  break;
2557  }
2558  result+=(pluralResult.isEmpty() ? singularResult+"s" : pluralResult);
2559  result+=" with links to ";
2560  if (extractAll)
2561  result+="the namespace documentation for each " + singularResult + ":";
2562  else
2563  result+="the namespaces they belong to:";
2564  return result;
2565  }
2566  QCString trDefinition() override { return "Definition";}
2567  QCString trDeclaration() override { return "Declaration";}
2568 
2570 // new since 1.9.8
2572 
2573  QCString trTopics() override
2574  { return "Topics"; }
2575  QCString trTopicDocumentation() override
2576  { return "Topic Documentation"; }
2577  QCString trTopicList() override
2578  { return "Topic List"; }
2579  QCString trTopicIndex() override
2580  { return "Topic Index"; }
2581  QCString trTopicListDescription() override
2582  { return "Here is a list of all topics with brief descriptions:"; }
2583  QCString trModuleMembersDescriptionTotal(ModuleMemberHighlight::Enum hl) override
2584  {
2585  bool extractAll = Config_getBool(EXTRACT_ALL);
2586  QCString result="Here is a list of all ";
2587  if (!extractAll) result+="documented ";
2588  result+="module ";
2589  QCString singularResult = "";
2590  QCString pluralResult = "";
2591  switch (hl)
2592  {
2593  case ModuleMemberHighlight::All:
2594  singularResult="member";
2595  break;
2596  case ModuleMemberHighlight::Functions:
2597  singularResult="function";
2598  break;
2599  case ModuleMemberHighlight::Variables:
2600  singularResult="variable";
2601  break;
2602  case ModuleMemberHighlight::Typedefs:
2603  singularResult="typedef";
2604  break;
2605  case ModuleMemberHighlight::Enums:
2606  singularResult="enum";
2607  break;
2608  case ModuleMemberHighlight::EnumValues:
2609  singularResult="enum value";
2610  break;
2611  case ModuleMemberHighlight::Total: // for completeness
2612  break;
2613  }
2614  result+=(pluralResult.isEmpty() ? singularResult+"s" : pluralResult);
2615  result+=" with links to ";
2616  if (extractAll)
2617  result+="the module documentation for each " + singularResult + ":";
2618  else
2619  result+="the module they belong to:";
2620  return result;
2621  }
2622  QCString trExportedModules() override
2623  {
2624  return "Exported Modules";
2625  }
2626 
2628 // new since 1.10.0
2630 
2631  QCString trCopyToClipboard() override
2632  {
2633  return "Copy to clipboard";
2634  }
2636 // new since 1.11.0
2638  QCString trImportant() override
2639  {
2640  return "Important";
2641  }
2642 };
2643 
2644 #endif
QCString trEnumName() override
Definition: translator_en.h:169
QCString trModulesList() override
Definition: translator_en.h:1622
QCString trLoading() override
Definition: translator_en.h:1764
QCString trStaticPackageFunctions() override
Definition: translator_en.h:1392
QCString trRTFCharSet() override
Definition: translator_en.h:1195
QCString trSourceFile(const QCString &filename) override
Definition: translator_en.h:1477
QCString trModulesMembers() override
Definition: translator_en.h:1664
QCString trInterfaces() override
old style UNO IDL services: implemented interfaces
Definition: translator_en.h:1971
QCString trDirRelation(const QCString &name) override
Definition: translator_en.h:1758
QCString trFile(bool first_capital, bool singular) override
Definition: translator_en.h:1221
QCString trInstanceMethods() override
Definition: translator_en.h:1954
QCString trInitialValue() override
Definition: translator_en.h:874
QCString trSingletonGeneratedFromFiles(bool single) override
UNO IDL singleton page.
Definition: translator_en.h:2013
QCString trRTFansicp() override
Definition: translator_en.h:1186
QCString trRelatedPagesDescription() override
Definition: translator_en.h:358
QCString trTypedefs() override
Definition: translator_en.h:448
QCString trVhdlType(VhdlSpecifier type, bool single) override
VHDL type.
Definition: translator_en.h:2051
QCString trReimplementedFromList(int numEntries) override
Definition: translator_en.h:709
QCString trConstantGroups() override
UNO IDL constant groups.
Definition: translator_en.h:1979
QCString trMemberTypedefDocumentation() override
Definition: translator_en.h:105
QCString trLegendDocs() override
Definition: translator_en.h:1005
QCString trCompoundListDescriptionFortran() override
Definition: translator_en.h:1567
QCString trModulesDescription() override
Definition: translator_en.h:362
QCString trConceptList() override
Definition: translator_en.h:2299
QCString trCompoundMembersFortran() override
Definition: translator_en.h:1563
QCString trPackageAttribs() override
Definition: translator_en.h:1399
QCString idLanguage() override
Definition: translator_en.h:55
QCString trTodo() override
Definition: translator_en.h:957
QCString trAdditionalInheritedMembers() override
Definition: translator_en.h:1908
QCString trFileIndex() override
Definition: translator_en.h:401
QCString trDetailedDescription() override
Definition: translator_en.h:97
QCString trFunctionAndProc() override
VHDL functions/procedures/processes.
Definition: translator_en.h:2048
QCString trDirectories() override
Definition: translator_en.h:1501
QCString trIncludingInheritedMembers() override
Definition: translator_en.h:155
QCString trTypeConstraints() override
Definition: translator_en.h:1748
QCString trInheritsList(int numEntries) override
Definition: translator_en.h:693
QCString trClassDocumentation() override
Definition: translator_en.h:413
QCString trCompoundReference(const QCString &clName, ClassDef::CompoundType compType, bool isTemplate) override
Definition: translator_en.h:607
QCString trCompoundMembers() override
Definition: translator_en.h:210
QCString trCompoundIndex() override
Definition: translator_en.h:386
QCString trAndMore(const QCString &number) override
Definition: translator_en.h:1886
QCString trExamples() override
Definition: translator_en.h:240
QCString trRelatedFunctions() override
Definition: translator_en.h:89
QCString trCompoundList() override
Definition: translator_en.h:193
QCString trVariables() override
Definition: translator_en.h:466
QCString trImplementedInList(int numEntries) override
Definition: translator_en.h:1322
QCString trTemplateParameters() override
Definition: translator_en.h:1882
QCString trReimplementedInList(int numEntries) override
Definition: translator_en.h:717
QCString trPostcondition() override
Definition: translator_en.h:864
QCString trDocumentation() override
Definition: translator_en.h:368
QCString trDesignUnitListDescription() override
VHDL design unit list description.
Definition: translator_en.h:2036
QCString trFileMembersDescription(bool extractAll) override
Definition: translator_en.h:332
QCString trRTFGeneralIndex() override
Definition: translator_en.h:1201
QCString trCompoundMembersDescription(bool extractAll) override
Definition: translator_en.h:290
QCString trInheritedFrom(const QCString &members, const QCString &what) override
Definition: translator_en.h:1902
QCString trCompoundListDescription() override
Definition: translator_en.h:271
QCString trDefineDocumentation() override
Definition: translator_en.h:478
QCString trAuthor(bool first_capital, bool singular) override
Definition: translator_en.h:1289
QCString trConceptDefinition() override
Definition: translator_en.h:2320
QCString trClassHierarchyDescription() override
Definition: translator_en.h:248
SrcLangExt
Language as given by extension.
Definition: types.h:41
QCString trCopyright() override
Definition: translator_en.h:1866
QCString trDirIndex() override
Definition: translator_en.h:1489
QCString trEnumReference(const QCString &name) override
Definition: translator_en.h:1898
QCString trReferenceManual() override
Definition: translator_en.h:436
QCString trCallGraph() override
Definition: translator_en.h:1423
QCString trConceptListDescription(bool extractAll) override
Definition: translator_en.h:2311
QCString trConceptReference(const QCString &conceptName) override
Definition: translator_en.h:2291
QCString trMemberFunctionDocumentationFortran() override
Definition: translator_en.h:1555
QCString trListOfAllMembers() override
Definition: translator_en.h:143
QCString trClasses() override
Definition: translator_en.h:1110
QCString trClass(bool first_capital, bool singular) override
Definition: translator_en.h:1210
QCString trReturns() override
Definition: translator_en.h:550
QCString trDesignUnitHierarchy() override
VHDL design unit hierarchy.
Definition: translator_en.h:2027
QCString trDesignUnitIndex() override
VHDL design unit index.
Definition: translator_en.h:2042
QCString trPrecondition() override
Definition: translator_en.h:859
QCString trRelatedSymbols() override
Definition: translator_en.h:2354
QCString trModule(bool first_capital, bool singular) override
Definition: translator_en.h:1694
QCString trIncludesFileIn(const QCString &name) override
Definition: translator_en.h:1804
QCString trCompoundListFortran() override
Definition: translator_en.h:1559
QCString trDesignUnits() override
VHDL design units.
Definition: translator_en.h:2045
Definition: translator_en.h:43
QCString trSubprogramDocumentation() override
Definition: translator_en.h:1612
QCString trMainPage() override
Definition: translator_en.h:798
QCString trSearch() override
Definition: translator_en.h:244
QCString generateMarker(int id)
Definition: util.cpp:288
QCString trReturnValues() override
Definition: translator_en.h:793
QCString trNamespace(bool first_capital, bool singular) override
Definition: translator_en.h:1232
QCString trPackageFunctions() override
Definition: translator_en.h:1381
QCString trModuleIndex() override
Definition: translator_en.h:374
QCString trPage(bool first_capital, bool singular) override
Definition: translator_en.h:1254
QCString trReferences() override
Definition: translator_en.h:1302
QCString trFileList() override
Definition: translator_en.h:206
QCString trDetails() override
Definition: translator_en.h:101
QCString trRelatedSubscript() override
Definition: translator_en.h:93
QCString trConceptDocumentation() override
Definition: translator_en.h:2307
QCString trSubprogram(bool first_capital, bool singular) override
Definition: translator_en.h:1740
QCString trPackages() override
Definition: translator_en.h:1132
QCString trRTFTableOfContents() override
Definition: translator_en.h:1334
QCString trProperties() override
Definition: translator_en.h:1095
QCString trDirDepGraph(const QCString &name) override
Definition: translator_en.h:1870
QCString trParameters() override
Definition: translator_en.h:558
QCString trBug() override
Definition: translator_en.h:1147
QCString trCompoundIndexFortran() override
Definition: translator_en.h:1594
QCString trFileIn(const QCString &name) override
Definition: translator_en.h:1795
QCString trCiteReferences() override
Definition: translator_en.h:1862
QCString trClassDiagram(const QCString &clName) override
Definition: translator_en.h:532
QCString trSearchMatches() override
Definition: translator_en.h:1466
QCString trExceptions() override
Definition: translator_en.h:562
QCString trModulesMemberDescription(bool extractAll) override
Definition: translator_en.h:1668
QCString trDataTypes() override
Definition: translator_en.h:1618
QCString trModulesListDescription(bool extractAll) override
Definition: translator_en.h:1626
QCString trDefineValue() override
Definition: translator_en.h:1137
QCString trConstructorDocumentation() override
Definition: translator_en.h:844
QCString trConcept(bool first_capital, bool singular) override
C++20 concept.
Definition: translator_en.h:2284
QCString trGotoDocumentation() override
Definition: translator_en.h:854
QCString trBugList() override
Definition: translator_en.h:1152
QCString trCompoundMembersDescriptionFortran(bool extractAll) override
Definition: translator_en.h:1571
QCString trNamespaceMembers() override
Definition: translator_en.h:723
QCString trRelatedSymbolsSubscript() override
Definition: translator_en.h:2361
QCString trSubprograms() override
Definition: translator_en.h:1606
QCString trFunctionDocumentation() override
Definition: translator_en.h:496
QCString trInvariant() override
Definition: translator_en.h:869
QCString trGroup(bool first_capital, bool singular) override
Definition: translator_en.h:1243
QCString trCompounds() override
Definition: translator_en.h:508
QCString trConstantGroupReference(const QCString &namespaceName) override
UNO IDL constant groups.
Definition: translator_en.h:1983
QCString trVersion() override
Definition: translator_en.h:542
QCString trGeneratedAt(const QCString &date, const QCString &projName) override
Definition: translator_en.h:523
QCString trDesignUnitList() override
VHDL design unit list.
Definition: translator_en.h:2030
QCString trGlobal(bool first_capital, bool singular) override
Definition: translator_en.h:1276
QCString trDateTime(int year, int month, int day, int dayOfWeek, int hour, int minutes, int seconds, DateTimeType includeTime) override
Compiles a date string.
Definition: translator_en.h:1819
QCString trDeprecatedList() override
Definition: translator_en.h:1346
QCString trExtendsClass() override
Definition: translator_en.h:1938
QCString trMember(bool first_capital, bool singular) override
Definition: translator_en.h:1265
QCString trRelatedSymbolDocumentation() override
Definition: translator_en.h:2369
QCString trEnumerations() override
Definition: translator_en.h:454
QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType, bool single) override
Definition: translator_en.h:1704
QCString trThisIsTheListOfAllMembers() override
Definition: translator_en.h:151
QCString trOverloadText() override
Definition: translator_en.h:1527
QCString trGeneratedBy() override
Definition: translator_en.h:566
QCString trEnumValue() override
Definition: translator_en.h:173
QCString trClassHierarchy() override
Definition: translator_en.h:189
QCString trLegendTitle() override
Definition: translator_en.h:998
QCString trHierarchicalIndex() override
Definition: translator_en.h:380
QCString trModulesIndex() override
Definition: translator_en.h:1687
QCString trImplementedFromList(int numEntries) override
Definition: translator_en.h:1314
QCString trPackageTypes() override
Definition: translator_en.h:1374
QCString trGotoSourceCode() override
Definition: translator_en.h:849
QCString trSearchResults(int numDocuments) override
Definition: translator_en.h:1447
QCString trTestList() override
Definition: translator_en.h:1085
QCString trEnumerationTypeDocumentation() override
Definition: translator_en.h:490
QCString trDefinedIn() override
Definition: translator_en.h:177
Abstract base class for all translatable text fragments.
Definition: translator.h:27
QCString trDetailLevel() override
Definition: translator_en.h:1878
QCString trMethodDocumentation() override
Definition: translator_en.h:1961
QCString trGeneratedFromFiles(ClassDef::CompoundType compType, bool single) override
Definition: translator_en.h:767
QCString trNamespaceListDescription(bool extractAll) override
Definition: translator_en.h:578
QCString trConceptIndex() override
Definition: translator_en.h:2303
QCString trMemberList() override
Definition: translator_en.h:147
QCString trCompoundType(ClassDef::CompoundType compType, SrcLangExt lang) override
Definition: translator_en.h:2373
QCString trTodoList() override
Definition: translator_en.h:962
QCString trPanelSynchronisationTooltip(bool enable) override
Definition: translator_en.h:1919
QCString trFileReference(const QCString &fileName) override
Definition: translator_en.h:629
QCString trPageAbbreviation() override
Definition: translator_en.h:804
QCString trFlowchart() override
Definition: translator_en.h:2339
QCString trDir(bool first_capital, bool singular) override
Definition: translator_en.h:1513
QCString trGeneratedAutomatically(const QCString &s) override
Definition: translator_en.h:161
QCString trSearching() override
Definition: translator_en.h:1776
QCString trDesignUnitMembers() override
VHDL design unit members.
Definition: translator_en.h:2033
QCString trPropertyDocumentation() override
Definition: translator_en.h:1100
QCString trInheritedByList(int numEntries) override
Definition: translator_en.h:701
QCString latexLanguageSupportCommand() override
Definition: translator_en.h:72
QCString trMemberDataDocumentation() override
Definition: translator_en.h:126
QCString trFileMembers() override
Definition: translator_en.h:223
QCString trWarning() override
Definition: translator_en.h:538
QCString trCollaborationDiagram(const QCString &clName) override
Definition: translator_en.h:834
QCString trServiceGeneratedFromFiles(bool single) override
UNO IDL service page.
Definition: translator_en.h:2004
QCString trNamespaceList() override
Definition: translator_en.h:574
QCString trSearchResultsTitle() override
Definition: translator_en.h:1435
QCString trExamplesDescription() override
Definition: translator_en.h:354
QCString trEnumGeneratedFromFiles(bool single) override
Definition: translator_en.h:1890
QCString trNamespaceMemberDescription(bool extractAll) override
Definition: translator_en.h:727
QCString trInclDepGraph(const QCString &fName) override
Definition: translator_en.h:839
QCString trEnumerationValues() override
Definition: translator_en.h:472
QCString trModules() override
Definition: translator_en.h:185
QCString trFileDocumentation() override
Definition: translator_en.h:432
QCString trDate() override
Definition: translator_en.h:546
CompoundType
The various compound types.
Definition: classdef.h:107
QCString trNamespaceDocumentation() override
Definition: translator_en.h:747
QCString trServices() override
old style UNO IDL services: inherited services
Definition: translator_en.h:1975
QCString trFriends() override
Definition: translator_en.h:589
QCString trMore() override
Definition: translator_en.h:139
QCString trModuleReference(const QCString &namespaceName) override
Definition: translator_en.h:1656
QCString trVariableDocumentation() override
Definition: translator_en.h:502
QCString trNamespaceIndex() override
Definition: translator_en.h:741
QCString trMemberFunctionDocumentation() override
Definition: translator_en.h:113
QCString trAll() override
Definition: translator_en.h:1418
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition: qcstring.h:149
QCString trRelatedPages() override
Definition: translator_en.h:236
QCString trEnumerationValueDocumentation() override
Definition: translator_en.h:1547
QCString trModuleDocumentation() override
Definition: translator_en.h:407
QCString trCallerGraph() override
Definition: translator_en.h:1539
QCString trTest() override
Definition: translator_en.h:1080
QCString trDirReference(const QCString &dirName) override
Definition: translator_en.h:1507
QCString trMemberEnumerationDocumentation() override
Definition: translator_en.h:109
QCString trFileListDescription(bool extractAll) override
Definition: translator_en.h:262
QCString trCompoundReferenceFortran(const QCString &clName, ClassDef::CompoundType compType, bool isTemplate) override
Definition: translator_en.h:1635
This is an alternative implementation of QCString.
Definition: qcstring.h:93
QCString trTypeDocumentation() override
Definition: translator_en.h:1600
QCString trSeeAlso() override
Definition: translator_en.h:554
QCString trWriteList(int numEntries) override
Definition: translator_en.h:668
QCString trNamespaces() override
Definition: translator_en.h:757
QCString trCode() override
Definition: translator_en.h:879
QCString trDirDocumentation() override
Definition: translator_en.h:1495
QCString trType(bool first_capital, bool singular) override
Definition: translator_en.h:1729
QCString trNoMatches() override
Definition: translator_en.h:1782
QCString trDefines() override
Definition: translator_en.h:442
QCString trEventDocumentation() override
Definition: translator_en.h:1363
QCString trSingletonReference(const QCString &sName) override
UNO IDL singleton page title.
Definition: translator_en.h:1997
QCString trStaticPackageAttribs() override
Definition: translator_en.h:1406
QCString trFunctions() override
Definition: translator_en.h:460
QCString trPackage(const QCString &name) override
Definition: translator_en.h:1122
QCString trNamespaceReference(const QCString &namespaceName) override
Definition: translator_en.h:637
QCString trRelatedFunctionDocumentation() override
Definition: translator_en.h:599
QCString trLegend() override
Definition: translator_en.h:1070
QCString trEvents() override
Definition: translator_en.h:1358
QCString getLanguageString() override
language codes for Html help
Definition: translator_en.h:82
QCString trPackageListDescription() override
Definition: translator_en.h:1127
QCString trGlobalNamespace() override
Definition: translator_en.h:1770
QCString trServiceReference(const QCString &sName) override
UNO IDL service page title.
Definition: translator_en.h:1990
QCString trDesignUnitDocumentation() override
VHDL design unit documentation.
Definition: translator_en.h:2276
QCString trClassMethods() override
Definition: translator_en.h:1946
QCString trTypedefDocumentation() override
Definition: translator_en.h:484
QCString trProvidedByCategory() override
Definition: translator_en.h:1929