src/translator_lv.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_LV_H
  19 #define TRANSLATOR_LV_H
  20
  21 /*!
  22  When defining a translator class for the new language, follow
  23  the description in the documentation.  One of the steps says
  24  that you should copy the translator_en.h (this) file to your
  25  translator_xx.h new file.  Your new language should use the
  26  Translator class as the base class.  This means that you need to
  27  implement exactly the same (pure virtual) methods as the
  28  TranslatorEnglish does.  Because of this, it is a good idea to
  29  start with the copy of TranslatorEnglish and replace the strings
  30  one by one.
  31
  32  It is not necessary to include "translator.h" or
  33  "translator_adapter.h" here.  The files are included in the
  34  language.cpp correctly.  Not including any of the mentioned
  35  files frees the maintainer from thinking about whether the
  36  first, the second, or both files should be included or not, and
  37  why.  This holds namely for localized translators because their
  38  base class is changed occasionaly to adapter classes when the
  39  Translator class changes the interface, or back to the
  40  Translator class (by the local maintainer) when the localized
  41  translator is made up-to-date again.
  42 */
  43
  44 /* Translation from English to Latvian by Lauris Bukšis-Haberkorns
  45  *  (lauris@nix.lv)
  46  *  -------------------------------------------
  47  *  Project start                  : 24.Sept.2012
  48  *  Last Doxygen version covered   : 1.8.2
  49  */
  50
  51 class TranslatorLatvian : public TranslatorAdapter_1_8_4
  52 {
  53   public:
  54
  55     // --- Language control methods -------------------
  56
  57     /*! Used for identification of the language. The identification
  58      * should not be translated. It should be replaced by the name
  59      * of the language in English using lower-case characters only
  60      * (e.g. "czech", "japanese", "russian", etc.). It should be equal to
  61      * the identification used in language.cpp.
  62      */
  63     virtual QCString idLanguage()
  64     { return "latvian"; }
  65
  66     /*! Used to get the LaTeX command(s) for the language support.
  67      *  This method should return string with commands that switch
  68      *  LaTeX to the desired language.  For example
  69      *  <pre>"\\usepackage[german]{babel}\n"
  70      *  </pre>
  71      *  or
  72      *  <pre>"\\usepackage{polski}\n"
  73      *  "\\usepackage[latin2]{inputenc}\n"
  74      *  "\\usepackage[T1]{fontenc}\n"
  75      *  </pre>
  76      */
  77     virtual QCString latexLanguageSupportCommand()
  78     {
  79       return "\\usepackage[T2A]{fontenc}\n"
  80              "\\usepackage[latvian]{babel}\n";
  81     }
  82
  83     // --- Language translation methods -------------------
  84
  85     /*! used in the compound documentation before a list of related functions. */
  86     virtual QCString trRelatedFunctions()
  87     { return "Saistītās funkcijas"; }
  88
  89     /*! subscript for the related functions. */
  90     virtual QCString trRelatedSubscript()
  91     { return "(Šīs nav elementu funkcijas.)"; }
  92
  93     /*! header that is put before the detailed description of files, classes and namespaces. */
  94     virtual QCString trDetailedDescription()
  95     { return "Detalizēts apraksts"; }
  96
  97     /*! header that is put before the list of typedefs. */
  98     virtual QCString trMemberTypedefDocumentation()
  99     { return "Elementa Typedef dokumentācija"; }
 100
 101     /*! header that is put before the list of enumerations. */
 102     virtual QCString trMemberEnumerationDocumentation()
 103     { return "Elementa uzskaitījumliterāļa dokumentācija"; }
 104
 105     /*! header that is put before the list of member functions. */
 106     virtual QCString trMemberFunctionDocumentation()
 107     { return "Elementa funkcijas dokumentācija"; }
 108
 109     /*! header that is put before the list of member attributes. */
 110     virtual QCString trMemberDataDocumentation()
 111     {
 112       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 113       {
 114         return "Lauka dokumentācija";
 115       }
 116       else
 117       {
 118         return "Elementa datu dokumentācija";
 119       }
 120     }
 121
 122     /*! this is the text of a link put after brief descriptions. */
 123     virtual QCString trMore()
 124     { return "vairāk..."; }
 125
 126     /*! put in the class documentation */
 127     virtual QCString trListOfAllMembers()
 128     { return "Visu elementu saraksts"; }
 129
 130     /*! used as the title of the "list of all members" page of a class */
 131     virtual QCString trMemberList()
 132     { return "Elementu saraksts"; }
 133
 134     /*! this is the first part of a sentence that is followed by a class name */
 135     virtual QCString trThisIsTheListOfAllMembers()
 136     { return "Šis ir pilns elementu saraksts klasei "; }
 137
 138     /*! this is the remainder of the sentence after the class name */
 139     virtual QCString trIncludingInheritedMembers()
 140     { return ", ieskaitot mantotos elementus."; }
 141
 142     /*! this is put at the author sections at the bottom of man pages.
 143      *  parameter s is name of the project name.
 144      */
 145     virtual QCString trGeneratedAutomatically(const char *s)
 146     { QCString result="Automātiski ģenerēts izmantojot Doxygen";
 147       if (s) result+=(QCString)" priekš "+s;
 148       result+=" no pirmkoda.";
 149       return result;
 150     }
 151
 152     /*! put after an enum name in the list of all members */
 153     virtual QCString trEnumName()
 154     { return "uzskaitījuma nosaukums"; }
 155
 156     /*! put after an enum value in the list of all members */
 157     virtual QCString trEnumValue()
 158     { return "uzskaitījuma vērtība"; }
 159
 160     /*! put after an undocumented member in the list of all members */
 161     virtual QCString trDefinedIn()
 162     { return "definēts"; }
 163
 164     // quick reference sections
 165
 166     /*! This is put above each page as a link to the list of all groups of
 167      *  compounds or files (see the \\group command).
 168      */
 169     virtual QCString trModules()
 170     { return "Moduļi"; }
 171
 172     /*! This is put above each page as a link to the class hierarchy */
 173     virtual QCString trClassHierarchy()
 174     { return "Klašu hierarhija"; }
 175
 176     /*! This is put above each page as a link to the list of annotated classes */
 177     virtual QCString trCompoundList()
 178     {
 179       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 180       {
 181         return "Datu struktūras";
 182       }
 183       else
 184       {
 185         return "Klašu saraksts";
 186       }
 187     }
 188
 189     /*! This is put above each page as a link to the list of documented files */
 190     virtual QCString trFileList()
 191     { return "Failu saraksts"; }
 192
 193     /*! This is put above each page as a link to all members of compounds. */
 194     virtual QCString trCompoundMembers()
 195     {
 196       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 197       {
 198         return "Datu lauki";
 199       }
 200       else
 201       {
 202         return "Klases elementi";
 203       }
 204     }
 205
 206     /*! This is put above each page as a link to all members of files. */
 207     virtual QCString trFileMembers()
 208     {
 209       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 210       {
 211         return "Globālie";
 212       }
 213       else
 214       {
 215         return "Faila elementi";
 216       }
 217     }
 218
 219     /*! This is put above each page as a link to all related pages. */
 220     virtual QCString trRelatedPages()
 221     { return "Saistītās lapas"; }
 222
 223     /*! This is put above each page as a link to all examples. */
 224     virtual QCString trExamples()
 225     { return "Piemēri"; }
 226
 227     /*! This is put above each page as a link to the search engine. */
 228     virtual QCString trSearch()
 229     { return "Meklēt"; }
 230
 231     /*! This is an introduction to the class hierarchy. */
 232     virtual QCString trClassHierarchyDescription()
 233     { return "Šis mantojamības saraksts ir sakārtots aptuveni, "
 234              "bet ne pilnībā, alfabēta secībā:";
 235     }
 236
 237     /*! This is an introduction to the list with all files. */
 238     virtual QCString trFileListDescription(bool extractAll)
 239     {
 240       QCString result="Šeit ir visu ";
 241       if (!extractAll) result+="dokumentēto ";
 242       result+="failu saraksts ar īsu aprakstu:";
 243       return result;
 244     }
 245
 246     /*! This is an introduction to the annotated compound list. */
 247     virtual QCString trCompoundListDescription()
 248     {
 249
 250       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 251       {
 252         return "Šeit ir visas datu struktūras ar īsu aprakstu:";
 253       }
 254       else
 255       {
 256         return "Šeit ir visas klases, struktūras, "
 257                "apvienojumi un interfeisi ar īsu aprakstu:";
 258       }
 259     }
 260
 261     /*! This is an introduction to the page with all class members. */
 262     virtual QCString trCompoundMembersDescription(bool extractAll)
 263     {
 264       QCString result="Šeit ir visu ";
 265       if (!extractAll)
 266       {
 267         result+="dokumentēto ";
 268       }
 269       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 270       {
 271         result+="struktūru un apvienojumu lauku";
 272       }
 273       else
 274       {
 275         result+="klases elementu";
 276       }
 277       result+=" saraksts ar saitēm uz ";
 278       if (!extractAll)
 279       {
 280         if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 281         {
 282           result+="struktūru/apvienojumu dokumentāciju katram laukam:";
 283         }
 284         else
 285         {
 286           result+="klases dokumentāciju katram elementam:";
 287         }
 288       }
 289       else
 290       {
 291         if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 292         {
 293           result+="struktūrām/apvienojumiem, kam tie pieder:";
 294         }
 295         else
 296         {
 297           result+="klasēm, kam tie pieder:";
 298         }
 299       }
 300       return result;
 301     }
 302
 303     /*! This is an introduction to the page with all file members. */
 304     virtual QCString trFileMembersDescription(bool extractAll)
 305     {
 306       QCString result="Šeit ir visu ";
 307       if (!extractAll) result+="dokumentēto ";
 308
 309       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 310       {
 311         result+="funkciju, mainīgo, definīciju, uzskaitījumliterāļu un typedefs";
 312       }
 313       else
 314       {
 315         result+="faila elementu";
 316       }
 317       result+=" saraksts ar saitēm uz ";
 318       if (extractAll)
 319         result+="failiem, kam tie pieder:";
 320       else
 321         result+="dokumentāciju:";
 322       return result;
 323     }
 324
 325     /*! This is an introduction to the page with the list of all examples */
 326     virtual QCString trExamplesDescription()
 327     { return "Šeit ir visu piemēru saraksts:"; }
 328
 329     /*! This is an introduction to the page with the list of related pages */
 330     virtual QCString trRelatedPagesDescription()
 331     { return "Here is a list of all related documentation pages:"; }
 332
 333     /*! This is an introduction to the page with the list of class/file groups */
 334     virtual QCString trModulesDescription()
 335     { return "Šeit ir visu moduļu saraksts:"; }
 336
 337     // index titles (the project name is prepended for these)
 338
 339     /*! This is used in HTML as the title of index.html. */
 340     virtual QCString trDocumentation()
 341     { return "Dokumentācija"; }
 342
 343     /*! This is used in LaTeX as the title of the chapter with the
 344      * index of all groups.
 345      */
 346     virtual QCString trModuleIndex()
 347     { return "Moduļu indekss"; }
 348
 349     /*! This is used in LaTeX as the title of the chapter with the
 350      * class hierarchy.
 351      */
 352     virtual QCString trHierarchicalIndex()
 353     { return "Hierarhijas indekss"; }
 354
 355     /*! This is used in LaTeX as the title of the chapter with the
 356      * annotated compound index.
 357      */
 358     virtual QCString trCompoundIndex()
 359     {
 360       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 361       {
 362         return "Datu struktūru indess";
 363       }
 364       else
 365       {
 366         return "Klašu indekss";
 367       }
 368     }
 369
 370     /*! This is used in LaTeX as the title of the chapter with the
 371      * list of all files.
 372      */
 373     virtual QCString trFileIndex()
 374     { return "Failu indekss"; }
 375
 376     /*! This is used in LaTeX as the title of the chapter containing
 377      *  the documentation of all groups.
 378      */
 379     virtual QCString trModuleDocumentation()
 380     { return "Moduļa dokumentācija"; }
 381
 382     /*! This is used in LaTeX as the title of the chapter containing
 383      *  the documentation of all classes, structs and unions.
 384      */
 385     virtual QCString trClassDocumentation()
 386     {
 387       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 388       {
 389         return "Datu struktūras dokomentācija";
 390       }
 391       else
 392       {
 393         return "Klases dokumentācija";
 394       }
 395     }
 396
 397     /*! This is used in LaTeX as the title of the chapter containing
 398      *  the documentation of all files.
 399      */
 400     virtual QCString trFileDocumentation()
 401     { return "Faila dokumentācija"; }
 402
 403     /*! This is used in LaTeX as the title of the chapter containing
 404      *  the documentation of all examples.
 405      */
 406     virtual QCString trExampleDocumentation()
 407     { return "Piemēri"; }
 408
 409     /*! This is used in LaTeX as the title of the chapter containing
 410      *  the documentation of all related pages.
 411      */
 412     virtual QCString trPageDocumentation()
 413     { return "Lapas dokumentācija"; }
 414
 415     /*! This is used in LaTeX as the title of the document */
 416     virtual QCString trReferenceManual()
 417     { return "Rokasgrāmata"; }
 418
 419     /*! This is used in the documentation of a file as a header before the
 420      *  list of defines
 421      */
 422     virtual QCString trDefines()
 423     { return "Makro"; }
 424
 425     /*! This is used in the documentation of a file as a header before the
 426      *  list of typedefs
 427      */
 428     virtual QCString trTypedefs()
 429     { return "Typedefs"; }
 430
 431     /*! This is used in the documentation of a file as a header before the
 432      *  list of enumerations
 433      */
 434     virtual QCString trEnumerations()
 435     { return "Uzskaitījumi"; }
 436
 437     /*! This is used in the documentation of a file as a header before the
 438      *  list of (global) functions
 439      */
 440     virtual QCString trFunctions()
 441     { return "Funkcijas"; }
 442
 443     /*! This is used in the documentation of a file as a header before the
 444      *  list of (global) variables
 445      */
 446     virtual QCString trVariables()
 447     { return "Mainīgie"; }
 448
 449     /*! This is used in the documentation of a file as a header before the
 450      *  list of (global) variables
 451      */
 452     virtual QCString trEnumerationValues()
 453     { return "Uzskaitījumliterāļi"; }
 454
 455     /*! This is used in the documentation of a file before the list of
 456      *  documentation blocks for defines
 457      */
 458     virtual QCString trDefineDocumentation()
 459     { return "Makro definīcijas dokumentācija"; }
 460
 461     /*! This is used in the documentation of a file/namespace before the list
 462      *  of documentation blocks for typedefs
 463      */
 464     virtual QCString trTypedefDocumentation()
 465     { return "Typedef dokumentācija"; }
 466
 467     /*! This is used in the documentation of a file/namespace before the list
 468      *  of documentation blocks for enumeration types
 469      */
 470     virtual QCString trEnumerationTypeDocumentation()
 471     { return "Uzskaitījumliterāļa tipa dokumentācija"; }
 472
 473     /*! This is used in the documentation of a file/namespace before the list
 474      *  of documentation blocks for functions
 475      */
 476     virtual QCString trFunctionDocumentation()
 477     { return "Funkcijas dokumentācija"; }
 478
 479     /*! This is used in the documentation of a file/namespace before the list
 480      *  of documentation blocks for variables
 481      */
 482     virtual QCString trVariableDocumentation()
 483     { return "Mainīgo dokumentācija"; }
 484
 485     /*! This is used in the documentation of a file/namespace/group before
 486      *  the list of links to documented compounds
 487      */
 488     virtual QCString trCompounds()
 489     {
 490       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 491       {
 492         return "Datu struktūras";
 493       }
 494       else
 495       {
 496         return "Klases";
 497       }
 498     }
 499
 500     /*! This is used in the standard footer of each page and indicates when
 501      *  the page was generated
 502      */
 503     virtual QCString trGeneratedAt(const char *date,const char *projName)
 504     {
 505       QCString result=(QCString)"Ģenerēts "+date;
 506       if (projName) result+=(QCString)" projektam "+projName;
 507       result+=(QCString)" ar";
 508       return result;
 509     }
 510
 511     /*! this text is put before a class diagram */
 512     virtual QCString trClassDiagram(const char *clName)
 513     {
 514       return (QCString)"Mantojamības diagramma klasei "+clName+":";
 515     }
 516
 517     /*! this text is generated when the \\internal command is used. */
 518     virtual QCString trForInternalUseOnly()
 519     { return "Tikai iekšējai lietošanai."; }
 520
 521     /*! this text is generated when the \\warning command is used. */
 522     virtual QCString trWarning()
 523     { return "Brīdinājums"; }
 524
 525     /*! this text is generated when the \\version command is used. */
 526     virtual QCString trVersion()
 527     { return "Versija"; }
 528
 529     /*! this text is generated when the \\date command is used. */
 530     virtual QCString trDate()
 531     { return "Datums"; }
 532
 533     /*! this text is generated when the \\return command is used. */
 534     virtual QCString trReturns()
 535     { return "Atgriež"; }
 536
 537     /*! this text is generated when the \\sa command is used. */
 538     virtual QCString trSeeAlso()
 539     { return "Skatīties arī"; }
 540
 541     /*! this text is generated when the \\param command is used. */
 542     virtual QCString trParameters()
 543     { return "Parametri"; }
 544
 545     /*! this text is generated when the \\exception command is used. */
 546     virtual QCString trExceptions()
 547     { return "Izņēmumi"; }
 548
 549     /*! this text is used in the title page of a LaTeX document. */
 550     virtual QCString trGeneratedBy()
 551     { return "Ģenerēts ar"; }
 552
 553 //////////////////////////////////////////////////////////////////////////
 554 // new since 0.49-990307
 555 //////////////////////////////////////////////////////////////////////////
 556
 557     /*! used as the title of page containing all the index of all namespaces. */
 558     virtual QCString trNamespaceList()
 559     { return "Nosaukumvietu saraksts"; }
 560
 561     /*! used as an introduction to the namespace list */
 562     virtual QCString trNamespaceListDescription(bool extractAll)
 563     {
 564       QCString result="Šeit ir visas ";
 565       if (!extractAll) result+="dokumentētās ";
 566       result+="nosaukumvietas ar īsu aprakstu:";
 567       return result;
 568     }
 569
 570     /*! used in the class documentation as a header before the list of all
 571      *  friends of a class
 572      */
 573     virtual QCString trFriends()
 574     { return "Draugi"; }
 575
 576 //////////////////////////////////////////////////////////////////////////
 577 // new since 0.49-990405
 578 //////////////////////////////////////////////////////////////////////////
 579
 580     /*! used in the class documentation as a header before the list of all
 581      * related classes
 582      */
 583     virtual QCString trRelatedFunctionDocumentation()
 584     { return "Draugu un saistīto funkciju dokumentācija"; }
 585
 586 //////////////////////////////////////////////////////////////////////////
 587 // new since 0.49-990425
 588 //////////////////////////////////////////////////////////////////////////
 589
 590     /*! used as the title of the HTML page of a class/struct/union */
 591     virtual QCString trCompoundReference(const char *clName,
 592                                     ClassDef::CompoundType compType,
 593                                     bool isTemplate)
 594     {
 595       QCString result=(QCString)clName;
 596       switch(compType)
 597       {
 598         case ClassDef::Class:      result+=" klases"; break;
 599         case ClassDef::Struct:     result+=" struktūras"; break;
 600         case ClassDef::Union:      result+=" apvienojuma"; break;
 601         case ClassDef::Interface:  result+=" interfeisa"; break;
 602         case ClassDef::Protocol:   result+=" protokola"; break;
 603         case ClassDef::Category:   result+=" kategorijas"; break;
 604         case ClassDef::Exception:  result+=" izņēmuma"; break;
 605         default: break;
 606       }
 607       if (isTemplate) result+=" veidnes";
 608       result+=" apraksts";
 609       return result;
 610     }
 611
 612     /*! used as the title of the HTML page of a file */
 613     virtual QCString trFileReference(const char *fileName)
 614     {
 615       QCString result=fileName;
 616       result+=" faila apraksts";
 617       return result;
 618     }
 619
 620     /*! used as the title of the HTML page of a namespace */
 621     virtual QCString trNamespaceReference(const char *namespaceName)
 622     {
 623       QCString result=namespaceName;
 624       result+=" nosaukumvietas apraksts";
 625       return result;
 626     }
 627
 628     virtual QCString trPublicMembers()
 629     { return "Publiskās elementa funkcijas"; }
 630     virtual QCString trPublicSlots()
 631     { return "Publiskās spraugas"; }
 632     virtual QCString trSignals()
 633     { return "Signāli"; }
 634     virtual QCString trStaticPublicMembers()
 635     { return "Statiskās publiskās elementa funkcijas"; }
 636     virtual QCString trProtectedMembers()
 637     { return "Aizsargātās elementa funkcijas"; }
 638     virtual QCString trProtectedSlots()
 639     { return "Aizsargātās spraugas"; }
 640     virtual QCString trStaticProtectedMembers()
 641     { return "Statiskās aizsargātās elementa funkcijas"; }
 642     virtual QCString trPrivateMembers()
 643     { return "Privātās elementa funkcijas"; }
 644     virtual QCString trPrivateSlots()
 645     { return "Privātās spraugas"; }
 646     virtual QCString trStaticPrivateMembers()
 647     { return "Statiskās privātās elementa funkcijas"; }
 648
 649     /*! this function is used to produce a comma-separated list of items.
 650      *  use generateMarker(i) to indicate where item i should be put.
 651      */
 652     virtual QCString trWriteList(int numEntries)
 653     {
 654       QCString result;
 655       int i;
 656       // the inherits list contain `numEntries' classes
 657       for (i=0;i<numEntries;i++)
 658       {
 659         // use generateMarker to generate placeholders for the class links!
 660         result+=generateMarker(i); // generate marker for entry i in the list
 661                                    // (order is left to right)
 662
 663         if (i!=numEntries-1)  // not the last entry, so we need a separator
 664         {
 665           if (i<numEntries-2) // not the fore last entry
 666             result+=", ";
 667           else                // the fore last entry
 668             result+=", un ";
 669         }
 670       }
 671       return result;
 672     }
 673
 674     /*! used in class documentation to produce a list of base classes,
 675      *  if class diagrams are disabled.
 676      */
 677     virtual QCString trInheritsList(int numEntries)
 678     {
 679       return "Manto no "+trWriteList(numEntries)+".";
 680     }
 681
 682     /*! used in class documentation to produce a list of super classes,
 683      *  if class diagrams are disabled.
 684      */
 685     virtual QCString trInheritedByList(int numEntries)
 686     {
 687       return "Tiek mantots "+trWriteList(numEntries)+".";
 688     }
 689
 690     /*! used in member documentation blocks to produce a list of
 691      *  members that are hidden by this one.
 692      */
 693     virtual QCString trReimplementedFromList(int numEntries)
 694     {
 695       return "Pārimplementēts no "+trWriteList(numEntries)+".";
 696     }
 697
 698     /*! used in member documentation blocks to produce a list of
 699      *  all member that overwrite the implementation of this member.
 700      */
 701     virtual QCString trReimplementedInList(int numEntries)
 702     {
 703       return "Pārimplementēts "+trWriteList(numEntries)+".";
 704     }
 705
 706     /*! This is put above each page as a link to all members of namespaces. */
 707     virtual QCString trNamespaceMembers()
 708     { return "Nosaukumvietas elementi"; }
 709
 710     /*! This is an introduction to the page with all namespace members */
 711     virtual QCString trNamespaceMemberDescription(bool extractAll)
 712     {
 713       QCString result="Šeit ir visi ";
 714       if (!extractAll) result+="dokumentētie ";
 715       result+="nosaukumvietas elementi ar saitēm uz ";
 716       if (extractAll)
 717         result+="nosaukumvieta dokumentāciju katram elementam:";
 718       else
 719         result+="nosaukumvietu, kam tie pieder:";
 720       return result;
 721     }
 722     /*! This is used in LaTeX as the title of the chapter with the
 723      *  index of all namespaces.
 724      */
 725     virtual QCString trNamespaceIndex()
 726     { return "Nosaukumvietu indekss"; }
 727
 728     /*! This is used in LaTeX as the title of the chapter containing
 729      *  the documentation of all namespaces.
 730      */
 731     virtual QCString trNamespaceDocumentation()
 732     { return "Nosaukumvietas dokumentācija"; }
 733
 734 //////////////////////////////////////////////////////////////////////////
 735 // new since 0.49-990522
 736 //////////////////////////////////////////////////////////////////////////
 737
 738     /*! This is used in the documentation before the list of all
 739      *  namespaces in a file.
 740      */
 741     virtual QCString trNamespaces()
 742     { return "Nosaukumvietas"; }
 743
 744 //////////////////////////////////////////////////////////////////////////
 745 // new since 0.49-990728
 746 //////////////////////////////////////////////////////////////////////////
 747
 748     /*! This is put at the bottom of a class documentation page and is
 749      *  followed by a list of files that were used to generate the page.
 750      */
 751     virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
 752         bool single)
 753     { // single is true implies a single file
 754       QCString result=(QCString)"Šī";
 755       switch(compType)
 756       {
 757         case ClassDef::Class:      result+="s klases"; break;
 758         case ClassDef::Struct:     result+="s struktūras"; break;
 759         case ClassDef::Union:      result+=" apvienojuma"; break;
 760         case ClassDef::Interface:  result+=" interfeisa"; break;
 761         case ClassDef::Protocol:   result+=" protokola"; break;
 762         case ClassDef::Category:   result+="s kategorijas"; break;
 763         case ClassDef::Exception:  result+=" izņēmuma"; break;
 764         default: break;
 765       }
 766       result+=" dokumentācijas tika ģenerēta no šāda fail";
 767       if (single) result+="a:"; else result+="iem:";
 768       return result;
 769     }
 770
 771 //////////////////////////////////////////////////////////////////////////
 772 // new since 0.49-990901
 773 //////////////////////////////////////////////////////////////////////////
 774
 775     /*! This is used as the heading text for the retval command. */
 776     virtual QCString trReturnValues()
 777     { return "Atgriežamās vērtības"; }
 778
 779     /*! This is in the (quick) index as a link to the main page (index.html)
 780      */
 781     virtual QCString trMainPage()
 782     { return "Sākumlapa"; }
 783
 784     /*! This is used in references to page that are put in the LaTeX
 785      *  documentation. It should be an abbreviation of the word page.
 786      */
 787     virtual QCString trPageAbbreviation()
 788     { return "lpp."; }
 789
 790 //////////////////////////////////////////////////////////////////////////
 791 // new since 0.49-991003
 792 //////////////////////////////////////////////////////////////////////////
 793
 794     virtual QCString trDefinedAtLineInSourceFile()
 795     {
 796       return "Definēts līnijā @0 failā @1.";
 797     }
 798     virtual QCString trDefinedInSourceFile()
 799     {
 800       return "Definēts failā @0.";
 801     }
 802
 803 //////////////////////////////////////////////////////////////////////////
 804 // new since 0.49-991205
 805 //////////////////////////////////////////////////////////////////////////
 806
 807     virtual QCString trDeprecated()
 808     {
 809       return "Novecojusi";
 810     }
 811
 812 //////////////////////////////////////////////////////////////////////////
 813 // new since 1.0.0
 814 //////////////////////////////////////////////////////////////////////////
 815
 816     /*! this text is put before a collaboration diagram */
 817     virtual QCString trCollaborationDiagram(const char *clName)
 818     {
 819       return (QCString)"Sadarbības diagramma klasei "+clName+":";
 820     }
 821     /*! this text is put before an include dependency graph */
 822     virtual QCString trInclDepGraph(const char *fName)
 823     {
 824       return (QCString)"Include dependency graph for "+fName+":";
 825     }
 826     /*! header that is put before the list of constructor/destructors. */
 827     virtual QCString trConstructorDocumentation()
 828     {
 829       return "Konstruktora un destruktora dokumentācija";
 830     }
 831     /*! Used in the file documentation to point to the corresponding sources. */
 832     virtual QCString trGotoSourceCode()
 833     {
 834       return "Iet uz šī faila pirmkodu.";
 835     }
 836     /*! Used in the file sources to point to the corresponding documentation. */
 837     virtual QCString trGotoDocumentation()
 838     {
 839       return "Ietu uz šī faila dokumentāciju.";
 840     }
 841     /*! Text for the \\pre command */
 842     virtual QCString trPrecondition()
 843     {
 844       return "Pirmsnosacījums";
 845     }
 846     /*! Text for the \\post command */
 847     virtual QCString trPostcondition()
 848     {
 849       return "Pēcnosacījums";
 850     }
 851     /*! Text for the \\invariant command */
 852     virtual QCString trInvariant()
 853     {
 854       return "Invariants";
 855     }
 856     /*! Text shown before a multi-line variable/enum initialization */
 857     virtual QCString trInitialValue()
 858     {
 859       return "Sākotnējā vērtība:";
 860     }
 861     /*! Text used the source code in the file index */
 862     virtual QCString trCode()
 863     {
 864       return "pirmkods";
 865     }
 866     virtual QCString trGraphicalHierarchy()
 867     {
 868       return "Grafiska klases hierarhija";
 869     }
 870     virtual QCString trGotoGraphicalHierarchy()
 871     {
 872       return "Iet uz grafisku klases hierarhiju";
 873     }
 874     virtual QCString trGotoTextualHierarchy()
 875     {
 876       return "Iet uz tekstuālu klases hierarhiju";
 877     }
 878     virtual QCString trPageIndex()
 879     {
 880       return "Lapas indekss";
 881     }
 882
 883 //////////////////////////////////////////////////////////////////////////
 884 // new since 1.1.0
 885 //////////////////////////////////////////////////////////////////////////
 886
 887     virtual QCString trNote()
 888     {
 889       return "Piezīme";
 890     }
 891     virtual QCString trPublicTypes()
 892     {
 893       return "Publiskie tipi";
 894     }
 895     virtual QCString trPublicAttribs()
 896     {
 897       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
 898       {
 899         return "Datu lauki";
 900       }
 901       else
 902       {
 903         return "Publiskie atribūti";
 904       }
 905     }
 906     virtual QCString trStaticPublicAttribs()
 907     {
 908       return "Statiskie publiskie atribūti";
 909     }
 910     virtual QCString trProtectedTypes()
 911     {
 912       return "Aizsargātie tipi";
 913     }
 914     virtual QCString trProtectedAttribs()
 915     {
 916       return "Aizsargātie atribūti";
 917     }
 918     virtual QCString trStaticProtectedAttribs()
 919     {
 920       return "Statiskie aizsargātie atribūti";
 921     }
 922     virtual QCString trPrivateTypes()
 923     {
 924       return "Privātie tipi";
 925     }
 926     virtual QCString trPrivateAttribs()
 927     {
 928       return "Privātie atribūti";
 929     }
 930     virtual QCString trStaticPrivateAttribs()
 931     {
 932       return "Statiskie privātie atribūti";
 933     }
 934
 935 //////////////////////////////////////////////////////////////////////////
 936 // new since 1.1.3
 937 //////////////////////////////////////////////////////////////////////////
 938
 939     /*! Used as a marker that is put before a \\todo item */
 940     virtual QCString trTodo()
 941     {
 942       return "Jāizdara";
 943     }
 944     /*! Used as the header of the todo list */
 945     virtual QCString trTodoList()
 946     {
 947       return "Darāmo darbu saraksts";
 948     }
 949
 950 //////////////////////////////////////////////////////////////////////////
 951 // new since 1.1.4
 952 //////////////////////////////////////////////////////////////////////////
 953
 954     virtual QCString trReferencedBy()
 955     {
 956       return "Atsauces no";
 957     }
 958     virtual QCString trRemarks()
 959     {
 960       return "Piebildes";
 961     }
 962     virtual QCString trAttention()
 963     {
 964       return "Uzmanību";
 965     }
 966     virtual QCString trInclByDepGraph()
 967     {
 968       return "Šis grafs rāda kuri faili tieši vai "
 969              "netieši iekļauj šo failu:";
 970     }
 971     virtual QCString trSince()
 972     {
 973       return "Kopš";
 974     }
 975
 976 //////////////////////////////////////////////////////////////////////////
 977 // new since 1.1.5
 978 //////////////////////////////////////////////////////////////////////////
 979
 980     /*! title of the graph legend page */
 981     virtual QCString trLegendTitle()
 982     {
 983       return "Grafika leģenda";
 984     }
 985     /*! page explaining how the dot graph's should be interpreted
 986      *  The %A in the text below are to prevent link to classes called "A".
 987      */
 988     virtual QCString trLegendDocs()
 989     {
 990       return
 991         "This page explains how to interpret the graphs that are generated "
 992         "by doxygen.<p>\n"
 993         "Consider the following example:\n"
 994         "\\code\n"
 995         "/*! Invisible class because of truncation */\n"
 996         "class Invisible { };\n\n"
 997         "/*! Truncated class, inheritance relation is hidden */\n"
 998         "class Truncated : public Invisible { };\n\n"
 999         "/* Class not documented with doxygen comments */\n"
1000         "class Undocumented { };\n\n"
1001         "/*! Class that is inherited using public inheritance */\n"
1002         "class PublicBase : public Truncated { };\n\n"
1003         "/*! A template class */\n"
1004         "template<class T> class Templ { };\n\n"
1005         "/*! Class that is inherited using protected inheritance */\n"
1006         "class ProtectedBase { };\n\n"
1007         "/*! Class that is inherited using private inheritance */\n"
1008         "class PrivateBase { };\n\n"
1009         "/*! Class that is used by the Inherited class */\n"
1010         "class Used { };\n\n"
1011         "/*! Super class that inherits a number of other classes */\n"
1012         "class Inherited : public PublicBase,\n"
1013         "                  protected ProtectedBase,\n"
1014         "                  private PrivateBase,\n"
1015         "                  public Undocumented,\n"
1016         "                  public Templ<int>\n"
1017         "{\n"
1018         "  private:\n"
1019         "    Used *m_usedClass;\n"
1020         "};\n"
1021         "\\endcode\n"
1022         "This will result in the following graph:"
1023         "<p><center><img alt=\"\" src=\"graph_legend."+getDotImageExtension()+"\"></center></p>\n"
1024         "<p>\n"
1025         "The boxes in the above graph have the following meaning:\n"
1026         "</p>\n"
1027         "<ul>\n"
1028         "<li>%A filled gray box represents the struct or class for which the "
1029         "graph is generated.</li>\n"
1030         "<li>%A box with a black border denotes a documented struct or class.</li>\n"
1031         "<li>%A box with a gray border denotes an undocumented struct or class.</li>\n"
1032         "<li>%A box with a red border denotes a documented struct or class for"
1033         "which not all inheritance/containment relations are shown. %A graph is "
1034         "truncated if it does not fit within the specified boundaries.</li>\n"
1035         "</ul>\n"
1036         "<p>\n"
1037         "The arrows have the following meaning:\n"
1038         "</p>\n"
1039         "<ul>\n"
1040         "<li>%A dark blue arrow is used to visualize a public inheritance "
1041         "relation between two classes.</li>\n"
1042         "<li>%A dark green arrow is used for protected inheritance.</li>\n"
1043         "<li>%A dark red arrow is used for private inheritance.</li>\n"
1044         "<li>%A purple dashed arrow is used if a class is contained or used "
1045         "by another class. The arrow is labeled with the variable(s) "
1046         "through which the pointed class or struct is accessible.</li>\n"
1047         "<li>%A yellow dashed arrow denotes a relation between a template instance and "
1048         "the template class it was instantiated from. The arrow is labeled with "
1049         "the template parameters of the instance.</li>\n"
1050         "</ul>\n";
1051     }
1052     /*! text for the link to the legend page */
1053     virtual QCString trLegend()
1054     {
1055       return "leģenda";
1056     }
1057
1058 //////////////////////////////////////////////////////////////////////////
1059 // new since 1.2.0
1060 //////////////////////////////////////////////////////////////////////////
1061
1062     /*! Used as a marker that is put before a test item */
1063     virtual QCString trTest()
1064     {
1065       return "Testi";
1066     }
1067     /*! Used as the header of the test list */
1068     virtual QCString trTestList()
1069     {
1070       return "Testu saraksts";
1071     }
1072
1073 //////////////////////////////////////////////////////////////////////////
1074 // new since 1.2.2
1075 //////////////////////////////////////////////////////////////////////////
1076
1077     /*! Used as a section header for IDL properties */
1078     virtual QCString trProperties()
1079     {
1080       return "Rekvizīti";
1081     }
1082     /*! Used as a section header for IDL property documentation */
1083     virtual QCString trPropertyDocumentation()
1084     {
1085       return "Rekvizītu dokumentācija";
1086     }
1087
1088 //////////////////////////////////////////////////////////////////////////
1089 // new since 1.2.4
1090 //////////////////////////////////////////////////////////////////////////
1091
1092     /*! Used for Java classes in the summary section of Java packages */
1093     virtual QCString trClasses()
1094     {
1095       if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
1096       {
1097         return "Datu struktūras";
1098       }
1099       else
1100       {
1101         return "Klases";
1102       }
1103     }
1104     /*! Used as the title of a Java package */
1105     virtual QCString trPackage(const char *name)
1106     {
1107       return (QCString)"Pakotne "+name;
1108     }
1109     /*! Title of the package index page */
1110     virtual QCString trPackageList()
1111     {
1112       return "Pakotņu saraksts";
1113     }
1114     /*! The description of the package index page */
1115     virtual QCString trPackageListDescription()
1116     {
1117       return "Here are the packages with brief descriptions (if available):";
1118     }
1119     /*! The link name in the Quick links header for each page */
1120     virtual QCString trPackages()
1121     {
1122       return "Pakotnes";
1123     }
1124     /*! Text shown before a multi-line define */
1125     virtual QCString trDefineValue()
1126     {
1127       return "Vērtība:";
1128     }
1129
1130 //////////////////////////////////////////////////////////////////////////
1131 // new since 1.2.5
1132 //////////////////////////////////////////////////////////////////////////
1133
1134     /*! Used as a marker that is put before a \\bug item */
1135     virtual QCString trBug()
1136     {
1137       return "Kļūda";
1138     }
1139     /*! Used as the header of the bug list */
1140     virtual QCString trBugList()
1141     {
1142       return "Kļūdu saraksts";
1143     }
1144
1145 //////////////////////////////////////////////////////////////////////////
1146 // new since 1.2.6
1147 //////////////////////////////////////////////////////////////////////////
1148
1149     /*! Used as ansicpg for RTF file
1150      *
1151      * The following table shows the correlation of Charset name, Charset Value and
1152      * <pre>
1153      * Codepage number:
1154      * Charset Name       Charset Value(hex)  Codepage number
1155      * ------------------------------------------------------
1156      * DEFAULT_CHARSET           1 (x01)
1157      * SYMBOL_CHARSET            2 (x02)
1158      * OEM_CHARSET             255 (xFF)
1159      * ANSI_CHARSET              0 (x00)            1252
1160      * RUSSIAN_CHARSET         204 (xCC)            1251
1161      * EE_CHARSET              238 (xEE)            1250
1162      * GREEK_CHARSET           161 (xA1)            1253
1163      * TURKISH_CHARSET         162 (xA2)            1254
1164      * BALTIC_CHARSET          186 (xBA)            1257
1165      * HEBREW_CHARSET          177 (xB1)            1255
1166      * ARABIC _CHARSET         178 (xB2)            1256
1167      * SHIFTJIS_CHARSET        128 (x80)             932
1168      * HANGEUL_CHARSET         129 (x81)             949
1169      * GB2313_CHARSET          134 (x86)             936
1170      * CHINESEBIG5_CHARSET     136 (x88)             950
1171      * </pre>
1172      *
1173      */
1174     virtual QCString trRTFansicp()
1175     {
1176       return "1257";
1177     }
1178
1179
1180     /*! Used as ansicpg for RTF fcharset
1181      *  \see trRTFansicp() for a table of possible values.
1182      */
1183     virtual QCString trRTFCharSet()
1184     {
1185       return "186";
1186     }
1187
1188     /*! Used as header RTF general index */
1189     virtual QCString trRTFGeneralIndex()
1190     {
1191       return "Indekss";
1192     }
1193
1194     /*! This is used for translation of the word that will possibly
1195      *  be followed by a single name or by a list of names
1196      *  of the category.
1197      */
1198     virtual QCString trClass(bool first_capital, bool singular)
1199     {
1200       QCString result((first_capital ? "Klase" : "klase"));
1201       if (!singular)  result+="s";
1202       return result;
1203     }
1204
1205     /*! This is used for translation of the word that will possibly
1206      *  be followed by a single name or by a list of names
1207      *  of the category.
1208      */
1209     virtual QCString trFile(bool first_capital, bool singular)
1210     {
1211       QCString result((first_capital ? "Fail" : "fail"));
1212       if (singular) result+="s"; else result+="i";
1213       return result;
1214     }
1215
1216     /*! This is used for translation of the word that will possibly
1217      *  be followed by a single name or by a list of names
1218      *  of the category.
1219      */
1220     virtual QCString trNamespace(bool first_capital, bool singular)
1221     {
1222       QCString result((first_capital ? "Nosaukumvieta" : "nosaukumvieta"));
1223       if (!singular)  result+="s";
1224       return result;
1225     }
1226
1227     /*! This is used for translation of the word that will possibly
1228      *  be followed by a single name or by a list of names
1229      *  of the category.
1230      */
1231     virtual QCString trGroup(bool first_capital, bool singular)
1232     {
1233       QCString result((first_capital ? "Grupa" : "grupa"));
1234       if (!singular)  result+="s";
1235       return result;
1236     }
1237
1238     /*! This is used for translation of the word that will possibly
1239      *  be followed by a single name or by a list of names
1240      *  of the category.
1241      */
1242     virtual QCString trPage(bool first_capital, bool singular)
1243     {
1244       QCString result((first_capital ? "Lapa" : "lapa"));
1245       if (!singular)  result+="s";
1246       return result;
1247     }
1248
1249     /*! This is used for translation of the word that will possibly
1250      *  be followed by a single name or by a list of names
1251      *  of the category.
1252      */
1253     virtual QCString trMember(bool first_capital, bool singular)
1254     {
1255       QCString result((first_capital ? "Element" : "element"));
1256       if (singular) result+="s"; else result+="i";
1257       return result;
1258     }
1259
1260     /*! This is used for translation of the word that will possibly
1261      *  be followed by a single name or by a list of names
1262      *  of the category.
1263      */
1264     virtual QCString trGlobal(bool first_capital, bool singular)
1265     {
1266       QCString result((first_capital ? "Globāl" : "globāl"));
1267       if (singular) result+="ais"; else result+="ie";
1268       return result;
1269     }
1270
1271 //////////////////////////////////////////////////////////////////////////
1272 // new since 1.2.7
1273 //////////////////////////////////////////////////////////////////////////
1274
1275     /*! This text is generated when the \\author command is used and
1276      *  for the author section in man pages. */
1277     virtual QCString trAuthor(bool first_capital, bool singular)
1278     {
1279       QCString result((first_capital ? "Autor" : "autor"));
1280       if (singular) result+="s"; else result+="i";
1281       return result;
1282     }
1283
1284 //////////////////////////////////////////////////////////////////////////
1285 // new since 1.2.11
1286 //////////////////////////////////////////////////////////////////////////
1287
1288     /*! This text is put before the list of members referenced by a member
1289      */
1290     virtual QCString trReferences()
1291     {
1292       return "Atsauces";
1293     }
1294
1295 //////////////////////////////////////////////////////////////////////////
1296 // new since 1.2.13
1297 //////////////////////////////////////////////////////////////////////////
1298
1299     /*! used in member documentation blocks to produce a list of
1300      *  members that are implemented by this one.
1301      */
1302     virtual QCString trImplementedFromList(int numEntries)
1303     {
1304       return "Īsteno "+trWriteList(numEntries)+".";
1305     }
1306
1307     /*! used in member documentation blocks to produce a list of
1308      *  all members that implement this abstract member.
1309      */
1310     virtual QCString trImplementedInList(int numEntries)
1311     {
1312       return "Īstenots "+trWriteList(numEntries)+".";
1313     }
1314
1315 //////////////////////////////////////////////////////////////////////////
1316 // new since 1.2.16
1317 //////////////////////////////////////////////////////////////////////////
1318
1319     /*! used in RTF documentation as a heading for the Table
1320      *  of Contents.
1321      */
1322     virtual QCString trRTFTableOfContents()
1323     {
1324       return "Satura rādītājs";
1325     }
1326
1327 //////////////////////////////////////////////////////////////////////////
1328 // new since 1.2.17
1329 //////////////////////////////////////////////////////////////////////////
1330
1331     /*! Used as the header of the list of item that have been
1332      *  flagged deprecated
1333      */
1334     virtual QCString trDeprecatedList()
1335     {
1336       return "Novecojušo saraksts";
1337     }
1338
1339 //////////////////////////////////////////////////////////////////////////
1340 // new since 1.2.18
1341 //////////////////////////////////////////////////////////////////////////
1342
1343     /*! Used as a header for declaration section of the events found in
1344      * a C# program
1345      */
1346     virtual QCString trEvents()
1347     {
1348       return "Notikumi";
1349     }
1350     /*! Header used for the documentation section of a class' events. */
1351     virtual QCString trEventDocumentation()
1352     {
1353       return "Notikumu dokumentācija";
1354     }
1355
1356 //////////////////////////////////////////////////////////////////////////
1357 // new since 1.3
1358 //////////////////////////////////////////////////////////////////////////
1359
1360     /*! Used as a heading for a list of Java class types with package scope.
1361      */
1362     virtual QCString trPackageTypes()
1363     {
1364       return "Pakas tipi";
1365     }
1366     /*! Used as a heading for a list of Java class functions with package
1367      * scope.
1368      */
1369     virtual QCString trPackageMembers()
1370     {
1371       return "Pakas funkcijas";
1372     }
1373     /*! Used as a heading for a list of static Java class functions with
1374      *  package scope.
1375      */
1376     virtual QCString trStaticPackageMembers()
1377     {
1378       return "Statiskās pakas funkcijas";
1379     }
1380     /*! Used as a heading for a list of Java class variables with package
1381      * scope.
1382      */
1383     virtual QCString trPackageAttribs()
1384     {
1385       return "Pakas atribūti";
1386     }
1387     /*! Used as a heading for a list of static Java class variables with
1388      * package scope.
1389      */
1390     virtual QCString trStaticPackageAttribs()
1391     {
1392       return "Statiskie pakas atribūti";
1393     }
1394
1395 //////////////////////////////////////////////////////////////////////////
1396 // new since 1.3.1
1397 //////////////////////////////////////////////////////////////////////////
1398
1399     /*! Used in the quick index of a class/file/namespace member list page
1400      *  to link to the unfiltered list of all members.
1401      */
1402     virtual QCString trAll()
1403     {
1404       return "Visi";
1405     }
1406     /*! Put in front of the call graph for a function. */
1407     virtual QCString trCallGraph()
1408     {
1409       return "Šeit ir visu funkciju izsaugumu grafs:";
1410     }
1411
1412 //////////////////////////////////////////////////////////////////////////
1413 // new since 1.3.3
1414 //////////////////////////////////////////////////////////////////////////
1415
1416     /*! This string is used as the title for the page listing the search
1417      *  results.
1418      */
1419     virtual QCString trSearchResultsTitle()
1420     {
1421       return "Meklēšanas rezultāti";
1422     }
1423     /*! This string is put just before listing the search results. The
1424      *  text can be different depending on the number of documents found.
1425      *  Inside the text you can put the special marker $num to insert
1426      *  the number representing the actual number of search results.
1427      *  The @a numDocuments parameter can be either 0, 1 or 2, where the
1428      *  value 2 represents 2 or more matches. HTML markup is allowed inside
1429      *  the returned string.
1430      */
1431     virtual QCString trSearchResults(int numDocuments)
1432     {
1433       if (numDocuments==0)
1434       {
1435         return "Netika atrasts neviens dokuments.";
1436       }
1437       else if (numDocuments==1)
1438       {
1439         return "Atrasts <b>1</b> dokuments.";
1440       }
1441       else
1442       {
1443         return "Atrasti <b>$num</b> Dokumenti. "
1444                "Sākumā attēlo tos, kas atbilst visprecīzāk.";
1445       }
1446     }
1447     /*! This string is put before the list of matched words, for each search
1448      *  result. What follows is the list of words that matched the query.
1449      */
1450     virtual QCString trSearchMatches()
1451     {
1452       return "Atbilst meklētajam:";
1453     }
1454
1455 //////////////////////////////////////////////////////////////////////////
1456 // new since 1.3.8
1457 //////////////////////////////////////////////////////////////////////////
1458
1459     /*! This is used in HTML as the title of page with source code for file filename
1460      */
1461     virtual QCString trSourceFile(QCString& filename)
1462     {
1463       return filename + " pirmkoda fails";
1464     }
1465
1466 //////////////////////////////////////////////////////////////////////////
1467 // new since 1.3.9
1468 //////////////////////////////////////////////////////////////////////////
1469
1470     /*! This is used as the name of the chapter containing the directory
1471      *  hierarchy.
1472      */
1473     virtual QCString trDirIndex()
1474     { return "Direktoriju struktūra"; }
1475
1476     /*! This is used as the name of the chapter containing the documentation
1477      *  of the directories.
1478      */
1479     virtual QCString trDirDocumentation()
1480     { return "Direktorijas dokumentācija"; }
1481
1482     /*! This is used as the title of the directory index and also in the
1483      *  Quick links of an HTML page, to link to the directory hierarchy.
1484      */
1485     virtual QCString trDirectories()
1486     { return "Direktorijas"; }
1487
1488     /*! This returns a sentences that introduces the directory hierarchy.
1489      *  and the fact that it is sorted alphabetically per level
1490      */
1491     virtual QCString trDirDescription()
1492     { return "Šī direktoriju hierarhija ir aptuveni, "
1493              "bet ne pilnībā, alfabēta secībā:";
1494     }
1495
1496     /*! This returns the title of a directory page. The name of the
1497      *  directory is passed via \a dirName.
1498      */
1499     virtual QCString trDirReference(const char *dirName)
1500     { QCString result="Direktorijas "; result+=dirName; result+=" atsauce"; return result; }
1501
1502     /*! This returns the word directory with or without starting capital
1503      *  (\a first_capital) and in sigular or plural form (\a singular).
1504      */
1505     virtual QCString trDir(bool first_capital, bool singular)
1506     {
1507       QCString result((first_capital ? "Direktorija" : "direktorija"));
1508       if (!singular) result+="s";
1509       return result;
1510     }
1511
1512 //////////////////////////////////////////////////////////////////////////
1513 // new since 1.4.1
1514 //////////////////////////////////////////////////////////////////////////
1515
1516     /*! This text is added to the documentation when the \\overload command
1517      *  is used for a overloaded function.
1518      */
1519     virtual QCString trOverloadText()
1520     {
1521        return "Šī ir elementa pārslogota funkcija, kas "
1522               "parādīta tikai informātīvo nolūkos. Tā atšķiras no iepriekšapraksītās "
1523               "funkcijas tikai ar parametriem, ko tā saņem.";
1524     }
1525
1526 //////////////////////////////////////////////////////////////////////////
1527 // new since 1.4.6
1528 //////////////////////////////////////////////////////////////////////////
1529
1530     /*! This is used to introduce a caller (or called-by) graph */
1531     virtual QCString trCallerGraph()
1532     {
1533       return "Šeit ir šīs funkcijas izsaukuma grafs:";
1534     }
1535
1536     /*! This is used in the documentation of a file/namespace before the list
1537      *  of documentation blocks for enumeration values
1538      */
1539     virtual QCString trEnumerationValueDocumentation()
1540     { return "Uzskaitījumliterāļa dokumentācija"; }
1541
1542 //////////////////////////////////////////////////////////////////////////
1543 // new since 1.5.4 (mainly for Fortran)
1544 //////////////////////////////////////////////////////////////////////////
1545
1546     /*! header that is put before the list of member subprograms (Fortran). */
1547     virtual QCString trMemberFunctionDocumentationFortran()
1548     { return "Elementa funckijas/apakšrutīnas dokumentācija"; }
1549
1550     /*! This is put above each page as a link to the list of annotated data types (Fortran). */
1551     virtual QCString trCompoundListFortran()
1552     { return "Datu tipu saraksts"; }
1553
1554     /*! This is put above each page as a link to all members of compounds (Fortran). */
1555     virtual QCString trCompoundMembersFortran()
1556     { return "Datu lauki"; }
1557
1558     /*! This is an introduction to the annotated compound list (Fortran). */
1559     virtual QCString trCompoundListDescriptionFortran()
1560     { return "Šeit ir visu datu tipu saraksts ar īsu aprakstu:"; }
1561
1562     /*! This is an introduction to the page with all data types (Fortran). */
1563     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
1564     {
1565       QCString result="Šeit ir visu ";
1566       if (!extractAll)
1567       {
1568         result+="dokumentēto ";
1569       }
1570       result+="datu tipu saraksts";
1571       result+=" ar saitēm uz ";
1572       if (!extractAll)
1573       {
1574          result+="datu struktūras dokumentāciju katram elementam:";
1575       }
1576       else
1577       {
1578          result+="datu tipiem, kam tie pieder:";
1579       }
1580       return result;
1581     }
1582
1583     /*! This is used in LaTeX as the title of the chapter with the
1584      * annotated compound index (Fortran).
1585      */
1586     virtual QCString trCompoundIndexFortran()
1587     { return "Datu tipu indekss"; }
1588
1589     /*! This is used in LaTeX as the title of the chapter containing
1590      *  the documentation of all data types (Fortran).
1591      */
1592     virtual QCString trTypeDocumentation()
1593     { return "Datu tipa dokumentācija"; }
1594
1595     /*! This is used in the documentation of a file as a header before the
1596      *  list of (global) subprograms (Fortran).
1597      */
1598     virtual QCString trSubprograms()
1599     { return "Funkcijas/Apakšrutīnas"; }
1600
1601     /*! This is used in the documentation of a file/namespace before the list
1602      *  of documentation blocks for subprograms (Fortran)
1603      */
1604     virtual QCString trSubprogramDocumentation()
1605     { return "Funkcijas/Apakšrutīnas dokumentācija"; }
1606
1607     /*! This is used in the documentation of a file/namespace/group before
1608      *  the list of links to documented compounds (Fortran)
1609      */
1610      virtual QCString trDataTypes()
1611     { return "Datu tipi"; }
1612
1613     /*! used as the title of page containing all the index of all modules (Fortran). */
1614     virtual QCString trModulesList()
1615     { return "Moduļu saraksts"; }
1616
1617     /*! used as an introduction to the modules list (Fortran) */
1618     virtual QCString trModulesListDescription(bool extractAll)
1619     {
1620       QCString result="Šeit ir visu ";
1621       if (!extractAll) result+="dokumentēto ";
1622       result+="moduļu saraksts ar īsu aprakstu:";
1623       return result;
1624     }
1625
1626     /*! used as the title of the HTML page of a module/type (Fortran) */
1627     virtual QCString trCompoundReferenceFortran(const char *clName,
1628                                     ClassDef::CompoundType compType,
1629                                     bool isTemplate)
1630     {
1631       QCString result=(QCString)clName;
1632       switch(compType)
1633       {
1634         case ClassDef::Class:      result+=" moduļa"; break;
1635         case ClassDef::Struct:     result+=" tipa"; break;
1636         case ClassDef::Union:      result+=" apvienojuma"; break;
1637         case ClassDef::Interface:  result+=" interfeisa"; break;
1638         case ClassDef::Protocol:   result+=" protokola"; break;
1639         case ClassDef::Category:   result+=" kategorijas"; break;
1640         case ClassDef::Exception:  result+=" izņēmuma"; break;
1641         default: break;
1642       }
1643       if (isTemplate) result+=" sagataves";
1644       result+=" atsauce";
1645       return result;
1646     }
1647     /*! used as the title of the HTML page of a module (Fortran) */
1648     virtual QCString trModuleReference(const char *namespaceName)
1649     {
1650       QCString result=namespaceName;
1651       result+=" moduļu atsauce";
1652       return result;
1653     }
1654
1655     /*! This is put above each page as a link to all members of modules. (Fortran) */
1656     virtual QCString trModulesMembers()
1657     { return "Moduļa elementi"; }
1658
1659     /*! This is an introduction to the page with all modules members (Fortran) */
1660     virtual QCString trModulesMemberDescription(bool extractAll)
1661     {
1662       QCString result="Šeit ir visu ";
1663       if (!extractAll) result+="dokumentēto ";
1664       result+="moduļa elementu saraksts ar saitēm uz ";
1665       if (extractAll)
1666       {
1667         result+="moduļa dokumentāciju katram elementam:";
1668       }
1669       else
1670       {
1671         result+="moduļiem, kuriem tie pieder:";
1672       }
1673       return result;
1674     }
1675
1676     /*! This is used in LaTeX as the title of the chapter with the
1677      *  index of all modules (Fortran).
1678      */
1679     virtual QCString trModulesIndex()
1680     { return "Moduļu indekss"; }
1681
1682     /*! This is used for translation of the word that will possibly
1683      *  be followed by a single name or by a list of names
1684      *  of the category.
1685      */
1686     virtual QCString trModule(bool first_capital, bool singular)
1687     {
1688       QCString result((first_capital ? "Modu" : "modu"));
1689       if (singular) result+="lis"; else result+="ļi";
1690       return result;
1691     }
1692
1693     /*! This is put at the bottom of a module documentation page and is
1694      *  followed by a list of files that were used to generate the page.
1695      */
1696     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
1697         bool single)
1698     {
1699       // single is true implies a single file
1700       QCString result=(QCString)"Dokumentācija š";
1701       switch(compType)
1702       {
1703         case ClassDef::Class:      result+="im modulim"; break;
1704         case ClassDef::Struct:     result+="im tipam"; break;
1705         case ClassDef::Union:      result+="im apvienojumam"; break;
1706         case ClassDef::Interface:  result+="im interfeisam"; break;
1707         case ClassDef::Protocol:   result+="im protokolam"; break;
1708         case ClassDef::Category:   result+="ai kategorijai"; break;
1709         case ClassDef::Exception:  result+="im izņēmumam"; break;
1710         default: break;
1711       }
1712       result+=" tika ģenerēta no fail";
1713       if (single) result+="a:"; else result+="iem:";
1714       return result;
1715     }
1716
1717     /*! This is used for translation of the word that will possibly
1718      *  be followed by a single name or by a list of names
1719      *  of the category.
1720      */
1721     virtual QCString trType(bool first_capital, bool singular)
1722     {
1723       QCString result((first_capital ? "Tip" : "tip"));
1724       if (singular) result+="s"; else result+="i";
1725       return result;
1726     }
1727
1728     /*! This is used for translation of the word that will possibly
1729      *  be followed by a single name or by a list of names
1730      *  of the category.
1731      */
1732     virtual QCString trSubprogram(bool first_capital, bool singular)
1733     {
1734       QCString result((first_capital ? "Apakšprogramma" : "apakšprogramma"));
1735       if (!singular)  result+="s";
1736       return result;
1737     }
1738
1739     /*! C# Type Constraint list */
1740     virtual QCString trTypeConstraints()
1741     {
1742       return "Tipa ierobežojumi";
1743     }
1744
1745 //////////////////////////////////////////////////////////////////////////
1746 // new since 1.6.0 (mainly for the new search engine)
1747 //////////////////////////////////////////////////////////////////////////
1748
1749     /*! directory relation for \a name */
1750     virtual QCString trDirRelation(const char *name)
1751     {
1752       return QCString(name)+" relācija";
1753     }
1754
1755     /*! Loading message shown when loading search results */
1756     virtual QCString trLoading()
1757     {
1758       return "Tiek veikta ielāde...";
1759     }
1760
1761     /*! Label used for search results in the global namespace */
1762     virtual QCString trGlobalNamespace()
1763     {
1764       return "Global Namespace";
1765     }
1766
1767     /*! Message shown while searching */
1768     virtual QCString trSearching()
1769     {
1770       return "Meklē...";
1771     }
1772
1773     /*! Text shown when no search results are found */
1774     virtual QCString trNoMatches()
1775     {
1776       return "Nav atbilstību";
1777     }
1778
1779 //////////////////////////////////////////////////////////////////////////
1780 // new since 1.6.3 (missing items for the directory pages)
1781 //////////////////////////////////////////////////////////////////////////
1782
1783     /*! when clicking a directory dependency label, a page with a
1784      *  table is shown. The heading for the first column mentions the
1785      *  source file that has a relation to another file.
1786      */
1787     virtual QCString trFileIn(const char *name)
1788     {
1789       return (QCString)"File in "+name;
1790     }
1791
1792     /*! when clicking a directory dependency label, a page with a
1793      *  table is shown. The heading for the second column mentions the
1794      *  destination file that is included.
1795      */
1796     virtual QCString trIncludesFileIn(const char *name)
1797     {
1798       return (QCString)"Includes file in "+name;
1799     }
1800
1801     /** Compiles a date string.
1802      *  @param year Year in 4 digits
1803      *  @param month Month of the year: 1=January
1804      *  @param day Day of the Month: 1..31
1805      *  @param dayOfWeek Day of the week: 1=Monday..7=Sunday
1806      *  @param hour Hour of the day: 0..23
1807      *  @param minutes Minutes in the hour: 0..59
1808      *  @param seconds Seconds within the minute: 0..59
1809      *  @param includeTime Include time in the result string?
1810      */
1811     virtual QCString trDateTime(int year,int month,int day,int dayOfWeek,
1812                                 int hour,int minutes,int seconds,
1813                                 bool includeTime)
1814     {
1815       static const char *days[]   = { "Pirm","Otr","Tr","Cet","Piekt","Sest","Sv" };
1816       static const char *months[] = { "Jan","Feb","Mar","Apr","Mai","Jūn","Jūl","Aug","Sept","Okt","Nov","Dec" };
1817       QCString sdate;
1818       sdate.sprintf("%s %s %d %d",days[dayOfWeek-1],months[month-1],day,year);
1819       if (includeTime)
1820       {
1821         QCString stime;
1822         stime.sprintf(" %.2d:%.2d:%.2d",hour,minutes,seconds);
1823         sdate+=stime;
1824       }
1825       return sdate;
1826     }
1827
1828 //////////////////////////////////////////////////////////////////////////
1829 // new since 1.7.5
1830 //////////////////////////////////////////////////////////////////////////
1831
1832     /*! Header for the page with bibliographic citations */
1833     virtual QCString trCiteReferences()
1834     { return "Bibliogrāfiskās atsauces"; }
1835
1836     /*! Text for copyright paragraph */
1837     virtual QCString trCopyright()
1838     { return "Autortiesības"; }
1839
1840     /*! Header for the graph showing the directory dependencies */
1841     virtual QCString trDirDepGraph(const char *name)
1842     { return QCString("Atkarību grafs direktorijai ")+name+":"; }
1843
1844 //////////////////////////////////////////////////////////////////////////
1845 // new since 1.8.0
1846 //////////////////////////////////////////////////////////////////////////
1847
1848     /*! Detail level selector shown for hierarchical indices */
1849     virtual QCString trDetailLevel()
1850     { return "detalizācijas līmenis"; }
1851
1852     /*! Section header for list of template parameters */
1853     virtual QCString trTemplateParameters()
1854     { return "Sagataves parametri"; }
1855
1856     /*! Used in dot graph when UML_LOOK is enabled and there are many fields */
1857     virtual QCString trAndMore(const QCString &number)
1858     { return "un vēl "+number+"..."; }
1859
1860     /*! Used file list for a Java enum */
1861     virtual QCString trEnumGeneratedFromFiles(bool single)
1862     { QCString result = "Dokumentācija šim uzskaitījumliterālim tika ģenerēta no sekojoš";
1863       if (single) result+="a"; else result += "iem";
1864       result+=" fail";
1865       if (single) result+="a"; else result += "iem";
1866       result+=":";
1867       return result;
1868     }
1869
1870     /*! Header of a Java enum page (Java enums are represented as classes). */
1871     virtual QCString trEnumReference(const char *name)
1872     { return QCString(name)+" uzskaitījumliterāļa atsauce"; }
1873
1874     /*! Used for a section containing inherited members */
1875     virtual QCString trInheritedFrom(const char *members,const char *what)
1876     { return QCString(members)+" manto no "+what; }
1877
1878     /*! Header of the sections with inherited members specific for the
1879      *  base class(es)
1880      */
1881     virtual QCString trAdditionalInheritedMembers()
1882     { return "Papildus mantotie elementi"; }
1883
1884 //////////////////////////////////////////////////////////////////////////
1885 // new since 1.8.2
1886 //////////////////////////////////////////////////////////////////////////
1887
1888     /*! Used as a tooltip for the toggle button that appears in the
1889      *  navigation tree in the HTML output when GENERATE_TREEVIEW is
1890      *  enabled. This tooltip explains the meaning of the button.
1891      */
1892     virtual QCString trPanelSynchronisationTooltip(bool enable)
1893     {
1894       QCString opt = enable ? "iespējotu" : "atspējotu";
1895       return "uzklikšķināt, lai "+opt+" paneļu sinhronizāciju";
1896     }
1897
1898     /*! Used in a method of an Objective-C class that is declared in a
1899      *  a category. Note that the @1 marker is required and is replaced
1900      *  by a link.
1901      */
1902     virtual QCString trProvidedByCategory()
1903     {
1904       return "Nodrošina kategorija @0.";
1905     }
1906
1907     /*! Used in a method of an Objective-C category that extends a class.
1908      *  Note that the @1 marker is required and is replaced by a link to
1909      *  the class method.
1910      */
1911     virtual QCString trExtendsClass()
1912     {
1913       return "Paplašina klasi @0.";
1914     }
1915
1916     /*! Used as the header of a list of class methods in Objective-C.
1917      *  These are similar to static public member functions in C++.
1918      */
1919     virtual QCString trClassMethods()
1920     {
1921       return "Klases metodes";
1922     }
1923
1924     /*! Used as the header of a list of instance methods in Objective-C.
1925      *  These are similar to public member functions in C++.
1926      */
1927     virtual QCString trInstanceMethods()
1928     {
1929       return "Instances metodes";
1930     }
1931
1932     /*! Used as the header of the member functions of an Objective-C class.
1933      */
1934     virtual QCString trMethodDocumentation()
1935     {
1936       return "Metožu dokumentācija";
1937     }
1938
1939     /*! Used as the title of the design overview picture created for the
1940      *  VHDL output.
1941      */
1942     virtual QCString trDesignOverview()
1943     {
1944       return "Dizaina pārskats";
1945     }
1946
1947 //////////////////////////////////////////////////////////////////////////
1948
1949 };
1950
1951 #endif