FCL/sftools/depl/doctools: comparison Orb/Doxygen/src/translator

equal deleted inserted replaced

-:d8fccb2cd802
+:468f4c8d3d5b
 /******************************************************************************
 *
 *
 *
-* Copyright (C) 1997-2008 by Dimitri van Heesch.
+* Copyright (C) 1997-2010 by Dimitri van Heesch.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation under the terms of the GNU General Public License is hereby
 * granted. No representations are made about the suitability of this software
 * for any purpose. It is provided "as is" without express or implied warranty.
 *
 * Documents produced by Doxygen are derivative works derived from the
 * input used in their production; they are not affected by this license.
 *
 */
-// translation by Boris Bralo <boris.bralo@zg.htnet.hr>
+// translation by Boris Bralo <boris.bralo@gmail.com>
 // Updates:
 // --------
 // 2000/08/20
 //  - Better handling of ISO-8859-2/ WIN 1250 stuff based on (actualy stolen from :-)) Czech translations
 //    implemented by Petr Prikryl (prikrylp@skil.cz).
 // - Added strings for 1.4.6
 //
 // 2009/01/09
 // - Updated trLegendDocs
 //
+// 2010/03/04
+// - Updates for "new since 1.6.0 (mainly for the new search engine)".
+// - UTF-8
+// - removed decode()
 #ifndef TRANSLATOR_HR_H
 #define TRANSLATOR_HR_H
