translator_dk.h

Go to the documentation of this file.

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


    links -> (links.)
    -- Poul-Erik Hansen

 */

#ifndef TRANSLATOR_DK_H
#define TRANSLATOR_DK_H

class TranslatorDanish : public TranslatorAdapter_1_8_0
{
  public:

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

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

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

    // --- 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 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 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 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 "Undtagelser"; }    // "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+=" Protokol-"; break;
        case ClassDef::Category:   result+=" Kategori-"; break; // " Category-"
        case ClassDef::Exception:  result+=" Undtagelse-"; break;   //  " Exception"
        default: break;
      }
      if (isTemplate) result+="skabelon-";  // "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+="protokol"; break; // "protocol"
        case ClassDef::Category:   result+="kategori"; break; // "category"
        case ClassDef::Exception:  result+="undtagelse"; break;  // "exception"
        default: break;
      }
      result+=" blev genereret ud fra fil";
      if (single) result+="en:"; else result+="erne:";
      return result;
    }

// 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."+getDotImageExtension()+"\"></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.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 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:";
    }

    // None translated yet PEH 2010-11-27
    // Subroutine

    virtual QCString trMemberFunctionDocumentationFortran()
    { return "Medlem Funktion/Subroutine Dokumentation"; }  // "Member Function/Subroutine Documentation"

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


// new since 1.5.4 (mainly for Fortran)

    virtual QCString trCompoundListFortran()
    { return "Data Type Liste"; }       // "Data Types List"

    virtual QCString trCompoundMembersFortran()
    { return "Data felter"; }   // "Data Fields"

    virtual QCString trCompoundListDescriptionFortran()
    { return "Her er de datatyper med kort beskrivelse:"; }  // "Here are the data types with brief descriptions:"

    virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
    {
      QCString result="Her er en liste af alle "; // "Here is a list of all "
      if (!extractAll)
      {
        result+="dokumenteret ";  // "documented "
      }
      result+="datatype medlemmer"; //  "data types members"
      result+=" med links til ";    // " with links to "
      if (!extractAll)
      {
         result+="data strukturer dokumenteret for hver medlem";    // "the data structure documentation for each member"
      }
      else
      {
         result+="de datatyper som de tilhører:";  // "the data types they belong to:"
      }
      return result;
    }

    virtual QCString trCompoundIndexFortran()
    { return "Datatype indeks"; }   // "Data Type Index"

    virtual QCString trTypeDocumentation()
    { return "Datatype dokumentation"; }   // "Data Type Documentation"

    virtual QCString trSubprograms()
    { return "Funktioner/Subroutiner"; } // "Functions/Subroutines"

    virtual QCString trSubprogramDocumentation()
    { return "Funktion/Subroutine dokumentation"; } // "Function/Subroutine Documentation"

     virtual QCString trDataTypes()
    { return "Datatyper"; }    // "Data Types"

    virtual QCString trModulesList()
    { return "Modulliste"; }  // "Modules List"

    virtual QCString trModulesListDescription(bool extractAll)
    {
      QCString result="Her er en liste over alle ";     // "Here is a list of all "
      if (!extractAll) result+="dokumenteret ";       // "documented "
      result+="moduler med kort beskrivelse:";   // "modules with brief descriptions:"
      return result;
    }

    virtual QCString trCompoundReferenceFortran(const char *clName,
                                    ClassDef::CompoundType compType,
                                    bool isTemplate)
    {
      QCString result=(QCString)clName;
      switch(compType)
      {
        case ClassDef::Class:      result+=" Modul"; break;     // " Module"
        case ClassDef::Struct:     result+=" Type"; break;      // " Type"
        case ClassDef::Union:      result+=" Union"; break;     // " Union"
        case ClassDef::Interface:  result+=" Grænseflade"; break; // " Interface"
        case ClassDef::Protocol:   result+=" Protocol"; break;      // " Protocol"
        case ClassDef::Category:   result+=" Kategori"; break;      // " Category"
        case ClassDef::Exception:  result+=" Undtagelse"; break; // " Exception"
        default: break;
      }
      if (isTemplate) result+=" Template";
      result+=" Reference";
      return result;
    }

    virtual QCString trModuleReference(const char *namespaceName)
    {
      QCString result=namespaceName;
      result+=" Modulreference";  // " Module Reference"
      return result;
    }

    virtual QCString trModulesMembers()
    { return "Modulmedlemmer"; }    // "Module Members"

    virtual QCString trModulesMemberDescription(bool extractAll)
    {
      QCString result="Her er en list over alle ";     // "Here is a list of all "
      if (!extractAll) result+="Dokumentet ";       // "documented "
      result+="modulmemlemmer med link til ";      // "module members with links to "
      if (extractAll)
      {
        result+="dokumentation for hvert model medlem:";    // "the module documentation for each member:"
      }
      else
      {
        result+="moduler de tilhøre:";  // "the modules they belong to:"
      }
      return result;
    }

    virtual QCString trModulesIndex()
    { return "Modulindekser"; }     // "Modules Index"

    virtual QCString trModule(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Modul" : "modul"));   // "Module" : "module"));
      if (!singular)  result+="er";  // "s";
      return result;
    }

    virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
        bool single)
    {
      // single is true implies a single file
      QCString result=(QCString)"The documentation for this ";
      switch(compType)
      {
        case ClassDef::Class:      result+="modul"; break;        // "module"
        case ClassDef::Struct:     result+="type"; break;         // "type"
        case ClassDef::Union:      result+="union"; break;        // "union"
        case ClassDef::Interface:  result+="grænseflade"; break;  // "interface"
        case ClassDef::Protocol:   result+="protokol"; break;     // "protocol"
        case ClassDef::Category:   result+="kategori"; break;     // "category"
        case ClassDef::Exception:  result+="undtagelse"; break;   // "exception"
        default: break;
      }
      result+=" var lavet udfra følgende file";                   // " was generated from the following file"
      if (single) result+=":"; else result+="r:";                 // ":" / "s:"
      return result;
    }

    virtual QCString trType(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Type" : "type"));   // "Type" : "type"
      if (!singular)  result+="r";                          // "s"
      return result;
    }

    virtual QCString trSubprogram(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Subprogram" : "subprogram"));   // "Subprogram" : "subprogram"
      if (!singular)  result+="er";                                     // "s"
      return result;
    }

    virtual QCString trTypeConstraints()
    {
      return "typebegrænsninger";        // "Type Constraints"
    }

