translator_dk.h

Go to the documentation of this file.

/*-*- c-basic-offset: 2; tab-width: 8 -*-*/
/******************************************************************************
 *
 *
 *
 * Copyright (C) 1997-2008 by Dimitri van Heesch.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation under the terms of the GNU General Public License is hereby
 * granted. No representations are made about the suitability of this software
 * for any purpose. It is provided "as is" without express or implied warranty.
 * See the GNU General Public License for more details.
 *
 * Documents produced by Doxygen are derivative works derived from the
 * input used in their production; they are not affected by this license.
 *
 */

/*
 * Danish translation by
 * Erik S�e S�rensen <eriksoe@daimi.au.dk>
 *
 * First version (not complete) for Doxygen 1.2.7
 * Extended and revised for Doxygen 1.3
 * Extended and revised for Doxygen 1.3.4
 * Extended and revised for Doxygen 1.3.8
 */

/*  Translator's notes:

        Overs�ttelseskonventioner:
        (Konventioner for konventioner:
          '?'    angiver overs�ttelser, jeg har v�ret i tvivl om
          '??'   angiver tvivlsomme overs�ttelser
          '..?'  angiver ord, der endnu ikke er fundet en overs�ttelse til
          '(do.)' angiver ord, der med vilje ikke er oversat, idet jeg selv
             overvejende bruger det engelske udtryk
          '(-> _)' angiver ord, der er fundet en overs�ttelse til, men som jeg
                v�grer mig ved at overs�tte.
          'KLID:_' angiver ord, hvor jeg med overl�g har rettet mig efter
                KLID.dk's overs�ttelsesguide (enig eller ej).
        )
        bug -> 'kendt fejl'
        class -> klasse
        compound -> 'sammensat type'
        constructor -> konstrukt�r ?
        destructor -> destrukt�r ?
        directory -> KLID:katalog (kunne ogs� v�re 'bibliotek','mappe','folder')
        event -> begivenhed ?
        exception (-> undtagelse ?)
        friend ..?
        interface -> gr�nseflade ?
        member -> medlem (TODO)
        namespace -> (do.)
        overloaded -> KLID:overdefineret
        private -> privat
        property -> egenskab?
        protected -> beskyttet ??
        public -> offentlig
        reference(vb) -> "indeholde referencer til" (?)
        slot ..?
        source code -> kildekode
        struct -> datastruktur
        template (-> skabelon ?)
        typedef -> typedefinition (?)
        todo -> (do.)
        union ..?

        Specielle forbindelser:
        'Inheritance diagram' -> Stamtr�  (selvom Nedarvningsdiagram ogs� gik an)
        

        -----

        (Konstruktivt) input modtages med gl�de!
        -- Erik S�e S�rensen <eriksoe@daimi.au.dk>
 */

#ifndef TRANSLATOR_DK_H
#define TRANSLATOR_DK_H

class TranslatorDanish : public TranslatorAdapter_1_5_4
{
  public:

    // --- Language control methods -------------------

    virtual QCString idLanguage()
    { return "danish"; }

    virtual QCString latexLanguageSupportCommand()
    {
      return
        "\\usepackage[danish]{babel}\n"
        "\\usepackage[T1]{fontenc}\n";
    }

    virtual QCString idLanguageCharset()
    {
      return "iso-8859-1";
    }

    // --- Language translation methods -------------------

    virtual QCString trRelatedFunctions()
    { return "Relaterede funktioner"; }

    virtual QCString trRelatedSubscript()
    { return "(Bem�rk at disse ikke er medlems-funktioner.)"; }

    virtual QCString trDetailedDescription()
    { return "Detaljeret beskrivelse"; }

    virtual QCString trMemberTypedefDocumentation()
    { return "Dokumentation af medlems-typedefinitioner"; }

    virtual QCString trMemberEnumerationDocumentation()
    { return "Dokumentation af medlems-enumerationer"; }
        // medlems-enumerationer -> 'indeholdte enumerationer'

    virtual QCString trMemberFunctionDocumentation()
    { return "Dokumentation af medlemsfunktioner"; }

