Slovene converted to UTF-8.

    <td>Chinese Traditional</td>

    <td>Daniel YC Lin<br/>Gary Lee</td>

    <td>dlin dot tw at gmail dot com<br/>garywlee at gmail dot com</td>

    <td>1.8.0</td>

    <td>up-to-date</td>

  </tr>

  <tr bgcolor="#ffffff">

    <td>Croatian</td>

  ~ & Li Daobing & {\tt\tiny lidaobing at gmail dot com} & ~ \\

  ~ & Wei Liu & {\tt\tiny liuwei at asiainfo dot com} & ~ \\

  \hline

  Chinese Traditional & Daniel YC Lin & {\tt\tiny dlin dot tw at gmail dot com} & 1.8.0 \\

  Chinese Traditional & Daniel YC Lin & {\tt\tiny dlin dot tw at gmail dot com} & up-to-date \\

  ~ & Gary Lee & {\tt\tiny garywlee at gmail dot com} & ~ \\

  \hline

  Croatian & Boris Bralo & {\tt\tiny boris dot bralo at gmail dot com} & 1.8.2 \\

class TranslatorSlovene : public TranslatorAdapter_1_4_6

//public TranslatorAdapter_1_2_16

{

  protected:

    friend class TranslatorAdapterBase;

    }

    QCString idLanguageCharset()

    {

//#ifdef _WIN32

      return "windows-1250"; 

//#else

//      return "iso-8859-2"; 

//#endif

      return "utf-8";

    }

    QCString trRelatedFunctions()

    { return "Povezane funkcije"; }

    QCString trDetailedDescription()

    { return "Podroben opis"; }

    QCString trMemberTypedefDocumentation()

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

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

    QCString trMemberEnumerationDocumentation()

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

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

/*     QCString trEnumerationValueDocumentation() */

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

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

    QCString trMemberFunctionDocumentation()

    { return "Opis metod"; }

    QCString trMemberDataDocumentation()

    QCString trThisIsTheListOfAllMembers()

    { return "Seznam metod razreda "; }

    QCString trIncludingInheritedMembers()

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

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

    QCString trGeneratedAutomatically(const char *s)

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

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

      return result;

    }

    QCString trEnumName()

    { return "na¹tevno ime"; }

    { return "naštevno ime"; }

    QCString trEnumValue()

    { return "na¹tevna vrednost"; }

    { return "naštevna vrednost"; }

    QCString trDefinedIn()

    { return "definirano v"; }

    QCString trModules()

    QCString trExamples()

    { return "Primeri"; }

    QCString trSearch()

    { return "I¹èi"; }

    { return "Išči"; }

    QCString trClassHierarchyDescription()

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

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

    }

    QCString trFileListDescription(bool extractAll)

    {

      return result;

    }

    QCString trCompoundListDescription()

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

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

             "s kratkim opisom :";

    }

    QCString trCompoundMembersDescription(bool extractAll)

    QCString trModuleIndex()

    { return "seznam modulov"; }

    QCString trHierarchicalIndex()

    { return "Hierarhièni indeks"; }

    { return "Hierarhični indeks"; }

    QCString trCompoundIndex()

    { return "abecedni seznam"; }

    QCString trFileIndex()

    QCString trPageDocumentation()

    { return "Opis povezanih strani"; }

    QCString trReferenceManual()

    { return "Priroènik"; }

    { return "Priročnik"; }

    QCString trDefines()

    { return "Makro deklaracije"; }

    QCString trFuncProtos()

    { return "Prototipi funkcij"; }

    QCString trTypedefs()

    { return "Uporabni¹ko definirani tipi"; }

    { return "Uporabniško definirani tipi"; }

    QCString trEnumerations()

    { return "Na¹tevni tipi"; }

    { return "Naštevni tipi"; }

    QCString trFunctions()

    { return "Funkcije"; }

    QCString trVariables()

    { return "Spremenljivke"; }

    QCString trEnumerationValues()

    { return "Vrednosti na¹tevnih tipov"; }

    { return "Vrednosti naštevnih tipov"; }

    QCString trDefineDocumentation()

    { return "Opis makro definicije"; }

    QCString trFunctionPrototypeDocumentation()

    { return "Opis prototipa funkcije"; }

    QCString trTypedefDocumentation()

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

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

    QCString trEnumerationTypeDocumentation()

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

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

    QCString trFunctionDocumentation()

    { return "Opis funkcije"; }

    QCString trVariableDocumentation()

    QCString trExceptions()

    { return "Prekinitve"; }

    QCString trGeneratedBy()

    { return "Izdelano s pomoèjo"; }

    { return "Izdelano s pomočjo"; }

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

// new since 0.49-990307

      {

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

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

        case ClassDef::Union:  result+=" Mno¾ica "; 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!

    QCString trSignals()

    { return "Programske prekinitve"; }

    QCString trStaticPublicMembers()

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

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

    QCString trProtectedMembers()

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

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

    QCString trProtectedSlots()

    { return "Za¹èiteni sloti"; }

    { return "Zaščiteni sloti"; }

    QCString trStaticProtectedMembers()

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

    { 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"; }

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

    // end of member sections

    QCString trWriteList(int numEntries)

    {

      return (QCString)"Graf prikazuje seznam datotek, "

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

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

          "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\"."

	  "č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. */

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

    QCString trGotoDocumentation()

    {

      return "dokumenacija tekoèe datoteke.";

      return "dokumenacija tekoče datoteke.";

    }

    /*! Text for the \pre command */

    QCString trPrecondition()

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

    QCString trInitialValue()

    {

      return "Zaèetna vrednost / definicija :";

      return "Začetna vrednost / definicija :";

    }

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

    QCString trCode()

    }

    QCString trGraphicalHierarchy()

    {

      return "Hierarhija razredov v grafièni obliki";

      return "Hierarhija razredov v grafični obliki";

    }

    QCString trGotoGraphicalHierarchy()

    {

      return "Dedovalna hierarhija v grafièni obliki";

      return "Dedovalna hierarhija v grafični obliki";

    }

    QCString trGotoTextualHierarchy()

    {

    }

    QCString trStaticPublicAttribs()

    {

      return "Statièni javni atributi";

      return "Statični javni atributi";

    }

    QCString trProtectedTypes()

    {

      return "Za¹èiteni tipi";

      return "Zaščiteni tipi";

    }

    QCString trProtectedAttribs()

    {

      return "Za¹èiteni atributi";

      return "Zaščiteni atributi";

    }

    QCString trStaticProtectedAttribs()

    {

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

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

    }

    QCString trPrivateTypes()

    {

    }

    QCString trStaticPrivateAttribs()

    {

      return "Statièni skriti atributi";

      return "Statični skriti atributi";

    }

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

// new since 1.1.3

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

    virtual QCString trTodoList()

    {

      return "Seznam nedokonèanih opravil";

      return "Seznam nedokončanih opravil";

    }

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

    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 "

             "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 trLegendDocs()

    {

      return

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

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

        "doxygen.<p>\n"

        "Poglejmo si naslednji primer:\n"

        "\\code\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"

        "/*! 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"

        "/*! 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"

        "/*! 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"