/******************************************************************************

 *

 *

 *

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

 *

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

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

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

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

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

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

 *

 */

// translation by Matjaz Ostroversnik <matjaz.ostroversnik@zrs-tk.si>

#ifndef TRANSLATOR_SI_H

#define TRANSLATOR_SI_H

class TranslatorSlovene : public TranslatorAdapter_1_4_6

{

  protected:

    friend class TranslatorAdapterBase;

    virtual ~TranslatorSlovene() {}

  public:

    QCString idLanguage()

    { return "slovene"; }

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

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

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

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

     */

    QCString latexLanguageSupportCommand()

    {

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

    }

    QCString trRelatedFunctions()

    { return "Povezane funkcije"; }

    QCString trRelatedSubscript()

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

    QCString trDetailedDescription()

    { return "Podroben opis"; }

    QCString trMemberTypedefDocumentation()

    { return "Opis uporabniško definiranih tipov"; }

    QCString trMemberEnumerationDocumentation()

    { return "Opis komponent  naštevnih tipov"; }

/*     QCString trEnumerationValueDocumentation() */

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

    QCString trMemberFunctionDocumentation()

    { return "Opis metod"; }

    QCString trMemberDataDocumentation()

    { return "Opis atributov"; }

    QCString trMore()

    { return "..."; }

    QCString trListOfAllMembers()

    { return "Seznam vseh metod / atributov"; }

    QCString trMemberList()

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

    QCString trThisIsTheListOfAllMembers()

    { return "Seznam metod razreda "; }

    QCString trIncludingInheritedMembers()

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

    QCString trGeneratedAutomatically(const char *s)

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

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

      result+=" iz izvorne kode.";

      return result;

    }

    QCString trEnumName()

    { return "naštevno ime"; }

    QCString trEnumValue()

    { return "naštevna vrednost"; }

    QCString trDefinedIn()

    { return "definirano v"; }

    QCString trModules()

    { return "moduli"; }

    QCString trClassHierarchy()

    { return "dedovalna hierarhija"; }

    QCString trCompoundList()

    { return "kratek opis razredov"; }

    QCString trFileList()

    { return "seznam datotek"; }

/*     QCString trHeaderFiles() */

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

    QCString trCompoundMembers()

    { return "metode in atributi"; }

    QCString trFileMembers()

    { return "komponente v datotekah"; }

    QCString trRelatedPages()

    { return "dodatni opisi"; }

    QCString trExamples()

    { return "Primeri"; }

    QCString trSearch()

    { return "Išči"; }

    QCString trClassHierarchyDescription()

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

    }

    QCString trFileListDescription(bool extractAll)

    {

      QCString result="Seznam vseh ";

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

      result+="datotek s kratkim opisom:";

      return result;

    }

    QCString trCompoundListDescription()

    { return "Seznam razredov, množic in struktur "

             "s kratkim opisom :";

    }

    QCString trCompoundMembersDescription(bool extractAll)

    {

      QCString result="Seznam vseh ";

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

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

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

      else result+="opis razreda :";

      return result;

    }

    QCString trFileMembersDescription(bool extractAll)

    {

      QCString result="Seznam ";

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

      result+="entitet v datotekah ";

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

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

      return result;

    }

/*     QCString trHeaderFilesDescription() */

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

    QCString trExamplesDescription()

    { return "Seznam primerov :"; }

    QCString trRelatedPagesDescription()

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

    QCString trModulesDescription()

    { return "Seznam modulov:"; }