    virtual QCString trMemberDataDocumentation()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Felt-dokumentation";
      } else {
        return "Dokumentation af feltvariable";
      }
    }

    virtual QCString trMore()
    { return "Mere..."; }

    virtual QCString trListOfAllMembers()
    { return "Liste over alle medlemmer."; }

    virtual QCString trMemberList()
    { return "Liste over medlemmer"; }

    virtual QCString trThisIsTheListOfAllMembers()
    { return "Dette er den komplette liste over medlemmer i "; }

    virtual QCString trIncludingInheritedMembers()
    { return ", inklusive alle nedarvede medlemmer."; }

    virtual QCString trGeneratedAutomatically(const char *s)
    { QCString result="Automatisk genereret af Doxygen";
      if (s) result+=(QCString)" for "+s;
      result+=" ud fra kildekoden.";
      return result;
    }

    virtual QCString trEnumName()
    { return "enumerationsnavn"; }

    virtual QCString trEnumValue()
    { return "enumerationsv�rdi"; }

    virtual QCString trDefinedIn()
    { return "defineret i"; }

    // quick reference sections

    virtual QCString trModules()
    { return "Moduler"; }

    virtual QCString trClassHierarchy()
    { return "Klassehierarki"; }

    virtual QCString trCompoundList()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Datastrukturer";
      } else {
        return "Oversigt over sammensatte typer";
      }
    }

    virtual QCString trFileList()
    { return "Filoversigt"; }

    virtual QCString trCompoundMembers()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Data-felter";
      } else {
        return "Felter i sammensatte typer";
      }
    }

    virtual QCString trFileMembers()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Globale symboler";
      } else {
        return "Placering i filer"; // Fil-medlemmer"; //TODO
        //"Globale definitioner" ?
      }
    }

    virtual QCString trRelatedPages()
    { return "Relaterede sider"; }

    virtual QCString trExamples()
    { return "Eksempler"; }

    virtual QCString trSearch()
    { return "S�g"; }

    virtual QCString trClassHierarchyDescription()
    { return "Denne nedarvningsliste er sorteret n�sten - "
             "men ikke n�dvendigvis helt - alfabetisk:";
    }

    virtual QCString trFileListDescription(bool extractAll)
    {
      QCString result="Her er en liste over alle ";
      if (!extractAll) result+="dokumenterede ";
      result+="filer med korte beskrivelser:";
      return result;
    }

    virtual QCString trCompoundListDescription()
    {

      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Her er datastrukturerne med korte beskrivelser:";
      } else {
        return "Her er klasserne, datastrukturerne, "
               "unionerne og gr�nsefladerne med korte beskrivelser:";
      }
    }

    virtual QCString trCompoundMembersDescription(bool extractAll)
    {
      QCString result="Her er en liste over alle ";
      if (!extractAll) {
        result+="dokumenterede ";
      }
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        result+="felter i datastrukturer og unioner";
      } else {
        result+="klassemedlemmer";
      }
      result+=" med links til ";
      if (!extractAll) {
        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
          result+="datastruktur/unions-dokumentationen for hvert felt:";
        } else {
          result+="klassedokumentationen for hvert medlem:";
        }
      } else {
        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
          result+="de datastrukturer/unioner, de h�rer til:";
        } else {
          result+="de klasser, de h�rer til:";
        }
      }
      return result;
    }

    virtual QCString trFileMembersDescription(bool extractAll)
    {
      QCString result="Her er en liste over alle ";
      if (!extractAll) result+="dokumenterede ";

      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        result+="funktioner, variable, #defines, enumerationer "
            "og typedefinitioner";
      } else {
        result+="fil-medlemmer";
      }
      result+=", med links til ";
      if (extractAll)
        result+="de filer, de tilh�rer:";
      else
        result+="deres dokumentation:";
      return result;
    }

    virtual QCString trExamplesDescription()
    { return "Her er en liste over alle eksempler:"; }

    virtual QCString trRelatedPagesDescription()
    { return "Her er en liste over alle relaterede dokumentationssider:"; }

    virtual QCString trModulesDescription()
    { return "Her er en liste over alle moduler:"; }

    virtual QCString trDocumentation()
    { return "Dokumentation"; }

    virtual QCString trModuleIndex()
    { return "Modul-indeks"; }

    virtual QCString trHierarchicalIndex()
    { return "Hierarkisk indeks"; }

    virtual QCString trCompoundIndex()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Indeks over datastrukturer";
      } else {
        return "Indeks over sammensatte typer";
      }
    }

    virtual QCString trFileIndex()
    { return "Fil-indeks"; }

    virtual QCString trModuleDocumentation()
    { return "Modul-dokumentation"; }

    virtual QCString trClassDocumentation()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Datastruktur-documentation";
      } else {
        return "Klasse-dokumentation";
      }
    }

    virtual QCString trFileDocumentation()
    { return "Fil-dokumentation"; }

    virtual QCString trExampleDocumentation()
    { return "Eksempel-dokumentation"; }

    virtual QCString trPageDocumentation()
    { return "Side-dokumentation"; }

    virtual QCString trReferenceManual()
    { return "Referencemanual"; }

    virtual QCString trDefines()
    { return "#Defines"; }

    virtual QCString trFuncProtos()
    { return "Funktionsprototyper"; }

    virtual QCString trTypedefs()
    { return "Typedefinitioner"; }

    virtual QCString trEnumerations()
    { return "Enumerationer"; }

    virtual QCString trFunctions()
    { return "Funktioner"; }

    virtual QCString trVariables()
    { return "Variable"; }

    virtual QCString trEnumerationValues()
    { return "Enumerationsv�rdier"; }

    virtual QCString trDefineDocumentation()
    { return "#Define-dokumentation"; }

    virtual QCString trFunctionPrototypeDocumentation()
    { return "Dokumentation af funktionsprototyper"; }

    virtual QCString trTypedefDocumentation()
    { return "Dokumentation af typedefinitioner"; }

    virtual QCString trEnumerationTypeDocumentation()
    { return "Dokumentation af enumerations-typer"; }

    virtual QCString trEnumerationValueDocumentation()
    { return "Dokumentation af enumerations-v�rdier"; }

    virtual QCString trFunctionDocumentation()
    { return "Funktions-dokumentation"; }

    virtual QCString trVariableDocumentation()
    { return "Variabel-dokumentation"; }

    virtual QCString trCompounds()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Datastrukturer";
      } else {
        return "Sammensatte typer";
      }
    }

    virtual QCString trGeneratedAt(const char *date,const char *projName)
    {
      QCString result=(QCString)"Genereret "+date;
      if (projName) result+=(QCString)" for "+projName;
      result+=(QCString)" af";
      return result;
    }
    virtual QCString trWrittenBy()
    { return "skrevet af"; }

    virtual QCString trClassDiagram(const char *clName)
    {
      return (QCString)"Stamtr� for "+clName+":";
    }

    virtual QCString trForInternalUseOnly()
    { return "Kun til intern brug."; }

    virtual QCString trWarning()
    { return "Advarsel"; }

    virtual QCString trVersion()
    { return "Version"; }

    virtual QCString trDate()
    { return "Dato"; }

    virtual QCString trReturns()
    { return "Returnerer"; }

    virtual QCString trSeeAlso()
    { return "Se ogs�"; }

    virtual QCString trParameters()
    { return "Parametre"; }

    virtual QCString trExceptions()
    { return "Exceptions"; }

    virtual QCString trGeneratedBy()
    { return "Genereret af"; }