// new since 1.6.0 (mainly for the new search engine)

    virtual QCString trDirRelation(const char *name)
    {
      return QCString(name)+" Relation";        // " Relation"
    }

    virtual QCString trLoading()
    {
      return "Indlæser...";          // "Loading..."
    }

    virtual QCString trGlobalNamespace()
    {
      return "Globalt Namespace";    // "Global Namespace"
    }

    virtual QCString trSearching()
    {
      return "Søger...";    // "Searching..."
    }

    virtual QCString trNoMatches()
    {
      return "Ingen fund";      // "No Matches"
    }

// new since 1.6.3 (missing items for the directory pages)

    virtual QCString trFileIn(const char *name)
    {
      return (QCString)"File i "+name;     // "File in "
    }

    virtual QCString trIncludesFileIn(const char *name)
    {
      return (QCString)"Inkluderer file i "+name;    // "Includes file in "
    }

    virtual QCString trDateTime(int year,int month,int day,int dayOfWeek,
                                int hour,int minutes,int seconds,
                                bool includeTime)
    {
      static const char *days[]   = { "Man","Tir","Ons","Tor","Fre","Lør","Søn" }; // { "Mon","Tue","Wed","Thu","Fri","Sat","Sun" };
      static const char *months[] = { "Jan","Feb","Mar","Apr","Maj","Jun","Jul","Aug","Sep","Okt","Nov","Dec" };    //  { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
      QCString sdate;
      sdate.sprintf("%s %s %d %d",days[dayOfWeek-1],months[month-1],day,year);
      if (includeTime)
      {
        QCString stime;
        stime.sprintf(" %.2d:%.2d:%.2d",hour,minutes,seconds);
        sdate+=stime;
      }
      return sdate;
    }

// new since 1.7.5

    virtual QCString trCiteReferences()
    {
      return "Bibliografiske referencer";
    }

    virtual QCString trCopyright()
    {
      return "Copyright";
    }

    virtual QCString trDirDepGraph(const char *name)
    {
      return QCString("Afhængighedsgraf for katalog ")+name+":";
    }


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