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

     2  *

     3  * 

     4  *

     5  * Copyright (C) 1997-2008 by Dimitri van Heesch.

     6  *

     7  * Permission to use, copy, modify, and distribute this software and its

     8  * documentation under the terms of the GNU General Public License is hereby 

     9  * granted. No representations are made about the suitability of this software 

    10  * for any purpose. It is provided "as is" without express or implied warranty.

    11  * See the GNU General Public License for more details.

    12  *

    13  * Documents produced by Doxygen are derivative works derived from the

    14  * input used in their production; they are not affected by this license.

    15  *

    16 */

    17 // translation by Boris Bralo <boris.bralo@zg.htnet.hr>

    18 // Updates:

    19 // --------

    20 // 2000/08/20 

    21 //  - Better handling of ISO-8859-2/ WIN 1250 stuff based on (actualy stolen from :-)) Czech translations

    22 //    implemented by Petr Prikryl (prikrylp@skil.cz).

    23 //    As opposed to Czech translation this one assumes that Doxygen strings are written in Linux ( it's true,

    24 //    I don't have QT pro licence ) , and uses ISOToWin function when built in WIN32

    25 //

    26 // 2000/09/18

    27 // - Added strings from 1.2.1

    28 // - Removed unneeeded decode() calls

    29 // - Changed some CS terminology

    30 // 

    31 // 2001/01/22

    32 // - Added strings from 1.2.4

    33 //

    34 // 2001/05/25

    35 // - Added strings and up to and including 1.2.7_20010524

    36 // - Removed obsolete method trFiles()

    37 // - Removed obsolete method trAuthor()

    38 // - Removed obsolete method trAuthor()

    39 // - Removed obsolete method trVerbatimHeadert()

    40 // - Method latexBabelPackage() removed, ude latexLanguageSupportCommand

    41 //

    42 // 2001/11/13

    43 // - inherits from Translator 

    44 // - Added strings for 1.2.11

    45 // - better output for C documentation (trCompoundMembersDescription(), trClassDocumentation()) 

    46 //

    47 // 2001/11/13

    48 // - Added strings for 1.2.13

    49 //

    50 // 2003/02/26

    51 // - Added strings for 1.2.18

    52 //

    53 // 2003/04/29

    54 // - Added strings for 1.3.0

    55 //

    56 // 2004/06/21

    57 // - Added strings for 1.3.8

    58 //

    59 // 2004/09/15

    60 // - Added strings for 1.3.9

    61 //

    62 // 2005/02/28

    63 // - Removed obsolete (unused) methods

    64 //

    65 // 2005/03/21

    66 // - Added strings for 1.4.1

    67 //

    68 // 2006/06/11

    69 // - Added strings for 1.4.6

    70 //

    71 // 2009/01/09

    72 // - Updated trLegendDocs

    73 //

    74 #ifndef TRANSLATOR_HR_H

    75 #define TRANSLATOR_HR_H

    76 

    77 class TranslatorCroatian : public TranslatorAdapter_1_6_0

    78 {

    79   private:

    80         /*! to avoid macro redefinition from translator_cz.h */

    81         inline QCString decode(const QCString& sInput)

    82         { 

    83           //if (Config_getBool("USE_WINDOWS_ENCODING"))

    84           //{

    85           //  return ISO88592ToWin1250(sInput);

    86           //}

    87           //else

    88           //{

    89             return sInput;

    90           //}

    91         }

    92   

    93   public:

    94     QCString idLanguage()

    95     { return "croatian"; }

    96     QCString idLanguageCharset()

    97     {

    98       //if (Config_getBool("USE_WINDOWS_ENCODING"))

    99       //{

   100       //  return "windows-1250"; 

   101       //}

   102       //else

   103       //{

   104         return "iso-8859-2";

   105       //}

   106     }

   107     QCString latexLanguageSupportCommand()

   108     { return "\\usepackage[croatian]{babel}\n"; }

   109     QCString trRelatedFunctions()

   110     { return "Povezane funkcije"; }

   111     QCString trRelatedSubscript()

   112     { return "(To nisu member funkcije.)"; }

   113     QCString trDetailedDescription()

   114     { return decode("Detaljno objašnjenje"); }

   115     QCString trMemberTypedefDocumentation()

   116     { return decode("Dokumentacija typedef članova"); }

   117     QCString trMemberEnumerationDocumentation()

   118     { return decode("Dokumentacija enumeracijskih članova"); }

   119     QCString trMemberFunctionDocumentation()

   120     { return "Dokumentacija funkcija"; }

   121     QCString trMemberDataDocumentation()

   122     { return "Documentacija varijabli"; }

   123     QCString trMore()

   124     { return decode("Opširnije..."); }

   125     QCString trListOfAllMembers()

   126     { return decode("Popis svih članova."); }

   127     QCString trMemberList()

   128     { return decode("Popis članova."); }

   129     QCString trThisIsTheListOfAllMembers()

   130     { return decode("Ovo je popis svih članova"); }

   131     QCString trIncludingInheritedMembers()

   132     { return decode(", uključujući naslijeđene članove."); }

   133     QCString trGeneratedAutomatically(const char *s)

   134     { QCString result=decode("generirano automatski Doxygen-om"); 

   135       if (s) result+=(QCString)" za "+s;

   136       result+=" iz programskog koda."; 

   137       return decode(result);

   138     }

   139     QCString trEnumName()

   140     { return decode("enum ime"); }

   141     QCString trEnumValue()

   142     { return decode("enum vrijednost"); }

   143     QCString trDefinedIn()

   144     { return decode("definirano u"); }

   145     QCString trModules()

   146     { return "Moduli"; }

   147     QCString trClassHierarchy()

   148     { return "Stablo klasa"; }

   149     QCString trCompoundList()

   150 	{

   151 		if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   152 		{

   153 			return "Sve strukture";

   154 		}

   155 		else

   156 		{

   157 			return "Sve klase"; 

   158 		}

   159 	}

   160     QCString trFileList()

   161     { return "Popis datoteka"; }

   162     QCString trCompoundMembers()

   163 	{

   164 		if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   165 			return decode("Svi članovi struktura"); 

   166 		else

   167 			return decode("Svi članovi klasa"); 

   168 	}

   169     QCString trFileMembers()

   170     { return decode("Članovi klasa u datoteci"); }

   171     QCString trRelatedPages()

   172     { return decode("Stranice povezane s ovom"); }

   173     QCString trExamples()

   174     { return "Primjeri"; }

   175     QCString trSearch()

   176     { return decode("Traži"); }

   177     QCString trClassHierarchyDescription()

   178     { return decode("Stablo naslijeđivanja je složeno "

   179                                         "približno po abecedi:");

   180     }

   181     QCString trFileListDescription(bool extractAll)

   182     {

   183       QCString result="Popis svih ";

   184       if (!extractAll) result+="dokumentiranih ";

   185       result+="datoteka, s kratkim opisom:";

   186       return decode(result);

   187     }

   188     QCString trCompoundListDescription()

   189     { return "Popis svih klasa, unija i struktura "

   190 		  "s kratkim opisom :"; 

   191     }

   192     QCString trCompoundMembersDescription(bool extractAll)

   193     {

   194       QCString result="Popis svih ";

   195       if (!extractAll)

   196 		  result+="dokumentiranih ";

   197 

   198 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   199 		  result+="članova klasa s linkovima na ";

   200 	  else

   201 		  result+="članova struktura s linkovima na ";

   202 		  

   203       if (!extractAll)

   204 	  {

   205 		  result+="dokumentaciju svakog člana:";

   206       }

   207 	  else

   208 	  {

   209 		  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   210 			  result+="dokumentaciju klase :";

   211 		  else

   212 			  result +="dokumentaciju strukture";

   213 	  }

   214       return decode(result);

   215     }

   216     QCString trFileMembersDescription(bool extractAll)

   217     {

   218       QCString result="Popis svih ";

   219       if (!extractAll)

   220 		  result+="dokumentiranih ";

   221       result+="članova s linkovima na ";

   222       if (extractAll)

   223 		  result+="dokumentaciju datoteke u kojima se nalaze:";

   224       else

   225 		  result+="datoteke u kojima se nalaze:";

   226       return decode(result);

   227     }

   228     QCString trExamplesDescription()

   229     { return "Popis primjera :"; }

   230     QCString trRelatedPagesDescription()

   231     { return "Popis povezanih stranica:"; }

   232     QCString trModulesDescription()

   233     { return "Popis svih modula:"; }

   234 

   235     QCString trDocumentation()

   236     { return "Dokumentacija"; }

   237     QCString trModuleIndex()

   238     { return "Kazalo modula"; }

   239     QCString trHierarchicalIndex()

   240     { return "Hijerarhijsko kazalo"; }

   241     QCString trCompoundIndex()

   242     {

   243       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   244       { 

   245         return "Kazalo struktura podataka";

   246       }

   247       else

   248       {

   249 		return "Skupno kazalo ";

   250       }

   251 	}

   252     QCString trFileIndex() 

   253     { return "Kazalo datoteka"; }

   254     QCString trModuleDocumentation()

   255     { return "Dokumentacija modula"; }

   256     QCString trClassDocumentation()

   257     {

   258 		if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   259 		{

   260 			return "Dokumentacija struktura podataka"; 

   261 		}

   262 		else

   263 		{

   264 			return "Dokumentacija klasa";

   265 		}

   266 	}

   267     QCString trFileDocumentation()

   268     { return "Dokumentacija datoteka"; }

   269     QCString trExampleDocumentation()

   270     { return "Dokumentacija primjera"; }

   271     QCString trPageDocumentation()

   272     { return "Dokumentacija vezane stranice"; }

   273     QCString trReferenceManual()

   274     { return decode("Priručnik"); }

   275 

   276     QCString trDefines()

   277     { return "Definicije"; }

   278     QCString trFuncProtos()

   279     { return "Prototipi funkcija"; }

   280     QCString trTypedefs()

   281     { return "Typedef-ovi"; }

   282     QCString trEnumerations()

   283     { return "Enumeracije"; }

   284     QCString trFunctions()

   285     { return "Funkcije"; }

   286     QCString trVariables()

   287     { return "Varijable"; }

   288     QCString trEnumerationValues()

   289     { return "Vrijednosti enumeracija"; }

   290     QCString trDefineDocumentation()

   291     { return "Dokumentacija definicija"; }

   292     QCString trFunctionPrototypeDocumentation()

   293     { return "Dokumentacija prototipa funkcije"; }

   294     QCString trTypedefDocumentation()

   295     { return "Dokumentacija typedef-a"; }

   296     QCString trEnumerationTypeDocumentation()

   297     { return "Dokumentacija enumeracijskog tipa"; }

   298     QCString trFunctionDocumentation()

   299     { return "Dokumentacije funkcija"; }

   300     QCString trVariableDocumentation()

   301     { return "Dokumentacija varijable"; }

   302     QCString trCompounds()

   303     { return "Strukture"; }

   304     QCString trGeneratedAt(const char *date,const char *projName)

   305     { 

   306       QCString result=(QCString)"Generirano "+date;

   307       if (projName) result+=(QCString)" projekt: "+projName;

   308       result+=" generator: ";

   309       return decode(result);

   310     }

   311     QCString trWrittenBy()

   312     {

   313       return decode("napisao ");

   314     }

   315     QCString trClassDiagram(const char *clName)

   316     {

   317       return decode("Dijagram klasa za ")+clName;

   318     }

   319     QCString trForInternalUseOnly()

   320     { return decode("Isključivo za internu uporabu."); }

   321     QCString trWarning()

   322     { return "Upozorenje"; }

   323     QCString trVersion()

   324     { return "Verzija"; }

   325     QCString trDate()

   326     { return "Datum"; }

   327     QCString trReturns()

   328     { return "Povratne vrijednosti"; }

   329     QCString trSeeAlso()

   330     { return decode("Vidi također"); }

   331     QCString trParameters()

   332     { return "Parametri"; }

   333     QCString trExceptions()

   334     { return "Iznimke"; }

   335     QCString trGeneratedBy()

   336     { return "Generirao"; }

   337     

   338 //////////////////////////////////////////////////////////////////////////

   339 // new since 0.49-990307 

   340 //////////////////////////////////////////////////////////////////////////

   341     

   342     QCString trNamespaceList()

   343     { return "Popis imenika"; }

   344     QCString trNamespaceListDescription(bool extractAll)

   345     {

   346       QCString result="Popis svih ";

   347       if (!extractAll) result+="dokumentiranih ";

   348       result+="imenika s kratkim opisom:";

   349       return decode(result);

   350     }

   351     QCString trFriends()

   352     { return decode("Friend-ovi "); }

   353 

   354 //////////////////////////////////////////////////////////////////////////

   355 // new since 0.49-990405

   356 //////////////////////////////////////////////////////////////////////////

   357     

   358     QCString trRelatedFunctionDocumentation()

   359     { return "Dokumentacija povezanih funkcija"; }

   360     

   361 //////////////////////////////////////////////////////////////////////////

   362 // new since 0.49-990425

   363 //////////////////////////////////////////////////////////////////////////

   364 

   365     QCString trCompoundReference(const char *clName,

   366                                     ClassDef::CompoundType compType,

   367                                     bool /*isTemplate*/)

   368       // used as the title of the HTML page of a class/struct/union

   369     {

   370       QCString result="Opis ";

   371       switch(compType)

   372       {

   373         case ClassDef::Class:  result+=" klase "; break;

   374         case ClassDef::Struct: result+=" strukture "; break;

   375         case ClassDef::Union:  result+=" unije "; break;

   376         case ClassDef::Interface:  result+=" sučelja (interface) "; break;

   377         case ClassDef::Protocol:   result+=" protokola "; break; 

   378         case ClassDef::Category:   result+=" kategorije "; break; 

   379         case ClassDef::Exception:  result+=" iznimke (exception) "; break;

   380       }

   381           result += clName;

   382       

   383       return decode(result);

   384     }

   385     QCString trFileReference(const char *fileName)

   386       // used as the title of the HTML page of a file

   387     {

   388       QCString result="Opis datoteke "; 

   389           result+=fileName;

   390           return decode(result);

   391     }

   392     QCString trNamespaceReference(const char *namespaceName)

   393       // used as the title of the HTML page of a namespace

   394     {

   395       QCString result ="Opis imenika ";

   396           result+=namespaceName;

   397       

   398       return decode(result);

   399     }

   400     

   401     // these are for the member sections of a class, struct or union 

   402     QCString trPublicMembers()

   403     { return decode("Public članovi"); }

   404     QCString trPublicSlots()

   405     { return "Public slotovi"; }

   406     QCString trSignals()

   407     { return "Signali"; }

   408     QCString trStaticPublicMembers()

   409     { return decode("Static public članovi"); }

   410     QCString trProtectedMembers()

   411     { return decode("Protected članovi"); }

   412     QCString trProtectedSlots()

   413     { return "Protected slotovi"; }

   414     QCString trStaticProtectedMembers()

   415     { return decode("Static protected članovi"); }

   416     QCString trPrivateMembers()

   417     { return decode("Privatni članovi"); }

   418     QCString trPrivateSlots()

   419     { return decode("Privatni slotovi"); }

   420     QCString trStaticPrivateMembers()

   421     { return decode("Statični privatni članovi"); }

   422     // end of member sections 

   423     

   424     QCString trWriteList(int numEntries)

   425     {

   426       // this function is used to produce a comma-separated list of items.

   427       // use generateMarker(i) to indicate where item i should be put.

   428       QCString result;

   429       int i;

   430       // the inherits list contain `numEntries' classes

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

   432       {

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

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

   435                                    // (order is left to right)

   436         

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

   438         {

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

   440             result+=", ";

   441           else                // the fore last entry

   442             result+="";

   443         }

   444       }

   445       return result; 

   446     }

   447     

   448     QCString trInheritsList(int numEntries)

   449       // used in class documentation to produce a list of base classes,

   450       // if class diagrams are disabled.

   451     {

   452       return decode("Naslijeđuje od "+trWriteList(numEntries)+".");

   453     }

   454     QCString trInheritedByList(int numEntries)

   455       // used in class documentation to produce a list of super classes,

   456       // if class diagrams are disabled.

   457     {

   458       return decode("Naslijeđena u "+trWriteList(numEntries)+".");

   459     }

   460     QCString trReimplementedFromList(int numEntries)

   461       // used in member documentation blocks to produce a list of 

   462       // members that are hidden by this one.

   463     {

   464       return decode("Reimplementirano od  "+trWriteList(numEntries)+".");

   465     }

   466     QCString trReimplementedInList(int numEntries)

   467     {

   468       // used in member documentation blocks to produce a list of

   469       // all member that overwrite the implementation of this member.

   470       return decode("Reimplementacija u "+trWriteList(numEntries)+".");

   471     }

   472 

   473     QCString trNamespaceMembers()

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

   475     { return decode("Članovi imenika"); }

   476     QCString trNamespaceMemberDescription(bool extractAll)

   477       // This is an introduction to the page with all namespace members

   478     { 

   479       QCString result="Lista svih ";

   480       if (!extractAll) result+="dokumentiranih ";

   481       result+="članova imenika s linkovima na ";

   482       if (extractAll) 

   483         result+="imeničku dokumentaciju svakog člana:";

   484       else 

   485         result+="imenike kojima pripadaju:";

   486       return decode(result);

   487     }

   488     QCString trNamespaceIndex()

   489       // This is used in LaTeX as the title of the chapter with the 

   490       // index of all namespaces.

   491     { return "Kazalo imenika"; }

   492     QCString trNamespaceDocumentation()

   493       // This is used in LaTeX as the title of the chapter containing

   494       // the documentation of all namespaces.

   495     { return "Dokumentacija namespace-a"; }

   496 

   497 //////////////////////////////////////////////////////////////////////////

   498 // new since 0.49-990522

   499 //////////////////////////////////////////////////////////////////////////

   500 

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

   502      *  namespaces in a file.

   503      */

   504     QCString trNamespaces()

   505     {

   506       return "Imenici";

   507     }

   508 

   509 //////////////////////////////////////////////////////////////////////////

   510 // new since 0.49-990728

   511 //////////////////////////////////////////////////////////////////////////

   512 

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

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

   515      */

   516     QCString trGeneratedFromFiles(ClassDef::CompoundType compType,

   517         bool single)

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

   519       // single is true implies a single file

   520       QCString result="Dokumentacija ";

   521       switch(compType)

   522       {

   523         case ClassDef::Class:      result+="klase"; break;

   524         case ClassDef::Struct:     result+="strukture"; break;

   525         case ClassDef::Union:      result+="unije"; break;

   526         case ClassDef::Interface:  result+="sučelja (interface)"; break;

   527         case ClassDef::Protocol:   result+="protokola"; break; 

   528         case ClassDef::Category:   result+="kategorije"; break; 

   529         case ClassDef::Exception:  result+="iznimke (exception)"; break;

   530       }

   531       result+=" je generirana iz " + trFile(FALSE, single) + ": ";

   532 	  return decode(result);

   533     }

   534 

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

   536      * list.

   537      */

   538     QCString trAlphabeticalList()

   539     { return "Abecedni popis"; }

   540 

   541 //////////////////////////////////////////////////////////////////////////

   542 // new since 0.49-990901

   543 //////////////////////////////////////////////////////////////////////////

   544 

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

   546     QCString trReturnValues()

   547     { return "Povratna vrijednost"; }

   548 

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

   550      */

   551     QCString trMainPage()

   552     { return "Glavna stranica"; }

   553 

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

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

   556      */

   557     QCString trPageAbbreviation()

   558     { return "str."; }

   559 

   560 //////////////////////////////////////////////////////////////////////////

   561 // new since 0.49-991106

   562 //////////////////////////////////////////////////////////////////////////

   563 

   564     QCString trDefinedAtLineInSourceFile()

   565     {

   566       return "Definirano u liniji @0 datoteke @1.";

   567     }

   568     QCString trDefinedInSourceFile()

   569     {

   570       return "Definirano u datoteci @0.";

   571     }

   572 

   573 //////////////////////////////////////////////////////////////////////////

   574 // new since 0.49-991205

   575 //////////////////////////////////////////////////////////////////////////

   576 

   577     QCString trDeprecated()

   578     {

   579       return "Zastarjelo";

   580     }

   581 

   582 //////////////////////////////////////////////////////////////////////////

   583 // new since 1.0.0

   584 //////////////////////////////////////////////////////////////////////////

   585 

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

   587     QCString trCollaborationDiagram(const char *clName)

   588     {

   589       return decode( (QCString)"Kolaboracijski dijagram za "+clName+ ":");

   590     }

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

   592     QCString trInclDepGraph(const char *fName)

   593     {

   594       return decode((QCString)"Graf include međuovisnosti za "+fName+":");

   595     }

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

   597     QCString trConstructorDocumentation()

   598     {

   599       return "Dokumentacija konstruktora i destruktora "; 

   600     }

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

   602     QCString trGotoSourceCode()

   603     {

   604       return "Izvorni kod";

   605     }

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

   607     QCString trGotoDocumentation()

   608     {

   609       return "Dokumenacija za ovu datoteku.";

   610     }

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

   612     QCString trPrecondition()

   613     {

   614       return "Preduvjeti";

   615     }

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

   617     QCString trPostcondition()

   618     {

   619       return "Postuvjeti";

   620     }

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

   622     QCString trInvariant()

   623     {

   624       return "Invarijanta";

   625     }

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

   627     QCString trInitialValue()

   628     {

   629       return decode("Početna vrijednost:");

   630     }

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

   632     QCString trCode()

   633     {

   634       return "kod";

   635     }

   636     QCString trGraphicalHierarchy()

   637     {

   638       return decode("Grafičko stablo klasa");

   639     }

   640     QCString trGotoGraphicalHierarchy()

   641     {

   642       return decode("Grafičko stablo klasa");

   643     }

   644     QCString trGotoTextualHierarchy()

   645     {

   646       return "Tekstualno stablo klasa";

   647     }

   648     QCString trPageIndex()

   649     {

   650       return "Indeks stranice";

   651     }

   652 

   653 //////////////////////////////////////////////////////////////////////////

   654 // new since 1.1.0

   655 //////////////////////////////////////////////////////////////////////////

   656     

   657     QCString trNote()

   658     {

   659       return "Primjedba";

   660     }

   661     QCString trPublicTypes()

   662     {

   663       return "Public tipovi";

   664     }

   665     QCString trPublicAttribs()

   666     {

   667       return "Public atributi";

   668     }

   669     QCString trStaticPublicAttribs()

   670     {

   671       return "Static public atributi";

   672     }

   673     QCString trProtectedTypes()

   674     {

   675       return "Protected tipovi";

   676     }

   677     QCString trProtectedAttribs()

   678     {

   679       return "Protected atributi";

   680     }

   681     QCString trStaticProtectedAttribs()

   682     {

   683       return "Static protected atributi";

   684     }

   685     QCString trPrivateTypes()

   686     {

   687       return "Private tipovi";

   688     }

   689     QCString trPrivateAttribs()

   690     {

   691       return "Private atributi";

   692     }

   693     QCString trStaticPrivateAttribs()

   694     {

   695       return "Static private atributi";

   696     }

   697 //////////////////////////////////////////////////////////////////////////

   698 // new since 1.1.3

   699 //////////////////////////////////////////////////////////////////////////

   700 

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

   702     virtual QCString trTodo()

   703     {

   704       return "Za uraditi";

   705     }

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

   707     virtual QCString trTodoList()

   708     {

   709       return "Ostalo za uraditi";

   710     }

   711 

   712 //////////////////////////////////////////////////////////////////////////

   713 // new since 1.1.4

   714 //////////////////////////////////////////////////////////////////////////

   715 

   716     virtual QCString trReferencedBy()

   717     {

   718       return "Referencirano od";

   719     }

   720     virtual QCString trRemarks()

   721     {

   722       return "Napomene";

   723     }

   724     virtual QCString trAttention()

   725     {

   726         return decode("Pažnja");

   727     }

   728     virtual QCString trInclByDepGraph()

   729     {

   730       return decode("Ovaj graf pokazuje koje datoteke izravno "

   731                             "ili neizravno uključuju ovu datoteku:");

   732     }

   733     virtual QCString trSince()

   734     {

   735       return "Od";

   736     }

   737 

   738 //////////////////////////////////////////////////////////////////////////

   739 // new since 1.1.5

   740 //////////////////////////////////////////////////////////////////////////

   741 

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

   743     virtual QCString trLegendTitle()

   744     {

   745       return "Legenda";

   746     }

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

   748     virtual QCString trLegendDocs()

   749     {

   750       return 

   751         decode( "Ova stranica objašnjava kako interpretirati grafikone koje je generirao "

   752         "doxygen.<p>\n"

   753         "Na primjer:\n"

   754         "\\code\n"

   755         "/*! Nevidljiva klasa (neće stati na graf date visine) */\n"

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

   757         "/*! Odrezana klasa, inheritance je skriven (klase se vidi na grafu, ali ne i sve bazne klase) */\n"

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

   759         "/* Nedokumentirana klasa */\n"

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

   761         "/*! Klasa koja je naslijeđena public  */\n"

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

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

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

   765         "/*! Klasa koje je naslijeđena protected */\n"

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

   767         "/*! Klasa koje je naslijeđena private */\n"

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

   769         "/*! Klasa koja se koristi agregacijom  */\n"

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

   771         "/*! Super klasa koja naslijeđuje/koristi ostale */\n"

   772         "class Inherited : public PublicBase,\n"

   773         "                  protected ProtectedBase,\n"

   774         "                  private PrivateBase,\n"

   775         "                  public Undocumented,\n"

   776         "                  public Templ<int>\n"

   777         "{\n"

   778         "  private:\n"

   779         "    Used *m_usedClass;\n"

   780         "};\n"

   781         "\\endcode\n"

   782         "To će rezultirati grafikonom:"

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

   784         "<p>\n"

   785         "Pravokutnici imaju slijedeće značenje:\n"

   786         "<ul>\n"

   787         "<li>%A Puni crni predstavlja klasu za koji je generiran graf.\n"

   788         "<li>%A Pravokutnik s crnim rubom predstavlja dokumentiranu klasu.\n"

   789         "<li>%A Pravokutnik s sivim rubom predstavlja nedokumentiranu klasu.\n"

   790         "<li>%A Pravokutnik s crvenim rubom predstavlja dokumentiranu klasu\n"

   791         "Za koju nije prikazan graf naslijeđivanja. Graf je odrezan "

   792         "ako ne stane unutar određenih granica."

   793         "</ul>\n"

   794         "Strelice imaju slijedeće značenje:\n"

   795         "<ul>\n"

   796         "<li>%A Tamnoplava strelica označava public naslijeđivanje.\n"

   797         "<li>%A Tamnozelena strelica označava protected naslijeđivanje.\n"

   798         "<li>%A Tamnocrvena strelica označava private naslijeđivanje.\n"

   799         "<li>%A Ljubičasta isprekidana strelica se koristi ako je klasa dio "

   800         "druge klase ili ako se klasa koristi u drugoj klasi. Natpis na "

   801         "strelici je ime varijable u drugoj klasi\n"

   802         "Strelica je označena imenom varijable.\n"

   803         "<li>%A Žuta isprekidana strelica označava relaciju između template instance "

   804         "i template klase. Označena je imenom template parametra\n"

   805         "</ul>\n");

   806     }

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

   808     virtual QCString trLegend()

   809     {

   810       return "legenda";

   811     }

   812 //////////////////////////////////////////////////////////////////////////

   813 // new since 1.2.0

   814 //////////////////////////////////////////////////////////////////////////

   815     

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

   817     virtual QCString trTest()

   818     {

   819       return "Test";

   820     }

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

   822     virtual QCString trTestList()

   823     {

   824       return "Test lista";

   825     }

   826 

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

   828 // new since 1.2.1

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

   830 

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

   832     virtual QCString trDCOPMethods()

   833     {

   834       return "DCOP metode";

   835     }

   836 //////////////////////////////////////////////////////////////////////////

   837 // new since 1.2.2

   838 //////////////////////////////////////////////////////////////////////////

   839 

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

   841     virtual QCString trProperties()

   842     {

   843       return "Svojstva (property)";

   844     }

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

   846     virtual QCString trPropertyDocumentation()

   847     {

   848       return "Dokumentacija svojstava";

   849     }

   850 

   851 //////////////////////////////////////////////////////////////////////////

   852 // new since 1.2.4

   853 //////////////////////////////////////////////////////////////////////////

   854 

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

   856     virtual QCString trClasses()

   857     {

   858       return "Klase";

   859     }

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

   861     virtual QCString trPackage(const char *name)

   862     {

   863       return decode((QCString)"Paket "+name);

   864     }

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

   866     virtual QCString trPackageList()

   867     {

   868       return "Lista paketa";

   869     }

   870     /*! The description of the package index page */

   871     virtual QCString trPackageListDescription()

   872     {

   873       return "Paketi s kratkim opisom (ukoliko postoji):";

   874     }

   875     /*! The link name in the Quick links header for each page */

   876     virtual QCString trPackages()

   877     {

   878       return "Paketi";

   879     }

   880     /*! Text shown before a multi-line define */

   881     virtual QCString trDefineValue()

   882     {

   883       return "Vrijednost:";

   884     }

   885 

   886 //////////////////////////////////////////////////////////////////////////

   887 // new since 1.2.5

   888 //////////////////////////////////////////////////////////////////////////

   889     

   890     /*! Used as a marker that is put before a \\bug item */

   891     virtual QCString trBug()

   892     {

   893       return decode("Greška");

   894     }

   895     /*! Used as the header of the bug list */

   896     virtual QCString trBugList()

   897     {

   898       return decode("Popis grešaka");

   899     }

   900 

   901 //////////////////////////////////////////////////////////////////////////

   902 // new since 1.2.6

   903 //////////////////////////////////////////////////////////////////////////

   904     /*! Used as ansicpg for RTF file */

   905     virtual QCString trRTFansicp()

   906     {

   907       return "1252";

   908     }

   909     /*! Used as ansicpg for RTF fcharset */

   910     virtual QCString trRTFCharSet()

   911     {

   912       return "238";

   913     }

   914     /*! Used as header RTF general index */

   915     virtual QCString trRTFGeneralIndex()

   916     {

   917       return decode("Sadržaj");

   918     }

   919    

   920     /*! This is used for translation of the word that will possibly

   921      *  be followed by a single name or by a list of names 

   922      *  of the category.

   923      */

   924     virtual QCString trClass(bool first_capital, bool singular)

   925     { 

   926       QCString result((first_capital ? "Klas" : "klas"));

   927       result+= (singular ? "a" : "e");

   928       return result; 

   929     }

   930 

   931     /*! This is used for translation of the word that will possibly

   932      *  be followed by a single name or by a list of names 

   933      *  of the category.

   934      */

   935     virtual QCString trFile(bool first_capital, bool singular)

   936     { 

   937       QCString result((first_capital ? "Datotek" : "datotek"));

   938       result+= (singular ? "a" : "e");

   939       return result; 

   940     }

   941 

   942     /*! This is used for translation of the word that will possibly

   943      *  be followed by a single name or by a list of names 

   944      *  of the category.

   945      */

   946     virtual QCString trNamespace(bool first_capital, bool singular)

   947     { 

   948 		QCString result;

   949 		if (singular)

   950 			result = ((first_capital ? "Imenik" : "imenik"));

   951 		else

   952 			result = ((first_capital ? "Imenici" : "imenici"));

   953       return result; 

   954     }

   955 

   956     /*! This is used for translation of the word that will possibly

   957      *  be followed by a single name or by a list of names 

   958      *  of the category.

   959      */

   960     virtual QCString trGroup(bool first_capital, bool singular)

   961     { 

   962       QCString result((first_capital ? "Grup" : "grup"));

   963       result+= (singular ? "a" : "e");

   964       return result; 

   965     }

   966 

   967     /*! This is used for translation of the word that will possibly

   968      *  be followed by a single name or by a list of names 

   969      *  of the category.

   970      */

   971     virtual QCString trPage(bool first_capital, bool singular)

   972     { 

   973       QCString result((first_capital ? "Stranic" : "stranic"));

   974       result+= (singular ? "a" : "e");

   975       return result; 

   976     }

   977 

   978     /*! This is used for translation of the word that will possibly

   979      *  be followed by a single name or by a list of names 

   980      *  of the category.

   981      */

   982     virtual QCString trMember(bool first_capital, bool singular)

   983     { 

   984       QCString result((first_capital ? "Član" : "član"));

   985       if (!singular)  result+="ovi";

   986       return decode(result); 

   987     }

   988    

   989     /*! This is used for translation of the word that will possibly

   990      *  be followed by a single name or by a list of names 

   991      *  of the category.

   992      */

   993     virtual QCString trGlobal(bool first_capital, bool singular)

   994     { 

   995       QCString result((first_capital ? "G" : "g"));

   996 	  if( singular )

   997 		  result += "lobalna varijabla";

   998 	  else

   999 		  result += "lobalne varijable";

  1000 

  1001 	  return result; 

  1002     }

  1003 

  1004 //////////////////////////////////////////////////////////////////////////

  1005 // new since 1.2.7

  1006 //////////////////////////////////////////////////////////////////////////

  1007 

  1008     /*! This text is generated when the \\author command is used and

  1009      *  for the author section in man pages. */

  1010     virtual QCString trAuthor(bool first_capital, bool singular)

  1011     {                                                                         

  1012       QCString result((first_capital ? "Autor" : "autor"));

  1013       if (!singular)  result+="i";

  1014       return result; 

  1015     }

  1016 

  1017 //////////////////////////////////////////////////////////////////////////

  1018 // new since 1.2.11

  1019 //////////////////////////////////////////////////////////////////////////

  1020 

  1021     /*! This text is put before the list of members referenced by a member

  1022      */

  1023     virtual QCString trReferences()

  1024     {

  1025       return "Reference";

  1026     }

  1027 //////////////////////////////////////////////////////////////////////////

  1028 // new since 1.2.13

  1029 //////////////////////////////////////////////////////////////////////////

  1030 

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

  1032      *  members that are implemented by this one.

  1033      */

  1034     virtual QCString trImplementedFromList(int numEntries)

  1035     {

  1036       return "Implementira "+trWriteList(numEntries)+".";

  1037     }

  1038 

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

  1040      *  all members that implementation this member.

  1041      */

  1042     virtual QCString trImplementedInList(int numEntries)

  1043     {

  1044       return "Implementirano u "+trWriteList(numEntries)+".";

  1045     }

  1046 //////////////////////////////////////////////////////////////////////////

  1047 // new since 1.2.16

  1048 //////////////////////////////////////////////////////////////////////////

  1049 

  1050     /*! used in RTF documentation as a heading for the Table

  1051      *  of Contents.

  1052      */

  1053     virtual QCString trRTFTableOfContents()

  1054     {

  1055       return decode("Sadržaj");

  1056     }

  1057 //////////////////////////////////////////////////////////////////////////

  1058 // new since 1.2.17

  1059 //////////////////////////////////////////////////////////////////////////

  1060 

  1061     /*! Used as the header of the list of item that have been 

  1062      *  flagged deprecated 

  1063      */

  1064     virtual QCString trDeprecatedList()

  1065     {

  1066       return "Popis zastarjelih metoda";

  1067     }

  1068 //////////////////////////////////////////////////////////////////////////

  1069 // new since 1.2.18

  1070 //////////////////////////////////////////////////////////////////////////

  1071 

  1072     /*! Used as a header for declaration section of the events found in 

  1073      * a C# program

  1074      */

  1075     virtual QCString trEvents()

  1076     {

  1077       return decode("Događaji");

  1078     }

  1079     /*! Header used for the documentation section of a class' events. */

  1080     virtual QCString trEventDocumentation()

  1081     {

  1082       return decode("Dokumentacija događaja");

  1083     }

  1084 //////////////////////////////////////////////////////////////////////////

  1085 // new since 1.3

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

  1087 

  1088     /*! Used as a heading for a list of Java class types with package scope.

  1089      */

  1090     virtual QCString trPackageTypes()

  1091     { 

  1092       return "Tipovi u paketu";

  1093     }

  1094     /*! Used as a heading for a list of Java class functions with package 

  1095      * scope. 

  1096      */

  1097     virtual QCString trPackageMembers()

  1098     { 

  1099       return "Funkcije u paketu";

  1100     }

  1101     /*! Used as a heading for a list of static Java class functions with 

  1102      *  package scope.

  1103      */

  1104     virtual QCString trStaticPackageMembers()

  1105     { 

  1106       return decode("Statičke funkcije u paketu");

  1107     }

  1108     /*! Used as a heading for a list of Java class variables with package 

  1109      * scope.

  1110      */

  1111     virtual QCString trPackageAttribs()

  1112     { 

  1113       return "Atributi u paketu";

  1114     }

  1115     /*! Used as a heading for a list of static Java class variables with 

  1116      * package scope.

  1117      */

  1118     virtual QCString trStaticPackageAttribs()

  1119     { 

  1120       return decode("Statički atributi u paketu");

  1121     }

  1122 	//////////////////////////////////////////////////////////////////////////

  1123 	// new since 1.3.1

  1124 	//////////////////////////////////////////////////////////////////////////

  1125 

  1126 	/*! Used in the quick index of a class/file/namespace member list page 

  1127 	*  to link to the unfiltered list of all members.

  1128 	*/

  1129 	virtual QCString trAll()

  1130 	{

  1131 		return "Sve";

  1132 	}

  1133 	/*! Put in front of the call graph for a function. */

  1134 	virtual QCString trCallGraph()