/*     QCString trNoDescriptionAvailable() */

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

    QCString trDocumentation()

    { return "Dokumentacija"; }

    QCString trModuleIndex()

    { return "seznam modulov"; }

    QCString trHierarchicalIndex()

    { return "Hierarhični indeks"; }

    QCString trCompoundIndex()

    { return "abecedni seznam"; }

    QCString trFileIndex()

    { return "seznam datotek"; }

    QCString trModuleDocumentation()

    { return "Dokumentacija modulov"; }

    QCString trClassDocumentation()

    { return "Opis razreda"; }

    QCString trFileDocumentation()

    { return "Opis datoteke"; }

    QCString trExampleDocumentation()

    { return "Opis primera"; }

    QCString trPageDocumentation()

    { return "Opis povezanih strani"; }

    QCString trReferenceManual()

    { return "Priročnik"; }

    QCString trDefines()

    { return "Makro deklaracije"; }

    QCString trTypedefs()

    { return "Uporabniško definirani tipi"; }

    QCString trEnumerations()

    { return "Naštevni tipi"; }

    QCString trFunctions()

    { return "Funkcije"; }

    QCString trVariables()

    { return "Spremenljivke"; }

    QCString trEnumerationValues()

    { return "Vrednosti naštevnih tipov"; }

    QCString trDefineDocumentation()

    { return "Opis makro definicije"; }

    QCString trTypedefDocumentation()

    { return "Opis uporabniško definiranega tipa"; }

    QCString trEnumerationTypeDocumentation()

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

    QCString trFunctionDocumentation()

    { return "Opis funkcije"; }

    QCString trVariableDocumentation()

    { return "Opis spremenljivke"; }

    QCString trCompounds()

    { return "Strukture"; }

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

    {

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

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

      result+=(QCString)" generator: ";

      return result;

    }

    QCString trClassDiagram(const char *clName)

    {

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

    }

    QCString trForInternalUseOnly()

    { return "Samo za interno uporabo."; }

/*     QCString trReimplementedForInternalReasons() */

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

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

/*     } */

    QCString trWarning()

    { return "Opozorilo"; }

/*     QCString trBugsAndLimitations() */

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

    QCString trVersion()

    { return "Verzija"; }

    QCString trDate()

    { return "Datum"; }

    QCString trReturns()

    { return "Rezultat(i)"; }

    QCString trSeeAlso()

    { return "Glej"; }

    QCString trParameters()

    { return "Parametri"; }

    QCString trExceptions()

    { return "Prekinitve"; }

    QCString trGeneratedBy()

    { return "Izdelano s pomočjo"; }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-990307

//////////////////////////////////////////////////////////////////////////

    QCString trNamespaceList()

    { return "imenski prostori"; }

    QCString trNamespaceListDescription(bool extractAll)

    {

      QCString result="Seznam ";

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

      result+="imenskih prostorov z opisom:";

      return result;

    }

    QCString trFriends()

    { return "Prijatelji (Friends) "; }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-990405

//////////////////////////////////////////////////////////////////////////

    QCString trRelatedFunctionDocumentation()

    { return "Podatki o poveznih funkcijah"; }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-990425

