src/translator_ro.h

   1 /******************************************************************************
   2  *
   3  *
   4  *
   5  * Copyright (C) 1997-2012 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 /* Original translation from English to Romanian by Alexandru Iosup [aiosup@yahoo.com].
  19  * Updated by Ionuţ Dumitraşcu [reddumy@yahoo.com]
  20  *
  21  * -------------------------------------------
  22  * Project start                : 20.09.2000
  23  * Last Doxygen version covered : 1.5.8
  24  * Last revision                : 15.01.2009
  25  * -------------------------------------------
  26  *
  27  * Revision history
  28  * ----------------
  29  * 15.01.2009 - Updated Romanian translation to Doxygen 1.5.8 and modified strings to UTF-8, as well as some other changes (Ionuţ Dumitraşcu)
  30  * 28.07.2008 - Updated version - covering Doxygen 1.5.6 - and some minor changes  (Ionuţ Dumitraşcu)
  31  *
  32  * 01.Mar.2k5  Third revision, covering Doxygen 1.4.1
  33  *
  34  * 07.Mar.2k2  Second revision, covering Doxygen 1.2.14
  35  *             - fixed some bugs
  36  *
  37  * 20.Sep.2k   First version, covering Doxygen 1.2.1
  38  *
  39  */
  40 #ifndef TRANSLATOR_RO_H
  41 #define TRANSLATOR_RO_H
  42
  43
  44 class TranslatorRomanian : public TranslatorAdapter_1_6_0
  45 {
  46   public:
  47
  48     // --- Language control methods -------------------
  49
  50     /*! Used for identification of the language. The identification
  51      * should not be translated. It should be replaced by the name
  52      * of the language in English using lower-case characters only
  53      * (e.g. "czech", "japanese", "russian", etc.). It should be equal to
  54      * the identification used in language.cpp.
  55      */
  56     virtual QCString idLanguage()
  57     { return "romanian"; }
  58     /*! Used to get the LaTeX command(s) for the language support.
  59      *  This method should return string with commands that switch
  60      *  LaTeX to the desired language.  For example
  61      *  <pre>"\\usepackage[german]{babel}\n"
  62      *  </pre>
  63      *  or
  64      *  <pre>"\\usepackage{polski}\n"
  65      *  "\\usepackage[latin2]{inputenc}\n"
  66      *  "\\usepackage[T1]{fontenc}\n"
  67      *  </pre>
  68      *
  69      * The English LaTeX does not use such commands.  Because of this
  70      * the empty string is returned in this implementation.
  71      */
  72     virtual QCString latexLanguageSupportCommand()
  73     {
  74       return "\\usepackage[romanian]{babel}\n";
  75     }
  76
  77     /*! return the language charset. This will be used for the HTML output */
  78     virtual QCString idLanguageCharset()
  79     {
  80       return "utf-8";
  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 "Funcţii înrudite"; }
  88
  89     /*! subscript for the related functions. */
  90     virtual QCString trRelatedSubscript()
  91     { return "(Atenţie: acestea nu sunt funcţii membre.)"; }
  92
  93     /*! header that is put before the detailed description of files, classes and namespaces. */
  94     virtual QCString trDetailedDescription()
  95     { return "Descriere Detaliată"; }
  96
  97     /*! header that is put before the list of typedefs. */
  98     virtual QCString trMemberTypedefDocumentation()
  99     { return "Documentaţia Definiţiilor de Tipuri (typedef) Membre"; }
 100
 101     /*! header that is put before the list of enumerations. */
 102     virtual QCString trMemberEnumerationDocumentation()
 103     { return "Documentaţia Enumerărilor Membre"; }
 104
 105     /*! header that is put before the list of member functions. */
 106     virtual QCString trMemberFunctionDocumentation()
 107     { return "Documentaţia Funcţiilor Membre"; }
 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 "Documentaţia Câmpurilor";
 115       }
 116       else
 117       {
 118         return "Documentaţia Datelor Membre";
 119       }
 120
 121     }
 122
 123     /*! this is the text of a link put after brief descriptions. */
 124     virtual QCString trMore()
 125     { return "Mai mult..."; }
 126
 127     /*! put in the class documentation */
 128     virtual QCString trListOfAllMembers()
 129     { return "Lista tuturor membrilor"; }
 130
 131     /*! used as the title of the "list of all members" page of a class */
 132     virtual QCString trMemberList()
 133     { return "Lista Membrilor"; }
 134
 135     /*! this is the first part of a sentence that is followed by a class name */
 136     virtual QCString trThisIsTheListOfAllMembers()
 137     { return "Lista completă a membrilor din "; }
 138
 139     /*! this is the remainder of the sentence after the class name */
 140     virtual QCString trIncludingInheritedMembers()
 141     { return ", inclusiv a tuturor membrilor moşteniţi."; }
 142
 143     /*! this is put at the author sections at the bottom of man pages.
 144      *  parameter s is name of the project name.
 145      */
 146     virtual QCString trGeneratedAutomatically(const char *s)
 147     { QCString result="Generat automat de Doxygen";
 148       if (s) result+=(QCString)" pentru "+s;
 149       result+=" din codul sursă.";
 150       return result;
 151     }
 152
 153     /*! put after an enum name in the list of all members */
 154     virtual QCString trEnumName()
 155     { return "nume enumerare"; }
 156
 157     /*! put after an enum value in the list of all members */
 158     virtual QCString trEnumValue()
 159     { return "valoare enumerare"; }
 160
 161     /*! put after an undocumented member in the list of all members */
 162     virtual QCString trDefinedIn()
 163     { return "definit în"; }
 164
 165     // quick reference sections
 166
 167     /*! This is put above each page as a link to the list of all groups of
 168      *  compounds or files (see the \\group command).
 169      */
 170     virtual QCString trModules()
 171     { return "Module"; }
 172
 173     /*! This is put above each page as a link to the class hierarchy */
 174     virtual QCString trClassHierarchy()
 175     { return "Ierarhia Claselor"; }
 176
 177     /*! This is put above each page as a link to the list of annotated classes */
 178     virtual QCString trCompoundList()
 179     {
 180       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 181       {
 182         return "Structuri de Date";
 183       }
 184       else
 185       {
 186         return "Lista Claselor";
 187       }
 188
 189     }
 190
 191     /*! This is put above each page as a link to the list of documented files */
 192     virtual QCString trFileList()
 193     { return "Lista fişierelor"; }
 194
 195     /*! This is put above each page as a link to all members of compounds. */
 196     virtual QCString trCompoundMembers()
 197     {
 198       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 199       {
 200         return "Câmpurile de Date";
 201       }
 202       else
 203       {
 204         return "Membrii Componenţi"; //cu articol hotarat
 205       }
 206
 207     }
 208
 209     /*! This is put above each page as a link to all members of files. */
 210     virtual QCString trFileMembers()
 211     {
 212       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 213       {
 214         return "Globale";
 215       }
 216       else
 217       {
 218         return "Membrii din Fişier"; //cu articol hotarat
 219       }
 220
 221     }
 222
 223     /*! This is put above each page as a link to all related pages. */
 224     virtual QCString trRelatedPages()
 225     { return "Pagini înrudite"; }
 226
 227     /*! This is put above each page as a link to all examples. */
 228     virtual QCString trExamples()
 229     { return "Exemple"; }
 230
 231     /*! This is put above each page as a link to the search engine. */
 232     virtual QCString trSearch()
 233     { return "Caută"; }
 234
 235     /*! This is an introduction to the class hierarchy. */
 236     virtual QCString trClassHierarchyDescription()
 237     { return "Această listă de moşteniri este sortată în general, "
 238              "dar nu complet, în ordine alfabetică:";
 239     }
 240
 241     /*! This is an introduction to the list with all files. */
 242     virtual QCString trFileListDescription(bool extractAll)
 243     {
 244       QCString result="Lista tuturor ";
 245       result+="fişierelor";
 246           if (!extractAll) result+=" documentate";
 247           result+=", cu scurte descrieri:";
 248       return result;
 249     }
 250
 251     /*! This is an introduction to the annotated compound list. */
 252     virtual QCString trCompoundListDescription()
 253     {
 254       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 255       {
 256         return "Lista structurilor de date, cu scurte descrieri:";
 257       }
 258       else
 259       {
 260         return "Lista claselor, structurilor, uniunilor şi interfeţelor"
 261                 ", cu scurte descrieri:";
 262       }
 263
 264     }
 265
 266     /*! This is an introduction to the page with all class members. */
 267     virtual QCString trCompoundMembersDescription(bool extractAll)
 268     {
 269       QCString result="Lista tuturor ";
 270
 271       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 272       {
 273         result+="câmpurilor ";
 274         if (!extractAll) result+=" documentate ";
 275         result+="din structuri si uniuni ";
 276       }
 277       else
 278       {
 279         result+="membrilor ";
 280           if (!extractAll) result+="documentaţi ";
 281         result+="din toate clasele ";
 282       }
 283       result+=", cu legături către ";
 284       if (!extractAll)
 285       {
 286         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 287         {
 288           result+="documentaţia structurii/uniunii pentru fiecare câmp în parte:";
 289         }
 290         else
 291         {
 292           result+="documentaţia clasei pentru fiecare membru în parte:";
 293         }
 294       }
 295       else
 296       {
 297         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 298         {
 299           result+="structurile/uniunile de care aparţin:";
 300         }
 301         else
 302         {
 303           result+="clasele de care aparţin:";
 304         }
 305       }
 306
 307       return result;
 308     }
 309
 310     /*! This is an introduction to the page with all file members. */
 311     virtual QCString trFileMembersDescription(bool extractAll)
 312     {
 313       QCString result="Lista tuturor ";
 314       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 315       {
 316         result+="funcţiilor, variabilelor, definiţiilor, enumerărilor şi definiţiilor de tip";
 317           if (!extractAll) result+=" documentate";
 318       }
 319       else
 320       {
 321         result+="membrilor ";
 322           if (!extractAll) result+="documentaţi ";
 323           result+="din toate fişierele";
 324       }
 325       result+=", cu legături către ";
 326       if (extractAll)
 327         result+="fişierele de care aparţin:";
 328       else
 329         result+="documentaţia aferentă:";
 330
 331       return result;
 332     }
 333
 334     /*! This is an introduction to the page with the list of all examples */
 335     virtual QCString trExamplesDescription()
 336     { return "Lista tuturor exemplelor:"; }
 337
 338     /*! This is an introduction to the page with the list of related pages */
 339     virtual QCString trRelatedPagesDescription()
 340     { return "Lista tuturor documentaţiilor înrudite:"; }
 341
 342     /*! This is an introduction to the page with the list of class/file groups */
 343     virtual QCString trModulesDescription()
 344     { return "Lista tuturor modulelor:"; }
 345
 346     // index titles (the project name is prepended for these)
 347
 348
 349     /*! This is used in HTML as the title of index.html. */
 350     virtual QCString trDocumentation()
 351     { return "Documentaţie"; }
 352
 353     /*! This is used in LaTeX as the title of the chapter with the
 354      * index of all groups.
 355      */
 356     virtual QCString trModuleIndex()
 357     { return "Indexul Modulelor"; }
 358
 359     /*! This is used in LaTeX as the title of the chapter with the
 360      * class hierarchy.
 361      */
 362     virtual QCString trHierarchicalIndex()
 363     { return "Index Ierarhic"; }
 364
 365     /*! This is used in LaTeX as the title of the chapter with the
 366      * annotated compound index.
 367      */
 368     virtual QCString trCompoundIndex()
 369     {
 370       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 371       {
 372         return "Indexul Structurilor de Date";
 373       }
 374       else
 375       {
 376         return "Indexul Claselor";
 377       }
 378
 379     }
 380
 381     /*! This is used in LaTeX as the title of the chapter with the
 382      * list of all files.
 383      */
 384     virtual QCString trFileIndex()
 385     { return "Indexul Fişierelor"; }
 386
 387     /*! This is used in LaTeX as the title of the chapter containing
 388      *  the documentation of all groups.
 389      */
 390     virtual QCString trModuleDocumentation()
 391     { return "Documentaţia Modulelor"; }
 392
 393     /*! This is used in LaTeX as the title of the chapter containing
 394      *  the documentation of all classes, structs and unions.
 395      */
 396     virtual QCString trClassDocumentation()
 397     {
 398       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 399       {
 400         return "Documentaţia Structurilor de Date";
 401       }
 402       else
 403       {
 404         return "Documentaţia Claselor";
 405       }
 406
 407     }
 408
 409     /*! This is used in LaTeX as the title of the chapter containing
 410      *  the documentation of all files.
 411      */
 412     virtual QCString trFileDocumentation()
 413     { return "Documentaţia Fişierelor"; }
 414
 415     /*! This is used in LaTeX as the title of the chapter containing
 416      *  the documentation of all examples.
 417      */
 418     virtual QCString trExampleDocumentation()
 419     { return "Documentaţia Exemplelor"; }
 420
 421     /*! This is used in LaTeX as the title of the chapter containing
 422      *  the documentation of all related pages.
 423      */
 424     virtual QCString trPageDocumentation()
 425     { return "Documentaţii înrudite"; }
 426
 427     /*! This is used in LaTeX as the title of the document */
 428     virtual QCString trReferenceManual()
 429     { return "Manual de utilizare"; }
 430
 431     /*! This is used in the documentation of a file as a header before the
 432      *  list of defines
 433      */
 434     virtual QCString trDefines()
 435     { return "Definiţii"; }
 436
 437     /*! This is used in the documentation of a file as a header before the
 438      *  list of function prototypes
 439      */
 440     virtual QCString trFuncProtos()
 441     { return "Prototipuri de funcţii"; }
 442
 443     /*! This is used in the documentation of a file as a header before the
 444      *  list of typedefs
 445      */
 446     virtual QCString trTypedefs()
 447     { return "Definiţii de tipuri"; }
 448
 449     /*! This is used in the documentation of a file as a header before the
 450      *  list of enumerations
 451      */
 452     virtual QCString trEnumerations()
 453     { return "Enumerări"; }
 454
 455     /*! This is used in the documentation of a file as a header before the
 456      *  list of (global) functions
 457      */
 458     virtual QCString trFunctions()
 459     { return "Funcţii"; }
 460
 461     /*! This is used in the documentation of a file as a header before the
 462      *  list of (global) variables
 463      */
 464     virtual QCString trVariables()
 465     { return "Variabile"; }
 466
 467     /*! This is used in the documentation of a file as a header before the
 468      *  list of (global) variables
 469      */
 470     virtual QCString trEnumerationValues()
 471     { return "Valori de enumerări"; }
 472
 473     /*! This is used in the documentation of a file before the list of
 474      *  documentation blocks for defines
 475      */
 476     virtual QCString trDefineDocumentation()
 477     { return "Documentaţia definiţiilor"; }
 478
 479     /*! This is used in the documentation of a file/namespace before the list
 480      *  of documentation blocks for function prototypes
 481      */
 482     virtual QCString trFunctionPrototypeDocumentation()
 483     { return "Documentaţia prototipurilor de funcţii"; }
 484
 485     /*! This is used in the documentation of a file/namespace before the list
 486      *  of documentation blocks for typedefs
 487      */
 488     virtual QCString trTypedefDocumentation()
 489     { return "Documentaţia definiţiilor de tipuri"; }
 490
 491     /*! This is used in the documentation of a file/namespace before the list
 492      *  of documentation blocks for enumeration types
 493      */
 494     virtual QCString trEnumerationTypeDocumentation()
 495     { return "Documentaţia enumerărilor"; }
 496
 497     /*! This is used in the documentation of a file/namespace before the list
 498      *  of documentation blocks for functions
 499      */
 500     virtual QCString trFunctionDocumentation()
 501     { return "Documentaţia funcţiilor"; }
 502
 503     /*! This is used in the documentation of a file/namespace before the list
 504      *  of documentation blocks for variables
 505      */
 506     virtual QCString trVariableDocumentation()
 507     { return "Documentaţia variabilelor"; }
 508
 509     /*! This is used in the documentation of a file/namespace/group before
 510      *  the list of links to documented compounds
 511      */
 512     virtual QCString trCompounds()
 513     {
 514       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 515       {
 516         return "Structuri de Date";
 517       }
 518       else
 519       {
 520         return "Membri";
 521       }
 522
 523     }
 524
 525     /*! This is used in the standard footer of each page and indicates when
 526      *  the page was generated
 527      */
 528     virtual QCString trGeneratedAt(const char *date,const char *projName)
 529     {
 530       QCString result=(QCString)"Generat "+date;
 531       if (projName) result+=(QCString)" pentru "+projName;
 532       result+=(QCString)" de către";
 533       return result;
 534     }
 535     /*! This is part of the sentence used in the standard footer of each page.
 536      */
 537     virtual QCString trWrittenBy()
 538     {
 539       return "scris de";
 540     }
 541
 542     /*! this text is put before a class diagram */
 543     virtual QCString trClassDiagram(const char *clName)
 544     {
 545       return (QCString)"Diagrama de relaţii pentru "+clName;
 546     }
 547
 548     /*! this text is generated when the \\internal command is used. */
 549     virtual QCString trForInternalUseOnly()
 550     { return "Doar pentru uz intern."; }
 551
 552     /*! this text is generated when the \\warning command is used. */
 553     virtual QCString trWarning()
 554     { return "Atenţie"; }
 555
 556     /*! this text is generated when the \\version command is used. */
 557     virtual QCString trVersion()
 558     { return "Versiunea"; }
 559
 560     /*! this text is generated when the \\date command is used. */
 561     virtual QCString trDate()
 562     { return "Data"; }
 563
 564     /*! this text is generated when the \\return command is used. */
 565     virtual QCString trReturns()
 566     { return "Întoarce"; }
 567
 568     /*! this text is generated when the \\sa command is used. */
 569     virtual QCString trSeeAlso()
 570     { return "Vezi şi"; }
 571
 572     /*! this text is generated when the \\param command is used. */
 573     virtual QCString trParameters()
 574     { return "Parametri"; }
 575
 576     /*! this text is generated when the \\exception command is used. */
 577     virtual QCString trExceptions()
 578     { return "Excepţii"; }
 579
 580     /*! this text is used in the title page of a LaTeX document. */
 581     virtual QCString trGeneratedBy()
 582     { return "Generat de"; }
 583
 584     // new since 0.49-990307
 585
 586     /*! used as the title of page containing all the index of all namespaces. */
 587     virtual QCString trNamespaceList()
 588     { return "Lista de Namespace-uri"; }
 589
 590     /*! used as an introduction to the namespace list */
 591     virtual QCString trNamespaceListDescription(bool extractAll)
 592     {
 593       QCString result="Lista tuturor ";
 594       result+="namespace-urilor ";
 595           if (!extractAll) result+="documentate ";
 596           result+=", cu scurte descrieri:";
 597       return result;
 598     }
 599
 600     /*! used in the class documentation as a header before the list of all
 601      *  friends of a class
 602      */
 603     virtual QCString trFriends()
 604     { return "Prieteni"; }
 605
 606 //////////////////////////////////////////////////////////////////////////
 607 // new since 0.49-990405
 608 //////////////////////////////////////////////////////////////////////////
 609
 610     /*! used in the class documentation as a header before the list of all
 611      * related classes
 612      */
 613     virtual QCString trRelatedFunctionDocumentation()
 614     { return "Documentaţia funcţiilor prietene sau înrudite"; }
 615
 616 //////////////////////////////////////////////////////////////////////////
 617 // new since 0.49-990425
 618 //////////////////////////////////////////////////////////////////////////
 619
 620     /*! used as the title of the HTML page of a class/struct/union */
 621     virtual QCString trCompoundReference(const char *clName,
 622                                     ClassDef::CompoundType compType,
 623                                     bool isTemplate)
 624     {
 625           QCString result="Referinţă la ";
 626       switch(compType)
 627       {
 628         case ClassDef::Class:      result+="clasa "; break;
 629         case ClassDef::Struct:     result+="structura "; break;
 630         case ClassDef::Union:      result+="uniunea "; break;
 631         case ClassDef::Interface:  result+="interfaţa "; break;
 632         case ClassDef::Protocol:   result+="protocolul "; break;
 633         case ClassDef::Category:   result+="categoria "; break;
 634         case ClassDef::Exception:  result+="excepţia "; break;
 635       }
 636           if (isTemplate) result+=" (Template) ";
 637           result+=(QCString)clName;
 638
 639       return result;
 640     }
 641
 642     /*! used as the title of the HTML page of a file */
 643     virtual QCString trFileReference(const char *fileName)
 644     {
 645       QCString result="Referinţă la fişierul ";
 646       result+=fileName;
 647       return result;
 648     }
 649
 650     /*! used as the title of the HTML page of a namespace */
 651     virtual QCString trNamespaceReference(const char *namespaceName)
 652     {
 653       QCString result="Referinţă la Namespace-ul ";
 654       result+=namespaceName;
 655       return result;
 656     }
 657
 658     /* these are for the member sections of a class, struct or union */
 659     virtual QCString trPublicMembers()
 660     { return "Metode Publice"; }
 661     virtual QCString trPublicSlots()
 662     { return "Conectori (slots) Publici"; }
 663     virtual QCString trSignals()
 664     { return "Semnale"; }
 665     virtual QCString trStaticPublicMembers()
 666     { return "Metode Statice Publice"; }
 667     virtual QCString trProtectedMembers()
 668     { return "Metode Protejate"; }
 669     virtual QCString trProtectedSlots()
 670     { return "Conectori (slots) Protejaţi"; }
 671     virtual QCString trStaticProtectedMembers()
 672     { return "Metode Statice Protejate"; }
 673     virtual QCString trPrivateMembers()
 674     { return "Metode Private"; }
 675     virtual QCString trPrivateSlots()
 676     { return "Conectori (slots) Privaţi"; }
 677     virtual QCString trStaticPrivateMembers()
 678     { return "Metode Statice Private"; }
 679
 680     /*! this function is used to produce a comma-separated list of items.
 681      *  use generateMarker(i) to indicate where item i should be put.
 682      */
 683     virtual QCString trWriteList(int numEntries)
 684     {
 685       QCString result;
 686       int i;
 687       // the inherits list contain `numEntries' classes
 688       for (i=0;i<numEntries;i++)
 689       {
 690         // use generateMarker to generate placeholders for the class links!
 691         result+=generateMarker(i); // generate marker for entry i in the list
 692                                    // (order is left to right)
 693
 694         if (i!=numEntries-1)  // not the last entry, so we need a separator
 695         {
 696           if (i<numEntries-2) // not the fore last entry
 697             result+=", ";
 698           else                // the fore last entry
 699             result+=" şi ";
 700         }
 701       }
 702       return result;
 703     }
 704
 705     /*! used in class documentation to produce a list of base classes,
 706      *  if class diagrams are disabled.
 707      */
 708     virtual QCString trInheritsList(int numEntries)
 709     {
 710       return "Moşteneşte "+trWriteList(numEntries)+".";
 711     }
 712
 713     /*! used in class documentation to produce a list of super classes,
 714      *  if class diagrams are disabled.
 715      */
 716     virtual QCString trInheritedByList(int numEntries)
 717     {
 718       return "Moştenit de "+trWriteList(numEntries)+".";
 719     }
 720
 721     /*! used in member documentation blocks to produce a list of
 722      *  members that are hidden by this one.
 723      */
 724     virtual QCString trReimplementedFromList(int numEntries)
 725     {
 726       return "Reimplementat din "+trWriteList(numEntries)+".";
 727     }
 728
 729     /*! used in member documentation blocks to produce a list of
 730      *  all member that overwrite the implementation of this member.
 731      */
 732     virtual QCString trReimplementedInList(int numEntries)
 733     {
 734       return "Reimplementat în "+trWriteList(numEntries)+".";
 735     }
 736
 737     /*! This is put above each page as a link to all members of namespaces. */
 738     virtual QCString trNamespaceMembers()
 739     { return "Membrii Namespace-ului"; }
 740
 741     /*! This is an introduction to the page with all namespace members */
 742     virtual QCString trNamespaceMemberDescription(bool extractAll)
 743     {
 744       QCString result="Lista tuturor membrilor ";
 745       if (!extractAll) result+="documentaţi ";
 746           result+="din toate namespace-urile, cu legături către ";
 747
 748       if (extractAll)
 749         result+="documentaţia namespace-ului pentru fiecare membru în parte:";
 750       else
 751         result+="namespace-urile de care aparţin:";
 752       return result;
 753     }
 754     /*! This is used in LaTeX as the title of the chapter with the
 755      *  index of all namespaces.
 756      */
 757     virtual QCString trNamespaceIndex()
 758     { return "Indexul Namespace-ului"; }
 759
 760     /*! This is used in LaTeX as the title of the chapter containing
 761      *  the documentation of all namespaces.
 762      */
 763     virtual QCString trNamespaceDocumentation()
 764     { return "Documentaţia Namespace-ului"; }
 765
 766 //////////////////////////////////////////////////////////////////////////
 767 // new since 0.49-990522
 768 //////////////////////////////////////////////////////////////////////////
 769
 770     /*! This is used in the documentation before the list of all
 771      *  namespaces in a file.
 772      */
 773     virtual QCString trNamespaces()
 774     { return "Namespace-uri"; }
 775
 776 //////////////////////////////////////////////////////////////////////////
 777 // new since 0.49-990728
 778 //////////////////////////////////////////////////////////////////////////
 779
 780     /*! This is put at the bottom of a class documentation page and is
 781      *  followed by a list of files that were used to generate the page.
 782      */
 783     virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
 784         bool single)
 785     { // here s is one of " Class", " Struct" or " Union"
 786       // single is true implies a single file
 787       QCString result=(QCString)"Documentaţia pentru această ";
 788       switch(compType)
 789       {
 790         case ClassDef::Class:      result+="clasă"; break;
 791         case ClassDef::Struct:     result+="structură"; break;
 792         case ClassDef::Union:      result+="uniune"; break;
 793         case ClassDef::Interface:  result+="interfaţă"; break;
 794         case ClassDef::Protocol:   result+="protocol"; break;
 795         case ClassDef::Category:   result+="categorie"; break;
 796         case ClassDef::Exception:  result+="excepţie"; break;
 797       }
 798       result+=" a fost generată din fişier";
 799       if (single) result+="ul:"; else result+="ele:";
 800       return result;
 801     }
 802
 803     /*! This is in the (quick) index as a link to the alphabetical compound
 804      * list.
 805      */
 806     virtual QCString trAlphabeticalList()
 807     { return "Listă Alfabetică"; }
 808
 809 //////////////////////////////////////////////////////////////////////////
 810 // new since 0.49-990901
 811 //////////////////////////////////////////////////////////////////////////
 812
 813     /*! This is used as the heading text for the retval command. */
 814     virtual QCString trReturnValues()
 815     { return "Valori returnate"; }
 816
 817     /*! This is in the (quick) index as a link to the main page (index.html)
 818      */
 819     virtual QCString trMainPage()
 820     { return "Pagina principală"; }
 821
 822     /*! This is used in references to page that are put in the LaTeX
 823      *  documentation. It should be an abbreviation of the word page.
 824      */
 825     virtual QCString trPageAbbreviation()
 826     { return "pg."; }
 827
 828 //////////////////////////////////////////////////////////////////////////
 829 // new since 0.49-991003
 830 //////////////////////////////////////////////////////////////////////////
 831
 832     virtual QCString trDefinedAtLineInSourceFile()
 833     {
 834       return "Definiţia în linia @0 a fişierului @1.";
 835     }
 836     virtual QCString trDefinedInSourceFile()
 837     {
 838       return "Definiţia în fişierul @0.";
 839     }
 840
 841 //////////////////////////////////////////////////////////////////////////
 842 // new since 0.49-991205
 843 //////////////////////////////////////////////////////////////////////////
 844
 845     virtual QCString trDeprecated()
 846     {
 847       return "Învechită(Deprecated)";
 848     }
 849
 850 //////////////////////////////////////////////////////////////////////////
 851 // new since 1.0.0
 852 //////////////////////////////////////////////////////////////////////////
 853
 854     /*! this text is put before a collaboration diagram */
 855     virtual QCString trCollaborationDiagram(const char *clName)
 856     {
 857       return (QCString)"Diagrama de relaţii pentru "+clName+":";
 858     }
 859     /*! this text is put before an include dependency graph */
 860     virtual QCString trInclDepGraph(const char *fName)
 861     {
 862       return (QCString)"Graful dependenţelor prin incluziune pentru "+fName+":";
 863     }
 864     /*! header that is put before the list of constructor/destructors. */
 865     virtual QCString trConstructorDocumentation()
 866     {
 867       return "Documentaţia pentru Constructori şi Destructori";
 868     }
 869     /*! Used in the file documentation to point to the corresponding sources. */
 870     virtual QCString trGotoSourceCode()
 871     {
 872       return "Vezi sursele.";
 873     }
 874     /*! Used in the file sources to point to the corresponding documentation. */
 875     virtual QCString trGotoDocumentation()
 876     {
 877       return "Vezi documentaţia.";
 878     }
 879     /*! Text for the \\pre command */
 880     virtual QCString trPrecondition()
 881     {
 882       return "Precondiţie";
 883     }
 884     /*! Text for the \\post command */
 885     virtual QCString trPostcondition()
 886     {
 887       return "Postcondiţie";
 888     }
 889     /*! Text for the \\invariant command */
 890     virtual QCString trInvariant()
 891     {
 892       return "Invariant";
 893     }
 894     /*! Text shown before a multi-line variable/enum initialization */
 895     virtual QCString trInitialValue()
 896     {
 897       return "Valoarea iniţială:";
 898     }
 899     /*! Text used the source code in the file index */
 900     virtual QCString trCode()
 901     {
 902       return "cod";
 903     }
 904     virtual QCString trGraphicalHierarchy()
 905     {
 906       return "Ierarhia Claselor în mod grafic";
 907     }
 908     virtual QCString trGotoGraphicalHierarchy()
 909     {
 910       return "Vezi ierarhia claselor în mod grafic";
 911     }
 912     virtual QCString trGotoTextualHierarchy()
 913     {
 914       return "Vezi ierarhia claselor în mod text";
 915     }
 916     virtual QCString trPageIndex()
 917     {
 918       return "Indexul Paginilor";
 919     }
 920
 921 //////////////////////////////////////////////////////////////////////////
 922 // new since 1.1.0
 923 //////////////////////////////////////////////////////////////////////////
 924
 925     virtual QCString trNote()
 926     {
 927       return "Notă";
 928     }
 929     virtual QCString trPublicTypes()
 930     {
 931       return "Tipuri Publice";
 932     }
 933     virtual QCString trPublicAttribs()
 934     {
 935       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 936       {
 937         return "Câmpuri de Date";
 938       }
 939       else
 940       {
 941         return "Atribute Publice";
 942       }
 943
 944     }
 945     virtual QCString trStaticPublicAttribs()
 946     {
 947       return "Atribute Statice Publice";
 948     }
 949     virtual QCString trProtectedTypes()
 950     {
 951       return "Tipuri Protejate";
 952     }
 953     virtual QCString trProtectedAttribs()
 954     {
 955       return "Atribute Protejate";
 956     }
 957     virtual QCString trStaticProtectedAttribs()
 958     {
 959       return "Atribute Statice Protejate";
 960     }
 961     virtual QCString trPrivateTypes()
 962     {
 963       return "Tipuri Private";
 964     }
 965     virtual QCString trPrivateAttribs()
 966     {
 967       return "Atribute Private";
 968     }
 969     virtual QCString trStaticPrivateAttribs()
 970     {
 971       return "Atribute Statice Private";
 972     }
 973
 974 //////////////////////////////////////////////////////////////////////////
 975 // new since 1.1.3
 976 //////////////////////////////////////////////////////////////////////////
 977
 978     /*! Used as a marker that is put before a todo item */
 979     virtual QCString trTodo()
 980     {
 981       return "De făcut";
 982     }
 983     /*! Used as the header of the todo list */
 984     virtual QCString trTodoList()
 985     {
 986       return "Lista lucrurilor de făcut";
 987     }
 988
 989 //////////////////////////////////////////////////////////////////////////
 990 // new since 1.1.4
 991 //////////////////////////////////////////////////////////////////////////
 992
 993     virtual QCString trReferencedBy()
 994     {
 995       return "Semnalat de";
 996     }
 997     virtual QCString trRemarks()
 998     {
 999       return "Observaţii";
1000     }
1001     virtual QCString trAttention()
1002     {
1003       return "Atenţie";
1004     }
1005     virtual QCString trInclByDepGraph()
1006     {
1007       return "Acest graf arată care fişiere includ, "
1008                   "direct sau indirect, acest fişier:";
1009     }
1010     virtual QCString trSince()
1011     {
1012       return "Din";
1013     }
1014
1015 //////////////////////////////////////////////////////////////////////////
1016 // new since 1.1.5
1017 //////////////////////////////////////////////////////////////////////////
1018
1019     /*! title of the graph legend page */
1020     virtual QCString trLegendTitle()
1021     {
1022       return "Legenda grafului";
1023     }
1024     /*! page explaining how the dot graph's should be interpreted */
1025     virtual QCString trLegendDocs()
1026     {
1027       return
1028         "Această pagină arată modul în care trebuie să interpretaţi "
1029                 "grafurile generate de doxygen.<p>\n"
1030         "Consideraţi următorul exemplu:\n"
1031         "\\code\n"
1032         "/*! Clasă invizibilă, tăiată din cauza depăşirii spaţiului */\n"
1033         "class Invisible { };\n\n"
1034         "/*! Altă clasă tăiată, relaţia de moştenire este ascunsă */\n"
1035         "class Truncated : public Invisible { };\n\n"
1036         "/* Clasă necomentată în stil doxygen */\n"
1037         "class Undocumented { };\n\n"
1038         "/*! Clasă care este moştenită în mod public */\n"
1039         "class PublicBase : public Truncated { };\n\n"
1040         "/*! Clasă template */\n"
1041         "template<class T> class Templ { };\n\n"
1042         "/*! Clasă care este moştenită în mod protejat */\n"
1043         "class ProtectedBase { };\n\n"
1044         "/*! Clasă care este moştenită în mod privat */\n"
1045         "class PrivateBase { };\n\n"
1046         "/*! Clasă care este folosită de clasa Inherited */\n"
1047         "class Used { };\n\n"
1048         "/*! Superclasă care moşteneşte un număr de alte clase */\n"
1049         "class Inherited : public PublicBase,\n"
1050         "                  protected ProtectedBase,\n"
1051         "                  private PrivateBase,\n"
1052         "                  public Undocumented,\n"
1053         "                  public Templ<int>\n"
1054         "{\n"
1055         "  private:\n"
1056         "    Used *m_usedClass;\n"
1057         "};\n"
1058         "\\endcode\n"
1059         "Dacă tagul \\c MAX_DOT_GRAPH_HEIGHT din fişierul de configurare "
1060         "este setat la 200, acesta este graful rezultat:"
1061         "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
1062         "<p>\n"
1063         "Căsuţele din partea de sus au următoarea semnificaţie:\n"
1064         "<ul>\n"
1065         "<li>O căsuţă neagră reprezintă structura sau clasa pentru care "
1066         "graful este generat.\n"
1067         "<li>O căsuţă cu marginea neagră reprezintă o structură sau o clasă documentate.\n"
1068         "<li>O căsuţă cu marginea gri reprezintă o structură sau o clasă nedocumentate.\n"
1069         "<li>O căsuţă cu marginea roşie reprezintă o structură sau o clasă documentate, pentru\n"
1070         "care nu toate relaţiile de moştenire/incluziune sunt arătate. Un graf este "
1071         "tăiat dacă nu încape în marginile specificate."
1072         "</ul>\n"
1073         "Săgeţile au următoarea semnificaţie:\n"
1074         "<ul>\n"
1075         "<li>O săgeată de un albastru închis este folosită când avem o relaţie de "
1076         "moştenire publică între două clase.\n"
1077         "<li>O săgeată de un verde închis este folosită când avem o moştenire protejată.\n"
1078         "<li>O săgeată de un roşu închis este folosită când avem o moştenire privată.\n"
1079         "<li>O săgeată violetă punctată este folosită pentru o clasă conţinută sau folosită "
1080         "de o altă clasă. Săgeata este marcată cu variabila(e) "
1081         "prin care este accesibilă clasa sau structura spre care este îndreptată. \n"
1082         "</ul>\n";
1083     }
1084     /*! text for the link to the legend page */
1085     virtual QCString trLegend()
1086     {
1087       return "legenda";
1088     }
1089
1090 //////////////////////////////////////////////////////////////////////////
1091 // new since 1.2.0
1092 //////////////////////////////////////////////////////////////////////////
1093
1094     /*! Used as a marker that is put before a test item */
1095     virtual QCString trTest()
1096     {
1097       return "Test";
1098     }
1099     /*! Used as the header of the test list */
1100     virtual QCString trTestList()
1101     {
1102       return "Listă de teste";
1103     }
1104
1105 //////////////////////////////////////////////////////////////////////////
1106 // new since 1.2.1
1107 //////////////////////////////////////////////////////////////////////////
1108
1109     /*! Used as a section header for KDE-2 IDL methods */
1110     virtual QCString trDCOPMethods()
1111     {
1112       return "Metode DCOP";
1113     }
1114
1115 //////////////////////////////////////////////////////////////////////////
1116 // new since 1.2.2
1117 //////////////////////////////////////////////////////////////////////////
1118
1119     /*! Used as a section header for IDL properties */
1120     virtual QCString trProperties()
1121     {
1122       return "Proprietăţi";
1123     }
1124     /*! Used as a section header for IDL property documentation */
1125     virtual QCString trPropertyDocumentation()
1126     {
1127       return "Documentaţia Proprietăţilor";
1128     }
1129
1130 //////////////////////////////////////////////////////////////////////////
1131 // new since 1.2.4
1132 //////////////////////////////////////////////////////////////////////////
1133
1134     /*! Used for Java classes in the summary section of Java packages */
1135     virtual QCString trClasses()
1136     {
1137       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
1138       {
1139         return "Structuri de Date";
1140       }
1141       else
1142       {
1143         return "Clase";
1144       }
1145     }
1146     /*! Used as the title of a Java package */
1147     virtual QCString trPackage(const char *name)
1148     {
1149       return (QCString)"Pachet "+name;
1150     }
1151     /*! Title of the package index page */
1152     virtual QCString trPackageList()
1153     {
1154       return "Lista Pachetelor";
1155     }
1156     /*! The description of the package index page */
1157     virtual QCString trPackageListDescription()
1158     {
1159       return "Lista pachetelor, însoţită de scurte explicaţii, acolo unde acestea există:";
1160     }
1161     /*! The link name in the Quick links header for each page */
1162     virtual QCString trPackages()
1163     {
1164       return "Pachete";
1165     }
1166     /*! Text shown before a multi-line define */
1167     virtual QCString trDefineValue()
1168     {
1169       return "Valoare:";
1170     }
1171
1172 //////////////////////////////////////////////////////////////////////////
1173 // new since 1.2.5
1174 //////////////////////////////////////////////////////////////////////////
1175
1176     /*! Used as a marker that is put before a \\bug item */
1177     virtual QCString trBug()
1178     {
1179       return "Problema (Bug)";
1180     }
1181     /*! Used as the header of the bug list */
1182     virtual QCString trBugList()
1183     {
1184       return "Lista de Probleme (Bugs)";
1185     }
1186
1187 //////////////////////////////////////////////////////////////////////////
1188 // new since 1.2.6
1189 //////////////////////////////////////////////////////////////////////////
1190
1191     /*! Used as ansicpg for RTF file
1192      *
1193      * The following table shows the correlation of Charset name, Charset Value and
1194      * <pre>
1195      * Codepage number:
1196      * Charset Name       Charset Value(hex)  Codepage number
1197      * ------------------------------------------------------
1198      * DEFAULT_CHARSET           1 (x01)
1199      * SYMBOL_CHARSET            2 (x02)
1200      * OEM_CHARSET             255 (xFF)
1201      * ANSI_CHARSET              0 (x00)            1252
1202      * RUSSIAN_CHARSET         204 (xCC)            1251
1203      * EE_CHARSET              238 (xEE)            1250
1204      * GREEK_CHARSET           161 (xA1)            1253
1205      * TURKISH_CHARSET         162 (xA2)            1254
1206      * BALTIC_CHARSET          186 (xBA)            1257
1207      * HEBREW_CHARSET          177 (xB1)            1255
1208      * ARABIC _CHARSET         178 (xB2)            1256
1209      * SHIFTJIS_CHARSET        128 (x80)             932
1210      * HANGEUL_CHARSET         129 (x81)             949
1211      * GB2313_CHARSET          134 (x86)             936
1212      * CHINESEBIG5_CHARSET     136 (x88)             950
1213      * </pre>
1214      *
1215      */
1216     virtual QCString trRTFansicp()
1217     {
1218       return "1250"; //EASTEUROPE_CHARSET
1219     }
1220
1221
1222     /*! Used as ansicpg for RTF fcharset
1223      *  \see trRTFansicp() for a table of possible values.
1224      */
1225     virtual QCString trRTFCharSet()
1226     {
1227       return "238";
1228     }
1229
1230     /*! Used as header RTF general index */
1231     virtual QCString trRTFGeneralIndex()
1232     {
1233       return "Index";
1234     }
1235
1236     /*! This is used for translation of the word that will possibly
1237      *  be followed by a single name or by a list of names
1238      *  of the category.
1239      */
1240     virtual QCString trClass(bool first_capital, bool singular)
1241     {
1242       QCString result((first_capital ? "Clas" : "clas"));
1243         result+= singular ? "a":"ele";
1244       return result;
1245     }
1246
1247     /*! This is used for translation of the word that will possibly
1248      *  be followed by a single name or by a list of names
1249      *  of the category.
1250      */
1251     virtual QCString trFile(bool first_capital, bool singular)
1252     {
1253       QCString result((first_capital ? "Fişier" : "fişier"));
1254         result+= singular ? "ul":"ele";
1255       return result;
1256     }
1257
1258     /*! This is used for translation of the word that will possibly
1259      *  be followed by a single name or by a list of names
1260      *  of the category.
1261      */
1262     virtual QCString trNamespace(bool first_capital, bool singular)
1263     {
1264       QCString result((first_capital ? "Namespace" : "namespace"));
1265         result+= singular ? "-ul":"-urile";
1266       return result;
1267     }
1268
1269     /*! This is used for translation of the word that will possibly
1270      *  be followed by a single name or by a list of names
1271      *  of the category.
1272      */
1273     virtual QCString trGroup(bool first_capital, bool singular)
1274     {
1275       QCString result((first_capital ? "Grupu" : "grupu"));
1276         result+= singular ? "l":"rile";
1277       return result;
1278     }
1279
1280     /*! This is used for translation of the word that will possibly
1281      *  be followed by a single name or by a list of names
1282      *  of the category.
1283      */
1284     virtual QCString trPage(bool first_capital, bool singular)
1285     {
1286       QCString result((first_capital ? "Pagin" : "pagin"));
1287         result+= singular ? "a":"ile";
1288       return result;
1289     }
1290
1291     /*! This is used for translation of the word that will possibly
1292      *  be followed by a single name or by a list of names
1293      *  of the category.
1294      */
1295     virtual QCString trMember(bool first_capital, bool singular)
1296     {
1297       QCString result((first_capital ? "Membr" : "membr"));
1298         result+= singular ? "ul":"ii";
1299       return result;
1300     }
1301
1302     /*! This is used for translation of the word that will possibly
1303      *  be followed by a single name or by a list of names
1304      *  of the category.
1305      */
1306     virtual QCString trGlobal(bool first_capital, bool singular)
1307     {
1308       QCString result((first_capital ? "Global" : "global"));
1309       if (!singular)  result+="e";
1310       return result;
1311     }
1312
1313 //////////////////////////////////////////////////////////////////////////
1314 // new since 1.2.7
1315 //////////////////////////////////////////////////////////////////////////
1316
1317     /*! This text is generated when the \\author command is used and
1318      *  for the author section in man pages. */
1319     virtual QCString trAuthor(bool first_capital, bool singular)
1320     {
1321       QCString result((first_capital ? "Autor" : "autor"));
1322         result+= singular ? "ul":"ii";
1323       return result;
1324     }
1325
1326 //////////////////////////////////////////////////////////////////////////
1327 // new since 1.2.11
1328 //////////////////////////////////////////////////////////////////////////
1329
1330     /*! This text is put before the list of members referenced by a member
1331      */
1332     virtual QCString trReferences()
1333     {
1334       return "Referinţe";
1335     }
1336
1337 //////////////////////////////////////////////////////////////////////////
1338 // new since 1.2.13
1339 //////////////////////////////////////////////////////////////////////////
1340
1341     /*! used in member documentation blocks to produce a list of
1342      *  members that are implemented by this one.
1343      */
1344     virtual QCString trImplementedFromList(int numEntries)
1345     {
1346       return "Implementează "+trWriteList(numEntries)+".";
1347     }
1348
1349     /*! used in member documentation blocks to produce a list of
1350      *  all members that implement this abstract member.
1351      */
1352     virtual QCString trImplementedInList(int numEntries)
1353     {
1354       return "Implementat în "+trWriteList(numEntries)+".";
1355     }
1356
1357 //////////////////////////////////////////////////////////////////////////
1358 // new since 1.2.16
1359 //////////////////////////////////////////////////////////////////////////
1360
1361     /*! used in RTF documentation as a heading for the Table
1362      *  of Contents.
1363      */
1364     virtual QCString trRTFTableOfContents()
1365     {
1366       return "Cuprins";
1367     }
1368
1369 //////////////////////////////////////////////////////////////////////////
1370 // new since 1.2.17
1371 //////////////////////////////////////////////////////////////////////////
1372
1373     /*! Used as the header of the list of item that have been
1374      *  flagged deprecated
1375      */
1376     virtual QCString trDeprecatedList()
1377     {
1378       return "Lista elementelor învechite (deprecated)";
1379     }
1380
1381 //////////////////////////////////////////////////////////////////////////
1382 // new since 1.2.18
1383 //////////////////////////////////////////////////////////////////////////
1384
1385     /*! Used as a header for declaration section of the events found in
1386      * a C# program
1387      */
1388     virtual QCString trEvents()
1389     {
1390       return "Evenimente";
1391     }
1392     /*! Header used for the documentation section of a class' events. */
1393     virtual QCString trEventDocumentation()
1394     {
1395       return "Documentaţia aferentă evenimentelor";
1396     }
1397
1398 //////////////////////////////////////////////////////////////////////////
1399 // new since 1.3
1400 //////////////////////////////////////////////////////////////////////////
1401
1402     /*! Used as a heading for a list of Java class types with package scope.
1403      */
1404     virtual QCString trPackageTypes()
1405     {
1406       return "Tipuri în pachet";
1407     }
1408     /*! Used as a heading for a list of Java class functions with package
1409      * scope.
1410      */
1411     virtual QCString trPackageMembers()
1412     {
1413       return "Funcţii în pachet";
1414     }
1415     /*! Used as a heading for a list of static Java class functions with
1416      *  package scope.
1417      */
1418     virtual QCString trStaticPackageMembers()
1419     {
1420       return "Funcţii statice în pachet";
1421     }
1422     /*! Used as a heading for a list of Java class variables with package
1423      * scope.
1424      */
1425     virtual QCString trPackageAttribs()
1426     {
1427       return "Atribute în pachet";
1428     }
1429     /*! Used as a heading for a list of static Java class variables with
1430      * package scope.
1431      */
1432     virtual QCString trStaticPackageAttribs()
1433     {
1434       return "Atribute statice în pachet";
1435     }
1436
1437 //////////////////////////////////////////////////////////////////////////
1438 // new since 1.3.1
1439 //////////////////////////////////////////////////////////////////////////
1440
1441     /*! Used in the quick index of a class/file/namespace member list page
1442      *  to link to the unfiltered list of all members.
1443      */
1444     virtual QCString trAll()
1445     {
1446       return "Toate";
1447     }
1448     /*! Put in front of the call graph for a function. */
1449     virtual QCString trCallGraph()
1450     {
1451       return "Graful de apel al acestei funcţii:";
1452     }
1453
1454 //////////////////////////////////////////////////////////////////////////
1455 // new since 1.3.3
1456 //////////////////////////////////////////////////////////////////////////
1457
1458     /*! When the search engine is enabled this text is put in the header
1459      *  of each page before the field where one can enter the text to search
1460      *  for.
1461      */
1462     virtual QCString trSearchForIndex()
1463     {
1464       return "Caută";
1465     }
1466     /*! This string is used as the title for the page listing the search
1467      *  results.
1468      */
1469     virtual QCString trSearchResultsTitle()
1470     {
1471       return "Rezultatele căutarii";
1472     }
1473     /*! This string is put just before listing the search results. The
1474      *  text can be different depending on the number of documents found.
1475      *  Inside the text you can put the special marker $num to insert
1476      *  the number representing the actual number of search results.
1477      *  The @a numDocuments parameter can be either 0, 1 or 2, where the
1478      *  value 2 represents 2 or more matches. HTML markup is allowed inside
1479      *  the returned string.
1480      */
1481     virtual QCString trSearchResults(int numDocuments)
1482     {
1483       if (numDocuments==0)
1484       {
1485         return "Din păcate nu am găsit nici un document care să corespundă cererii.";
1486       }
1487       else if (numDocuments==1)
1488       {
1489         return "Am găsit <b>1</b> document corespunzând cererii.";
1490       }
1491       else
1492       {
1493         return "Am găsit <b>$num</b> documente corespunzând cererii. "
1494                "Lista documentelor găsite, sortate după relevanţă.";
1495       }
1496     }
1497     /*! This string is put before the list of matched words, for each search
1498      *  result. What follows is the list of words that matched the query.
1499      */
1500     virtual QCString trSearchMatches()
1501     {
1502       return "Găsite:";
1503     }
1504
1505 //////////////////////////////////////////////////////////////////////////
1506 // new since 1.3.8
1507 //////////////////////////////////////////////////////////////////////////
1508
1509      /*! This is used in HTML as the title of page with source code for file filename
1510       */
1511      virtual QCString trSourceFile(QCString& filename)
1512      {
1513        return " Fişierul sursă " + filename;
1514      }
1515
1516 //////////////////////////////////////////////////////////////////////////
1517 // new since 1.3.9
1518 //////////////////////////////////////////////////////////////////////////
1519
1520      /*! This is used as the name of the chapter containing the directory
1521       *  hierarchy.
1522       */
1523      virtual QCString trDirIndex()
1524      { return "Ierarhia directoarelor"; }
1525
1526      /*! This is used as the name of the chapter containing the documentation
1527       *  of the directories.
1528       */
1529      virtual QCString trDirDocumentation()
1530      { return "Documentaţia directoarelor"; }
1531
1532      /*! This is used as the title of the directory index and also in the
1533       *  Quick links of a HTML page, to link to the directory hierarchy.
1534       */
1535      virtual QCString trDirectories()
1536      { return "Directoare"; }
1537
1538      /*! This returns a sentences that introduces the directory hierarchy.
1539       *  and the fact that it is sorted alphabetically per level
1540       */
1541      virtual QCString trDirDescription()
1542      { return "Această ierarhie de directoare este sortată în general, "
1543               "dar nu complet, în ordine alfabetică:";
1544      }
1545
1546      /*! This returns the title of a directory page. The name of the
1547       *  directory is passed via \a dirName.
1548       */
1549      virtual QCString trDirReference(const char *dirName)
1550      {
1551        QCString  result="Director-referinţă "; result+=dirName;
1552        return result;
1553      }
1554
1555      /*! This returns the word directory with or without starting capital
1556       *  (\a first_capital) and in sigular or plural form (\a singular).
1557       */
1558      virtual QCString trDir(bool first_capital, bool singular)
1559      {
1560        QCString result((first_capital ? "Directo" : "directo"));
1561        if (singular) result+="r"; else result="are";
1562        return result;
1563      }
1564
1565 //////////////////////////////////////////////////////////////////////////
1566 // new since 1.4.1
1567 //////////////////////////////////////////////////////////////////////////
1568
1569     /*! This text is added to the documentation when the \\overload command
1570      *  is used for a overloaded function.
1571      */
1572     virtual QCString trOverloadText()
1573     {
1574        return "Aceasta este o funcţie membră suprascrisă. "
1575               "Diferă de funcţia de mai sus "
1576               "doar prin argumentele acceptate.";
1577     }
1578
1579 //////////////////////////////////////////////////////////////////////////
1580 // new since 1.4.6
1581 //////////////////////////////////////////////////////////////////////////
1582
1583     /*! This is used to introduce a caller (or called-by) graph */
1584     virtual QCString trCallerGraph()
1585     {
1586       return "Graful de apeluri pentru această funcţie:";
1587     }
1588
1589     /*! This is used in the documentation of a file/namespace before the list
1590      *  of documentation blocks for enumeration values
1591      */
1592     virtual QCString trEnumerationValueDocumentation()
1593     { return "Documentaţia Enumeratorilor"; }
1594
1595 //////////////////////////////////////////////////////////////////////////
1596 // new since 1.5.4 (mainly for Fortran)
1597 //////////////////////////////////////////////////////////////////////////
1598
1599     /*! header that is put before the list of member subprograms (Fortran). */
1600     virtual QCString trMemberFunctionDocumentationFortran()
1601     { return "Documentaţia Funcţiei Membre/Subrutinei"; }
1602
1603     /*! This is put above each page as a link to the list of annotated data types (Fortran). */
1604     virtual QCString trCompoundListFortran()
1605     { return "Lista Tipurilor de Date"; }
1606
1607     /*! This is put above each page as a link to all members of compounds (Fortran). */
1608     virtual QCString trCompoundMembersFortran()
1609     { return "Câmpuri de date"; }
1610
1611     /*! This is an introduction to the annotated compound list (Fortran). */
1612     virtual QCString trCompoundListDescriptionFortran()
1613     { return "Tipurile de date, cu scurte descrieri:"; }
1614
1615     /*! This is an introduction to the page with all data types (Fortran). */
1616     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
1617     {
1618       QCString result="Lista tuturor tipurilor de date ";
1619       if (!extractAll)
1620       {
1621         result+="documentate ";
1622       }
1623       result+=" cu legături către ";
1624       if (!extractAll)
1625       {
1626          result+="documentaţia structurii de date pentru fiecare membru";
1627       }
1628       else
1629       {
1630          result+="tipurile de date de care aparţin:";
1631       }
1632       return result;
1633     }
1634
1635     /*! This is used in LaTeX as the title of the chapter with the
1636      * annotated compound index (Fortran).
1637      */
1638     virtual QCString trCompoundIndexFortran()
1639     { return "Indexul Tipurilor de Date"; }
1640
1641     /*! This is used in LaTeX as the title of the chapter containing
1642      *  the documentation of all data types (Fortran).
1643      */
1644     virtual QCString trTypeDocumentation()
1645     { return "Documentaţia Tipurilor de Date"; }
1646
1647     /*! This is used in the documentation of a file as a header before the
1648      *  list of (global) subprograms (Fortran).
1649      */
1650     virtual QCString trSubprograms()
1651     { return "Funcţii/Subrutine"; }
1652
1653     /*! This is used in the documentation of a file/namespace before the list
1654      *  of documentation blocks for subprograms (Fortran)
1655      */
1656     virtual QCString trSubprogramDocumentation()
1657     { return "Documentaţia Funcţiilor/Subrutinelor"; }
1658
1659     /*! This is used in the documentation of a file/namespace/group before
1660      *  the list of links to documented compounds (Fortran)
1661      */
1662      virtual QCString trDataTypes()
1663     { return "Tipuri de Date"; }
1664
1665     /*! used as the title of page containing all the index of all modules (Fortran). */
1666     virtual QCString trModulesList()
1667     { return "Lista Modulelor"; }
1668
1669     /*! used as an introduction to the modules list (Fortran) */
1670     virtual QCString trModulesListDescription(bool extractAll)
1671     {
1672       QCString result="Lista tuturor modulelor ";
1673       if (!extractAll) result+="documentate ";
1674       result+="cu scurte descrieri:";
1675       return result;
1676     }
1677
1678     /*! used as the title of the HTML page of a module/type (Fortran) */
1679     virtual QCString trCompoundReferenceFortran(const char *clName,
1680                                     ClassDef::CompoundType compType,
1681                                     bool isTemplate)
1682     {
1683       QCString result="Referinţă la ";
1684       switch(compType)
1685       {
1686         case ClassDef::Class:      result+="Modulul "; break;
1687         case ClassDef::Struct:     result+="Tipul "; break;
1688         case ClassDef::Union:      result+="Uniunea "; break;
1689         case ClassDef::Interface:  result+="Interfaţa "; break;
1690         case ClassDef::Protocol:   result+="Protocolul "; break;
1691         case ClassDef::Category:   result+="Categoria "; break;
1692         case ClassDef::Exception:  result+="Excepţia "; break;
1693       }
1694       if (isTemplate) result+="(Template) ";
1695           result+=(QCString)clName;
1696       return result;
1697     }
1698     /*! used as the title of the HTML page of a module (Fortran) */
1699     virtual QCString trModuleReference(const char *namespaceName)
1700     {
1701       QCString result="Referinţă la Modulul ";
1702           result += namespaceName;
1703       return result;
1704     }
1705
1706     /*! This is put above each page as a link to all members of modules. (Fortran) */
1707     virtual QCString trModulesMembers()
1708     { return "Membrii Modulului"; }
1709
1710     /*! This is an introduction to the page with all modules members (Fortran) */
1711     virtual QCString trModulesMemberDescription(bool extractAll)
1712     {
1713       QCString result="Lista tuturor membrilor ";
1714       if (!extractAll) result+="documentaţi ai ";
1715       result+="modulului cu legături către ";
1716       if (extractAll)
1717       {
1718         result+="documentaţia modulului pentru fiecare membru:";
1719       }
1720       else
1721       {
1722         result+="modulele de care aparţin:";
1723       }
1724       return result;
1725     }
1726
1727     /*! This is used in LaTeX as the title of the chapter with the
1728      *  index of all modules (Fortran).
1729      */
1730     virtual QCString trModulesIndex()
1731     { return "Indexul Modulelor"; }
1732
1733     /*! This is used for translation of the word that will possibly
1734      *  be followed by a single name or by a list of names
1735      *  of the category.
1736      */
1737     virtual QCString trModule(bool first_capital, bool singular)
1738     {
1739       QCString result((first_capital ? "Modul" : "modul"));
1740       if (singular)  result+="ul";
1741           else result += "ele";
1742       return result;
1743     }
1744     /*! This is put at the bottom of a module documentation page and is
1745      *  followed by a list of files that were used to generate the page.
1746      */
1747     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
1748         bool single)
1749     { // here s is one of " Module", " Struct" or " Union"
1750       // single is true implies a single file
1751       QCString result=(QCString)"Documentaţia ";
1752       switch(compType)
1753       {
1754         case ClassDef::Class:      result+="modulului"; break;
1755         case ClassDef::Struct:     result+="tipului"; break;
1756         case ClassDef::Union:      result+="uniunii"; break;
1757         case ClassDef::Interface:  result+="interfeţei"; break;
1758         case ClassDef::Protocol:   result+="protocolului"; break;
1759         case ClassDef::Category:   result+="categoriei"; break;
1760         case ClassDef::Exception:  result+="excepţiei"; break;
1761       }
1762       result+=" a fost generată din următo";
1763       if (single) result+="rul fişier:"; else result+="arele fişiere:";
1764       return result;
1765     }
1766     /*! This is used for translation of the word that will possibly
1767      *  be followed by a single name or by a list of names
1768      *  of the category.
1769      */
1770     virtual QCString trType(bool first_capital, bool singular)
1771     {
1772       QCString result((first_capital ? "Tip" : "tip"));
1773       if (singular)  result+="ul";
1774           else result += "urile";
1775       return result;
1776     }
1777     /*! This is used for translation of the word that will possibly
1778      *  be followed by a single name or by a list of names
1779      *  of the category.
1780      */
1781     virtual QCString trSubprogram(bool first_capital, bool singular)
1782     {
1783       QCString result((first_capital ? "Subprogram" : "subprogram"));
1784       if (singular)  result+="ul";
1785           else result += "urile";
1786       return result;
1787     }
1788
1789     /*! C# Type Constraint list */
1790     virtual QCString trTypeConstraints()
1791     {
1792       return "Constrângerile de Tip";
1793     }
1794
1795 };
1796
1797 #endif