// new since 0.49-990307

    virtual QCString trNamespaceList()
    { return "Oversigt over namespaces"; }

    virtual QCString trNamespaceListDescription(bool extractAll)
    {
      QCString result="Her er en liste over alle ";
      if (!extractAll) result+="dokumenterede ";
      result+="namespaces med korte beskrivelser:";
      return result;
    }

    virtual QCString trFriends()
    { return "Friends"; }

// new since 0.49-990405

    virtual QCString trRelatedFunctionDocumentation()
    { return "Dokumentation af friends og af relaterede funktioner"; }

// new since 0.49-990425

    virtual QCString trCompoundReference(const char *clName,
                                    ClassDef::CompoundType compType,
                                    bool isTemplate)
    {
      QCString result=(QCString)clName+" ";
      switch(compType)
      {
        case ClassDef::Class:      result+=" Klasse-"; break;
        case ClassDef::Struct:     result+=" Datastruktur-"; break;
        case ClassDef::Union:      result+=" Union-"; break;
        case ClassDef::Interface:  result+=" Gr�nseflade-"; break;
        case ClassDef::Protocol:   result+=" Protocol-"; break; // translate me!
        case ClassDef::Category:   result+=" Category-"; break; // translate me!
        case ClassDef::Exception:  result+=" Exception-"; break;
      }
      if (isTemplate) result+="template-";
      result+="reference";
      return result;
    }

    virtual QCString trFileReference(const char *fileName)
    {
      QCString result=fileName;
      result+=" filreference";
      return result;
    }

    virtual QCString trNamespaceReference(const char *namespaceName)
    {
      QCString result=namespaceName;
      result+=" namespace-reference";
      return result;
    }

    virtual QCString trPublicMembers()
    { return "Offentlige metoder"; }
    virtual QCString trPublicSlots()
    { return "Offentlige slots"; }
    virtual QCString trSignals()
    { return "Signaler"; }
    virtual QCString trStaticPublicMembers()
    { return "Statiske, offentlige metoder"; }
    virtual QCString trProtectedMembers()
    { return "Beskyttede metoder"; }
    virtual QCString trProtectedSlots()
    { return "Beskyttede slots"; }
    virtual QCString trStaticProtectedMembers()
    { return "Statiske, beskyttede metoder"; }
    virtual QCString trPrivateMembers()
    { return "Private metoder"; }
    virtual QCString trPrivateSlots()
    { return "Private slots"; }
    virtual QCString trStaticPrivateMembers()
    { return "Statiske, private metoder"; }

    virtual QCString trWriteList(int numEntries)
    {
      QCString result;
      int i;
      // the inherits list contain `numEntries' classes
      for (i=0;i<numEntries;i++) {
        // use generateMarker to generate placeholders for the class links!
        result+=generateMarker(i); // generate marker for entry i in the list
                                   // (order is left to right)

        if (i!=numEntries-1) { // not the last entry, so we need a separator
          if (i<numEntries-2) // not the fore last entry
            result+=", ";
          else                // the fore last entry
            result+=" og ";
        }
      }
      return result;
    }

    virtual QCString trInheritsList(int numEntries)
    {
      return "Nedarver "+trWriteList(numEntries)+".";
    }

    virtual QCString trInheritedByList(int numEntries)
    {
      return "Nedarvet af "+trWriteList(numEntries)+".";
    }

    virtual QCString trReimplementedFromList(int numEntries)
    {
      return "Overskriver metode fra "+trWriteList(numEntries)+".";
    }

    virtual QCString trReimplementedInList(int numEntries)
    {
      return "Reimplementeret i "+trWriteList(numEntries)+".";
    }

    virtual QCString trNamespaceMembers()
    { return "Namespace-medlemmer"; }

    virtual QCString trNamespaceMemberDescription(bool extractAll)
    {
      QCString result="Her er en liste over alle ";
      if (!extractAll) result+="dokumenterede ";
      result+="namespace-medlemmer med links til ";
      if (extractAll)
        result+="namespace-dokumentationen for hvert medlem:";
      else
        result+="det namespace, de h�rer til:";
      return result;
    }
    virtual QCString trNamespaceIndex()
    { return "Namespace-indeks"; }

    virtual QCString trNamespaceDocumentation()
    { return "Namespace-dokumentation"; }

