Release-1.1.5

1 files changed, 655 insertions, 285 deletions

diff --git a/src/translator_cz.h b/src/translator_cz.h
index ffbcdc3..63edec7 100644
--- a/src/translator_cz.h
+++ b/src/translator_cz.h
@@ -27,249 +27,478 @@
 //
 // havran@fel.cvut.cz, 1999/04/11
 
+
+// Notice that the following texts were written in Czech using
+// MS-Windows code page 1250. If you want to use it in Unix, 
+// convert the file to the ISO Latin-2 
+// This is a prototype created by Petr Prikryl (prikrylp@skil.cz), 2000/06/20.
+//
 class TranslatorCzech : public Translator
 {
   public:
-    QCString latexBabelPackage()
+    virtual QCString idLanguage()
     { return "czech"; }
-    QCString trInherits()
-    { return "Dedi"; }
-    QCString trAnd()
-    { return "a"; }
-    QCString trInheritedBy()
-    { return "Je potomkem"; }
-    QCString trRelatedFunctions()
-    { return "Pribuzne metody"; }
-    QCString trRelatedSubscript()
-    { return "(Tyto funkce nejsou metody.)"; }
-    QCString trDetailedDescription()
-    { return "Podrobna dokumentace"; }
-    QCString trMemberTypedefDocumentation()
-    { return "Dokumentace pro deklaraci typu (typedef) ve tride";}
-    QCString trMemberEnumerationDocumentation()
-    { return "Dokumentace vyctovych typu"; }
-    QCString trEnumerationValueDocumentation()
-    { return "Dokumentace hodnot vyctovych typu"; }
-    QCString trMemberFunctionDocumentation()
-    { return "Dokumentace metod"; }
-    QCString trMemberDataDocumentation()
-    { return "Dokumentace datovych slozek tridy"; }
-    QCString trGeneratedFrom(const char *s,bool single)
-    { 
-      QCString result=(QCString)"Dokumentace pro tento"+s+
-                     " byla generovana z nasledujiciho souboru";
-      if (single) result+=":";   else result+="s:";
-      return result;
-    }
-    QCString trMore()
-    { return "Detaily"; }
-    QCString trReference()
-    { return "Reference"; }
-    QCString trListOfAllMembers()
-    { return "Seznam vsech datovych polozek a metod tridy."; }
-    QCString trMemberList()
-    { return "Seznam datovych polozek a metod tridy"; }
-    QCString trThisIsTheListOfAllMembers()
-    { return "Toto je uplny seznam datovych polozek a metod tridy pro"; }
-    QCString trIncludingInheritedMembers()
-    { return "zahrnuje vsechny nasledujici zdedene datove polozky a metody."; }
-    QCString trGeneratedAutomatically(const char *s)
-    { QCString result="Automaticky vygenerovany pomoci programu doxygen"; 
-      if (s) result+=(QCString)" pro "+s;
-      result+=" ze zdrojoveho souboru."; 
+
+    virtual QCString latexLanguageSupportCommand()
+    { return "\\usepackage{czech}\n"; }
+    
+    /*! returns the name of the package that is included by LaTeX */
+    virtual QCString latexBabelPackage() 
+    { return ""; }
+
+    /*! used in the compound documentation before a list of related functions. */
+    virtual QCString trRelatedFunctions()
+    { return "Související funkce"; }
+
+    /*! subscript for the related functions. */
+    virtual QCString trRelatedSubscript()
+    { return "(Výše uvedené funkce nejsou členskými funkcemi.)"; }
+
+    /*! header that is put before the detailed description of files, classes and namespaces. */
+    virtual QCString trDetailedDescription()
+    { return "Detailní popis"; }
+
+    /*! header that is put before the list of typedefs. */
+    virtual QCString trMemberTypedefDocumentation()
+    { return "Dokumentace k členských typům"; }
+    
+    /*! header that is put before the list of enumerations. */
+    virtual QCString trMemberEnumerationDocumentation()
+    { return "Dokumentace k členským výčtům"; }
+    
+    /*! header that is put before the list of member functions. */
+    virtual QCString trMemberFunctionDocumentation()
+    { return "Dokumentace k metodám"; }
+    
+    /*! header that is put before the list of member attributes. */
+    virtual QCString trMemberDataDocumentation()
+    { return "Dokumentace k datovým členům"; }
+
+    /*! this is the text of a link put after brief descriptions. */
+    virtual QCString trMore() 
+    { return "Podrobnosti..."; }
+
+    /*! put in the class documentation */
+    virtual QCString trListOfAllMembers()
+    { return "Seznam všech členů."; }
+
+    /*! used as the title of the "list of all members" page of a class */
+    virtual QCString trMemberList()
+    { return "Seznam členů třídy"; }
+
+    /*! this is the first part of a sentence that is followed by a class name */
+    virtual QCString trThisIsTheListOfAllMembers()
+    { return "Úplný seznam členů třídy "; }
+
+    /*! this is the remainder of the sentence after the class name */
+    virtual QCString trIncludingInheritedMembers()
+    { return ", včetně všech zděděných členů."; }
+    
+    /*! this is put at the author sections at the bottom of man pages.
+     *  parameter s is name of the project name.
+     */
+    virtual QCString trGeneratedAutomatically(const char *s)
+    { QCString result="Generováno automaticky programem Doxygen "
+                      "ze zdrojových textů";
+      if (s) result+=(QCString)" projektu "+s;
+      result+="."; 
       return result;
     }
-    QCString trEnumName()
-    { return "pojmenovani vyctoveho typu"; }
-    QCString trEnumValue()
-    { return "hodnota vyctoveho typu"; }
-    QCString trDefinedIn()
-    { return "definovany v"; }
-    QCString trIncludeFile()
-    { return "Vklada soubor"; }
-    QCString trVerbatimText(const char *f)
-    { return (QCString)"Toto je presny text z vlozeneho souboru "+f+""; }
-    QCString trModules()
+
+    /*! put after an enum name in the list of all members */
+    virtual QCString trEnumName()
+    { return "jméno výčtu"; }
+    
+    /*! put after an enum value in the list of all members */
+    virtual QCString trEnumValue()
+    { return "hodnota výčtu"; }
+    
+    /*! put after an undocumented member in the list of all members */
+    virtual QCString trDefinedIn()
+    { return "definován v"; }
+
+    /*! put as in introduction in the verbatim header file of a class.
+     *  parameter f is the name of the include file.
+     */
+    virtual QCString trVerbatimText(const char *f)
+    { return (QCString)"Úplný text vkládaného souboru "+f+"."; }
+    
+    // quick reference sections
+
+    /*! This is put above each page as a link to the list of all groups of 
+     *  compounds or files (see the \group command).
+     */
+    virtual QCString trModules()
     { return "Moduly"; }
-    QCString trClassHierarchy()
-    { return "Hierarchie trid"; }
-    QCString trCompoundList()
-    { return "Seznam objektovych typu"; }
-    QCString trFileList()
-    { return "Seznam souboru"; }
-    QCString trHeaderFiles()
-    { return "Hlavickove soubory"; }
-    QCString trCompoundMembers()
-    { return "Datove slozky a metody objektovych typu"; }
-    QCString trFileMembers()
-    { return "Globalni deklarace"; }
-    QCString trRelatedPages()
-    { return "Souvisejici stranky"; }
-    QCString trExamples()
-    { return "Priklady:"; }
-    QCString trSearch()
-    { return "Hledej"; }
-    QCString trClassHierarchyDescription()
-    { return "Tento seznam dedicnych zavislosti je temer setriden"
-	     " podle abecedy:";
-    }
-    QCString trFileListDescription(bool extractAll)
-    {
-      QCString result="A toto je seznam vsech ";
-      if (!extractAll) result+="zdokumentovanych ";
-      result+="souboru s kratkymi popisy:";
+    
+    /*! This is put above each page as a link to the class hierarchy */
+    virtual QCString trClassHierarchy()
+    { return "Hierarchie tříd"; }
+    
+    /*! This is put above each page as a link to the list of annotated classes */
+    virtual QCString trCompoundList()
+    { return "Seznam složenin"; }
+    
+    /*! This is put above each page as a link to the list of documented files */
+    virtual QCString trFileList()
+    { return "Seznam souborů"; }
+
+    /*! This is put above each page as a link to the list of all verbatim headers */
+    virtual QCString trHeaderFiles()
+    { return "Seznam hlavičkových souborů"; }
+
+    /*! This is put above each page as a link to all members of compounds. */
+    virtual QCString trCompoundMembers()
+    { return "Součásti složenin"; }
+
+    /*! This is put above each page as a link to all members of files. */
+    virtual QCString trFileMembers()
+    { return "Seznam globálních symbolů"; }
+
+    /*! This is put above each page as a link to all related pages. */
+    virtual QCString trRelatedPages()
+    { return "Související stránky"; }
+
+    /*! This is put above each page as a link to all examples. */
+    virtual QCString trExamples()
+    { return "Příklady"; }
+
+    /*! This is put above each page as a link to the search engine. */
+    virtual QCString trSearch()
+    { return "Hledat"; }
+
+    /*! This is an introduction to the class hierarchy. */
+    virtual QCString trClassHierarchyDescription()
+    { return "Zde naleznete seznam, vyjadřující vztah dědičnosti tříd. "
+             "Je seřazen přibližně (ale ne úplně) podle abecedy:";
+    }
+
+    /*! This is an introduction to the list with all files. */
+    virtual QCString trFileListDescription(bool extractAll)
+    {
+      QCString result="Zde naleznete seznam všech ";
+      if (!extractAll) result+="dokumentovaných ";
+      result+="souborů se stručnými popisy:";
       return result;
     }
-    QCString trCompoundListDescription()
-    { return "Zde jsou tridy, struktury a "
-             "unie s kratkymi popisy:";
+
+    /*! This is an introduction to the annotated compound list. */
+    virtual QCString trCompoundListDescription()
+    { return "Složeninami (compound) se rozumí netriviální prvky, které "
+             "zahrnují třídy, struktury (struct), unie (union) "
+             "a rozhraní (interface). V seznamu jsou uvedeny jejich stručné "
+             "popisy:"; 
     }
-    QCString trCompoundMembersDescription(bool extractAll)
+
+    /*! This is an introduction to the page with all class members. */
+    virtual QCString trCompoundMembersDescription(bool extractAll)
     {
-      QCString result="Zde je seznam vsech ";
-      if (!extractAll) result+="zdokumentovanych ";
-      result+="clenu tridy (metod a datovych slozek) s odkazy na ";
-      if (extractAll) result+="dokumentaci tridy pro kazdo polozku:";
-      else result+="tridy, kam patri:";
+      QCString result="Zde naleznete seznam všech ";
+      if (!extractAll) result+="dokumentovaných ";
+      result+="členů tříd s odkazy na ";
+      if (extractAll) 
+        result+="dokumentaci tříd, ke kterým příslušejí:";
+      else 
+        result+="třídy, ke kterým příslušejí:";
       return result;
     }
-    QCString trFileMembersDescription(bool extractAll)
+
+    /*! This is an introduction to the page with all file members. */
+    virtual QCString trFileMembersDescription(bool extractAll)
     {
-      QCString result="Zde je seznam vsech ";
-      if (!extractAll) result+="zdokumentovanych ";
-      result+="globalnich deklaraci s odkazy ";
-      if (extractAll) result+="na dokumentaci k souboru pro kazdou deklaraci:";
-      else result+="na soubory, kde jsou umisteny:";
+      QCString result="Zde naleznete seznam všech ";
+      if (!extractAll) result+="dokumentovaných ";
+      result+="globálních symbolů, které jsou definovány v souborech projektu. "
+              "Pro každý symbol je uveden odkaz na ";
+      if (extractAll) 
+        result+="dokumentaci příslušného souboru";
+      else 
+        result+="soubor, ve kterém je symbol definován";
+      result+=". Symbol může označovat makro, typ, instanci třídy, "
+              "proměnnou, konstantu, funkci, výčet, hodnotu výčtu a podobně:";  
+        
       return result;
     }
-    QCString trHeaderFilesDescription()
-    {return "Zde jsou hlavickove soubory ktere tvori programove"
-            " rozhrani aplikace(API):";
-    }
-    QCString trExamplesDescription()
-    { return "Zde je seznam vsech prikladu:"; }
-    QCString trRelatedPagesDescription()
-    { return "Zde je seznam vsech souvisejicich stranek dokumentace:"; }
-    QCString trModulesDescription()
-    { return "Zde je seznam vsech modulu:"; }
-    QCString trNoDescriptionAvailable()
-    { return "Zadny popis neni k dispozici."; }
 
-    QCString trDocumentation()
+    /*! This is an introduction to the page with the list of all header files. */
+    virtual QCString trHeaderFilesDescription()
+    { return "Zde naleznete hlavičkové soubory, které tvoří "
+             "aplikační programátorské rozhraní (API):"; }
+
+    /*! This is an introduction to the page with the list of all examples */
+    virtual QCString trExamplesDescription()
+    { return "Zde naleznete seznam všech příkladů:"; }
+
+    /*! This is an introduction to the page with the list of related pages */
+    virtual QCString trRelatedPagesDescription()
+    { return "Zde naleznete seznam všech souvisejících stránek dokumentace:"; }
+
+    /*! This is an introduction to the page with the list of class/file groups */
+    virtual QCString trModulesDescription()
+    { return "Zde naleznete seznam všech modulů:"; }
+
+    /*! This sentences is used in the annotated class/file lists if no brief
+     * description is given. 
+     */
+    virtual QCString trNoDescriptionAvailable()
+    { return "Popis není k dispozici"; }
+    
+    // index titles (the project name is prepended for these) 
+
+
+    /*! This is used in HTML as the title of index.html. */
+    virtual QCString trDocumentation()
     { return "Dokumentace"; }
-    QCString trModuleIndex()
-    { return "Index modulu"; }
-    QCString trHierarchicalIndex()
-    { return "Index hierarchie"; }
-    QCString trCompoundIndex()
-    { return "Index objektovych typu"; }
-    QCString trFileIndex() 
-    { return "Index souboru"; }
-    QCString trModuleDocumentation()
-    { return "Dokumentace modulu"; }
-    QCString trClassDocumentation()
-    { return "Dokumentace tridy"; }
-    QCString trFileDocumentation()
-    { return "Dokumentace souboru"; }
-    QCString trExampleDocumentation()
-    { return "Dokumentace prikladu"; }
-    QCString trPageDocumentation()
-    { return "Dokumentace stranek"; }
-    QCString trReferenceManual()
-    { return "Referencni manual"; }
-
-    QCString trDefines()
-    { return "Definice"; }
-    QCString trFuncProtos()
-    { return "Prototypy funkci"; }
-    QCString trTypedefs()
-    { return "Deklarace datovych typu(typedefs)"; }
-    QCString trEnumerations()
-    { return "Vyctove typy (enumerations)"; }
-    QCString trFunctions()
+
+    /*! This is used in LaTeX as the title of the chapter with the 
+     * index of all groups.
+     */
+    virtual QCString trModuleIndex()
+    { return "Rejstřík modulů"; }
+
+    /*! This is used in LaTeX as the title of the chapter with the 
+     * class hierarchy.
+     */
+    virtual QCString trHierarchicalIndex()
+    { return "Rejstřík hierarchie tříd"; }
+
+    /*! This is used in LaTeX as the title of the chapter with the 
+     * annotated compound index.
+     */
+    virtual QCString trCompoundIndex()
+    { return "Rejstřík složenin"; }
+
+    /*! This is used in LaTeX as the title of the chapter with the
+     * list of all files.
+     */
+    virtual QCString trFileIndex() 
+    { return "Rejstřík souborů"; }
+
+    /*! This is used in LaTeX as the title of the chapter containing
+     *  the documentation of all groups.
+     */
+    virtual QCString trModuleDocumentation()
+    { return "Dokumentace modulů"; }
+
+    /*! This is used in LaTeX as the title of the chapter containing
+     *  the documentation of all classes, structs and unions.
+     */
+    virtual QCString trClassDocumentation()
+    { return "Dokumentace tříd"; }
+
+    /*! This is used in LaTeX as the title of the chapter containing
+     *  the documentation of all files.
+     */
+    virtual QCString trFileDocumentation()
+    { return "Dokumentace souborů"; }
+
+    /*! This is used in LaTeX as the title of the chapter containing
+     *  the documentation of all examples.
+     */
+    virtual QCString trExampleDocumentation()
+    { return "Dokumentace příkladů"; }
+
+    /*! This is used in LaTeX as the title of the chapter containing
+     *  the documentation of all related pages.
+     */
+    virtual QCString trPageDocumentation()
+    { return "Dokumentace souvisejících stránek"; }
+
+    /*! This is used in LaTeX as the title of the document */
+    virtual QCString trReferenceManual()
+    { return "Referenční příručka"; }
+    
+    /*! This is used in the documentation of a file as a header before the 
+     *  list of defines
+     */
+    virtual QCString trDefines()
+    { return "Definice maker"; }
+
+    /*! This is used in the documentation of a file as a header before the 
+     *  list of function prototypes
+     */
+    virtual QCString trFuncProtos()
+    { return "Prototypy"; }
+
+    /*! This is used in the documentation of a file as a header before the 
+     *  list of typedefs
+     */
+    virtual QCString trTypedefs()
+    { return "Definice typů"; }
+
+    /*! This is used in the documentation of a file as a header before the 
+     *  list of enumerations
+     */
+    virtual QCString trEnumerations()
+    { return "Výčty"; }
+
+    /*! This is used in the documentation of a file as a header before the 
+     *  list of (global) functions
+     */
+    virtual QCString trFunctions()
     { return "Funkce"; }
-    QCString trVariables()
-    { return "Promenne"; }
-    QCString trEnumerationValues()
-    { return "Hodnoty vyctovych typu"; }
-    QCString trReimplementedFrom()
-    { return "Je znovu implementovan podle"; }
-    QCString trReimplementedIn()
-    { return "Je znovu implementovan v"; }
-    QCString trAuthor()
+
+    /*! This is used in the documentation of a file as a header before the 
+     *  list of (global) variables
+     */
+    virtual QCString trVariables()
+    { return "Proměnné"; }
+
+    /*! This is used in the documentation of a file as a header before the 
+     *  list of (global) variables
+     */
+    virtual QCString trEnumerationValues()
+    { return "Hodnoty výčtů"; }
+    
+    /*! This is used in man pages as the author section. */
+    virtual QCString trAuthor()
     { return "Autor"; }
-    QCString trDefineDocumentation()
-    { return "Dokumentace definic pomoci maker"; }
-    QCString trFunctionPrototypeDocumentation()
-    { return "Dokumentace prototypu funkci"; }
-    QCString trTypedefDocumentation()
-    { return "Dokumentace deklaraci datovych typu(typedefs)"; }
-    QCString trEnumerationTypeDocumentation()
-    { return "Dokumentace vyctovych typu"; }
-    QCString trFunctionDocumentation()
-    { return "Dokumentace funkci"; }
-    QCString trVariableDocumentation()
-    { return "Dokumentace promennych"; }
-    QCString trCompounds()
-    { return "Polozky objektovych typu"; }
-    QCString trFiles()
-    { return "Soubory:"; }
-    QCString trGeneratedAt(const char *date,const char *projName)
+
+    /*! This is used in the documentation of a file before the list of
+     *  documentation blocks for defines
+     */
+    virtual QCString trDefineDocumentation()
+    { return "Dokumentace k definicím maker"; }
+
+    /*! This is used in the documentation of a file/namespace before the list 
+     *  of documentation blocks for function prototypes
+     */
+    virtual QCString trFunctionPrototypeDocumentation()
+    { return "Dokumentace prototypů"; }
+
+    /*! This is used in the documentation of a file/namespace before the list 
+     *  of documentation blocks for typedefs
+     */
+    virtual QCString trTypedefDocumentation()
+    { return "Dokumentace definic typů"; }
+
+    /*! This is used in the documentation of a file/namespace before the list 
+     *  of documentation blocks for enumeration types
+     */
+    virtual QCString trEnumerationTypeDocumentation()
+    { return "Dokumentace výčtových typů"; }
+
+    /*! This is used in the documentation of a file/namespace before the list 
+     *  of documentation blocks for enumeration values
+     */
+    virtual QCString trEnumerationValueDocumentation()
+    { return "Dokumentace výčtových hodnot"; }
+
+    /*! This is used in the documentation of a file/namespace before the list 
+     *  of documentation blocks for functions
+     */
+    virtual QCString trFunctionDocumentation()
+    { return "Dokumentace funkcí"; }
+
+    /*! This is used in the documentation of a file/namespace before the list 
+     *  of documentation blocks for variables
+     */
+    virtual QCString trVariableDocumentation()
+    { return "Dokumentace proměnných"; }
+
+    /*! This is used in the documentation of a file/namespace/group before 
+     *  the list of links to documented compounds
+     */
+    virtual QCString trCompounds()
+    { return "Složeniny"; }
+
+    /*! This is used in the documentation of a group before the list of 
+     *  links to documented files
+     */
+    virtual QCString trFiles()
+    { return "Soubory"; }
+
+    /*! This is used in the standard footer of each page and indicates when 
+     *  the page was generated 
+     */
+    virtual QCString trGeneratedAt(const char *date,const char *projName)
     { 
-      QCString result=(QCString)"Generovany dne "+date;
-      if (projName) result+=(QCString)" pro "+projName;
-      result+=(QCString)" ";
+      QCString result=(QCString)"Generováno "+date;
+      if (projName) result+=(QCString)" pro projekt "+projName;
+      result+=(QCString)" programem";
       return result;
     }
-    QCString trWrittenBy()
-    {
-      return "napsany podle";
-    }
-    QCString trClassDiagram(const char *clName)
+    /*! This is part of the sentence used in the standard footer of each page.
+     */
+    virtual QCString trWrittenBy()
     {
-      return (QCString)"Diagram trid pro "+clName;
+      return " -- autor ";
     }
-    QCString trForInternalUseOnly()
-    { return "Jen pro interni pouziti."; }
-    QCString trReimplementedForInternalReasons()
+
+    /*! this text is put before a class diagram */
+    virtual QCString trClassDiagram(const char *clName)
     {
-      return "Znovu implementovany z internich duvodu; programove rozhrani"
-             " aplikace(API) neni zmeneno.";
+      return (QCString)"Diagram dědičnosti pro třídu "+clName;
     }
-    QCString trWarning()
-    { return "Upozorneni"; }
-    QCString trBugsAndLimitations()
-    { return "Chyby a omezeni"; }
-    QCString trVersion()
+    
+    /*! this text is generated when the \internal command is used. */
+    virtual QCString trForInternalUseOnly()
+    { return "Pouze pro vnitřní použití."; }
+
+    /*! this text is generated when the \reimp command is used. */
+    virtual QCString trReimplementedForInternalReasons()
+    { return "Reimplementováno z interních důvodů; aplikační rozhraní zachováno."; }
+
+    /*! this text is generated when the \warning command is used. */
+    virtual QCString trWarning()
+    { return "Pozor"; }
+
+    /*! this text is generated when the \bug command is used. */
+    virtual QCString trBugsAndLimitations()
+    { return "Chyby a omezení"; }
+
+    /*! this text is generated when the \version command is used. */
+    virtual QCString trVersion()
     { return "Verze"; }
-    QCString trDate()
+
+    /*! this text is generated when the \date command is used. */
+    virtual QCString trDate()
     { return "Datum"; }
-    QCString trAuthors()
-    { return "Autor(i)"; }
-    QCString trReturns()
-    { return "ma navratovou hodnotu"; }
-    QCString trSeeAlso()
-    { return "Podrobnosti take tady"; }
-    QCString trParameters()
+
+    /*! this text is generated when the \author command is used. */
+    virtual QCString trAuthors()
+    { return "Autor/autoři"; }
+
+    /*! this text is generated when the \return command is used. */
+    virtual QCString trReturns()
+    { return "Vrací"; }
+
+    /*! this text is generated when the \sa command is used. */
+    virtual QCString trSeeAlso()
+    { return "Viz také"; }
+
+    /*! this text is generated when the \param command is used. */
+    virtual QCString trParameters()
     { return "Parametry"; }
-    QCString trExceptions()
-    { return "Vyjimky"; }
-    QCString trGeneratedBy()
-    { return "Generovan podle"; }
+
+    /*! this text is generated when the \exception command is used. */
+    virtual QCString trExceptions()
+    { return "Výjimky"; }
     
-    // new since 0.49-990307 
+    /*! this text is used in the title page of a LaTeX document. */
+    virtual QCString trGeneratedBy()
+    { return "Generováno programem"; }
+
+    // new since 0.49-990307
     
-    QCString trNamespaceList()
-    { return "Seznam prostoru jmen"; }
-    QCString trNamespaceListDescription(bool extractAll)
+    /*! used as the title of page containing all the index of all namespaces. */
+    virtual QCString trNamespaceList()
+    { return "Seznam prostorů jmen"; }
+
+    /*! used as an introduction to the namespace list */
+    virtual QCString trNamespaceListDescription(bool extractAll)
     {
-      QCString result="Zde je seznam vsech ";
-      if (!extractAll) result+="dokumentovanych ";
-      result+="prostoru jmen s kratkymi popisy:";
+      QCString result="Zde naleznete seznam všech ";
+      if (!extractAll) result+="dokumentovaných ";
+      result+="prostorů jmen se stručným popisem:";
       return result;
     }
-    QCString trFriends()
-    { return "Spratelene tridy, funkce a metody"; }
+
+    /*! used in the class documentation as a header before the list of all
+     *  friends of a class
+     */
+    virtual QCString trFriends()
+    { return "Friends"; }
     
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990405
@@ -278,76 +507,75 @@ class TranslatorCzech : public Translator
     /*! used in the class documentation as a header before the list of all
      * related classes 
      */
-    QCString trRelatedFunctionDocumentation()
-    { return "Dokumentace pro spratelene funkce a ostatni"; }
+    virtual QCString trRelatedFunctionDocumentation()
+    { return "Dokumentace k friends"; }
     
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990425
 //////////////////////////////////////////////////////////////////////////
 
     /*! used as the title of the HTML page of a class/struct/union */
-    QCString trCompoundReference(const char *clName,
-                                 ClassDef::CompoundType compType,
-                                 bool /*isTemplate*/)
+    virtual QCString trCompoundReference(const char *clName,
+                                    ClassDef::CompoundType compType)
     {
       QCString result=(QCString)clName+" ";
-      result+=" Reference";
       switch(compType)
       {
-        case ClassDef::Class:      result+=" tridy"; break;
-        case ClassDef::Struct:     result+=" struktury"; break;
-        case ClassDef::Union:      result+=" unie"; break;
-        case ClassDef::Interface:  result+=" rozhrani"; break;
-        case ClassDef::Exception:  result+=" exception"; break;
+        case ClassDef::Class:      result+=" Třída"; break;
+        case ClassDef::Struct:     result+=" Struktura"; break;
+        case ClassDef::Union:      result+=" Unie"; break;
+        case ClassDef::Interface:  result+=" Rozhraní"; break;
+        case ClassDef::Exception:  result+=" Výjimka"; break;
       }
+      result+=" Reference";
       return result;
     }
 
     /*! used as the title of the HTML page of a file */
-    QCString trFileReference(const char *fileName)
+    virtual QCString trFileReference(const char *fileName)
     {
-      QCString result=fileName;
-      result+=" Reference souboru"; 
+      QCString result="Odkaz na soubor";
+      result+=fileName; 
       return result;
     }
 
     /*! used as the title of the HTML page of a namespace */
-    QCString trNamespaceReference(const char *namespaceName)
+    virtual QCString trNamespaceReference(const char *namespaceName)
     {
       QCString result=namespaceName;
-      result+=" Reference prostoru jmen";
+      result+=" Namespace Reference???";
       return result;
     }
     
     /*! \mgroup Class sections
      *  these are for the member sections of a class, struct or union 
      */
-    QCString trPublicMembers()
-    { return "Verejne metody a datove polozky"; }
-    QCString trPublicSlots()
-    { return "Verejne sloty"; }
-    QCString trSignals()
-    { return "Signaly"; }
-    QCString trStaticPublicMembers()
-    { return "Staticke verejne metody a datove polozky"; }
-    QCString trProtectedMembers()
-    { return "Chranene metody a datove polozky"; }
-    QCString trProtectedSlots()
-    { return "Chranene sloty"; }
-    QCString trStaticProtectedMembers()
-    { return "Staticke chranene metody a datove polozky"; }
-    QCString trPrivateMembers()
-    { return "Privatni metody a datove polozky"; }
-    QCString trPrivateSlots()
-    { return "Privatni sloty"; }
-    QCString trStaticPrivateMembers()
-    { return "Staticke privatni metody a datove polozky"; }
+    virtual QCString trPublicMembers()
+    { return "Veřejné metody"; }
+    virtual QCString trPublicSlots()
+    { return "Veřejné sloty"; }
+    virtual QCString trSignals()
+    { return "Signály"; }
+    virtual QCString trStaticPublicMembers()
+    { return "Statické veřejné metody"; }
+    virtual QCString trProtectedMembers()
+    { return "Chráněné metody"; }
+    virtual QCString trProtectedSlots()
+    { return "Chráněné sloty"; }
+    virtual QCString trStaticProtectedMembers()
+    { return "Statické chráněné metody"; }
+    virtual QCString trPrivateMembers()
+    { return "Privátní metody"; }
+    virtual QCString trPrivateSlots()
+    { return "Privátní sloty"; }
+    virtual QCString trStaticPrivateMembers()
+    { return "Statické privátní metody"; }
     /*! \endmgroup */ 
     
     /*! this function is used to produce a comma-separated list of items.
      *  use generateMarker(i) to indicate where item i should be put.
      */
-    QCString trWriteList(int numEntries)
+    virtual QCString trWriteList(int numEntries)
     {
       QCString result;
       int i;
@@ -372,62 +600,62 @@ class TranslatorCzech : public Translator
     /*! used in class documentation to produce a list of base classes,
      *  if class diagrams are disabled.
      */
-    QCString trInheritsList(int numEntries)
+    virtual QCString trInheritsList(int numEntries)
     {
-      return "dedi "+trWriteList(numEntries)+".";
+      return "Dědí "+trWriteList(numEntries)+".";
     }
 
     /*! used in class documentation to produce a list of super classes,
      *  if class diagrams are disabled.
      */
-    QCString trInheritedByList(int numEntries)
+    virtual QCString trInheritedByList(int numEntries)
     {
-      return "je zdeden z "+trWriteList(numEntries)+".";
+      return "Zděděna třídami "+trWriteList(numEntries)+".";
     }
 
     /*! used in member documentation blocks to produce a list of 
      *  members that are hidden by this one.
      */
-    QCString trReimplementedFromList(int numEntries)
+    virtual QCString trReimplementedFromList(int numEntries)
     {
-      return "Znovu implementuje "+trWriteList(numEntries)+".";
+      return "Reimplementace z "+trWriteList(numEntries)+".";
     }
 
     /*! used in member documentation blocks to produce a list of
      *  all member that overwrite the implementation of this member.
      */
-    QCString trReimplementedInList(int numEntries)
+    virtual QCString trReimplementedInList(int numEntries)
     {
-      return "znovu implementovan v "+trWriteList(numEntries)+".";
+      return "Reimplementováno v "+trWriteList(numEntries)+".";
     }
 
     /*! This is put above each page as a link to all members of namespaces. */
-    QCString trNamespaceMembers()
-    { return "Polozky prostoru jmen"; }
+    virtual QCString trNamespaceMembers()
+    { return "???Namespace Members"; }
 
     /*! This is an introduction to the page with all namespace members */
-    QCString trNamespaceMemberDescription(bool extractAll)
+    virtual QCString trNamespaceMemberDescription(bool extractAll)
     { 
-      QCString result="Tady je seznam vsech ";
-      if (!extractAll) result+="zdokumentovanych ";
-      result+="clenu prostoru jmen s odkazy na ";
+      QCString result="Zde naleznete seznam všech ";
+      if (!extractAll) result+="dokumentovaných ";
+      result+="???namespace members s odkazy na ";
       if (extractAll) 
-        result+="dukumentaci prostoru jmen pro kazdou polozku:";
+        result+="dokumentaci prostoru jmen pro každý člen:";
       else 
-        result+="prostor jmen, kteremu patri:";
+        result+="prostory jmen, ke kterým příslušejí:";
       return result;
     }
     /*! This is used in LaTeX as the title of the chapter with the 
      *  index of all namespaces.
      */
-    QCString trNamespaceIndex()
-    { return "Index prostoru jmen"; }
+    virtual QCString trNamespaceIndex()
+    { return "Rejstřík prostorů jmen"; }
 
     /*! This is used in LaTeX as the title of the chapter containing
      *  the documentation of all namespaces.
      */
-    QCString trNamespaceDocumentation()
-    { return "Dokumentace prostoru jmen"; }
+    virtual QCString trNamespaceDocumentation()
+    { return "Dokumentace prostorů jmen"; }
 
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990522
@@ -436,7 +664,7 @@ class TranslatorCzech : public Translator
     /*! This is used in the documentation before the list of all
      *  namespaces in a file.
      */
-    QCString trNamespaces()
+    virtual QCString trNamespaces()
     { return "Prostory jmen"; }
 
 //////////////////////////////////////////////////////////////////////////
@@ -446,48 +674,49 @@ class TranslatorCzech : public Translator
     /*! This is put at the bottom of a class documentation page and is
      *  followed by a list of files that were used to generate the page.
      */
-    QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
+    virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
         bool single)
     { // here s is one of " Class", " Struct" or " Union"
       // single is true implies a single file
       QCString result=(QCString)"Dokumentace pro ";
       switch(compType)
       {
-        case ClassDef::Class:      result+="tuto tridu"; break;
-        case ClassDef::Struct:     result+="tuto strukturu"; break;
-        case ClassDef::Union:      result+="tuto unii"; break;
-        case ClassDef::Interface:  result+="toto rozhrani"; break;
-        case ClassDef::Exception:  result+="exception"; break;
+        case ClassDef::Class:      result+="tuto třídu"; break;
+        case ClassDef::Struct:     result+="tuto strukturu (struct)"; break;
+        case ClassDef::Union:      result+="tuto unii (union)"; break;
+        case ClassDef::Interface:  result+="toto rozhraní"; break;
+        case ClassDef::Exception:  result+="tuto výjimku"; break;
       }
-      result+=" byla vygenerovana z nasledujiciho souboru";
-      if (single) result+=":"; else result+="s:";
+      result+=" byla generována z ";
+      if (single) result+="následujícího souboru:"; 
+      else        result+="následujících souborů:";
       return result;
     }
 
     /*! This is in the (quick) index as a link to the alphabetical compound
      * list.
      */
-    QCString trAlphabeticalList()
-    { return "Abecedni seznam"; }
+    virtual QCString trAlphabeticalList()
+    { return "Abecední seznam složenin"; }
 
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990901
 //////////////////////////////////////////////////////////////////////////
 
     /*! This is used as the heading text for the retval command. */
-    QCString trReturnValues()
-    { return "Vraci hodnoty"; }
+    virtual QCString trReturnValues()
+    { return "Vracené hodnoty"; }
 
     /*! This is in the (quick) index as a link to the main page (index.html)
      */
-    QCString trMainPage()
-    { return "Hlavni stranka"; }
+    virtual QCString trMainPage()
+    { return "Hlavní stránka"; }
 
     /*! This is used in references to page that are put in the LaTeX 
      *  documentation. It should be an abbreviation of the word page.
      */
-    QCString trPageAbbreviation()
-    { return "str."; }
+    virtual QCString trPageAbbreviation()
+    { return "s."; }
 
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-991003
@@ -495,16 +724,157 @@ class TranslatorCzech : public Translator
 
     virtual QCString trSources()
     {
-      return "Zdrojove soubory";
+      return "Zdroje";
     }
     virtual QCString trDefinedAtLineInSourceFile()
     {
-      return "Definice v souboru @1 na radce @0";
+      return "Definice je uvedena na řádku @0 v souboru @1.";
     }
     virtual QCString trDefinedInSourceFile()
     {
       return "Definice v souboru @0.";
-    }    
+    }
+
+//////////////////////////////////////////////////////////////////////////
+// new since 0.49-991205
+//////////////////////////////////////////////////////////////////////////
+
+    virtual QCString trDeprecated()
+    {
+      return "Zastaralé";
+    }
+
+//////////////////////////////////////////////////////////////////////////
+// new since 1.0.0
+//////////////////////////////////////////////////////////////////////////
+
+    /*! this text is put before a collaboration diagram */
+    virtual QCString trCollaborationDiagram(const char *clName)
+    {
+      return (QCString)"Diagram tříd pro "+clName+":";
+    }
+    /*! this text is put before an include dependency graph */
+    virtual QCString trInclDepGraph(const char *fName)
+    {
+      return (QCString)"Graf závislostí souborů pro "+fName+":";
+    }
+    /*! header that is put before the list of constructor/destructors. */
+    virtual QCString trConstructorDocumentation()
+    {
+      return "Dokumentace konstruktoru a destruktoru"; 
+    }
+    /*! Used in the file documentation to point to the corresponding sources. */
+    virtual QCString trGotoSourceCode()
+    {
+      return "Zobrazit zdrojový text tohoto souboru.";
+    }
+    /*! Used in the file sources to point to the corresponding documentation. */
+    virtual QCString trGotoDocumentation()
+    {
+      return "Zobrazit dokumentaci tohoto souboru.";
+    }
+    /*! Text for the \pre command */
+    virtual QCString trPrecondition()
+    {
+      return "Precondition";
+    }
+    /*! Text for the \post command */
+    virtual QCString trPostcondition()
+    {
+      return "Postcondition";
+    }
+    /*! Text for the \invariant command */
+    virtual QCString trInvariant()
+    {
+      return "Invariant";
+    }
+    /*! Text shown before a multi-line variable/enum initialization */
+    virtual QCString trInitialValue()
+    {
+      return "Initializer:";
+    }
+    /*! Text used the source code in the file index */
+    virtual QCString trCode()
+    {
+      return "zdrojový text";
+    }
+    virtual QCString trGraphicalHierarchy()
+    {
+      return "Grafické zobrazení hierarchie tříd";
+    }
+    virtual QCString trGotoGraphicalHierarchy()
+    {
+      return "Zobrazit grafickou podobu hierarchie tříd";
+    }
+    virtual QCString trGotoTextualHierarchy()
+    {
+      return "Zobrazit textovou podobu hierarchie tříd";
+    }
+    virtual QCString trPageIndex()
+    {
+      return "Rejstřík stránek";
+    }
+
+//////////////////////////////////////////////////////////////////////////
+// new since 1.1.0
+//////////////////////////////////////////////////////////////////////////
+    
+    virtual QCString trNote()
+    {
+      return "Poznámka";
+    }
+    virtual QCString trPublicTypes()
+    {
+      return "Veřejné typy";
+    }
+    virtual QCString trPublicAttribs()
+    {
+      return "Veřejné atributy";
+    }
+    virtual QCString trStaticPublicAttribs()
+    {
+      return "Statické veřejné atributy";
+    }
+    virtual QCString trProtectedTypes()
+    {
+      return "Chráněné typy";
+    }
+    virtual QCString trProtectedAttribs()
+    {
+      return "Chráněné atributy";
+    }
+    virtual QCString trStaticProtectedAttribs()
+    {
+      return "Statické chráněné atributy";
+    }
+    virtual QCString trPrivateTypes()
+    {
+      return "Privátní typy";
+    }
+    virtual QCString trPrivateAttribs()
+    {
+      return "Privátní atributy";
+    }
+    virtual QCString trStaticPrivateAttribs()
+    {
+      return "Statické privátní atributy";
+    }
+
+//////////////////////////////////////////////////////////////////////////
+// new since 1.1.3
+//////////////////////////////////////////////////////////////////////////
+
+    /*! Used as a marker that is put before a todo item */
+    virtual QCString trTodo()
+    {
+      return "Udělat";
+    }
+    /*! Used as the header of the todo list */
+    virtual QCString trTodoList()
+    {
+      return "Seznam plánovaných úprav";
+    }
+
 };
 
 #endif // TRANSLATOR_CZ_H