Orb/Doxygen/src/translator_sr.h
changeset 3 d8fccb2cd802
parent 0 42188c7ea2d9
child 4 468f4c8d3d5b
equal deleted inserted replaced
2:932c358ece3e 3:d8fccb2cd802
       
     1 /******************************************************************************
       
     2  *
       
     3  * 
       
     4  *
       
     5  * Copyright (C) 1997-2007 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_SR_H
       
    19 #define TRANSLATOR_SR_H
       
    20 
       
    21 // translation by Dejan D. M. Milosavljevic <dmilos@email.com>;<dmilosx@ptt.yu>;<office@ddmrm.com>
       
    22 // // 10x 2 Ivana Miletic for grammatical consultation.
       
    23 
       
    24 // UTF-8 patch by Nenad Bulatovic <buletina@gmail.com>
       
    25 // translation update by Andrija M. Bosnjakovic <andrija@etf.bg.ac.yu>
       
    26 
       
    27 class TranslatorSerbian : public TranslatorAdapter_1_6_0
       
    28 {                                
       
    29 private:
       
    30    QCString decode(const QCString& sInput)
       
    31    { 
       
    32 //#ifdef _WIN32
       
    33 //     return ISO88592ToWin1250(sInput);
       
    34 //#else
       
    35      return sInput;
       
    36 //#endif
       
    37    }
       
    38 
       
    39 
       
    40   public:
       
    41 
       
    42     // --- Language control methods -------------------
       
    43     
       
    44     /*! Used for identification of the language. The identification 
       
    45      * should not be translated. It should be replaced by the name 
       
    46      * of the language in English using lower-case characters only
       
    47      * (e.g. "czech", "japanese", "russian", etc.). It should be equal to 
       
    48      * the identification used in language.cpp.
       
    49      */
       
    50     virtual QCString idLanguage()
       
    51     { return "serbian"; }
       
    52     
       
    53     /*! Used to get the LaTeX command(s) for the language support. 
       
    54      *  This method should return string with commands that switch
       
    55      *  LaTeX to the desired language.  For example 
       
    56      *  <pre>"\\usepackage[german]{babel}\n"
       
    57      *  </pre>
       
    58      *  or
       
    59      *  <pre>"\\usepackage{polski}\n"
       
    60      *  "\\usepackage[latin2]{inputenc}\n"
       
    61      *  "\\usepackage[T1]{fontenc}\n"
       
    62      *  </pre>
       
    63      * 
       
    64      * The English LaTeX does not use such commands.  Because of this
       
    65      * the empty string is returned in this implementation.
       
    66      */
       
    67     virtual QCString latexLanguageSupportCommand()
       
    68     {
       
    69       QCString result="\\usepackage[serbian]{babel}\n";
       
    70       return result;
       
    71     }
       
    72 
       
    73     /*! return the language charset. This will be used for the HTML output */
       
    74     virtual QCString idLanguageCharset()
       
    75     {
       
    76 //#ifdef _WIN32
       
    77 //        { return "windows-1250"; }
       
    78 //#else
       
    79         { return "UTF-8"; }
       
    80 //#endif
       
    81     }
       
    82 
       
    83     // --- Language translation methods -------------------
       
    84 
       
    85     /*! used in the compound documentation before a list of related functions. */
       
    86     virtual QCString trRelatedFunctions()
       
    87     //! Čini se da je ovako manje loše nego "Povezane funkcije", 
       
    88     //! što uopšte ne izgleda dobro jer ta kartica sadrži prijatelje i globalne funkcije
       
    89     { return decode( "Relevantne funkcije" ); }  
       
    90 
       
    91     /*! subscript for the related functions. */
       
    92     virtual QCString trRelatedSubscript()
       
    93     { return decode( "(To nisu funkcije članice.)" ); } 
       
    94 
       
    95     /*! header that is put before the detailed description of files, classes and namespaces. */
       
    96     virtual QCString trDetailedDescription()
       
    97     { return decode( "Opširniji opis" ); }
       
    98 
       
    99     /*! header that is put before the list of typedefs. */
       
   100     virtual QCString trMemberTypedefDocumentation()
       
   101     { return decode( "Dokumentacija unutrašnjih definicija tipa" ); }
       
   102     
       
   103     /*! header that is put before the list of enumerations. */
       
   104     virtual QCString trMemberEnumerationDocumentation()
       
   105     //! Ovo je u skladu sa "unutrašnja klasa" što se može videti u knjizi.
       
   106     { return decode( "Dokumentacija unutrašnjih nabrajanja" ); }
       
   107     
       
   108     /*! header that is put before the list of member functions. */
       
   109     virtual QCString trMemberFunctionDocumentation()
       
   110     { return decode( "Dokumentacija funkcija članica" ); }
       
   111     
       
   112     /*! header that is put before the list of member attributes. */
       
   113     virtual QCString trMemberDataDocumentation()
       
   114     { 
       
   115       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   116       {
       
   117         return decode( "Dokumentacija polja" ); 
       
   118       }
       
   119       else
       
   120       {
       
   121         return decode( "Dokumentacija atributa" ); 
       
   122       }
       
   123     }
       
   124 
       
   125     /*! this is the text of a link put after brief descriptions. */
       
   126     virtual QCString trMore() 
       
   127     { return decode( "Još..." ); }
       
   128 
       
   129     /*! put in the class documentation */
       
   130     virtual QCString trListOfAllMembers()
       
   131     { return decode( "Spisak svih članova." ); }
       
   132 
       
   133     /*! used as the title of the "list of all members" page of a class */
       
   134     virtual QCString trMemberList()
       
   135     { return decode( "Spisak članova" ); }
       
   136 
       
   137     /*! this is the first part of a sentence that is followed by a class name */
       
   138     virtual QCString trThisIsTheListOfAllMembers()
       
   139     { return decode( "Ovo je spisak svih članova " ); }
       
   140 
       
   141     /*! this is the remainder of the sentence after the class name */
       
   142     virtual QCString trIncludingInheritedMembers()
       
   143     { return decode( ", uključujući nasleđene članove." ); }
       
   144     
       
   145     /*! this is put at the author sections at the bottom of man pages.
       
   146      *  parameter s is name of the project name.
       
   147      */
       
   148     virtual QCString trGeneratedAutomatically(const char *s)
       
   149     { QCString result="Napravljeno automatski korišćenjem alata Doxygen";
       
   150       if( s ) result+=(QCString)" za projekat " + s;
       
   151       result+=" od izvornog koda."; 
       
   152       return decode( result );
       
   153     }
       
   154 
       
   155     /*! put after an enum name in the list of all members */
       
   156     virtual QCString trEnumName()
       
   157     { return decode( "ime nabrajanja " ); }
       
   158     
       
   159     /*! put after an enum value in the list of all members */
       
   160     virtual QCString trEnumValue()
       
   161     { return decode( "vrednost nabrojane konstante" ); }
       
   162     
       
   163     /*! put after an undocumented member in the list of all members */
       
   164     virtual QCString trDefinedIn()
       
   165     { return decode( "definicija u" ); }
       
   166 
       
   167     // quick reference sections
       
   168 
       
   169     /*! This is put above each page as a link to the list of all groups of 
       
   170      *  compounds or files (see the \\group command).
       
   171      */
       
   172     virtual QCString trModules()
       
   173     { return decode( "Moduli" ); }
       
   174     
       
   175     /*! This is put above each page as a link to the class hierarchy */
       
   176     virtual QCString trClassHierarchy()
       
   177     { return decode( "Hijerarhija klasa" ); }
       
   178     
       
   179     /*! This is put above each page as a link to the list of annotated classes */
       
   180     virtual QCString trCompoundList()
       
   181     { 
       
   182       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   183       {
       
   184         return decode( "Spisak struktura" );
       
   185       }
       
   186       else
       
   187       {
       
   188         return decode( "Spisak klasa" ); 
       
   189       }
       
   190     }
       
   191     
       
   192     /*! This is put above each page as a link to the list of documented files */
       
   193     virtual QCString trFileList()
       
   194     { return decode( "Spisak datoteka" ); }
       
   195 
       
   196     /*! This is put above each page as a link to all members of compounds. */
       
   197     virtual QCString trCompoundMembers()
       
   198     { 
       
   199       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   200       {
       
   201         return decode( "Sva polja struktura" ); 
       
   202       }
       
   203       else
       
   204       {
       
   205         return decode( "Svi članovi klasa" ); 
       
   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 decode( "Članovi datoteke" ); 
       
   215       }
       
   216       else
       
   217       {
       
   218        return decode( "Članovi datoteke" ); 
       
   219       }
       
   220     }
       
   221 
       
   222     /*! This is put above each page as a link to all related pages. */
       
   223     virtual QCString trRelatedPages()
       
   224     { return decode( "Stranice koje imaju veze sa ovom stranicom" ); }
       
   225 
       
   226     /*! This is put above each page as a link to all examples. */
       
   227     virtual QCString trExamples()
       
   228     { return decode( "Primeri" ); }
       
   229 
       
   230     /*! This is put above each page as a link to the search engine. */
       
   231     virtual QCString trSearch()
       
   232     { return decode( "Traži" ); }
       
   233 
       
   234     /*! This is an introduction to the class hierarchy. */
       
   235     virtual QCString trClassHierarchyDescription()
       
   236     { return decode( "Hijerahija klasa uređena približno "
       
   237                      "po abecedi:" ); 
       
   238 	}
       
   239 
       
   240     /*! This is an introduction to the list with all files. */
       
   241     virtual QCString trFileListDescription(bool extractAll)
       
   242     {
       
   243       QCString result="Spisak svih ";
       
   244       if (!extractAll) result+="dokumentovanih ";
       
   245       result+="datoteka, sa kratkim opisima:";
       
   246       return decode( result );
       
   247     }
       
   248 
       
   249     /*! This is an introduction to the annotated compound list. */
       
   250     virtual QCString trCompoundListDescription()
       
   251     { 
       
   252       
       
   253       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   254       {
       
   255         return decode( "Spisak struktura sa kratkim opisima:" ); 
       
   256       }
       
   257       else
       
   258       {
       
   259         return decode( "Spisak klasa, struktura, "
       
   260                        "unija i interfejsa sa kratkim opisima:" );
       
   261       }
       
   262     }
       
   263 
       
   264     /*! This is an introduction to the page with all class members. */
       
   265     virtual QCString trCompoundMembersDescription(bool extractAll)
       
   266     {
       
   267       QCString result="Spisak svih ";
       
   268       if (!extractAll)
       
   269       {
       
   270         result+="dokumentovanih ";
       
   271       }
       
   272       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   273       {
       
   274         result+="članova struktura/unija";
       
   275       }
       
   276       else
       
   277       {
       
   278         result+="članova klasa";
       
   279       }
       
   280       result+=" sa vezama ka ";
       
   281       if (extractAll) 
       
   282       {
       
   283         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   284         {
       
   285           result+="dokumentaciji svakog polja strukture/unije:";  
       
   286         }
       
   287         else
       
   288         {
       
   289           result+="dokumentaciji svakog člana klase:";       
       
   290         }
       
   291       }
       
   292       else 
       
   293       {
       
   294         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   295         {
       
   296           result+="strukturama/unijama kojima pripadaju:";
       
   297         }
       
   298         else
       
   299         {
       
   300           result+="klasama kojima pripadaju:"; 
       
   301         }
       
   302       }
       
   303       return decode( result );
       
   304     }
       
   305 
       
   306     /*! This is an introduction to the page with all file members. */
       
   307     virtual QCString trFileMembersDescription(bool extractAll)
       
   308     {
       
   309       QCString result="Spisak svih ";
       
   310       if (!extractAll) result+="dokumentovanih ";
       
   311       
       
   312       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   313       {
       
   314         result+="funkcija, promenljivih, makro zamena, nabrajanja i definicija tipa";
       
   315       }
       
   316       else
       
   317       {
       
   318         result+="članova";               
       
   319       }
       
   320       result+=" sa vezama ka ";
       
   321       if (extractAll) 
       
   322         result+="datotekama u kojima se nalaze:";
       
   323       else 
       
   324         result+="dokumentaciji:";
       
   325       return decode( result );
       
   326     }
       
   327 
       
   328     /*! This is an introduction to the page with the list of all examples */
       
   329     virtual QCString trExamplesDescription()
       
   330     { return decode( "Spisak svih primera:" ); }
       
   331 
       
   332     /*! This is an introduction to the page with the list of related pages */
       
   333     virtual QCString trRelatedPagesDescription()
       
   334     { return decode( "Spisak stranica koje imaju veze sa ovom stranicom:" ); }
       
   335 
       
   336     /*! This is an introduction to the page with the list of class/file groups */
       
   337     virtual QCString trModulesDescription()
       
   338     { return decode( "Spisak svih modula:" ); }
       
   339 
       
   340     // index titles (the project name is prepended for these) 
       
   341 
       
   342     /*! This is used in HTML as the title of index.html. */
       
   343     virtual QCString trDocumentation()
       
   344     { return decode("Dokumentacija" ); }
       
   345 
       
   346     /*! This is used in LaTeX as the title of the chapter with the 
       
   347      * index of all groups.
       
   348      */
       
   349     virtual QCString trModuleIndex()
       
   350     { return decode( "Indeks modula" ); }
       
   351 
       
   352     /*! This is used in LaTeX as the title of the chapter with the 
       
   353      * class hierarchy.
       
   354      */
       
   355     virtual QCString trHierarchicalIndex()
       
   356     { return decode( "Hijerarhijski sadržaj" ); }
       
   357 
       
   358     /*! This is used in LaTeX as the title of the chapter with the 
       
   359      * annotated compound index.
       
   360      */
       
   361     virtual QCString trCompoundIndex()
       
   362     {
       
   363       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   364       { 
       
   365         return decode( "Spisak struktura/unija" ); 
       
   366       }
       
   367       else
       
   368       {
       
   369         return decode( "Spisak klasa" ); 
       
   370       }
       
   371     }
       
   372 
       
   373     /*! This is used in LaTeX as the title of the chapter with the
       
   374      * list of all files.
       
   375      */
       
   376     virtual QCString trFileIndex() 
       
   377     { return decode( "Indeks datoteka" ); }
       
   378 
       
   379     /*! This is used in LaTeX as the title of the chapter containing
       
   380      *  the documentation of all groups.
       
   381      */
       
   382     virtual QCString trModuleDocumentation()
       
   383     { return decode( "Dokumentacija modula" ); }
       
   384 
       
   385     /*! This is used in LaTeX as the title of the chapter containing
       
   386      *  the documentation of all classes, structs and unions.
       
   387      */
       
   388     virtual QCString trClassDocumentation()
       
   389     { 
       
   390       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   391       {
       
   392         return decode( "Dokumentacija stuktura/unija" ); 
       
   393       }
       
   394       else
       
   395       {
       
   396         return decode( "Dokumentacija klasa" ); 
       
   397       }
       
   398     }
       
   399 
       
   400     /*! This is used in LaTeX as the title of the chapter containing
       
   401      *  the documentation of all files.
       
   402      */
       
   403     virtual QCString trFileDocumentation()
       
   404     { return decode( "Dokumentacija datoteke" ); }
       
   405 
       
   406     /*! This is used in LaTeX as the title of the chapter containing
       
   407      *  the documentation of all examples.
       
   408      */
       
   409     virtual QCString trExampleDocumentation()
       
   410     { return decode( "Dokumentacija primera" ); }
       
   411 
       
   412     /*! This is used in LaTeX as the title of the chapter containing
       
   413      *  the documentation of all related pages.
       
   414      */
       
   415     virtual QCString trPageDocumentation()
       
   416     { return decode( "Dokumentacija stranice" ); }
       
   417 
       
   418     /*! This is used in LaTeX as the title of the document */
       
   419     virtual QCString trReferenceManual()
       
   420     { return decode( "Priručnik" ); }
       
   421     
       
   422     /*! This is used in the documentation of a file as a header before the 
       
   423      *  list of defines
       
   424      */
       
   425     virtual QCString trDefines()
       
   426     { return decode( "Makro zamene" ); }
       
   427 
       
   428     /*! This is used in the documentation of a file as a header before the 
       
   429      *  list of function prototypes
       
   430      */
       
   431     virtual QCString trFuncProtos()
       
   432     { return decode( "Deklaracije funkcija" ); }
       
   433 
       
   434     /*! This is used in the documentation of a file as a header before the 
       
   435      *  list of typedefs
       
   436      */
       
   437     virtual QCString trTypedefs()
       
   438     { return decode( "Definicije tipa" ); }
       
   439 
       
   440     /*! This is used in the documentation of a file as a header before the 
       
   441      *  list of enumerations
       
   442      */
       
   443     virtual QCString trEnumerations()
       
   444     { return decode( "Nabrajanja" ); }
       
   445 
       
   446     /*! This is used in the documentation of a file as a header before the 
       
   447      *  list of (global) functions
       
   448      */
       
   449     virtual QCString trFunctions()
       
   450     { return decode( "Funkcije" ); }
       
   451 
       
   452     /*! This is used in the documentation of a file as a header before the 
       
   453      *  list of (global) variables
       
   454      */
       
   455     virtual QCString trVariables()
       
   456     { return decode( "Promenljive" ); }
       
   457 
       
   458     /*! This is used in the documentation of a file as a header before the 
       
   459      *  list of (global) variables
       
   460      */
       
   461     virtual QCString trEnumerationValues()
       
   462     { return decode( "Vrednosti nabrojanih konstanti" ); }
       
   463     
       
   464     /*! This is used in the documentation of a file before the list of
       
   465      *  documentation blocks for defines
       
   466      */
       
   467     virtual QCString trDefineDocumentation()
       
   468     { return decode( "Dokumentacija makro zamene" ); }
       
   469 
       
   470     /*! This is used in the documentation of a file/namespace before the list 
       
   471      *  of documentation blocks for function prototypes
       
   472      */
       
   473     virtual QCString trFunctionPrototypeDocumentation()
       
   474     { return decode( "Dokumentacija deklaracije funkcije" ); }
       
   475 
       
   476     /*! This is used in the documentation of a file/namespace before the list 
       
   477      *  of documentation blocks for typedefs
       
   478      */
       
   479     virtual QCString trTypedefDocumentation()
       
   480     { return decode( "Dokumentacija definicije tipa" ); }
       
   481 
       
   482     /*! This is used in the documentation of a file/namespace before the list 
       
   483      *  of documentation blocks for enumeration types
       
   484      */
       
   485     virtual QCString trEnumerationTypeDocumentation()
       
   486     { return decode( "Dokumentacija nabrajanja" ); }
       
   487 
       
   488     /*! This is used in the documentation of a file/namespace before the list 
       
   489      *  of documentation blocks for functions
       
   490      */
       
   491     virtual QCString trFunctionDocumentation()
       
   492     { return decode( "Dokumentacija funkcije" ); }
       
   493 
       
   494     /*! This is used in the documentation of a file/namespace before the list 
       
   495      *  of documentation blocks for variables
       
   496      */
       
   497     virtual QCString trVariableDocumentation()
       
   498     { return decode( "Dokumentacija promenljive" ); }
       
   499 
       
   500     /*! This is used in the documentation of a file/namespace/group before 
       
   501      *  the list of links to documented compounds
       
   502      */
       
   503     virtual QCString trCompounds()
       
   504     { 
       
   505       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   506       {
       
   507         return decode( "Strukture i unije" );  
       
   508       }
       
   509       else
       
   510       {
       
   511         return decode( "Klase, strukture i unije" );   
       
   512       }
       
   513     }
       
   514 
       
   515     /*! This is used in the standard footer of each page and indicates when 
       
   516      *  the page was generated 
       
   517      */
       
   518     virtual QCString trGeneratedAt(const char *date,const char *projName)
       
   519     { 
       
   520       QCString result=(QCString)"[" + date + "] Napravljeno automatski ";
       
   521       if ( projName ) result+=(QCString)" za projekat " + projName;
       
   522 	  result+=(QCString)" upotrebom ";
       
   523       return decode( result );
       
   524     }
       
   525     /*! This is part of the sentence used in the standard footer of each page.
       
   526      */
       
   527     virtual QCString trWrittenBy()
       
   528     {
       
   529       return decode( "napisao" );
       
   530     }
       
   531 
       
   532     /*! this text is put before a class diagram */
       
   533     virtual QCString trClassDiagram(const char *clName)
       
   534     {
       
   535       return decode( QCString("Dijagram nasleđivanja za klasu ") + clName + ":" );
       
   536     }
       
   537     
       
   538     /*! this text is generated when the \\internal command is used. */
       
   539     virtual QCString trForInternalUseOnly()
       
   540     { return decode( "Samo za unutrašnju upotrebu." ); }
       
   541 
       
   542     /*! this text is generated when the \\warning command is used. */
       
   543     virtual QCString trWarning()
       
   544     { return decode( "Upozorenje" ); }
       
   545 
       
   546     /*! this text is generated when the \\version command is used. */
       
   547     virtual QCString trVersion()
       
   548     { return decode( "Verzija" ); }
       
   549 
       
   550     /*! this text is generated when the \\date command is used. */
       
   551     virtual QCString trDate()
       
   552     { return decode( "Datum" ); }
       
   553 
       
   554     /*! this text is generated when the \\return command is used. */
       
   555     virtual QCString trReturns()
       
   556     { return decode( "Vrednost funkcije" ); }
       
   557 
       
   558     /*! this text is generated when the \\sa command is used. */
       
   559     virtual QCString trSeeAlso()
       
   560     { return decode( "Takođe pogledati" ); }
       
   561 
       
   562     /*! this text is generated when the \\param command is used. */
       
   563     virtual QCString trParameters()
       
   564     { return decode( "Parametri" ); }
       
   565 
       
   566     /*! this text is generated when the \\exception command is used. */
       
   567     virtual QCString trExceptions()
       
   568     { return decode( "Izuzeci" ); }
       
   569     
       
   570     /*! this text is used in the title page of a LaTeX document. */
       
   571     virtual QCString trGeneratedBy()
       
   572     { return decode( "Napravio" ); }
       
   573 
       
   574 //////////////////////////////////////////////////////////////////////////
       
   575 // new since 0.49-990307
       
   576 //////////////////////////////////////////////////////////////////////////
       
   577     
       
   578     /*! used as the title of page containing all the index of all namespaces. */
       
   579     virtual QCString trNamespaceList()
       
   580     { return decode( "Spisak prostora imena" ); }
       
   581 
       
   582     /*! used as an introduction to the namespace list */
       
   583     virtual QCString trNamespaceListDescription(bool extractAll)
       
   584     {
       
   585       QCString result="Spisak svih ";
       
   586       if (!extractAll) result+="dokumentovanih ";
       
   587       result+="prostora imena sa kratkim opisom:";
       
   588       return decode( result );
       
   589     }
       
   590 
       
   591     /*! used in the class documentation as a header before the list of all
       
   592      *  friends of a class
       
   593      */
       
   594     virtual QCString trFriends()
       
   595     { return decode( "Prijatelji" ); }
       
   596     
       
   597 //////////////////////////////////////////////////////////////////////////
       
   598 // new since 0.49-990405
       
   599 //////////////////////////////////////////////////////////////////////////
       
   600     
       
   601     /*! used in the class documentation as a header before the list of all
       
   602      * related classes 
       
   603      */
       
   604     virtual QCString trRelatedFunctionDocumentation()
       
   605     { return decode( "Dokumentacija prijatelja i relevantnih funkcija" ); }
       
   606     
       
   607 //////////////////////////////////////////////////////////////////////////
       
   608 // new since 0.49-990425
       
   609 //////////////////////////////////////////////////////////////////////////
       
   610 
       
   611     /*! used as the title of the HTML page of a class/struct/union */
       
   612     virtual QCString trCompoundReference(const char *clName,
       
   613                                     ClassDef::CompoundType compType,
       
   614                                     bool isTemplate)
       
   615     {                            
       
   616       QCString result( "Dokumentacija " );   
       
   617       switch(compType)
       
   618       {
       
   619         case ClassDef::Class:      result+="klase "; break;
       
   620         case ClassDef::Struct:     result+="strukture "; break;
       
   621         case ClassDef::Union:      result+="unije "; break;
       
   622         case ClassDef::Interface:  result+="interfejsa "; break;
       
   623         case ClassDef::Protocol:   result+="protokola "; break;
       
   624         case ClassDef::Category:   result+="kategorije "; break;
       
   625         case ClassDef::Exception:  result+="izuzetka "; break;
       
   626       }
       
   627       if (isTemplate) result += "šablona ";  
       
   628       result += clName;
       
   629       return decode( result );
       
   630     }
       
   631 
       
   632     /*! used as the title of the HTML page of a file */
       
   633     virtual QCString trFileReference(const char *fileName)
       
   634     {
       
   635       QCString result = "Opis datoteke ";
       
   636       result += fileName; 
       
   637       return decode( result );
       
   638     }
       
   639 
       
   640     /*! used as the title of the HTML page of a namespace */
       
   641     virtual QCString trNamespaceReference(const char *namespaceName)
       
   642     {
       
   643       QCString result="Opis prostora imena ";
       
   644       result += namespaceName;
       
   645       return decode( result );
       
   646     }
       
   647     
       
   648     virtual QCString trPublicMembers()
       
   649     { return decode("Javni članovi"); }
       
   650     virtual QCString trPublicSlots()
       
   651     { return decode( "Javni slotovi" ); }
       
   652     virtual QCString trSignals()
       
   653     { return decode( "Signali" ); }
       
   654     virtual QCString trStaticPublicMembers()
       
   655     { return decode("Zajednički javni članovi"); }
       
   656     virtual QCString trProtectedMembers()
       
   657     { return decode("Zaštićeni članovi");  }
       
   658     virtual QCString trProtectedSlots()
       
   659     { return decode("Zaštićeni slotovi"); }
       
   660     virtual QCString trStaticProtectedMembers()
       
   661     { return decode("Zajednički zaštićeni članovi"); }
       
   662     virtual QCString trPrivateMembers()
       
   663     { return decode("Privatni članovi"); }
       
   664     virtual QCString trPrivateSlots()
       
   665     { return decode("Privatni slotovi"); }
       
   666     virtual QCString trStaticPrivateMembers()
       
   667     { return decode("Zajednički privatni članovi"); }
       
   668     
       
   669     /*! this function is used to produce a comma-separated list of items.
       
   670      *  use generateMarker(i) to indicate where item i should be put.
       
   671      */
       
   672     virtual QCString trWriteList(int numEntries)
       
   673     {
       
   674       QCString result;
       
   675       int i;
       
   676       // the inherits list contain `numEntries' classes
       
   677       for (i=0;i<numEntries;i++) 
       
   678       {
       
   679         // use generateMarker to generate placeholders for the class links!
       
   680         result+=generateMarker(i); // generate marker for entry i in the list 
       
   681                                    // (order is left to right)
       
   682         
       
   683         if (i!=numEntries-1)  // not the last entry, so we need a separator
       
   684         {
       
   685           if (i<numEntries-2) // not the fore last entry 
       
   686             result+=", ";
       
   687           else                // the fore last entry
       
   688             result+=" i ";
       
   689         }
       
   690       }
       
   691       return result; 
       
   692     }
       
   693     
       
   694     /*! used in class documentation to produce a list of base classes,
       
   695      *  if class diagrams are disabled.
       
   696      */
       
   697     virtual QCString trInheritsList(int numEntries)
       
   698     {
       
   699       return decode("Spisak osnovnih klasa: "+trWriteList(numEntries)+".");
       
   700     }
       
   701 
       
   702     /*! used in class documentation to produce a list of derived classes,
       
   703      *  if class diagrams are disabled.
       
   704      */
       
   705     virtual QCString trInheritedByList(int numEntries)
       
   706     {
       
   707       return decode( "Spisak izvedenih klasa: "+trWriteList(numEntries)+"." );
       
   708     }
       
   709 
       
   710     /*! used in member documentation blocks to produce a list of 
       
   711      *  members that are hidden by this one.
       
   712      */
       
   713     virtual QCString trReimplementedFromList(int numEntries)
       
   714     {
       
   715       return decode("Menja definiciju iz "+trWriteList(numEntries)+"." );
       
   716     }
       
   717 
       
   718     /*! used in member documentation blocks to produce a list of
       
   719      *  all member that overwrite the implementation of this member.
       
   720      */
       
   721     virtual QCString trReimplementedInList(int numEntries)
       
   722     { //! Ako već ne možemo jednu reč (redefinicija), da uskladimo sa prethodnim i izbacimo upotrebu roda
       
   723       return decode("Definicija je izmenjena u "+trWriteList(numEntries)+"." );
       
   724     }
       
   725 
       
   726     /*! This is put above each page as a link to all members of namespaces. */
       
   727     virtual QCString trNamespaceMembers()
       
   728     { return decode("Članovi prostora imena"); }
       
   729 
       
   730     /*! This is an introduction to the page with all namespace members */
       
   731     virtual QCString trNamespaceMemberDescription(bool extractAll)
       
   732     { 
       
   733       QCString result="Spisak svih ";
       
   734       if (!extractAll) result+="dokumentovanih ";
       
   735       result+="članova prostora imena sa vezama prema ";
       
   736       if (extractAll) 
       
   737         result+="dokumentaciji svakog člana prostora imena: ";
       
   738       else 
       
   739         result+="prostorima imena kojima pripadaju: ";
       
   740       return decode( result );
       
   741     }
       
   742     /*! This is used in LaTeX as the title of the chapter with the 
       
   743      *  index of all namespaces.
       
   744      */
       
   745     virtual QCString trNamespaceIndex()
       
   746     { return decode( "Indeks prostora imena" ); }
       
   747 
       
   748     /*! This is used in LaTeX as the title of the chapter containing
       
   749      *  the documentation of all namespaces.
       
   750      */
       
   751     virtual QCString trNamespaceDocumentation()
       
   752     { return decode( "Dokumentacija prostora imena" ); }
       
   753 
       
   754 //////////////////////////////////////////////////////////////////////////
       
   755 // new since 0.49-990522
       
   756 //////////////////////////////////////////////////////////////////////////
       
   757 
       
   758     /*! This is used in the documentation before the list of all
       
   759      *  namespaces in a file.
       
   760      */
       
   761     virtual QCString trNamespaces()
       
   762     { return decode( "Prostori imena" ); }
       
   763 
       
   764 //////////////////////////////////////////////////////////////////////////
       
   765 // new since 0.49-990728
       
   766 //////////////////////////////////////////////////////////////////////////
       
   767 
       
   768     /*! This is put at the bottom of a class documentation page and is
       
   769      *  followed by a list of files that were used to generate the page.
       
   770      */
       
   771     virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
       
   772         bool single)
       
   773     { // here s is one of " Class", " Struct" or " Union"
       
   774       // single is true implies a single file
       
   775       QCString result=(QCString)"Dokumentacija ";
       
   776       switch(compType)
       
   777       {
       
   778         case ClassDef::Class:      result+="ove klase"; break;
       
   779         case ClassDef::Struct:     result+="ove strukture"; break;
       
   780         case ClassDef::Union:      result+="ove unije"; break;
       
   781         case ClassDef::Interface:  result+="ovog interfejsa"; break;
       
   782         case ClassDef::Protocol:   result+="ovog protokola"; break;
       
   783         case ClassDef::Category:   result+="ove kategorije"; break;
       
   784         case ClassDef::Exception:  result+="ovog izuzetka"; break;
       
   785       }
       
   786       result+=" je napravljena na osnovu ";
       
   787       if (single) result+="datoteke "; else result+="sledećih datoteka:";
       
   788       return decode( result );
       
   789     }
       
   790 
       
   791     /*! This is in the (quick) index as a link to the alphabetical compound
       
   792      * list.
       
   793      */
       
   794     virtual QCString trAlphabeticalList()
       
   795     { return decode( "Abecedni spisak" ); }
       
   796 
       
   797 //////////////////////////////////////////////////////////////////////////
       
   798 // new since 0.49-990901
       
   799 //////////////////////////////////////////////////////////////////////////
       
   800 
       
   801     /*! This is used as the heading text for the retval command. */
       
   802     virtual QCString trReturnValues()
       
   803     { return decode( "Karakteristične vrednosti funkcije" ); }
       
   804 
       
   805     /*! This is in the (quick) index as a link to the main page (index.html)
       
   806      */
       
   807     virtual QCString trMainPage()
       
   808     { return decode( "Glavna strana" ); }
       
   809 
       
   810     /*! This is used in references to page that are put in the LaTeX 
       
   811      *  documentation. It should be an abbreviation of the word page.
       
   812      */
       
   813     virtual QCString trPageAbbreviation()
       
   814     { return decode( "str." ); }
       
   815 
       
   816 //////////////////////////////////////////////////////////////////////////
       
   817 // new since 0.49-991003
       
   818 //////////////////////////////////////////////////////////////////////////
       
   819 
       
   820     virtual QCString trDefinedAtLineInSourceFile()
       
   821     { //! Izbacujemo rod
       
   822       return decode( "Definicija je u redu @0 datoteke @1." );
       
   823     }
       
   824     virtual QCString trDefinedInSourceFile()
       
   825     { //! Izbacujemo rod
       
   826       return decode( "Definicija je u datoteci @0." );
       
   827     }
       
   828 
       
   829 //////////////////////////////////////////////////////////////////////////
       
   830 // new since 0.49-991205
       
   831 //////////////////////////////////////////////////////////////////////////
       
   832 
       
   833     virtual QCString trDeprecated()
       
   834     {
       
   835       return decode( "Zastarelo" );
       
   836     }
       
   837 
       
   838 //////////////////////////////////////////////////////////////////////////
       
   839 // new since 1.0.0
       
   840 //////////////////////////////////////////////////////////////////////////
       
   841 
       
   842     /*! this text is put before a collaboration diagram */
       
   843     virtual QCString trCollaborationDiagram(const char *clName)
       
   844     {
       
   845       return decode( (QCString)"Klasni dijagram za "+clName+":" );
       
   846     }
       
   847     /*! this text is put before an include dependency graph */
       
   848     virtual QCString trInclDepGraph(const char *fName)
       
   849     {
       
   850       return decode( (QCString)"Graf zavisnosti datoteka za "+fName+":" );
       
   851     }
       
   852     /*! header that is put before the list of constructor/destructors. */
       
   853     virtual QCString trConstructorDocumentation()
       
   854     {
       
   855       return decode( "Dokumentacija konstruktora i destruktora" ); 
       
   856     }
       
   857     /*! Used in the file documentation to point to the corresponding sources. */
       
   858     virtual QCString trGotoSourceCode()
       
   859     {
       
   860       return decode( "Izvorni kod." );
       
   861     }
       
   862     /*! Used in the file sources to point to the corresponding documentation. */
       
   863     virtual QCString trGotoDocumentation()
       
   864     {
       
   865       return decode( "Dokumentacija." );
       
   866     }
       
   867     /*! Text for the \\pre command */
       
   868     virtual QCString trPrecondition()
       
   869     {
       
   870       return decode( "Preduslovi" );
       
   871     }
       
   872     /*! Text for the \\post command */
       
   873     virtual QCString trPostcondition()
       
   874     {
       
   875       return decode( "Stanje po izvršenju" );
       
   876     }
       
   877     /*! Text for the \\invariant command */
       
   878     virtual QCString trInvariant()
       
   879     {
       
   880       return decode( "Invarijanta" );
       
   881     }
       
   882     /*! Text shown before a multi-line variable/enum initialization */
       
   883     virtual QCString trInitialValue()
       
   884     {
       
   885       return decode( "Početna vrednost:" );
       
   886     }
       
   887     /*! Text used the source code in the file index */
       
   888     virtual QCString trCode()
       
   889     {
       
   890       return decode( "programski kod" );
       
   891     }
       
   892     virtual QCString trGraphicalHierarchy()
       
   893     {
       
   894       return decode( "Hijerarhija klasa u obliku grafa" );
       
   895     }
       
   896     virtual QCString trGotoGraphicalHierarchy()
       
   897     {
       
   898       return decode( "Prikaz hijerarhije klasa u obliku grafa" );
       
   899     }
       
   900     virtual QCString trGotoTextualHierarchy()
       
   901     {
       
   902       return decode( "Prikaz hijerarhije klasa u obliku nazubljenog teksta" );
       
   903     }
       
   904     virtual QCString trPageIndex()
       
   905     {
       
   906       return decode( "Indeks stranice" );
       
   907     }
       
   908 
       
   909 //////////////////////////////////////////////////////////////////////////
       
   910 // new since 1.1.0
       
   911 //////////////////////////////////////////////////////////////////////////
       
   912     
       
   913     virtual QCString trNote()
       
   914     {
       
   915       return decode( "Beleška" ); 
       
   916     }
       
   917     virtual QCString trPublicTypes()
       
   918     {
       
   919       return decode( "Javni tipovi" );
       
   920     }
       
   921     virtual QCString trPublicAttribs()
       
   922     {
       
   923       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   924       {
       
   925         return decode( "Polja" );        
       
   926       }
       
   927       else
       
   928       {
       
   929         return decode( "Javni članovi" );
       
   930       }
       
   931     }
       
   932     virtual QCString trStaticPublicAttribs()
       
   933     {
       
   934       return decode( "Zajednički javni članovi");
       
   935     }
       
   936     virtual QCString trProtectedTypes()
       
   937     {
       
   938       return decode( "Zaštićeni tipovi" );
       
   939     }
       
   940     virtual QCString trProtectedAttribs()
       
   941     {
       
   942       return decode( "Zaštićeni članovi" );
       
   943     }
       
   944     virtual QCString trStaticProtectedAttribs()
       
   945     {
       
   946       return decode( "Zajednički zaštićeni članovi" );
       
   947     }
       
   948     virtual QCString trPrivateTypes()
       
   949     {
       
   950       return decode( "Privatni tipovi" );
       
   951     }
       
   952     virtual QCString trPrivateAttribs()
       
   953     {
       
   954       return decode( "Privatni članovi" );
       
   955     }
       
   956     virtual QCString trStaticPrivateAttribs()
       
   957     {
       
   958       return decode( "Zajednički privatni članovi" );
       
   959     }
       
   960 
       
   961 //////////////////////////////////////////////////////////////////////////
       
   962 // new since 1.1.3
       
   963 //////////////////////////////////////////////////////////////////////////
       
   964 
       
   965     /*! Used as a marker that is put before a \\todo item */
       
   966     virtual QCString trTodo()
       
   967     {
       
   968       return decode( "Uraditi" );
       
   969     }
       
   970     /*! Used as the header of the todo list */
       
   971     virtual QCString trTodoList()
       
   972     {
       
   973       return decode("Spisak stvari koje treba uraditi");
       
   974     }
       
   975 
       
   976 //////////////////////////////////////////////////////////////////////////
       
   977 // new since 1.1.4
       
   978 //////////////////////////////////////////////////////////////////////////
       
   979 
       
   980     virtual QCString trReferencedBy()
       
   981     { //! Izbegavanje roda. Uskladjivanje sa trReferences
       
   982       return decode( "Korisnici: " ); 
       
   983     }
       
   984     virtual QCString trRemarks()
       
   985     {
       
   986       return decode( "Napomene" );
       
   987     }
       
   988     virtual QCString trAttention()
       
   989     {
       
   990       return decode( "Pažnja" );
       
   991     }
       
   992     virtual QCString trInclByDepGraph()
       
   993     {
       
   994       return decode("Ovaj graf pokazuje koje datoteke direktno "
       
   995       "ili indirektno uključuju ovu datoteku: ");
       
   996     }
       
   997     virtual QCString trSince()
       
   998     {
       
   999       return decode( "Od" );
       
  1000     }
       
  1001     
       
  1002 //////////////////////////////////////////////////////////////////////////
       
  1003 // new since 1.1.5
       
  1004 //////////////////////////////////////////////////////////////////////////
       
  1005 
       
  1006     /*! title of the graph legend page */
       
  1007     virtual QCString trLegendTitle()
       
  1008     {
       
  1009       return decode( "Objašnjenje korišćenih simbola" );
       
  1010     }
       
  1011     /*! page explaining how the dot graph's should be interpreted 
       
  1012      *  The %A in the text below are to prevent link to classes called "A".
       
  1013      */
       
  1014     virtual QCString trLegendDocs()
       
  1015     {
       
  1016       return decode(        
       
  1017        "Ova stranica objašnjava kako tumačiti grafikone koje je napravio "
       
  1018         "doxygen.<p>\n"
       
  1019         "Na primer:\n"
       
  1020         "\\code\n"
       
  1021         "/*! Klasa nevidljiva zbog trenutnih ograničenja */\n"
       
  1022         "class Invisible { };\n\n"
       
  1023         "/*! Klasa kojoj se ne vidi način izvođenja */\n"
       
  1024         "class Truncated : public Invisible { };\n\n"
       
  1025         "/* Klasa bez doxygen komentara */\n"
       
  1026         "class Undocumented { };\n\n"
       
  1027         "/*! Klasa izvedena iz osnovne klase javnim izvođenjem */\n"
       
  1028         "class PublicBase : public Truncated { };\n\n"
       
  1029         "/*! Šablonska klasa */\n"
       
  1030         "template<class T> class Templ { };\n\n"
       
  1031         "/*! Klasa izvedena iz osnovne klase zaštićenim izvođenjem */\n"
       
  1032         "class ProtectedBase { };\n\n"
       
  1033         "/*! Klasa izvedena iz osnovne klase privatnim izvođenjem */\n"
       
  1034         "class PrivateBase { };\n\n"
       
  1035         "/*! Klasa korišćena u nekoj/nekim od drugih klasa */\n"
       
  1036         "class Used { };\n\n"
       
  1037         "/*! Klasa izvedena iz više osnovnih klasa */\n"
       
  1038         "class Inherited : public PublicBase,\n"
       
  1039         "                  protected ProtectedBase,\n"
       
  1040         "                  private PrivateBase,\n"
       
  1041         "                  public Undocumented,\n"
       
  1042         "                  public Templ<int>\n"
       
  1043         "{\n"
       
  1044         "  private:\n"
       
  1045         "    Used *m_usedClass;\n"
       
  1046         "};\n"
       
  1047         "\\endcode\n"
       
  1048         "Ako je \\c MAX_DOT_GRAPH_HEIGHT tag u konfiguracionoj datoteci "
       
  1049         "postavljen na \\c 200 graf izvođenja će izgledati ovako:"
       
  1050         "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
       
  1051         "Graf će biti odsečen ako ne stane unutar zadatih granica.\n"
       
  1052         "<p>\n"
       
  1053         "Pravougaonici imaju sledeća značenja:\n"
       
  1054         "<ul>\n"
       
  1055          "<li>Puni sivi predstavlja strukturu ili klasu za koju je graf napravljen.\n"
       
  1056          "<li>Sa crnom ivicom predstavlja dokumentovanu strukturu ili klasu.\n"
       
  1057          "<li>Sa sivom ivicom predstavlja strukturu ili klasu bez doxygen komentara.\n"
       
  1058          "<li>Sa crvenom ivicom predstavlja dokumentovanu strukturu ili klasu\n"
       
  1059          "za koju nisu prikazani svi relevantni grafovi.\n"
       
  1060          "</ul>" 
       
  1061         "Strelice imaju sledeća značenja:\n"
       
  1062         "<ul>\n"
       
  1063          "<li>Tamnoplava strelica označava javno izvođenje.\n"
       
  1064          "<li>Tamnozelena strelica označava zaštićeno izvođenje.\n"
       
  1065          "<li>Tamnocrvena strelica označava privatno izvođenje.\n"
       
  1066          "<li>Ljubičasta isprekidana strelica označava da je klasa sadržana "
       
  1067           "ili korišćena u drugoj klasi. Strelica je označena imenom atributa "
       
  1068           "preko koga se pristupa klasi/strukturi na koju pokazuje.\n"
       
  1069          "<li>Žuta isprekidana strelica označava vezu između primerka šablona i"
       
  1070           " šablona klase od kojeg je primerak napravljen. "
       
  1071           "Strelica je označena stvarnim argumentima šablona.\n"
       
  1072         "</ul>\n"
       
  1073          );
       
  1074     }
       
  1075     /*! text for the link to the legend page */
       
  1076     virtual QCString trLegend()
       
  1077     {
       
  1078       return decode( "Objašnjenje korišćenih simbola" );
       
  1079     }
       
  1080     
       
  1081 //////////////////////////////////////////////////////////////////////////
       
  1082 // new since 1.2.0
       
  1083 //////////////////////////////////////////////////////////////////////////
       
  1084     
       
  1085     /*! Used as a marker that is put before a test item */
       
  1086     virtual QCString trTest()
       
  1087     {
       
  1088       return decode( "Test" );
       
  1089     }
       
  1090     /*! Used as the header of the test list */
       
  1091     virtual QCString trTestList()
       
  1092     {
       
  1093       return decode( "Spisak testova" );
       
  1094     }
       
  1095 
       
  1096 //////////////////////////////////////////////////////////////////////////
       
  1097 // new since 1.2.1
       
  1098 //////////////////////////////////////////////////////////////////////////
       
  1099 
       
  1100     /*! Used as a section header for KDE-2 IDL methods */
       
  1101     virtual QCString trDCOPMethods()
       
  1102     {
       
  1103       return decode( "DCOP metode" );
       
  1104     }
       
  1105 
       
  1106 //////////////////////////////////////////////////////////////////////////
       
  1107 // new since 1.2.2
       
  1108 //////////////////////////////////////////////////////////////////////////
       
  1109 
       
  1110     /*! Used as a section header for IDL properties */
       
  1111     virtual QCString trProperties()
       
  1112     {
       
  1113       return decode( "Osobine" );
       
  1114     }
       
  1115     /*! Used as a section header for IDL property documentation */
       
  1116     virtual QCString trPropertyDocumentation()
       
  1117     {
       
  1118       return decode( "Dokumentacija osobina" );
       
  1119     }
       
  1120 
       
  1121 //////////////////////////////////////////////////////////////////////////
       
  1122 // new since 1.2.4
       
  1123 //////////////////////////////////////////////////////////////////////////
       
  1124 
       
  1125     /*! Used for Java classes in the summary section of Java packages */
       
  1126     virtual QCString trClasses()
       
  1127     {
       
  1128       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
  1129       {
       
  1130         return decode( "Strukture i unije" );
       
  1131       }
       
  1132       else
       
  1133       {
       
  1134         return decode( "Klase" );
       
  1135       }
       
  1136     }
       
  1137     /*! Used as the title of a Java package */
       
  1138     virtual QCString trPackage(const char *name)
       
  1139     {
       
  1140       return (QCString)"Paket "+name;
       
  1141     }
       
  1142     /*! Title of the package index page */
       
  1143     virtual QCString trPackageList()
       
  1144     {
       
  1145       return decode( "Spisak paketa" );
       
  1146     }
       
  1147     /*! The description of the package index page */
       
  1148     virtual QCString trPackageListDescription()
       
  1149     {
       
  1150       return decode( "Paketi s kratkim opisom (ukoliko postoji):" );
       
  1151     }
       
  1152     /*! The link name in the Quick links header for each page */
       
  1153     virtual QCString trPackages()
       
  1154     {
       
  1155       return decode( "Paketi" );
       
  1156     }
       
  1157     /*! Text shown before a multi-line define */
       
  1158     virtual QCString trDefineValue()
       
  1159     {
       
  1160       return decode( "Vrednost:" );
       
  1161     }
       
  1162     
       
  1163 //////////////////////////////////////////////////////////////////////////
       
  1164 // new since 1.2.5
       
  1165 //////////////////////////////////////////////////////////////////////////
       
  1166     
       
  1167     /*! Used as a marker that is put before a \\bug item */
       
  1168     virtual QCString trBug()
       
  1169     {
       
  1170       return decode( "Greška" );
       
  1171     }
       
  1172     /*! Used as the header of the bug list */
       
  1173     virtual QCString trBugList()
       
  1174     {
       
  1175       return decode( "Spisak grešaka" );
       
  1176     }
       
  1177 
       
  1178 //////////////////////////////////////////////////////////////////////////
       
  1179 // new since 1.2.6
       
  1180 //////////////////////////////////////////////////////////////////////////
       
  1181 
       
  1182     /*! Used as ansicpg for RTF file 
       
  1183      * 
       
  1184      * The following table shows the correlation of Charset name, Charset Value and 
       
  1185      * <pre>
       
  1186      * Codepage number:
       
  1187      * Charset Name       Charset Value(hex)  Codepage number
       
  1188      * ------------------------------------------------------
       
  1189      * DEFAULT_CHARSET           1 (x01)
       
  1190      * SYMBOL_CHARSET            2 (x02)
       
  1191      * OEM_CHARSET             255 (xFF)
       
  1192      * ANSI_CHARSET              0 (x00)            1252
       
  1193      * RUSSIAN_CHARSET         204 (xCC)            1251
       
  1194      * EE_CHARSET              238 (xEE)            1250
       
  1195      * GREEK_CHARSET           161 (xA1)            1253
       
  1196      * TURKISH_CHARSET         162 (xA2)            1254
       
  1197      * BALTIC_CHARSET          186 (xBA)            1257
       
  1198      * HEBREW_CHARSET          177 (xB1)            1255
       
  1199      * ARABIC _CHARSET         178 (xB2)            1256
       
  1200      * SHIFTJIS_CHARSET        128 (x80)             932
       
  1201      * HANGEUL_CHARSET         129 (x81)             949
       
  1202      * GB2313_CHARSET          134 (x86)             936
       
  1203      * CHINESEBIG5_CHARSET     136 (x88)             950
       
  1204      * </pre>
       
  1205      * 
       
  1206      */
       
  1207     virtual QCString trRTFansicp()
       
  1208     {
       
  1209       return "1252";
       
  1210     }
       
  1211     
       
  1212 
       
  1213     /*! Used as ansicpg for RTF fcharset 
       
  1214      *  \see trRTFansicp() for a table of possible values.
       
  1215      */
       
  1216     virtual QCString trRTFCharSet()
       
  1217     {
       
  1218       return "238";
       
  1219     }
       
  1220 
       
  1221     /*! Used as header RTF general index */
       
  1222     virtual QCString trRTFGeneralIndex()
       
  1223     {
       
  1224       return decode( "Sadržaj" );
       
  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 trClass(bool first_capital, bool singular)
       
  1232     { 
       
  1233       QCString result( (first_capital ? "Klas" : "klas") );
       
  1234       result+= (singular ? "a" : "e");
       
  1235       return decode( 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 trFile(bool first_capital, bool singular)
       
  1243     { 
       
  1244       QCString result((first_capital ? "Datotek" : "datotek"));
       
  1245       result+= (singular ? "a" : "e");
       
  1246       return decode( 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 trNamespace(bool first_capital, bool singular)
       
  1254     { 
       
  1255       QCString result((first_capital ? "Prostor" : "prostor"));
       
  1256       result += (singular ? "" : "i"); 
       
  1257       result += " imena";
       
  1258       return decode( result ); 
       
  1259     }
       
  1260 
       
  1261     /*! This is used for translation of the word that will possibly
       
  1262      *  be followed by a single name or by a list of names 
       
  1263      *  of the category.
       
  1264      */
       
  1265     virtual QCString trGroup(bool first_capital, bool singular)
       
  1266     { 
       
  1267       QCString result((first_capital ? "Grup" : "grup"));
       
  1268       result+= (singular ? "a" : "e");
       
  1269       return decode( result ); 
       
  1270     }
       
  1271 
       
  1272     /*! This is used for translation of the word that will possibly
       
  1273      *  be followed by a single name or by a list of names 
       
  1274      *  of the category.
       
  1275      */
       
  1276     virtual QCString trPage(bool first_capital, bool singular)
       
  1277     { 
       
  1278       QCString result((first_capital ? "Stran" : "stran"));
       
  1279       result+= (singular ? "a" : "e");
       
  1280       return decode( result ); 
       
  1281     }
       
  1282 
       
  1283     /*! This is used for translation of the word that will possibly
       
  1284      *  be followed by a single name or by a list of names 
       
  1285      *  of the category.
       
  1286      */
       
  1287     virtual QCString trMember(bool first_capital, bool singular)
       
  1288     { 
       
  1289       QCString result((first_capital ? "Član" : "član"));
       
  1290       result+= (singular ? "" : "ovi");
       
  1291       return decode( result ); 
       
  1292     }
       
  1293    
       
  1294     /*! This is used for translation of the word that will possibly
       
  1295      *  be followed by a single name or by a list of names 
       
  1296      *  of the category.
       
  1297      */
       
  1298     virtual QCString trGlobal(bool first_capital, bool singular)
       
  1299     { 
       
  1300       QCString result((first_capital ? "Globalni " : "globalni "));
       
  1301       result+= (singular ? "podatak" : "podaci");
       
  1302       return decode( result ); 
       
  1303     }
       
  1304 
       
  1305 //////////////////////////////////////////////////////////////////////////
       
  1306 // new since 1.2.7
       
  1307 //////////////////////////////////////////////////////////////////////////
       
  1308 
       
  1309     /*! This text is generated when the \\author command is used and
       
  1310      *  for the author section in man pages. */
       
  1311     virtual QCString trAuthor(bool first_capital, bool singular)
       
  1312     {                                                                         
       
  1313       QCString result((first_capital ? "Autor" : "autor"));
       
  1314       result+= (singular ? "" : "i");
       
  1315       return decode( result ); 
       
  1316     }
       
  1317 
       
  1318 //////////////////////////////////////////////////////////////////////////
       
  1319 // new since 1.2.11
       
  1320 //////////////////////////////////////////////////////////////////////////
       
  1321 
       
  1322     /*! This text is put before the list of members referenced by a member
       
  1323      */
       
  1324     virtual QCString trReferences()
       
  1325     {
       
  1326       return decode( "Koristi" );
       
  1327     }
       
  1328 
       
  1329 //////////////////////////////////////////////////////////////////////////
       
  1330 // new since 1.2.13
       
  1331 //////////////////////////////////////////////////////////////////////////
       
  1332 
       
  1333     /*! used in member documentation blocks to produce a list of 
       
  1334      *  members that are implemented by this one.
       
  1335      */
       
  1336     virtual QCString trImplementedFromList(int numEntries)
       
  1337     { //! "Definiše" je previše kratko, ispada sa de definišu same apstraktne klase
       
  1338       return decode( "Definiše apstraktnu funkciju deklarisanu u "+trWriteList(numEntries)+"." );
       
  1339     }
       
  1340 
       
  1341     /*! used in member documentation blocks to produce a list of
       
  1342      *  all members that implement this abstract member.
       
  1343      */
       
  1344     virtual QCString trImplementedInList(int numEntries)
       
  1345     { //! Izbegavanje roda
       
  1346       return decode( "Definicija u " + trWriteList(numEntries) + "." );
       
  1347     }
       
  1348 
       
  1349 //////////////////////////////////////////////////////////////////////////
       
  1350 // new since 1.2.16
       
  1351 //////////////////////////////////////////////////////////////////////////
       
  1352 
       
  1353     /*! used in RTF documentation as a heading for the Table
       
  1354     *  of Contents.
       
  1355          */
       
  1356     virtual QCString trRTFTableOfContents()
       
  1357      {
       
  1358       return decode( "Sadržaj" );
       
  1359      }
       
  1360      
       
  1361 //////////////////////////////////////////////////////////////////////////
       
  1362 // new since 1.2.17
       
  1363 //////////////////////////////////////////////////////////////////////////
       
  1364 
       
  1365     /*! Used as the header of the list of item that have been 
       
  1366      *  flagged deprecated 
       
  1367      */
       
  1368     virtual QCString trDeprecatedList()
       
  1369     {
       
  1370       return decode( "Spisak zastarelih stvari" );
       
  1371     } 
       
  1372 
       
  1373 //////////////////////////////////////////////////////////////////////////
       
  1374 // new since 1.2.18
       
  1375 //////////////////////////////////////////////////////////////////////////
       
  1376 
       
  1377     /*! Used as a header for declaration section of the events found in 
       
  1378      * a C# program
       
  1379      */
       
  1380     virtual QCString trEvents()
       
  1381     {
       
  1382       return decode( "Događaji" );
       
  1383     }
       
  1384     /*! Header used for the documentation section of a class' events. */
       
  1385     virtual QCString trEventDocumentation()
       
  1386     {
       
  1387       return decode( "Dokumentacija događaja" );
       
  1388     }
       
  1389 
       
  1390 //////////////////////////////////////////////////////////////////////////
       
  1391 // new since 1.3
       
  1392 //////////////////////////////////////////////////////////////////////////
       
  1393 
       
  1394     /*! Used as a heading for a list of Java class types with package scope.
       
  1395      */
       
  1396     virtual QCString trPackageTypes()
       
  1397     { 
       
  1398       return decode( "Tipovi u paketu" );
       
  1399     }
       
  1400     /*! Used as a heading for a list of Java class functions with package 
       
  1401      * scope. 
       
  1402      */
       
  1403     virtual QCString trPackageMembers()
       
  1404     { 
       
  1405       return decode( "Funkcije u paketu" );
       
  1406     }
       
  1407     /*! Used as a heading for a list of static Java class functions with 
       
  1408      *  package scope.
       
  1409      */
       
  1410     virtual QCString trStaticPackageMembers()
       
  1411     { 
       
  1412       return decode( "Statičke funkcije u paketu" );  // Zajednicke funkcije u paketu
       
  1413     }
       
  1414     /*! Used as a heading for a list of Java class variables with package 
       
  1415      * scope.
       
  1416      */
       
  1417     virtual QCString trPackageAttribs()
       
  1418     { 
       
  1419       return decode( "Atributi u paketu" ); // Clanovi u paketu
       
  1420     }
       
  1421     /*! Used as a heading for a list of static Java class variables with 
       
  1422      * package scope.
       
  1423      */
       
  1424     virtual QCString trStaticPackageAttribs()
       
  1425     { 
       
  1426       return decode( "Statički atributi u paketu" );  // Zajednicki clanovi u paketu
       
  1427     }
       
  1428     
       
  1429 //////////////////////////////////////////////////////////////////////////
       
  1430 // new since 1.3.1
       
  1431 //////////////////////////////////////////////////////////////////////////
       
  1432 
       
  1433     /*! Used in the quick index of a class/file/namespace member list page 
       
  1434      *  to link to the unfiltered list of all members.
       
  1435      */
       
  1436     virtual QCString trAll()
       
  1437     {
       
  1438       return decode( "Sve" );
       
  1439     }
       
  1440     /*! Put in front of the call graph for a function. */
       
  1441     virtual QCString trCallGraph()
       
  1442     {
       
  1443       return decode( "Graf poziva iz ove funkcije:" );
       
  1444     }
       
  1445 
       
  1446 //////////////////////////////////////////////////////////////////////////
       
  1447 // new since 1.3.3
       
  1448 //////////////////////////////////////////////////////////////////////////
       
  1449 
       
  1450     /*! When the search engine is enabled this text is put in the header 
       
  1451      *  of each page before the field where one can enter the text to search 
       
  1452      *  for. 
       
  1453      */
       
  1454     virtual QCString trSearchForIndex()
       
  1455     {
       
  1456       return decode("Traži");
       
  1457     }
       
  1458     /*! This string is used as the title for the page listing the search
       
  1459      *  results.
       
  1460      */
       
  1461     virtual QCString trSearchResultsTitle()
       
  1462     {
       
  1463       return decode( "Rezultati pretraživanja" );
       
  1464     }
       
  1465     /*! This string is put just before listing the search results. The
       
  1466      *  text can be different depending on the number of documents found.
       
  1467      *  Inside the text you can put the special marker $num to insert
       
  1468      *  the number representing the actual number of search results.
       
  1469      *  The @a numDocuments parameter can be either 0, 1 or 2, where the 
       
  1470      *  value 2 represents 2 or more matches. HTML markup is allowed inside
       
  1471      *  the returned string.
       
  1472      */
       
  1473     virtual QCString trSearchResults(int numDocuments)
       
  1474     {
       
  1475       if (numDocuments==0)
       
  1476       {
       
  1477         return decode("Nema dokumenata koji odgovaraju Vašem upitu.");
       
  1478       }
       
  1479       else if (numDocuments==1)
       
  1480       { return decode("Nađen je <b>1</b> dokument koji odgovara vašem upitu."); }
       
  1481       else if (numDocuments<5) 
       
  1482       { return decode("Nađena su <b>$num</b> dokumenta koji odgovaraju vašem upitu."
       
  1483                     "Najbolji su prikazani prvi."); }
       
  1484       else
       
  1485       { return decode("Nađeno je <b>$num</b> dokumenata koji odgovaraju vašem upitu."
       
  1486         "Najbolji su prikazani prvi.");
       
  1487       }
       
  1488     }
       
  1489     /*! This string is put before the list of matched words, for each search 
       
  1490      *  result. What follows is the list of words that matched the query.
       
  1491      */
       
  1492     virtual QCString trSearchMatches()
       
  1493     {
       
  1494       return decode( "Pronađeno:" );
       
  1495     }
       
  1496 
       
  1497 //////////////////////////////////////////////////////////////////////////
       
  1498 // new since 1.3.8
       
  1499 //////////////////////////////////////////////////////////////////////////
       
  1500 
       
  1501     /*! This is used in HTML as the title of page with source code for file filename
       
  1502      */
       
  1503     virtual QCString trSourceFile(QCString& filename)
       
  1504     {
       
  1505       return decode( "Izvorni kod datoteke " + filename ) ;
       
  1506     }
       
  1507 
       
  1508 //////////////////////////////////////////////////////////////////////////
       
  1509 // new since 1.3.9
       
  1510 //////////////////////////////////////////////////////////////////////////
       
  1511 
       
  1512     /*! This is used as the name of the chapter containing the directory
       
  1513      *  hierarchy.
       
  1514      */
       
  1515     virtual QCString trDirIndex()
       
  1516     { return decode( "Hijerarhija direktorijuma" ); }
       
  1517 
       
  1518     /*! This is used as the name of the chapter containing the documentation
       
  1519      *  of the directories.
       
  1520      */
       
  1521     virtual QCString trDirDocumentation()
       
  1522     { return decode( "Dokumentacija direktorijuma" ); }
       
  1523 
       
  1524     /*! This is used as the title of the directory index and also in the
       
  1525      *  Quick links of a HTML page, to link to the directory hierarchy.
       
  1526      */
       
  1527     virtual QCString trDirectories()
       
  1528     { return decode( "Direktorijumi" ); }
       
  1529 
       
  1530     /*! This returns a sentences that introduces the directory hierarchy. 
       
  1531      *  and the fact that it is sorted alphabetically per level
       
  1532      */
       
  1533     virtual QCString trDirDescription()
       
  1534     { return decode( "Hijerarhija direktorijuma uređena približno "
       
  1535                      "po abecedi:" );
       
  1536     }
       
  1537 
       
  1538     /*! This returns the title of a directory page. The name of the
       
  1539      *  directory is passed via \a dirName.
       
  1540      */
       
  1541     virtual QCString trDirReference(const char *dirName)
       
  1542     { QCString result=dirName; result+="Opis direktorijuma"; return decode( result ); }
       
  1543 
       
  1544     /*! This returns the word directory with or without starting capital
       
  1545      *  (\a first_capital) and in sigular or plural form (\a singular).
       
  1546      */
       
  1547     virtual QCString trDir(bool first_capital, bool singular)
       
  1548     { 
       
  1549       QCString result((first_capital ? "Direktorijum" : "direktorijum"));
       
  1550       if (!singular) result+="i"; 
       
  1551       return decode( result ); 
       
  1552     }
       
  1553 
       
  1554 //////////////////////////////////////////////////////////////////////////
       
  1555 // new since 1.4.1
       
  1556 //////////////////////////////////////////////////////////////////////////
       
  1557 
       
  1558     /*! This text is added to the documentation when the \\overload command
       
  1559      *  is used for a overloaded function.
       
  1560      */
       
  1561     virtual QCString trOverloadText()
       
  1562     {
       
  1563        return decode ( "Ovo je funkcija prekopljenog imena, razlikuje se "
       
  1564               "od gore navedene samo po argumentima koje prihvata." );
       
  1565     }
       
  1566 
       
  1567 //////////////////////////////////////////////////////////////////////////
       
  1568 // new since 1.4.6
       
  1569 //////////////////////////////////////////////////////////////////////////
       
  1570 
       
  1571     /*! This is used to introduce a caller (or called-by) graph */
       
  1572     virtual QCString trCallerGraph()
       
  1573     { //! Možda je bolje "Graf pozivalaca ove funkcije"
       
  1574       return decode( "Graf funkcija koje pozivaju ovu funkciju:" );
       
  1575     }
       
  1576 
       
  1577     /*! This is used in the documentation of a file/namespace before the list 
       
  1578      *  of documentation blocks for enumeration values
       
  1579      */
       
  1580     virtual QCString trEnumerationValueDocumentation()
       
  1581     { return decode( "Dokumentacija enum vrednosti" ); }
       
  1582 
       
  1583 //////////////////////////////////////////////////////////////////////////
       
  1584 // new since 1.5.4 (mainly for Fortran)
       
  1585 //////////////////////////////////////////////////////////////////////////
       
  1586     
       
  1587     /*! header that is put before the list of member subprograms (Fortran). */
       
  1588     virtual QCString trMemberFunctionDocumentationFortran()
       
  1589     { return "Dokumentacija funkcija i procedura"; }
       
  1590 
       
  1591     /*! This is put above each page as a link to the list of annotated data types (Fortran). */    
       
  1592     /*! @todo Koji je prevod za Compound u Fortran kontekstu */
       
  1593     virtual QCString trCompoundListFortran()
       
  1594     { return "Složeni tipovi podataka"; }
       
  1595 
       
  1596     /*! This is put above each page as a link to all members of compounds (Fortran). */
       
  1597     virtual QCString trCompoundMembersFortran()
       
  1598     { return "Polja u složenim tipovima podataka"; }
       
  1599 
       
  1600     /*! This is an introduction to the annotated compound list (Fortran). */
       
  1601     virtual QCString trCompoundListDescriptionFortran()
       
  1602     { return "Spisak složenih tipova podataka sa kratkim opisima:"; }
       
  1603 
       
  1604     /*! This is an introduction to the page with all data types (Fortran). */
       
  1605     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
       
  1606     {
       
  1607       QCString result=" Spisak svih ";
       
  1608       if (!extractAll)
       
  1609       {
       
  1610         result+="dokumentovanih ";
       
  1611       }
       
  1612       result+="polja složenih tipova podataka";
       
  1613       result+=" sa vezama ka ";
       
  1614       if (!extractAll) 
       
  1615       {
       
  1616          result+="dokumentaciji strukture podataka za svakog člana";
       
  1617       }
       
  1618       else 
       
  1619       {
       
  1620          result+="složenim tipovima podataka kojima pripadaju:";
       
  1621       }
       
  1622       return result;
       
  1623     }
       
  1624 
       
  1625     /*! This is used in LaTeX as the title of the chapter with the 
       
  1626      * annotated compound index (Fortran).
       
  1627      */
       
  1628     virtual QCString trCompoundIndexFortran()
       
  1629     { return "Sadržaj složenog tipa podataka"; }
       
  1630 
       
  1631     /*! This is used in LaTeX as the title of the chapter containing
       
  1632      *  the documentation of all data types (Fortran).
       
  1633      */
       
  1634     virtual QCString trTypeDocumentation()
       
  1635     { return "Dokumentacija tipova podataka"; }
       
  1636 
       
  1637     /*! This is used in the documentation of a file as a header before the 
       
  1638      *  list of (global) subprograms (Fortran).
       
  1639      */
       
  1640     virtual QCString trSubprograms()
       
  1641     { return "Funkcije i procedure"; }
       
  1642 
       
  1643     /*! This is used in the documentation of a file/namespace before the list 
       
  1644      *  of documentation blocks for subprograms (Fortran)
       
  1645      */
       
  1646     virtual QCString trSubprogramDocumentation()
       
  1647     { return "Dokumentacija funkcija i procedura"; }
       
  1648 
       
  1649     /*! This is used in the documentation of a file/namespace/group before 
       
  1650      *  the list of links to documented compounds (Fortran)
       
  1651      */
       
  1652      virtual QCString trDataTypes()
       
  1653     { return "Složeni tipovi podataka"; }
       
  1654     
       
  1655     /*! used as the title of page containing all the index of all modules (Fortran). */
       
  1656     virtual QCString trModulesList()
       
  1657     { return "Spisak modula"; }
       
  1658 
       
  1659     /*! used as an introduction to the modules list (Fortran) */
       
  1660     virtual QCString trModulesListDescription(bool extractAll)
       
  1661     {
       
  1662       QCString result="Spisak svih ";
       
  1663       if (!extractAll) result+="dokumentovanih ";
       
  1664       result+="modula sa kratkim opisima:";
       
  1665       return result;
       
  1666     }
       
  1667 
       
  1668     /*! used as the title of the HTML page of a module/type (Fortran) */
       
  1669     virtual QCString trCompoundReferenceFortran(const char *clName,
       
  1670                                     ClassDef::CompoundType compType,
       
  1671                                     bool isTemplate)
       
  1672     {
       
  1673       QCString result=(QCString)clName;
       
  1674       switch(compType)
       
  1675       {
       
  1676         case ClassDef::Class:      result+=" Modul"; break;
       
  1677         case ClassDef::Struct:     result+=" Tip"; break;
       
  1678         case ClassDef::Union:      result+=" Unija"; break;
       
  1679         case ClassDef::Interface:  result+=" Interfejs"; break;
       
  1680         case ClassDef::Protocol:   result+=" Protokol"; break;
       
  1681         case ClassDef::Category:   result+=" Kategorija"; break;
       
  1682         case ClassDef::Exception:  result+=" Izuzetak"; break;
       
  1683       }
       
  1684       result+=" - sažet pregled";
       
  1685       if (isTemplate) result+=" šablona";
       
  1686       return result;
       
  1687     }
       
  1688     /*! used as the title of the HTML page of a module (Fortran) */
       
  1689     virtual QCString trModuleReference(const char *namespaceName)
       
  1690     {
       
  1691       QCString result=namespaceName;
       
  1692       result+=" - sažet pregled modula";        
       
  1693       return result;
       
  1694     }
       
  1695     
       
  1696     /*! This is put above each page as a link to all members of modules. (Fortran) */
       
  1697     virtual QCString trModulesMembers()
       
  1698     { return "Članovi modula"; }
       
  1699 
       
  1700     /*! This is an introduction to the page with all modules members (Fortran) */
       
  1701     virtual QCString trModulesMemberDescription(bool extractAll)
       
  1702     { 
       
  1703       QCString result="Spisak svih ";
       
  1704       if (!extractAll) result+="dokumentovanih ";
       
  1705       result+="članova modula sa vezama ka ";
       
  1706       if (extractAll) 
       
  1707       {
       
  1708         result+="dokumentaciji za svakog člana modula:";
       
  1709       }
       
  1710       else 
       
  1711       {
       
  1712         result+="modulima kojima pripadaju:";
       
  1713       }
       
  1714       return result;
       
  1715     }
       
  1716 
       
  1717     /*! This is used in LaTeX as the title of the chapter with the 
       
  1718      *  index of all modules (Fortran).
       
  1719      */
       
  1720     virtual QCString trModulesIndex()
       
  1721     { return "Spisak modula"; }
       
  1722     
       
  1723     /*! This is used for translation of the word that will possibly
       
  1724      *  be followed by a single name or by a list of names 
       
  1725      *  of the category.
       
  1726      */
       
  1727     virtual QCString trModule(bool first_capital, bool singular)
       
  1728     {       
       
  1729       QCString result((first_capital ? "Modul" : "modul"));
       
  1730       if (!singular)  result+="i";
       
  1731       return result; 
       
  1732     }
       
  1733     /*! This is put at the bottom of a module documentation page and is
       
  1734      *  followed by a list of files that were used to generate the page.
       
  1735      */
       
  1736     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
       
  1737         bool single)
       
  1738     { // here s is one of " Module", " Struct" or " Union"
       
  1739       // single is true implies a single file
       
  1740       QCString result=(QCString)"Dokumentacija za ovaj ";
       
  1741       switch(compType)
       
  1742       {
       
  1743         case ClassDef::Class:      result+="modul"; break;
       
  1744         case ClassDef::Struct:     result+="tip"; break;
       
  1745         case ClassDef::Union:      result+="uniju"; break;
       
  1746         case ClassDef::Interface:  result+="interfejs"; break;
       
  1747         case ClassDef::Protocol:   result+="protokol"; break;
       
  1748         case ClassDef::Category:   result+="kategoriju"; break;
       
  1749         case ClassDef::Exception:  result+="izuzetak"; break;
       
  1750       }
       
  1751       result+=" napravljena je automatski od sledeć";
       
  1752       if (single) result+="e datoteke:"; else result+="ih datoteka:";
       
  1753       return result;
       
  1754     }
       
  1755     /*! This is used for translation of the word that will possibly
       
  1756      *  be followed by a single name or by a list of names 
       
  1757      *  of the category.
       
  1758      */
       
  1759     virtual QCString trType(bool first_capital, bool singular)
       
  1760     { 
       
  1761       QCString result((first_capital ? "Tip" : "tip"));
       
  1762       if (!singular)  result+="ovi";
       
  1763       return result; 
       
  1764     }
       
  1765     /*! This is used for translation of the word that will possibly
       
  1766      *  be followed by a single name or by a list of names 
       
  1767      *  of the category.
       
  1768      */
       
  1769     virtual QCString trSubprogram(bool first_capital, bool singular)
       
  1770     { 
       
  1771       QCString result((first_capital ? "Procedura" : "procedura"));
       
  1772       if (!singular)  result = (first_capital ? "Procedure" : "procedure");
       
  1773       return result; 
       
  1774     }
       
  1775 
       
  1776     /*! C# Type Constraint list */
       
  1777     virtual QCString trTypeConstraints()
       
  1778     {
       
  1779       return "Ograničenja tipova";
       
  1780     }
       
  1781     
       
  1782 //////////////////////////////////////////////////////////////////////////
       
  1783 // following methods have no corresponding entry in translator_en.h
       
  1784 //////////////////////////////////////////////////////////////////////////
       
  1785 
       
  1786 //      /*! This is put above each page as a link to the list of all verbatim headers */
       
  1787 //     virtual QCString trHeaderFiles()
       
  1788 //     { return decode( "Zaglavlja" ); }
       
  1789 // 
       
  1790 //     /*! This is an introduction to the page with the list of all header files. */
       
  1791 //     virtual QCString trHeaderFilesDescription()
       
  1792 //     { return decode( "Zaglavlja koje izgraduju API:" ); }
       
  1793 // 
       
  1794 //     /*! This sentences is used in the annotated class/file lists if no brief
       
  1795 //      * description is given. 
       
  1796 //      */
       
  1797 //     virtual QCString trNoDescriptionAvailable()
       
  1798 //     { return decode( "Opis nije dostupan" ); }
       
  1799 //     
       
  1800 //     /*! this text is generated when the \\reimp command is used. */
       
  1801 //     virtual QCString trReimplementedForInternalReasons()
       
  1802 //     { return decode("Preuradeno zbog unutrasnjih razloga; Nema uticaja na API." ); }
       
  1803 // 
       
  1804 //     /*! this text is generated when the \\bug command is used. */
       
  1805 //     virtual QCString trBugsAndLimitations()
       
  1806 //     { return decode( "Greske i ogranicenja" ); }
       
  1807 // 
       
  1808 //     virtual QCString trSources()
       
  1809 //     {
       
  1810 //       return decode("Izvorne datoteke" );
       
  1811 //     }
       
  1812 // 
       
  1813 //     /*! Used for Java interfaces in the summary section of Java packages */
       
  1814 //     virtual QCString trInterfaces()
       
  1815 //     {
       
  1816 //       return decode( "Interfejsi" );  //!< Radna okruzenja. Ali to je dve reci.
       
  1817 //     }
       
  1818 // 
       
  1819 //     /*! Used as a chapter title for Latex & RTF output */
       
  1820 //     virtual QCString trPackageDocumentation()
       
  1821 //     {
       
  1822 //       return decode( "Dokumentacija paketa" );
       
  1823 //     }
       
  1824 //  
       
  1825 //     /*! This is used for translation of the word that will possibly
       
  1826 //      *  be followed by a single name or by a list of names 
       
  1827 //      *  of the category.
       
  1828 //      */
       
  1829 //     virtual QCString trField(bool first_capital, bool singular)
       
  1830 //     { 
       
  1831 //       QCString result((first_capital ? "Polj" : "polj"));
       
  1832 //       result+= (singular ? "e" : "a");
       
  1833 //       return decode( result ); 
       
  1834 //     }
       
  1835 
       
  1836 };
       
  1837 
       
  1838 #endif