Orb/Doxygen/src/translator_sk.h
changeset 0 42188c7ea2d9
child 4 468f4c8d3d5b
equal deleted inserted replaced
-1:000000000000 0:42188c7ea2d9
       
     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  *
       
    18  * Slovak translation by Stanislav Kudlac (skudlac@pobox.sk)
       
    19  *
       
    20  * ----------------------------------------------------------------------------
       
    21  */
       
    22 
       
    23 #ifndef TRANSLATOR_SK_H
       
    24 #define TRANSLATOR_SK_H
       
    25 
       
    26 class TranslatorSlovak : public TranslatorAdapter_1_2_18
       
    27 {
       
    28   private:
       
    29 	/*! The Decode() inline assumes the source written in the
       
    30 		Windows encoding (maintainer only dependent).
       
    31 	 */
       
    32 	inline QCString Decode(const QCString & sInput)
       
    33 	{
       
    34 //#ifdef _WIN32
       
    35 	  return sInput;
       
    36 //#else
       
    37 //	  return Win1250ToISO88592(sInput);
       
    38 //#endif
       
    39 	}
       
    40 
       
    41   public:
       
    42 	// --- Language control methods -------------------
       
    43 
       
    44 	virtual QCString idLanguage()
       
    45 	{ return "slovak"; }
       
    46 
       
    47 	virtual QCString latexLanguageSupportCommand()
       
    48 	{ return "\\usepackage[slovak]{babel}\n"; }
       
    49 
       
    50 	/*! return the language charset. This will be used for the HTML output */
       
    51 	virtual QCString idLanguageCharset()
       
    52 	{
       
    53 //#ifdef _WIN32
       
    54 		return "windows-1250";
       
    55 //#else
       
    56 //		return "iso-8859-2";
       
    57 //#endif
       
    58 	}
       
    59 
       
    60 	// --- Language translation methods -------------------
       
    61 
       
    62 	/*! used in the compound documentation before a list of related functions. */
       
    63 	virtual QCString trRelatedFunctions()
       
    64 	{ return Decode("Súvisiace funkcie"); }
       
    65 
       
    66 	/*! subscript for the related functions. */
       
    67 	virtual QCString trRelatedSubscript()
       
    68 	{ return Decode("(Uvedené funkcie niesú členskými funkciami.)"); }
       
    69 
       
    70 	/*! header that is put before the detailed description of files, classes and namespaces. */
       
    71 	virtual QCString trDetailedDescription()
       
    72 	{ return Decode("Detailný popis"); }
       
    73 
       
    74 	/*! header that is put before the list of typedefs. */
       
    75 	virtual QCString trMemberTypedefDocumentation()
       
    76 	{ return Decode("Dokumentácia k členským typom"); }
       
    77 
       
    78 	/*! header that is put before the list of enumerations. */
       
    79 	virtual QCString trMemberEnumerationDocumentation()
       
    80 	{ return Decode("Dokumentácia k členským enumeráciám"); }
       
    81 
       
    82 	/*! header that is put before the list of member functions. */
       
    83 	virtual QCString trMemberFunctionDocumentation()
       
    84 	{ return Decode("Dokumentácia k metódam"); }
       
    85 
       
    86 	/*! header that is put before the list of member attributes. */
       
    87 	virtual QCString trMemberDataDocumentation()
       
    88 	{
       
    89 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
    90 	  {
       
    91 		return Decode("Dokumentácia k položkám");
       
    92 	  }
       
    93 	  else
       
    94 	  {
       
    95 		return Decode("Dokumentácia k dátovým členom");
       
    96 	  }
       
    97 	}
       
    98 
       
    99 	/*! this is the text of a link put after brief descriptions. */
       
   100 	virtual QCString trMore()
       
   101 	{ return Decode("..."); }
       
   102 
       
   103 	/*! put in the class documentation */
       
   104 	virtual QCString trListOfAllMembers()
       
   105 	{ return Decode("Zoznam všetkých členov."); }
       
   106 
       
   107 	/*! used as the title of the "list of all members" page of a class */
       
   108 	virtual QCString trMemberList()
       
   109 	{ return Decode("Zoznam členov triedy"); }
       
   110 
       
   111 	/*! this is the first part of a sentence that is followed by a class name */
       
   112 	virtual QCString trThisIsTheListOfAllMembers()
       
   113 	{ return Decode("Tu nájdete úplný zoznam členov triedy "); }
       
   114 
       
   115 	/*! this is the remainder of the sentence after the class name */
       
   116 	virtual QCString trIncludingInheritedMembers()
       
   117 	{ return Decode(", vrátane všetkých zdedených členov."); }
       
   118 
       
   119 	/*! this is put at the author sections at the bottom of man pages.
       
   120 	 *	parameter s is name of the project name.
       
   121 	 */
       
   122 	virtual QCString trGeneratedAutomatically(const char *s)
       
   123 	{ QCString result="Generované automaticky programom Doxygen "
       
   124 					  "zo zdrojových textov";
       
   125 	  if (s) result+=(QCString)" projektu "+s;
       
   126 	  result+=".";
       
   127 	  return Decode(result);
       
   128 	}
       
   129 
       
   130 	/*! put after an enum name in the list of all members */
       
   131 	virtual QCString trEnumName()
       
   132 	{ return Decode("meno enumerácie"); }
       
   133 
       
   134 	/*! put after an enum value in the list of all members */
       
   135 	virtual QCString trEnumValue()
       
   136 	{ return Decode("hodnota enumerácie"); }
       
   137 
       
   138 	/*! put after an undocumented member in the list of all members */
       
   139 	virtual QCString trDefinedIn()
       
   140 	{ return Decode("definovaný v"); }
       
   141 
       
   142 	// quick reference sections
       
   143 
       
   144 	/*! This is put above each page as a link to the list of all groups of
       
   145 	 *	compounds or files (see the \\group command).
       
   146 	 */
       
   147 	virtual QCString trModules()
       
   148 	{ return Decode("Moduly"); }
       
   149 
       
   150 	/*! This is put above each page as a link to the class hierarchy */
       
   151 	virtual QCString trClassHierarchy()
       
   152 	{ return Decode("Hierarchia tried"); }
       
   153 
       
   154 	/*! This is put above each page as a link to the list of annotated classes */
       
   155 	virtual QCString trCompoundList()
       
   156 	{
       
   157 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   158 	  {
       
   159 		return Decode("Dátové štruktúry");
       
   160 	  }
       
   161 	  else
       
   162 	  {
       
   163 		return Decode("Zoznam tried");
       
   164 	  }
       
   165 	}
       
   166 
       
   167 	/*! This is put above each page as a link to the list of documented files */
       
   168 	virtual QCString trFileList()
       
   169 	{ return Decode("Zoznam súborov"); }
       
   170 
       
   171 	/*! This is put above each page as a link to the list of all verbatim headers */
       
   172 	virtual QCString trHeaderFiles()
       
   173 	{ return Decode("Zoznam hlavičkových súborov"); }
       
   174 
       
   175 	/*! This is put above each page as a link to all members of compounds. */
       
   176 	virtual QCString trCompoundMembers()
       
   177 	{
       
   178 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   179 	  {
       
   180 		return Decode("Dátové položky");
       
   181 	  }
       
   182 	  else
       
   183 	  {
       
   184 		return Decode("Zoznam členov tried");
       
   185 	  }
       
   186 	}
       
   187 
       
   188 	/*! This is put above each page as a link to all members of files. */
       
   189 	virtual QCString trFileMembers()
       
   190 	{
       
   191 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   192 	  {
       
   193 		return Decode("Globálne symboly");
       
   194 	  }
       
   195 	  else
       
   196 	  {
       
   197 		return Decode("Symboly v súboroch");
       
   198 	  }
       
   199 	}
       
   200 
       
   201 	/*! This is put above each page as a link to all related pages. */
       
   202 	virtual QCString trRelatedPages()
       
   203 	{ return Decode("Ostatné stránky"); }
       
   204 
       
   205 	/*! This is put above each page as a link to all examples. */
       
   206 	virtual QCString trExamples()
       
   207 	{ return Decode("Príklady"); }
       
   208 
       
   209 	/*! This is put above each page as a link to the search engine. */
       
   210 	virtual QCString trSearch()
       
   211 	{ return Decode("Hľadať"); }
       
   212 
       
   213 	/*! This is an introduction to the class hierarchy. */
       
   214 	virtual QCString trClassHierarchyDescription()
       
   215 	{ return Decode("Tu nájdete zoznam, vyjadrujúci vzťah dedičnosti tried. "
       
   216 			 "Je zoradený približne (ale nie úplne) podľa abecedy:");
       
   217 	}
       
   218 
       
   219 	/*! This is an introduction to the list with all files. */
       
   220 	virtual QCString trFileListDescription(bool extractAll)
       
   221 	{
       
   222 	  QCString result="Tu nájdete zoznam všetkých ";
       
   223 	  if (!extractAll) result+="dokumentovaných ";
       
   224 	  result+="súborov so stručnými popismi:";
       
   225 	  return Decode(result);
       
   226 	}
       
   227 
       
   228 	/*! This is an introduction to the annotated compound list. */
       
   229 	virtual QCString trCompoundListDescription()
       
   230 	{
       
   231 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   232 	  {
       
   233 		return Decode("Nasledujúci zoznam obsahuje identifikáciu dátových "
       
   234 					  "štruktúr a ich stručné popisy:");
       
   235 	  }
       
   236 	  else
       
   237 	  {
       
   238 		return Decode("Nasledujúci zoznam obsahuje predovšetkým identifikáciu "
       
   239 					  "tried, ale nachádzajú sa tu i ďalšie netriviálne prvky, "
       
   240 					  "ako sú štruktúry (struct), uniony (union) a rozhrania "
       
   241 					  "(interface). V zozname sú uvedené ich stručné "
       
   242 					  "popisy:");
       
   243 	  }
       
   244 	}
       
   245 
       
   246 	/*! This is an introduction to the page with all class members. */
       
   247 	virtual QCString trCompoundMembersDescription(bool extractAll)
       
   248 	{
       
   249 	  QCString result= "Tu nájdete zoznam všetkých ";
       
   250 	  if (!extractAll)
       
   251 	  {
       
   252 		result += "dokumentovaných ";
       
   253 	  }
       
   254 
       
   255 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   256 	  {
       
   257 		result += "položiek štruktúr (struct) a unionov (union) ";
       
   258 	  }
       
   259 	  else
       
   260 	  {
       
   261 		result += "členov tried ";
       
   262 	  }
       
   263 
       
   264 	  result += "s odkazmi na ";
       
   265 
       
   266 	  if (!extractAll)
       
   267 	  {
       
   268 		if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   269 		{
       
   270 		  result += "dokumentáciu štruktúr/unionov, ku ktorým prislúchajú:";
       
   271 		}
       
   272 		else
       
   273 		{
       
   274 		  result += "dokumentáciu tried, ku ktorým prislúchajú:";
       
   275 		}
       
   276 	  }
       
   277 	  else
       
   278 	  {
       
   279 		if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   280 		{
       
   281 		  result+="štruktúry/uniony, ku ktorým prislúchajú:";
       
   282 		}
       
   283 		else
       
   284 		{
       
   285 		  result+="triedy, ku ktorým prislúchajú:";
       
   286 		}
       
   287 	  }
       
   288 
       
   289 	  return Decode(result);
       
   290 	}
       
   291 
       
   292 	/*! This is an introduction to the page with all file members. */
       
   293 	virtual QCString trFileMembersDescription(bool extractAll)
       
   294 	{
       
   295 	  QCString result="Tu nájdete zoznam všetkých ";
       
   296 	  if (!extractAll) result+="dokumentovaných ";
       
   297 
       
   298 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   299 	  {
       
   300 		result+="funkcií, premenných, makier, enumerácií a definícií typov (typedef) "
       
   301 				"s odkazmi na ";
       
   302 	  }
       
   303 	  else
       
   304 	  {
       
   305 		result+="symbolov, ktoré sú definované na úrovni svojich súborov. "
       
   306 				"Pre každý symbol je uvedený odkaz na ";
       
   307 	  }
       
   308 
       
   309 	  if (extractAll)
       
   310 		result+="súbory, ku ktorým prislúchajú:";
       
   311 	  else
       
   312 		result+="dokumentáciu:";
       
   313 
       
   314 	  return Decode(result);
       
   315 	}
       
   316 
       
   317 	/*! This is an introduction to the page with the list of all header files. */
       
   318 	virtual QCString trHeaderFilesDescription()
       
   319 	{ return Decode("Tu nájdete hlavičkové súbory, ktoré tvoria "
       
   320 			 "aplikačné programové rozhranie (API):"); }
       
   321 
       
   322 	/*! This is an introduction to the page with the list of all examples */
       
   323 	virtual QCString trExamplesDescription()
       
   324 	{ return Decode("Tu nájdete zoznam všetkých príkladov:"); }
       
   325 
       
   326 	/*! This is an introduction to the page with the list of related pages */
       
   327 	virtual QCString trRelatedPagesDescription()
       
   328 	{ return Decode("Nasledujúci zoznam odkazuje na ďalšie stránky projektu, "
       
   329 					"ktoré majú charakter usporiadaných zoznamov informácií, "
       
   330 					"pozbieraných z rôznych miest v zdrojových súboroch:"); }
       
   331 
       
   332 	/*! This is an introduction to the page with the list of class/file groups */
       
   333 	virtual QCString trModulesDescription()
       
   334 	{ return Decode("Tu nájdete zoznam všetkých modulov:"); }
       
   335 
       
   336 	/*! This sentences is used in the annotated class/file lists if no brief
       
   337 	 * description is given.
       
   338 	 */
       
   339 	virtual QCString trNoDescriptionAvailable()
       
   340 	{ return Decode("Popis nieje k dispozícii"); }
       
   341 
       
   342 	// index titles (the project name is prepended for these)
       
   343 
       
   344 
       
   345 	/*! This is used in HTML as the title of index.html. */
       
   346 	virtual QCString trDocumentation()
       
   347 	{ return Decode("Dokumentácia"); }
       
   348 
       
   349 	/*! This is used in LaTeX as the title of the chapter with the
       
   350 	 * index of all groups.
       
   351 	 */
       
   352 	virtual QCString trModuleIndex()
       
   353 	{ return Decode("Register modulov"); }
       
   354 
       
   355 	/*! This is used in LaTeX as the title of the chapter with the
       
   356 	 * class hierarchy.
       
   357 	 */
       
   358 	virtual QCString trHierarchicalIndex()
       
   359 	{ return Decode("Register hierarchie tried"); }
       
   360 
       
   361 	/*! This is used in LaTeX as the title of the chapter with the
       
   362 	 * annotated compound index.
       
   363 	 */
       
   364 	virtual QCString trCompoundIndex()
       
   365 	{
       
   366 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   367 	  {
       
   368 		return Decode("Register dátových štruktúr");
       
   369 	  }
       
   370 	  else
       
   371 	  {
       
   372 		return Decode("Register tried");
       
   373 	  }
       
   374 	}
       
   375 
       
   376 	/*! This is used in LaTeX as the title of the chapter with the
       
   377 	 * list of all files.
       
   378 	 */
       
   379 	virtual QCString trFileIndex()
       
   380 	{ return Decode("Register súborov"); }
       
   381 
       
   382 	/*! This is used in LaTeX as the title of the chapter containing
       
   383 	 *	the documentation of all groups.
       
   384 	 */
       
   385 	virtual QCString trModuleDocumentation()
       
   386 	{ return Decode("Dokumentácia modulov"); }
       
   387 
       
   388 	/*! This is used in LaTeX as the title of the chapter containing
       
   389 	 *	the documentation of all classes, structs and unions.
       
   390 	 */
       
   391 	virtual QCString trClassDocumentation()
       
   392 	{ return Decode("Dokumentácia tried"); }
       
   393 
       
   394 	/*! This is used in LaTeX as the title of the chapter containing
       
   395 	 *	the documentation of all files.
       
   396 	 */
       
   397 	virtual QCString trFileDocumentation()
       
   398 	{ return Decode("Dokumentácia súborov"); }
       
   399 
       
   400 	/*! This is used in LaTeX as the title of the chapter containing
       
   401 	 *	the documentation of all examples.
       
   402 	 */
       
   403 	virtual QCString trExampleDocumentation()
       
   404 	{ return Decode("Dokumentácia príkladov"); }
       
   405 
       
   406 	/*! This is used in LaTeX as the title of the chapter containing
       
   407 	 *	the documentation of all related pages.
       
   408 	 */
       
   409 	virtual QCString trPageDocumentation()
       
   410 	{ return Decode("Dokumentácia súvisiacich stránok"); }
       
   411 
       
   412 	/*! This is used in LaTeX as the title of the document */
       
   413 	virtual QCString trReferenceManual()
       
   414 	{ return Decode("Referenčná príručka"); }
       
   415 
       
   416 	/*! This is used in the documentation of a file as a header before the
       
   417 	 *	list of defines
       
   418 	 */
       
   419 	virtual QCString trDefines()
       
   420 	{ return Decode("Definícia makier"); }
       
   421 
       
   422 	/*! This is used in the documentation of a file as a header before the
       
   423 	 *	list of function prototypes
       
   424 	 */
       
   425 	virtual QCString trFuncProtos()
       
   426 	{ return Decode("Prototypy"); }
       
   427 
       
   428 	/*! This is used in the documentation of a file as a header before the
       
   429 	 *	list of typedefs
       
   430 	 */
       
   431 	virtual QCString trTypedefs()
       
   432 	{ return Decode("Definícia typov"); }
       
   433 
       
   434 	/*! This is used in the documentation of a file as a header before the
       
   435 	 *	list of enumerations
       
   436 	 */
       
   437 	virtual QCString trEnumerations()
       
   438 	{ return Decode("Enumerácie"); }
       
   439 
       
   440 	/*! This is used in the documentation of a file as a header before the
       
   441 	 *	list of (global) functions
       
   442 	 */
       
   443 	virtual QCString trFunctions()
       
   444 	{ return Decode("Funkcie"); }
       
   445 
       
   446 	/*! This is used in the documentation of a file as a header before the
       
   447 	 *	list of (global) variables
       
   448 	 */
       
   449 	virtual QCString trVariables()
       
   450 	{ return Decode("Premenné"); }
       
   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 trEnumerationValues()
       
   456 	{ return Decode("Hodnoty enumerácií"); }
       
   457 
       
   458 	/*! This is used in the documentation of a file before the list of
       
   459 	 *	documentation blocks for defines
       
   460 	 */
       
   461 	virtual QCString trDefineDocumentation()
       
   462 	{ return Decode("Dokumentácia k definíciám makier"); }
       
   463 
       
   464 	/*! This is used in the documentation of a file/namespace before the list
       
   465 	 *	of documentation blocks for function prototypes
       
   466 	 */
       
   467 	virtual QCString trFunctionPrototypeDocumentation()
       
   468 	{ return Decode("Dokumentácia prototypov"); }
       
   469 
       
   470 	/*! This is used in the documentation of a file/namespace before the list
       
   471 	 *	of documentation blocks for typedefs
       
   472 	 */
       
   473 	virtual QCString trTypedefDocumentation()
       
   474 	{ return Decode("Dokumentácia definícií typov"); }
       
   475 
       
   476 	/*! This is used in the documentation of a file/namespace before the list
       
   477 	 *	of documentation blocks for enumeration types
       
   478 	 */
       
   479 	virtual QCString trEnumerationTypeDocumentation()
       
   480 	{ return Decode("Dokumentácia enumeračných typov"); }
       
   481 
       
   482 	/*! This is used in the documentation of a file/namespace before the list
       
   483 	 *	of documentation blocks for enumeration values
       
   484 	 */
       
   485 	virtual QCString trEnumerationValueDocumentation()
       
   486 	{ return Decode("Dokumentácia enumeračných hodnôt"); }
       
   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("Dokumentácia funkcií"); }
       
   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("Dokumentácia premenných"); }
       
   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("Dátové štruktúry");
       
   508 	  }
       
   509 	  else
       
   510 	  {
       
   511 		return Decode("Triedy");
       
   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)"Generované "+date;
       
   521 	  if (projName) result+=(QCString)" pre projekt "+projName;
       
   522 	  result+=(QCString)" programom";
       
   523 	  return Decode(result);
       
   524 	}
       
   525 
       
   526 	/*! This is part of the sentence used in the standard footer of each page.
       
   527 	 */
       
   528 	virtual QCString trWrittenBy()
       
   529 	{
       
   530 	  return Decode(" -- autor ");
       
   531 	}
       
   532 
       
   533 	/*! this text is put before a class diagram */
       
   534 	virtual QCString trClassDiagram(const char *clName)
       
   535 	{
       
   536 	  return Decode((QCString)"Diagram dedičnosti pre triedu "+clName);
       
   537 	}
       
   538 
       
   539 	/*! this text is generated when the \\internal command is used. */
       
   540 	virtual QCString trForInternalUseOnly()
       
   541 	{ return Decode("Iba pre interné použitie."); }
       
   542 
       
   543 	/*! this text is generated when the \\reimp command is used. */
       
   544 	virtual QCString trReimplementedForInternalReasons()
       
   545 	{ return Decode("Reimplementované z interných dôvodov; "
       
   546 					"aplikačné rozhranie zachované."); }
       
   547 
       
   548 	/*! this text is generated when the \\warning command is used. */
       
   549 	virtual QCString trWarning()
       
   550 	{ return Decode("Pozor"); }
       
   551 
       
   552 	/*! this text is generated when the \\bug command is used. */
       
   553 	virtual QCString trBugsAndLimitations()
       
   554 	{ return Decode("Chyby a obmedzenia"); }
       
   555 
       
   556 	/*! this text is generated when the \\version command is used. */
       
   557 	virtual QCString trVersion()
       
   558 	{ return Decode("Verzia"); }
       
   559 
       
   560 	/*! this text is generated when the \\date command is used. */
       
   561 	virtual QCString trDate()
       
   562 	{ return Decode("Dátum"); }
       
   563 
       
   564 	/*! this text is generated when the \\return command is used. */
       
   565 	virtual QCString trReturns()
       
   566 	{ return Decode("Návratová hodnota"); }
       
   567 
       
   568 	/*! this text is generated when the \\sa command is used. */
       
   569 	virtual QCString trSeeAlso()
       
   570 	{ return Decode("Viz tiež"); }
       
   571 
       
   572 	/*! this text is generated when the \\param command is used. */
       
   573 	virtual QCString trParameters()
       
   574 	{ return Decode("Parametre"); }
       
   575 
       
   576 	/*! this text is generated when the \\exception command is used. */
       
   577 	virtual QCString trExceptions()
       
   578 	{ return Decode("Výnimky"); }
       
   579 
       
   580 	/*! this text is used in the title page of a LaTeX document. */
       
   581 	virtual QCString trGeneratedBy()
       
   582 	{ return Decode("Generované programom"); }
       
   583 
       
   584 	// new since 0.49-990307
       
   585 
       
   586 	/*! used as the title of page containing all the index of all namespaces. */
       
   587 	virtual QCString trNamespaceList()
       
   588 	{ return Decode("Zoznam priestorov mien"); }
       
   589 
       
   590 	/*! used as an introduction to the namespace list */
       
   591 	virtual QCString trNamespaceListDescription(bool extractAll)
       
   592 	{
       
   593 	  QCString result="Tu nájdete zoznam všetkých ";
       
   594 	  if (!extractAll) result+="dokumentovaných ";
       
   595 	  result+="priestorov mien so stručným popisom:";
       
   596 	  return Decode(result);
       
   597 	}
       
   598 
       
   599 	/*! used in the class documentation as a header before the list of all
       
   600 	 *	friends of a class
       
   601 	 */
       
   602 	virtual QCString trFriends()
       
   603 	{ return Decode("Priatelia (friends)"); }
       
   604 
       
   605 //////////////////////////////////////////////////////////////////////////
       
   606 // new since 0.49-990405
       
   607 //////////////////////////////////////////////////////////////////////////
       
   608 
       
   609 	/*! used in the class documentation as a header before the list of all
       
   610 	 * related classes
       
   611 	 */
       
   612 	virtual QCString trRelatedFunctionDocumentation()
       
   613 	{ return Decode("Dokumentácia k priateľom (friends)"); }
       
   614 
       
   615 //////////////////////////////////////////////////////////////////////////
       
   616 // new since 0.49-990425
       
   617 //////////////////////////////////////////////////////////////////////////
       
   618 
       
   619 	/*! used as the title of the HTML page of a class/struct/union */
       
   620 	virtual QCString trCompoundReference(const char *clName,
       
   621 									ClassDef::CompoundType compType,
       
   622 									bool isTemplate)
       
   623 	{
       
   624 	  QCString result("Dokumentácia ");
       
   625 	  if (isTemplate) result+="šablóny ";
       
   626 	  switch(compType)
       
   627 	  {
       
   628 		case ClassDef::Class:	   result+="triedy "; break;
       
   629 		case ClassDef::Struct:	   result+="štruktúry "; break;
       
   630 		case ClassDef::Union:	   result+="unionu "; break;
       
   631 		case ClassDef::Interface:  result+="rozhrania "; break;
       
   632 		case ClassDef::Protocol:   result+="protocol "; break; // translate me!
       
   633 		case ClassDef::Category:   result+="category "; break; // translate me!
       
   634 		case ClassDef::Exception:  result+="výnimky "; break;
       
   635 	  }
       
   636 	  result+=clName;
       
   637 	  return Decode(result);
       
   638 	}
       
   639 
       
   640 	/*! used as the title of the HTML page of a file */
       
   641 	virtual QCString trFileReference(const char *fileName)
       
   642 	{
       
   643 	  QCString result("Dokumentácia súboru ");
       
   644 	  result+=fileName;
       
   645 	  return Decode(result);
       
   646 	}
       
   647 
       
   648 	/*! used as the title of the HTML page of a namespace */
       
   649 	virtual QCString trNamespaceReference(const char *namespaceName)
       
   650 	{
       
   651 	  QCString result("Dokumentácia priestoru mien ");
       
   652 	  result+=namespaceName;
       
   653 	  return Decode(result);
       
   654 	}
       
   655 
       
   656 	/* these are for the member sections of a class, struct or union */
       
   657 	virtual QCString trPublicMembers()
       
   658 	{ return Decode("Verejné metódy"); }
       
   659 	virtual QCString trPublicSlots()
       
   660 	{ return Decode("Verejné sloty"); }
       
   661 	virtual QCString trSignals()
       
   662 	{ return Decode("Signály"); }
       
   663 	virtual QCString trStaticPublicMembers()
       
   664 	{ return Decode("Statické verejné metódy"); }
       
   665 	virtual QCString trProtectedMembers()
       
   666 	{ return Decode("Chránené metódy"); }
       
   667 	virtual QCString trProtectedSlots()
       
   668 	{ return Decode("Chránené sloty"); }
       
   669 	virtual QCString trStaticProtectedMembers()
       
   670 	{ return Decode("Statické chránené metódy"); }
       
   671 	virtual QCString trPrivateMembers()
       
   672 	{ return Decode("Privátne metódy"); }
       
   673 	virtual QCString trPrivateSlots()
       
   674 	{ return Decode("Privátne sloty"); }
       
   675 	virtual QCString trStaticPrivateMembers()
       
   676 	{ return Decode("Statické privátne metódy"); }
       
   677 
       
   678 	/*! this function is used to produce a comma-separated list of items.
       
   679 	 *	use generateMarker(i) to indicate where item i should be put.
       
   680 	 */
       
   681 	virtual QCString trWriteList(int numEntries)
       
   682 	{
       
   683 	  QCString result;
       
   684 	  int i;
       
   685 	  // the inherits list contain `numEntries' classes
       
   686 	  for (i=0;i<numEntries;i++)
       
   687 	  {
       
   688 		// use generateMarker to generate placeholders for the class links!
       
   689 		result+=generateMarker(i); // generate marker for entry i in the list
       
   690 								   // (order is left to right)
       
   691 
       
   692 		if (i!=numEntries-1)  // not the last entry, so we need a separator
       
   693 		{
       
   694 		  if (i<numEntries-2) // not the fore last entry
       
   695 			result+=", ";
       
   696 		  else				  // the fore last entry
       
   697 			result+=" a ";
       
   698 		}
       
   699 	  }
       
   700 	  return Decode(result);
       
   701 	}
       
   702 
       
   703 	/*! used in class documentation to produce a list of base classes,
       
   704 	 *	if class diagrams are disabled.
       
   705 	 */
       
   706 	virtual QCString trInheritsList(int numEntries)
       
   707 	{
       
   708 	  QCString result("Dedí od ");
       
   709 	  result += (numEntries == 1) ? "bázovej triedy " : "bázových tried ";
       
   710 	  result += trWriteList(numEntries)+".";
       
   711 	  return Decode(result);
       
   712 	}
       
   713 
       
   714 	/*! used in class documentation to produce a list of super classes,
       
   715 	 *	if class diagrams are disabled.
       
   716 	 */
       
   717 	virtual QCString trInheritedByList(int numEntries)
       
   718 	{
       
   719 	  QCString result("Zdedená ");
       
   720 	  result += (numEntries == 1) ? "triedou " : "triedami ";
       
   721 	  result += trWriteList(numEntries)+".";
       
   722 	  return Decode(result);
       
   723 	}
       
   724 
       
   725 	/*! used in member documentation blocks to produce a list of
       
   726 	 *	members that are hidden by this one.
       
   727 	 */
       
   728 	virtual QCString trReimplementedFromList(int numEntries)
       
   729 	{
       
   730 	  QCString result("Reimplementuje ");
       
   731 	  result += (numEntries == 1) ? "metódu triedy " : "metódy tried ";
       
   732 	  result += trWriteList(numEntries)+".";
       
   733 	  return Decode(result);
       
   734 	}
       
   735 
       
   736 	/*! used in member documentation blocks to produce a list of
       
   737 	 *	all member that overwrite the implementation of this member.
       
   738 	 */
       
   739 	virtual QCString trReimplementedInList(int numEntries)
       
   740 	{
       
   741 	  QCString result("Reimplementované ");
       
   742 	  result += (numEntries == 1) ? "triedou " : "triedami ";
       
   743 	  result += trWriteList(numEntries)+".";
       
   744 	  return Decode(result);
       
   745 	}
       
   746 
       
   747 	/*! This is put above each page as a link to all members of namespaces. */
       
   748 	virtual QCString trNamespaceMembers()
       
   749 	{ return Decode("Symboly v priestoroch mien"); }
       
   750 
       
   751 	/*! This is an introduction to the page with all namespace members */
       
   752 	virtual QCString trNamespaceMemberDescription(bool extractAll)
       
   753 	{
       
   754 	  QCString result="Tu nájdete zoznam všetkých ";
       
   755 	  if (!extractAll) result+="dokumentovaných ";
       
   756 	  result+="symbolov, ktoré sú definované vo svojich priestoroch mien. "
       
   757 			  "U každého je uvedený odkaz na ";
       
   758 	  if (extractAll)
       
   759 		result+="dokumentáciu príslušného priestoru mien:";
       
   760 	  else
       
   761 		result+="príslušný priestor mien:";
       
   762 	  return Decode(result);
       
   763 	}
       
   764 	/*! This is used in LaTeX as the title of the chapter with the
       
   765 	 *	index of all namespaces.
       
   766 	 */
       
   767 	virtual QCString trNamespaceIndex()
       
   768 	{ return Decode("Register priestorov mien"); }
       
   769 
       
   770 	/*! This is used in LaTeX as the title of the chapter containing
       
   771 	 *	the documentation of all namespaces.
       
   772 	 */
       
   773 	virtual QCString trNamespaceDocumentation()
       
   774 	{ return Decode("Dokumentácia priestorov mien"); }
       
   775 
       
   776 //////////////////////////////////////////////////////////////////////////
       
   777 // new since 0.49-990522
       
   778 //////////////////////////////////////////////////////////////////////////
       
   779 
       
   780 	/*! This is used in the documentation before the list of all
       
   781 	 *	namespaces in a file.
       
   782 	 */
       
   783 	virtual QCString trNamespaces()
       
   784 	{ return Decode("Priestory mien"); }
       
   785 
       
   786 //////////////////////////////////////////////////////////////////////////
       
   787 // new since 0.49-990728
       
   788 //////////////////////////////////////////////////////////////////////////
       
   789 
       
   790 	/*! This is put at the bottom of a class documentation page and is
       
   791 	 *	followed by a list of files that were used to generate the page.
       
   792 	 */
       
   793 	virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
       
   794 		bool single)
       
   795 	{ // here s is one of " Class", " Struct" or " Union"
       
   796 	  // single is true implies a single file
       
   797 	  QCString result=(QCString)"Dokumentácia pre ";
       
   798 	  switch(compType)
       
   799 	  {
       
   800 		case ClassDef::Class:	   result+="túto triedu"; break;
       
   801 		case ClassDef::Struct:	   result+="túto štruktúru (struct)"; break;
       
   802 		case ClassDef::Union:	   result+="tento union"; break;
       
   803 		case ClassDef::Interface:  result+="toto rozhranie"; break;
       
   804 		case ClassDef::Protocol:   result+="protocol"; break; // translate me!
       
   805 		case ClassDef::Category:   result+="category"; break; // translate me!
       
   806 		case ClassDef::Exception:  result+="túto výnimku"; break;
       
   807 	  }
       
   808 	  result+=" bola generovaná z ";
       
   809 	  if (single) result+="nasledujúceho súboru:";
       
   810 	  else		  result+="nasledujúcich súborov:";
       
   811 	  return Decode(result);
       
   812 	}
       
   813 
       
   814 	/*! This is in the (quick) index as a link to the alphabetical compound
       
   815 	 * list.
       
   816 	 */
       
   817 	virtual QCString trAlphabeticalList()
       
   818 	{ return Decode("Register tried"); }
       
   819 
       
   820 //////////////////////////////////////////////////////////////////////////
       
   821 // new since 0.49-990901
       
   822 //////////////////////////////////////////////////////////////////////////
       
   823 
       
   824 	/*! This is used as the heading text for the retval command. */
       
   825 	virtual QCString trReturnValues()
       
   826 	{ return Decode("Návratové hodnoty"); }
       
   827 
       
   828 	/*! This is in the (quick) index as a link to the main page (index.html)
       
   829 	 */
       
   830 	virtual QCString trMainPage()
       
   831 	{ return Decode("Hlavná stránka"); }
       
   832 
       
   833 	/*! This is used in references to page that are put in the LaTeX
       
   834 	 *	documentation. It should be an abbreviation of the word page.
       
   835 	 */
       
   836 	virtual QCString trPageAbbreviation()
       
   837 	{ return Decode("s."); }
       
   838 
       
   839 //////////////////////////////////////////////////////////////////////////
       
   840 // new since 0.49-991003
       
   841 //////////////////////////////////////////////////////////////////////////
       
   842 
       
   843 	virtual QCString trSources()
       
   844 	{
       
   845 	  return Decode("Zdroje");
       
   846 	}
       
   847 	virtual QCString trDefinedAtLineInSourceFile()
       
   848 	{
       
   849 	  return Decode("Definícia je uvedená na riadku @0 v súbore @1.");
       
   850 	}
       
   851 	virtual QCString trDefinedInSourceFile()
       
   852 	{
       
   853 	  return Decode("Definícia v súbore @0.");
       
   854 	}
       
   855 
       
   856 //////////////////////////////////////////////////////////////////////////
       
   857 // new since 0.49-991205
       
   858 //////////////////////////////////////////////////////////////////////////
       
   859 
       
   860 	virtual QCString trDeprecated()
       
   861 	{
       
   862 	  return Decode("Zastaralé");
       
   863 	}
       
   864 
       
   865 //////////////////////////////////////////////////////////////////////////
       
   866 // new since 1.0.0
       
   867 //////////////////////////////////////////////////////////////////////////
       
   868 
       
   869 	/*! this text is put before a collaboration diagram */
       
   870 	virtual QCString trCollaborationDiagram(const char *clName)
       
   871 	{
       
   872 	  return Decode((QCString)"Diagram tried pre "+clName+":");
       
   873 	}
       
   874 	/*! this text is put before an include dependency graph */
       
   875 	virtual QCString trInclDepGraph(const char *fName)
       
   876 	{
       
   877 	  return Decode((QCString)"Graf závislostí na vkladaných súboroch "
       
   878 					"pre "+fName+":");
       
   879 	}
       
   880 	/*! header that is put before the list of constructor/destructors. */
       
   881 	virtual QCString trConstructorDocumentation()
       
   882 	{
       
   883 	  return Decode("Dokumentácia konštruktoru a deštruktoru");
       
   884 	}
       
   885 	/*! Used in the file documentation to point to the corresponding sources. */
       
   886 	virtual QCString trGotoSourceCode()
       
   887 	{
       
   888 	  return Decode("Zobraziť zdrojový text tohoto súboru.");
       
   889 	}
       
   890 	/*! Used in the file sources to point to the corresponding documentation. */
       
   891 	virtual QCString trGotoDocumentation()
       
   892 	{
       
   893 	  return Decode("Zobraziť dokumentáciu tohoto súboru.");
       
   894 	}
       
   895 	/*! Text for the \\pre command */
       
   896 	virtual QCString trPrecondition()
       
   897 	{
       
   898 	  return Decode("Prepodmienka");
       
   899 	}
       
   900 	/*! Text for the \\post command */
       
   901 	virtual QCString trPostcondition()
       
   902 	{
       
   903 	  return Decode("Postpodmienka");
       
   904 	}
       
   905 	/*! Text for the \\invariant command */
       
   906 	virtual QCString trInvariant()
       
   907 	{
       
   908 	  return Decode("Invariant");
       
   909 	}
       
   910 	/*! Text shown before a multi-line variable/enum initialization */
       
   911 	virtual QCString trInitialValue()
       
   912 	{
       
   913 	  return Decode("Inicializátor:");
       
   914 	}
       
   915 	/*! Text used the source code in the file index */
       
   916 	virtual QCString trCode()
       
   917 	{
       
   918 	  return Decode("zdrojový text");
       
   919 	}
       
   920 	virtual QCString trGraphicalHierarchy()
       
   921 	{
       
   922 	  return Decode("Grafické zobrazenie hierarchie tried");
       
   923 	}
       
   924 	virtual QCString trGotoGraphicalHierarchy()
       
   925 	{
       
   926 	  return Decode("Zobraziť grafickú podobu hierarchie tried");
       
   927 	}
       
   928 	virtual QCString trGotoTextualHierarchy()
       
   929 	{
       
   930 	  return Decode("Zobraziť textovú podobu hierarchie tried");
       
   931 	}
       
   932 	virtual QCString trPageIndex()
       
   933 	{
       
   934 	  return Decode("Register stránok");
       
   935 	}
       
   936 
       
   937 //////////////////////////////////////////////////////////////////////////
       
   938 // new since 1.1.0
       
   939 //////////////////////////////////////////////////////////////////////////
       
   940 
       
   941 	virtual QCString trNote()
       
   942 	{
       
   943 	  return Decode("Poznámka");
       
   944 	}
       
   945 	virtual QCString trPublicTypes()
       
   946 	{
       
   947 	  return Decode("Verejné typy");
       
   948 	}
       
   949 	virtual QCString trPublicAttribs()
       
   950 	{
       
   951 	  if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   952 	  {
       
   953 		return Decode("Dátové položky");
       
   954 	  }
       
   955 	  else
       
   956 	  {
       
   957 		return Decode("Verejné atribúty");
       
   958 	  }
       
   959 	}
       
   960 	virtual QCString trStaticPublicAttribs()
       
   961 	{
       
   962 	  return Decode("Statické verejné atribúty");
       
   963 	}
       
   964 	virtual QCString trProtectedTypes()
       
   965 	{
       
   966 	  return Decode("Chránené typy");
       
   967 	}
       
   968 	virtual QCString trProtectedAttribs()
       
   969 	{
       
   970 	  return Decode("Chránené atribúty");
       
   971 	}
       
   972 	virtual QCString trStaticProtectedAttribs()
       
   973 	{
       
   974 	  return Decode("Statické chránené atribúty");
       
   975 	}
       
   976 	virtual QCString trPrivateTypes()
       
   977 	{
       
   978 	  return Decode("Privátne typy");
       
   979 	}
       
   980 	virtual QCString trPrivateAttribs()
       
   981 	{
       
   982 	  return Decode("Privátne atribúty");
       
   983 	}
       
   984 	virtual QCString trStaticPrivateAttribs()
       
   985 	{
       
   986 	  return Decode("Statické privátne atribúty");
       
   987 	}
       
   988 
       
   989 //////////////////////////////////////////////////////////////////////////
       
   990 // new since 1.1.3
       
   991 //////////////////////////////////////////////////////////////////////////
       
   992 
       
   993 	/*! Used as a marker that is put before a todo item */
       
   994 	virtual QCString trTodo()
       
   995 	{
       
   996 	  return Decode("Plánované úpravy");
       
   997 	}
       
   998 	/*! Used as the header of the todo list */
       
   999 	virtual QCString trTodoList()
       
  1000 	{
       
  1001 	  return Decode("Zoznam plánovaných úprav");
       
  1002 	}
       
  1003 
       
  1004 //////////////////////////////////////////////////////////////////////////
       
  1005 // new since 1.1.4
       
  1006 //////////////////////////////////////////////////////////////////////////
       
  1007 
       
  1008 	virtual QCString trReferencedBy()
       
  1009 	{
       
  1010 	  return Decode("Používa sa v");
       
  1011 	}
       
  1012 	virtual QCString trRemarks()
       
  1013 	{
       
  1014 	  return Decode("Poznámky"); // ??? not checked in a context
       
  1015 	}
       
  1016 	virtual QCString trAttention()
       
  1017 	{
       
  1018 	  return Decode("Upozornenie"); // ??? not checked in a context
       
  1019 	}
       
  1020 	virtual QCString trInclByDepGraph()
       
  1021 	{
       
  1022 	  return Decode("Nasledujúci graf ukazuje, ktoré súbory priamo alebo "
       
  1023 			 "nepriamo vkladajú tento súbor:");
       
  1024 	}
       
  1025 	virtual QCString trSince()
       
  1026 	{
       
  1027 	  return Decode("Od"); // ??? not checked in a context
       
  1028 	}
       
  1029 
       
  1030 ////////////////////////////////////////////////////////////////////////////
       
  1031 // new since 1.1.5
       
  1032 //////////////////////////////////////////////////////////////////////////
       
  1033 
       
  1034 	/*! title of the graph legend page */
       
  1035 	virtual QCString trLegendTitle()
       
  1036 	{
       
  1037 	  return Decode("Vysvetlivky ku grafu");
       
  1038 	}
       
  1039 	/*! page explaining how the dot graph's should be interpreted */
       
  1040 	virtual QCString trLegendDocs()
       
  1041 	{
       
  1042 	  QCString result(
       
  1043 		"Tu nájdete vysvetlenie, ako majú byť interpretované grafy, "
       
  1044 		"ktoré boli generované programom doxygen.<p>\n"
       
  1045 		"Uvažujte nasledujúci príklad:\n"
       
  1046 		"\\code\n"
       
  1047 		"/*! Neviditelná trieda, ktorá sa v grafe nezobrazuje, pretože "
       
  1048 		"došlo k orezaniu grafu. */\n"
       
  1049 		"class Invisible { };\n\n"
       
  1050 		"/*! Trieda, u ktorej došlo k orezaniu grafu. Vzťah dedičnosti "
       
  1051 		"je skrytý. */\n"
       
  1052 		"class Truncated : public Invisible { };\n\n"
       
  1053 		"/* Trieda, ktorá nieje dokumentovaná komentármi programu doxygen. */\n"
       
  1054 		"class Undocumented { };\n\n"
       
  1055 		"/*! Odvodená trieda s verejným (public) dedením bázovej triedy. */\n"
       
  1056 		"class PublicBase : public Truncated { };\n\n"
       
  1057 		"/*! Odvodená trieda s chráneným (protected) dedením bázovej triedy. */\n"
       
  1058 		"/*! A template class */\n"
       
  1059 		"template<class T> class Templ { };\n\n"
       
  1060 		"class ProtectedBase { };\n\n"
       
  1061 		"/*! Odvodená trieda s privátnym dedením bázovej triedy. */\n"
       
  1062 		"class PrivateBase { };\n\n"
       
  1063 		"/*! Trieda, ktorá je využívaná triedou Inherited. */\n"
       
  1064 		"class Used { };\n\n"
       
  1065 		"/*! Odvodená trieda, ktorá rôznym spôsobom dedí od viacerých bázových "
       
  1066 		"tried. */\n"
       
  1067 		"class Inherited : public PublicBase,\n"
       
  1068 		"                  protected ProtectedBase,\n"
       
  1069 		"                  private PrivateBase,\n"
       
  1070 		"                  public Undocumented,\n"
       
  1071 		"                  public Templ<int>\n"
       
  1072 		"{\n"
       
  1073 		"  private:\n"
       
  1074 		"	 Used *m_usedClass;\n"
       
  1075 		"};\n"
       
  1076 		"\\endcode\n"
       
  1077 		"Pokiaľ je položka \\c MAX_DOT_GRAPH_HEIGHT konfiguračného súboru "
       
  1078 		"nastavená na hodnotu 200, bude vygenerovaný nasledujúci graf:"
       
  1079 		"<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
       
  1080 		"<p>\n"
       
  1081 		"Bloky (tj. uzly) v uvedenom grafe majú nasledujúci význam:\n"
       
  1082 		"<ul>\n"
       
  1083 		"<li>Čierne vyplnený obdĺžnik reprezentuje štruktúru alebo triedu, "
       
  1084 			"pre ktorú bol graf generovaný.\n"
       
  1085 		"<li>Obdĺžnik s čiernym obrysom označuje dokumentovanú "
       
  1086 			"štruktúru alebo triedu.\n"
       
  1087 		"<li>Obdĺžnik so šedým obrysom označuje nedokumentovanú "
       
  1088 			"štruktúru alebo triedu.\n"
       
  1089 		"<li>Obdĺžnik s červeným obrysom označuje dokumentovanú "
       
  1090 			"štruktúru alebo triedu, pre ktorú\n"
       
  1091 			"niesú zobrazené všetky vzťahy dedičnosti alebo obsiahnutia. "
       
  1092 			"Graf je orezaný v prípade, kedy ho\n"
       
  1093 			"nieje možné umiestniť do vymedzených hraníc.\n"
       
  1094 		"</ul>\n"
       
  1095 		"Šípky (tj. hrany grafu) majú nasledujúcí význam:\n"
       
  1096 		"<ul>\n"
       
  1097 		"<li>Tmavo modrá šípka sa používa pre označenie vzťahu verejnej "
       
  1098 			"dedičnosti medzi dvoma triedami.\n"
       
  1099 		"<li>Tmavo zelená šípka označuje vzťah chránenej dedičnosti "
       
  1100 			"(protected).\n"
       
  1101 		"<li>Tmavo červená šípka označuje vzťah privátnej dedičnosti.\n"
       
  1102 		"<li>Purpurová šípka kreslená čiarkovane sa používa v prípade, "
       
  1103 			"ak je trieda obsiahnutá v inej triede,\n"
       
  1104 			"alebo ak je používaná inou triedou. Je označená identifikátorom "
       
  1105 			"jednej alebo viacerých premenných (objektov), cez ktoré\n"
       
  1106 			"je trieda alebo štruktúra zprístupnena.\n"
       
  1107 		"</ul>\n");
       
  1108 
       
  1109 		return Decode(result);
       
  1110 	}
       
  1111 	/*! text for the link to the legend page */
       
  1112 	virtual QCString trLegend()
       
  1113 	{
       
  1114 	  return Decode("vysvetlivky");
       
  1115 	}
       
  1116 
       
  1117 //////////////////////////////////////////////////////////////////////////
       
  1118 // new since 1.2.0
       
  1119 //////////////////////////////////////////////////////////////////////////
       
  1120 
       
  1121 	/*! Used as a marker that is put before a test item */
       
  1122 	virtual QCString trTest()
       
  1123 	{
       
  1124 	  return Decode("Test");
       
  1125 	}
       
  1126 
       
  1127 	/*! Used as the header of the test list */
       
  1128 	virtual QCString trTestList()
       
  1129 	{
       
  1130 	  return Decode("Zoznam testov");
       
  1131 	}
       
  1132 
       
  1133 //////////////////////////////////////////////////////////////////////////
       
  1134 // new since 1.2.1
       
  1135 //////////////////////////////////////////////////////////////////////////
       
  1136 
       
  1137 	/*! Used as a section header for KDE-2 IDL methods */
       
  1138 	virtual QCString trDCOPMethods()
       
  1139 	{
       
  1140 	  return Decode("Metódy DCOP");
       
  1141 	}
       
  1142 
       
  1143 //////////////////////////////////////////////////////////////////////////
       
  1144 // new since 1.2.2
       
  1145 //////////////////////////////////////////////////////////////////////////
       
  1146 
       
  1147 	/*! Used as a section header for IDL properties */
       
  1148 	virtual QCString trProperties()
       
  1149 	{
       
  1150 	  return Decode("Vlastnosti");
       
  1151 	}
       
  1152 	/*! Used as a section header for IDL property documentation */
       
  1153 	virtual QCString trPropertyDocumentation()
       
  1154 	{
       
  1155 	  return Decode("Dokumentácia k vlastnosti");
       
  1156 	}
       
  1157 //////////////////////////////////////////////////////////////////////////
       
  1158 // new since 1.2.4
       
  1159 //////////////////////////////////////////////////////////////////////////
       
  1160 
       
  1161 	/*! Used for Java interfaces in the summary section of Java packages */
       
  1162 	virtual QCString trInterfaces()
       
  1163 	{
       
  1164 	  return Decode("Rozhranie");
       
  1165 	}
       
  1166 	/*! Used for Java classes in the summary section of Java packages */
       
  1167 	virtual QCString trClasses()
       
  1168 	{
       
  1169 	  return Decode("Triedy");
       
  1170 	}
       
  1171 	/*! Used as the title of a Java package */
       
  1172 	virtual QCString trPackage(const char *name)
       
  1173 	{
       
  1174 	  return Decode((QCString)"Balík "+name);
       
  1175 	}
       
  1176 	/*! Title of the package index page */
       
  1177 	virtual QCString trPackageList()
       
  1178 	{
       
  1179 	  return Decode("Zoznam balíkov");
       
  1180 	}
       
  1181 	/*! The description of the package index page */
       
  1182 	virtual QCString trPackageListDescription()
       
  1183 	{
       
  1184 	  return Decode("Tu nájdete zoznam balíkov so stručným popisom "
       
  1185 					"(pokiaľ bol uvedený):");
       
  1186 	}
       
  1187 	/*! The link name in the Quick links header for each page */
       
  1188 	virtual QCString trPackages()
       
  1189 	{
       
  1190 	  return Decode("Balíky");
       
  1191 	}
       
  1192 	/*! Used as a chapter title for Latex & RTF output */
       
  1193 	virtual QCString trPackageDocumentation()
       
  1194 	{
       
  1195 	  return Decode("Dokumentácia balíku");
       
  1196 	}
       
  1197 	/*! Text shown before a multi-line define */
       
  1198 	virtual QCString trDefineValue()
       
  1199 	{
       
  1200 	  return Decode("Hodnota:");
       
  1201 	}
       
  1202 
       
  1203 //////////////////////////////////////////////////////////////////////////
       
  1204 // new since 1.2.5
       
  1205 //////////////////////////////////////////////////////////////////////////
       
  1206 
       
  1207 	/*! Used as a marker that is put before a \\bug item */
       
  1208 	virtual QCString trBug()
       
  1209 	{
       
  1210 	  return Decode("Chyba");
       
  1211 	}
       
  1212 	/*! Used as the header of the bug list */
       
  1213 	virtual QCString trBugList()
       
  1214 	{
       
  1215 	  return Decode("Zoznam chýb");
       
  1216 	}
       
  1217 
       
  1218 //////////////////////////////////////////////////////////////////////////
       
  1219 // new since 1.2.6-20010422
       
  1220 //////////////////////////////////////////////////////////////////////////
       
  1221 
       
  1222 	/*! Used as ansicpg for RTF file */
       
  1223 	virtual QCString trRTFansicp()
       
  1224 	{
       
  1225 	  return "1250";
       
  1226 	}
       
  1227 
       
  1228 	/*! Used as ansicpg for RTF fcharset */
       
  1229 	virtual QCString trRTFCharSet()
       
  1230 	{
       
  1231 	  return "3";
       
  1232 	}
       
  1233 
       
  1234 	/*! Used as header RTF general index */
       
  1235 	virtual QCString trRTFGeneralIndex()
       
  1236 	{
       
  1237 	  return "Index";
       
  1238 	}
       
  1239 
       
  1240 	/*! This is used for translation of the word that will possibly
       
  1241 	 *	be followed by a single name or by a list of names
       
  1242 	 *	of the category.
       
  1243 	 */
       
  1244 	virtual QCString trClass(bool first_capital, bool singular)
       
  1245 	{
       
  1246 	  QCString result((first_capital ? "Tried" : "tried"));
       
  1247 	  result+=(singular ? "a" : "y");
       
  1248 	  return Decode(result);
       
  1249 	}
       
  1250 
       
  1251 	/*! This is used for translation of the word that will possibly
       
  1252 	 *	be followed by a single name or by a list of names
       
  1253 	 *	of the category.
       
  1254 	 */
       
  1255 	virtual QCString trFile(bool first_capital, bool singular)
       
  1256 	{
       
  1257 	  QCString result((first_capital ? "Súbor" : "súbor"));
       
  1258 	  if (!singular)  result+="y";
       
  1259 	  return Decode(result);
       
  1260 	}
       
  1261 
       
  1262 	/*! This is used for translation of the word that will possibly
       
  1263 	 *	be followed by a single name or by a list of names
       
  1264 	 *	of the category.
       
  1265 	 */
       
  1266 	virtual QCString trNamespace(bool first_capital, bool singular)
       
  1267 	{
       
  1268 	  QCString result((first_capital ? "Priestor" : "priestor"));
       
  1269 	  if (!singular)  result+="y";
       
  1270 	  result+=" mien";
       
  1271 	  return Decode(result);
       
  1272 	}
       
  1273 
       
  1274 	/*! This is used for translation of the word that will possibly
       
  1275 	 *	be followed by a single name or by a list of names
       
  1276 	 *	of the category.
       
  1277 	 */
       
  1278 	virtual QCString trGroup(bool first_capital, bool singular)
       
  1279 	{
       
  1280 	  QCString result((first_capital ? "Skupin" : "skupin"));
       
  1281 	  result+=(singular ? "a" : "y");
       
  1282 	  return Decode(result);
       
  1283 	}
       
  1284 
       
  1285 	/*! This is used for translation of the word that will possibly
       
  1286 	 *	be followed by a single name or by a list of names
       
  1287 	 *	of the category.
       
  1288 	 */
       
  1289 	virtual QCString trPage(bool first_capital, bool singular)
       
  1290 	{
       
  1291 	  QCString result((first_capital ? "Stránk" : "stránk"));
       
  1292 	  result+=(singular ? "a" : "y");
       
  1293 	  return Decode(result);
       
  1294 	}
       
  1295 
       
  1296 	/*! This is used for translation of the word that will possibly
       
  1297 	 *	be followed by a single name or by a list of names
       
  1298 	 *	of the category.
       
  1299 	 */
       
  1300 	virtual QCString trMember(bool first_capital, bool singular)
       
  1301 	{
       
  1302 	  QCString result((first_capital ? "Člen" : "člen"));
       
  1303 	  if (!singular)  result+="y";
       
  1304 	  return Decode(result);
       
  1305 	}
       
  1306 
       
  1307 	/*! This is used for translation of the word that will possibly
       
  1308 	 *	be followed by a single name or by a list of names
       
  1309 	 *	of the category.
       
  1310 	 */
       
  1311 	virtual QCString trField(bool first_capital, bool singular)
       
  1312 	{
       
  1313 	  QCString result((first_capital ? "Položk" : "položk"));
       
  1314 	  result+=(singular ? "a" : "y");
       
  1315 	  return Decode(result);
       
  1316 	}
       
  1317 
       
  1318 	/*! This is used for translation of the word that will possibly
       
  1319 	 *	be followed by a single name or by a list of names
       
  1320 	 *	of the category.
       
  1321 	 */
       
  1322 	virtual QCString trGlobal(bool first_capital, bool singular)
       
  1323 	{
       
  1324 	  QCString result((first_capital ? "Globáln" : "globáln"));
       
  1325 	  result+=(singular ? "y" : "e");
       
  1326 	  return result;
       
  1327 	}
       
  1328 
       
  1329 //////////////////////////////////////////////////////////////////////////
       
  1330 // new since 1.2.7
       
  1331 //////////////////////////////////////////////////////////////////////////
       
  1332 
       
  1333 	/*! This text is generated when the \\author command is used and
       
  1334 	 *	for the author section in man pages. */
       
  1335 	virtual QCString trAuthor(bool first_capital, bool singular)
       
  1336 	{
       
  1337 	  QCString result((first_capital ? "Auto" : "auto"));
       
  1338 	  result += (singular) ? "r" : "ri";
       
  1339 	  return result;
       
  1340 	}
       
  1341 
       
  1342 //////////////////////////////////////////////////////////////////////////
       
  1343 // new since 1.2.11
       
  1344 //////////////////////////////////////////////////////////////////////////
       
  1345 
       
  1346 	/*! This text is put before the list of members referenced by a member
       
  1347 	 */
       
  1348 	virtual QCString trReferences()
       
  1349 	{
       
  1350 	  return Decode("Odkazuje sa na");
       
  1351 	}
       
  1352 
       
  1353 //////////////////////////////////////////////////////////////////////////
       
  1354 // new since 1.2.13
       
  1355 //////////////////////////////////////////////////////////////////////////
       
  1356 
       
  1357 	/*! used in member documentation blocks to produce a list of
       
  1358 	 *	members that are implemented by this one.
       
  1359 	 */
       
  1360 	virtual QCString trImplementedFromList(int numEntries)
       
  1361 	{
       
  1362 	  return "Implementuje " + trWriteList(numEntries) + ".";
       
  1363 	}
       
  1364 
       
  1365 	/*! used in member documentation blocks to produce a list of
       
  1366 	 *	all members that implement this member.
       
  1367 	 */
       
  1368 	virtual QCString trImplementedInList(int numEntries)
       
  1369 	{
       
  1370 	  return Decode("Implementované v " + trWriteList(numEntries) + ".");
       
  1371 	}
       
  1372 
       
  1373 //////////////////////////////////////////////////////////////////////////
       
  1374 // new since 1.2.16
       
  1375 //////////////////////////////////////////////////////////////////////////
       
  1376 
       
  1377 	/*! used in RTF documentation as a heading for the Table
       
  1378 	 *	of Contents.
       
  1379 	 */
       
  1380 	virtual QCString trRTFTableOfContents()
       
  1381 	{
       
  1382 	  return "Obsah";
       
  1383 	}
       
  1384 
       
  1385 //////////////////////////////////////////////////////////////////////////
       
  1386 // new since 1.2.17
       
  1387 //////////////////////////////////////////////////////////////////////////
       
  1388 
       
  1389 	/*! Used as the header of the list of item that have been
       
  1390 	 *	flagged deprecated
       
  1391 	 */
       
  1392 	virtual QCString trDeprecatedList()
       
  1393 	{
       
  1394 	  return "Zastarané metódy";
       
  1395 	}
       
  1396 };
       
  1397 
       
  1398 #endif // TRANSLATOR_SK_H