src/translator_cz.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_CZ_H
  19 #define TRANSLATOR_CZ_H
  20
  21 // Updates:
  22 // --------
  23 // 2013/04/11 - Updates for "new since 1.8.4".
  24 // 2012/07/31 - Updates for "new since 1.8.2".
  25 // 2012/04/10 - Updates for "new since 1.8.0".
  26 // 2011/07/28 - Updates for "new since 1.7.5".
  27 // 2010/06/01 - typo
  28 // 2010/04/28 - Updates for "new since 1.6.3".
  29 // 2009/09/02 - Updates for "new since 1.6.0 (mainly for the new search engine)".
  30 // 2008/06/09 - Corrections in trLegendDocs().
  31 // 2007/11/13 - Update for "new since 1.5.4 (mainly for Fortran)".
  32 // 2007/03/20 - removing decode(), conversion of literals to UTF-8.
  33 // 2006/06/13 - translation of the trEnumerationValueDocumentation().
  34 //              and clear in the Czech language.
  35 //              modified trCallGraph() to make the meaning unambiguous
  36 // 2006/05/10 - Update for "new since 1.4.6" -- trCallerGraph(),
  37 // 2005/03/08 - Update for "new since 1.4.1" (trOverloadText())
  38 // 2005/02/11 - The "never used" methods removed.
  39 // 2004/09/14 - The new methods "since 1.3.9" implemented.
  40 // 2004/06/16 - The new method "since 1.3.8" implemented.
  41 // 2004/02/27 - Text inside the trCallGraph() corrected.
  42 // 2004/02/26 - trLegendDocs() updated.
  43 // 2003/08/13 - Four new methods "since 1.3.3" implemented.
  44 // 2003/06/10 - Two new methods "since 1.3.1" implemented.
  45 // 2003/04/28 - Five new methods "since 1.3" implemented.
  46 // 2002/10/15 - The new trEvents() and trEventDocumentation() implemented.
  47 // 2002/07/29 - The new trDeprecatedList() implemented.
  48 // 2002/07/08 - The new trRTFTableOfContents() implemented. (my birthday! ;)
  49 // 2002/03/05 - ... forgot to replace TranslatorAdapter... by Translator.
  50 // 2002/01/23 - Two new methods "since 1.2.13" implemented.
  51 // 2001/11/06 - trReferences() implemented.
  52 // 2001/07/16 - trClassDocumentation() updated as in the English translator.
  53 // 2001/05/25 - Corrections.
  54 // 2001/05/18 - Updates, corrections.
  55 // 2001/05/02 - Decode() inline changed to decode(); cleaning.
  56 //              level as other translators.
  57 //              class Translator.  The English translator is now on the same
  58 //              introducing TranslatorAdapter class and the abstract base
  59 // 2001/04/20 - Update for "new since 1.2.6-20010422". Experimental version
  60 // 2001/04/10 - Updates (1.2.6-20010408), cleaning.
  61 // 2001/03/12 - Minor correction of comments (synchronous with translator.h).
  62 // 2001/02/26 - Update for "new since 1.2.5" version (trBug(), trBugList()).
  63 // 2001/02/15 - trMore() now returns only "..." (ellipsis).
  64 // 2001/01/09 - Update for "new since 1.2.4" version.
  65 // 2000/10/17 - Update for "new since 1.2.2" version.
  66 // 2000/09/11 - Update for "new since 1.2.1" version.
  67 // 2000/09/06 - Reimplementation of trInheritsList().
  68 // 2000/08/31 - ISOToWin() and WinToISO() moved to the base class.
  69 // 2000/08/30 - Macro DECODE replaced by the inline (thanks to Boris Bralo).
  70 // 2000/08/24 - Corrections, updates.
  71 // 2000/08/02 - Updated for 1.2.0
  72 // 2000/07/19 - Updates for "new since 1.1.5"; encoding conversion separated.
  73 // 2000/07/10 - Update to 1.1.5; conditionally decoding to iso-8859-2 for UNIX.
  74 // 2000/06/20 - Prototype: with diacritics; based on ver. 1.1.4 (from scratch).
  75 //
  76 // The first translation from English to Czech was started by
  77 // Vlastimil Havran (1999--2000). The prototype version of Czech strings
  78 // with diacritics was implemented by Petr Prikryl (prikrylp@skil.cz),
  79 // 2000/06/20. Vlastimil agreed that Petr be the new maintainer.
  80
  81 // Todo
  82 // ----
  83 //  - The trReimplementedFromList() should pass the kind of the
  84 //    reimplemented element.  It can be method, typedef or possibly
  85 //    something else.  It is difficult to find the general translation
  86 //    for all kinds in the Czech language.
  87
  88 class TranslatorCzech : public Translator
  89 {
  90   public:
  91     // --- Language control methods -------------------
  92
  93     virtual QCString idLanguage()
  94     { return "czech"; }
  95
  96     virtual QCString latexLanguageSupportCommand()
  97     {
  98       return "\\usepackage[T2A]{fontenc}\n"
  99              "\\usepackage[czech]{babel}\n";
 100     }
 101
 102     // --- Language translation methods -------------------
 103
 104     /*! used in the compound documentation before a list of related functions. */
 105     virtual QCString trRelatedFunctions()
 106     { return "Související funkce"; }
 107
 108     /*! subscript for the related functions. */
 109     virtual QCString trRelatedSubscript()
 110     { return "(Uvedené funkce nejsou členskými funkcemi.)"; }
 111
 112     /*! header that is put before the detailed description of files, classes and namespaces. */
 113     virtual QCString trDetailedDescription()
 114     { return "Detailní popis"; }
 115
 116     /*! header that is put before the list of typedefs. */
 117     virtual QCString trMemberTypedefDocumentation()
 118     { return "Dokumentace k členským typům"; }
 119
 120     /*! header that is put before the list of enumerations. */
 121     virtual QCString trMemberEnumerationDocumentation()
 122     { return "Dokumentace k členským výčtům"; }
 123
 124     /*! header that is put before the list of member functions. */
 125     virtual QCString trMemberFunctionDocumentation()
 126     { return "Dokumentace k metodám"; }
 127
 128     /*! header that is put before the list of member attributes. */
 129     virtual QCString trMemberDataDocumentation()
 130     {
 131       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 132       {
 133         return "Dokumentace k položkám";
 134       }
 135       else
 136       {
 137         return "Dokumentace k datovým členům";
 138       }
 139     }
 140
 141     /*! this is the text of a link put after brief descriptions. */
 142     virtual QCString trMore()
 143     { return "..."; }
 144
 145     /*! put in the class documentation */
 146     virtual QCString trListOfAllMembers()
 147     { return "Seznam všech členů"; }
 148
 149     /*! used as the title of the "list of all members" page of a class */
 150     virtual QCString trMemberList()
 151     { return "Seznam členů třídy"; }
 152
 153     /*! this is the first part of a sentence that is followed by a class name */
 154     virtual QCString trThisIsTheListOfAllMembers()
 155     { return "Zde naleznete úplný seznam členů třídy "; }
 156
 157     /*! this is the remainder of the sentence after the class name */
 158     virtual QCString trIncludingInheritedMembers()
 159     { return ", včetně všech zděděných členů."; }
 160
 161     /*! this is put at the author sections at the bottom of man pages.
 162      *  parameter s is name of the project name.
 163      */
 164     virtual QCString trGeneratedAutomatically(const char *s)
 165     { QCString result("Generováno automaticky programem Doxygen "
 166                       "ze zdrojových textů");
 167       if (s) result += QCString(" projektu ") + s;
 168       result += ".";
 169       return result;
 170     }
 171
 172     /*! put after an enum name in the list of all members */
 173     virtual QCString trEnumName()
 174     { return "jméno výčtu"; }
 175
 176     /*! put after an enum value in the list of all members */
 177     virtual QCString trEnumValue()
 178     { return "hodnota výčtu"; }
 179
 180     /*! put after an undocumented member in the list of all members */
 181     virtual QCString trDefinedIn()
 182     { return "definován v"; }
 183
 184     // quick reference sections
 185
 186     /*! This is put above each page as a link to the list of all groups of
 187      *  compounds or files (see the \\group command).
 188      */
 189     virtual QCString trModules()
 190     { return "Moduly"; }
 191
 192     /*! This is put above each page as a link to the class hierarchy */
 193     virtual QCString trClassHierarchy()
 194     { return "Hierarchie tříd"; }
 195
 196     /*! This is put above each page as a link to the list of annotated classes */
 197     virtual QCString trCompoundList()
 198     {
 199       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 200       {
 201         return "Datové struktury";
 202       }
 203       else
 204       {
 205         return "Seznam tříd";
 206       }
 207     }
 208
 209     /*! This is put above each page as a link to the list of documented files */
 210     virtual QCString trFileList()
 211     { return "Seznam souborů"; }
 212
 213     /*! This is put above each page as a link to all members of compounds. */
 214     virtual QCString trCompoundMembers()
 215     {
 216       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 217       {
 218         return "Datové položky";
 219       }
 220       else
 221       {
 222         return "Seznam členů tříd";
 223       }
 224     }
 225
 226     /*! This is put above each page as a link to all members of files. */
 227     virtual QCString trFileMembers()
 228     {
 229       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 230       {
 231         return "Globální symboly";
 232       }
 233       else
 234       {
 235         return "Symboly v souborech";
 236       }
 237     }
 238
 239     /*! This is put above each page as a link to all related pages. */
 240     virtual QCString trRelatedPages()
 241     { return "Ostatní stránky"; }
 242
 243     /*! This is put above each page as a link to all examples. */
 244     virtual QCString trExamples()
 245     { return "Příklady"; }
 246
 247     /*! This is put above each page as a link to the search engine. */
 248     virtual QCString trSearch()
 249     { return "Hledat"; }
 250
 251     /*! This is an introduction to the class hierarchy. */
 252     virtual QCString trClassHierarchyDescription()
 253     { return "Zde naleznete seznam, vyjadřující vztah dědičnosti tříd. "
 254              "Je seřazen přibližně (ale ne úplně) podle abecedy:";
 255     }
 256
 257     /*! This is an introduction to the list with all files. */
 258     virtual QCString trFileListDescription(bool extractAll)
 259     {
 260       QCString result="Zde naleznete seznam všech ";
 261       if (!extractAll) result+="dokumentovaných ";
 262       result+="souborů se stručnými popisy:";
 263       return result;
 264     }
 265
 266     /*! This is an introduction to the annotated compound list. */
 267     virtual QCString trCompoundListDescription()
 268     {
 269       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 270       {
 271         return "Následující seznam obsahuje identifikace datových "
 272                       "struktur a jejich stručné popisy:";
 273       }
 274       else
 275       {
 276         return "Následující seznam obsahuje především identifikace "
 277                       "tříd, ale nacházejí se zde i další netriviální prvky, "
 278                       "jako jsou struktury (struct), unie (union) a rozhraní "
 279                       "(interface). V seznamu jsou uvedeny jejich stručné "
 280                       "popisy:";
 281       }
 282     }
 283
 284     /*! This is an introduction to the page with all class members. */
 285     virtual QCString trCompoundMembersDescription(bool extractAll)
 286     {
 287       QCString result= "Zde naleznete seznam všech ";
 288       if (!extractAll)
 289       {
 290         result += "dokumentovaných ";
 291       }
 292
 293       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 294       {
 295         result += "položek struktur (struct) a unií (union) ";
 296       }
 297       else
 298       {
 299         result += "členů tříd ";
 300       }
 301
 302       result += "s odkazy na ";
 303
 304       if (extractAll)
 305       {
 306         if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 307         {
 308           result += "dokumentaci struktur/unií, ke kterým příslušejí:";
 309         }
 310         else
 311         {
 312           result += "dokumentaci tříd, ke kterým příslušejí:";
 313         }
 314       }
 315       else
 316       {
 317         if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 318         {
 319           result+="struktury/unie, ke kterým příslušejí:";
 320         }
 321         else
 322         {
 323           result+="třídy, ke kterým příslušejí:";
 324         }
 325       }
 326
 327       return result;
 328     }
 329
 330     /*! This is an introduction to the page with all file members. */
 331     virtual QCString trFileMembersDescription(bool extractAll)
 332     {
 333       QCString result="Zde naleznete seznam všech ";
 334       if (!extractAll) result+="dokumentovaných ";
 335
 336       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 337       {
 338         result+="funkcí, proměnných, maker, výčtů a definic typů (typedef) "
 339                 "s odkazy na ";
 340       }
 341       else
 342       {
 343         result+="symbolů, které jsou definovány na úrovni svých souborů. "
 344                 "Pro každý symbol je uveden odkaz na ";
 345       }
 346
 347       if (extractAll)
 348         result+="soubory, ke kterým příslušejí:";
 349       else
 350         result+="dokumentaci:";
 351
 352       return result;
 353     }
 354
 355     /*! This is an introduction to the page with the list of all examples */
 356     virtual QCString trExamplesDescription()
 357     { return "Zde naleznete seznam všech příkladů:"; }
 358
 359     /*! This is an introduction to the page with the list of related pages */
 360     virtual QCString trRelatedPagesDescription()
 361     { return "Následující seznam odkazuje na další stránky projektu:"; }
 362
 363     /*! This is an introduction to the page with the list of class/file groups */
 364     virtual QCString trModulesDescription()
 365     { return "Zde naleznete seznam všech modulů:"; }
 366
 367     // index titles (the project name is prepended for these)
 368
 369
 370     /*! This is used in HTML as the title of index.html. */
 371     virtual QCString trDocumentation()
 372     { return "Dokumentace"; }
 373
 374     /*! This is used in LaTeX as the title of the chapter with the
 375      * index of all groups.
 376      */
 377     virtual QCString trModuleIndex()
 378     { return "Rejstřík modulů"; }
 379
 380     /*! This is used in LaTeX as the title of the chapter with the
 381      * class hierarchy.
 382      */
 383     virtual QCString trHierarchicalIndex()
 384     { return "Rejstřík hierarchie tříd"; }
 385
 386     /*! This is used in LaTeX as the title of the chapter with the
 387      * annotated compound index.
 388      */
 389     virtual QCString trCompoundIndex()
 390     {
 391       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 392       {
 393         return "Rejstřík datových struktur";
 394       }
 395       else
 396       {
 397         return "Rejstřík tříd";
 398       }
 399     }
 400
 401     /*! This is used in LaTeX as the title of the chapter with the
 402      * list of all files.
 403      */
 404     virtual QCString trFileIndex()
 405     { return "Rejstřík souborů"; }
 406
 407     /*! This is used in LaTeX as the title of the chapter containing
 408      *  the documentation of all groups.
 409      */
 410     virtual QCString trModuleDocumentation()
 411     { return "Dokumentace modulů"; }
 412
 413     /*! This is used in LaTeX as the title of the chapter containing
 414      *  the documentation of all classes, structs and unions.
 415      */
 416     virtual QCString trClassDocumentation()
 417     {
 418       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 419       {
 420         return "Dokumentace datových struktur";
 421       }
 422       else
 423       {
 424         return "Dokumentace tříd";
 425       }
 426     }
 427
 428     /*! This is used in LaTeX as the title of the chapter containing
 429      *  the documentation of all files.
 430      */
 431     virtual QCString trFileDocumentation()
 432     { return "Dokumentace souborů"; }
 433
 434     /*! This is used in LaTeX as the title of the chapter containing
 435      *  the documentation of all examples.
 436      */
 437     virtual QCString trExampleDocumentation()
 438     { return "Dokumentace příkladů"; }
 439
 440     /*! This is used in LaTeX as the title of the chapter containing
 441      *  the documentation of all related pages.
 442      */
 443     virtual QCString trPageDocumentation()
 444     { return "Dokumentace souvisejících stránek"; }
 445
 446     /*! This is used in LaTeX as the title of the document */
 447     virtual QCString trReferenceManual()
 448     { return "Referenční příručka"; }
 449
 450     /*! This is used in the documentation of a file as a header before the
 451      *  list of defines
 452      */
 453     virtual QCString trDefines()
 454     { return "Definice maker"; }
 455
 456     /*! This is used in the documentation of a file as a header before the
 457      *  list of typedefs
 458      */
 459     virtual QCString trTypedefs()
 460     { return "Definice typů"; }
 461
 462     /*! This is used in the documentation of a file as a header before the
 463      *  list of enumerations
 464      */
 465     virtual QCString trEnumerations()
 466     { return "Výčty"; }
 467
 468     /*! This is used in the documentation of a file as a header before the
 469      *  list of (global) functions
 470      */
 471     virtual QCString trFunctions()
 472     { return "Funkce"; }
 473
 474     /*! This is used in the documentation of a file as a header before the
 475      *  list of (global) variables
 476      */
 477     virtual QCString trVariables()
 478     { return "Proměnné"; }
 479
 480     /*! This is used in the documentation of a file as a header before the
 481      *  list of (global) variables
 482      */
 483     virtual QCString trEnumerationValues()
 484     { return "Hodnoty výčtu"; }
 485
 486     /*! This is used in the documentation of a file before the list of
 487      *  documentation blocks for defines
 488      */
 489     virtual QCString trDefineDocumentation()
 490     { return "Dokumentace k definicím maker"; }
 491
 492     /*! This is used in the documentation of a file/namespace before the list
 493      *  of documentation blocks for typedefs
 494      */
 495     virtual QCString trTypedefDocumentation()
 496     { return "Dokumentace definic typů"; }
 497
 498     /*! This is used in the documentation of a file/namespace before the list
 499      *  of documentation blocks for enumeration types
 500      */
 501     virtual QCString trEnumerationTypeDocumentation()
 502     { return "Dokumentace výčtových typů"; }
 503
 504     /*! This is used in the documentation of a file/namespace before the list
 505      *  of documentation blocks for functions
 506      */
 507     virtual QCString trFunctionDocumentation()
 508     { return "Dokumentace funkcí"; }
 509
 510     /*! This is used in the documentation of a file/namespace before the list
 511      *  of documentation blocks for variables
 512      */
 513     virtual QCString trVariableDocumentation()
 514     { return "Dokumentace proměnných"; }
 515
 516     /*! This is used in the documentation of a file/namespace/group before
 517      *  the list of links to documented compounds
 518      */
 519     virtual QCString trCompounds()
 520     {
 521       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 522       {
 523         return "Datové struktry";
 524       }
 525       else
 526       {
 527         return "Třídy";
 528       }
 529     }
 530
 531     /*! This is used in the standard footer of each page and indicates when
 532      *  the page was generated
 533      */
 534     virtual QCString trGeneratedAt(const char *date,const char *projName)
 535     {
 536       QCString result("Generováno ");
 537       result += date;
 538       if (projName)
 539           result += QCString(" pro projekt ") + projName;
 540       result += " programem";
 541       return result;
 542     }
 543
 544     /*! this text is put before a class diagram */
 545     virtual QCString trClassDiagram(const char *clName)
 546     {
 547       return QCString("Diagram dědičnosti pro třídu ") + clName;
 548     }
 549
 550     /*! this text is generated when the \\internal command is used. */
 551     virtual QCString trForInternalUseOnly()
 552     { return "Pouze pro vnitřní použití."; }
 553
 554     /*! this text is generated when the \\warning command is used. */
 555     virtual QCString trWarning()
 556     { return "Pozor"; }
 557
 558     /*! this text is generated when the \\version command is used. */
 559     virtual QCString trVersion()
 560     { return "Verze"; }
 561
 562     /*! this text is generated when the \\date command is used. */
 563     virtual QCString trDate()
 564     { return "Datum"; }
 565
 566     /*! this text is generated when the \\return command is used. */
 567     virtual QCString trReturns()
 568     { return "Návratová hodnota"; }
 569
 570     /*! this text is generated when the \\sa command is used. */
 571     virtual QCString trSeeAlso()
 572     { return "Viz také"; }
 573
 574     /*! this text is generated when the \\param command is used. */
 575     virtual QCString trParameters()
 576     { return "Parametry"; }
 577
 578     /*! this text is generated when the \\exception command is used. */
 579     virtual QCString trExceptions()
 580     { return "Výjimky"; }
 581
 582     /*! this text is used in the title page of a LaTeX document. */
 583     virtual QCString trGeneratedBy()
 584     { return "Generováno programem"; }
 585
 586     // new since 0.49-990307
 587
 588     /*! used as the title of page containing all the index of all namespaces. */
 589     virtual QCString trNamespaceList()
 590     { return "Seznam prostorů jmen"; }
 591
 592     /*! used as an introduction to the namespace list */
 593     virtual QCString trNamespaceListDescription(bool extractAll)
 594     {
 595       QCString result="Zde naleznete seznam všech ";
 596       if (!extractAll) result+="dokumentovaných ";
 597       result+="prostorů jmen se stručným popisem:";
 598       return result;
 599     }
 600
 601     /*! used in the class documentation as a header before the list of all
 602      *  friends of a class
 603      */
 604     virtual QCString trFriends()
 605     { return "Friends"; }
 606
 607 //////////////////////////////////////////////////////////////////////////
 608 // new since 0.49-990405
 609 //////////////////////////////////////////////////////////////////////////
 610
 611     /*! used in the class documentation as a header before the list of all
 612      * related classes
 613      */
 614     virtual QCString trRelatedFunctionDocumentation()
 615     { return "Dokumentace k friends"; }
 616
 617 //////////////////////////////////////////////////////////////////////////
 618 // new since 0.49-990425
 619 //////////////////////////////////////////////////////////////////////////
 620
 621     /*! used as the title of the HTML page of a class/struct/union */
 622     virtual QCString trCompoundReference(const char *clName,
 623                                     ClassDef::CompoundType compType,
 624                                     bool isTemplate)
 625     {
 626       QCString result("Dokumentace ");
 627       if (isTemplate) result += "šablony ";
 628       switch(compType)
 629       {
 630         case ClassDef::Class:      result += "třídy "; break;
 631         case ClassDef::Struct:     result += "struktury "; break;
 632         case ClassDef::Union:      result += "unie "; break;
 633         case ClassDef::Interface:  result += "rozhraní "; break;
 634         case ClassDef::Protocol:   result += "protokolu "; break;
 635         case ClassDef::Category:   result += "kategorie "; break;
 636         case ClassDef::Exception:  result += "výjimky "; break;
 637         default: break;
 638       }
 639       result += clName;
 640       return result;
 641     }
 642
 643     /*! used as the title of the HTML page of a file */
 644     virtual QCString trFileReference(const char *fileName)
 645     {
 646       QCString result("Dokumentace souboru ");
 647       result+=fileName;
 648       return result;
 649     }
 650
 651     /*! used as the title of the HTML page of a namespace */
 652     virtual QCString trNamespaceReference(const char *namespaceName)
 653     {
 654       QCString result("Dokumentace prostoru jmen ");
 655       result+=namespaceName;
 656       return result;
 657     }
 658
 659     /*
 660      *  these are for the member sections of a class, struct or union
 661      */
 662     virtual QCString trPublicMembers()
 663     { return "Veřejné metody"; }
 664     virtual QCString trPublicSlots()
 665     { return "Veřejné sloty"; }
 666     virtual QCString trSignals()
 667     { return "Signály"; }
 668     virtual QCString trStaticPublicMembers()
 669     { return "Statické veřejné metody"; }
 670     virtual QCString trProtectedMembers()
 671     { return "Chráněné metody"; }
 672     virtual QCString trProtectedSlots()
 673     { return "Chráněné sloty"; }
 674     virtual QCString trStaticProtectedMembers()
 675     { return "Statické chráněné metody"; }
 676     virtual QCString trPrivateMembers()
 677     { return "Privátní metody"; }
 678     virtual QCString trPrivateSlots()
 679     { return "Privátní sloty"; }
 680     virtual QCString trStaticPrivateMembers()
 681     { return "Statické privátní metody"; }
 682
 683     /*! this function is used to produce a comma-separated list of items.
 684      *  use generateMarker(i) to indicate where item i should be put.
 685      */
 686     virtual QCString trWriteList(int numEntries)
 687     {
 688       QCString result;
 689       int i;
 690       // the inherits list contain `numEntries' classes
 691       for (i=0;i<numEntries;i++)
 692       {
 693         // use generateMarker to generate placeholders for the class links!
 694         result+=generateMarker(i); // generate marker for entry i in the list
 695                                    // (order is left to right)
 696
 697         if (i!=numEntries-1)  // not the last entry, so we need a separator
 698         {
 699           if (i<numEntries-2) // not the fore last entry
 700             result+=", ";
 701           else                // the fore last entry
 702             result+=" a ";
 703         }
 704       }
 705       return result;
 706     }
 707
 708     /*! used in class documentation to produce a list of base classes,
 709      *  if class diagrams are disabled.
 710      */
 711     virtual QCString trInheritsList(int numEntries)
 712     {
 713       QCString result("Dědí z ");
 714       result += (numEntries == 1) ? "bázové třídy " : "bázových tříd ";
 715       result += trWriteList(numEntries) + ".";
 716       return result;
 717     }
 718
 719     /*! used in class documentation to produce a list of super classes,
 720      *  if class diagrams are disabled.
 721      */
 722     virtual QCString trInheritedByList(int numEntries)
 723     {
 724       QCString result("Zděděna ");
 725       result += (numEntries == 1) ? "třídou " : "třídami ";
 726       result += trWriteList(numEntries) + ".";
 727       return result;
 728     }
 729
 730     /*! used in member documentation blocks to produce a list of
 731      *  members that are hidden by this one.
 732      */
 733     virtual QCString trReimplementedFromList(int numEntries)
 734     {
 735       QCString result("Reimplementuje stejnojmenný prvek z ");
 736       result += trWriteList(numEntries) + ".";
 737       return result;
 738     }
 739
 740     /*! used in member documentation blocks to produce a list of
 741      *  all member that overwrite the implementation of this member.
 742      */
 743     virtual QCString trReimplementedInList(int numEntries)
 744     {
 745       QCString result("Reimplementováno v ");
 746       result += trWriteList(numEntries) + ".";
 747       return result;
 748     }
 749
 750     /*! This is put above each page as a link to all members of namespaces. */
 751     virtual QCString trNamespaceMembers()
 752     { return "Symboly v prostorech jmen"; }
 753
 754     /*! This is an introduction to the page with all namespace members */
 755     virtual QCString trNamespaceMemberDescription(bool extractAll)
 756     {
 757       QCString result="Zde naleznete seznam všech ";
 758       if (!extractAll) result+="dokumentovaných ";
 759       result+="symbolů, které jsou definovány ve svých prostorech jmen. "
 760               "U každého je uveden odkaz na ";
 761       if (extractAll)
 762         result+="dokumentaci příslušného prostoru jmen:";
 763       else
 764         result+="příslušný prostor jmen:";
 765       return result;
 766     }
 767     /*! This is used in LaTeX as the title of the chapter with the
 768      *  index of all namespaces.
 769      */
 770     virtual QCString trNamespaceIndex()
 771     { return "Rejstřík prostorů jmen"; }
 772
 773     /*! This is used in LaTeX as the title of the chapter containing
 774      *  the documentation of all namespaces.
 775      */
 776     virtual QCString trNamespaceDocumentation()
 777     { return "Dokumentace prostorů jmen"; }
 778
 779 //////////////////////////////////////////////////////////////////////////
 780 // new since 0.49-990522
 781 //////////////////////////////////////////////////////////////////////////
 782
 783     /*! This is used in the documentation before the list of all
 784      *  namespaces in a file.
 785      */
 786     virtual QCString trNamespaces()
 787     { return "Prostory jmen"; }
 788
 789 //////////////////////////////////////////////////////////////////////////
 790 // new since 0.49-990728
 791 //////////////////////////////////////////////////////////////////////////
 792
 793     /*! This is put at the bottom of a class documentation page and is
 794      *  followed by a list of files that were used to generate the page.
 795      */
 796     virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
 797         bool single)
 798     { // here s is one of " Class", " Struct" or " Union"
 799       // single is true implies a single file
 800       QCString result=(QCString)"Dokumentace pro ";
 801       switch(compType)
 802       {
 803         case ClassDef::Class:      result+="tuto třídu"; break;
 804         case ClassDef::Struct:     result+="tuto strukturu (struct)"; break;
 805         case ClassDef::Union:      result+="tuto unii (union)"; break;
 806         case ClassDef::Interface:  result+="toto rozhraní"; break;
 807         case ClassDef::Protocol:   result+="tento protokol "; break;
 808         case ClassDef::Category:   result+="tuto kategorii "; break;
 809         case ClassDef::Exception:  result+="tuto výjimku"; break;
 810         default: break;
 811       }
 812       result+=" byla generována z ";
 813       if (single) result+="následujícího souboru:";
 814       else        result+="následujících souborů:";
 815       return result;
 816     }
 817
 818 //////////////////////////////////////////////////////////////////////////
 819 // new since 0.49-990901
 820 //////////////////////////////////////////////////////////////////////////
 821
 822     /*! This is used as the heading text for the retval command. */
 823     virtual QCString trReturnValues()
 824     { return "Vracené hodnoty"; }
 825
 826     /*! This is in the (quick) index as a link to the main page (index.html)
 827      */
 828     virtual QCString trMainPage()
 829     { return "Hlavní stránka"; }
 830
 831     /*! This is used in references to page that are put in the LaTeX
 832      *  documentation. It should be an abbreviation of the word page.
 833      */
 834     virtual QCString trPageAbbreviation()
 835     { return "s."; }
 836
 837 //////////////////////////////////////////////////////////////////////////
 838 // new since 0.49-991003
 839 //////////////////////////////////////////////////////////////////////////
 840
 841     virtual QCString trDefinedAtLineInSourceFile()
 842     {
 843       return "Definice je uvedena na řádku @0 v souboru @1.";
 844     }
 845     virtual QCString trDefinedInSourceFile()
 846     {
 847       return "Definice v souboru @0.";
 848     }
 849
 850 //////////////////////////////////////////////////////////////////////////
 851 // new since 0.49-991205
 852 //////////////////////////////////////////////////////////////////////////
 853
 854     virtual QCString trDeprecated()
 855     {
 856       return "Zastaralé";
 857     }
 858
 859 //////////////////////////////////////////////////////////////////////////
 860 // new since 1.0.0
 861 //////////////////////////////////////////////////////////////////////////
 862
 863     /*! this text is put before a collaboration diagram */
 864     virtual QCString trCollaborationDiagram(const char *clName)
 865     {
 866       return (QCString)"Diagram tříd pro "+clName+":";
 867     }
 868     /*! this text is put before an include dependency graph */
 869     virtual QCString trInclDepGraph(const char *fName)
 870     {
 871       return (QCString)"Graf závislostí na vkládaných souborech "
 872                     "pro "+fName+":";
 873     }
 874     /*! header that is put before the list of constructor/destructors. */
 875     virtual QCString trConstructorDocumentation()
 876     {
 877       return "Dokumentace konstruktoru a destruktoru";
 878     }
 879     /*! Used in the file documentation to point to the corresponding sources. */
 880     virtual QCString trGotoSourceCode()
 881     {
 882       return "Zobrazit zdrojový text tohoto souboru.";
 883     }
 884     /*! Used in the file sources to point to the corresponding documentation. */
 885     virtual QCString trGotoDocumentation()
 886     {
 887       return "Zobrazit dokumentaci tohoto souboru.";
 888     }
 889     /*! Text for the \\pre command */
 890     virtual QCString trPrecondition()
 891     {
 892       return "Precondition";
 893     }
 894     /*! Text for the \\post command */
 895     virtual QCString trPostcondition()
 896     {
 897       return "Postcondition";
 898     }
 899     /*! Text for the \\invariant command */
 900     virtual QCString trInvariant()
 901     {
 902       return "Invariant";
 903     }
 904     /*! Text shown before a multi-line variable/enum initialization */
 905     virtual QCString trInitialValue()
 906     {
 907       return "Initializer:";
 908     }
 909     /*! Text used the source code in the file index */
 910     virtual QCString trCode()
 911     {
 912       return "zdrojový text";
 913     }
 914     virtual QCString trGraphicalHierarchy()
 915     {
 916       return "Grafické zobrazení hierarchie tříd";
 917     }
 918     virtual QCString trGotoGraphicalHierarchy()
 919     {
 920       return "Zobrazit grafickou podobu hierarchie tříd";
 921     }
 922     virtual QCString trGotoTextualHierarchy()
 923     {
 924       return "Zobrazit textovou podobu hierarchie tříd";
 925     }
 926     virtual QCString trPageIndex()
 927     {
 928       return "Rejstřík stránek";
 929     }
 930
 931 //////////////////////////////////////////////////////////////////////////
 932 // new since 1.1.0
 933 //////////////////////////////////////////////////////////////////////////
 934
 935     virtual QCString trNote()
 936     {
 937       return "Poznámka";
 938     }
 939     virtual QCString trPublicTypes()
 940     {
 941       return "Veřejné typy";
 942     }
 943     virtual QCString trPublicAttribs()
 944     {
 945       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 946       {
 947         return "Datové položky";
 948       }
 949       else
 950       {
 951         return "Veřejné atributy";
 952       }
 953     }
 954     virtual QCString trStaticPublicAttribs()
 955     {
 956       return "Statické veřejné atributy";
 957     }
 958     virtual QCString trProtectedTypes()
 959     {
 960       return "Chráněné typy";
 961     }
 962     virtual QCString trProtectedAttribs()
 963     {
 964       return "Chráněné atributy";
 965     }
 966     virtual QCString trStaticProtectedAttribs()
 967     {
 968       return "Statické chráněné atributy";
 969     }
 970     virtual QCString trPrivateTypes()
 971     {
 972       return "Privátní typy";
 973     }
 974     virtual QCString trPrivateAttribs()
 975     {
 976       return "Privátní atributy";
 977     }
 978     virtual QCString trStaticPrivateAttribs()
 979     {
 980       return "Statické privátní atributy";
 981     }
 982
 983 //////////////////////////////////////////////////////////////////////////
 984 // new since 1.1.3
 985 //////////////////////////////////////////////////////////////////////////
 986
 987     /*! Used as a marker that is put before a todo item */
 988     virtual QCString trTodo()
 989     {
 990       return "Plánované úpravy";
 991     }
 992     /*! Used as the header of the todo list */
 993     virtual QCString trTodoList()
 994     {
 995       return "Seznam plánovaných úprav";
 996     }
 997
 998 //////////////////////////////////////////////////////////////////////////
 999 // new since 1.1.4
