summaryrefslogtreecommitdiffstats
path: root/src/translator_it.h
diff options
context:
space:
mode:
authorDimitri van Heesch <dimitri@stack.nl>1999-12-15 19:29:47 (GMT)
committerDimitri van Heesch <dimitri@stack.nl>1999-12-15 19:29:47 (GMT)
commit6aa7383e23c850af36c25b87e5737a2e2f635083 (patch)
tree223d088e44a6b0956dd0437ed4851244b2e7f36c /src/translator_it.h
parente04496cb647291b94c0b27b8babb127a79803579 (diff)
downloadDoxygen-6aa7383e23c850af36c25b87e5737a2e2f635083.zip
Doxygen-6aa7383e23c850af36c25b87e5737a2e2f635083.tar.gz
Doxygen-6aa7383e23c850af36c25b87e5737a2e2f635083.tar.bz2
mods for doxygen-0.49-990728
Diffstat (limited to 'src/translator_it.h')
-rw-r--r--src/translator_it.h499
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&euml;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&iuml;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&iuml;mplemented; "
- "de API wordt er niet door be&iuml;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