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 // translation by Matjaz Ostroversnik <matjaz.ostroversnik@zrs-tk.si>

    19 

    20 #ifndef TRANSLATOR_SI_H

    21 #define TRANSLATOR_SI_H

    22 

    23 

    24 class TranslatorSlovene : public TranslatorAdapter_1_4_6

    25 //public TranslatorAdapter_1_2_16

    26 {

    27   protected:

    28     friend class TranslatorAdapterBase;

    29     virtual ~TranslatorSlovene() {}

    30   public:

    31     QCString idLanguage()

    32     { return "slovene"; }

    33     /*! Used to get the command(s) for the language support. This method

    34      *  was designed for languages which do not prefer babel package.

    35      *  If this methods returns empty string, then the latexBabelPackage()

    36      *  method is used to generate the command for using the babel package.

    37      */

    38     QCString latexLanguageSupportCommand()

    39     {

    40       return "\\usepackage[slovene]{babel}\n\\usepackage[T1]{fontenc}\n";

    41     }

    42     QCString idLanguageCharset()

    43     { 

    44 //#ifdef _WIN32

    45       return "windows-1250"; 

    46 //#else

    47 //      return "iso-8859-2"; 

    48 //#endif

    49     }

    50     QCString trRelatedFunctions()

    51     { return "Povezane funkcije"; }

    52     QCString trRelatedSubscript()

    53     { return "(To niso metode.)"; }

    54     QCString trDetailedDescription()

    55     { return "Podroben opis"; }

    56     QCString trMemberTypedefDocumentation()

    57     { return "Opis uporabni¹ko definiranih tipov"; }

    58     QCString trMemberEnumerationDocumentation()

    59     { return "Opis komponent  na¹tevnih tipov"; }

    60 /*     QCString trEnumerationValueDocumentation() */

    61 /*     { return "Opis vrednosti na¹tevnih tipov (enum) "; } */

    62     QCString trMemberFunctionDocumentation()

    63     { return "Opis metod"; }

    64     QCString trMemberDataDocumentation()

    65     { return "Opis atributov"; }

    66     QCString trMore()

    67     { return "..."; }

    68     QCString trListOfAllMembers()

    69     { return "Seznam vseh metod / atributov."; }

    70     QCString trMemberList()

    71     { return " - seznam metod in atributov."; }

    72     QCString trThisIsTheListOfAllMembers()

    73     { return "Seznam metod razreda "; }

    74     QCString trIncludingInheritedMembers()

    75     { return ", vkljuèujoè dedovane metode in atribute."; }

    76     QCString trGeneratedAutomatically(const char *s)

    77     { QCString result="zgenerirano z Doxygen-om"; 

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

    79       result+=" iz izvorne kode."; 

    80       return result;

    81     }

    82     QCString trEnumName()

    83     { return "na¹tevno ime"; }

    84     QCString trEnumValue()

    85     { return "na¹tevna vrednost"; }

    86     QCString trDefinedIn()

    87     { return "definirano v"; }

    88     QCString trModules()

    89     { return "moduli"; }

    90     QCString trClassHierarchy()

    91     { return "dedovalna hierarhija"; }

    92     QCString trCompoundList()

    93     { return "kratek opis razredov"; }

    94     QCString trFileList()

    95     { return "seznam datotek"; }

    96 /*     QCString trHeaderFiles() */

    97 /*     { return "'Header' datoteka"; } */

    98     QCString trCompoundMembers()

    99     { return "metode in atributi"; }

   100     QCString trFileMembers()

   101     { return "komponente v datotekah"; }

   102     QCString trRelatedPages()

   103     { return "dodatni opisi"; }

   104     QCString trExamples()

   105     { return "Primeri"; }

   106     QCString trSearch()

   107     { return "I¹èi"; }

   108     QCString trClassHierarchyDescription()

   109       { return "Hierarhièno drevo je (okvirno) sortirano po abecedi. ";

   110     }

   111     QCString trFileListDescription(bool extractAll)

   112     {

   113       QCString result="Seznam vseh ";

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

   115       result+="datotek s kratkim opisom:";

   116       return result;

   117     }

   118     QCString trCompoundListDescription()

   119     { return "Seznam razredov, mno¾ic in struktur "

   120              "s kratkim opisom :"; 

   121     }

   122     QCString trCompoundMembersDescription(bool extractAll)

   123     {

   124       QCString result="Seznam vseh ";

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

   126       result+="metod in atributov s povezavami na ";

   127       if (extractAll) result+="opis posamezne metode in/ali atributa:";

   128       else result+="opis razreda :";

   129       return result;

   130     }

   131     QCString trFileMembersDescription(bool extractAll)

   132     {

   133       QCString result="Seznam ";

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

   135       result+="entitet v datotekah ";

   136       if (extractAll) result+="skupaj z opisom datoteke v kateri se nahajajo:";

   137       else result+="s povezavami na datoteke v katerih se nahajajo:";

   138       return result;

   139     }

   140 /*     QCString trHeaderFilesDescription() */

   141 /*     { return "Seznam header datotek, ki tvorijo aplikacijski vmesnik (API) :"; } */

   142     QCString trExamplesDescription()

   143     { return "Seznam primerov :"; }

   144     QCString trRelatedPagesDescription()

   145     { return "Seznam strani z dodatnimi opisi:"; }

   146     QCString trModulesDescription()

   147     { return "Seznam modulov:"; }

   148 /*     QCString trNoDescriptionAvailable() */

   149 /*     { return "Opis ni dostopen"; } */

   150 

   151     QCString trDocumentation()

   152     { return "Dokumentacija"; }

   153     QCString trModuleIndex()

   154     { return "seznam modulov"; }

   155     QCString trHierarchicalIndex()

   156     { return "Hierarhièni indeks"; }

   157     QCString trCompoundIndex()

   158     { return "abecedni seznam"; }

   159     QCString trFileIndex() 

   160     { return "seznam datotek"; }

   161     QCString trModuleDocumentation()

   162     { return "Dokumentacija modulov"; }

   163     QCString trClassDocumentation()

   164     { return "Opis razreda"; }

   165     QCString trFileDocumentation()

   166     { return "Opis datoteke"; }

   167     QCString trExampleDocumentation()

   168     { return "Opis primera"; }

   169     QCString trPageDocumentation()

   170     { return "Opis povezanih strani"; }

   171     QCString trReferenceManual()

   172     { return "Priroènik"; }

   173 

   174     QCString trDefines()

   175     { return "Makro deklaracije"; }

   176     QCString trFuncProtos()

   177     { return "Prototipi funkcij"; }

   178     QCString trTypedefs()

   179     { return "Uporabni¹ko definirani tipi"; }

   180     QCString trEnumerations()

   181     { return "Na¹tevni tipi"; }

   182     QCString trFunctions()

   183     { return "Funkcije"; }

   184     QCString trVariables()

   185     { return "Spremenljivke"; }

   186     QCString trEnumerationValues()

   187     { return "Vrednosti na¹tevnih tipov"; }

   188     QCString trDefineDocumentation()

   189     { return "Opis makro definicije"; }

   190     QCString trFunctionPrototypeDocumentation()

   191     { return "Opis prototipa funkcije"; }

   192     QCString trTypedefDocumentation()

   193     { return "Opis uporabni¹ko definiranega tipa"; }

   194     QCString trEnumerationTypeDocumentation()

   195     { return "Opis na¹tevnega (enum) tipa"; }

   196     QCString trFunctionDocumentation()

   197     { return "Opis funkcije"; }

   198     QCString trVariableDocumentation()

   199     { return "Opis spremenljivke"; }

   200     QCString trCompounds()

   201     { return "Strukture"; }

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

   203     { 

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

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

   206       result+=(QCString)" generator: ";

   207       return result;

   208     }

   209     QCString trWrittenBy()

   210     {

   211       return "napisal ";

   212     }

   213     QCString trClassDiagram(const char *clName)

   214     {

   215       return (QCString)"Diagram razredov za "+clName;

   216     }

   217     QCString trForInternalUseOnly()

   218     { return "Samo za interno uporabo."; }

   219 /*     QCString trReimplementedForInternalReasons() */

   220 /*     { return "Ponovno implementirano zaradi internih razlogov. " */

   221 /*              "Nima vpliva na API.";  */

   222 /*     } */

   223     QCString trWarning()

   224     { return "Opozorilo"; }

   225 /*     QCString trBugsAndLimitations() */

   226 /*     { return "Napake in omejtive"; } */

   227     QCString trVersion()

   228     { return "Verzija"; }

   229     QCString trDate()

   230     { return "Datum"; }

   231     QCString trReturns()

   232     { return "Rezultat(i)"; }

   233     QCString trSeeAlso()

   234     { return "Glej"; }

   235     QCString trParameters()

   236     { return "Parametri"; }

   237     QCString trExceptions()

   238     { return "Prekinitve"; }

   239     QCString trGeneratedBy()

   240     { return "Izdelano s pomoèjo"; }

   241     

   242 //////////////////////////////////////////////////////////////////////////

   243 // new since 0.49-990307 

   244 //////////////////////////////////////////////////////////////////////////

   245     

   246     QCString trNamespaceList()

   247     { return "imenski prostori"; }

   248     QCString trNamespaceListDescription(bool extractAll)

   249     {

   250       QCString result="Seznam ";

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

   252       result+="imenskih prostorov z opisom:";

   253       return result;

   254     }

   255     QCString trFriends()

   256     { return "Prijatelji (Friends) "; }

   257 

   258 //////////////////////////////////////////////////////////////////////////

   259 // new since 0.49-990405

   260 //////////////////////////////////////////////////////////////////////////

   261     

   262     QCString trRelatedFunctionDocumentation()

   263     { return "Podatki o poveznih funkcijah"; }

   264     

   265 //////////////////////////////////////////////////////////////////////////

   266 // new since 0.49-990425

   267 //////////////////////////////////////////////////////////////////////////

   268 

   269     QCString trCompoundReference(const char *clName,

   270                                     ClassDef::CompoundType compType,

   271                                     bool /*isTemplate*/)

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

   273     {

   274       QCString result="";

   275       switch(compType)

   276       {

   277         case ClassDef::Class:  result+=" Razred "; break;

   278         case ClassDef::Struct: result+=" Struktura "; break;

   279         case ClassDef::Union:  result+=" Mno¾ica "; break;

   280         case ClassDef::Interface:  result+=" IDL vmesnik "; break;

   281         case ClassDef::Protocol:   result+=" protocol "; break; // translate me!

   282         case ClassDef::Category:   result+=" category "; break; // translate me!

   283         case ClassDef::Exception:  result+=" IDL prekinitev "; break;

   284       }

   285 	  result += (QCString)clName;

   286       

   287       return result;

   288     }

   289     QCString trFileReference(const char *fileName)

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

   291     {

   292       QCString result="Datoteka "; 

   293 	  result+=fileName;

   294 	  return result;

   295     }

   296     QCString trNamespaceReference(const char *namespaceName)

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

   298     {

   299       QCString result ="Imenski prostor ";

   300 	  result+=namespaceName;

   301       

   302       return result;

   303     }

   304     

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

   306     QCString trPublicMembers()

   307     { return "Javne metode"; }

   308     QCString trPublicSlots()

   309     { return "Public slotovi"; }

   310     QCString trSignals()

   311     { return "Programske prekinitve"; }

   312     QCString trStaticPublicMembers()

   313     { return "Statiène javne metode in atributi"; }

   314     QCString trProtectedMembers()

   315     { return "Za¹èitene metode in atributi"; }

   316     QCString trProtectedSlots()

   317     { return "Za¹èiteni sloti"; }

   318     QCString trStaticProtectedMembers()

   319     { return "Statiène za¹èitene metode in atributi"; }

   320     QCString trPrivateMembers()

   321     { return "Skrite metode in atributi"; }

   322     QCString trPrivateSlots()

   323     { return "Skriti slotovi"; }

   324     QCString trStaticPrivateMembers()

   325     { return "Statiène skrite metode in atributi"; }

   326     // end of member sections 

   327     

   328     QCString trWriteList(int numEntries)

   329     {

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

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

   332       QCString result;

   333       int i;

   334       // the inherits list contain `numEntries' classes

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

   336       {

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

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

   339                                    // (order is left to right)

   340         

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

   342         {

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

   344             result+=", ";

   345           else                // the fore last entry

   346             result+=" in ";

   347         }

   348       }

   349       return result; 

   350     }

   351     

   352     QCString trInheritsList(int numEntries)

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

   354       // if class diagrams are disabled.

   355     {

   356       return "Deduje od "+trWriteList(numEntries)+".";

   357     }

   358     QCString trInheritedByList(int numEntries)

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

   360       // if class diagrams are disabled.

   361     {

   362       return "Naslijeðena u "+trWriteList(numEntries)+".";

   363     }

   364     QCString trReimplementedFromList(int numEntries)

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

   366       // members that are hidden by this one.

   367     {

   368       return "Skrije implementacijo iz "+trWriteList(numEntries)+".";

   369     }

   370     QCString trReimplementedInList(int numEntries)

   371     {

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

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

   374       return "Metodo skrijejo implementacije v razredih "+trWriteList(numEntries)+".";

   375     }

   376 

   377     QCString trNamespaceMembers()

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

   379     { return "elementi imenskega prostora"; }

   380     QCString trNamespaceMemberDescription(bool extractAll)

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

   382     { 

   383       QCString result="Seznam vseh ";

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

   385       result+="elementov imenskega prostora s povezavami na ";

   386       if (extractAll) 

   387         result+="opis vsakega elementa:";

   388       else 

   389         result+="imenski prostor, ki mu pripadajo:";

   390       return result;

   391     }

   392     QCString trNamespaceIndex()

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

   394       // index of all namespaces.

   395     { return "Indeks imenskih prostorov"; }

   396     QCString trNamespaceDocumentation()

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

   398       // the documentation of all namespaces.

   399     { return "Podatki o imenskih prostorih"; }

   400 //////////////////////////////////////////////////////////////////////////

   401 // new since 0.49-990522

   402 //////////////////////////////////////////////////////////////////////////

   403 

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

   405      *  namespaces in a file.

   406      */

   407     virtual QCString trNamespaces()

   408     { return "Imenski prostori"; }

   409 

   410 

   411 //////////////////////////////////////////////////////////////////////////

   412 // new since 0.49-990728

   413 //////////////////////////////////////////////////////////////////////////

   414 

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

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

   417      */

   418     QCString trGeneratedFromFiles(ClassDef::CompoundType compType,

   419         bool single)

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

   421       // single is true implies a single file

   422       QCString result=(QCString)"Opis ";

   423       switch(compType)

   424       {

   425         case ClassDef::Class:      result+="razreda"; break;

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

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

   428         case ClassDef::Interface:  result+="vmesnika (interface)"; break;

   429         case ClassDef::Protocol:   result+="protocol"; break; // translate me!

   430         case ClassDef::Category:   result+="category"; break; // translate me!

   431         case ClassDef::Exception:  result+="prekinitve (exception)"; break;

   432       }

   433       result+=" je zgrajen na podlagi naslednj";

   434       if (single) result+="e "; else result+="ih";

   435       result+=" datotek";

   436       if (single) result+="e :"; else result+=" :";

   437       return result;

   438     }

   439 

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

   441      * list.

   442      */

   443     QCString trAlphabeticalList()

   444     { return "abecedni seznam"; }

   445 

   446 //////////////////////////////////////////////////////////////////////////

   447 // new since 0.49-990901

   448 //////////////////////////////////////////////////////////////////////////

   449 

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

   451     QCString trReturnValues()

   452     { return "Povratna vrednost"; }

   453 

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

   455      */

   456     QCString trMainPage()

   457     { return "prva stran"; }

   458 

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

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

   461      */

   462     QCString trPageAbbreviation()

   463     { return "str."; }

   464 

   465 //////////////////////////////////////////////////////////////////////////

   466 // new since 0.49-991106

   467 //////////////////////////////////////////////////////////////////////////

   468 

   469 /*     QCString trSources() */

   470 /*     { */

   471 /*       return "Izvorne datoteke"; */

   472 /*     } */

   473     QCString trDefinedAtLineInSourceFile()

   474     {

   475       return "Definirano v @0 vrstici datoteke @1.";

   476     }

   477     QCString trDefinedInSourceFile()

   478     {

   479       return "Definirano v datoteki @0.";

   480     }

   481 

   482 //////////////////////////////////////////////////////////////////////////

   483 // new since 0.49-991205

   484 //////////////////////////////////////////////////////////////////////////

   485 

   486     QCString trDeprecated()

   487     {

   488       return "Zastarelo";

   489     }

   490 

   491 //////////////////////////////////////////////////////////////////////////

   492 // new since 1.0.0

   493 //////////////////////////////////////////////////////////////////////////

   494 

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

   496     QCString trCollaborationDiagram(const char *clName)

   497     {

   498       return (QCString)"Kolaboracijski diagram razreda "+clName+":";

   499     }

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

   501     QCString trInclDepGraph(const char *fName)

   502     {

   503       return (QCString)"Graf prikazuje seznam datotek, "

   504           "ki jih datoteka \""+fName+"\" "

   505           "direktno ali indirektno vkljuèuje. Pravokotniki ponazarjajo datoteke, pu¹èice "

   506 	  "predstavljajo relacije med njimi. "

   507 	  "Èrn pravokotnik ponazarja datoteko "+fName+". Pu¹èice A->B ponazarjajo "

   508 	  "usmerjeno relacijo \"A vkljuèuje B\"."

   509 ;

   510     }

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

   512     QCString trConstructorDocumentation()

   513     {

   514       return "Opis konstruktorjev in destruktorjev "; 

   515     }

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

   517     QCString trGotoSourceCode()

   518     {

   519       return "izvorna koda";

   520     }

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

   522     QCString trGotoDocumentation()

   523     {

   524       return "dokumenacija tekoèe datoteke.";

   525     }

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

   527     QCString trPrecondition()

   528     {

   529       return "Predpogoji (preconditions)";

   530     }

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

   532     QCString trPostcondition()

   533     {

   534       return "Naknadni pogoji (posconditions)";

   535     }

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

   537     QCString trInvariant()

   538     {

   539       return "Invarianta";

   540     }

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

   542     QCString trInitialValue()

   543     {

   544       return "Zaèetna vrednost / definicija :";

   545     }

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

   547     QCString trCode()

   548     {

   549       return "koda";

   550     }

   551     QCString trGraphicalHierarchy()

   552     {

   553       return "Hierarhija razredov v grafièni obliki";

   554     }

   555     QCString trGotoGraphicalHierarchy()

   556     {

   557       return "Dedovalna hierarhija v grafièni obliki";

   558     }

   559     QCString trGotoTextualHierarchy()

   560     {

   561       return "Dedovalna hierarhija v tekstovni obliki";

   562     }

   563     QCString trPageIndex()

   564     {

   565       return "Indeks strani";

   566     }

   567 

   568 //////////////////////////////////////////////////////////////////////////

   569 // new since 1.1.0

   570 //////////////////////////////////////////////////////////////////////////

   571     

   572     QCString trNote()

   573     {

   574       return "Opomba";

   575     }

   576     QCString trPublicTypes()

   577     {

   578       return "Javni tipi";

   579     }

   580     QCString trPublicAttribs()

   581     {

   582       return "Javni atributi";

   583     }

   584     QCString trStaticPublicAttribs()

   585     {

   586       return "Statièni javni atributi";

   587     }

   588     QCString trProtectedTypes()

   589     {

   590       return "Za¹èiteni tipi";

   591     }

   592     QCString trProtectedAttribs()

   593     {

   594       return "Za¹èiteni atributi";

   595     }

   596     QCString trStaticProtectedAttribs()

   597     {

   598       return "Statièni za¹èiteni tipi";

   599     }

   600     QCString trPrivateTypes()

   601     {

   602       return "Skriti tipi";

   603     }

   604     QCString trPrivateAttribs()

   605     {

   606       return "Skriti atributi";

   607     }

   608     QCString trStaticPrivateAttribs()

   609     {

   610       return "Statièni skriti atributi";

   611     }

   612 //////////////////////////////////////////////////////////////////////////

   613 // new since 1.1.3

   614 //////////////////////////////////////////////////////////////////////////

   615 

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

   617     virtual QCString trTodo()

   618     {

   619       return "TODO";

   620     }

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

   622     virtual QCString trTodoList()

   623     {

   624       return "Seznam nedokonèanih opravil";

   625     }

   626 

   627 //////////////////////////////////////////////////////////////////////////

   628 // new since 1.1.4

   629 //////////////////////////////////////////////////////////////////////////

   630 

   631     virtual QCString trReferencedBy()

   632     {

   633       return "Uporabniki entitete:  ";

   634     }

   635     virtual QCString trRemarks()

   636     {

   637       return "Opomba";

   638     }

   639     virtual QCString trAttention()

   640     {

   641       return "Pozor";

   642     }

   643     virtual QCString trInclByDepGraph()

   644     {

   645       return "Graf prikazuje datoteke, ki posredno ali neposredno "

   646              "vkljuèujejo tekoèo datoteko. Pravokotniki simbolizirajo datoteke, "

   647              "pu¹èice pa relacije med datotekami. Tekoèa datoteka je prikazana "

   648 	     "kot pravokotnik s èrno podlago, ostale pa kot pravokotnik brez podlage. "

   649 	     "Smer pu¹èice A->B definira relacijo \"A vkljuèuje B\". "

   650 	     "Vse datoteke, ki torej mejijo na tekoèo (t.j. obstaja povezava med èrnim in "

   651 	     "praznim pravokotnikom), jo direktno vkljuèujejo, medtem, ko jo ostale vkljuèujejo "

   652 	     "le posredno. "

   653 	;

   654     }

   655     virtual QCString trSince()

   656     {

   657       return "Od";

   658     }

   659 

   660 //////////////////////////////////////////////////////////////////////////

   661 // new since 1.1.5

   662 //////////////////////////////////////////////////////////////////////////

   663 

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

   665     virtual QCString trLegendTitle()

   666     {

   667       return "Legenda grafa";

   668     }

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

   670      *  The %A in the text below are to prevent link to classes called "A".

   671      */

   672     virtual QCString trLegendDocs()

   673     {

   674       return 

   675         "Tekoèa stran pojasnjuje naèin interpretacije grafov, ki jih izri¹e "

   676         "doxygen.<p>\n"

   677         "Poglejmo si naslednji primer:\n"

   678         "\\code\n"

   679         "/*! Nevide razred zaradi rezanja */\n"

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

   681         "/*! Odrezan razred, dedovalna relacija je skrita */\n"

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

   683         "/* razred, ki ni opisan z doxygen komentarji */\n"

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

   685         "/*! Razred, ki ga dedujemo s pomoèjo javnega dedovanja */\n"

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

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

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

   689         "/*! Razred, ki ga dedujemo s pomoèjo za¹èitenega dedovanja */\n"

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

   691         "/*! Razred, ki ga dedujemo s pomoèjo skritega dedovanja */\n"

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

   693         "/*! Razred, ki ga uporablja dedovani razred */\n"

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

   695         "/*! Super class that inherits a number of other classes */\n"

   696         "class Inherited : public PublicBase,\n"

   697         "                  protected ProtectedBase,\n"

   698         "                  private PrivateBase,\n"

   699         "                  public Undocumented,\n"

   700         "                  public Templ<int>\n"

   701         "{\n"

   702         "  private:\n"

   703         "    Used *m_usedClass;\n"

   704         "};\n"

   705         "\\endcode\n"

   706         "If the \\c MAX_DOT_GRAPH_HEIGHT tag in the configuration file "

   707         "is set to 200 this will result in the following graph:"

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

   709         "<p>\n"

   710         "The boxes in the above graph have the following meaning:\n"

   711         "<ul>\n"

   712         "<li>%A filled black box represents the struct or class for which the "

   713         "graph is generated.\n"

   714         "<li>%A box with a black border denotes a documented struct or class.\n"

   715         "<li>%A box with a grey border denotes an undocumented struct or class.\n"

   716         "<li>%A box with a red border denotes a documented struct or class for\n"

   717         "which not all inheritance/containment relations are shown. %A graph is "

   718         "truncated if it does not fit within the specified boundaries."

   719         "</ul>\n"

   720         "The arrows have the following meaning:\n"

   721         "<ul>\n"

   722         "<li>%A dark blue arrow is used to visualize a public inheritance "

   723         "relation between two classes.\n"

   724         "<li>%A dark green arrow is used for protected inheritance.\n"

   725         "<li>%A dark red arrow is used for private inheritance.\n"

   726         "<li>%A purple dashed arrow is used if a class is contained or used "

   727         "by another class. The arrow is labeled with the variable(s) "

   728         "through which the pointed class or struct is accessible. \n"

   729         "</ul>\n";

   730     }

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

   732     virtual QCString trLegend()

   733     {

   734       return "legenda";

   735     }

   736     

   737 //////////////////////////////////////////////////////////////////////////

   738 // new since 1.2.0

   739 //////////////////////////////////////////////////////////////////////////

   740     

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

   742     virtual QCString trTest()

   743     {

   744       return "Test";

   745     }

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

   747     virtual QCString trTestList()

   748     {

   749       return "Test List";

   750     }

   751 

   752 //////////////////////////////////////////////////////////////////////////

   753 // new since 1.2.1

   754 //////////////////////////////////////////////////////////////////////////

   755 

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

   757     virtual QCString trDCOPMethods()

   758     {

   759       return "DCOP metode";

   760     }

   761 

   762 //////////////////////////////////////////////////////////////////////////

   763 // new since 1.2.2

   764 //////////////////////////////////////////////////////////////////////////

   765 

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

   767     virtual QCString trProperties()

   768     {

   769       return "IDL Lastnosti";

   770     }

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

   772     virtual QCString trPropertyDocumentation()

   773     {

   774       return "Opis IDL lastnosti";

   775     }

   776 

   777 //////////////////////////////////////////////////////////////////////////

   778 // new since 1.2.4

   779 //////////////////////////////////////////////////////////////////////////

   780 

   781     /*! Used for Java interfaces in the summary section of Java packages */

   782 /*     virtual QCString trInterfaces() */

   783 /*     { */

   784 /*       return "Vmesniki"; */

   785 /*     } */

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

   787     virtual QCString trClasses()

   788     {

   789       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))

   790       {

   791         return "Podatkovne strukture";

   792       }

   793       else

   794       {

   795         return "Razredi";

   796       }

   797     }

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

   799     virtual QCString trPackage(const char *name)

   800     {

   801       return (QCString)"JAVA paket "+name;

   802     }

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

   804     virtual QCString trPackageList()

   805     {

   806       return "Seznam JAVA paketov";

   807     }

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

   809     virtual QCString trPackageListDescription()

   810     {

   811       return "Seznam JAVA paketov in njihovih kratkih opisov v primeru, da obstajajo:";

   812     }

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

   814     virtual QCString trPackages()

   815     {

   816       return "JAVA paketi";

   817     }

   818     /*! Used as a chapter title for Latex & RTF output */

   819 /*     virtual QCString trPackageDocumentation() */

   820 /*     { */

   821 /*       return "Opisi JAVA paketov"; */

   822 /*     } */

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

   824     virtual QCString trDefineValue()

   825     {

   826       return "Vrednost:";

   827     }

   828     

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

   830 // new since 1.2.5

   831 //////////////////////////////////////////////////////////////////////////

   832     

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

   834     virtual QCString trBug()

   835     {

   836       return "Programska napaka";

   837     }

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

   839     virtual QCString trBugList()

   840     {

   841       return "Seznam programskih napak";

   842     }

   843 

   844 //////////////////////////////////////////////////////////////////////////

   845 // new since 1.2.6

   846 //////////////////////////////////////////////////////////////////////////

   847 

   848     /*! Used as ansicpg for RTF file 

   849      * 

   850      * The following table shows the correlation of Charset name, Charset Value and 

   851      * <pre>

   852      * Codepage number:

   853      * Charset Name       Charset Value(hex)  Codepage number

   854      * ------------------------------------------------------

   855      * DEFAULT_CHARSET           1 (x01)

   856      * SYMBOL_CHARSET            2 (x02)

   857      * OEM_CHARSET             255 (xFF)

   858      * ANSI_CHARSET              0 (x00)            1252

   859      * RUSSIAN_CHARSET         204 (xCC)            1251

   860      * EE_CHARSET              238 (xEE)            1250

   861      * GREEK_CHARSET           161 (xA1)            1253

   862      * TURKISH_CHARSET         162 (xA2)            1254

   863      * BALTIC_CHARSET          186 (xBA)            1257

   864      * HEBREW_CHARSET          177 (xB1)            1255

   865      * ARABIC _CHARSET         178 (xB2)            1256

   866      * SHIFTJIS_CHARSET        128 (x80)             932

   867      * HANGEUL_CHARSET         129 (x81)             949

   868      * GB2313_CHARSET          134 (x86)             936

   869      * CHINESEBIG5_CHARSET     136 (x88)             950

   870      * </pre>

   871      * 

   872      */

   873     virtual QCString trRTFansicp()

   874     {

   875       return "1250";

   876     }

   877     

   878 

   879     /*! Used as ansicpg for RTF fcharset 

   880      *  \see trRTFansicp() for a table of possible values.

   881      */

   882     virtual QCString trRTFCharSet()

   883     {

   884       return "0";

   885     }

   886 

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

   888     virtual QCString trRTFGeneralIndex()

   889     {

   890       return "Indeks";

   891     }

   892    

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

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

   895      *  of the category.

   896      */

   897     virtual QCString trClass(bool first_capital, bool singular)

   898     { 

   899       QCString result((first_capital ? "Razred" : "razred"));

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

   901       return result; 

   902     }

   903 

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

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

   906      *  of the category.

   907      */

   908     virtual QCString trFile(bool first_capital, bool singular)

   909     { 

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

   911       if (!singular)  result+="e";

   912       else result += "a";

   913       return result; 

   914     }

   915 

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

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

   918      *  of the category.

   919      */

   920     virtual QCString trNamespace(bool first_capital, bool singular)

   921     { 

   922       QCString result((first_capital ? "Imenski prostor" : "imenski prostor"));

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

   924       return result; 

   925     }

   926 

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

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

   929      *  of the category.

   930      */

   931     virtual QCString trGroup(bool first_capital, bool singular)

   932     { 

   933       QCString result((first_capital ? "Skupina" : "skupina"));

   934       if (!singular)  result+="s";

   935       return result; 

   936     }

   937 

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

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

   940      *  of the category.

   941      */

   942     virtual QCString trPage(bool first_capital, bool singular)

   943     { 

   944       QCString result((first_capital ? "Stran" : "stran"));

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

   946       return result; 

   947     }

   948 

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

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

   951      *  of the category.

   952      */

   953     virtual QCString trMember(bool first_capital, bool singular)

   954     { 

   955       QCString result((first_capital ? "Element" : "element"));

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

   957       return result; 

   958     }

   959    

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

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

   962      *  of the category.

   963      */

   964 /*     virtual QCString trField(bool first_capital, bool singular) */

   965 /*     {  */

   966 /*       QCString result((first_capital ? "Polj" : "polj")); */

   967 /*       if (!singular)  result+="a"; */

   968 /*       else result += "e"; */

   969 /*       return result;  */

   970 /*     } */

   971 

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

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

   974      *  of the category.

   975      */

   976     virtual QCString trGlobal(bool first_capital, bool singular)

   977     { 

   978       QCString result((first_capital ? "Global" : "global"));

   979       if (!singular)  result+="s";

   980       return result; 

   981     }

   982 

   983 //////////////////////////////////////////////////////////////////////////

   984 // new since 1.2.7

   985 //////////////////////////////////////////////////////////////////////////

   986 

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

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

   989     virtual QCString trAuthor(bool first_capital, bool singular)

   990     {                                                                         

   991       QCString result((first_capital ? "Avtor" : "avtor"));

   992       if (!singular)  result+="ji";

   993       return result; 

   994     }

   995 //////////////////////////////////////////////////////////////////////////

   996 // new since 1.2.11

   997 //////////////////////////////////////////////////////////////////////////

   998 

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

  1000      */

  1001     virtual QCString trReferences()

  1002     {

  1003       return "Reference";

  1004     }

  1005 //////////////////////////////////////////////////////////////////////////

  1006 // new since 1.2.13

  1007 //////////////////////////////////////////////////////////////////////////

  1008 

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

  1010      *  members that are implemented by this one.

  1011      */

  1012     virtual QCString trImplementedFromList(int numEntries)

  1013     {

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

  1015     }

  1016 

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

  1018      *  all members that implement this abstract member.

  1019      */

  1020     virtual QCString trImplementedInList(int numEntries)

  1021     {

  1022       return "Implementirano v "+trWriteList(numEntries)+".";

  1023     }

  1024 

  1025 //////////////////////////////////////////////////////////////////////////

  1026 // new since 1.2.16

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

  1028 

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

  1030      *  of Contents.

  1031      */

  1032     virtual QCString trRTFTableOfContents()

  1033     {

  1034       return "Vsebina";

  1035     }

  1036 

  1037 //////////////////////////////////////////////////////////////////////////

  1038 // new since 1.2.17

  1039 //////////////////////////////////////////////////////////////////////////

  1040 

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

  1042      *  flagged deprecated 

  1043      */

  1044     virtual QCString trDeprecatedList()

  1045     {

  1046       return "Seznam opuščenih";

  1047     }

  1048 

  1049 //////////////////////////////////////////////////////////////////////////

  1050 // new since 1.2.18

  1051 //////////////////////////////////////////////////////////////////////////

  1052 

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

  1054      * a C# program

  1055      */

  1056     virtual QCString trEvents()

  1057     {

  1058       return "Dogodki";

  1059     }

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

  1061     virtual QCString trEventDocumentation()

  1062     {

  1063       return "Opisi dogodkov";

  1064     }

  1065 

  1066 //////////////////////////////////////////////////////////////////////////

  1067 // new since 1.3

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

  1069 

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

  1071      */

  1072     virtual QCString trPackageTypes()

  1073     { 

  1074       return "Tipi paketov";

  1075     }

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

  1077      * scope. 

  1078      */

  1079     virtual QCString trPackageMembers()

  1080     { 

  1081       return "Funkcije paketa";   /* don't know the context */

  1082     }

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

  1084      *  package scope.

  1085      */

  1086     virtual QCString trStaticPackageMembers()

  1087     { 

  1088       return "Statične funkcije paketa";

  1089     }

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

  1091      * scope.

  1092      */

  1093     virtual QCString trPackageAttribs()

  1094     { 

  1095       return "Atributi paketa";

  1096     }

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

  1098      * package scope.

  1099      */

  1100     virtual QCString trStaticPackageAttribs()

  1101     { 

  1102       return "Statični atributi paketa";

  1103     }

  1104     

  1105 //////////////////////////////////////////////////////////////////////////

  1106 // new since 1.3.1

  1107 //////////////////////////////////////////////////////////////////////////

  1108 

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

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

  1111      */

  1112     virtual QCString trAll()

  1113     {

  1114       return "Vse";

  1115     }

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

  1117     virtual QCString trCallGraph()

  1118     {

  1119       return "Graf klicev tekoče funkcije:";

  1120     }

  1121 

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

  1123 // new since 1.3.3

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

  1125 

  1126     /*! When the search engine is enabled this text is put in the header 

  1127      *  of each page before the field where one can enter the text to search 

  1128      *  for. 

  1129      */

  1130     virtual QCString trSearchForIndex()

  1131     {

  1132       return "Išči";

  1133     }

  1134     /*! This string is used as the title for the page listing the search