diff options
Diffstat (limited to 'src/translator_it.h')
| -rw-r--r-- | src/translator_it.h | 499 |
1 files changed, 306 insertions, 193 deletions
diff --git a/src/translator_it.h b/src/translator_it.h index 316f43a..e2f76dc 100644 --- a/src/translator_it.h +++ b/src/translator_it.h @@ -4,6 +4,9 @@ * * Copyright (C) 1997-1999 by Dimitri van Heesch. * + * Initial Italian Translation by Ahmed Aldo Faisal + * Revised and completed by Alessandro Falappa (June 1999) + * * 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 @@ -17,250 +20,360 @@ #ifndef TRANSLATOR_IT_H #define TRANSLATOR_IT_H -#include <qstring.h> +#include "translator.h" class TranslatorItalian : public Translator { public: - QString latexBabelPackage() + QCString latexBabelPackage() { return "italian"; } - QString trInherits() + QCString trInherits() { return "eredita"; } - QString trAnd() + QCString trAnd() { return "e"; } - QString trInheritedBy() - { return "Ereditato da"; } - QString trRelatedFunctions() - { return "Funzioni relative"; } - QString trRelatedSubscript() - { return "(Nota che questo no sono funzioni membro)"; } - QString trDetailedDescription() + QCString trInheritedBy() + //{ return "Ereditato da"; } + { return "Ereditate da"; } + QCString trRelatedFunctions() + //{ return "Funzioni relative"; } + { return "Funzioni collegate"; } + QCString trRelatedSubscript() + //{ return "(Nota che questo no sono funzioni membro)"; } + { return "(Attenzione, queste non sono funzioni membro)"; } + QCString trDetailedDescription() { return "Descrizione dettagliata"; } - QString trMemberTypedefDocumentation() - { return "Documentazione dei membri Typedef"; } - QString trMemberEnumerationDocumentation() - { return "Documentazione dei membri enumerati"; } - QString trEnumerationValueDocumentation() - { return "Documentazione dei tipi enumerati"; } - QString trMemberFunctionDocumentation() + QCString trMemberTypedefDocumentation() + //{ return "Documentazione dei membri Typedef"; } + { return "Documentazione delle ridefinizioni dei tipi (typedef)"; } + QCString trMemberEnumerationDocumentation() + //{ return "Documentazione dei membri enumerati"; } + { return "Documentazione dei tipi enumerati (enum)"; } + QCString trEnumerationValueDocumentation() + { return "Documentazione dei valori dei tipi enumerati"; } + QCString trMemberFunctionDocumentation() { return "Documentazione delle funzioni membro"; } - QString trMemberDataDocumentation() + QCString trMemberDataDocumentation() { return "Documentazione dei dati membro"; } - QString trGeneratedFrom(const char *s,bool single) + QCString trGeneratedFrom(const char *s,bool single) { - QString result=(QString)"La documentazione di questa "+s+ - " e stata generata dal seguente file"; - if (single) result+=":"; else result+=":"; + QCString result=(QCString)"La documentazione di questa "+s+ + " è stata generata a partire"; + if (single) result+=" dal seguente file:"; + else result+=" dai seguenti files:"; return result; } - QString trMore() + QCString trMore() { return "Continua..."; } - QString trReference() + QCString trReference() { return "Riferimento"; } - QString trListOfAllMembers() - { return "Lista di tuti i memberi."; } - QString trMemberList() - { return "Lista membri"; } - QString trThisIsTheListOfAllMembers() - { return "Questa e la lista completa di tutti i membri"; } - QString trIncludingInheritedMembers() - { return "includendo tutti i membri ereditati."; } - QString trGeneratedAutomatically(const char *s) - { QString result="Generato automaticalmenta da Doxygen"; - if (s) result+=(QString)" per "+s; - result+=" dall codice."; + QCString trListOfAllMembers() + { return "Lista di tutti i membri."; } + QCString trMemberList() + { return "Lista dei membri"; } + QCString trThisIsTheListOfAllMembers() + { return "Questa è la lista completa di tutti i membri di "; } + QCString trIncludingInheritedMembers() + { return ", includendo tutti i membri ereditati."; } + QCString trGeneratedAutomatically(const char *s) + { + QCString result="Generato automaticamente da Doxygen"; + if (s) result+=(QCString)" per "+s; + result+=" a partire dal codice sorgente."; return result; } - QString trEnumName() - { return "nome dell enum"; } - QString trEnumValue() - { return "valore dell enum"; } - QString trDefinedIn() + QCString trEnumName() + { return "nome di tipo enumerato"; } + QCString trEnumValue() + { return "valore di tipo enumerato"; } + QCString trDefinedIn() { return "definito in"; } - QString trIncludeFile() + QCString trIncludeFile() { return "Include il file"; } - QString trVerbatimText(const char *f) - { return (QString)"Questo e il contenuto verbatim dell file "+f+"."; } - QString trModules() + QCString trVerbatimText(const char *f) + { return (QCString)"Questo è il contenuto integrale dell file "+f+"."; } + QCString trModules() { return "Moduli"; } - QString trClassHierarchy() - { return "gerarchia delle classi"; } - QString trCompoundList() - { return "Lista dei tipi composti"; } - QString trFileList() - { return "Lista dei file"; } - QString trHeaderFiles() - { return "List dei fei file header"; } - QString trCompoundMembers() - { return "Membri composti"; } - QString trFileMembers() - { return "Membri dell file"; } - QString trRelatedPages() - { return "Relativo a pagina"; } - QString trExamples() - { return "Esempio"; } - QString trSearch() - { return "Ricerca"; } - QString trClassHierarchyDescription() - { return "Qua sono la lista delle classi, structs e unions" - "gesorte:"; + QCString trClassHierarchy() + { return "Gerarchia delle classi"; } + QCString trCompoundList() + { return "Lista dei composti"; } + QCString trFileList() + { return "Lista dei files"; } + QCString trHeaderFiles() + { return "Lista dei file header"; } + QCString trCompoundMembers() + { return "Membri dei composti"; } + QCString trFileMembers() + { return "Membri dei files"; } + QCString trRelatedPages() + { return "Pagine collegate"; } + QCString trExamples() + { return "Esempi"; } + QCString trSearch() + { return "Cerca"; } + QCString trClassHierarchyDescription() + { + return "Questa lista di ereditarietà è ordinata " + "approssimativamente, ma non completamente, in ordine alfabetico:"; } - QString trFileListDescription(bool extractAll) + QCString trFileListDescription(bool extractAll) { - QString result="Hieronder volgt de lijst met alle "; - if (!extractAll) result+="gedocumenteerde "; - result+="files, elk met een korte beschrijving:"; + QCString result="Questa è una lista "; + if (!extractAll) result+="dei files documentati "; + else result+="di tutti i files "; + result+="con una loro breve descrizione:"; return result; } - QString trCompoundListDescription() - { return "Hieronder volgen de klassen, structs en " - "unions met voor elk een korte beschrijving:"; + QCString trCompoundListDescription() + { return "Queste sono le classi, structs e " + "unions con una loro breve descrizione:"; } - QString trCompoundMembersDescription(bool extractAll) + QCString trCompoundMembersDescription(bool extractAll) { - QString result="Hieronder volgt de lijst met alle "; - if (!extractAll) result+="gedocumenteerde "; - result+="klasse members met links naar "; - if (extractAll) result+="de klasse Documentazione voor elke member:"; - else result+="de klassen waartoe ze behoren:"; + QCString result="Questa è una lista "; + if (!extractAll) result+="dei membri documentati, "; + else result+="di tutti i membri "; + result+="con collegamenti "; + if (extractAll) result+="alla documentazione della classe di ciascun membro:"; + else result+="alla documentazione delle classi a cui appartengono:"; return result; } - QString trFileMembersDescription(bool extractAll) + QCString trFileMembersDescription(bool extractAll) { - QString result="Hieronder volgt de lijst met alle "; - if (!extractAll) result+="gedocumenteerde "; - result+="file members met links naar "; - if (extractAll) result+="de file Documentazione voor elke member:"; - else result+="de files waartoe ze behoren:"; + QCString result="Questa è una lista "; + if (!extractAll) result+="dei membri dei files documentati, "; + else result+="di tutti i membri dei files "; + result+="con collegamenti "; + if (extractAll) result+="alla documentazione del file di ciascun membro:"; + else result+="alla documentazione dei files a cui appartengono:"; return result; } - QString trHeaderFilesDescription() - { return "Hieronder volgen de header files die de API vormen:"; } - QString trExamplesDescription() - { return "Hieronder volgt de lijst met alle voorbeelden:"; } - QString trRelatedPagesDescription() - { return "Hieronder volgt de lijst met alle pagina's die gerelateerde Documentazione bevatten:"; } - QString trModulesDescription() - { return "Hieronder volgt de lijst met alle modules:"; } - QString trNoDescriptionAvailable() - { return "Geen korte beschrijving beschikbaar"; } + QCString trHeaderFilesDescription() + { return "Questi sono gli header files che compongono l'API:"; } + QCString trExamplesDescription() + { return "Questa è la lista di tutti gli esempi:"; } + QCString trRelatedPagesDescription() + { return "Questa è la lista di tutte le pagine di documentazione collegate fra loro:"; } + QCString trModulesDescription() + { return "Questa è la lista di tutti i moduli:"; } + QCString trNoDescriptionAvailable() + { return "Descrizione non disponibile"; } - QString trDocumentation() + QCString trDocumentation() { return "Documentazione"; } - QString trModuleIndex() - { return "Module Index"; } - QString trHierarchicalIndex() - { return "Hiërarchische Index"; } - QString trCompoundIndex() - { return "Compound Index"; } - QString trFileIndex() - { return "File Index"; } - QString trModuleDocumentation() - { return "Module Documentazione"; } - QString trClassDocumentation() - { return "Klasse Documentazione"; } - QString trFileDocumentation() - { return "File Documentazione"; } - QString trExampleDocumentation() - { return "Documentazione di voorbeelden"; } - QString trPageDocumentation() - { return "Documentazione di gerelateerde pagina's"; } - QString trReferenceManual() - { return "Naslagwerk"; } + QCString trModuleIndex() + { return "Indice dei moduli"; } + QCString trHierarchicalIndex() + { return "Indice della gerarchia"; } + QCString trCompoundIndex() + { return "Indice dei composti"; } + QCString trFileIndex() + { return "Indice dei files"; } + QCString trModuleDocumentation() + { return "Documentazione dei moduli"; } + QCString trClassDocumentation() + { return "Documentazione delle classi"; } + QCString trFileDocumentation() + { return "Documentazione dei files"; } + QCString trExampleDocumentation() + { return "Documentazione degli esempi"; } + QCString trPageDocumentation() + { return "Documentazione delle pagine"; } + QCString trReferenceManual() + { return "Manuale di riferimento"; } - QString trDefines() - { return "Defines"; } - QString trFuncProtos() - { return "Functie Prototypes"; } - QString trTypedefs() + QCString trDefines() + { return "Definizioni"; } + QCString trFuncProtos() + { return "Prototipi delle funzioni"; } + QCString trTypedefs() { return "Typedefs"; } - QString trEnumerations() - { return "Enumeraties"; } - QString trFunctions() - { return "Functies"; } - QString trVariables() - { return "Variabelen"; } - QString trEnumerationValues() - { return "Enumeratie waarden"; } - QString trReimplementedFrom() - { return "Nieuwe implementatie di"; } - QString trReimplementedIn() - { return "Opnieuw geïmplementeerd in"; } - QString trAuthor() - { return "auteur"; } - QString trDefineDocumentation() - { return "Lista "; } - QString trFunctionPrototypeDocumentation() - { return "Documentazione di functie Prototypes"; } - QString trTypedefDocumentation() - { return "Documentazione di typedefs"; } - QString trEnumerationTypeDocumentation() - { return "Documentazione di enumeratie types"; } - QString trFunctionDocumentation() - { return "Documentazione di functies"; } - QString trVariableDocumentation() - { return "Lista variabelen"; } - QString trCompounds() - { return "Compounds"; } - QString trFiles() + QCString trEnumerations() + { return "Tipi enumerati"; } + QCString trFunctions() + { return "Funzioni"; } + QCString trVariables() + { return "Variabili"; } + QCString trEnumerationValues() + { return "Valori dei tipi enumerati"; } + QCString trReimplementedFrom() + { return "Nuova implementazione di"; } + QCString trReimplementedIn() + { return "Reimplementato in"; } + QCString trAuthor() + { return "Autore"; } + QCString trDefineDocumentation() + { return "Documentazione delle definizioni"; } + QCString trFunctionPrototypeDocumentation() + { return "Documentazione dei prototipi delle funzioni"; } + QCString trTypedefDocumentation() + { return "Documentazione dei typedefs"; } + QCString trEnumerationTypeDocumentation() + { return "Documentazione dei tipi enumerati"; } + QCString trFunctionDocumentation() + { return "Documentazione delle funzioni"; } + QCString trVariableDocumentation() + { return "Documentazione delle variabili"; } + QCString trCompounds() + { return "Composti"; } + QCString trFiles() { return "Files"; } - QString trGeneratedAt(const char *date,const char *projName) + QCString trGeneratedAt(const char *date,const char *projName) { - QString result=(QString)"Gegenereerd op "+date; - if (projName) result+=(QString)" voor "+projName; - result+=(QString)" door"; + QCString result=(QCString)"Generato il "+date; + if (projName) result+=(QCString)" per "+projName; + result+=(QCString)" da"; return result; } - QString trWrittenBy() + QCString trWrittenBy() { - return "geschreven door"; + return "scritto da"; } - QString trClassDiagram(const char *clName) + QCString trClassDiagram(const char *clName) { - return (QString)"Klasse diagram voor "+clName; + return (QCString)"Diagramma delle classi per "+clName; } - QString trForInternalUseOnly() - { return "Alleen voor intern gebruik."; } - QString trReimplementedForInternalReasons() - { return "Om interne rederene opnieuwd geïmplemented; " - "de API wordt er niet door beïnvloed."; + QCString trForInternalUseOnly() + { return "Solo per uso interno."; } + QCString trReimplementedForInternalReasons() + { return "Reimplementato per motivi interni; " + "l'API non è stata modificata."; } - QString trWarning() - { return "Waarschuwing"; } - QString trBugsAndLimitations() - { return "Fouten en beperkingen"; } - QString trVersion() - { return "Versie"; } - QString trDate() - { return "Datum"; } - QString trAuthors() - { return "Auteur(s)"; } - QString trReturns() - { return "Retourneerd"; } - QString trSeeAlso() - { return "Zie ook"; } - QString trParameters() - { return "Parameters"; } - QString trExceptions() - { return "Excepties"; } - QString trGeneratedBy() - { return "Gegenereerd door"; } + QCString trWarning() + { return "Attenzione"; } + QCString trBugsAndLimitations() + { return "Bugs e limitazioni"; } + QCString trVersion() + { return "Versione"; } + QCString trDate() + { return "Data"; } + QCString trAuthors() + { return "Autore(i)"; } + QCString trReturns() + { return "Restituisce"; } + QCString trSeeAlso() + { return "Vedi anche"; } + QCString trParameters() + { return "Parametri"; } + QCString trExceptions() + { return "Eccezioni"; } + QCString trGeneratedBy() + { return "Generato da"; } - // new since 0.49-990307 +////////////////////////////////////////////////////////////////////////// +// new since 0.49-990307 +////////////////////////////////////////////////////////////////////////// - QString trNamespaces() + QCString trNamespaces() { return "Namespaces"; } - QString trNamespaceList() - { return "Namespace Lijst"; } - QString trNamespaceListDescription(bool extractAll) + QCString trNamespaceList() + { return "Lista dei namespaces"; } + QCString trNamespaceListDescription(bool extractAll) { - QString result="Hier is een lijst met alle "; - if (!extractAll) result+="gedocumenteerde "; - result+="namespaces met voor elk een korte beschrijving:"; + QCString result="Questa è la lista "; + if (!extractAll) result+="dei namespaces documentati, "; + else result+="di tutti i namespaces "; + result+="con una loro breve descrizione:"; return result; } - QString trFriends() + QCString trFriends() { return "Friends"; } + +////////////////////////////////////////////////////////////////////////// +// new since 0.49-990405 +////////////////////////////////////////////////////////////////////////// + + QCString trRelatedFunctionDocumentation() + { return "Documentazione dei friends e delle funzioni collegate"; } + +////////////////////////////////////////////////////////////////////////// +// new since 0.49-990425 +////////////////////////////////////////////////////////////////////////// + + QCString trCompoundReference(const char *clName, + ClassDef::CompoundType compType) + { + QCString result="Riferimenti per la"; + switch(compType) + { + case ClassDef::Class: result+=" classe"; break; + case ClassDef::Struct: result+=" struct"; break; + case ClassDef::Union: result+=" union"; break; + } + result+=" "+(QCString)clName; + return result; + } + QCString trFileReference(const char *fileName) + { + QCString result="Riferimenti per il file "; + result+=(QCString)fileName; + return result; + } + QCString trNamespaceReference(const char *namespaceName) + { + QCString result="Riferimenti per il namespace "; + result+=(QCString)namespaceName; + return result; + } + + // these are for the member sections of a class, struct or union + QCString trPublicMembers() + { return "Membri pubblici"; } + QCString trPublicSlots() + { return "Slots pubblici"; } + QCString trSignals() + { return "Signals"; } + QCString trStaticPublicMembers() + { return "Membri pubblici statici"; } + QCString trProtectedMembers() + { return "Membri protetti"; } + QCString trProtectedSlots() + { return "Slots protetti"; } + QCString trStaticProtectedMembers() + { return "Membri protetti statici"; } + QCString trPrivateMembers() + { return "Membri privati"; } + QCString trPrivateSlots() + { return "Slots privati"; } + QCString trStaticPrivateMembers() + { return "Membri privati statici"; } + + + QCString trInheritsList(int numEntries) + { + return "Eredita da "+trWriteList(numEntries)+"."; + } + QCString trInheritedByList(int numEntries) + { + return "Base per "+trWriteList(numEntries)+"."; + } + QCString trReimplementedFromList(int numEntries) + { + return "Reimplementa "+trWriteList(numEntries)+"."; + } + QCString trReimplementedInList(int numEntries) + { + return "Reimplementata in "+trWriteList(numEntries)+"."; + } + + QCString trNamespaceMembers() + { return "Membri dei namespaces"; } + QCString trNamespaceMemberDescription(bool extractAll) + { + QCString result="Questa è la lista "; + if (!extractAll) result+="dei membri dei namespaces documentati, "; + else result+="di tutti i membri dei namespaces "; + result+="con collegamenti "; + if (extractAll) + result+="alla documentazione del namespace per ciascun membro:"; + else + result+="ai namespaces a cui appartengono:"; + return result; + } + QCString trNamespaceIndex() + { return "Indice dei namespaces"; } + QCString trNamespaceDocumentation() + { return "Documentazione dei namespaces"; } }; #endif |