mods for doxygen-0.49-990728

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