//////////////////////////////////////////////////////////////////////////

    QCString trCompoundReference(const char *clName,

                                    ClassDef::CompoundType compType,

                                    bool /*isTemplate*/)

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

    {

      QCString result="";

      switch(compType)

      {

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

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

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

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

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

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

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

        default: break;

      }

      result += (QCString)clName;

      return result;

    }

    QCString trFileReference(const char *fileName)

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

    {

      QCString result="Datoteka ";

	  result+=fileName;

	  return result;

    }

    QCString trNamespaceReference(const char *namespaceName)

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

    {

      QCString result ="Imenski prostor ";

	  result+=namespaceName;

      return result;

    }

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

    QCString trPublicMembers()

    { return "Javne metode"; }

    QCString trPublicSlots()

    { return "Public slotovi"; }

    QCString trSignals()

    { return "Programske prekinitve"; }

    QCString trStaticPublicMembers()

    { return "Statične javne metode in atributi"; }

    QCString trProtectedMembers()

    { return "Zaščitene metode in atributi"; }

    QCString trProtectedSlots()

    { return "Zaščiteni sloti"; }

    QCString trStaticProtectedMembers()

    { return "Statične zaščitene metode in atributi"; }

    QCString trPrivateMembers()

    { return "Skrite metode in atributi"; }

    QCString trPrivateSlots()

    { return "Skriti slotovi"; }

    QCString trStaticPrivateMembers()

    { return "Statične skrite metode in atributi"; }

    // end of member sections

    QCString trWriteList(int numEntries)

    {

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

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

      QCString result;

      int i;

      // the inherits list contain `numEntries' classes

      for (i=0;i

      {

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

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

                                   // (order is left to right)

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

        {

          if (i

            result+=", ";

          else                // the fore last entry

            result+=" in ";

        }

      }

      return result;

    }

    QCString trInheritsList(int numEntries)

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

      // if class diagrams are disabled.

    {

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

    }

    QCString trInheritedByList(int numEntries)

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

      // if class diagrams are disabled.

    {

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

    }

    QCString trReimplementedFromList(int numEntries)

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

      // members that are hidden by this one.

    {

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

    }

    QCString trReimplementedInList(int numEntries)

    {

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

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

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

    }

    QCString trNamespaceMembers()

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

    { return "elementi imenskega prostora"; }

    QCString trNamespaceMemberDescription(bool extractAll)

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

    {

      QCString result="Seznam vseh ";

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

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

      if (extractAll)

        result+="opis vsakega elementa:";

      else

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

      return result;

    }

    QCString trNamespaceIndex()

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

      // index of all namespaces.

    { return "Indeks imenskih prostorov"; }

    QCString trNamespaceDocumentation()

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

      // the documentation of all namespaces.

    { return "Podatki o imenskih prostorih"; }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-990522

//////////////////////////////////////////////////////////////////////////

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

     *  namespaces in a file.

     */

    virtual QCString trNamespaces()

    { return "Imenski prostori"; }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-990728

//////////////////////////////////////////////////////////////////////////

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

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

     */

    QCString trGeneratedFromFiles(ClassDef::CompoundType compType,

        bool single)

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

      // single is true implies a single file

      QCString result=(QCString)"Opis ";

      switch(compType)

      {

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

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

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

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

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

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

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

        default: break;

      }

      result+=" je zgrajen na podlagi naslednj";

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

      result+=" datotek";

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

      return result;

    }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-990901

//////////////////////////////////////////////////////////////////////////

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

    QCString trReturnValues()

    { return "Povratna vrednost"; }

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

     */

    QCString trMainPage()

    { return "prva stran"; }

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

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

     */

    QCString trPageAbbreviation()

    { return "str."; }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-991106

//////////////////////////////////////////////////////////////////////////

/*     QCString trSources() */

/*     { */

/*       return "Izvorne datoteke"; */

/*     } */

    QCString trDefinedAtLineInSourceFile()

    {

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

    }

    QCString trDefinedInSourceFile()

    {

      return "Definirano v datoteki @0.";

    }

//////////////////////////////////////////////////////////////////////////

// new since 0.49-991205

//////////////////////////////////////////////////////////////////////////

    QCString trDeprecated()

    {

      return "Zastarelo";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.0.0

//////////////////////////////////////////////////////////////////////////

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

    QCString trCollaborationDiagram(const char *clName)

    {

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

    }

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

    QCString trInclDepGraph(const char *fName)

    {

      return (QCString)"Graf prikazuje seznam datotek, "

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

          "direktno ali indirektno vključuje. Pravokotniki ponazarjajo datoteke, puščice "

	  "predstavljajo relacije med njimi. "

	  "črn pravokotnik ponazarja datoteko "+fName+". Puščice A->B ponazarjajo "

	  "usmerjeno relacijo \"A vključuje B\"."

;

    }

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

    QCString trConstructorDocumentation()

    {

      return "Opis konstruktorjev in destruktorjev ";

    }

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

    QCString trGotoSourceCode()

    {

      return "izvorna koda";

    }

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

    QCString trGotoDocumentation()

    {

      return "dokumenacija tekoče datoteke.";

    }

    /*! Text for the \pre command */

    QCString trPrecondition()

    {

      return "Predpogoji (preconditions)";

    }

    /*! Text for the \post command */

    QCString trPostcondition()

    {

      return "Naknadni pogoji (posconditions)";

    }

    /*! Text for the \invariant command */

    QCString trInvariant()

    {

      return "Invarianta";

    }

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

    QCString trInitialValue()

    {

      return "Začetna vrednost / definicija :";

    }

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

    QCString trCode()

    {

      return "koda";

    }

    QCString trGraphicalHierarchy()

    {

      return "Hierarhija razredov v grafični obliki";

    }

    QCString trGotoGraphicalHierarchy()

    {

      return "Dedovalna hierarhija v grafični obliki";

    }

    QCString trGotoTextualHierarchy()

    {

      return "Dedovalna hierarhija v tekstovni obliki";

    }

    QCString trPageIndex()

    {

      return "Indeks strani";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.1.0

//////////////////////////////////////////////////////////////////////////

    QCString trNote()

    {

      return "Opomba";

    }

    QCString trPublicTypes()

    {

      return "Javni tipi";

    }

    QCString trPublicAttribs()

    {

      return "Javni atributi";

    }

    QCString trStaticPublicAttribs()

    {

      return "Statični javni atributi";

    }

    QCString trProtectedTypes()

    {

      return "Zaščiteni tipi";

    }

    QCString trProtectedAttribs()

    {

      return "Zaščiteni atributi";

    }

    QCString trStaticProtectedAttribs()

    {

      return "Statični zaščiteni tipi";

    }

    QCString trPrivateTypes()

    {

      return "Skriti tipi";

    }

    QCString trPrivateAttribs()

    {

      return "Skriti atributi";

    }

    QCString trStaticPrivateAttribs()

    {

      return "Statični skriti atributi";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.1.3

//////////////////////////////////////////////////////////////////////////

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

    virtual QCString trTodo()

    {

      return "TODO";

    }

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

    virtual QCString trTodoList()

    {

      return "Seznam nedokončanih opravil";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.1.4

//////////////////////////////////////////////////////////////////////////

    virtual QCString trReferencedBy()

    {

      return "Uporabniki entitete:  ";

    }

    virtual QCString trRemarks()

    {

      return "Opomba";

    }

    virtual QCString trAttention()

    {

      return "Pozor";

    }

    virtual QCString trInclByDepGraph()

    {

      return "Graf prikazuje datoteke, ki posredno ali neposredno "

             "vključujejo tekočo datoteko. Pravokotniki simbolizirajo datoteke, "

             "puščice pa relacije med datotekami. Tekoča datoteka je prikazana "

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

	     "Smer puščice A->B definira relacijo \"A vključuje B\". "

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

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

	     "le posredno. "

	;

    }

    virtual QCString trSince()

    {

      return "Od";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.1.5

//////////////////////////////////////////////////////////////////////////

    /*! title of the graph legend page */

    virtual QCString trLegendTitle()

    {

      return "Legenda grafa";

    }

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

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

     */

    virtual QCString trLegendDocs()

    {

      return

        "Tekoča stran pojasnjuje način interpretacije grafov, ki jih izriše "

        "doxygen.
\n"

        "Poglejmo si naslednji primer:\n"

        "\\code\n"

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

        "class Invisible { };\n\n"

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

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

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

        "class Undocumented { };\n\n"

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

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

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

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

        "/*! Razred, ki ga dedujemo s pomočjo zaščitenega dedovanja */\n"

        "class ProtectedBase { };\n\n"

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

        "class PrivateBase { };\n\n"

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

        "class Used { };\n\n"

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

        "class Inherited : public PublicBase,\n"

        "                  protected ProtectedBase,\n"

        "                  private PrivateBase,\n"

        "                  public Undocumented,\n"

        "                  public Templ<int>\n"

        "{\n"

        "  private:\n"

        "    Used *m_usedClass;\n"

        "};\n"

        "\\endcode\n"

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

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

        "
<center></center>\n"

        "
\n"

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

        "
\n"

        "
%A filled black box represents the struct or class for which the "

        "graph is generated.\n"

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

        "
%A box with a gray border denotes an undocumented struct or class.\n"

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

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

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

        "\n"

        "The arrows have the following meaning:\n"

        "
\n"

        "
%A dark blue arrow is used to visualize a public inheritance "

        "relation between two classes.\n"

        "
%A dark green arrow is used for protected inheritance.\n"

        "
%A dark red arrow is used for private inheritance.\n"

        "
%A purple dashed arrow is used if a class is contained or used "

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

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

        "\n";

    }

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

    virtual QCString trLegend()

    {

      return "legenda";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.2.0

//////////////////////////////////////////////////////////////////////////

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

    virtual QCString trTest()

    {

      return "Test";

    }

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

    virtual QCString trTestList()

    {

      return "Test List";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.2.2

//////////////////////////////////////////////////////////////////////////

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

    virtual QCString trProperties()

    {

      return "IDL Lastnosti";

    }

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

    virtual QCString trPropertyDocumentation()

    {

      return "Opis IDL lastnosti";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.2.4

//////////////////////////////////////////////////////////////////////////

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

/*     virtual QCString trInterfaces() */

/*     { */

/*       return "Vmesniki"; */

/*     } */

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

    virtual QCString trClasses()

    {

      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))

      {

        return "Podatkovne strukture";

      }

      else

      {

        return "Razredi";

      }

    }

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

    virtual QCString trPackage(const char *name)

    {

      return (QCString)"JAVA paket "+name;

    }

    /*! Title of the package index page */

    virtual QCString trPackageList()

    {

      return "Seznam JAVA paketov";

    }

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

    virtual QCString trPackageListDescription()

    {

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

    }

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

    virtual QCString trPackages()

    {

      return "JAVA paketi";

    }

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

/*     virtual QCString trPackageDocumentation() */

/*     { */

/*       return "Opisi JAVA paketov"; */

/*     } */

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

    virtual QCString trDefineValue()

    {

      return "Vrednost:";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.2.5

//////////////////////////////////////////////////////////////////////////

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

    virtual QCString trBug()

    {

      return "Programska napaka";

    }

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

    virtual QCString trBugList()

    {

      return "Seznam programskih napak";

    }

//////////////////////////////////////////////////////////////////////////

// new since 1.2.6

//////////////////////////////////////////////////////////////////////////

    /*! Used as ansicpg for RTF file

     *

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

     * 

     * Codepage number:

     * Charset Name       Charset Value(hex)  Codepage number

     * ------------------------------------------------------

     * DEFAULT_CHARSET           1 (x01)

     * SYMBOL_CHARSET            2 (x02)

     * OEM_CHARSET             255 (xFF)

     * ANSI_CHARSET              0 (x00)            1252

     * RUSSIAN_CHARSET         204 (xCC)            1251

     * EE_CHARSET              238 (xEE)            1250

     * GREEK_CHARSET           161 (xA1)            1253

     * TURKISH_CHARSET         162 (xA2)            1254

     * BALTIC_CHARSET          186 (xBA)            1257

     * HEBREW_CHARSET          177 (xB1)            1255

     * ARABIC _CHARSET         178 (xB2)            1256

     * SHIFTJIS_CHARSET        128 (x80)             932

     * HANGEUL_CHARSET         129 (x81)             949

     * GB2313_CHARSET          134 (x86)             936

     * CHINESEBIG5_CHARSET     136 (x88)             950

     * 

     *

     */

    virtual QCString trRTFansicp()

    {

      return "1250";

    }

    /*! Used as ansicpg for RTF fcharset

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

     */

    virtual QCString trRTFCharSet()

    {

      return "0";

    }

    /*! Used as header RTF general index */

    virtual QCString trRTFGeneralIndex()

    {

      return "Indeks";

    }

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

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

     *  of the category.

     */

    virtual QCString trClass(bool first_capital, bool singular)

    {

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

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

      return result;

    }

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

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

     *  of the category.

     */

    virtual QCString trFile(bool first_capital, bool singular)

    {