// new since 0.49-990522

    virtual QCString trNamespaces()
    { return "Namespaces"; }

// new since 0.49-990728

    virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
        bool single)
    { // here s is one of " Class", " Struct" or " Union"
      // single is true implies a single file
      QCString result=(QCString)"Dokumentationen for denne ";
      switch(compType)
      {
        case ClassDef::Class:      result+="klasse"; break;
        case ClassDef::Struct:     result+="datastruktur"; break;
        case ClassDef::Union:      result+="union"; break;
        case ClassDef::Interface:  result+="gr�nseflade"; break;
        case ClassDef::Protocol:   result+="protocol"; break; // translate me!
        case ClassDef::Category:   result+="category"; break; // translate me!
        case ClassDef::Exception:  result+="exception"; break;
      }
      result+=" blev genereret ud fra fil";
      if (single) result+="en:"; else result+="erne:";
      return result;
    }

    virtual QCString trAlphabeticalList()
    { return "Alfabetisk oversigt"; }

// new since 0.49-990901

    virtual QCString trReturnValues()
    { return "Returv�rdier"; }

    virtual QCString trMainPage()
    { return "Hovedside"; }

    virtual QCString trPageAbbreviation()
    { return "s."; }

// new since 0.49-991003

    virtual QCString trDefinedAtLineInSourceFile()
    {
      return "Defineret p� linje @0 i filen @1.";
    }

    virtual QCString trDefinedInSourceFile()
    {
      return "Defineret i filen @0.";
    }

// new since 0.49-991205

    virtual QCString trDeprecated()
    {
      return "Frar�des - fortidslevn"; // ?? - What is the context?
          // "Ugleset" :)
    }

