1 /******************************************************************************

     2  *

     3  * 

     4  *

     5  * Copyright (C) 1997-2008 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 /* Translation from English to Lithanian by Tomas Simonaitis, Mindaugas Radzius and Aidas Berukstis

    19  *  (haden@homelan.lt/mindaugasradzius@takas.lt/aidasber@takas.lt)

    20  *  We tried to keep meaning close to original, 

    21  *  if you have any suggestions drop us an email

    22  *  -------------------------------------------

    23  *  Project start                  :13.May.2k4

    24  *  Last Doxygen version covered   : 1.4.3

    25  *  

    26  *  Revisions:

    27  *  Updated to 1.3.9 25.Oct.2k4

    28  *

    29 */

    30 

    31 #ifndef TRANSLATOR_LT_H

    32 #define TRANSLATOR_LT_H

    33 

    34 

    35 class TranslatorLithuanian : public TranslatorAdapter_1_4_6

    36 {

    37   public:

    38 

    39     // --- Language control methods -------------------

    40     

    41     /*! Used for identification of the language. The identification 

    42      * should not be translated. It should be replaced by the name 

    43      * of the language in English using lower-case characters only

    44      * (e.g. "czech", "japanese", "russian", etc.). It should be equal to 

    45      * the identification used in language.cpp.

    46      */

    47     virtual QCString idLanguage()

    48     { return "lithuanian"; }

    49     

    50     /*! Used to get the LaTeX command(s) for the language support. 

    51      *  This method should return string with commands that switch

    52      *  LaTeX to the desired language.  For example 

    53      *  <pre>"\\usepackage[german]{babel}\n"

    54      *  </pre>

    55      *  or

    56      *  <pre>"\\usepackage{polski}\n"

    57      *  "\\usepackage[latin2]{inputenc}\n"

    58      *  "\\usepackage[T1]{fontenc}\n"

    59      *  </pre>

    60      * 

    61      * The English LaTeX does not use such commands.  Because of this

    62      * the empty string is returned in this implementation.

    63      */

    64     virtual QCString latexLanguageSupportCommand()

    65     {

    66       return "\\usepackage[T2A]{fontenc}\n"

    67              "\\usepackage[lithuanian]{babel}\n";

    68     }

    69 

    70     /*! return the language charset. This will be used for the HTML output */

    71     virtual QCString idLanguageCharset()

    72     {

    73       return "iso-8859-13";

    74     }

    75 

    76     // --- Language translation methods -------------------

    77 

    78     /*! used in the compound documentation before a list of related functions. */

    79     virtual QCString trRelatedFunctions()

    80     { return "Susiję Funkcijos"; }

    81 

    82     /*! subscript for the related functions. */

    83     virtual QCString trRelatedSubscript()

    84     { return "Atkreipkite dėmesį, čią ne metodai"; }

    85 

    86     /*! header that is put before the detailed description of files, classes and namespaces. */

    87     virtual QCString trDetailedDescription()

    88     { return "Smulkus aprašymas"; }

    89 

    90     /*! header that is put before the list of typedefs. */

    91     virtual QCString trMemberTypedefDocumentation()

    92     { return "Tipo Aprašymo Dokumentacija"; }

    93     

    94     /*! header that is put before the list of enumerations. */

    95     virtual QCString trMemberEnumerationDocumentation()

    96     { return "Išvardinimo Dokumentacija"; }

    97     

    98     /*! header that is put before the list of member functions. */

    99     virtual QCString trMemberFunctionDocumentation()

   100     { return "Metodų Dokumentacija"; }

   101     

   102     /*! header that is put before the list of member attributes. */

   103     virtual QCString trMemberDataDocumentation()

   104     { 

   105       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   106       {

   107         return "Lauko aprašymas"; 

   108       }

   109       else

   110       {

   111         return "Atributų Dokumentacija"; 

   112       }

   113     }

   114 

   115     /*! this is the text of a link put after brief descriptions. */

   116     virtual QCString trMore() 

   117     { return "Daugiau..."; }

   118 

   119     /*! put in the class documentation */

   120     virtual QCString trListOfAllMembers()

   121     { return "Visų narių sąrašas."; }

   122 

   123     /*! used as the title of the "list of all members" page of a class */

   124     virtual QCString trMemberList()

   125     { return "Narių sąrašas"; }

   126 

   127     /*! this is the first part of a sentence that is followed by a class name */

   128     virtual QCString trThisIsTheListOfAllMembers()

   129     { return "Tai galutinis narių sąrašas "; }

   130 

   131     /*! this is the remainder of the sentence after the class name */

   132     virtual QCString trIncludingInheritedMembers()

   133     { return ", įtraukiant visus paveldėtus narius."; }

   134     

   135     /*! this is put at the author sections at the bottom of man pages.

   136      *  parameter s is name of the project name.

   137      */

   138     virtual QCString trGeneratedAutomatically(const char *s)

   139     { QCString result="Automatiškai sugeneruota Doxygen įrankiu";

   140       if (s) result+=(QCString)" "+s;

   141       result+=" iš programos kodo."; 

   142       return result;

   143     }

   144 

   145     /*! put after an enum name in the list of all members */

   146     virtual QCString trEnumName()

   147     { return "išvardinimo vardas"; }

   148     

   149     /*! put after an enum value in the list of all members */

   150     virtual QCString trEnumValue()

   151     { return "išvardinimo reikšmė"; }

   152     

   153     /*! put after an undocumented member in the list of all members */

   154     virtual QCString trDefinedIn()

   155     { return "apibrėžta"; }

   156 

   157     // quick reference sections

   158 

   159     /*! This is put above each page as a link to the list of all groups of 

   160      *  compounds or files (see the \\group command).

   161      */

   162     virtual QCString trModules()

   163     { return "Moduliai"; }

   164     

   165     /*! This is put above each page as a link to the class hierarchy */

   166     virtual QCString trClassHierarchy()

   167     { return "Klasių hierarchija"; }

   168     

   169     /*! This is put above each page as a link to the list of annotated classes */

   170     virtual QCString trCompoundList()

   171     { 

   172       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   173       {

   174         return "Duomenų Struktūros";

   175       }

   176       else

   177       {

   178         return "Klasės"; 

   179       }

   180     }

   181     

   182     /*! This is put above each page as a link to the list of documented files */

   183     virtual QCString trFileList()

   184     { return "Failai"; }

   185 

   186     /*! This is put above each page as a link to all members of compounds. */

   187     virtual QCString trCompoundMembers()

   188     { 

   189       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   190       {

   191         return "Duomenų Laukai"; 

   192       }

   193       else

   194       {

   195         return "Klasių Nariai"; 

   196       }

   197     }

   198 

   199     /*! This is put above each page as a link to all members of files. */

   200     virtual QCString trFileMembers()

   201     { 

   202       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   203       {

   204         return "Globalūs Nariai"; 

   205       }

   206       else

   207       {

   208         return "Globalūs Nariai"; 

   209       }

   210     }

   211 

   212     /*! This is put above each page as a link to all related pages. */

   213     virtual QCString trRelatedPages()

   214     { return "Susiję Puslapiai"; }

   215 

   216     /*! This is put above each page as a link to all examples. */

   217     virtual QCString trExamples()

   218     { return "Pavyzdžiai"; }

   219 

   220     /*! This is put above each page as a link to the search engine. */

   221     virtual QCString trSearch()

   222     { return "Paieška"; }

   223 

   224     /*! This is an introduction to the class hierarchy. */

   225     virtual QCString trClassHierarchyDescription()

   226     { return "Šis paveldėjimo sąrašas yra beveik surikiuotas "

   227              "abėcėlės tvarka:";

   228     }

   229 

   230     /*! This is an introduction to the list with all files. */

   231     virtual QCString trFileListDescription(bool extractAll)

   232     {

   233       QCString result="Visų ";

   234       if (!extractAll) result+="dokumentuotų ";

   235       result+="failų sąrašas su trumpais aprašymais:";

   236       return result;

   237     }

   238 

   239     /*! This is an introduction to the annotated compound list. */

   240     virtual QCString trCompoundListDescription()

   241     { 

   242       

   243       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   244       {

   245         return "Duomenų struktūros su trumpais aprašymais:"; 

   246       }

   247       else

   248       {

   249         return "Klasės, struktūros, "

   250                "sąjungos ir sąsajos su trumpais aprašymais:"; 

   251       }

   252     }

   253 

   254     /*! This is an introduction to the page with all class members. */

   255     virtual QCString trCompoundMembersDescription(bool extractAll)

   256     {

   257       QCString result="Visų ";

   258       if (!extractAll)

   259       {

   260         result+="dokumentuotų ";

   261       }

   262       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   263       {

   264         result+="struktūrų ir sąjungų laukų sąrašas";

   265       }

   266       else

   267       {

   268         result+="klasių nariai";

   269       }

   270       result+=" su ryšiais į ";

   271       if (!extractAll) 

   272       {

   273         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   274         {

   275           result+="struktūrų/sąjungų kiekvieno lauko dokumentaciją:";

   276         }

   277         else

   278         {

   279           result+="klasės dokumentacija kiekvienam nariui:";

   280         }

   281       }

   282       else 

   283       {

   284         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   285         {

   286           result+="struktūros/sąjungos, kurios priklauso:";

   287         }

   288         else

   289         {

   290           result+="klasės, kurios priklauso:";

   291         }

   292       }

   293       return result;

   294     }

   295 

   296     /*! This is an introduction to the page with all file members. */

   297     virtual QCString trFileMembersDescription(bool extractAll)

   298     {

   299       QCString result="Sąrašas visų ";

   300       if (!extractAll) result+="dokumentuotų ";

   301       

   302       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   303       {

   304         result+="funkcijų, kintamųjų, apibrėžimų, išvardinimų, ir tipų apibrėžimų";

   305       }

   306       else

   307       {

   308         result+="globalių narių";

   309       }

   310       result+=" su ryšiais į ";

   311       if (extractAll) 

   312         result+="failus, kuriems jie priklauso:";

   313       else 

   314         result+="dokumentacija:";

   315       return result;

   316     }

   317 

   318     /*! This is an introduction to the page with the list of all examples */

   319     virtual QCString trExamplesDescription()

   320     { return "Visų pavyzdžių sąrašas:"; }

   321 

   322     /*! This is an introduction to the page with the list of related pages */

   323     virtual QCString trRelatedPagesDescription()

   324     { return "Visų susijusių dokumentacijos puslapių sąrašas:"; }

   325 

   326     /*! This is an introduction to the page with the list of class/file groups */

   327     virtual QCString trModulesDescription()

   328     { return "Visų modulių sąrašas:"; }

   329 

   330     // index titles (the project name is prepended for these) 

   331     

   332     /*! This is used in HTML as the title of index.html. */

   333     virtual QCString trDocumentation()

   334     { return "Dokumentacija"; }

   335 

   336     /*! This is used in LaTeX as the title of the chapter with the 

   337      * index of all groups.

   338      */

   339     virtual QCString trModuleIndex()

   340     { return "Modulio Indeksas"; }

   341 

   342     /*! This is used in LaTeX as the title of the chapter with the 

   343      * class hierarchy.

   344      */

   345     virtual QCString trHierarchicalIndex()

   346     { return "Hierarchijos Indeksas"; }

   347 

   348     /*! This is used in LaTeX as the title of the chapter with the 

   349      * annotated compound index.

   350      */

   351     virtual QCString trCompoundIndex()

   352     {

   353       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   354       { 

   355         return "Duomenų Struktūros Indeksas";

   356       }

   357       else

   358       {

   359         return "Klasės Indeksas"; 

   360       }

   361     }

   362 

   363     /*! This is used in LaTeX as the title of the chapter with the

   364      * list of all files.

   365      */

   366     virtual QCString trFileIndex() 

   367     { return "Failo Indeksas"; }

   368 

   369     /*! This is used in LaTeX as the title of the chapter containing

   370      *  the documentation of all groups.

   371      */

   372     virtual QCString trModuleDocumentation()

   373     { return "Modulio Dokumentacija"; }

   374 

   375     /*! This is used in LaTeX as the title of the chapter containing

   376      *  the documentation of all classes, structs and unions.

   377      */

   378     virtual QCString trClassDocumentation()

   379     { 

   380       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   381       {

   382         return "Duomenų Struktūros Dokumentacija"; 

   383       }

   384       else

   385       {

   386         return "Klasės Dokumentacija"; 

   387       }

   388     }

   389 

   390     /*! This is used in LaTeX as the title of the chapter containing

   391      *  the documentation of all files.

   392      */

   393     virtual QCString trFileDocumentation()

   394     { return "Failo Dokumentacija"; }

   395 

   396     /*! This is used in LaTeX as the title of the chapter containing

   397      *  the documentation of all examples.

   398      */

   399     virtual QCString trExampleDocumentation()

   400     { return "Pavyzdžio Dokumentacija"; }

   401 

   402     /*! This is used in LaTeX as the title of the chapter containing

   403      *  the documentation of all related pages.

   404      */

   405     virtual QCString trPageDocumentation()

   406     { return "Puslapio Dokumentacija"; }

   407 

   408     /*! This is used in LaTeX as the title of the document */

   409     virtual QCString trReferenceManual()

   410     { return "Informacinis Vadovas"; }

   411     

   412     /*! This is used in the documentation of a file as a header before the 

   413      *  list of defines

   414      */

   415     virtual QCString trDefines()

   416     { return "Apibrėžimai"; }

   417 

   418     /*! This is used in the documentation of a file as a header before the 

   419      *  list of function prototypes

   420      */

   421     virtual QCString trFuncProtos()

   422     { return "Funkcijų Prototipai"; }

   423 

   424     /*! This is used in the documentation of a file as a header before the 

   425      *  list of typedefs

   426      */

   427     virtual QCString trTypedefs()

   428     { return "Tipų apibrėžimai"; }

   429 

   430     /*! This is used in the documentation of a file as a header before the 

   431      *  list of enumerations

   432      */

   433     virtual QCString trEnumerations()

   434     { return "Išvardinimai"; }

   435 

   436     /*! This is used in the documentation of a file as a header before the 

   437      *  list of (global) functions

   438      */

   439     virtual QCString trFunctions()

   440     { return "Funkcijos"; }

   441 

   442     /*! This is used in the documentation of a file as a header before the 

   443      *  list of (global) variables

   444      */

   445     virtual QCString trVariables()

   446     { return "Kintamieji"; }

   447 

   448     /*! This is used in the documentation of a file as a header before the 

   449      *  list of (global) variables

   450      */

   451     virtual QCString trEnumerationValues()

   452     { return "Išvardinimų reikšmės"; }

   453     

   454     /*! This is used in the documentation of a file before the list of

   455      *  documentation blocks for defines

   456      */

   457     virtual QCString trDefineDocumentation()

   458     { return "Apibrėžimų Dokumentacija"; }

   459 

   460     /*! This is used in the documentation of a file/namespace before the list 

   461      *  of documentation blocks for function prototypes

   462      */

   463     virtual QCString trFunctionPrototypeDocumentation()

   464     { return "Funkcijų Prototipų Dokumentacija"; }

   465 

   466     /*! This is used in the documentation of a file/namespace before the list 

   467      *  of documentation blocks for typedefs

   468      */

   469     virtual QCString trTypedefDocumentation()

   470     { return "Tipų apibrėžimų Dokumentacija"; }

   471 

   472     /*! This is used in the documentation of a file/namespace before the list 

   473      *  of documentation blocks for enumeration types

   474      */

   475     virtual QCString trEnumerationTypeDocumentation()

   476     { return "Išvardinimo Tipo Dokumentacija"; }

   477 

   478     /*! This is used in the documentation of a file/namespace before the list 

   479      *  of documentation blocks for functions

   480      */

   481     virtual QCString trFunctionDocumentation()

   482     { return "Funkcijos Dokumentacija"; }

   483 

   484     /*! This is used in the documentation of a file/namespace before the list

   485      *  of documentation blocks for variables

   486      */

   487     virtual QCString trVariableDocumentation()

   488     { return "Kintamojo Dokumentacija"; }

   489 

   490     /*! This is used in the documentation of a file/namespace/group before

   491      *  the list of links to documented compounds

   492      */

   493     virtual QCString trCompounds()

   494     {

   495       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   496       {

   497         return "Duomenų struktųros";

   498       }

   499       else

   500       {

   501         return "Klasės";

   502       }

   503     }

   504 

   505     /*! This is used in the standard footer of each page and indicates when

   506      *  the page was generated

   507      */

   508     virtual QCString trGeneratedAt(const char *date,const char *projName)

   509     {

   510       QCString result=(QCString)"Sugeneruota "+date;/*FIXME*/

   511       if (projName) result+=(QCString)" "+projName;/*FIXME*/

   512       result+=(QCString)" ";/*FIXME*/

   513       return result;

   514     }

   515     /*! This is part of the sentence used in the standard footer of each page.

   516      */

   517     virtual QCString trWrittenBy()

   518     {

   519       return "parašyta";

   520     }

   521 

   522     /*! this text is put before a class diagram */

   523     virtual QCString trClassDiagram(const char *clName)

   524     {

   525       return (QCString)"Paveldimumo diagrama "+clName+":"; /*FIXME*/

   526     }

   527 

   528     /*! this text is generated when the \\internal command is used. */

   529     virtual QCString trForInternalUseOnly()

   530     { return "Tiktai vidiniam naudojimui."; }

   531 

   532     /*! this text is generated when the \\warning command is used. */

   533     virtual QCString trWarning()

   534     { return "Įspėjimas"; }

   535 

   536     /*! this text is generated when the \\version command is used. */

   537     virtual QCString trVersion()

   538     { return "Versija"; }

   539 

   540     /*! this text is generated when the \\date command is used. */

   541     virtual QCString trDate()

   542     { return "Data"; }

   543 

   544     /*! this text is generated when the \\return command is used. */

   545     virtual QCString trReturns()

   546     { return "Gražina"; }

   547 

   548     /*! this text is generated when the \\sa command is used. */

   549     virtual QCString trSeeAlso()

   550     { return "Taip pat žiūrėti"; }

   551 

   552     /*! this text is generated when the \\param command is used. */

   553     virtual QCString trParameters()

   554     { return "Parametrai"; }

   555 

   556     /*! this text is generated when the \\exception command is used. */

   557     virtual QCString trExceptions()

   558     { return "Išimtys"; }

   559 

   560     /*! this text is used in the title page of a LaTeX document. */

   561     virtual QCString trGeneratedBy()

   562     { return "Sugeneruota"; }

   563 

   564 //////////////////////////////////////////////////////////////////////////

   565 // new since 0.49-990307

   566 //////////////////////////////////////////////////////////////////////////

   567 

   568     /*! used as the title of page containing all the index of all namespaces. */

   569     virtual QCString trNamespaceList()

   570     { return "Varų Srities Sąrašas"; }

   571 

   572     /*! used as an introduction to the namespace list */

   573     virtual QCString trNamespaceListDescription(bool extractAll)

   574     {

   575       QCString result="Sąrašas visų ";

   576       if (!extractAll) result+="dokumentuotų ";

   577       result+="vardų sričių su trumpais aprašymais:";

   578       return result;

   579     }

   580 

   581     /*! used in the class documentation as a header before the list of all

   582      *  friends of a class

   583      */

   584     virtual QCString trFriends()

   585     { return "Draugai"; }

   586 

   587 //////////////////////////////////////////////////////////////////////////

   588 // new since 0.49-990405

   589 //////////////////////////////////////////////////////////////////////////

   590 

   591     /*! used in the class documentation as a header before the list of all

   592      * related classes

   593      */

   594     virtual QCString trRelatedFunctionDocumentation()

   595     { return "Draugiškų Ir Susijusių Funkcijų Dokumentacija"; }

   596 

   597 //////////////////////////////////////////////////////////////////////////

   598 // new since 0.49-990425

   599 //////////////////////////////////////////////////////////////////////////

   600 

   601     /*! used as the title of the HTML page of a class/struct/union */

   602     virtual QCString trCompoundReference(const char *clName,

   603                                     ClassDef::CompoundType compType,

   604                                     bool isTemplate)

   605     {

   606       QCString result=(QCString)clName;

   607       switch(compType)

   608       {

   609         case ClassDef::Class:      result+=" Klasė"; break;

   610         case ClassDef::Struct:     result+=" Struktūra"; break;

   611         case ClassDef::Union:      result+=" Sąjunga"; break;

   612         case ClassDef::Interface:  result+=" Sąsaja"; break;

   613         case ClassDef::Protocol:   result+=" Protokolas"; break;

   614         case ClassDef::Category:   result+=" Kategorija"; break;

   615         case ClassDef::Exception:  result+=" Išimtis"; break;

   616       }

   617       if (isTemplate) result+=" Šablonas";

   618       return result;

   619     }

   620 

   621     /*! used as the title of the HTML page of a file */

   622     virtual QCString trFileReference(const char *fileName)

   623     {

   624       QCString result=fileName;

   625       result+=" Failo Nuoroda";

   626       return result;

   627     }

   628 

   629     /*! used as the title of the HTML page of a namespace */

   630     virtual QCString trNamespaceReference(const char *namespaceName)

   631     {

   632       QCString result=namespaceName;

   633       result+=" Vardų Srities Nuoroda";

   634       return result;

   635     }

   636 

   637     virtual QCString trPublicMembers()

   638     { return "Vieši Metodai"; }

   639     virtual QCString trPublicSlots()

   640     { return "Vieši Slotai"; } /*FIXME*/

   641     virtual QCString trSignals()

   642     { return "Signalai"; }

   643     virtual QCString trStaticPublicMembers()

   644     { return "Statiniai Vieši Metodai"; }

   645     virtual QCString trProtectedMembers()

   646     { return "Apsaugoti Metodai"; }

   647     virtual QCString trProtectedSlots()

   648     { return "Apsaugoti Slotai"; }/*FIXME*/

   649     virtual QCString trStaticProtectedMembers()

   650     { return "Statiniai Apsaugoti Metodai"; }

   651     virtual QCString trPrivateMembers()

   652     { return "Privatatūs Metodai"; }

   653     virtual QCString trPrivateSlots()

   654     { return "Privatūs Slotai"; }/*FIXME*/

   655     virtual QCString trStaticPrivateMembers()

   656     { return "Statiniai Privatūs Metodai"; }

   657 

   658     /*! this function is used to produce a comma-separated list of items.

   659      *  use generateMarker(i) to indicate where item i should be put.

   660      */

   661     virtual QCString trWriteList(int numEntries)

   662     {

   663       QCString result;

   664       int i;

   665       // the inherits list contain `numEntries' classes

   666       for (i=0;i<numEntries;i++)

   667       {

   668         // use generateMarker to generate placeholders for the class links!

   669         result+=generateMarker(i); // generate marker for entry i in the list

   670                                    // (order is left to right)

   671 

   672         if (i!=numEntries-1)  // not the last entry, so we need a separator

   673         {

   674           if (i<numEntries-2) // not the fore last entry

   675             result+=", ";

   676           else                // the fore last entry

   677             result+=", ir ";

   678         }

   679       }

   680       return result;

   681     }

   682 

   683     /*! used in class documentation to produce a list of base classes,

   684      *  if class diagrams are disabled.

   685      */

   686     virtual QCString trInheritsList(int numEntries)

   687     {

   688       return "Paveldi "+trWriteList(numEntries)+".";

   689     }

   690 

   691     /*! used in class documentation to produce a list of super classes,

   692      *  if class diagrams are disabled.

   693      */

   694     virtual QCString trInheritedByList(int numEntries)

   695     {

   696       return "Paveldėta "+trWriteList(numEntries)+".";

   697     }

   698 

   699     /*! used in member documentation blocks to produce a list of

   700      *  members that are hidden by this one.

   701      */

   702     virtual QCString trReimplementedFromList(int numEntries)

   703     {

   704       return "Perkrauna metodą iš "+trWriteList(numEntries)+".";

   705     }

   706 

   707     /*! used in member documentation blocks to produce a list of

   708      *  all member that overwrite the implementation of this member.

   709      */

   710     virtual QCString trReimplementedInList(int numEntries)

   711     {

   712       return "Metodas perkraunamas "+trWriteList(numEntries)+".";

   713     }

   714 

   715     /*! This is put above each page as a link to all members of namespaces. */

   716     virtual QCString trNamespaceMembers()

   717     { return "Vardų Srities Nariai"; }

   718 

   719     /*! This is an introduction to the page with all namespace members */

   720     virtual QCString trNamespaceMemberDescription(bool extractAll)

   721     {

   722       QCString result="Sąrašas visų ";

   723       if (!extractAll) result+="dokumentuotų ";

   724       result+="vardų srities narių su nuorodomis į ";

   725       if (extractAll)

   726         result+="vardų srities dokumentaciją kiekvienam nariui:";

   727       else

   728         result+="vardų sritis, kurioms jos priklauso:";

   729       return result;

   730     }

   731     /*! This is used in LaTeX as the title of the chapter with the

   732      *  index of all namespaces.

   733      */

   734     virtual QCString trNamespaceIndex()

   735     { return "Vardų Srities Indeksas"; }

   736 

   737     /*! This is used in LaTeX as the title of the chapter containing

   738      *  the documentation of all namespaces.

   739      */

   740     virtual QCString trNamespaceDocumentation()

   741     { return "Vardų Srities Dokumentacija"; }

   742 

   743 //////////////////////////////////////////////////////////////////////////

   744 // new since 0.49-990522

   745 //////////////////////////////////////////////////////////////////////////

   746 

   747     /*! This is used in the documentation before the list of all

   748      *  namespaces in a file.

   749      */

   750     virtual QCString trNamespaces()

   751     { return "Vardų Sritys"; }

   752 

   753 //////////////////////////////////////////////////////////////////////////

   754 // new since 0.49-990728

   755 //////////////////////////////////////////////////////////////////////////

   756 

   757     /*! This is put at the bottom of a class documentation page and is

   758      *  followed by a list of files that were used to generate the page.

   759      */

   760     virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,

   761         bool single)

   762     { // here s is one of " Class", " Struct" or " Union"

   763       // single is true implies a single file

   764       QCString result=(QCString)"Dokumentacija ";

   765       switch(compType)

   766       {

   767         case ClassDef::Class:      result+="šiai klasei"; break;

   768         case ClassDef::Struct:     result+="šiai struktūrai"; break;

   769         case ClassDef::Union:      result+="šiai sąjungai"; break;

   770         case ClassDef::Interface:  result+="šiai sąsajai"; break;

   771         case ClassDef::Protocol:   result+="šiam protocolui"; break;

   772         case ClassDef::Category:   result+="šiai kategorijai"; break;

   773         case ClassDef::Exception:  result+="šiai išimčiai"; break;

   774       }

   775       result+=" sugeneruota iš ";

   776       if (single) result+="šio failo:"; else result+="šių failų:";

   777       return result;

   778     }

   779 

   780     /*! This is in the (quick) index as a link to the alphabetical compound

   781      * list.

   782      */

   783     virtual QCString trAlphabeticalList()

   784     { return "Abėcėlinis Sąrašas"; }

   785 

   786 //////////////////////////////////////////////////////////////////////////

   787 // new since 0.49-990901

   788 //////////////////////////////////////////////////////////////////////////

   789 

   790     /*! This is used as the heading text for the retval command. */

   791     virtual QCString trReturnValues()

   792     { return "Gražinamos reikšmės"; }

   793 

   794     /*! This is in the (quick) index as a link to the main page (index.html)

   795      */

   796     virtual QCString trMainPage()

   797     { return "Pagrindinis Puslapis"; }

   798 

   799     /*! This is used in references to page that are put in the LaTeX

   800      *  documentation. It should be an abbreviation of the word page.

   801      */

   802     virtual QCString trPageAbbreviation()

   803     { return "psl."; }

   804 

   805 //////////////////////////////////////////////////////////////////////////

   806 // new since 0.49-991003

   807 //////////////////////////////////////////////////////////////////////////

   808 

   809     virtual QCString trDefinedAtLineInSourceFile()

   810     {

   811       return "Apibrėžimas failo @1 eilutėje @0.";

   812     }

   813     virtual QCString trDefinedInSourceFile()

   814     {

   815       return "Apibrėžimas faile @0.";

   816     }

   817 

   818 //////////////////////////////////////////////////////////////////////////

   819 // new since 0.49-991205

   820 //////////////////////////////////////////////////////////////////////////

   821 

   822     virtual QCString trDeprecated()

   823     {

   824       return "Smerktina";

   825     }

   826 

   827 //////////////////////////////////////////////////////////////////////////

   828 // new since 1.0.0

   829 //////////////////////////////////////////////////////////////////////////

   830 

   831     /*! this text is put before a collaboration diagram */

   832     virtual QCString trCollaborationDiagram(const char *clName)

   833     {

   834       return (QCString)"Bendradarbiavimo diagrama "+clName+":";/*FIXME*/

   835     }

   836     /*! this text is put before an include dependency graph */

   837     virtual QCString trInclDepGraph(const char *fName)

   838     {

   839       return (QCString)"Įtraukimo priklausomybių diagrama "+fName+":";/*FIXME*/

   840     }

   841     /*! header that is put before the list of constructor/destructors. */

   842     virtual QCString trConstructorDocumentation()

   843     {

   844       return "Konstruktoriaus ir Destruktoriaus Dokumentacija";

   845     }

   846     /*! Used in the file documentation to point to the corresponding sources. */

   847     virtual QCString trGotoSourceCode()

   848     {

   849       return "Eiti į šio failo programos kodą.";

   850     }

   851     /*! Used in the file sources to point to the corresponding documentation. */

   852     virtual QCString trGotoDocumentation()

   853     {

   854       return "Eiti į šio failo dokumentaciją.";

   855     }

   856     /*! Text for the \\pre command */

   857     virtual QCString trPrecondition()

   858     {

   859       return "Išakstinė sąlyga";

   860     }

   861     /*! Text for the \\post command */

   862     virtual QCString trPostcondition()

   863     {

   864       return "Postcondition";/*FIXME*/

   865     }

   866     /*! Text for the \\invariant command */

   867     virtual QCString trInvariant()

   868     {

   869       return "Pastovus";

   870     }

   871     /*! Text shown before a multi-line variable/enum initialization */

   872     virtual QCString trInitialValue()

   873     {

   874       return "Pradinė reikšmė:";

   875     }

   876     /*! Text used the source code in the file index */

   877     virtual QCString trCode()

   878     {

   879       return "tekstas";/*FIXME*/

   880     }

   881     virtual QCString trGraphicalHierarchy()

   882     {

   883       return "Grafinė Klasės Hierarchija";

   884     }

   885     virtual QCString trGotoGraphicalHierarchy()

   886     {

   887       return "Eiti į grafinę klasės hierarchiją";

   888     }

   889     virtual QCString trGotoTextualHierarchy()

   890     {

   891       return "Eiti į tekstinę klasės hierarchiją";

   892     }

   893     virtual QCString trPageIndex()

   894     {

   895       return "Puslapio Indeksas";

   896     }

   897 

   898 //////////////////////////////////////////////////////////////////////////

   899 // new since 1.1.0

   900 //////////////////////////////////////////////////////////////////////////

   901 

   902     virtual QCString trNote()

   903     {

   904       return "Pastaba";

   905     }

   906     virtual QCString trPublicTypes()

   907     {

   908       return "Vieši Tipai";

   909     }

   910     virtual QCString trPublicAttribs()

   911     {

   912       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   913       {

   914         return "Duomenų Laukai";

   915       }

   916       else

   917       {

   918         return "Vieši Atributai";

   919       }

   920     }

   921     virtual QCString trStaticPublicAttribs()

   922     {

   923       return "Statiniai Vieši Atributai";

   924     }

   925     virtual QCString trProtectedTypes()

   926     {

   927       return "Apsaugoti Tipai";

   928     }

   929     virtual QCString trProtectedAttribs()

   930     {

   931       return "Apsaugoti Atributai";

   932     }

   933     virtual QCString trStaticProtectedAttribs()

   934     {

   935       return "Statiniai Apsaugoti Atributai";

   936     }

   937     virtual QCString trPrivateTypes()

   938     {

   939       return "Privatūs Tipai";

   940     }

   941     virtual QCString trPrivateAttribs()

   942     {

   943       return "Privatūs Atributai";

   944     }

   945     virtual QCString trStaticPrivateAttribs()

   946     {

   947       return "Statiniai Privatūs Atributai";

   948     }

   949 

   950 //////////////////////////////////////////////////////////////////////////

   951 // new since 1.1.3

   952 //////////////////////////////////////////////////////////////////////////

   953 

   954     /*! Used as a marker that is put before a \\todo item */

   955     virtual QCString trTodo()

   956     {

   957       return "Daryti";

   958     }

   959     /*! Used as the header of the todo list */

   960     virtual QCString trTodoList()

   961     {

   962       return "Tolimesni Darbai";

   963     }

   964     

   965 //////////////////////////////////////////////////////////////////////////

   966 // new since 1.1.4

   967 //////////////////////////////////////////////////////////////////////////

   968 

   969     virtual QCString trReferencedBy()

   970     {

   971       return "Naudojamas";

   972     }

   973     virtual QCString trRemarks()

   974     {

   975       return "Pastabos";

   976     }

   977     virtual QCString trAttention()

   978     {

   979       return "Attention";

   980     }

   981     virtual QCString trInclByDepGraph()

   982     {

   983       return "Šis grafas rodo, kuris failas tiesiogiai ar "

   984              "netiesiogiai įtraukia šį failą:";

   985     }

   986     virtual QCString trSince()

   987     {

   988       return "Nuo";

   989     }

   990     

   991 //////////////////////////////////////////////////////////////////////////

   992 // new since 1.1.5

   993 //////////////////////////////////////////////////////////////////////////

   994 

   995     /*! title of the graph legend page */

   996     virtual QCString trLegendTitle()

   997     {

   998       return "Grafo Legenda";

   999     }

  1000     /*! page explaining how the dot graph's should be interpreted 

  1001      *  The %A in the text below are to prevent link to classes called "A".

  1002      */

  1003     virtual QCString trLegendDocs()

  1004     {

  1005       return 

  1006         "Šis puslapis paaiškina, kaip interpretuoti sugeneruotus grafus "

  1007         "su Doxygen įrankiu.<p>\n"

  1008         "Panagrinėkite pavyzdį:\n"

  1009         "\\kodo pradžia\n"

  1010         "/*! Invisible class because of truncation */\n"

  1011         "class Invisible { };\n\n"

  1012         "/*! Truncated class, inheritance relation is hidden */\n"

  1013         "class Truncated : public Invisible { };\n\n"

  1014         "/* Class not documented with doxygen comments */\n"

  1015         "class Undocumented { };\n\n"

  1016         "/*! Class that is inherited using public inheritance */\n"

  1017         "class PublicBase : public Truncated { };\n\n"

  1018         "/*! A template class */\n"

  1019         "template<class T> class Templ { };\n\n"

  1020         "/*! Class that is inherited using protected inheritance */\n"

  1021         "class ProtectedBase { };\n\n"

  1022         "/*! Class that is inherited using private inheritance */\n"

  1023         "class PrivateBase { };\n\n"

  1024         "/*! Class that is used by the Inherited class */\n"

  1025         "class Used { };\n\n"

  1026         "/*! Super class that inherits a number of other classes */\n"

  1027         "class Inherited : public PublicBase,\n"

  1028         "                  protected ProtectedBase,\n"

  1029         "                  private PrivateBase,\n"

  1030         "                  public Undocumented,\n"

  1031         "                  public Templ<int>\n"

  1032         "{\n"

  1033         "  private:\n"

  1034         "    Used *m_usedClass;\n"

  1035         "};\n"

  1036         "\\endcode\n"

  1037         "If the \\c MAX_DOT_GRAPH_HEIGHT tag in the configuration file "

  1038         "is set to 240 this will result in the following graph:"

  1039         "<p><center><img alt=\"\" src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"

  1040         "<p>\n"

  1041         "The boxes in the above graph have the following meaning:\n"

  1042         "<ul>\n"

  1043         "<li>%A filled black box represents the struct or class for which the "

  1044         "graph is generated.\n"

  1045         "<li>%A box with a black border denotes a documented struct or class.\n"

  1046         "<li>%A box with a grey border denotes an undocumented struct or class.\n"

  1047         "<li>%A box with a red border denotes a documented struct or class for"

  1048         "which not all inheritance/containment relations are shown. %A graph is "

  1049         "truncated if it does not fit within the specified boundaries.\n"

  1050         "</ul>\n"

  1051         "The arrows have the following meaning:\n"

  1052         "<ul>\n"

  1053         "<li>%A dark blue arrow is used to visualize a public inheritance "

  1054         "relation between two classes.\n"

  1055         "<li>%A dark green arrow is used for protected inheritance.\n"

  1056         "<li>%A dark red arrow is used for private inheritance.\n"

  1057         "<li>%A purple dashed arrow is used if a class is contained or used "

  1058         "by another class. The arrow is labeled with the variable(s) "

  1059         "through which the pointed class or struct is accessible.\n"

  1060         "<li>%A yellow dashed arrow denotes a relation between a template instance and "

  1061         "the template class it was instantiated from. The arrow is labeled with "

  1062         "the template parameters of the instance.\n"

  1063         "</ul>\n";

  1064     }

  1065     /*! text for the link to the legend page */

  1066     virtual QCString trLegend()

  1067     {

  1068       return "legenda";

  1069     }

  1070     

  1071 //////////////////////////////////////////////////////////////////////////

  1072 // new since 1.2.0

  1073 //////////////////////////////////////////////////////////////////////////

  1074     

  1075     /*! Used as a marker that is put before a test item */

  1076     virtual QCString trTest()

  1077     {

  1078       return "Testas";

  1079     }

  1080     /*! Used as the header of the test list */

  1081     virtual QCString trTestList()

  1082     {

  1083       return "Testo Sąrašas";

  1084     }

  1085 

  1086 //////////////////////////////////////////////////////////////////////////

  1087 // new since 1.2.1

  1088 //////////////////////////////////////////////////////////////////////////

  1089 

  1090     /*! Used as a section header for KDE-2 IDL methods */

  1091     virtual QCString trDCOPMethods()

  1092     {

  1093       return "DCOP Metodai";

  1094     }

  1095 

  1096 //////////////////////////////////////////////////////////////////////////

  1097 // new since 1.2.2

  1098 //////////////////////////////////////////////////////////////////////////

  1099 

  1100     /*! Used as a section header for IDL properties */

  1101     virtual QCString trProperties()

  1102     {

  1103       return "Savybės";

  1104     }

  1105     /*! Used as a section header for IDL property documentation */

  1106     virtual QCString trPropertyDocumentation()

  1107     {

  1108       return "Savybės Dokumentacija";

  1109     }

  1110 

  1111 //////////////////////////////////////////////////////////////////////////

  1112 // new since 1.2.4

  1113 //////////////////////////////////////////////////////////////////////////

  1114 

  1115     /*! Used for Java classes in the summary section of Java packages */

  1116     virtual QCString trClasses()

  1117     {

  1118       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

  1119       {

  1120         return "Duomenų Struktūros";

  1121       }

  1122       else

  1123       {

  1124         return "Klasės";

  1125       }

  1126     }

  1127     /*! Used as the title of a Java package */

  1128     virtual QCString trPackage(const char *name)

  1129     {

  1130       return (QCString)"Paketas "+name;

  1131     }

  1132     /*! Title of the package index page */

  1133     virtual QCString trPackageList()

  1134     {