-class TranslatorCroatian : public TranslatorAdapter_1_6_0
+class TranslatorCroatian : public TranslatorAdapter_1_6_3
 {
 private:
-/*! to avoid macro redefinition from translator_cz.h */
-inline QCString decode(const QCString& sInput)
-{
-//if (Config_getBool("USE_WINDOWS_ENCODING"))
-//{
-//  return ISO88592ToWin1250(sInput);
-//}
-//else
-//{
-return sInput;
-//}
-}
 public:
 QCString idLanguage()
 { return "croatian"; }
 QCString idLanguageCharset()
 {
-//if (Config_getBool("USE_WINDOWS_ENCODING"))
+return "utf-8";
-//{
-//  return "windows-1250";
-//}
-//else
-//{
-return "iso-8859-2";
-//}
 }
 QCString latexLanguageSupportCommand()
 { return "\\usepackage[croatian]{babel}\n"; }
 QCString trRelatedFunctions()
 { return "Povezane funkcije"; }
 QCString trRelatedSubscript()
 { return "(To nisu member funkcije.)"; }
 QCString trDetailedDescription()
-{ return decode("Detaljno objašnjenje"); }
+{ return "Detaljno objaÅ¡njenje"; }
 QCString trMemberTypedefDocumentation()
-{ return decode("Dokumentacija typedef èlanova"); }
+{ return "Dokumentacija typedef Älanova"; }
 QCString trMemberEnumerationDocumentation()
-{ return decode("Dokumentacija enumeracijskih èlanova"); }
+{ return "Dokumentacija enumeracijskih Älanova"; }
 QCString trMemberFunctionDocumentation()
 { return "Dokumentacija funkcija"; }
 QCString trMemberDataDocumentation()
 { return "Documentacija varijabli"; }
 QCString trMore()
-{ return decode("Opširnije..."); }
+{ return "OpÅ¡irnije..."; }
 QCString trListOfAllMembers()
-{ return decode("Popis svih èlanova."); }
+{ return "Popis svih Älanova."; }
 QCString trMemberList()
-{ return decode("Popis èlanova."); }
+{ return "Popis Älanova."; }
 QCString trThisIsTheListOfAllMembers()
-{ return decode("Ovo je popis svih èlanova"); }
+{ return "Ovo je popis svih Älanova"; }
 QCString trIncludingInheritedMembers()
-{ return decode(", ukljuèujuæi naslijeðene èlanove."); }
+{ return ", ukljuÄujuÄ‡i naslijeÄ‘ene Älanove."; }
 QCString trGeneratedAutomatically(const char *s)
-{ QCString result=decode("generirano automatski Doxygen-om");
+{ QCString result="napravljeno automatski Doxygen-om";
 if (s) result+=(QCString)" za "+s;
 result+=" iz programskog koda.";
-return decode(result);
+return result;
 }
 QCString trEnumName()
-{ return decode("enum ime"); }
+{ return "enum ime"; }
 QCString trEnumValue()
-{ return decode("enum vrijednost"); }
+{ return "enum vrijednost"; }
 QCString trDefinedIn()
-{ return decode("definirano u"); }
+{ return "definirano u"; }
 QCString trModules()
 { return "Moduli"; }
 QCString trClassHierarchy()
 { return "Stablo klasa"; }
 QCString trCompoundList()
 QCString trFileList()
 { return "Popis datoteka"; }
 QCString trCompoundMembers()
 	{
 		if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
-			return decode("Svi èlanovi struktura");
+			return "Svi Älanovi struktura";
 		else
-			return decode("Svi èlanovi klasa");
+			return "Svi Älanovi klasa";
 	}
 QCString trFileMembers()
-{ return decode("Èlanovi klasa u datoteci"); }
+{ return "Älanovi klasa u datoteci"; }
 QCString trRelatedPages()
-{ return decode("Stranice povezane s ovom"); }
+{ return "Stranice povezane s ovom"; }
 QCString trExamples()
 { return "Primjeri"; }
 QCString trSearch()
-{ return decode("Traži"); }
+{ return "TraÅ¾i"; }
 QCString trClassHierarchyDescription()
-{ return decode("Stablo naslijeðivanja je složeno "
+{ return "Stablo naslijeÄ‘ivanja je sloÅ¾eno "
-"približno po abecedi:");
+"pribliÅ¾no po abecedi:";
 }
 QCString trFileListDescription(bool extractAll)
 {
 QCString result="Popis svih ";
 if (!extractAll) result+="dokumentiranih ";
 result+="datoteka, s kratkim opisom:";
-return decode(result);
+return result;
 }
 QCString trCompoundListDescription()
 { return "Popis svih klasa, unija i struktura "
 		  "s kratkim opisom :";
 }
 QCString result="Popis svih ";
 if (!extractAll)
 		  result+="dokumentiranih ";
 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
-		  result+="èlanova klasa s linkovima na ";
+		  result+="Älanova klasa s linkovima na ";
 	  else
-		  result+="èlanova struktura s linkovima na ";
+		  result+="Älanova struktura s linkovima na ";
 if (!extractAll)
 	  {
-		  result+="dokumentaciju svakog èlana:";
+		  result+="dokumentaciju svakog Älana:";
 }
 	  else
 	  {
 		  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
 			  result+="dokumentaciju klase :";
 		  else
 			  result +="dokumentaciju strukture";
 	  }
-return decode(result);
+return result;
 }
 QCString trFileMembersDescription(bool extractAll)
 {
 QCString result="Popis svih ";
 if (!extractAll)
 		  result+="dokumentiranih ";
-result+="èlanova s linkovima na ";
+result+="Älanova s linkovima na ";
 if (extractAll)
 		  result+="dokumentaciju datoteke u kojima se nalaze:";
 else
 		  result+="datoteke u kojima se nalaze:";
-return decode(result);
+return result;
 }
 QCString trExamplesDescription()
 { return "Popis primjera :"; }
 QCString trRelatedPagesDescription()
 { return "Popis povezanih stranica:"; }
 QCString trExampleDocumentation()
 { return "Dokumentacija primjera"; }
 QCString trPageDocumentation()
 { return "Dokumentacija vezane stranice"; }
 QCString trReferenceManual()
-{ return decode("Priruènik"); }
+{ return "PriruÄnik"; }
 QCString trDefines()
 { return "Definicije"; }
 QCString trFuncProtos()
 { return "Prototipi funkcija"; }
 { return "Dokumentacija varijable"; }
 QCString trCompounds()
 { return "Strukture"; }
 QCString trGeneratedAt(const char *date,const char *projName)
 {
-QCString result=(QCString)"Generirano "+date;
+QCString result=(QCString)"Napravljeno "+date;
 if (projName) result+=(QCString)" projekt: "+projName;
 result+=" generator: ";
-return decode(result);
+return result;
 }
 QCString trWrittenBy()
 {
-return decode("napisao ");
+return "napisao ";
 }
 QCString trClassDiagram(const char *clName)
 {
-return decode("Dijagram klasa za ")+clName;
+return QCString("Dijagram klasa za ")+clName;
 }
 QCString trForInternalUseOnly()
-{ return decode("Iskljuèivo za internu uporabu."); }
+{ return "IskljuÄivo za internu uporabu."; }
 QCString trWarning()
 { return "Upozorenje"; }
 QCString trVersion()
 { return "Verzija"; }
 QCString trDate()
 { return "Datum"; }
 QCString trReturns()
 { return "Povratne vrijednosti"; }
 QCString trSeeAlso()
-{ return decode("Vidi takoðer"); }
+{ return "Vidi takoÄ‘er"; }
 QCString trParameters()
 { return "Parametri"; }
 QCString trExceptions()
 { return "Iznimke"; }
 QCString trGeneratedBy()
 QCString trNamespaceListDescription(bool extractAll)
 {
 QCString result="Popis svih ";
 if (!extractAll) result+="dokumentiranih ";
 result+="imenika s kratkim opisom:";
-return decode(result);
+return result;
 }
 QCString trFriends()
-{ return decode("Friend-ovi "); }
+{ return "Friend-ovi "; }
 //////////////////////////////////////////////////////////////////////////
 // new since 0.49-990405
 //////////////////////////////////////////////////////////////////////////
 switch(compType)
 {
 case ClassDef::Class:  result+=" klase "; break;
 case ClassDef::Struct: result+=" strukture "; break;
 case ClassDef::Union:  result+=" unije "; break;
-case ClassDef::Interface:  result+=" suèelja (interface) "; break;
+case ClassDef::Interface:  result+=" suÄelja (interface) "; break;
 case ClassDef::Protocol:   result+=" protokola "; break;
 case ClassDef::Category:   result+=" kategorije "; break;
 case ClassDef::Exception:  result+=" iznimke (exception) "; break;
 }
 result += clName;
-return decode(result);
+return result;
 }
 QCString trFileReference(const char *fileName)
 // used as the title of the HTML page of a file
 {
 QCString result="Opis datoteke ";
 result+=fileName;
-return decode(result);
+return result;
 }
 QCString trNamespaceReference(const char *namespaceName)
 // used as the title of the HTML page of a namespace
 {
 QCString result ="Opis imenika ";
 result+=namespaceName;
-return decode(result);
+return result;
 }
 // these are for the member sections of a class, struct or union
 QCString trPublicMembers()
-{ return decode("Public èlanovi"); }
+{ return "Public Älanovi"; }
 QCString trPublicSlots()
 { return "Public slotovi"; }
 QCString trSignals()
 { return "Signali"; }
 QCString trStaticPublicMembers()
-{ return decode("Static public èlanovi"); }
+{ return "Static public Älanovi"; }
 QCString trProtectedMembers()
-{ return decode("Protected èlanovi"); }
+{ return "Protected Älanovi"; }
 QCString trProtectedSlots()
 { return "Protected slotovi"; }
 QCString trStaticProtectedMembers()
-{ return decode("Static protected èlanovi"); }
+{ return "Static protected Älanovi"; }
 QCString trPrivateMembers()
-{ return decode("Privatni èlanovi"); }
+{ return "Privatni Älanovi"; }
 QCString trPrivateSlots()
-{ return decode("Privatni slotovi"); }
+{ return "Privatni slotovi"; }
 QCString trStaticPrivateMembers()
-{ return decode("Statièni privatni èlanovi"); }
+{ return "StatiÄni privatni Älanovi"; }
 // end of member sections
 QCString trWriteList(int numEntries)
 {
 // this function is used to produce a comma-separated list of items.
 QCString trInheritsList(int numEntries)
 // used in class documentation to produce a list of base classes,
 // if class diagrams are disabled.
 {
-return decode("Naslijeðuje od "+trWriteList(numEntries)+".");
+return "NaslijeÄ‘uje od "+trWriteList(numEntries)+".";
 }
 QCString trInheritedByList(int numEntries)
 // used in class documentation to produce a list of super classes,
 // if class diagrams are disabled.
 {
-return decode("Naslijeðena u "+trWriteList(numEntries)+".");
+return "NaslijeÄ‘ena u "+trWriteList(numEntries)+".";
 }
 QCString trReimplementedFromList(int numEntries)
 // used in member documentation blocks to produce a list of
 // members that are hidden by this one.
 {
-return decode("Reimplementirano od  "+trWriteList(numEntries)+".");
+return "Reimplementirano od  "+trWriteList(numEntries)+".";
 }
 QCString trReimplementedInList(int numEntries)
 {
 // used in member documentation blocks to produce a list of
 // all member that overwrite the implementation of this member.
-return decode("Reimplementacija u "+trWriteList(numEntries)+".");
+return "Reimplementacija u "+trWriteList(numEntries)+".";
 }
 QCString trNamespaceMembers()
 // This is put above each page as a link to all members of namespaces.
-{ return decode("Èlanovi imenika"); }
+{ return "Älanovi imenika"; }
 QCString trNamespaceMemberDescription(bool extractAll)
 // This is an introduction to the page with all namespace members
 {
 QCString result="Lista svih ";
 if (!extractAll) result+="dokumentiranih ";
-result+="èlanova imenika s linkovima na ";
+result+="Älanova imenika s linkovima na ";
 if (extractAll)
-result+="imenièku dokumentaciju svakog èlana:";
+result+="imeniÄku dokumentaciju svakog Älana:";
 else
 result+="imenike kojima pripadaju:";
-return decode(result);
+return result;
 }
 QCString trNamespaceIndex()
 // This is used in LaTeX as the title of the chapter with the
 // index of all namespaces.
 { return "Kazalo imenika"; }
 switch(compType)
 {
 case ClassDef::Class:      result+="klase"; break;
 case ClassDef::Struct:     result+="strukture"; break;
 case ClassDef::Union:      result+="unije"; break;
-case ClassDef::Interface:  result+="suèelja (interface)"; break;
+case ClassDef::Interface:  result+="suÄelja (interface)"; break;
 case ClassDef::Protocol:   result+="protokola"; break;
 case ClassDef::Category:   result+="kategorije"; break;
 case ClassDef::Exception:  result+="iznimke (exception)"; break;
 }
-result+=" je generirana iz " + trFile(FALSE, single) + ": ";
+result+=" je napravljena iz " + trFile(FALSE, single) + ": ";
-	  return decode(result);
+	  return result;
 }
 /*! This is in the (quick) index as a link to the alphabetical compound
 * list.
 */
 //////////////////////////////////////////////////////////////////////////
 /*! this text is put before a collaboration diagram */
 QCString trCollaborationDiagram(const char *clName)
 {
-return decode( (QCString)"Kolaboracijski dijagram za "+clName+ ":");
+return (QCString)"Kolaboracijski dijagram za "+clName+ ":";
 }
 /*! this text is put before an include dependency graph */
 QCString trInclDepGraph(const char *fName)
 {
-return decode((QCString)"Graf include meðuovisnosti za "+fName+":");
+return (QCString)"Graf include meÄ‘uovisnosti za "+fName+":";
 }
 /*! header that is put before the list of constructor/destructors. */
 QCString trConstructorDocumentation()
 {
 return "Dokumentacija konstruktora i destruktora ";
 return "Invarijanta";
 }
 /*! Text shown before a multi-line variable/enum initialization */
 QCString trInitialValue()
 {
-return decode("Poèetna vrijednost:");
+return "PoÄetna vrijednost:";
 }
 /*! Text used the source code in the file index */
 QCString trCode()
 {
 return "kod";
 }
 QCString trGraphicalHierarchy()
 {
-return decode("Grafièko stablo klasa");
+return "GrafiÄko stablo klasa";
 }
 QCString trGotoGraphicalHierarchy()
 {
-return decode("Grafièko stablo klasa");
+return "GrafiÄko stablo klasa";
 }
 QCString trGotoTextualHierarchy()
 {
 return "Tekstualno stablo klasa";
 }
 {
 return "Napomene";
 }
 virtual QCString trAttention()
 {
-return decode("Pažnja");
+return "PaÅ¾nja";
 }
 virtual QCString trInclByDepGraph()
 {
-return decode("Ovaj graf pokazuje koje datoteke izravno "
+return "Ovaj graf pokazuje koje datoteke izravno "
-"ili neizravno ukljuèuju ovu datoteku:");
+"ili neizravno ukljuÄuju ovu datoteku:";
 }
 virtual QCString trSince()
 {
 return "Od";
 }
 }
 /*! page explaining how the dot graph's should be interpreted */
 virtual QCString trLegendDocs()
 {
 return
-decode( "Ova stranica objašnjava kako interpretirati grafikone koje je generirao "
+"Ova stranica objaÅ¡njava kako interpretirati grafikone koje je generirao "
 "doxygen.<p>\n"
 "Na primjer:\n"
 "\\code\n"
-"/*! Nevidljiva klasa (neæe stati na graf date visine) */\n"
+"/*! Nevidljiva klasa (neÄ‡e stati na graf date visine) */\n"
 "class Invisible { };\n\n"
 "/*! Odrezana klasa, inheritance je skriven (klase se vidi na grafu, ali ne i sve bazne klase) */\n"
 "class Truncated : public Invisible { };\n\n"
 "/* Nedokumentirana klasa */\n"
 "class Undocumented { };\n\n"
-"/*! Klasa koja je naslijeðena public  */\n"
+"/*! Klasa koja je naslijeÄ‘ena public  */\n"
 "class PublicBase : public Truncated { };\n\n"
 "/*! A template class */\n"
 "template<class T> class Templ { };\n\n"
-"/*! Klasa koje je naslijeðena protected */\n"
+"/*! Klasa koje je naslijeÄ‘ena protected */\n"
 "class ProtectedBase { };\n\n"
-"/*! Klasa koje je naslijeðena private */\n"
+"/*! Klasa koje je naslijeÄ‘ena private */\n"
 "class PrivateBase { };\n\n"
 "/*! Klasa koja se koristi agregacijom  */\n"
 "class Used { };\n\n"
-"/*! Super klasa koja naslijeðuje/koristi ostale */\n"
+"/*! Super klasa koja naslijeÄ‘uje/koristi ostale */\n"
 "class Inherited : public PublicBase,\n"
 "                  protected ProtectedBase,\n"
 "                  private PrivateBase,\n"
 "                  public Undocumented,\n"
 "                  public Templ<int>\n"
 "{\n"
 "  private:\n"
 "    Used *m_usedClass;\n"
 "};\n"
 "\\endcode\n"
-"To æe rezultirati grafikonom:"
+"To Ä‡e rezultirati grafikonom:"
 "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
 "<p>\n"
-"Pravokutnici imaju slijedeæe znaèenje:\n"
+"Pravokutnici imaju slijedeÄ‡e znaÄenje:\n"
 "<ul>\n"
-"<li>%A Puni crni predstavlja klasu za koji je generiran graf.\n"
+"<li>Puni crni predstavlja klasu za koji je napravljen graf.\n"
-"<li>%A Pravokutnik s crnim rubom predstavlja dokumentiranu klasu.\n"
+"<li>Pravokutnik s crnim rubom predstavlja dokumentiranu klasu.\n"
-"<li>%A Pravokutnik s sivim rubom predstavlja nedokumentiranu klasu.\n"
+"<li>Pravokutnik s sivim rubom predstavlja nedokumentiranu klasu.\n"
-"<li>%A Pravokutnik s crvenim rubom predstavlja dokumentiranu klasu\n"
+"<li>Pravokutnik s crvenim rubom predstavlja dokumentiranu klasu\n"
-"Za koju nije prikazan graf naslijeðivanja. Graf je odrezan "
+"Za koju nije prikazan graf naslijeÄ‘ivanja. Graf je odrezan "
-"ako ne stane unutar odreðenih granica."
+"ako ne stane unutar odreÄ‘enih granica."
 "</ul>\n"
-"Strelice imaju slijedeæe znaèenje:\n"
+"Strelice imaju slijedeÄ‡e znaÄenje:\n"
 "<ul>\n"
-"<li>%A Tamnoplava strelica oznaèava public naslijeðivanje.\n"
+"<li>Tamnoplava strelica oznaÄava public naslijeÄ‘ivanje.\n"
-"<li>%A Tamnozelena strelica oznaèava protected naslijeðivanje.\n"
+"<li>Tamnozelena strelica oznaÄava protected naslijeÄ‘ivanje.\n"
-"<li>%A Tamnocrvena strelica oznaèava private naslijeðivanje.\n"
+"<li>Tamnocrvena strelica oznaÄava private naslijeÄ‘ivanje.\n"
-"<li>%A Ljubièasta isprekidana strelica se koristi ako je klasa dio "
+"<li>LjubiÄasta isprekidana strelica se koristi ako je klasa dio "
 "druge klase ili ako se klasa koristi u drugoj klasi. Natpis na "
 "strelici je ime varijable u drugoj klasi\n"
-"Strelica je oznaèena imenom varijable.\n"
+"Strelica je oznaÄena imenom varijable.\n"
-"<li>%A Žuta isprekidana strelica oznaèava relaciju izmeðu template instance "
+"<li>Å½uta isprekidana strelica oznaÄava relaciju izmeÄ‘u template instance "
-"i template klase. Oznaèena je imenom template parametra\n"
+"i template klase. OznaÄena je imenom template parametra\n"
-"</ul>\n");
+"</ul>\n";
 }
 /*! text for the link to the legend page */
 virtual QCString trLegend()
 {
 return "legenda";
 return "Klase";
 }
 /*! Used as the title of a Java package */
 virtual QCString trPackage(const char *name)
 {
-return decode((QCString)"Paket "+name);
+return (QCString)"Paket "+name;
 }
 /*! Title of the package index page */
 virtual QCString trPackageList()
 {
 return "Lista paketa";
 //////////////////////////////////////////////////////////////////////////
 /*! Used as a marker that is put before a \\bug item */
 virtual QCString trBug()
 {
-return decode("Greška");
+return "GreÅ¡ka";
 }
 /*! Used as the header of the bug list */
 virtual QCString trBugList()
 {
-return decode("Popis grešaka");
+return "Popis greÅ¡aka";
 }
 //////////////////////////////////////////////////////////////////////////
 // new since 1.2.6
 //////////////////////////////////////////////////////////////////////////
 return "238";
 }
 /*! Used as header RTF general index */
 virtual QCString trRTFGeneralIndex()
 {
-return decode("Sadržaj");
+return "SadrÅ¾aj";
 }
 /*! This is used for translation of the word that will possibly
 *  be followed by a single name or by a list of names
 *  of the category.
 *  be followed by a single name or by a list of names
 *  of the category.
 */
 virtual QCString trMember(bool first_capital, bool singular)
 {
-QCString result((first_capital ? "Èlan" : "èlan"));
+QCString result((first_capital ? "Älan" : "Älan"));
 if (!singular)  result+="ovi";
-return decode(result);
+return result;
 }
 /*! This is used for translation of the word that will possibly
 *  be followed by a single name or by a list of names
 *  of the category.
 /*! used in RTF documentation as a heading for the Table
 *  of Contents.
 */
 virtual QCString trRTFTableOfContents()
 {
-return decode("Sadržaj");
+return "SadrÅ¾aj";
 }
 //////////////////////////////////////////////////////////////////////////
 // new since 1.2.17
 //////////////////////////////////////////////////////////////////////////
 /*! Used as a header for declaration section of the events found in
 * a C# program
 */
 virtual QCString trEvents()
 {
-return decode("Dogaðaji");
+return "DogaÄ‘aji";
 }
 /*! Header used for the documentation section of a class' events. */
 virtual QCString trEventDocumentation()
 {
-return decode("Dokumentacija dogaðaja");
+return "Dokumentacija dogaÄ‘aja";
 }
 //////////////////////////////////////////////////////////////////////////
 // new since 1.3
 //////////////////////////////////////////////////////////////////////////
 /*! Used as a heading for a list of static Java class functions with
 *  package scope.
 */
 virtual QCString trStaticPackageMembers()
 {
-return decode("Statièke funkcije u paketu");
+return "StatiÄke funkcije u paketu";
 }
 /*! Used as a heading for a list of Java class variables with package
 * scope.
 */
 virtual QCString trPackageAttribs()
 /*! Used as a heading for a list of static Java class variables with
 * package scope.
 */
 virtual QCString trStaticPackageAttribs()
 {
-return decode("Statièki atributi u paketu");
+return "StatiÄki atributi u paketu";
 }
 	//////////////////////////////////////////////////////////////////////////
 	// new since 1.3.1
 	//////////////////////////////////////////////////////////////////////////
 	*  of each page before the field where one can enter the text to search
 	*  for.
 	*/
 	virtual QCString trSearchForIndex()
 	{
-		return decode("Traži");
+		return "TraÅ¾i";
 	}
 	/*! This string is used as the title for the page listing the search
 	*  results.
 	*/
 	virtual QCString trSearchResultsTitle()
 	*/
 	virtual QCString trSearchResults(int numDocuments)
 	{
 		if (numDocuments==0)
 		{
-			return decode("Nema dokumenta koji odgovaraju vašem upitu");
+			return "Nema dokumenta koji odgovaraju vaÅ¡em upitu";
 		}
 		else if (numDocuments==1)
 		{
-			return decode("Naðen <b>1</b> dokument koji odgovara vašem upitu.");
+			return "NaÄ‘en <b>1</b> dokument koji odgovara vaÅ¡em upitu.";
 		}
 		else if (numDocuments<5)
 		{
-			// croatian handle numbers up to 5 differently
+			// Croatian (AFAIK all Slavic languages except Macedonian and Bulgarian)
-			// For those of you who like to read comments :
+// have different plural form for 2,3,4.
-			// There are only 4 men in the world in croatian.
+			return "NaÄ‘ena <b>$num</b> dokumenta koji odgovaraju vaÅ¡em upitu."
-			// We say 1 èovjek (man), 2 èovjeka, 3 èovjeka , 4 èovjeka , but 5, 6, 7 ... ljudi (people)
+				"Najbolji su prikazani prvi.";
-			// That's deep, isn't it :-)?
-			return decode("Naðena <b>$num</b> dokumenta koji odgovaraju vašem upitu."
-				"Najbolji su prikazani prvi.");
 		}
 		else
 		{
-			return decode("Naðeno <b>$num</b> dokumenata koji odgovaraju vašem upitu."
+			return "NaÄ‘eno <b>$num</b> dokumenata koji odgovaraju vaÅ¡em upitu."
-				"Najbolji su prikazani prvi.");
+				"Najbolji su prikazani prvi.";
 		}
 	}
 	/*! This string is put before the list of matched words, for each search
 	*  result. What follows is the list of words that matched the query.
 	*/
 	virtual QCString trSearchMatches()
 	{
-		return decode("Pronaðeno:");
+		return "PronaÄ‘eno:";
 	}
 //////////////////////////////////////////////////////////////////////////
 // new since 1.3.8
 //////////////////////////////////////////////////////////////////////////
 /*! This text is added to the documentation when the \\overload command
 *  is used for a overloaded function.
 */
 virtual QCString trOverloadText()
 {
-return decode("Ovo je preoptereæena funkcija (overload). "
+return "Ovo je preoptereÄ‡ena funkcija (overload). "
 "Razlikuje se od navedene metode "
-"samo po vrsti argumenata koje prihvata.");
+"samo po vrsti argumenata koje prihvaÄ‡a.";
 }
 //////////////////////////////////////////////////////////////////////////
 // new since 1.4.6
 //////////////////////////////////////////////////////////////////////////
 switch(compType)
 {
 case ClassDef::Class:      result+=" Modul"; break;
 case ClassDef::Struct:     result+=" Tip"; break;
 case ClassDef::Union:      result+=" Unija"; break;
-case ClassDef::Interface:  result+=" Suèelje"; break;
+case ClassDef::Interface:  result+=" SuÄelje"; break;
 case ClassDef::Protocol:   result+=" Protokol"; break;
 case ClassDef::Category:   result+=" Kategorija"; break;
 case ClassDef::Exception:  result+=" Iznimka"; break;
 }