// new since 1.0.0

    virtual QCString trCollaborationDiagram(const char *clName)
    {
      return (QCString)"Samarbejdsdiagram for "+clName+":";
    }
    virtual QCString trInclDepGraph(const char *fName)
    {
      return (QCString)"Inklusions-afh�ngighedsgraf for "+fName+":";
    }
    virtual QCString trConstructorDocumentation()
    {
      return "Dokumentation af konstrukt�rer og destrukt�rer";
      // "Constructor & Destructor dokumentation";
    }

    virtual QCString trGotoSourceCode()
    { return "Hop til denne fils kildekode."; }
    virtual QCString trGotoDocumentation()
    { return "Hop til denne fils dokumentation."; }

    virtual QCString trPrecondition()
    { return "Foruds�tninger (precondition)"; }
    virtual QCString trPostcondition()
    { return "Resultat (postcondition)"; }
    virtual QCString trInvariant()
    { return "Invariant"; }

    virtual QCString trInitialValue()
    { return "Startv�rdi:"; }

    virtual QCString trCode()
    { return "kildekode"; }
    virtual QCString trGraphicalHierarchy()
    { return "Grafisk klassehierarki"; }
    virtual QCString trGotoGraphicalHierarchy()
    { return "Hop til det grafiske klassehierarki"; }
    virtual QCString trGotoTextualHierarchy()
    { return "Hop til det tekstuelle klassehierarki"; }
    virtual QCString trPageIndex()
    { return "Sideindeks"; }

// new since 1.1.0

    virtual QCString trNote()
    { return "Note"; }
    virtual QCString trPublicTypes()
    { return "Offentlige typer"; }

    virtual QCString trPublicAttribs()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Datafelter";
      } else {
        return "Offentlige attributter";
      }
    }

    virtual QCString trStaticPublicAttribs()
    { return "Statiske, offentlige attributter"; }
    virtual QCString trProtectedTypes()
    { return "Beskyttede typer"; }
    virtual QCString trProtectedAttribs()
    { return "Beskyttede attributter"; }
    virtual QCString trStaticProtectedAttribs()
    { return "Statiske, beskyttede attributter"; }
    virtual QCString trPrivateTypes()
    { return "Private typer"; }
    virtual QCString trPrivateAttribs()
    { return "Private attributter"; }
    virtual QCString trStaticPrivateAttribs()
    { return "Statiske, private attributter"; }

// new since 1.1.3

    virtual QCString trTodo()
    {
      return "Todo";
    }
    virtual QCString trTodoList()
    {
      return "Todo-liste";
    }

// new since 1.1.4

    virtual QCString trReferencedBy()
    {
      return "Refereret til af";
    }
    virtual QCString trRemarks()
    {
      return "Bem�rkninger";
    }
    virtual QCString trAttention()
    {
      return "OBS";
    }
    virtual QCString trInclByDepGraph()
    {
      return
        "Denne graf viser, hvilke filer der direkte eller "
        "indirekte inkluderer denne fil:";
    }
    virtual QCString trSince()
    {
      return "Siden";
    }

