Orb/Doxygen/src/translator_fi.h
changeset 3 d8fccb2cd802
parent 0 42188c7ea2d9
child 4 468f4c8d3d5b
equal deleted inserted replaced
2:932c358ece3e 3:d8fccb2cd802
       
     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 ==================================================================================
       
    19 Suomenkielinen käännös:
       
    20 Olli Korhonen ( -> 0.49-990425)     <olli.korhonen@ccc.fi>
       
    21 Antti Laine   (0.49-990425 -> )     <antti.a.laine@tut.fi>
       
    22 ==================================================================================
       
    23 1999/10/19
       
    24 *  Alustava käännös valmis.
       
    25 
       
    26 *  Huom: Kaikille termeille on keksitty käännösvastine, mikä ei ehkä ole 
       
    27          kaikissa tapauksissa hyvä ratkaisu, ja parempikin termi voi 
       
    28          olla vakiintuneessa käytössä.
       
    29 
       
    30 2008-04-08
       
    31 * Käännetty versioon 1.5.5 asti.
       
    32 2008-08-26
       
    33 * MAX_DOT_GRAPH_HEIGHT poistettu, versio 1.5.6
       
    34 * Tekstit muutettu UTF-8:ksi
       
    35 2009-01-17
       
    36 * versio 1.5.8
       
    37 * Kantaluokka vaihdettu TranslatorEnglishistä Translatoriksi
       
    38 * Enumeraatio -> luettelotyyppi
       
    39 * Paranneltu kieltä ja poistettu kirjoitusvirheitä
       
    40 
       
    41 * Tehtävää: 
       
    42         - Termien kokoaminen listaksi ja suomennosten järkevyyden tarkastelu. (lista on jo melko kattava)
       
    43                 Author          = Tekijä
       
    44                 Class           = Luokka
       
    45                 Compound        = Kooste
       
    46                 Data            = Data
       
    47                 Documentation   = Dokumentaatio
       
    48                 Defines         = Määrittelyt
       
    49                 Description     = Selite
       
    50                 Detailed        = Yksityiskohtainen
       
    51                 Diagram         = Kaavio
       
    52                 Enum            = Luettelotyyppi
       
    53                 Exceptions      = Poikkeukset
       
    54                 File            = Tiedosto
       
    55                 Friends         = Ystävät
       
    56                 Functions       = Funktiot
       
    57                 Hierarchical    = Hierarkinen
       
    58                 Index           = Indeksi
       
    59                 Inherits        = Perii
       
    60                 Member          = Jäsen
       
    61                 Module          = Moduli
       
    62                 Namespace       = Nimiavaruus
       
    63                 Parameters      = Parametrit
       
    64                 Private         = Yksityinen
       
    65                 Protected       = Suojattu
       
    66                 Prototypes      = Prototyypit
       
    67                 Public          = Julkinen
       
    68                 Reference Manual= Käsikirja
       
    69                 Reimplemented   = Uudelleen toteutettu
       
    70                 Related         = Liittyvä
       
    71                 Signals         = Signaalit
       
    72                 Slots           = Vastineet
       
    73                 Static          = Staattinen
       
    74                 Struct          = Tietue
       
    75                 Typedef         = Tyyppimäärittely
       
    76                 Union           = Yhdiste
       
    77                 Variables       = Muuttujat
       
    78         - Taivutusmuotojen virheettömyyden tarkastelu prepositioiden korvauskohdissa.
       
    79         - Sanasta sanaan käännöskohtien mielekkyyden tarkastelu valmiista dokumentista.
       
    80         - umlaut vastineiden käyttö scandien kohdalla.
       
    81 
       
    82 positiiviset kommentit otetaan ilolla vastaan.
       
    83 ===================================================================================
       
    84 */
       
    85 
       
    86 #ifndef TRANSLATOR_FI_H
       
    87 #define TRANSLATOR_FI_H
       
    88 
       
    89 class TranslatorFinnish : public TranslatorAdapter_1_6_0
       
    90 {
       
    91   public:
       
    92     /*! This method is used to generate a warning message to signal
       
    93      *  the user that the translation of his/her language of choice
       
    94      *  needs updating.
       
    95      */
       
    96     /*virtual QCString updateNeededMessage()
       
    97     {
       
    98       return "Warning: The Finnish translator is really obsolete.\n"
       
    99              "It was not updated since version 1.0.0.  As a result,\n"
       
   100              "some sentences may appear in English.\n\n";
       
   101     }*/
       
   102     
       
   103     // --- Language control methods -------------------
       
   104     
       
   105     /*! Used for identification of the language. The identification 
       
   106      * should not be translated. It should be replaced by the name 
       
   107      * of the language in English using lower-case characters only
       
   108      * (e.g. "czech", "japanese", "russian", etc.). It should be equal to 
       
   109      * the identification used in language.cpp.
       
   110      */
       
   111     virtual QCString idLanguage()
       
   112     { return "finnish"; }
       
   113 
       
   114     /*! Used to get the LaTeX command(s) for the language support. 
       
   115      *  This method should return string with commands that switch
       
   116      *  LaTeX to the desired language.  For example 
       
   117      *  <pre>"\\usepackage[german]{babel}\n"
       
   118      *  </pre>
       
   119      *  or
       
   120      *  <pre>"\\usepackage{polski}\n"
       
   121      *  "\\usepackage[latin2]{inputenc}\n"
       
   122      *  "\\usepackage[T1]{fontenc}\n"
       
   123      *  </pre>
       
   124      * 
       
   125      * The English LaTeX does not use such commands.  Because of this
       
   126      * the empty string is returned in this implementation.
       
   127      */
       
   128     virtual QCString latexLanguageSupportCommand()
       
   129     {
       
   130       return "\\usepackage[finnish]{babel}\n";
       
   131     }
       
   132 
       
   133     /*! return the language charset. This will be used for the HTML output */
       
   134     virtual QCString idLanguageCharset()
       
   135     {
       
   136       return "utf-8";
       
   137     }
       
   138 
       
   139     // --- Language translation methods -------------------
       
   140 
       
   141     /*! used in the compound documentation before a list of related functions. */
       
   142     virtual QCString trRelatedFunctions()
       
   143     { return "Liittyvät funktiot"; } // "Related Functions";
       
   144 
       
   145     /*! subscript for the related functions. */
       
   146     virtual QCString trRelatedSubscript()
       
   147     { return "(Huomaa, että nämä eivät ole jäsenfunktioita.)"; } // "(Note that these are not member functions.)"
       
   148 
       
   149     /*! header that is put before the detailed description of files, classes and namespaces. */
       
   150     virtual QCString trDetailedDescription()
       
   151     { return "Yksityiskohtainen selite"; } // "Detailed Description"
       
   152 
       
   153     /*! header that is put before the list of typedefs. */
       
   154     virtual QCString trMemberTypedefDocumentation()
       
   155       // header that is put before the list of typedefs.
       
   156     { return "Jäsentyyppimäärittelyiden dokumentaatio"; } // "Member Typedef Documentation"
       
   157 
       
   158     /*! header that is put before the list of enumerations. */
       
   159     virtual QCString trMemberEnumerationDocumentation()
       
   160     { return "Jäsenluettelotyyppien dokumentaatio"; } // "Member Enumeration Documentation"
       
   161 
       
   162     /*! header that is put before the list of member functions. */
       
   163     virtual QCString trMemberFunctionDocumentation()
       
   164     { return "Jäsenfunktioiden dokumentaatio"; } // "Member Function Documentation"
       
   165 
       
   166     /*! header that is put before the list of member attributes. */
       
   167     virtual QCString trMemberDataDocumentation()
       
   168     { 
       
   169       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   170       {
       
   171         return "Kenttien dokumentaatio"; // "Field Documentation"; 
       
   172       }
       
   173       else
       
   174       {
       
   175         return "Jäsendatan dokumentaatio"; // "Member Data Documentation"
       
   176       }
       
   177     }
       
   178 
       
   179     /*! this is the text of a link put after brief descriptions. */
       
   180     virtual QCString trMore()
       
   181     { return "Lisää..."; } // "More..."
       
   182 
       
   183      /*! put in the class documentation */
       
   184     virtual QCString trListOfAllMembers()
       
   185     { return "Lista kaikista jäsenistä."; } // "List of all members."
       
   186     virtual QCString trMemberList()
       
   187 
       
   188     /*! used as the title of the "list of all members" page of a class */
       
   189     { return "Jäsenlista"; } // "Member List"
       
   190 
       
   191     /*! this is the first part of a sentence that is followed by a class name */
       
   192     virtual QCString trThisIsTheListOfAllMembers()
       
   193     { return "Tämä on lista kaikista jäsenistä luokassa "; } // "This is the complete list of members for "
       
   194 
       
   195     /*! this is the remainder of the sentence after the class name */
       
   196     virtual QCString trIncludingInheritedMembers()
       
   197     { return ", sisältäen kaikki perityt jäsenet."; } // ", including all inherited members."
       
   198 
       
   199     /*! this is put at the author sections at the bottom of man pages.
       
   200      *  parameter s is name of the project name.
       
   201      */
       
   202     virtual QCString trGeneratedAutomatically(const char *s)
       
   203     { QCString result=(QCString)"Automaattisesti luotu Doxygenilla "
       
   204                       "lähdekoodista projektille "+s; // "Generated automatically by Doxygen" ... "for" ... "from the sourcecode"
       
   205       //if (s) result+=(QCString)" voor "+s;
       
   206       // tässä on ongelma, kuinka taivuttaa parametria, esim. "Jcad"+"in"; "IFC2VRML konversio"+"n"
       
   207       // mutta ratkaistaan ongelma kätevästi kaksoispisteellä -> "Jcad:n" / "IFC2VRML konversio:n"
       
   208       // lopputulos on vähemmän kökkö ja täysin luettava, mutta ei kuitenkaan täydellinen.
       
   209       //
       
   210       // kierretään ongelma taivuttamalla sanaa projekti :)
       
   211       return result;
       
   212     }
       
   213 
       
   214     /*! put after an enum name in the list of all members */
       
   215     virtual QCString trEnumName()
       
   216     { return "luettelotyypin nimi"; } // "enum name"
       
   217 
       
   218     /*! put after an enum value in the list of all members */
       
   219     virtual QCString trEnumValue()
       
   220     { return "luettelotyypin arvo"; } // "enum value"
       
   221 
       
   222     /*! put after an undocumented member in the list of all members */
       
   223     virtual QCString trDefinedIn()
       
   224     { return "määritelty"; } // "defined in"
       
   225 
       
   226     // quick reference sections
       
   227 
       
   228     /*! This is put above each page as a link to the list of all groups of 
       
   229      *  compounds or files (see the \\group command).
       
   230      */
       
   231     virtual QCString trModules()
       
   232     { return "Moduulit"; } // "Modules"
       
   233     
       
   234     /*! This is put above each page as a link to the class hierarchy */
       
   235     virtual QCString trClassHierarchy()
       
   236     { return "Luokkahierarkia"; } // "Class Hierarchy"
       
   237    
       
   238     /*! This is put above each page as a link to the list of annotated classes */ 
       
   239     virtual QCString trCompoundList()
       
   240     { 
       
   241       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   242       {
       
   243         return "Tietueet"; // "Data Structures"
       
   244       }
       
   245       else
       
   246       {
       
   247         return "Luokkalista"; // "Class List"
       
   248       }
       
   249     }
       
   250 
       
   251     /*! This is put above each page as a link to the list of documented files */
       
   252     virtual QCString trFileList()
       
   253     { return "Tiedostolista"; } // "File List"
       
   254    
       
   255     /*! This is put above each page as a link to all members of compounds. */ 
       
   256     virtual QCString trCompoundMembers()
       
   257     { 
       
   258       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   259       {
       
   260         return "Tietueen kentät"; // "Data Fields" 
       
   261       }
       
   262       else
       
   263       {
       
   264         return "Luokan jäsenet"; // "Class Members"
       
   265       }
       
   266     }
       
   267     
       
   268     /*! This is put above each page as a link to all members of files. */
       
   269     virtual QCString trFileMembers()
       
   270     { 
       
   271       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   272       {
       
   273         return "Globaalit"; // "Globals" 
       
   274       }
       
   275       else
       
   276       {
       
   277         return "Tiedoston jäsenet"; // "File Members"
       
   278       }
       
   279     }
       
   280 
       
   281     /*! This is put above each page as a link to all related pages. */
       
   282     virtual QCString trRelatedPages()
       
   283     { return "Liittyvät sivut"; } // "Related Pages"
       
   284    
       
   285     /*! This is put above each page as a link to all examples. */ 
       
   286     virtual QCString trExamples()
       
   287     { return "Esimerkit"; } // "Examples"
       
   288    
       
   289     /*! This is put above each page as a link to the search engine. */ 
       
   290     virtual QCString trSearch()
       
   291     { return "Etsi"; } // "Search"
       
   292    
       
   293     /*! This is an introduction to the class hierarchy. */ 
       
   294     virtual QCString trClassHierarchyDescription()
       
   295     { return "Tämä periytymislista on päätasoltaan aakkostettu " // "This inheritance list is sorted roughly, "
       
   296              "mutta alijäsenet on aakkostettu itsenäisesti:"; // "but not completely, alphabetically:";
       
   297     }
       
   298 
       
   299     /*! This is an introduction to the list with all files. */
       
   300     virtual QCString trFileListDescription(bool extractAll)
       
   301     {
       
   302       QCString result="Tässä on lista kaikista ";
       
   303       if (!extractAll) result+="dokumentoiduista "; // "documented "
       
   304       result+="tiedostoista lyhyen selitteen kanssa:"; // "files with brief descriptions:"
       
   305       return result;
       
   306     }
       
   307     
       
   308     /*! This is an introduction to the annotated compound list. */
       
   309     virtual QCString trCompoundListDescription()
       
   310     {
       
   311     
       
   312       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   313       {
       
   314         return "Tässä ovat tietueet lyhyen selitteen kanssa:"; // "Here are the data structures with brief descriptions:"
       
   315       }
       
   316       else
       
   317       {
       
   318         return "Tässä ovat luokat, tietueet ja " // "Here are the classes, structs and "
       
   319              "yhdisteet lyhyen selitteen kanssa:"; // "unions with brief descriptions:"
       
   320       }
       
   321     }
       
   322     
       
   323     /*! This is an introduction to the page with all class members. */
       
   324     virtual QCString trCompoundMembersDescription(bool extractAll)
       
   325     {
       
   326       QCString result="Tässä on lista kaikista "; // "Here is a list of all "
       
   327       if (!extractAll)
       
   328       {
       
   329         result+="dokumentoiduista "; // "documented "
       
   330       }
       
   331       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   332       {
       
   333         result+="tietuiden ja yhdisteiden kentistä"; // "struct and union fields"
       
   334       }
       
   335       else
       
   336       {
       
   337         result+="luokkien jäsenistä"; // "class members"
       
   338       }
       
   339       result+=" linkitettyinä "; // " with links to "
       
   340       if (!extractAll) 
       
   341       {
       
   342         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   343         {
       
   344           result+="jokaisen kentän tietueen/yhdisteen dokumentaatioon:"; // "the struct/union documentation for each field:"
       
   345         }
       
   346         else
       
   347         {
       
   348           result+="jokaisen jäsenen luokkadokumentaatioon:"; // "the class documentation for each member:"
       
   349         }
       
   350       }
       
   351       else 
       
   352       {
       
   353         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   354         {
       
   355           result+= "tietueisiin/yhdisteisiin, joihin ne kuuluvat:"; // "the structures/unions they belong to:"
       
   356         }
       
   357         else
       
   358         {
       
   359           result+="luokkiin, joihin ne kuuluvat"; //"the classes they belong to:"
       
   360         }
       
   361       }
       
   362       return result;
       
   363     }
       
   364 
       
   365     /*! This is an introduction to the page with all file members. */
       
   366     virtual QCString trFileMembersDescription(bool extractAll)
       
   367     {
       
   368       QCString result="Tässä on lista kaikista "; // "Here is a list of all "
       
   369       if (!extractAll) result+="dokumentoiduista "; // "documented "
       
   370       
       
   371       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   372       {
       
   373         result+="funktioista, muuttujista, määrittelyistä, luettelotyypeistä ja tyyppimäärittelyistä"; // "functions, variables, defines, enums, and typedefs"
       
   374       }
       
   375       else
       
   376       {
       
   377         result+="tiedoston jäsenistä"; // "file members"
       
   378       }
       
   379       result+=" linkitettyinä "; // " with links to "
       
   380       if (extractAll) 
       
   381         result+="tiedostoihin, joihin ne kuuluvat:"; // "the files they belong to:"
       
   382       else 
       
   383         result+="dokumentaatioon:"; // "the documentation:"
       
   384       return result;
       
   385     }
       
   386     
       
   387     /*! This is an introduction to the page with the list of all examples */
       
   388     virtual QCString trExamplesDescription()
       
   389     { return "Tässä on lista kaikista esimerkeistä:"; } //  "Here is a list of all examples:"
       
   390    
       
   391     /*! This is an introduction to the page with the list of related pages */ 
       
   392     virtual QCString trRelatedPagesDescription()
       
   393     { return "Tässä on lista kaikista liittyvistä dokumentaatiosivuista:"; } // "Here is a list of all related documentation pages:"
       
   394    
       
   395     /*! This is an introduction to the page with the list of class/file groups */ 
       
   396     virtual QCString trModulesDescription()
       
   397     { return "Tässä on lista kaikista moduleista:"; } // "Here is a list of all modules:"
       
   398     
       
   399     // index titles (the project name is prepended for these) 
       
   400     
       
   401     /*! This is used in HTML as the title of index.html. */
       
   402     virtual QCString trDocumentation()
       
   403     { return "Dokumentaatio"; } // "Documentation"
       
   404     
       
   405     /*! This is used in LaTeX as the title of the chapter with the 
       
   406      * index of all groups.
       
   407      */
       
   408     virtual QCString trModuleIndex()
       
   409     { return "Moduuliluettelo"; } // "Module Index"
       
   410     
       
   411     /*! This is used in LaTeX as the title of the chapter with the 
       
   412      * class hierarchy.
       
   413      */
       
   414     virtual QCString trHierarchicalIndex()
       
   415     { return "Hierarkinen luettelo"; } // "Hierarchical Index"
       
   416     
       
   417     /*! This is used in LaTeX as the title of the chapter with the 
       
   418      * annotated compound index.
       
   419      */
       
   420     virtual QCString trCompoundIndex()
       
   421     {
       
   422       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   423       { 
       
   424         return "Tietueluettelo"; // "Data Structure Index"
       
   425       }
       
   426       else
       
   427       {
       
   428         return "Luokkaluettelo"; // "Class Index"
       
   429       }
       
   430     }
       
   431     
       
   432     /*! This is used in LaTeX as the title of the chapter with the
       
   433      * list of all files.
       
   434      */
       
   435     virtual QCString trFileIndex() 
       
   436     { return "Tiedostoluettelo"; } // "File Index"
       
   437     
       
   438     /*! This is used in LaTeX as the title of the chapter containing
       
   439      *  the documentation of all groups.
       
   440      */
       
   441     virtual QCString trModuleDocumentation()
       
   442     { return "Moduulien dokumentaatio"; } // "Module Documentation"
       
   443     
       
   444     /*! This is used in LaTeX as the title of the chapter containing
       
   445      *  the documentation of all classes, structs and unions.
       
   446      */
       
   447     virtual QCString trClassDocumentation()
       
   448     {
       
   449       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   450       {
       
   451         return "Tietueiden dokumentaatio"; // "Data Structure Documentation"
       
   452       }
       
   453       else
       
   454       {
       
   455         return "Luokkien dokumentaatio"; // "Class Documentation"
       
   456       }
       
   457     }
       
   458 
       
   459     /*! This is used in LaTeX as the title of the chapter containing
       
   460      *  the documentation of all files.
       
   461      */
       
   462     virtual QCString trFileDocumentation()
       
   463     { return "Tiedostojen dokumentaatio"; } // "File Documentation"
       
   464     
       
   465     /*! This is used in LaTeX as the title of the chapter containing
       
   466      *  the documentation of all examples.
       
   467      */
       
   468     virtual QCString trExampleDocumentation()
       
   469     { return "Esimerkkien dokumentaatio"; } // "Example Documentation"
       
   470     
       
   471     /*! This is used in LaTeX as the title of the chapter containing
       
   472      *  the documentation of all related pages.
       
   473      */
       
   474     virtual QCString trPageDocumentation()
       
   475     { return "Sivujen dokumentaatio"; } // "Page Documentation"
       
   476     
       
   477     /*! This is used in LaTeX as the title of the document */
       
   478     virtual QCString trReferenceManual()
       
   479     { return "Käsikirja"; } // "Reference Manual"
       
   480 
       
   481     /*! This is used in the documentation of a file as a header before the 
       
   482      *  list of defines
       
   483      */
       
   484     virtual QCString trDefines()
       
   485     { return "Määrittelyt"; } // "Defines"
       
   486     
       
   487     /*! This is used in the documentation of a file as a header before the 
       
   488      *  list of function prototypes
       
   489      */
       
   490     virtual QCString trFuncProtos()
       
   491     { return "Funktioiden prototyypit"; } // "Function Prototypes"
       
   492     
       
   493     /*! This is used in the documentation of a file as a header before the 
       
   494      *  list of typedefs
       
   495      */
       
   496     virtual QCString trTypedefs()
       
   497     { return "Tyyppimäärittelyt"; } // "Typedefs"
       
   498     
       
   499     /*! This is used in the documentation of a file as a header before the 
       
   500      *  list of enumerations
       
   501      */
       
   502     virtual QCString trEnumerations()
       
   503     { return "Luettelotyypit"; } // "Enumerations"
       
   504     
       
   505     /*! This is used in the documentation of a file as a header before the 
       
   506      *  list of (global) functions
       
   507      */
       
   508     virtual QCString trFunctions()
       
   509     { return "Funktiot"; } // "Functions"
       
   510     
       
   511     /*! This is used in the documentation of a file as a header before the 
       
   512      *  list of (global) variables
       
   513      */
       
   514     virtual QCString trVariables()
       
   515     { return "Muuttujat"; } // "Variables"
       
   516     
       
   517     /*! This is used in the documentation of a file as a header before the 
       
   518      *  list of (global) variables
       
   519      */
       
   520     virtual QCString trEnumerationValues()
       
   521     { return "Luettelotyyppien arvot"; } // "Enumerator"
       
   522 
       
   523     /*! This is used in the documentation of a file before the list of
       
   524      *  documentation blocks for defines
       
   525      */
       
   526     virtual QCString trDefineDocumentation()
       
   527     { return "Määritysten dokumentointi"; } // "Define Documentation"
       
   528     
       
   529     /*! This is used in the documentation of a file/namespace before the list 
       
   530      *  of documentation blocks for function prototypes
       
   531      */
       
   532     virtual QCString trFunctionPrototypeDocumentation()
       
   533     { return "Funktioprototyyppien dokumentaatio"; } // "Function Prototype Documentation"
       
   534     
       
   535     /*! This is used in the documentation of a file/namespace before the list 
       
   536      *  of documentation blocks for typedefs
       
   537      */
       
   538     virtual QCString trTypedefDocumentation()
       
   539     { return "Tyyppimääritysten dokumentaatio"; } // "Typedef Documentation"
       
   540     
       
   541     /*! This is used in the documentation of a file/namespace before the list 
       
   542      *  of documentation blocks for enumeration types
       
   543      */
       
   544     virtual QCString trEnumerationTypeDocumentation()
       
   545     { return "Luettelotyyppien dokumentaatio"; } // "Enumeration Type Documentation"
       
   546     
       
   547     /*! This is used in the documentation of a file/namespace before the list 
       
   548      *  of documentation blocks for functions
       
   549      */
       
   550     virtual QCString trFunctionDocumentation()
       
   551     { return "Funktioiden dokumentaatio"; } // "Function Documentation"
       
   552     
       
   553     /*! This is used in the documentation of a file/namespace before the list 
       
   554      *  of documentation blocks for variables
       
   555      */
       
   556     virtual QCString trVariableDocumentation()
       
   557     { return "Muuttujien dokumentaatio"; } // "Variable Documentation"
       
   558     
       
   559     /*! This is used in the documentation of a file/namespace/group before 
       
   560      *  the list of links to documented compounds
       
   561      */
       
   562     virtual QCString trCompounds()
       
   563     {
       
   564       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   565       {
       
   566         return "Tietueet"; // "Data Structures"
       
   567       }
       
   568       else
       
   569       {
       
   570         return "Luokat"; // "Classes"
       
   571       }
       
   572     }
       
   573     
       
   574     /*! This is used in the standard footer of each page and indicates when 
       
   575      *  the page was generated 
       
   576      */
       
   577     virtual QCString trGeneratedAt(const char *date,const char *projName)
       
   578     { 
       
   579         // funktio on hiukan vaikea kääntää prepositioihin sidotun rakenteen vuoksi.
       
   580         // Muutetaan siis lauserakennetta suomalaisemmaksi
       
   581         // Generated on $date for $project by:
       
   582         // -> Generated for $project on $date by:
       
   583       QCString result=(QCString)"Generoinut ";
       
   584       if (projName) result+=(QCString)"projektille "+projName+" ";
       
   585       result+=(QCString)date+" ";
       
   586       return result;
       
   587     }
       
   588     /*! This is part of the sentence used in the standard footer of each page.
       
   589      */
       
   590     virtual QCString trWrittenBy()
       
   591     {
       
   592       return "kirjoittanut"; // "written by"
       
   593     }
       
   594 
       
   595     /*! this text is put before a class diagram */
       
   596     virtual QCString trClassDiagram(const char *clName)
       
   597     {
       
   598       return "Luokan "+(QCString)clName+" luokkakaavio"; // "Inheritance diagram for "
       
   599     }
       
   600 
       
   601     /*! this text is generated when the \\internal command is used. */
       
   602     virtual QCString trForInternalUseOnly()
       
   603     { return "Vain sisäiseen käyttöön."; } // "For internal use only."
       
   604     
       
   605     /*! this text is generated when the \\warning command is used. */
       
   606     virtual QCString trWarning()
       
   607     { return "Varoitus"; } // "Warning"
       
   608     
       
   609     /*! this text is generated when the \\version command is used. */
       
   610     virtual QCString trVersion()
       
   611     { return "Versio"; } // "Version"
       
   612     
       
   613     /*! this text is generated when the \\date command is used. */
       
   614     virtual QCString trDate()
       
   615     { return "Päiväys"; } // "Date"
       
   616     
       
   617     /*! this text is generated when the \\return command is used. */
       
   618     virtual QCString trReturns()
       
   619     { return "Palauttaa"; } // "Returns"
       
   620     
       
   621     /*! this text is generated when the \\sa command is used. */
       
   622     virtual QCString trSeeAlso()
       
   623     { return "Katso myös"; } // "See also"
       
   624     
       
   625     /*! this text is generated when the \\param command is used. */
       
   626     virtual QCString trParameters()
       
   627     { return "Parametrit"; } // "Parameters"
       
   628     
       
   629     /*! this text is generated when the \\exception command is used. */
       
   630     virtual QCString trExceptions()
       
   631     { return "Poikkeukset"; } // "Exceptions"
       
   632     
       
   633     /*! this text is used in the title page of a LaTeX document. */
       
   634     virtual QCString trGeneratedBy()
       
   635     { return "Generoinut"; } // "Generated by"
       
   636     
       
   637 //////////////////////////////////////////////////////////////////////////
       
   638 // new since 0.49-990307 
       
   639 //////////////////////////////////////////////////////////////////////////
       
   640     
       
   641     /*! used as the title of page containing all the index of all namespaces. */
       
   642     virtual QCString trNamespaceList()
       
   643     { return "Nimiavaruus Lista"; } // "Namespace List"
       
   644     
       
   645     /*! used as an introduction to the namespace list */
       
   646     virtual QCString trNamespaceListDescription(bool extractAll)
       
   647     {
       
   648       QCString result="Tässä on lista kaikista "; // "Here is a list of all "
       
   649       if (!extractAll) result+="dokumentoiduista "; // "documented "
       
   650       result+="nimiavaruuksista lyhyen selitteen kanssa:"; // "namespaces with brief descriptions:"
       
   651       return result;
       
   652     }
       
   653     
       
   654     /*! used in the class documentation as a header before the list of all
       
   655      *  friends of a class
       
   656      */
       
   657     virtual QCString trFriends()
       
   658     { return "Ystävät"; } // "Friends"
       
   659 
       
   660 //////////////////////////////////////////////////////////////////////////
       
   661 // new since 0.49-990405
       
   662 //////////////////////////////////////////////////////////////////////////
       
   663     
       
   664     /*! used in the class documentation as a header before the list of all
       
   665      * related classes 
       
   666      */
       
   667     virtual QCString trRelatedFunctionDocumentation()
       
   668     { return "Ystävät ja niihin liittyvien funktioiden dokumentaatio"; } // "Friends And Related Function Documentation"
       
   669     
       
   670 //////////////////////////////////////////////////////////////////////////
       
   671 // new since 0.49-990425
       
   672 //////////////////////////////////////////////////////////////////////////
       
   673 
       
   674     /*! used as the title of the HTML page of a class/struct/union */
       
   675     virtual QCString trCompoundReference(const char *clName,
       
   676                                     ClassDef::CompoundType compType,
       
   677                                     bool isTemplate)
       
   678     {
       
   679       QCString result=(QCString)clName;
       
   680       switch(compType)
       
   681       {
       
   682         case ClassDef::Class:      result+=" luokka"; break; // " Class"
       
   683         case ClassDef::Struct:     result+=" tietue"; break; // " Struct"
       
   684         case ClassDef::Union:      result+=" yhdiste"; break; // " Union"
       
   685         case ClassDef::Interface:  result+=" rajapinta"; break; // " Interface"
       
   686         case ClassDef::Protocol:   result+=" protokolla"; break; // " Protocol"
       
   687         case ClassDef::Category:   result+=" kategoria"; break; // " Category"
       
   688         case ClassDef::Exception:  result+=" poikkeus"; break; // " Exception"
       
   689       }
       
   690       if (isTemplate) result+="malli"; // " Template"
       
   691       result+="referenssi"; // " Reference"
       
   692       return result;
       
   693     }
       
   694 
       
   695     /*! used as the title of the HTML page of a file */
       
   696     virtual QCString trFileReference(const char *fileName)
       
   697     {
       
   698       QCString result=fileName;
       
   699       result+=" tiedostoreferenssi"; // " File Reference"
       
   700       return result;
       
   701     }
       
   702     
       
   703     /*! used as the title of the HTML page of a namespace */
       
   704     virtual QCString trNamespaceReference(const char *namespaceName)
       
   705     {
       
   706       QCString result=namespaceName;
       
   707       result+=" nimiavaruusreferenssi"; // " Namespace Reference"
       
   708       return result;
       
   709     }
       
   710     
       
   711     virtual QCString trPublicMembers()
       
   712     { return "Julkiset jäsenfunktiot"; } // "Public Member Functions"
       
   713     virtual QCString trPublicSlots()
       
   714     { return "Julkiset vastineet"; } // "Public Slots"
       
   715     virtual QCString trSignals()
       
   716     { return "Signaalit"; } // "Signals"
       
   717     virtual QCString trStaticPublicMembers()
       
   718     { return "Staattiset julkiset jäsenfunktiot"; } // "Static Public Member Functions"
       
   719     virtual QCString trProtectedMembers()
       
   720     { return "Suojatut jäsenfunktiot"; } // "Protected Member Functions"
       
   721     virtual QCString trProtectedSlots()
       
   722     { return "Suojatut vastineet"; } // "Protected Slots"
       
   723     virtual QCString trStaticProtectedMembers()
       
   724     { return "Staattiset suojatut jäsenfunktiot"; } // "Static Protected Member Functions"
       
   725     virtual QCString trPrivateMembers()
       
   726     { return "Yksityiset jäsenfunktiot"; } // "Private Member Functions"
       
   727     virtual QCString trPrivateSlots()
       
   728     { return "Yksityiset vastineet"; } // "Private Slots"
       
   729     virtual QCString trStaticPrivateMembers()
       
   730     { return "Staattiset yksityiset jäsenfunktiot"; } // "Static Private Member Functions"
       
   731 
       
   732     /*! this function is used to produce a comma-separated list of items.
       
   733      *  use generateMarker(i) to indicate where item i should be put.
       
   734      */
       
   735     virtual QCString trWriteList(int numEntries)
       
   736     {
       
   737       QCString result;
       
   738       int i;
       
   739       // the inherits list contain `numEntries' classes
       
   740       for (i=0;i<numEntries;i++) 
       
   741       {
       
   742         // use generateMarker to generate placeholders for the class links!
       
   743         result+=generateMarker(i); // generate marker for entry i in the list 
       
   744                                    // (order is left to right)
       
   745         
       
   746         if (i!=numEntries-1)  // not the last entry, so we need a separator
       
   747         {
       
   748           if (i<numEntries-2) // not the fore last entry 
       
   749             result+=", ";
       
   750           else                // the fore last entry
       
   751             result+=" ja "; // ", and "
       
   752         }
       
   753       }
       
   754       return result; 
       
   755     }
       
   756     
       
   757     /*! used in class documentation to produce a list of base classes,
       
   758      *  if class diagrams are disabled.
       
   759      */
       
   760     virtual QCString trInheritsList(int numEntries)
       
   761     {
       
   762       return (QCString)"Periytyy "+(numEntries > 1 ? "luokista " : "luokasta ")+trWriteList(numEntries)+"."; // "Inherits "
       
   763     }
       
   764     
       
   765     /*! used in class documentation to produce a list of super classes,
       
   766      *  if class diagrams are disabled.
       
   767      */
       
   768     virtual QCString trInheritedByList(int numEntries)
       
   769     {
       
   770       return (QCString)"Periytetään "+(numEntries > 1 ? "luokissa " : "luokassa ")+trWriteList(numEntries)+"."; // "Inherited by "
       
   771     }
       
   772     
       
   773     /*! used in member documentation blocks to produce a list of 
       
   774      *  members that are hidden by this one.
       
   775      */
       
   776     virtual QCString trReimplementedFromList(int numEntries)
       
   777     {
       
   778       return (QCString)"Uudelleentoteuttaa "+(numEntries > 1 ? "luokat " : "luokan  ")+trWriteList(numEntries)+"."; // "Reimplemented from "
       
   779     }
       
   780     
       
   781     /*! used in member documentation blocks to produce a list of
       
   782      *  all member that overwrite the implementation of this member.
       
   783      */
       
   784     virtual QCString trReimplementedInList(int numEntries)
       
   785     {
       
   786       return (QCString)"Uudelleentoteutetaan "+(numEntries > 1 ? "luokissa " : "luokassa ")+trWriteList(numEntries)+"."; // "Reimplemented in "
       
   787     }
       
   788 
       
   789     /*! This is put above each page as a link to all members of namespaces. */
       
   790     virtual QCString trNamespaceMembers()
       
   791     { return "Nimiavaruuden jäsenet"; } // "Namespace Members"
       
   792     
       
   793     /*! This is an introduction to the page with all namespace members */
       
   794     virtual QCString trNamespaceMemberDescription(bool extractAll)
       
   795     { 
       
   796       QCString result="Tässä on lista kaikista "; // "Here is a list of all "
       
   797       if (!extractAll) result+="dokumentoiduista "; // "documented "
       
   798       result+="nimiavaruuden jäsenistä linkitettynä "; // "namespace members with links to "
       
   799       if (extractAll) 
       
   800         result+="nimiavaruuden dokumentaatioon johon ne kuuluvat:"; // "the namespace documentation for each member:";
       
   801       else 
       
   802         result+="nimiavaruuksiin joihin ne kuuluvat:"; // "the namespaces they belong to:"
       
   803       return result;
       
   804     }
       
   805     /*! This is used in LaTeX as the title of the chapter with the 
       
   806      *  index of all namespaces.
       
   807      */ 
       
   808     virtual QCString trNamespaceIndex()
       
   809     { return "Nimiavaruuksien luettelo"; } // "Namespace Index"
       
   810     
       
   811     /*! This is used in LaTeX as the title of the chapter containing
       
   812      *  the documentation of all namespaces.
       
   813      */
       
   814     virtual QCString trNamespaceDocumentation()
       
   815     { return "Nimiavaruuden dokumentaatio"; } // "Namespace Documentation"
       
   816 
       
   817 //////////////////////////////////////////////////////////////////////////
       
   818 // new since 0.49-990522
       
   819 //////////////////////////////////////////////////////////////////////////
       
   820 
       
   821     /*! This is used in the documentation before the list of all
       
   822      *  namespaces in a file.
       
   823      */
       
   824     virtual QCString trNamespaces()
       
   825     { return "Nimiavaruudet"; } // "Namespaces"; }
       
   826 
       
   827 //////////////////////////////////////////////////////////////////////////
       
   828 // new since 0.49-990728
       
   829 //////////////////////////////////////////////////////////////////////////
       
   830 
       
   831     /*! This is put at the bottom of a class documentation page and is
       
   832      *  followed by a list of files that were used to generate the page.
       
   833      */
       
   834     virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
       
   835         bool single)
       
   836     { // here s is one of " Class", " Struct" or " Union"
       
   837       // single is true implies a single file
       
   838       QCString result=(QCString)"Dokumentaatio tälle "; // "The documentation for this "
       
   839       switch(compType)
       
   840       {
       
   841         case ClassDef::Class:      result+="luokalle"; break; // "class"
       
   842         case ClassDef::Struct:     result+="tietueelle"; break; // "struct"
       
   843         case ClassDef::Union:      result+="yhdisteelle"; break; // "union"
       
   844         case ClassDef::Interface:  result+="rajapinnalle"; break; // "interface"
       
   845         case ClassDef::Protocol:   result+="protokollalle"; break; // "protocol"
       
   846         case ClassDef::Category:   result+="kategorialle"; break; // "category"
       
   847         case ClassDef::Exception:  result+="poikkeukselle"; break; // "exception"
       
   848       }
       
   849       if (single) result+=" luotiin seuraavasta tiedostosta:"; // " was generated from the following file"
       
   850       else result+=" luotiin seuraavista tiedostoista:"; // ":" or "s:"
       
   851       return result;
       
   852     }
       
   853 
       
   854     /*! This is in the (quick) index as a link to the alphabetical compound
       
   855      * list.
       
   856      */
       
   857     virtual QCString trAlphabeticalList()
       
   858     { return "Aakkosellinen lista"; } // "Alphabetical List"
       
   859 
       
   860 //////////////////////////////////////////////////////////////////////////
       
   861 // new since 0.49-990901
       
   862 //////////////////////////////////////////////////////////////////////////
       
   863 
       
   864     /*! This is used as the heading text for the retval command. */
       
   865     virtual QCString trReturnValues()
       
   866     { return "Paluuarvot"; } // "Return values"
       
   867 
       
   868     /*! This is in the (quick) index as a link to the main page (index.html)
       
   869      */
       
   870     virtual QCString trMainPage()
       
   871     { return "Pääsivu"; } // "Main Page"
       
   872 
       
   873     /*! This is used in references to page that are put in the LaTeX 
       
   874      *  documentation. It should be an abbreviation of the word page.
       
   875      */
       
   876     virtual QCString trPageAbbreviation()
       
   877     { return "s."; } // "p."
       
   878 
       
   879 //////////////////////////////////////////////////////////////////////////
       
   880 // new since 0.49-991003
       
   881 //////////////////////////////////////////////////////////////////////////
       
   882 
       
   883     virtual QCString trDefinedAtLineInSourceFile()
       
   884     {
       
   885       return "Määrittely tiedoston @1 rivillä @0."; //  "Definition at line @0 of file @1."
       
   886     }
       
   887     virtual QCString trDefinedInSourceFile()
       
   888     {
       
   889       return "Määrittely tiedostossa @0."; // "Definition in file @0."
       
   890     }
       
   891 
       
   892 //////////////////////////////////////////////////////////////////////////
       
   893 // new since 0.49-991205
       
   894 //////////////////////////////////////////////////////////////////////////
       
   895 
       
   896     virtual QCString trDeprecated()
       
   897     {
       
   898       return "Vanhentunut"; // "Deprecated"
       
   899     }
       
   900 
       
   901 //////////////////////////////////////////////////////////////////////////
       
   902 // new since 1.0.0
       
   903 //////////////////////////////////////////////////////////////////////////
       
   904 
       
   905     /*! this text is put before a collaboration diagram */
       
   906     virtual QCString trCollaborationDiagram(const char *clName)
       
   907     {
       
   908       return (QCString)"Yhteistyökaavio luokalle "+clName+":"; // "Collaboration diagram for "+clName+":"
       
   909     }
       
   910     /*! this text is put before an include dependency graph */
       
   911     virtual QCString trInclDepGraph(const char *fName)
       
   912     {
       
   913       return (QCString)"Sisällytysriippuvuuskaavio tiedostolle "+fName+":"; // "Include dependency graph for "+fName+":"
       
   914     }
       
   915     /*! header that is put before the list of constructor/destructors. */
       
   916     virtual QCString trConstructorDocumentation()
       
   917     {
       
   918       return "Rakentajien & purkajien dokumentaatio"; // "Constructor & Destructor Documentation";
       
   919     }
       
   920     /*! Used in the file documentation to point to the corresponding sources. */
       
   921     virtual QCString trGotoSourceCode()
       
   922     {
       
   923       return "Siirry tämän tiedoston lähdekoodiin."; // "Go to the source code of this file."
       
   924     }
       
   925     /*! Used in the file sources to point to the corresponding documentation. */
       
   926     virtual QCString trGotoDocumentation()
       
   927     {
       
   928       return "Siirry tämän tiedoston dokumentaatioon."; // "Go to the documentation of this file."
       
   929     }
       
   930     /*! Text for the \\pre command */
       
   931     virtual QCString trPrecondition()
       
   932     {
       
   933       return "Esiehto"; //"Precondition"
       
   934     }
       
   935     /*! Text for the \\post command */
       
   936     virtual QCString trPostcondition()
       
   937     {
       
   938       return "Jälkiehto"; // "Postcondition"
       
   939     }
       
   940     /*! Text for the \\invariant command */
       
   941     virtual QCString trInvariant()
       
   942     {
       
   943       return "Invariantti"; // vai "Pysyväisväittämä"? "Invariant"
       
   944     }
       
   945     /*! Text shown before a multi-line variable/enum initialization */
       
   946     virtual QCString trInitialValue()
       
   947     {
       
   948       return "Alkuarvo:"; // "Initial value:"
       
   949     }
       
   950     /*! Text used the source code in the file index */
       
   951     virtual QCString trCode()
       
   952     {
       
   953       return "koodi"; // "code"
       
   954     }
       
   955     virtual QCString trGraphicalHierarchy()
       
   956     {
       
   957       return "Graafinen luokkahierarkia"; // "Graphical Class Hierarchy"
       
   958     }
       
   959     virtual QCString trGotoGraphicalHierarchy()
       
   960     {
       
   961       return "Siirry graafiseen luokkahierarkiaan"; // "Go to the graphical class hierarchy"
       
   962     }
       
   963     virtual QCString trGotoTextualHierarchy()
       
   964     {
       
   965       return "Siirry tekstimuotoiseen luokkahierarkiaan"; // "Go to the textual class hierarchy"
       
   966     }
       
   967     virtual QCString trPageIndex()
       
   968     {
       
   969       return "Sivuhakemisto"; // "Page Index"
       
   970     }
       
   971 
       
   972 //////////////////////////////////////////////////////////////////////////
       
   973 // new since 1.1.0
       
   974 //////////////////////////////////////////////////////////////////////////
       
   975     
       
   976     virtual QCString trNote()
       
   977     {
       
   978         // FIXME: Missähän merkityksessä tätä käytetään?
       
   979       return "Huomautus"; // "Note"
       
   980     }
       
   981     virtual QCString trPublicTypes()
       
   982     {
       
   983       return "Julkiset tyypit"; // "Public Types"
       
   984     }
       
   985     virtual QCString trPublicAttribs()
       
   986     {
       
   987       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
   988       {
       
   989         return "Tietueen kentät"; // "Data Fields"
       
   990       }
       
   991       else
       
   992       {
       
   993         return "Julkiset attribuutit"; // "Public Attributes"
       
   994       }
       
   995     }
       
   996     virtual QCString trStaticPublicAttribs()
       
   997     {
       
   998       return "Staattiset julkiset attribuutit"; // "Static Public Attributes"
       
   999     }
       
  1000     virtual QCString trProtectedTypes()
       
  1001     {
       
  1002       return "Suojellut tyypit"; // "Protected Types"
       
  1003     }
       
  1004     virtual QCString trProtectedAttribs()
       
  1005     {
       
  1006       return "Suojellut attribuutit"; // "Protected Attributes"
       
  1007     }
       
  1008     virtual QCString trStaticProtectedAttribs()
       
  1009     {
       
  1010       return "Staattiset suojellut attribuutit"; // "Static Protected Attributes"
       
  1011     }
       
  1012     virtual QCString trPrivateTypes()
       
  1013     {
       
  1014       return "Yksityiset tyypit"; // "Private Types"
       
  1015     }
       
  1016     virtual QCString trPrivateAttribs()
       
  1017     {
       
  1018       return "Yksityiset attribuutit"; // "Private Attributes"
       
  1019     }
       
  1020     virtual QCString trStaticPrivateAttribs()
       
  1021     {
       
  1022       return "Staattiset yksityiset attribuutit"; // "Static Private Attributes"
       
  1023     }
       
  1024 
       
  1025 //////////////////////////////////////////////////////////////////////////
       
  1026 // new since 1.1.3
       
  1027 //////////////////////////////////////////////////////////////////////////
       
  1028 
       
  1029     /*! Used as a marker that is put before a \\todo item */
       
  1030     virtual QCString trTodo()
       
  1031     {
       
  1032       return "Vielä tehtävänä"; // "Todo"
       
  1033     }
       
  1034     /*! Used as the header of the todo list */
       
  1035     virtual QCString trTodoList()
       
  1036     {
       
  1037       return "Tehtävälista"; // "Todo List"
       
  1038     }
       
  1039 
       
  1040 //////////////////////////////////////////////////////////////////////////
       
  1041 // new since 1.1.4
       
  1042 //////////////////////////////////////////////////////////////////////////
       
  1043 
       
  1044     virtual QCString trReferencedBy()
       
  1045     {
       
  1046       return "Viitattu"; // "Referenced by"
       
  1047     }
       
  1048     virtual QCString trRemarks()
       
  1049     {
       
  1050       return "Huomioita"; // "Remarks"
       
  1051     }
       
  1052     virtual QCString trAttention()
       
  1053     {
       
  1054       return "Huomio"; // "Attention"
       
  1055     }
       
  1056     virtual QCString trInclByDepGraph()
       
  1057     {
       
  1058       return "Tämä kaavio näyttää, mitkä tiedostot suorasti "
       
  1059              "tai epäsuorasti sisällyttävät tämän tiedoston";
       
  1060              // "This graph shows which files directly or "
       
  1061              // "indirectly include this file:"
       
  1062     }
       
  1063     virtual QCString trSince()
       
  1064     {
       
  1065         // FIXME: Missä merkityksessä tätä käytetään?
       
  1066       return "Lähtien"; // "Since"
       
  1067     }
       
  1068     
       
  1069 //////////////////////////////////////////////////////////////////////////
       
  1070 // new since 1.1.5
       
  1071 //////////////////////////////////////////////////////////////////////////
       
  1072 
       
  1073     /*! title of the graph legend page */
       
  1074     virtual QCString trLegendTitle()
       
  1075     {
       
  1076       return "Kaavion selite"; // "Graph Legend"
       
  1077     }
       
  1078     /*! page explaining how the dot graph's should be interpreted 
       
  1079      *  The %A in the text below are to prevent link to classes called "A".
       
  1080      */
       
  1081     virtual QCString trLegendDocs()
       
  1082     {
       
  1083       return 
       
  1084         "Tämä sivu selittää, kuinka doxygenin luomia kaavioita tulkitaan.<p>\n"
       
  1085         // "This page explains how to interpret the graphs that are generated "
       
  1086         // "by doxygen.<p>\n"
       
  1087         "Ajattele seuraavaa esimerkkiä:\n"
       
  1088         // "Consider the following example:\n"
       
  1089         "\\code\n"
       
  1090         "/*! Näkymätön luokka katkaisun vuoksi */\n"
       
  1091         // "/*! Invisible class because of truncation */\n"
       
  1092         "class Nakymaton { };\n\n"
       
  1093         // "class Invisible { };\n\n"
       
  1094         "/*! Katkaistu luokka, periytymissuhde on piilotettu */\n"
       
  1095         // "/*! Truncated class, inheritance relation is hidden */\n"
       
  1096         "class Katkaistu : public Nakymaton { };\n\n"
       
  1097         // "class Truncated : public Invisible { };\n\n"
       
  1098         "/* Luokkaa ei ole dokumentoitu doxygen-kommenteilla */\n"
       
  1099         // "/* Class not documented with doxygen comments */\n"
       
  1100         "class Dokumentoimaton { };\n\n"
       
  1101         // "class Undocumented { };\n\n"
       
  1102         "/*! Julkista periyttämistä käyttäen periytetty luokka */\n"
       
  1103         // "/*! Class that is inherited using public inheritance */\n"
       
  1104         "class JulkinenKanta : public Katkaistu { };\n\n"
       
  1105         // "class PublicBase : public Truncated { };\n\n"
       
  1106         "/*! Malliluokka */\n"
       
  1107         // "/*! A template class */\n"
       
  1108         "template<class T> class Malli { };\n\n"
       
  1109         // "template<class T> class Templ { };\n\n"
       
  1110         "/*! Suojeltua periytymistä käyttäen periytetty luokka */\n"
       
  1111         // "/*! Class that is inherited using protected inheritance */\n"
       
  1112         "class SuojeltuKanta { };\n\n"
       
  1113         // "class ProtectedBase { };\n\n"
       
  1114         "/*! Yksityistä periytymistä käyttäen periytetty luokka */\n"
       
  1115         // "/*! Class that is inherited using private inheritance */\n"
       
  1116         "class YksityisKanta { };\n\n"
       
  1117         // "class PrivateBase { };\n\n"
       
  1118         "/*! Luokka jota periytetty luokka käyttää */\n"
       
  1119         // "/*! Class that is used by the Inherited class */\n"
       
  1120         "class Kaytetty { };\n\n"
       
  1121         // "class Used { };\n\n"
       
  1122         "/*! Kantaluokka joka periytyy useasta muusta luokasta */\n"
       
  1123         // "/*! Super class that inherits a number of other classes */\n"
       
  1124         "class Periytetty : public JulkinenKanta,\n"
       
  1125         "                 : protected SuojeltuKanta,\n"
       
  1126         "                 : private YksityisKanta,\n"
       
  1127         "                 : public Dokumentoimaton,\n"
       
  1128         "                 : public Malli<int>\n"
       
  1129         "{\n"
       
  1130         "  private:\n"
       
  1131         "    Kaytetty *m_kaytettyLuokka;\n"
       
  1132         "}\n";
       
  1133         // "class Inherited : public PublicBase,\n"
       
  1134         // "                  protected ProtectedBase,\n"
       
  1135         // "                  private PrivateBase,\n"
       
  1136         // "                  public Undocumented,\n"
       
  1137         // "                  public Templ<int>\n"
       
  1138         // "{\n"
       
  1139         // "  private:\n"
       
  1140         // "    Used *m_usedClass;\n"
       
  1141         // "};\n"
       
  1142         "\\endcode\n"
       
  1143         "Tuloksena on seuraavanlainen kaavio:"
       
  1144         //"This will result in the following graph:"
       
  1145         "<p><center><img alt=\"\" src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
       
  1146         "<p>\n"
       
  1147         "Ylläolevassa kaaviossa laatikoilla on seuraavat merkitykset\n:"
       
  1148         // "The boxes in the above graph have the following meaning:\n"
       
  1149         "<ul>\n"
       
  1150         "<li>Täytetty harmaa laatikko esittää tietuetta tai luokkaa, jolle "
       
  1151         // "<li>%A filled gray box represents the struct or class for which the "
       
  1152         "kaavio on luotu.\n"
       
  1153         // "graph is generated.\n"
       
  1154         "<li>Mustareunainen laatikko merkitsee dokumentoitua tietuetta tai luokkaa.\n"
       
  1155         // "<li>%A box with a black border denotes a documented struct or class.\n"
       
  1156         "<li>Harmaareunainen laatikko merkitsee dokumentoimatonta tietuetta tai luokkaa.\n"
       
  1157         // "<li>%A box with a grey border denotes an undocumented struct or class.\n"
       
  1158         "<li>Punareunainen laatikko merkistee dokumentoitua luokkaa tai structia "
       
  1159         // "<li>%A box with a red border denotes a documented struct or class for"
       
  1160         "jolle ei näytetä kaikkia periytymis-/sisällyssuhteita. Kaavio "
       
  1161         // "which not all inheritance/containment relations are shown. %A graph is "
       
  1162         "katkaistaan, jos se ei mahdu määriteltyjen rajojen sisään.\n"
       
  1163         // "truncated if it does not fit within the specified boundaries.\n"
       
  1164         "</ul>\n"
       
  1165         "Nuolilla on seuraavat merkitykset:\n"
       
  1166         // "The arrows have the following meaning:\n"
       
  1167         "<ul>\n"
       
  1168         "<li>Tummansinistä nuolta käytetään osoittamaan julkista periytymis"
       
  1169         // "<li>%A dark blue arrow is used to visualize a public inheritance "
       
  1170         "suhdetta kahden luokan välillä.\n"
       
  1171         // "relation between two classes.\n"
       
  1172         "<li>Tummanvihreää nuolta käytetään suojellussa periytymisessä.\n"
       
  1173         // "<li>%A dark green arrow is used for protected inheritance.\n"
       
  1174         "<li>Tummanpunaista nuolta käytetään yksityisessä periytymisessä.\n"
       
  1175         // "<li>%A dark red arrow is used for private inheritance.\n"
       
  1176         "<li>Purppuranväristä katkoviivaa käytetään, jos luokka sisältyy tai "
       
  1177         // "<li>%A purple dashed arrow is used if a class is contained or used "
       
  1178         "on toisen luokan käyttämä. Nuoli nimetään sillä muuttujalla/muuttujilla "
       
  1179         // "by another class. The arrow is labeled with the variable(s) "
       
  1180         "jonka läpi osoitettua luokkaa tai tietuetta käytetään.\n"
       
  1181         // "through which the pointed class or struct is accessible.\n"
       
  1182         "<li>Keltainen katkoviivalla piirretty nuoli merkitsee suhdetta mallin esiintymän ja "
       
  1183         // "<li>%A yellow dashed arrow denotes a relation between a template instance and "
       
  1184         "malliluokan välillä. Nuoli nimetään "
       
  1185         // "the template class it was instantiated from. The arrow is labeled with "
       
  1186         "mallin esiintymän malliparametrilla.\n"
       
  1187         // "the template parameters of the instance.\n"
       
  1188         "</ul>\n";
       
  1189     }
       
  1190     /*! text for the link to the legend page */
       
  1191     virtual QCString trLegend()
       
  1192     {
       
  1193       return "selite"; // "legend"
       
  1194     }
       
  1195     
       
  1196 //////////////////////////////////////////////////////////////////////////
       
  1197 // new since 1.2.0
       
  1198 //////////////////////////////////////////////////////////////////////////
       
  1199     
       
  1200     /*! Used as a marker that is put before a test item */
       
  1201     virtual QCString trTest()
       
  1202     {
       
  1203       return "Testi"; // "Test"
       
  1204     }
       
  1205     /*! Used as the header of the test list */
       
  1206     virtual QCString trTestList()
       
  1207     {
       
  1208       return "Testilista"; // "Test List"
       
  1209     }
       
  1210 
       
  1211 //////////////////////////////////////////////////////////////////////////
       
  1212 // new since 1.2.1
       
  1213 //////////////////////////////////////////////////////////////////////////
       
  1214 
       
  1215     /*! Used as a section header for KDE-2 IDL methods */
       
  1216     virtual QCString trDCOPMethods()
       
  1217     {
       
  1218       return "DCOP-jäsenfunktiot"; // "DCOP Member Functions"
       
  1219     }
       
  1220 
       
  1221 //////////////////////////////////////////////////////////////////////////
       
  1222 // new since 1.2.2
       
  1223 //////////////////////////////////////////////////////////////////////////
       
  1224 
       
  1225     /*! Used as a section header for IDL properties */
       
  1226     virtual QCString trProperties()
       
  1227     {
       
  1228       return "Ominaisuudet"; // "Properties"
       
  1229     }
       
  1230     /*! Used as a section header for IDL property documentation */
       
  1231     virtual QCString trPropertyDocumentation()
       
  1232     {
       
  1233       return "Ominaisuuksien dokumentaatio"; // "Property Documentation"
       
  1234     }
       
  1235 
       
  1236 //////////////////////////////////////////////////////////////////////////
       
  1237 // new since 1.2.4
       
  1238 //////////////////////////////////////////////////////////////////////////
       
  1239 
       
  1240     /*! Used for Java classes in the summary section of Java packages */
       
  1241     virtual QCString trClasses()
       
  1242     {
       
  1243       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
       
  1244       {
       
  1245         return "Tietueet"; // "Data Structures"
       
  1246       }
       
  1247       else
       
  1248       {
       
  1249         return "Luokat"; // "Classes"
       
  1250       }
       
  1251     }
       
  1252     /*! Used as the title of a Java package */
       
  1253     virtual QCString trPackage(const char *name)
       
  1254     {
       
  1255       return (QCString)"Paketti "+name; // "Package "
       
  1256     }
       
  1257     /*! Title of the package index page */
       
  1258     virtual QCString trPackageList()
       
  1259     {
       
  1260       return "Pakettilista"; // "Package List"
       
  1261     }
       
  1262     /*! The description of the package index page */
       
  1263     virtual QCString trPackageListDescription()
       
  1264     {
       
  1265       return "Tässä ovat paketit lyhyiden selitysten kanssa (jos saatavilla):"; // "Here are the packages with brief descriptions (if available):"
       
  1266     }
       
  1267     /*! The link name in the Quick links header for each page */
       
  1268     virtual QCString trPackages()
       
  1269     {
       
  1270       return "Paketit"; // "Packages"
       
  1271     }
       
  1272     /*! Text shown before a multi-line define */
       
  1273     virtual QCString trDefineValue()
       
  1274     {
       
  1275       return "Arvo:"; // "Value:"
       
  1276     }
       
  1277     
       
  1278 //////////////////////////////////////////////////////////////////////////
       
  1279 // new since 1.2.5
       
  1280 //////////////////////////////////////////////////////////////////////////
       
  1281     
       
  1282     /*! Used as a marker that is put before a \\bug item */
       
  1283     virtual QCString trBug()
       
  1284     {
       
  1285       return "Bugi"; // "Bug"
       
  1286     }
       
  1287     /*! Used as the header of the bug list */
       
  1288     virtual QCString trBugList()
       
  1289     {
       
  1290       return "Bugilista"; // "Bug List"
       
  1291     }
       
  1292 
       
  1293 //////////////////////////////////////////////////////////////////////////
       
  1294 // new since 1.2.6
       
  1295 //////////////////////////////////////////////////////////////////////////
       
  1296 
       
  1297     /*! Used as ansicpg for RTF file 
       
  1298      * 
       
  1299      * The following table shows the correlation of Charset name, Charset Value and 
       
  1300      * <pre>
       
  1301      * Codepage number:
       
  1302      * Charset Name       Charset Value(hex)  Codepage number
       
  1303      * ------------------------------------------------------
       
  1304      * DEFAULT_CHARSET           1 (x01)
       
  1305      * SYMBOL_CHARSET            2 (x02)
       
  1306      * OEM_CHARSET             255 (xFF)
       
  1307      * ANSI_CHARSET              0 (x00)            1252
       
  1308      * RUSSIAN_CHARSET         204 (xCC)            1251
       
  1309      * EE_CHARSET              238 (xEE)            1250
       
  1310      * GREEK_CHARSET           161 (xA1)            1253
       
  1311      * TURKISH_CHARSET         162 (xA2)            1254
       
  1312      * BALTIC_CHARSET          186 (xBA)            1257
       
  1313      * HEBREW_CHARSET          177 (xB1)            1255
       
  1314      * ARABIC _CHARSET         178 (xB2)            1256
       
  1315      * SHIFTJIS_CHARSET        128 (x80)             932
       
  1316      * HANGEUL_CHARSET         129 (x81)             949
       
  1317      * GB2313_CHARSET          134 (x86)             936
       
  1318      * CHINESEBIG5_CHARSET     136 (x88)             950
       
  1319      * </pre>
       
  1320      * 
       
  1321      */
       
  1322     virtual QCString trRTFansicp()
       
  1323     {
       
  1324       return "1252";
       
  1325     }
       
  1326     
       
  1327 
       
  1328     /*! Used as ansicpg for RTF fcharset 
       
  1329      *  \see trRTFansicp() for a table of possible values.
       
  1330      */
       
  1331     virtual QCString trRTFCharSet()
       
  1332     {
       
  1333       return "0";
       
  1334     }
       
  1335 
       
  1336     /*! Used as header RTF general index */
       
  1337     virtual QCString trRTFGeneralIndex()
       
  1338     {
       
  1339       return "Hakemisto"; // "Index"
       
  1340     }
       
  1341    
       
  1342     /*! This is used for translation of the word that will possibly
       
  1343      *  be followed by a single name or by a list of names 
       
  1344      *  of the category.
       
  1345      */
       
  1346     virtual QCString trClass(bool first_capital, bool singular)
       
  1347     { 
       
  1348       QCString result((first_capital ? "Luokka" : "luokka")); // "Class" / "class"
       
  1349       if (!singular)  result=(first_capital ? "Luokat" : "luokat"); // "+es" -> "Classes" / "classes"
       
  1350       return result; 
       
  1351     }
       
  1352 
       
  1353     /*! This is used for translation of the word that will possibly
       
  1354      *  be followed by a single name or by a list of names 
       
  1355      *  of the category.
       
  1356      */
       
  1357     virtual QCString trFile(bool first_capital, bool singular)
       
  1358     { 
       
  1359       QCString result((first_capital ? "Tiedosto" : "tiedosto")); // "File" / "file"
       
  1360       if (!singular)  result+="t"; // "+s" -> "Files" / "files"
       
  1361       return result; 
       
  1362     }
       
  1363 
       
  1364     /*! This is used for translation of the word that will possibly
       
  1365      *  be followed by a single name or by a list of names 
       
  1366      *  of the category.
       
  1367      */
       
  1368     virtual QCString trNamespace(bool first_capital, bool singular)
       
  1369     { 
       
  1370       QCString result((first_capital ? "Nimiavaruus" : "nimiavaruus")); // "Namespace" / "namespace"
       
  1371       if (!singular)  result=(first_capital ? "Nimiavaruudet" : "nimiavaruudet"); // "+s"
       
  1372       return result; 
       
  1373     }
       
  1374 
       
  1375     /*! This is used for translation of the word that will possibly
       
  1376      *  be followed by a single name or by a list of names 
       
  1377      *  of the category.
       
  1378      */
       
  1379     virtual QCString trGroup(bool first_capital, bool singular)
       
  1380     { 
       
  1381       QCString result((first_capital ? "Ryhmä" : "ryhmä")); // "Group" / "group"
       
  1382       if (!singular)  result+="t"; // "+s"
       
  1383       return result; 
       
  1384     }
       
  1385 
       
  1386     /*! This is used for translation of the word that will possibly
       
  1387      *  be followed by a single name or by a list of names 
       
  1388      *  of the category.
       
  1389      */
       
  1390     virtual QCString trPage(bool first_capital, bool singular)
       
  1391     { 
       
  1392       QCString result((first_capital ? "Sivu" : "sivu")); // "Page" / "page"
       
  1393       if (!singular)  result+="t"; // "+s"
       
  1394       return result; 
       
  1395     }
       
  1396 
       
  1397     /*! This is used for translation of the word that will possibly
       
  1398      *  be followed by a single name or by a list of names 
       
  1399      *  of the category.
       
  1400      */
       
  1401     virtual QCString trMember(bool first_capital, bool singular)
       
  1402     { 
       
  1403       QCString result((first_capital ? "Jäsen" : "jäsen")); // "Member" / "member"
       
  1404       if (!singular)  result+="et"; // "+s"
       
  1405       return result; 
       
  1406     }
       
  1407    
       
  1408     /*! This is used for translation of the word that will possibly
       
  1409      *  be followed by a single name or by a list of names 
       
  1410      *  of the category.
       
  1411      */
       
  1412     virtual QCString trGlobal(bool first_capital, bool singular)
       
  1413     { 
       
  1414       QCString result((first_capital ? "Globaali" : "globaali")); // "Global" / "global"
       
  1415       if (!singular)  result+="t"; // "+s"
       
  1416       return result; 
       
  1417     }
       
  1418 
       
  1419 //////////////////////////////////////////////////////////////////////////
       
  1420 // new since 1.2.7
       
  1421 //////////////////////////////////////////////////////////////////////////
       
  1422 
       
  1423     /*! This text is generated when the \\author command is used and
       
  1424      *  for the author section in man pages. */
       
  1425     virtual QCString trAuthor(bool first_capital, bool singular)
       
  1426     {                                                                         
       
  1427       QCString result((first_capital ? "Tekijä" : "tekijä")); // "Author" / "author"
       
  1428       if (!singular)  result+="t"; // "+s"
       
  1429       return result; 
       
  1430     }
       
  1431 
       
  1432 //////////////////////////////////////////////////////////////////////////
       
  1433 // new since 1.2.11
       
  1434 //////////////////////////////////////////////////////////////////////////
       
  1435 
       
  1436     /*! This text is put before the list of members referenced by a member
       
  1437      */
       
  1438     virtual QCString trReferences()
       
  1439     {
       
  1440       return "Viittaukset"; // "References"
       
  1441     }
       
  1442 
       
  1443 //////////////////////////////////////////////////////////////////////////
       
  1444 // new since 1.2.13
       
  1445 //////////////////////////////////////////////////////////////////////////
       
  1446 
       
  1447     /*! used in member documentation blocks to produce a list of 
       
  1448      *  members that are implemented by this one.
       
  1449      */
       
  1450     virtual QCString trImplementedFromList(int numEntries)
       
  1451     {
       
  1452       return "Toteuttaa luokan "+trWriteList(numEntries)+"."; // "Implements "
       
  1453     }
       
  1454 
       
  1455     /*! used in member documentation blocks to produce a list of
       
  1456      *  all members that implement this abstract member.
       
  1457      */
       
  1458     virtual QCString trImplementedInList(int numEntries)
       
  1459     {
       
  1460       return "Toteutettu luokassa "+trWriteList(numEntries)+"."; // "Implemented in "
       
  1461     }
       
  1462 
       
  1463 //////////////////////////////////////////////////////////////////////////
       
  1464 // new since 1.2.16
       
  1465 //////////////////////////////////////////////////////////////////////////
       
  1466 
       
  1467     /*! used in RTF documentation as a heading for the Table
       
  1468      *  of Contents.
       
  1469      */
       
  1470     virtual QCString trRTFTableOfContents()
       
  1471     {
       
  1472       return "Sisällysluettelo"; // "Table of Contents"
       
  1473     }
       
  1474 
       
  1475 //////////////////////////////////////////////////////////////////////////
       
  1476 // new since 1.2.17
       
  1477 //////////////////////////////////////////////////////////////////////////
       
  1478 
       
  1479     /*! Used as the header of the list of item that have been 
       
  1480      *  flagged deprecated 
       
  1481      */
       
  1482     virtual QCString trDeprecatedList()
       
  1483     {
       
  1484       return "Vanhentuneiden lista"; // "Deprecated List"
       
  1485     }
       
  1486 
       
  1487 //////////////////////////////////////////////////////////////////////////
       
  1488 // new since 1.2.18
       
  1489 //////////////////////////////////////////////////////////////////////////
       
  1490 
       
  1491     /*! Used as a header for declaration section of the events found in 
       
  1492      * a C# program
       
  1493      */
       
  1494     virtual QCString trEvents()
       
  1495     {
       
  1496       return "Tapahtumat"; // "Events"
       
  1497     }
       
  1498     /*! Header used for the documentation section of a class' events. */
       
  1499     virtual QCString trEventDocumentation()
       
  1500     {
       
  1501       return "Tapahtumien dokumentaatio"; // "Event Documentation"
       
  1502     }
       
  1503 
       
  1504 //////////////////////////////////////////////////////////////////////////
       
  1505 // new since 1.3
       
  1506 //////////////////////////////////////////////////////////////////////////
       
  1507 
       
  1508     /*! Used as a heading for a list of Java class types with package scope.
       
  1509      */
       
  1510     virtual QCString trPackageTypes()
       
  1511     { 
       
  1512       return "Paketin tyypit"; // "Package Types"
       
  1513     }
       
  1514     /*! Used as a heading for a list of Java class functions with package 
       
  1515      * scope. 
       
  1516      */
       
  1517     virtual QCString trPackageMembers()
       
  1518     { 
       
  1519       return "Paketin funktiot"; // "Package Functions"
       
  1520     }
       
  1521     /*! Used as a heading for a list of static Java class functions with 
       
  1522      *  package scope.
       
  1523      */
       
  1524     virtual QCString trStaticPackageMembers()
       
  1525     { 
       
  1526       return "Paketin staattiset funktiot"; // "Static Package Functions"
       
  1527     }
       
  1528     /*! Used as a heading for a list of Java class variables with package 
       
  1529      * scope.
       
  1530      */
       
  1531     virtual QCString trPackageAttribs()
       
  1532     { 
       
  1533       return "Paketin attribuutit"; // "Package Attributes"
       
  1534     }
       
  1535     /*! Used as a heading for a list of static Java class variables with 
       
  1536      * package scope.
       
  1537      */
       
  1538     virtual QCString trStaticPackageAttribs()
       
  1539     { 
       
  1540       return "Paketin staattiset attribuutit"; // "Static Package Attributes"
       
  1541     }
       
  1542     
       
  1543 //////////////////////////////////////////////////////////////////////////
       
  1544 // new since 1.3.1
       
  1545 //////////////////////////////////////////////////////////////////////////
       
  1546 
       
  1547     /*! Used in the quick index of a class/file/namespace member list page 
       
  1548      *  to link to the unfiltered list of all members.
       
  1549      */
       
  1550     virtual QCString trAll()
       
  1551     {
       
  1552       return "Kaikki"; // "All"
       
  1553     }
       
  1554     /*! Put in front of the call graph for a function. */
       
  1555     virtual QCString trCallGraph()
       
  1556     {
       
  1557       return "Tässä on kutsukaavio tälle funktiolle:"; // "Here is the call graph for this function:"
       
  1558     }
       
  1559 
       
  1560 //////////////////////////////////////////////////////////////////////////
       
  1561 // new since 1.3.3
       
  1562 //////////////////////////////////////////////////////////////////////////
       
  1563 
       
  1564     /*! When the search engine is enabled this text is put in the header 
       
  1565      *  of each page before the field where one can enter the text to search 
       
  1566      *  for. 
       
  1567      */
       
  1568     virtual QCString trSearchForIndex()
       
  1569     {
       
  1570       return "Etsi"; // "Search for"
       
  1571     }
       
  1572     /*! This string is used as the title for the page listing the search
       
  1573      *  results.
       
  1574      */
       
  1575     virtual QCString trSearchResultsTitle()
       
  1576     {
       
  1577       return "Hakutulokset"; // "Search Results"
       
  1578     }
       
  1579     /*! This string is put just before listing the search results. The
       
  1580      *  text can be different depending on the number of documents found.
       
  1581      *  Inside the text you can put the special marker $num to insert
       
  1582      *  the number representing the actual number of search results.
       
  1583      *  The @a numDocuments parameter can be either 0, 1 or 2, where the 
       
  1584      *  value 2 represents 2 or more matches. HTML markup is allowed inside
       
  1585      *  the returned string.
       
  1586      */
       
  1587     virtual QCString trSearchResults(int numDocuments)
       
  1588     {
       
  1589       if (numDocuments==0)
       
  1590       {
       
  1591         return "Valitettavasti yksikään dokumentti ei vastannut hakuasi."; // "Sorry, no documents matching your query."
       
  1592       }
       
  1593       else if (numDocuments==1)
       
  1594       {
       
  1595         return "Löytyi <b>1</b> dokumentti, joka vastasi hakuasi."; // "Found <b>1</b> document matching your query.";
       
  1596       }
       
  1597       else 
       
  1598       {
       
  1599         return "Löytyi <b>$num</b> dokumenttia, jotka vastasivat hakuasi. " // "Found <b>$num</b> documents matching your query. "
       
  1600                 "Parhaat tulokset näytetään ensin."; // "Showing best matches first."
       
  1601       }
       
  1602     }
       
  1603     /*! This string is put before the list of matched words, for each search 
       
  1604      *  result. What follows is the list of words that matched the query.
       
  1605      */
       
  1606     virtual QCString trSearchMatches()
       
  1607     {
       
  1608       return "Osumat:"; // "Matches:"
       
  1609     }
       
  1610 
       
  1611 //////////////////////////////////////////////////////////////////////////
       
  1612 // new since 1.3.8
       
  1613 //////////////////////////////////////////////////////////////////////////
       
  1614 
       
  1615     /*! This is used in HTML as the title of page with source code for file filename
       
  1616      */
       
  1617     virtual QCString trSourceFile(QCString& filename)
       
  1618     {
       
  1619       return filename + " lähdekooditiedosto"; // " Source File"
       
  1620     }
       
  1621 
       
  1622 //////////////////////////////////////////////////////////////////////////
       
  1623 // new since 1.3.9
       
  1624 //////////////////////////////////////////////////////////////////////////
       
  1625 
       
  1626     /*! This is used as the name of the chapter containing the directory
       
  1627      *  hierarchy.
       
  1628      */
       
  1629     virtual QCString trDirIndex()
       
  1630     { return "Hakemistohierarkia"; } // "Directory Hierarchy"
       
  1631 
       
  1632     /*! This is used as the name of the chapter containing the documentation
       
  1633      *  of the directories.
       
  1634      */
       
  1635     virtual QCString trDirDocumentation()
       
  1636     { return "Hakemistojen dokumentaatio"; } // "Directory Documentation"
       
  1637 
       
  1638     /*! This is used as the title of the directory index and also in the
       
  1639      *  Quick links of an HTML page, to link to the directory hierarchy.
       
  1640      */
       
  1641     virtual QCString trDirectories()
       
  1642     { return "Hakemistot"; } // "Directories"
       
  1643 
       
  1644     /*! This returns a sentences that introduces the directory hierarchy. 
       
  1645      *  and the fact that it is sorted alphabetically per level
       
  1646      */
       
  1647     virtual QCString trDirDescription()
       
  1648     { return "Tämä hakemistohierarkia on järjestetty aakkosellisesti tasoittain:";
       
  1649              //This directory hierarchy is sorted roughly, "
       
  1650              // "but not completely, alphabetically:";
       
  1651     }
       
  1652 
       
  1653     /*! This returns the title of a directory page. The name of the
       
  1654      *  directory is passed via \a dirName.
       
  1655      */
       
  1656     virtual QCString trDirReference(const char *dirName)
       
  1657     { QCString result=dirName; result+=" hakemistoreferenssi"; return result; }
       
  1658         // " Directory Reference"
       
  1659 
       
  1660     /*! This returns the word directory with or without starting capital
       
  1661      *  (\a first_capital) and in sigular or plural form (\a singular).
       
  1662      */
       
  1663     virtual QCString trDir(bool first_capital, bool singular)
       
  1664     { 
       
  1665       QCString result((first_capital ? "Hakemisto" : "hakemisto")); // "Director" / "director"
       
  1666       if (singular) result+=""; else result+="t"; // "+y" / "+ies"
       
  1667       return result; 
       
  1668     }
       
  1669 
       
  1670 //////////////////////////////////////////////////////////////////////////
       
  1671 // new since 1.4.1
       
  1672 //////////////////////////////////////////////////////////////////////////
       
  1673 
       
  1674     /*! This text is added to the documentation when the \\overload command
       
  1675      *  is used for a overloaded function.
       
  1676      */
       
  1677     virtual QCString trOverloadText()
       
  1678     {
       
  1679        return "Tämä on ylikuormitettu jäsenfunktio, ja se tarjotaan "
       
  1680               "käytön helpottamiseksi. Se eroaa ylläolevasta "
       
  1681               "funktiosta ainoastaan hyväksymiltään parametreilta.";
       
  1682               // "This is an overloaded member function, "
       
  1683               // "provided for convenience. It differs from the above "
       
  1684               // "function only in what argument(s) it accepts."
       
  1685     }
       
  1686 
       
  1687 //////////////////////////////////////////////////////////////////////////
       
  1688 // new since 1.4.6
       
  1689 //////////////////////////////////////////////////////////////////////////
       
  1690 
       
  1691     /*! This is used to introduce a caller (or called-by) graph */
       
  1692     virtual QCString trCallerGraph()
       
  1693     {
       
  1694       return "Tässä on kutsukaavio tälle funktiolle:"; // "Here is the caller graph for this function:"
       
  1695     }
       
  1696 
       
  1697     /*! This is used in the documentation of a file/namespace before the list 
       
  1698      *  of documentation blocks for enumeration values
       
  1699      */
       
  1700     virtual QCString trEnumerationValueDocumentation()
       
  1701     { return "Luettelotyypin dokumentaatio"; } // "Enumerator Documentation"
       
  1702 
       
  1703 //////////////////////////////////////////////////////////////////////////
       
  1704 // new since 1.5.4 (mainly for Fortran)
       
  1705 //////////////////////////////////////////////////////////////////////////
       
  1706     
       
  1707     /*! header that is put before the list of member subprograms (Fortran). */
       
  1708     virtual QCString trMemberFunctionDocumentationFortran()
       
  1709     { return "Jäsenfunktioiden/aliohjelmien dokumentaatio"; } // "Member Function/Subroutine Documentation"
       
  1710 
       
  1711     /*! This is put above each page as a link to the list of annotated data types (Fortran). */    
       
  1712     virtual QCString trCompoundListFortran()
       
  1713     { return "Tietotyyppien lista"; } // "Data Types List"
       
  1714 
       
  1715     /*! This is put above each page as a link to all members of compounds (Fortran). */
       
  1716     virtual QCString trCompoundMembersFortran()
       
  1717     { return "Kentät"; } // "Data Fields";
       
  1718 
       
  1719     /*! This is an introduction to the annotated compound list (Fortran). */
       
  1720     virtual QCString trCompoundListDescriptionFortran()
       
  1721     { return "Tässä ovat tietotyypit lyhyiden selitysten kanssa:"; } // "Here are the data types with brief descriptions:"
       
  1722 
       
  1723     /*! This is an introduction to the page with all data types (Fortran). */
       
  1724     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
       
  1725     {
       
  1726       QCString result="Tässä on lista kaikista "; // "Here is a list of all "
       
  1727       if (!extractAll)
       
  1728       {
       
  1729         result+="dokumentoiduista "; // "documented "
       
  1730       }
       
  1731       result+="tietotyyppien jäsenistä"; // "data types members"
       
  1732       result+=", sekä linkit "; // " with links to "
       
  1733       if (!extractAll) 
       
  1734       {
       
  1735          result+="tietueen dokumentaatioon jokaiselle jäsenelle"; // "the data structure documentation for each member"
       
  1736       }
       
  1737       else 
       
  1738       {
       
  1739          result+="tietotyyppeihin, joihin ne kuuluvat:"; // "the data types they belong to:"
       
  1740       }
       
  1741       return result;
       
  1742     }
       
  1743 
       
  1744     /*! This is used in LaTeX as the title of the chapter with the 
       
  1745      * annotated compound index (Fortran).
       
  1746      */
       
  1747     virtual QCString trCompoundIndexFortran()
       
  1748     { return "Tietotyyppien hakemisto"; } // "Data Type Index"
       
  1749 
       
  1750     /*! This is used in LaTeX as the title of the chapter containing
       
  1751      *  the documentation of all data types (Fortran).
       
  1752      */
       
  1753     virtual QCString trTypeDocumentation()
       
  1754     { return "Tietotyyppien dokumentaatio"; } // "Data Type Documentation"
       
  1755 
       
  1756     /*! This is used in the documentation of a file as a header before the 
       
  1757      *  list of (global) subprograms (Fortran).
       
  1758      */
       
  1759     virtual QCString trSubprograms()
       
  1760     { return "Funktiot/aliohjelmat"; } // "Functions/Subroutines"
       
  1761 
       
  1762     /*! This is used in the documentation of a file/namespace before the list 
       
  1763      *  of documentation blocks for subprograms (Fortran)
       
  1764      */
       
  1765     virtual QCString trSubprogramDocumentation()
       
  1766     { return "Funktioiden/aliohjelmien dokumentaatio"; } // "Function/Subroutine Documentation"
       
  1767 
       
  1768     /*! This is used in the documentation of a file/namespace/group before 
       
  1769      *  the list of links to documented compounds (Fortran)
       
  1770      */
       
  1771      virtual QCString trDataTypes()
       
  1772     { return "Tietotyypit"; } // "Data Types"
       
  1773     
       
  1774     /*! used as the title of page containing all the index of all modules (Fortran). */
       
  1775     virtual QCString trModulesList()
       
  1776     { return "Moduulilista"; } // "Modules List"
       
  1777 
       
  1778     /*! used as an introduction to the modules list (Fortran) */
       
  1779     virtual QCString trModulesListDescription(bool extractAll)
       
  1780     {
       
  1781       QCString result="Tässä on lista kaikista "; // "Here is a list of all "
       
  1782       if (!extractAll) result+="dokumentoiduista "; // "documented "
       
  1783       result+="moduuleista lyhyiden selitysten kanssa:"; // "modules with brief descriptions:"
       
  1784       return result;
       
  1785     }
       
  1786 
       
  1787     /*! used as the title of the HTML page of a module/type (Fortran) */
       
  1788     virtual QCString trCompoundReferenceFortran(const char *clName,
       
  1789                                     ClassDef::CompoundType compType,
       
  1790                                     bool isTemplate)
       
  1791     {
       
  1792       QCString result=(QCString)clName;
       
  1793       switch(compType)
       
  1794       {
       
  1795         case ClassDef::Class:      result+=" moduuli"; break; // " Module"
       
  1796         case ClassDef::Struct:     result+=" tyyppi"; break; // " Type"
       
  1797         case ClassDef::Union:      result+=" yhdiste"; break; // " Union"
       
  1798         case ClassDef::Interface:  result+=" rajapinta"; break; // " Interface"
       
  1799         case ClassDef::Protocol:   result+=" protokolla"; break; // " Protocol"
       
  1800         case ClassDef::Category:   result+=" kategoria"; break; // " Category"
       
  1801         case ClassDef::Exception:  result+=" poikkeus"; break; // " Exception"
       
  1802       }
       
  1803       if (isTemplate) result+="malli"; // " Template"
       
  1804       result+="referenssi"; // " Reference"
       
  1805       return result;
       
  1806     }
       
  1807     /*! used as the title of the HTML page of a module (Fortran) */
       
  1808     virtual QCString trModuleReference(const char *namespaceName)
       
  1809     {
       
  1810       QCString result=namespaceName;
       
  1811       result+=" moduulin referenssi"; // " Module Reference"
       
  1812       return result;
       
  1813     }
       
  1814     
       
  1815     /*! This is put above each page as a link to all members of modules. (Fortran) */
       
  1816     virtual QCString trModulesMembers()
       
  1817     { return "Moduulin jäsenet"; } // "Module Members"
       
  1818 
       
  1819     /*! This is an introduction to the page with all modules members (Fortran) */
       
  1820     virtual QCString trModulesMemberDescription(bool extractAll)
       
  1821     { 
       
  1822       QCString result="Tässä on lista moduulin kaikista "; // "Here is a list of all "
       
  1823       if (!extractAll) result+="dokumentoiduista"; // "documented "
       
  1824       result+="jäsenistä, sekä linkit "; // "module members with links to "
       
  1825       if (extractAll) 
       
  1826       {
       
  1827         result+="moduulin dokumentaatioon jokaiselle jäsenelle:"; // "the module documentation for each member:"
       
  1828       }
       
  1829       else 
       
  1830       {
       
  1831         result+="moduuleihin, joihin ne kuuluvat:"; // "the modules they belong to:"
       
  1832       }
       
  1833       return result;
       
  1834     }
       
  1835 
       
  1836     /*! This is used in LaTeX as the title of the chapter with the 
       
  1837      *  index of all modules (Fortran).
       
  1838      */
       
  1839     virtual QCString trModulesIndex()
       
  1840     { return "Moduulien hakemisto"; } // "Modules Index"
       
  1841     
       
  1842     /*! This is used for translation of the word that will possibly
       
  1843      *  be followed by a single name or by a list of names 
       
  1844      *  of the category.
       
  1845      */
       
  1846     virtual QCString trModule(bool first_capital, bool singular)
       
  1847     {       
       
  1848       QCString result((first_capital ? "Moduuli" : "moduuli")); // "Module" / "module"
       
  1849       if (!singular)  result+="t"; // "+s"
       
  1850       return result; 
       
  1851     }
       
  1852     /*! This is put at the bottom of a module documentation page and is
       
  1853      *  followed by a list of files that were used to generate the page.
       
  1854      */
       
  1855     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
       
  1856         bool single)
       
  1857     { // here s is one of " Module", " Struct" or " Union"
       
  1858       // single is true implies a single file
       
  1859       QCString result=(QCString)"Dokumentaatio tälle "; // "The documentation for this "
       
  1860       switch(compType)
       
  1861       {
       
  1862         case ClassDef::Class:      result+="moduulille"; break; // "module"
       
  1863         case ClassDef::Struct:     result+="tyypille"; break; // "type"
       
  1864         case ClassDef::Union:      result+="yhdisteelle"; break; // "union"
       
  1865         case ClassDef::Interface:  result+="rajapinnalle"; break; // "interface"
       
  1866         case ClassDef::Protocol:   result+="protokollalle"; break; // "protocol"
       
  1867         case ClassDef::Category:   result+="kategorialle"; break; // "category"
       
  1868         case ClassDef::Exception:  result+="poikkeukselle"; break; // "exception"
       
  1869       }
       
  1870       result+=" luotiin "; // " was generated from the following file"
       
  1871       if (single) result+="seuraavasta tiedostosta:"; else result+="seuraavista tiedostoista:"; // ":" / "s:"
       
  1872       return result;
       
  1873     }
       
  1874     /*! This is used for translation of the word that will possibly
       
  1875      *  be followed by a single name or by a list of names 
       
  1876      *  of the category.
       
  1877      */
       
  1878     virtual QCString trType(bool first_capital, bool singular)
       
  1879     { 
       
  1880       QCString result((first_capital ? "Tyyppi" : "tyyppi")); // "Type" / "type"
       
  1881       if (!singular)  result=(first_capital ? "Tyypit" : "tyypit"); // "+s"
       
  1882       return result; 
       
  1883     }
       
  1884     /*! This is used for translation of the word that will possibly
       
  1885      *  be followed by a single name or by a list of names 
       
  1886      *  of the category.
       
  1887      */
       
  1888     virtual QCString trSubprogram(bool first_capital, bool singular)
       
  1889     { 
       
  1890       QCString result((first_capital ? "Aliohjelma" : "aliohjelma")); // "Subprogram" / "subprogram"
       
  1891       if (!singular)  result+="t"; // "+s"
       
  1892       return result; 
       
  1893     }
       
  1894 
       
  1895     /*! C# Type Constraint list */
       
  1896     virtual QCString trTypeConstraints()
       
  1897     {
       
  1898       return "Tyyppien rajoitteet"; // "Type Constraints"
       
  1899     }
       
  1900 
       
  1901 };
       
  1902 
       
  1903 #endif