1000 //////////////////////////////////////////////////////////////////////////
1001
1002     virtual QCString trReferencedBy()
1003     {
1004       return "Používá se v";
1005     }
1006     virtual QCString trRemarks()
1007     {
1008       return "Poznámky"; // ??? not checked in a context
1009     }
1010     virtual QCString trAttention()
1011     {
1012       return "Upozornění"; // ??? not checked in a context
1013     }
1014     virtual QCString trInclByDepGraph()
1015     {
1016       return "Následující graf ukazuje, které soubory přímo nebo "
1017              "nepřímo vkládají tento soubor:";
1018     }
1019     virtual QCString trSince()
1020     {
1021       return "Od"; // ??? not checked in a context
1022     }
1023
1024 ////////////////////////////////////////////////////////////////////////////
1025 // new since 1.1.5
1026 //////////////////////////////////////////////////////////////////////////
1027
1028     /*! title of the graph legend page */
1029     virtual QCString trLegendTitle()
1030     {
1031       return "Vysvětlivky ke grafu";
1032     }
1033     /*! page explaining how the dot graph's should be interpreted */
1034     virtual QCString trLegendDocs()
1035     {
1036       return
1037         "Zde naleznete vysvětlení, jak mají být interpretovány grafy, "
1038         "které byly generovány programem doxygen.<p>\n"
1039         "Uvažujte následující příklad:\n"
1040         "\\code\n"
1041         "/*! Neviditelná třída, která se v grafu nezobrazuje, protože "
1042         "došlo k ořezání grafu. */\n"
1043         "class Invisible { };\n\n"
1044         "/*! Třída, u které došlo k ořezání grafu. Vztah dědičnosti "
1045         "je skryt. */\n"
1046         "class Truncated : public Invisible { };\n\n"
1047         "/* Třída, která není dokumentována komentáři programu doxygen. */\n"
1048         "class Undocumented { };\n\n"
1049         "/*! Bázová třída děděná veřejně (public inheritance). */\n"
1050         "class PublicBase : public Truncated { };\n\n"
1051         "/*! Šablona třídy. */\n"
1052         "template<class T> class Templ { };\n\n"
1053         "/*! Bázová třída, použitá pro chráněné dědění "
1054         "(protected inheritance). */\n"
1055         "class ProtectedBase { };\n\n"
1056         "/*! Bázová třída, využitá pro privátní dědění "
1057         "(private inheritance). */\n"
1058         "class PrivateBase { };\n\n"
1059         "/*! Třída, která je využívána třídou Inherited. */\n"
1060         "class Used { };\n\n"
1061         "/*! Odvozená třída, která dědí z více tříd. */\n"
1062         "class Inherited : public PublicBase,\n"
1063         "                  protected ProtectedBase,\n"
1064         "                  private PrivateBase,\n"
1065         "                  public Undocumented,\n"
1066         "                  public Templ<int>\n"
1067         "{\n"
1068         "  private:\n"
1069         "    Used *m_usedClass;\n"
1070         "};\n"
1071         "\\endcode\n"
1072         "K výše uvedenému bude vygenerován následující graf:"
1073         "<p><center><img src=\"graph_legend."+getDotImageExtension()+"\"></center>\n"
1074         "<p>\n"
1075         "Bloky (tj. uzly) v uvedeném grafu mají následující význam:\n"
1076         "<ul>\n"
1077         "<li>Šedě vyplněný obdélník reprezentuje strukturu nebo třídu, "
1078             "pro kterou byl graf generován.\n"
1079         "<li>Obdélník s černým obrysem označuje dokumentovanou "
1080             "strukturu nebo třídu.\n"
1081         "<li>Obdélník s šedým obrysem označuje nedokumentovanou "
1082             "strukturu nebo třídu.\n"
1083         "<li>Obdélník s červeným obrysem označuje dokumentovanou "
1084             "strukturu nebo třídu, pro kterou\n"
1085             "nejsou zobrazeny všechny vztahy dědičnosti nebo obsažení. "
1086             "Graf je ořezán v případě, kdy jej\n"
1087             "není možné umístit do vymezeného prostoru.\n"
1088         "</ul>\n"
1089         "Šipky (tj. hrany grafu) mají následující význam:\n"
1090         "<ul>\n"
1091         "<li>Tmavě modrá šipka se používá pro označení vztahu veřejné "
1092             "dědičnosti (public) mezi dvěma třídami.\n"
1093         "<li>Tmavě zelená šipka označuje vztah chráněné dědičnosti "
1094             "(protected).\n"
1095         "<li>Tmavě červená šipka označuje vztah privátní dědičnosti "
1096             "(private).\n"
1097         "<li>Purpurová šipka kreslená čárkovaně se používá v případě, "
1098             "kdy je třída obsažena v jiné třídě,\n"
1099             "nebo kdy je používána jinou třídou. Je označena identifikátorem "
1100             "jedné nebo více proměných, přes které\n"
1101             "je třída nebo struktura zpřístupněna.\n"
1102         "<li>Žlutá šipka kreslená čárkovaně vyjadřuje vztah mezi instancí šablony "
1103             "a šablonou třídy, na základě které byla\n"
1104             "instance šablony vytvořena. V popisu šipky jsou uvedeny  příslušné"
1105             " parametry šablony.\n"
1106         "</ul>\n";
1107     }
1108     /*! text for the link to the legend page */
1109     virtual QCString trLegend()
1110     {
1111       return "vysvětlivky";
1112     }
1113
1114 //////////////////////////////////////////////////////////////////////////
1115 // new since 1.2.0
1116 //////////////////////////////////////////////////////////////////////////
1117
1118     /*! Used as a marker that is put before a test item */
1119     virtual QCString trTest()
1120     {
1121       return "Test";
1122     }
1123
1124     /*! Used as the header of the test list */
1125     virtual QCString trTestList()
1126     {
1127       return "Seznam testů";
1128     }
1129
1130 //////////////////////////////////////////////////////////////////////////
1131 // new since 1.2.2
1132 //////////////////////////////////////////////////////////////////////////
1133
1134     /*! Used as a section header for IDL properties */
1135     virtual QCString trProperties()
1136     {
1137       return "Vlastnosti";
1138     }
1139     /*! Used as a section header for IDL property documentation */
1140     virtual QCString trPropertyDocumentation()
1141     {
1142       return "Dokumentace k vlastnosti";
1143     }
1144 //////////////////////////////////////////////////////////////////////////
1145 // new since 1.2.4
1146 //////////////////////////////////////////////////////////////////////////
1147
1148     /*! Used for Java classes in the summary section of Java packages */
1149     virtual QCString trClasses()
1150     {
1151       return "Třídy";
1152     }
1153     /*! Used as the title of a Java package */
1154     virtual QCString trPackage(const char *name)
1155     {
1156       return QCString("Balík ") + name;
1157     }
1158     /*! Title of the package index page */
1159     virtual QCString trPackageList()
1160     {
1161       return "Seznam balíků";
1162     }
1163     /*! The description of the package index page */
1164     virtual QCString trPackageListDescription()
1165     {
1166       return "Zde naleznete seznam balíků se stručným popisem "
1167                     "(pokud byl uveden):";
1168     }
1169     /*! The link name in the Quick links header for each page */
1170     virtual QCString trPackages()
1171     {
1172       return "Balíky";
1173     }
1174     /*! Text shown before a multi-line define */
1175     virtual QCString trDefineValue()
1176     {
1177       return "Hodnota:";
1178     }
1179
1180 //////////////////////////////////////////////////////////////////////////
1181 // new since 1.2.5
1182 //////////////////////////////////////////////////////////////////////////
1183
1184     /*! Used as a marker that is put before a \\bug item */
1185     virtual QCString trBug()
1186     {
1187       return "Chyba";
1188     }
1189     /*! Used as the header of the bug list */
1190     virtual QCString trBugList()
1191     {
1192       return "Seznam chyb";
1193     }
1194
1195 //////////////////////////////////////////////////////////////////////////
1196 // new since 1.2.6-20010422
1197 //////////////////////////////////////////////////////////////////////////
1198
1199     /*! Used as ansicpg for RTF file */
1200     virtual QCString trRTFansicp()
1201     {
1202       return "1250";
1203     }
1204
1205     /*! Used as ansicpg for RTF fcharset */
1206     virtual QCString trRTFCharSet()
1207     {
1208       return "238";
1209     }
1210
1211     /*! Used as header RTF general index */
1212     virtual QCString trRTFGeneralIndex()
1213     {
1214       return "Rejstřík";
1215     }
1216
1217     /*! This is used for translation of the word that will possibly
1218      *  be followed by a single name or by a list of names
1219      *  of the category.
1220      */
1221     virtual QCString trClass(bool first_capital, bool singular)
1222     {
1223       QCString result((first_capital ? "Tříd" : "tříd"));
1224       result += singular ? "a" : "y";
1225       return result;
1226     }
1227
1228     /*! This is used for translation of the word that will possibly
1229      *  be followed by a single name or by a list of names
1230      *  of the category.
1231      */
1232     virtual QCString trFile(bool first_capital, bool singular)
1233     {
1234       QCString result((first_capital ? "Soubor" : "soubor"));
1235       if (!singular)  result+="y";
1236       return result;
1237     }
1238
1239     /*! This is used for translation of the word that will possibly
1240      *  be followed by a single name or by a list of names
1241      *  of the category.
1242      */
1243     virtual QCString trNamespace(bool first_capital, bool singular)
1244     {
1245       QCString result((first_capital ? "Prostor" : "prostor"));
1246       if (!singular)  result+="y";
1247       result+=" jmen";
1248       return result;
1249     }
1250
1251     /*! This is used for translation of the word that will possibly
1252      *  be followed by a single name or by a list of names
1253      *  of the category.
1254      */
1255     virtual QCString trGroup(bool first_capital, bool singular)
1256     {
1257       QCString result((first_capital ? "Skupin" : "skupin"));
1258       result += singular ? "a" : "y";
1259       return result;
1260     }
1261
1262     /*! This is used for translation of the word that will possibly
1263      *  be followed by a single name or by a list of names
1264      *  of the category.
1265      */
1266     virtual QCString trPage(bool first_capital, bool singular)
1267     {
1268       QCString result((first_capital ? "Stránk" : "stránk"));
1269       result += singular ? "a" : "y";
1270       return result;
1271     }
1272
1273     /*! This is used for translation of the word that will possibly
1274      *  be followed by a single name or by a list of names
1275      *  of the category.
1276      */
1277     virtual QCString trMember(bool first_capital, bool singular)
1278     {
1279       QCString result((first_capital ? "Člen" : "člen"));
1280       if (!singular)
1281           result += "y";
1282       return result;
1283     }
1284
1285     /*! ??? Jak to prelozit? Bylo by dobre, kdyby se ozval nekdo,
1286      * kdo to pouziva.
1287      */
1288     virtual QCString trGlobal(bool first_capital, bool singular)
1289     {
1290       QCString result((first_capital ? "Global" : "global"));
1291       if (!singular)  result+="s";
1292       return result;
1293     }
1294
1295 //////////////////////////////////////////////////////////////////////////
1296 // new since 1.2.7
1297 //////////////////////////////////////////////////////////////////////////
1298
1299     /*! This text is generated when the \\author command is used and
1300      *  for the author section in man pages. */
1301     virtual QCString trAuthor(bool first_capital, bool singular)
1302     {
1303       QCString result((first_capital ? "Auto" : "auto"));
1304       result += (singular) ? "r" : "ři";
1305       return result;
1306     }
1307
1308 //////////////////////////////////////////////////////////////////////////
1309 // new since 1.2.11
1310 //////////////////////////////////////////////////////////////////////////
1311
1312     /*! This text is put before the list of members referenced by a member
1313      */
1314     virtual QCString trReferences()
1315     {
1316       return "Odkazuje se na";
1317     }
1318
1319 //////////////////////////////////////////////////////////////////////////
1320 // new since 1.2.13
1321 //////////////////////////////////////////////////////////////////////////
1322
1323     /*! used in member documentation blocks to produce a list of
1324      *  members that are implemented by this one.
1325      */
1326     virtual QCString trImplementedFromList(int numEntries)
1327     {
1328       return "Implementuje "+trWriteList(numEntries)+".";
1329     }
1330
1331     /*! used in member documentation blocks to produce a list of
1332      *  all members that implement this member.
1333      */
1334     virtual QCString trImplementedInList(int numEntries)
1335     {
1336       return "Implementováno v "+trWriteList(numEntries)+".";
1337     }
1338
1339 //////////////////////////////////////////////////////////////////////////
1340 // new since 1.2.16
1341 //////////////////////////////////////////////////////////////////////////
1342
1343     /*! used in RTF documentation as a heading for the Table
1344      *  of Contents.
1345      */
1346     virtual QCString trRTFTableOfContents()
1347     {
1348       return "Obsah";
1349     }
1350
1351 //////////////////////////////////////////////////////////////////////////
1352 // new since 1.2.17
1353 //////////////////////////////////////////////////////////////////////////
1354
1355     /*! Used as the header of the list of item that have been
1356      *  flagged deprecated
1357      */
1358     virtual QCString trDeprecatedList()
1359     {
1360       return "Seznam zastaralých prvků";
1361     }
1362
1363 //////////////////////////////////////////////////////////////////////////
1364 // new since 1.2.18
1365 //////////////////////////////////////////////////////////////////////////
1366
1367     /*! Used as a header for declaration section of the events found in
1368      * a C# program
1369      */
1370     virtual QCString trEvents()
1371     {
1372       return "Události";
1373     }
1374     /*! Header used for the documentation section of a class' events. */
1375     virtual QCString trEventDocumentation()
1376     {
1377       return "Dokumentace událostí";
1378     }
1379
1380 //////////////////////////////////////////////////////////////////////////
1381 // new since 1.3
1382 //////////////////////////////////////////////////////////////////////////
1383
1384     /*! Used as a heading for a list of Java class types with package scope.
1385      */
1386     virtual QCString trPackageTypes()
1387     {
1388       return "Typy v balíku";
1389     }
1390     /*! Used as a heading for a list of Java class functions with package
1391      * scope.
1392      */
1393     virtual QCString trPackageMembers()
1394     {
1395       return "Funkce v balíku";
1396     }
1397     /*! Used as a heading for a list of static Java class functions with
1398      *  package scope.
1399      */
1400     virtual QCString trStaticPackageMembers()
1401     {
1402       return "Statické funkce v balíku";
1403     }
1404     /*! Used as a heading for a list of Java class variables with package
1405      * scope.
1406      */
1407     virtual QCString trPackageAttribs()
1408     {
1409       return "Atributy balíku";
1410     }
1411     /*! Used as a heading for a list of static Java class variables with
1412      * package scope.
1413      */
1414     virtual QCString trStaticPackageAttribs()
1415     {
1416       return "Statické atributy balíku";
1417     }
1418
1419 //////////////////////////////////////////////////////////////////////////
1420 // new since 1.3.1
1421 //////////////////////////////////////////////////////////////////////////
1422
1423     /*! Used in the quick index of a class/file/namespace member list page
1424      *  to link to the unfiltered list of all members.
1425      */
1426     virtual QCString trAll()
1427     {
1428       return "Vše";
1429     }
1430     /*! Put in front of the call graph for a function. */
1431     virtual QCString trCallGraph()
1432     {
1433       return "Tato funkce volá...";
1434     }
1435
1436 //////////////////////////////////////////////////////////////////////////
1437 // new since 1.3.3
1438 //////////////////////////////////////////////////////////////////////////
1439
1440     /*! This string is used as the title for the page listing the search
1441      *  results.
1442      */
1443     virtual QCString trSearchResultsTitle()
1444     {
1445       return "Výsledky vyhledávání";
1446     }
1447     /*! This string is put just before listing the search results. The
1448      *  text can be different depending on the number of documents found.
1449      *  Inside the text you can put the special marker $num to insert
1450      *  the number representing the actual number of search results.
1451      *  The @a numDocuments parameter can be either 0, 1 or 2, where the
1452      *  value 2 represents 2 or more matches. HTML markup is allowed inside
1453      *  the returned string.
1454      */
1455     virtual QCString trSearchResults(int numDocuments)
1456     {
1457       if (numDocuments==0)
1458       {
1459         return "Lituji. Vašemu dotazu neodpovídá žádný dokument.";
1460       }
1461       else if (numDocuments==1)
1462       {
1463         return "Nalezen jediný dokument, který vyhovuje vašemu dotazu.";
1464       }
1465       else
1466       {
1467         return "Nalezeno <b>$num</b> dokumentů, které vyhovují vašemu "
1468                       "dotazu. Nejlépe odpovídající dokumenty jsou zobrazeny "
1469                       "jako první.";
1470       }
1471     }
1472     /*! This string is put before the list of matched words, for each search
1473      *  result. What follows is the list of words that matched the query.
1474      */
1475     virtual QCString trSearchMatches()
1476     {
1477       return "Nalezená slova:";
1478     }
1479
1480 //////////////////////////////////////////////////////////////////////////
1481 // new since 1.3.8
1482 //////////////////////////////////////////////////////////////////////////
1483
1484     /*! This is used in HTML as the title of page with source code for file filename
1485      */
1486     virtual QCString trSourceFile(QCString& filename)
1487     {
1488       return QCString("Zdrojový soubor ") + filename;
1489     }
1490
1491
1492 //////////////////////////////////////////////////////////////////////////
1493 // new since 1.3.9
1494 //////////////////////////////////////////////////////////////////////////
1495
1496
1497     /*! This is used as the name of the chapter containing the directory
1498      *  hierarchy.
1499      */
1500     virtual QCString trDirIndex()
1501     { return "Hierarchie adresářů"; }
1502
1503     /*! This is used as the name of the chapter containing the documentation
1504      *  of the directories.
1505      */
1506     virtual QCString trDirDocumentation()
1507     { return "Dokumentace k adresářům"; }
1508
1509     /*! This is used as the title of the directory index and also in the
1510      *  Quick links of a HTML page, to link to the directory hierarchy.
1511      */
1512     virtual QCString trDirectories()
1513     { return "Adresáře"; }
1514
1515     /*! This returns a sentences that introduces the directory hierarchy.
1516      *  and the fact that it is sorted alphabetically per level
1517      */
1518     virtual QCString trDirDescription()
1519     {
1520         return "Následující hierarchie adresářů je zhruba, "
1521                       "ale ne úplně, řazena podle abecedy:";
1522     }
1523
1524     /*! This returns the title of a directory page. The name of the
1525      *  directory is passed via \a dirName.
1526      */
1527     virtual QCString trDirReference(const char *dirName)
1528     {
1529         QCString result = "Reference k adresáři ";
1530         result += dirName;
1531         return result;
1532     }
1533
1534     /*! This returns the word directory with or without starting capital
1535      *  (\a first_capital) and in sigular or plural form (\a singular).
1536      */
1537     virtual QCString trDir(bool first_capital, bool singular)
1538     {
1539         QCString result((first_capital ? "Adresář" : "adresář"));
1540         if ( ! singular)
1541             result += "e";
1542         return result;
1543     }
1544
1545 //////////////////////////////////////////////////////////////////////////
1546 // new since 1.4.1
1547 //////////////////////////////////////////////////////////////////////////
1548
1549     /*! This text is added to the documentation when the \\overload command
1550      *  is used for a overloaded function.
1551      */
1552     virtual QCString trOverloadText()
1553     {
1554        return "Jde o přetíženou (overloaded) metodu, "
1555               "která má usnadnit používání. Od výše uvedené metody se liší "
1556               "pouze jinak zadávanými argumenty.";
1557     }
1558
1559 //////////////////////////////////////////////////////////////////////////
1560 // new since 1.4.6
1561 //////////////////////////////////////////////////////////////////////////
1562
1563     virtual QCString trCallerGraph()
1564     {
1565       return "Tuto funkci volají...";
1566     }
1567
1568
1569     /*! This is used in the documentation of a file/namespace before the list
1570      *  of documentation blocks for enumeration values
1571      */
1572     virtual QCString trEnumerationValueDocumentation()
1573     {
1574       return "Dokumentace výčtových hodnot";
1575     }
1576
1577 //////////////////////////////////////////////////////////////////////////
1578 // new since 1.5.4 (mainly for Fortran)
1579 //////////////////////////////////////////////////////////////////////////
1580
1581     /*! header that is put before the list of member subprograms (Fortran). */
1582     virtual QCString trMemberFunctionDocumentationFortran()
1583     { return "Dokumentace členských funkcí/podprogramů"; }
1584
1585     /*! This is put above each page as a link to the list of annotated data types (Fortran). */
1586     virtual QCString trCompoundListFortran()
1587     { return "Seznam datových typů"; }
1588
1589     /*! This is put above each page as a link to all members of compounds (Fortran). */
1590     virtual QCString trCompoundMembersFortran()
1591     { return "Datová pole"; }
1592
1593     /*! This is an introduction to the annotated compound list (Fortran). */
1594     virtual QCString trCompoundListDescriptionFortran()
1595     { return "Datové typy se stručnými popisy:"; }
1596
1597     /*! This is an introduction to the page with all data types (Fortran). */
1598     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
1599     {
1600
1601       QCString result="Následuje seznam všech ";
1602       if (!extractAll)
1603       {
1604         result+="dokumentovaných ";
1605       }
1606       result+="složek datových typů";
1607       result+=" s odkazy na ";
1608       if (!extractAll)
1609       {
1610          result+="dokumentaci datové struktury pro každou složku:";
1611       }
1612       else
1613       {
1614           result+="příslušné datové typy:";
1615       }
1616       return result;
1617     }
1618
1619     /*! This is used in LaTeX as the title of the chapter with the
1620      * annotated compound index (Fortran).
1621      */
1622     virtual QCString trCompoundIndexFortran()
1623     { return "Rejstřík datových typů"; }
1624
1625     /*! This is used in LaTeX as the title of the chapter containing
1626      *  the documentation of all data types (Fortran).
1627      */
1628     virtual QCString trTypeDocumentation()
1629     { return "Dokumentace k datovým typům"; }
1630
1631     /*! This is used in the documentation of a file as a header before the
1632      *  list of (global) subprograms (Fortran).
1633      */
1634     virtual QCString trSubprograms()
1635     { return "Funkce/podprogramy"; }
1636
1637     /*! This is used in the documentation of a file/namespace before the list
1638      *  of documentation blocks for subprograms (Fortran)
1639      */
1640     virtual QCString trSubprogramDocumentation()
1641     { return "Dokumentace funkce/podprogramu"; }
1642
1643     /*! This is used in the documentation of a file/namespace/group before
1644      *  the list of links to documented compounds (Fortran)
1645      */
1646      virtual QCString trDataTypes()
1647     { return "Datové typy"; }
1648
1649     /*! used as the title of page containing all the index of all modules (Fortran). */
1650     virtual QCString trModulesList()
1651     { return "Seznam modulů"; }
1652
1653     /*! used as an introduction to the modules list (Fortran) */
1654     virtual QCString trModulesListDescription(bool extractAll)
1655     {
1656       QCString result="Následuje seznam všech ";
1657       if (!extractAll) result+="dokumentovaných ";
1658       result+="modulů se stručnými popisy:";
1659       return result;
1660     }
1661
1662     /*! used as the title of the HTML page of a module/type (Fortran) */
1663     virtual QCString trCompoundReferenceFortran(const char *clName,
1664                                     ClassDef::CompoundType compType,
1665                                     bool isTemplate)
1666     {
1667       QCString result("Dokumentace ");
1668       if (isTemplate) result += "šablony ";
1669       switch(compType)
1670       {
1671         case ClassDef::Class:      result += "třídy "; break;
1672         case ClassDef::Struct:     result += "typu "; break;
1673         case ClassDef::Union:      result += "unie "; break;
1674         case ClassDef::Interface:  result += "rozhraní "; break;
1675         case ClassDef::Protocol:   result += "protokolu "; break;
1676         case ClassDef::Category:   result += "kategorie "; break;
1677         case ClassDef::Exception:  result += "výjimky "; break;
1678         default: break;
1679       }
1680       result += clName;
1681       return result;
1682
1683     }
1684     /*! used as the title of the HTML page of a module (Fortran) */
1685     virtual QCString trModuleReference(const char *namespaceName)
1686     {
1687       QCString result="Dokumentace modulu ";
1688       result += namespaceName;
1689       return result;
1690     }
1691
1692     /*! This is put above each page as a link to all members of modules. (Fortran) */
1693     virtual QCString trModulesMembers()
1694     { return "Části modulu"; }
1695
1696     /*! This is an introduction to the page with all modules members (Fortran) */
1697     virtual QCString trModulesMemberDescription(bool extractAll)
1698     {
1699       QCString result="Následuje seznam všech ";
1700       if (!extractAll) result+="dokumentovaných ";
1701       result+="částí modulů s odkazy ";
1702       if (extractAll)
1703       {
1704         result+="na dokumentaci modulu pro danou část:";
1705       }
1706       else
1707       {
1708         result+="na moduly, ke kterým část patří:";
1709       }
1710       return result;
1711     }
1712
1713     /*! This is used in LaTeX as the title of the chapter with the
1714      *  index of all modules (Fortran).
1715      */
1716     virtual QCString trModulesIndex()
1717     { return "Rejstřík modulů"; }
1718
1719     /*! This is used for translation of the word that will possibly
1720      *  be followed by a single name or by a list of names
1721      *  of the category.
1722      */
1723     virtual QCString trModule(bool first_capital, bool singular)
1724     {
1725       QCString result((first_capital ? "Modul" : "modul"));
1726       if (!singular)  result+="y";
1727       return result;
1728     }
1729     /*! This is put at the bottom of a module documentation page and is
1730      *  followed by a list of files that were used to generate the page.
1731      */
1732     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
1733         bool single)
1734     { // here s is one of " Module", " Struct" or " Union"
1735       // single is true implies a single file
1736       QCString result=(QCString)"Dokumentace ";
1737       switch(compType)
1738       {
1739         case ClassDef::Class:      result+="k tomuto modulu"; break;
1740         case ClassDef::Struct:     result+="k tomuto typu"; break;
1741         case ClassDef::Union:      result+="k této unii"; break;
1742         case ClassDef::Interface:  result+="k tomuto rozhraní"; break;
1743         case ClassDef::Protocol:   result+="k tomuto protokolu"; break;
1744         case ClassDef::Category:   result+="k této kategorii"; break;
1745         case ClassDef::Exception:  result+="k této výjimce"; break;
1746         default: break;
1747       }
1748       result+=" byla vygenerována z ";
1749       if (single) result+="následujícího souboru:";
1750       else result+="následujících souborů:";
1751       return result;
1752     }
1753     /*! This is used for translation of the word that will possibly
1754      *  be followed by a single name or by a list of names
1755      *  of the category.
1756      */
1757     virtual QCString trType(bool first_capital, bool singular)
1758     {
1759       QCString result((first_capital ? "Typ" : "typ"));
1760       if (!singular)  result+="y";
1761       return result;
1762     }
1763     /*! This is used for translation of the word that will possibly
1764      *  be followed by a single name or by a list of names
1765      *  of the category.
1766      */
1767     virtual QCString trSubprogram(bool first_capital, bool singular)
1768     {
1769       QCString result((first_capital ? "Podprogram" : "podprogram"));
1770       if (!singular)  result+="y";
1771       return result;
1772     }
1773
1774     /*! C# Type Contraint list */
1775     virtual QCString trTypeConstraints()
1776     {
1777       return "Omezení typů (Type Constraints)";
1778     }
1779
1780 //////////////////////////////////////////////////////////////////////////
1781 // new since 1.6.0 (mainly for the new search engine)
1782 //////////////////////////////////////////////////////////////////////////
1783
1784     /*! directory relation for \a name */
1785     virtual QCString trDirRelation(const char *name)
1786     {
1787       return "Relace " + QCString(name);
1788     }
1789
1790     /*! Loading message shown when loading search results */
1791     virtual QCString trLoading()
1792     {
1793       return "Načítám...";
1794     }
1795
1796     /*! Label used for search results in the global namespace */
1797     virtual QCString trGlobalNamespace()
1798     {
1799       return "Globální prostor jmen";
1800     }
1801
1802     /*! Message shown while searching */
1803     virtual QCString trSearching()
1804     {
1805       return "Vyhledávám...";
1806     }
1807
1808     /*! Text shown when no search results are found */
1809     virtual QCString trNoMatches()
1810     {
1811       return "Nic se nenašlo";
1812     }
1813
1814 //////////////////////////////////////////////////////////////////////////
1815 // new since 1.6.3 (missing items for the directory pages)
1816 //////////////////////////////////////////////////////////////////////////
1817
1818     /*! when clicking a directory dependency label, a page with a
1819      *  table is shown. The heading for the first column mentions the
1820      *  source file that has a relation to another file.
1821      */
1822     virtual QCString trFileIn(const char *name)
1823     {
1824       return (QCString)"Soubor v "+name;
1825     }
1826
1827     /*! when clicking a directory dependency label, a page with a
1828      *  table is shown. The heading for the second column mentions the
1829      *  destination file that is included.
1830      */
1831     virtual QCString trIncludesFileIn(const char *name)
1832     {
1833       return (QCString)"Vkládá (include) soubor z "+name;
1834     }
1835
1836     /** Compiles a date string.
1837      *  @param year Year in 4 digits
1838      *  @param month Month of the year: 1=January
1839      *  @param day Day of the Month: 1..31
1840      *  @param dayOfWeek Day of the week: 1=Monday..7=Sunday
1841      *  @param hour Hour of the day: 0..23
1842      *  @param minutes Minutes in the hour: 0..59
1843      *  @param seconds Seconds within the minute: 0..59
1844      *  @param includeTime Include time in the result string?
1845      */
1846     virtual QCString trDateTime(int year,int month,int day,int dayOfWeek,
1847                                 int hour,int minutes,int seconds,
1848                                 bool includeTime)
1849     {
1850       static const char *days[]   = { "po","út","st","čt","pá","so","ne" };
1851       static const char *months[] = { "led","úno","bře","dub","kvě","čer","čec","srp","zář","říj","lis","pro" };
1852       QCString sdate;
1853       sdate.sprintf("%s %d. %s %d",days[dayOfWeek-1],day,months[month-1],year);
1854       if (includeTime)
1855       {
1856         QCString stime;
1857         stime.sprintf(" %.2d.%.2d:%.2d",hour,minutes,seconds);
1858         sdate+=stime;
1859       }
1860       return sdate;
1861     }
1862
1863 //////////////////////////////////////////////////////////////////////////
1864 // new since 1.7.5
1865 //////////////////////////////////////////////////////////////////////////
1866
1867     /*! Header for the page with bibliographic citations */
1868     virtual QCString trCiteReferences()
1869     { return "Odkazy na literaturu"; }
1870
1871     /*! Text for copyright paragraph */
1872     virtual QCString trCopyright()
1873     { return "Copyright"; }
1874
1875     /*! Header for the graph showing the directory dependencies */
1876     virtual QCString trDirDepGraph(const char *name)
1877     { return QCString("Graf závislosti na adresářích pro  ")+name+":"; }
1878
1879 //////////////////////////////////////////////////////////////////////////
1880 // new since 1.8.0
1881 //////////////////////////////////////////////////////////////////////////
1882
1883     /*! Detail level selector shown for hierarchical indices */
1884     virtual QCString trDetailLevel()
1885     { return "úroveň detailů"; }
1886
1887     /*! Section header for list of template parameters */
1888     virtual QCString trTemplateParameters()
1889     { return "Parametry šablon"; }
1890
1891     /*! Used in dot graph when UML_LOOK is enabled and there are many fields */
1892     virtual QCString trAndMore(const QCString &number)
1893     { return "a "+number+" další(ch)..."; }
1894
1895     /*! Used file list for a Java enum */
1896     virtual QCString trEnumGeneratedFromFiles(bool single)
1897     { QCString result = "Dokumentace pro tento výčet byla generována z ";
1898       if (single)
1899           result += "následujícího souboru:";
1900       else
1901           result += "následujících souborů:";
1902       return result;
1903     }
1904
1905     /*! Header of a Java enum page (Java enums are represented as classes). */
1906     virtual QCString trEnumReference(const char *name)
1907     { return "Reference k výčtu "+QCString(name); }
1908
1909     /*! Used for a section containing inherited members */
1910     virtual QCString trInheritedFrom(const char *members,const char *what)
1911     { return QCString(members)+" dědí se z "+what; }
1912
1913     /*! Header of the sections with inherited members specific for the
1914      *  base class(es)
1915      */
1916     virtual QCString trAdditionalInheritedMembers()
1917     { return "Další zděděné členy"; }
1918
1919 //////////////////////////////////////////////////////////////////////////
1920 // new since 1.8.2
1921 //////////////////////////////////////////////////////////////////////////
1922
1923     /*! Used as a tooltip for the toggle button that appears in the
1924      *  navigation tree in the HTML output when GENERATE_TREEVIEW is
1925      *  enabled. This tooltip explains the meaning of the button.
1926      */
1927     virtual QCString trPanelSynchronisationTooltip(bool enable)
1928     {
1929       QCString opt = enable ? "povolit" : "zakázat";
1930       return opt + " synchronizaci panelů";
1931     }
1932
1933     /*! Used in a method of an Objective-C class that is declared in a
1934      *  a category. Note that the @1 marker is required and is replaced
1935      *  by a link.
1936      */
1937     virtual QCString trProvidedByCategory()
1938     {
1939       return "Deklarováno v kategorii @0.";
1940     }
1941
1942     /*! Used in a method of an Objective-C category that extends a class.
1943      *  Note that the @1 marker is required and is replaced by a link to
1944      *  the class method.
1945      */
1946     virtual QCString trExtendsClass()
1947     {
1948       return "Rozšiřuje třídu @0.";
1949     }
1950
1951     /*! Used as the header of a list of class methods in Objective-C.
1952      *  These are similar to static public member functions in C++.
1953      */
1954     virtual QCString trClassMethods()
1955     {
1956       return "Metody třídy";
1957     }
1958
1959     /*! Used as the header of a list of instance methods in Objective-C.
1960      *  These are similar to public member functions in C++.
1961      */
1962     virtual QCString trInstanceMethods()
1963     {
1964       return "Metody instance";
1965     }
1966
1967     /*! Used as the header of the member functions of an Objective-C class.
1968      */
1969     virtual QCString trMethodDocumentation()
1970     {
1971       return "Dokumentace metody";
1972     }
1973
1974     /*! Used as the title of the design overview picture created for the
1975      *  VHDL output.
1976      */
1977     virtual QCString trDesignOverview()
1978     {
1979       return "Návrhové schéma";
1980     }
1981
1982 //////////////////////////////////////////////////////////////////////////
1983 // new since 1.8.4
1984 //////////////////////////////////////////////////////////////////////////
1985
1986     /** old style UNO IDL services: implemented interfaces */
1987     virtual QCString trInterfaces()
1988     { return "Exportovaná rozhraní"; }
1989
1990     /** old style UNO IDL services: inherited services */
1991     virtual QCString trServices()
1992     { return "Začleněné služby"; }
1993
1994     /** UNO IDL constant groups */
1995     virtual QCString trConstantGroups()
1996     { return "Konstantní skupiny"; }
1997
1998     /** UNO IDL constant groups */
1999     virtual QCString trConstantGroupReference(const char *namespaceName)
2000     {
2001       QCString result="Konstantní skupiny z ";
2002       result += namespaceName;
2003       return result;
2004     }
2005     /** UNO IDL service page title */
2006     virtual QCString trServiceReference(const char *sName)
2007     {
2008       QCString result="Popis služby ";
2009       result += sName;
2010       return result;
2011     }
2012     /** UNO IDL singleton page title */
2013     virtual QCString trSingletonReference(const char *sName)
2014     {
2015       QCString result="Popis singletonu ";
2016       result += sName;
2017       return result;
2018     }
2019     /** UNO IDL service page */
2020     virtual QCString trServiceGeneratedFromFiles(bool single)
2021     {
2022       // single is true implies a single file
2023       QCString result="Dokumentace k této službě byla generována ";
2024       if (single) result+="z následujícího souboru:";
2025       else        result+="z následujících souborů:";
2026       return result;
2027     }
2028     /** UNO IDL singleton page */
2029     virtual QCString trSingletonGeneratedFromFiles(bool single)
2030     {
2031       // single is true implies a single file
2032       QCString result="Dokumentace k tomuto singletonu byla generována ";
2033       if (single) result+="z následujícího souboru:";
2034       else        result+="z následujících souborů:";
2035       return result;
2036     }
2037
2038 //////////////////////////////////////////////////////////////////////////
2039
2040 };
2041
2042 #endif // TRANSLATOR_CZ_H