// new since 1.1.5

    virtual QCString trLegendTitle()
    {
      return "Graf-forklaring";
    }
    virtual QCString trLegendDocs() //TODO
    {
      return
                "Denne side forklarer, hvordan man skal fortolke de grafer, "
                "der genereres af doxygen.<p>\n"
        "Tag f�lgende eksempel:\n"
        "\\code\n"
        "/*! Klasse der er usynlig pg.a. besk�ring */\n"
        "class Invisible { };\n\n"
        "/*! Besk�ret klasse: nedarvningsrelation er skjult */\n"
        "class Truncated : public Invisible { };\n\n"
        "/* Klasse der ikke er dokumenteret med doxygen-kommentarer */\n"
        "class Undocumented { };\n\n"
        "/*! Klasse der nedarves fra offentligt */\n"
        "class PublicBase : public Truncated { };\n\n"
        "/*! En template-klasse */\n"
        "template<class T> class Templ { };\n\n"
        "/*! Klasse der nedarves fra beskyttet */\n"
        "class ProtectedBase { };\n\n"
        "/*! Klasse der nedarves fra privat */\n"
        "class PrivateBase { };\n\n"
        "/*! Klasse der bruges af Inherited-klassen */\n"
        "class Used { };\n\n"
        "/*! Klasse der nedarver en masse andre klasser */\n"
        "class Inherited : public PublicBase,\n"
        "                  protected ProtectedBase,\n"
        "                  private PrivateBase,\n"
        "                  public Undocumented,\n"
        "                  public Templ<int>\n"
        "{\n"
        "  private:\n"
        "    Used *m_usedClass;\n"
        "};\n"
        "\\endcode\n"
        "Hvis \\c MAX_DOT_GRAPH_HEIGHT i konfigurationsfilen "
        "er sat til 240, vil dette resultere i f�lgende graf:"
        "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
        "<p>\n"
        "De forskellige slags kasser i ovenst�ende graf har f�lgende "
                "betydninger:\n"
        "<ul>\n"
        "<li>%En udfyldt sort kasse repr�senterer den datastruktur eller "
                "klasse, grafen er genereret for.\n"
        "<li>%En kasse med sort kant betegner en dokumenteret datastruktur "
                " eller klasse.\n"
        "<li>%En kasse med gr� kant betegner en udokumenteret datastruktur "
                " eller klasse.\n"
        "<li>%En kasse med r�d kant betegner en dokumenteret datastruktur "
                " eller klasse, for hvilken ikke alle "
                "nedarvnings- og indeholdelses-relationer er vist. "
        "%Grafer besk�res, hvis de fylder mere end de specificerede dimensioner.\n "
        "</ul>\n"
        "Pilene har f�lgende betydninger:\n"
        "<ul>\n"
        "<li>%En m�rkebl� pil viser en offentlig nedarvningsrelation "
                "mellem to klasser.\n"
        "<li>%En m�rkegr�n pil viser en beskyttet nedarvningsrelation.\n"
        "<li>%En m�rker�d pil viser en privat nedarvningsrelation.\n"
        "<li>%En lilla, stiplet pil bruges, n�r en klasse er indeholdt i "
                "eller benyttes af en anden klasse. "
        "Ved pilen st�r navnet p� den eller de variable, gennem hvilke(n) "
                "den klasse, pilen peger p�, er tilg�ngelig.\n"
        "<li>%En gul, stiplet pil viser forholdet mellem en template-instans "
                "og den template-klasse, den er instantieret fra."
        "Ved pilen st�r template-parametrene brugt ved instantieringen.\n"
        "</ul>\n";
    }
    virtual QCString trLegend()
    {
      return "forklaring til graf";
    }

// new since 1.2.0

    virtual QCString trTest()
    {
      return "Test";
    }
    virtual QCString trTestList()
    {
      return "Testliste";
    }

// new since 1.2.1

    virtual QCString trDCOPMethods()
    {
      return "DCOP-metoder";
    }

// new since 1.2.2

    virtual QCString trProperties()
    {
      return "Egenskaber";
    }
    virtual QCString trPropertyDocumentation()
    {
      return "Egenskabsdokumentation";
    }

// new since 1.2.4

    virtual QCString trClasses()
    {
      if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
        return "Datastrukturer";
      } else {
        return "Klasser";
      }
    }
    virtual QCString trPackage(const char *name)
    {
      return (QCString)"Pakke "+name;
    }
    virtual QCString trPackageList()
    {
      return "Pakkeoversigt";
    }
    virtual QCString trPackageListDescription()
    {
      return
        "Her er en liste over pakkerne, med korte beskrivelser "
        "(hvor en s�dan findes):";
    }
    virtual QCString trPackages()
    {
      return "Pakker";
    }
    virtual QCString trDefineValue()
    {
      return "V�rdi:";
    }

// new since 1.2.5

    virtual QCString trBug()
    {
      return "Kendte fejl";
    }
    virtual QCString trBugList()
    {
      return "Liste over kendte fejl";
    }

// new since 1.2.6

    virtual QCString trRTFansicp()
    {
      return "1252";
    }

    virtual QCString trRTFCharSet()
    {
      return "0";
    }

    virtual QCString trRTFGeneralIndex()
    {
      return "Indeks";
    }

    virtual QCString trClass(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "klasse", "r");
    }

    virtual QCString trFile(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "fil", "er");
    }

    virtual QCString trNamespace(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "namespace", "s");
    }

    virtual QCString trGroup(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "gruppe", "r");
    }

    virtual QCString trPage(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "side", "r");
    }

    virtual QCString trMember(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "medlem", "mer");
    }

    virtual QCString trGlobal(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "global", "e");
    }