-if (isTemplate) result+=" Predložak";
+if (isTemplate) result+=" PredloÅ¾ak";
 result+=" Referenca";
 return result;
 }
 /*! used as the title of the HTML page of a module (Fortran) */
 virtual QCString trModuleReference(const char *namespaceName)
 {
 QCString result=namespaceName;
-result+=" - Sadržaj modula";
+result+=" - SadrÅ¾aj modula";
 return result;
 }
 /*! This is put above each page as a link to all members of modules. (Fortran) */
 virtual QCString trModulesMembers()
-{ return "Èlanovi modula"; }
+{ return "Älanovi modula"; }
 /*! This is an introduction to the page with all modules members (Fortran) */
 virtual QCString trModulesMemberDescription(bool extractAll)
 {
 QCString result="Lista svih ";
 if (!extractAll) result+="dokumentiranih ";
-result+="èlanova modula s linkovima na ";
+result+="Älanova modula s linkovima na ";
 if (extractAll)
 {
-result+="dokumentaciju modula za svaki èlan:";
+result+="dokumentaciju modula za svaki Älan:";
 }
 else
 {
 result+="modul kojem pripadaju:";
 }
 switch(compType)
 {
 case ClassDef::Class:      result+="modula"; break;
 case ClassDef::Struct:     result+="tipa"; break;
 case ClassDef::Union:      result+="unije"; break;
-case ClassDef::Interface:  result+="suèelja"; break;
+case ClassDef::Interface:  result+="suÄelja"; break;
 case ClassDef::Protocol:   result+="protokola"; break;
 case ClassDef::Category:   result+="kategorije"; break;
 case ClassDef::Exception:  result+="iznimke"; break;
 }
-result+=" je generirana iz :";
+result+=" je napravljena iz :";
 return result;
 }
 /*! This is used for translation of the word that will possibly
 *  be followed by a single name or by a list of names
 *  of the category.
 QCString result((first_capital ? "Subprogram" : "subprogram"));
 if (!singular)  result+="i";
 return result;
 }
-/*! C# Type Contraint list */
+/*! C# Type Constraint list */
 virtual QCString trTypeConstraints()
 {
-return "Ogranièenja za tip podataka";
+return "OgraniÄenja tipova (Type Constraints)";
+}
+//////////////////////////////////////////////////////////////////////////
+// new since 1.6.0 (mainly for the new search engine)
+//////////////////////////////////////////////////////////////////////////
+/*! directory relation for \a name */
+virtual QCString trDirRelation(const char *name)
+{
+return QCString("Relacije ") + QCString(name);
+}
+/*! Loading message shown when loading search results */
+virtual QCString trLoading()
+{
+return "UÄitavam...";
+}
+/*! Label used for search results in the global namespace */
+virtual QCString trGlobalNamespace()
+{
+return "Globalni namespace";
+}
+/*! Message shown while searching */
+virtual QCString trSearching()
+{
+return "TraÅ¾im...";
+}
+/*! Text shown when no search results are found */
+virtual QCString trNoMatches()
+{
+return "Nema traÅ¾enih podataka";
 }
 };
 #endif

changeset 4	468f4c8d3d5b
parent 0	42188c7ea2d9