// new since 1.2.7

    virtual QCString trAuthor(bool first_capital, bool singular)
    {
      return createNoun(first_capital, singular, "forfatter", "e");
    }

// new since 1.2.11

    virtual QCString trReferences()
    {
      return "Indeholder referencer til";
    }

// new since 1.2.13

    virtual QCString trImplementedFromList(int numEntries)
    {
      return "Implementerer "+trWriteList(numEntries)+".";
    }

    virtual QCString trImplementedInList(int numEntries)
    {
      return "Implementeret i "+trWriteList(numEntries)+".";
    }

// new since 1.2.16

    virtual QCString trRTFTableOfContents()
    {
      return "Indholdsfortegnelse";
    }

// new since 1.2.17

    virtual QCString trDeprecatedList()
    {
      return "Liste over fortidslevn, hvis brug frar�des";
    }

// new since 1.2.18

    virtual QCString trEvents()
    {
      return "Begivenheder";
    }
    virtual QCString trEventDocumentation()
    {
      return "Begivenhedsdokumentation";
    }

// new since 1.3

    /* Java: Entities with package scope... */
    virtual QCString trPackageTypes()
    { return "Typer med pakke-scope"; }
    virtual QCString trPackageMembers()
    { return "Metoder med pakke-scope"; }
    virtual QCString trStaticPackageMembers()
    { return "Statiske metoder med pakke-scope"; }
    virtual QCString trPackageAttribs()
    { return "Attributter med pakke-scope"; }
    virtual QCString trStaticPackageAttribs()
    { return "Statiske attributter med pakke-scope"; }

// new since 1.3.1

    virtual QCString trAll()
    {
      return "Alle";
    }

    virtual QCString trCallGraph()
    {
      return "Her er kald-grafen for denne funktion:";
    }

// new since 1.3.3

    virtual QCString trSearchForIndex()
    {
      return "S�g efter";
    }

    virtual QCString trSearchResultsTitle()
    {
      return "S�geresultater";
    }

    virtual QCString trSearchResults(int numDocuments)
    {
      if (numDocuments==0) {
        return "Beklager - ingen dokumenter passede til din foresp�rgsel.";
      } else if (numDocuments==1) {
        return "Fandt <b>1</b> dokument, der passer til din foresp�rgsel.";
      } else {
        return
          "Fandt <b>$num</b> dokumenter, der passer til din foresp�rgsel. "
          "De, der passer bedst, vises f�rst.";
      }
    }

    virtual QCString trSearchMatches()
    {
      return "Fundne ord:"; //translation?
    }

// new since 1.3.8

    virtual QCString trSourceFile(QCString& filename)
    {
      return "Kildefilen " + filename;
    }


// new since 1.3.9

    virtual QCString trDirIndex()
    { return "Katalogstruktur"; }

    virtual QCString trDirDocumentation()
    { return "Katalog-dokumentation"; }

    virtual QCString trDirectories()
    { return "Kataloger"; }

    virtual QCString trDirDescription()
    { return "Denne katalogstruktur er sorteret n�sten - "
             "men ikke n�dvendigvis helt - alfabetisk:";
    }

    virtual QCString trDirReference(const char *dirName)
      { QCString result="Indhold af kataloget "; result+=dirName; return result;}

    virtual QCString trDir(bool first_capital, bool singular)
    { 
      return createNoun(first_capital, singular, "katalog", "er");
    }

// new since 1.4.1

    virtual QCString trOverloadText()
    {
       return "Dette er en overdefineret medlemsfunktion, "
              "defineret af bekvemmelighedshensyn. "
              "Den adskiller sig kun fra den ovenst�ende funktion i, "
              "hvilke argumenter den tager.";
    }

// new since 1.4.6

    virtual QCString trCallerGraph()
    {
      return "Her er kalder-grafen for denne funktion:";
    }

    /*
    virtual QCString trEnumerationValueDocumentation()
      { return "Enumerator-dokumentation"; } //TODO?
*/



/*---------- For internal use: ----------------------------------------*/
  protected:
    QCString createNoun(bool first_capital, bool singular,
                        const char* base, const char* plurSuffix)
    {
      QCString result(base);
      if (first_capital) result.at(0) = toupper(result.at(0));
      if (!singular)  result+=plurSuffix;
      return result;
    }
};

#endif

---

• ソフトウェア開発
• ホームページ制作
• Tcl版
• STLport版
• Dradnats C++ Library
• 要約文庫