translator_it.h

Go to the documentation of this file.
00001 /******************************************************************************
00002  *
00003  *
00004  *
00005  * Copyright (C) 1997-2008 by Dimitri van Heesch.
00006  *
00007  * Permission to use, copy, modify, and distribute this software and its
00008  * documentation under the terms of the GNU General Public License is hereby
00009  * granted. No representations are made about the suitability of this software
00010  * for any purpose. It is provided "as is" without express or implied warranty.
00011  * See the GNU General Public License for more details.
00012  *
00013  * Documents produced by Doxygen are derivative works derived from the
00014  * input used in their production; they are not affected by this license.
00015  *
00016  */
00017 
00018 /******************************************************************************
00019  *
00020  * Revision history
00021  *
00022  *  2007/11: updated translation of new items used since version 1.5.4
00023  *  2007/10: Included corrections provided by Arialdo Martini <arialdomartini@bebox.it>, updated some strings marked with 'translate me' comment
00024  *  2006/10: made class to derive directly from Translator class (reported in Petr Prikryl October 9 translator report)
00025  *  2006/06: updated translation of new items used since version 1.4.6
00026  *  2006/05: translated new items used since version 1.4.6
00027  *           corrected typo in trPackageMembers method
00028  *  2005/03: translated new items used since version 1.4.1
00029  *           removed unused methods listed in Petr Prikryl February 28 translator report
00030  *  2004/09: translated new items used since version 1.3.9
00031  *  2004/06: translated new items used since version 1.3.8
00032  *  2003/11: translated new items used since version 1.3.3
00033  *  2003/06: translated new items used since version 1.3.1
00034  *  2003/04: translated new items used since version 1.3
00035  *  2002/11: translated new items used since version 1.2.18
00036  *  2002/08: translated new items used since version 1.2.17
00037  *  2002/07: translated new items used since version 1.2.16
00038  *  2002/06: modified trRelatedPagesDescription() method
00039  *           corrected typo in trInclByDepGraph() method
00040  *  2002/01: translated new items used since version 1.2.13
00041  *           updated e-mail address
00042  *  2001/11: corrected the translation fixing the issues reported by the translator.pl script
00043  *           translated new items used since version 1.2.11
00044  *  2001/08: corrected the translation fixing the issues reported by the translator.pl script
00045  *           translated new items used since version 1.2.7
00046  *  2001/05: adopted new translation mechanism (trough adapters),
00047  *           translated new items used since version 1.2.5 and 1.2.6,
00048  *           revised those function returning strings in OPTIMIZE_OTPUT_FOR_C case,
00049  *           corrections regarding the plurals of some english terms mantained in the translation,
00050  *           changed some terms to better suit the sense
00051  *  2001/02: translated new items used since version 1.2.4
00052  *  2000/11: modified slightly the translation in trLegendDocs() function,
00053  *           translated new items used since version 1.2.1 and 1.2.2
00054  *  2000/08: translated new items used since version 1.1.3, 1.1.4, 1.1.5 and 1.2.0
00055  *  2000/03: translated new items used since version 1.0 and 1.1.0
00056  *  1999/19: entirely rewritten the translation to correct small variations due
00057  *           to feature additions and to conform to the layout of the latest
00058  *           commented translator.h for the english language
00059  *  1999/09: corrected some small typos in the "new since 0.49-990425" section
00060  *           added the "new since 0.49-990728" section
00061  *  1999/06: revised and completed by Alessandro Falappa (current mantainer)
00062  *  1999/??: initial italian translation by Ahmed Aldo Faisal
00063  */
00064 
00065 /******************************************************************************
00066  *
00067  * Note sui criteri adottati per la traduzione
00068  *
00069  * Nella traduzione non si sono tradotti alcuni termini inglesi ormai entrati
00070  * a far parte del "gergo" informatico (per es. file o namespace)
00071  *
00072  * Il plurale dei termini inglesi non tradotti è stato reso con il singolare
00073  * della parola inglese secondo una convenzione spesso ritrovata nella documentazione
00074  * tecnica (ad es. "lista dei file" e non "lista dei files")
00075  *
00076  * Se avete suggerimenti sulla traduzione di alcuni termini o volete segnalare
00077  * eventuali sviste potete scrivermi all'indirizzo: alessandro@falappa.net
00078  */
00079 
00080 #ifndef TRANSLATOR_IT_H
00081 #define TRANSLATOR_IT_H
00082 
00083 class TranslatorItalian : public Translator
00084 {
00085   public:
00086 
00087     // --- Language control methods -------------------
00088 
00095     virtual QCString idLanguage()
00096     { return "italian"; }
00097 
00101     virtual QCString latexLanguageSupportCommand()
00102     {
00103       return "\\usepackage[italian]{babel}\n";
00104     }
00105 
00107     virtual QCString idLanguageCharset()
00108     {
00109       return "UTF-8";
00110     }
00111 
00112     // --- Language translation methods -------------------
00113 
00115     QCString trRelatedFunctions()
00116     { return "Funzioni collegate"; }
00117 
00119     QCString trRelatedSubscript()
00120     { return "(Si noti che queste non sono funzioni membro.)"; }
00121 
00123     QCString trDetailedDescription()
00124     { return "Descrizione dettagliata"; }
00125 
00127     QCString trMemberTypedefDocumentation()
00128     { return "Documentazione delle ridefinizioni dei tipi (typedef)"; }
00129 
00131     QCString trMemberEnumerationDocumentation()
00132     { return "Documentazione dei tipi enumerati (enum)"; }
00133 
00135     QCString trMemberFunctionDocumentation()
00136     { return "Documentazione delle funzioni membro"; }
00137 
00139     QCString trMemberDataDocumentation()
00140     {
00141       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00142       {
00143         return "Documentazione dei campi";
00144       }
00145       else
00146       {
00147         return "Documentazione dei dati membri";
00148       }
00149     }
00150 
00152     QCString trMore()
00153     { return "Continua..."; }
00154 
00156     QCString trListOfAllMembers()
00157     { return "Elenco di tutti i membri."; }
00158 
00160     QCString trMemberList()
00161     { return "Elenco dei membri"; }
00162 
00164     QCString trThisIsTheListOfAllMembers()
00165     { return "Questo è l'elenco completo di tutti i membri di "; }
00166 
00168     QCString trIncludingInheritedMembers()
00169     { return ", inclusi tutti i membri ereditati."; }
00170 
00174     QCString trGeneratedAutomatically(const char *s)
00175     {
00176       QCString result="Generato automaticamente da Doxygen";
00177       if (s) result+=(QCString)" per "+s;
00178       result+=" a partire dal codice sorgente.";
00179       return result;
00180     }
00181 
00183     QCString trEnumName()
00184     { return "nome di tipo enumerato"; }
00185 
00187     QCString trEnumValue()
00188     { return "valore di tipo enumerato"; }
00189 
00191     QCString trDefinedIn()
00192     { return "definito in"; }
00193 
00194     // quick reference sections
00195 
00199     QCString trModules()
00200     { return "Moduli"; }
00201 
00203     QCString trClassHierarchy()
00204     { return "Gerarchia delle classi"; }
00205 
00207     QCString trCompoundList()
00208     {
00209       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00210       {
00211         return "Strutture dati";
00212       }
00213       else
00214       {
00215         return "Elenco dei tipi composti";
00216       }
00217     }
00218 
00220     QCString trFileList()
00221     { return "Elenco dei file"; }
00222 
00224     QCString trCompoundMembers()
00225      {
00226       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00227       {
00228         return "Campi dei dati";
00229       }
00230       else
00231       {
00232         return "Membri dei composti";
00233       }
00234     }
00235 
00237     QCString trFileMembers()
00238     {
00239       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00240       {
00241         return "Elementi globali";
00242       }
00243       else
00244       {
00245         return "Membri dei file";
00246       }
00247     }
00248 
00250     QCString trRelatedPages()
00251     { return "Pagine collegate"; }
00252 
00254     QCString trExamples()
00255     { return "Esempi"; }
00256 
00258     QCString trSearch()
00259     { return "Cerca"; }
00260 
00262     QCString trClassHierarchyDescription()
00263     {
00264         return "Questo elenco di ereditarietà è ordinato "
00265         "approssimativamente, ma non completamente, in ordine alfabetico:";
00266     }
00267 
00269     QCString trFileListDescription(bool extractAll)
00270     {
00271       QCString result="Questo è un elenco ";
00272       if (!extractAll) result+="dei file documentati ";
00273       else result+="di tutti i file ";
00274       result+="con una loro breve descrizione:";
00275       return result;
00276     }
00277 
00279     QCString trCompoundListDescription()
00280     {
00281 
00282       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00283       {
00284         return "Queste sono le strutture dati con una loro breve descrizione:";
00285       }
00286       else
00287       {
00288         return "Queste sono le classi, le struct, le union e le interfacce con una loro breve descrizione:";
00289       }
00290     }
00291 
00293     QCString trCompoundMembersDescription(bool extractAll)
00294     {
00295       QCString result="Questo è un elenco ";
00296       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00297       {
00298         if (!extractAll) result+="delle struct e delle union documentate ";
00299         else result+="di tutte le struct e le union ";
00300       }
00301       else
00302       {
00303         if (!extractAll) result+="dei membri documentati ";
00304         else result+="di tutti i membri ";
00305       }
00306       result+="con collegamenti alla documentazione ";
00307       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00308       {
00309           if (extractAll) result+="della struct/union per ciascun campo:";
00310           else result+="delle struct/union a cui appartengono:";
00311       }
00312       else
00313       {
00314           if (extractAll) result+="della classe a cui appartengono:";
00315           else result+="delle classi a cui appartengono:";
00316       }
00317       return result;
00318     }
00319 
00321     QCString trFileMembersDescription(bool extractAll)
00322     {
00323       QCString result="Questo è un elenco ";
00324       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00325       {
00326           if (!extractAll) result+="delle funczioni, delle variabili, delle define, dei tipi enumerati e delle typedef documentate ";
00327           else result+="di tutte le funczioni, variabili, define, tipi enumerati, e typedef ";
00328       }
00329       else
00330       {
00331           if (!extractAll) result+="dei membri dei file documentati ";
00332           else result+="di tutti i membri dei file ";
00333       }
00334       result+="con collegamenti alla documentazione";
00335       if (extractAll) result+=" del file a cui appartengono:";
00336       else result+=":";
00337       return result;
00338     }
00339 
00341     QCString trExamplesDescription()
00342     { return "Questo è l'elenco di tutti gli esempi:"; }
00343 
00345     QCString trRelatedPagesDescription()
00346     { return "Questo è l'elenco di tutte le pagine di documentazione generale:"; }
00347 
00349     QCString trModulesDescription()
00350     { return "Questo è l'elenco di tutti i moduli:"; }
00351 
00352     // index titles (the project name is prepended for these)
00353 
00355     QCString trDocumentation()
00356     { return "Documentazione"; }
00357 
00361     QCString trModuleIndex()
00362     { return "Indice dei moduli"; }
00363 
00367     QCString trHierarchicalIndex()
00368     { return "Indice della gerarchia"; }
00369 
00373     QCString trCompoundIndex()
00374     {
00375       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00376       {
00377         return "Indice delle strutture dati";
00378       }
00379       else
00380       {
00381         return "Indice dei tipi composti";
00382       }
00383     }
00384 
00388     QCString trFileIndex()
00389     { return "Indice dei file"; }
00390 
00394     QCString trModuleDocumentation()
00395     { return "Documentazione dei moduli"; }
00396 
00400     QCString trClassDocumentation()
00401     { return "Documentazione delle classi"; }
00402 
00406     QCString trFileDocumentation()
00407     { return "Documentazione dei file"; }
00408 
00412     QCString trExampleDocumentation()
00413     { return "Documentazione degli esempi"; }
00414 
00418     QCString trPageDocumentation()
00419     { return "Documentazione delle pagine tra loro collegate "; }
00420 
00422     QCString trReferenceManual()
00423     { return "Manuale di riferimento"; }
00424 
00428     QCString trDefines()
00429     { return "Definizioni"; }
00430 
00434     QCString trFuncProtos()
00435     { return "Prototipi delle funzioni"; }
00436 
00440     QCString trTypedefs()
00441     { return "Ridefinizioni di tipo (typedef)"; }
00442 
00446     QCString trEnumerations()
00447     { return "Tipi enumerati (enum)"; }
00448 
00452     QCString trFunctions()
00453     { return "Funzioni"; }
00454 
00458     QCString trVariables()
00459     { return "Variabili"; }
00460 
00464     QCString trEnumerationValues()
00465     { return "Valori dei tipi enumerati"; }
00466 
00470     QCString trDefineDocumentation()
00471     { return "Documentazione delle definizioni"; }
00472 
00476     QCString trFunctionPrototypeDocumentation()
00477     { return "Documentazione dei prototipi delle funzioni"; }
00478 
00482     QCString trTypedefDocumentation()
00483     { return "Documentazione delle ridefinizioni di tipo (typedef)"; }
00484 
00488     QCString trEnumerationTypeDocumentation()
00489     { return "Documentazione dei tipi enumerati"; }
00490 
00494     QCString trFunctionDocumentation()
00495     { return "Documentazione delle funzioni"; }
00496 
00500     QCString trVariableDocumentation()
00501     { return "Documentazione delle variabili"; }
00502 
00506     QCString trCompounds()
00507     {
00508       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00509       {
00510         return "Strutture dati";
00511       }
00512       else
00513       {
00514         return "Composti";
00515       }
00516     }
00517 
00521     QCString trGeneratedAt(const char *date,const char *projName)
00522     {
00523       QCString result=(QCString)"Generato il "+date;
00524       if (projName) result+=(QCString)" per "+projName;
00525       result+=(QCString)" da";
00526       return result;
00527     }
00530     QCString trWrittenBy()
00531     {
00532       return "scritto da";
00533     }
00534 
00536     QCString trClassDiagram(const char *clName)
00537     {
00538       return (QCString)"Diagramma delle classi per "+clName;
00539     }
00540 
00542     QCString trForInternalUseOnly()
00543     { return "Solo per uso interno."; }
00544 
00546     QCString trWarning()
00547     { return "Avvertimento"; }
00548 
00550     QCString trVersion()
00551     { return "Versione"; }
00552 
00554     QCString trDate()
00555     { return "Data"; }
00556 
00558     QCString trReturns()
00559     { return "Restituisce"; }
00560 
00562     QCString trSeeAlso()
00563     { return "Vedi anche"; }
00564 
00566     QCString trParameters()
00567     { return "Parametri"; }
00568 
00570     QCString trExceptions()
00571     { return "Eccezioni"; }
00572 
00574     QCString trGeneratedBy()
00575     { return "Generato da"; }
00576 
00578 // new since 0.49-990307
00580 
00582     QCString trNamespaceList()
00583     { return "Lista dei namespace"; }
00584 
00586     QCString trNamespaceListDescription(bool extractAll)
00587     {
00588       QCString result="Questa è l'elenco ";
00589       if (!extractAll) result+="dei namespace documentati, ";
00590       else result+="di tutti i namespace ";
00591       result+="con una loro breve descrizione:";
00592       return result;
00593     }
00594 
00598     QCString trFriends()
00599     { return "Friend"; }
00600 
00602 // new since 0.49-990405
00604 
00608     QCString trRelatedFunctionDocumentation()
00609     { return "Documentazione dei friend e delle funzioni collegate"; }
00610 
00612 // new since 0.49-990425
00614 
00616     QCString trCompoundReference(const char *clName,
00617                                  ClassDef::CompoundType compType,
00618                                  bool isTemplate)
00619     {
00620       QCString result="Riferimenti per ";
00621       if (isTemplate) result="Template per ";
00622       switch(compType)
00623       {
00624         case ClassDef::Class:  result+="la classe "; break;
00625         case ClassDef::Struct: result+="la struct "; break;
00626         case ClassDef::Union:  result+="la union "; break;
00627         case ClassDef::Interface:  result+="l'interfaccia "; break;
00628         case ClassDef::Protocol:   result+="il protocollo "; break;
00629         case ClassDef::Category:   result+="la categoria "; break;
00630         case ClassDef::Exception:  result+="l'eccezione "; break;
00631       }
00632       result+=(QCString)clName;
00633       return result;
00634 
00635     }
00636 
00638     QCString trFileReference(const char *fileName)
00639     {
00640       QCString result="Riferimenti per il file ";
00641       result+=(QCString)fileName;
00642       return result;
00643     }
00644 
00646     QCString trNamespaceReference(const char *namespaceName)
00647     {
00648       QCString result="Riferimenti per il namespace ";
00649       result+=(QCString)namespaceName;
00650       return result;
00651     }
00652 
00653     /* these are for the member sections of a class, struct or union */
00654     QCString trPublicMembers()
00655     { return "Membri pubblici"; }
00656     QCString trPublicSlots()
00657     { return "Slot pubblici"; }
00658     QCString trSignals()
00659     { return "Signal"; }
00660     QCString trStaticPublicMembers()
00661     { return "Membri pubblici statici"; }
00662     QCString trProtectedMembers()
00663     { return "Membri protetti"; }
00664     QCString trProtectedSlots()
00665     { return "Slot protetti"; }
00666     QCString trStaticProtectedMembers()
00667     { return "Membri protetti statici"; }
00668     QCString trPrivateMembers()
00669     { return "Membri privati"; }
00670     QCString trPrivateSlots()
00671     { return "Slot privati"; }
00672     QCString trStaticPrivateMembers()
00673     { return "Membri privati statici"; }
00674 
00678     QCString trWriteList(int numEntries)
00679     {
00680       QCString result;
00681       int i;
00682       // the inherits list contain `numEntries' classes
00683       for (i=0;i<numEntries;i++)
00684       {
00685         // use generateMarker to generate placeholders for the class links!
00686         result+=generateMarker(i); // generate marker for entry i in the list
00687                                    // (order is left to right)
00688 
00689         if (i!=numEntries-1)  // not the last entry, so we need a separator
00690         {
00691           if (i<numEntries-2) // not the fore last entry
00692             result+=", ";
00693           else                // the fore last entry
00694             result+=", e ";
00695         }
00696       }
00697       return result;
00698     }
00699 
00703     QCString trInheritsList(int numEntries)
00704     {
00705       return "Eredita da "+trWriteList(numEntries)+".";
00706     }
00707 
00711     QCString trInheritedByList(int numEntries)
00712     {
00713       return "Base per "+trWriteList(numEntries)+".";
00714     }
00715 
00719     QCString trReimplementedFromList(int numEntries)
00720     {
00721       return "Reimplementa "+trWriteList(numEntries)+".";
00722     }
00723 
00727     QCString trReimplementedInList(int numEntries)
00728     {
00729       return "Reimplementata in "+trWriteList(numEntries)+".";
00730     }
00731 
00733     QCString trNamespaceMembers()
00734     { return "Membri dei namespace"; }
00735 
00737     QCString trNamespaceMemberDescription(bool extractAll)
00738     {
00739       QCString result="Questa è la lista ";
00740       if (!extractAll) result+="dei membri dei namespace documentati, ";
00741        else result+="di tutti i membri dei namespace ";
00742       result+="con collegamenti ";
00743       if (extractAll)
00744         result+="alla documentazione del namespace per ciascun membro:";
00745       else
00746         result+="ai namespace a cui appartengono:";
00747       return result;
00748     }
00752     QCString trNamespaceIndex()
00753     { return "Indice dei namespace"; }
00754 
00758     QCString trNamespaceDocumentation()
00759     { return "Documentazione dei namespace"; }
00760 
00762 // new since 0.49-990522
00764 
00768     QCString trNamespaces()
00769     { return "Namespace"; }
00770 
00772 // new since 0.49-990728
00774 
00778     QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
00779         bool single)
00780     { // here s is one of " Class", " Struct" or " Union"
00781       // single is true implies a single file
00782       QCString result=(QCString)"La documentazione per quest";
00783       switch(compType)
00784       {
00785         case ClassDef::Class:      result+="a classe"; break;
00786         case ClassDef::Struct:     result+="a struct"; break;
00787         case ClassDef::Union:      result+="a union"; break;
00788         case ClassDef::Interface:  result+="a interfaccia"; break;
00789         case ClassDef::Protocol:   result+="o protocollo"; break;
00790         case ClassDef::Category:   result+="a categoria"; break;
00791         case ClassDef::Exception:  result+="a eccezione"; break;
00792       }
00793       result+=" è stata generata a partire ";
00794       if (single) result+="dal seguente file:";
00795       else result+="dai seguenti file:";
00796       return result;
00797     }
00798 
00802     QCString trAlphabeticalList()
00803      { return "Lista in ordine alfabetico";}
00804 
00806 // new since 0.49-990901
00808 
00810     QCString trReturnValues()
00811     { return "Valori di ritorno"; }
00812 
00815     QCString trMainPage()
00816     { return "Pagina Principale"; }
00817 
00821     QCString trPageAbbreviation()
00822     { return "pag."; }
00823 
00825 // new since 0.49-991003
00827 
00828     QCString trDefinedAtLineInSourceFile()
00829     {
00830       return "Definizione alla linea @0 del file @1.";
00831     }
00832     QCString trDefinedInSourceFile()
00833     {
00834       return "Definizione nel file @0.";
00835     }
00836 
00838 // new since 0.49-991205
00840 
00841     QCString trDeprecated()
00842     {
00843       return "Deprecato";
00844     }
00845 
00847 // new since 1.0.0
00849 
00851     QCString trCollaborationDiagram(const char *clName)
00852     {
00853       return (QCString)"Diagramma di collaborazione per "+clName+":";
00854     }
00856     QCString trInclDepGraph(const char *fName)
00857     {
00858       return (QCString)"Grafo delle dipendenze di inclusione per "+fName+":";
00859     }
00861     QCString trConstructorDocumentation()
00862     {
00863       return "Documentazione dei costruttori e dei distruttori";
00864     }
00866     QCString trGotoSourceCode()
00867     {
00868       return "Vai al codice sorgente di questo file.";
00869     }
00871     QCString trGotoDocumentation()
00872     {
00873       return "Vai alla documentazione di questo file.";
00874     }
00876     QCString trPrecondition()
00877     {
00878       return "Precondizione";
00879     }
00881     QCString trPostcondition()
00882     {
00883       return "Postcondizione";
00884     }
00886     QCString trInvariant()
00887     {
00888       return "Invariante";
00889     }
00891     QCString trInitialValue()
00892     {
00893       return "Valore iniziale:";
00894     }
00896     QCString trCode()
00897     {
00898       return "codice";
00899     }
00900     QCString trGraphicalHierarchy()
00901     {
00902       return "Grafico della gerarchia delle classi";
00903     }
00904     QCString trGotoGraphicalHierarchy()
00905     {
00906       return "Vai al grafico della gerarchia delle classi";
00907     }
00908     QCString trGotoTextualHierarchy()
00909     {
00910       return "Vai alla gerarchia delle classi (testuale)";
00911     }
00912     QCString trPageIndex()
00913     {
00914       return "Indice delle pagine";
00915     }
00916 
00918 // new since 1.1.0
00920 
00921     QCString trNote()
00922     {
00923       return "Nota";
00924     }
00925     QCString trPublicTypes()
00926     {
00927       return "Tipi pubblici";
00928     }
00929     QCString trPublicAttribs()
00930     {
00931       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00932       {
00933         return "Campi";
00934       }
00935       else
00936       {
00937       return "Attributi pubblici";
00938       }
00939     }
00940 
00941     QCString trStaticPublicAttribs()
00942     {
00943       return "Attributi pubblici statici";
00944     }
00945     QCString trProtectedTypes()
00946     {
00947       return "Tipi protetti";
00948     }
00949     QCString trProtectedAttribs()
00950     {
00951       return "Attributi protetti";
00952     }
00953     QCString trStaticProtectedAttribs()
00954     {
00955       return "Attributi protetti statici";
00956     }
00957     QCString trPrivateTypes()
00958     {
00959       return "Tipi privati";
00960     }
00961     QCString trPrivateAttribs()
00962     {
00963       return "Attributi privati";
00964     }
00965     QCString trStaticPrivateAttribs()
00966     {
00967       return "Attributi privati statici";
00968     }
00969 
00971 // new since 1.1.3
00973 
00975     virtual QCString trTodo()
00976     {
00977       return "Da fare";
00978     }
00980     virtual QCString trTodoList()
00981     {
00982       return "Elenco delle cose da fare";
00983     }
00984 
00986 // new since 1.1.4
00988 
00989     virtual QCString trReferencedBy()
00990     {
00991       return "Referenziato da";
00992     }
00993     virtual QCString trRemarks()
00994     {
00995       return "Osservazioni";
00996     }
00997     virtual QCString trAttention()
00998     {
00999       return "Attenzione";
01000     }
01001     virtual QCString trInclByDepGraph()
01002     {
01003       return "Questo grafo mostra quali altri file includono direttamente o indirettamente questo file:";
01004     }
01005     virtual QCString trSince()
01006     {
01007       return "A partire da";
01008     }
01009 
01011 // new since 1.1.5
01013 
01015     virtual QCString trLegendTitle()
01016     {
01017       return "Legenda del grafo";
01018     }
01020     virtual QCString trLegendDocs()
01021     {
01022       return
01023         "Questa pagina spiega come interpretare i grafi generati da doxygen.<p>\n"
01024         "Considerate l'esempio seguente:\n"
01025         "\\code\n"
01026         "/*! Classe invisibile per troncamento */\n"
01027         "class Invisible { };\n\n"
01028         "/*! Classe troncata, la relazione di ereditarietà e nascosta */\n"
01029         "class Truncated : public Invisible { };\n\n"
01030         "/* Classe non documentata con i commenti speciali di doxygen*/\n"
01031         "class Undocumented { };\n\n"
01032         "/*! Classe che utilizza una ereditarietà pubblica */\n"
01033         "class PublicBase : public Truncated { };\n\n"
01034         "/*! A template class */\n"
01035         "template<class T> class Templ { };\n\n"
01036         "/*! Classe che utilizza una ereditarietà protetta*/\n"
01037         "class ProtectedBase { };\n\n"
01038         "/*! Classe che utilizza una ereditarietà  privata*/\n"
01039         "class PrivateBase { };\n\n"
01040         "/*! Classe utilizzata dalla classe Inherited */\n"
01041         "class Used { };\n\n"
01042         "/*! Classe che eredita da varie classi*/\n"
01043         "class Inherited : public PublicBase,\n"
01044         "                  protected ProtectedBase,\n"
01045         "                  private PrivateBase,\n"
01046         "                  public Undocumented,\n"
01047         "                  public Templ<int>\n"
01048         "{\n"
01049         "  private:\n"
01050         "    Used *m_usedClass;\n"
01051         "};\n"
01052         "\\endcode\n"
01053         "Se il tag \\c MAX_DOT_GRAPH_HEIGHT nel file di configurazione "
01054         "è impostato a 200 verrà prodotto il grafo seguente:"
01055         "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
01056         "<p>\n"
01057         "I riquadri nel grafo qui sopra hanno il seguente significato:\n"
01058         "<ul>\n"
01059         "<li>Il riquadro nero pieno rappresenta la struct o la classe per la quale il grafo è stato generato.\n"
01060         "<li>Un riquadro con un bordo nero denota una struct o una classe documentata.\n"
01061         "<li>Un riquadro con un bordo grigio indica una struct o una classe non documentata.\n"
01062         "<li>Un riquadro con un bordo rosso indica una struct o una classe per la quale non sono mostrate tutte le relazioni di ereditarietà/contenimento (un grafo viene troncato se non rientra nei limiti prestabiliti)."
01063         "</ul>\n"
01064         "Le frecce hanno il seguente significato:\n"
01065         "<ul>\n"
01066         "<li>Una freccia blu scuro indica una relazione di ereditarietà pubblica tra due classi.\n"
01067         "<li>Una freccia verde indica un'ereditarietà protetta.\n"
01068         "<li>Una freccia rossa indica un'ereditarietà privata.\n"
01069         "<li>Una freccia viola tratteggiata indica che una classe è contenuta o usata da un'altra classe."
01070         " La freccia viene etichettata con la o le variabili attraverso cui la struct o la classe puntata dalla freccia è accessibile.\n"
01071         "</ul>\n";
01072     }
01074     virtual QCString trLegend()
01075     {
01076       return "legenda";
01077     }
01078 
01080 // new since 1.2.0
01082 
01084     virtual QCString trTest()
01085     {
01086       return "Test";
01087     }
01089     virtual QCString trTestList()
01090     {
01091       return "Lista dei test";
01092     }
01093 
01095 // new since 1.2.1
01097 
01099     virtual QCString trDCOPMethods()
01100     {
01101       return "Metodi DCOP";
01102     }
01103 
01105 // new since 1.2.2
01107 
01109     virtual QCString trProperties()
01110     {
01111       return "Proprietà";
01112     }
01114     virtual QCString trPropertyDocumentation()
01115     {
01116       return "Documentazione delle proprietà";
01117     }
01118 
01120 // new since 1.2.4
01122 
01124     virtual QCString trClasses()
01125     {
01126       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
01127       {
01128         return "Strutture dati";
01129       }
01130       else
01131       {
01132           return "Classi";
01133       }
01134     }
01136     virtual QCString trPackage(const char *name)
01137     {
01138       return (QCString)"Package "+name;
01139     }
01141     virtual QCString trPackageList()
01142     {
01143       return "Lista dei package";
01144     }
01146     virtual QCString trPackageListDescription()
01147     {
01148       return "Questi sono i package e una loro breve descrizione (se disponibile):";
01149     }
01151     virtual QCString trPackages()
01152     {
01153       return "Package";
01154     }
01156     virtual QCString trDefineValue()
01157     {
01158       return "Valore:";
01159     }
01160 
01162 // new since 1.2.5
01164 
01166     virtual QCString trBug()
01167     {
01168       return "Bug";
01169     }
01171     virtual QCString trBugList()
01172     {
01173       return "Lista dei bug";
01174     }
01175 
01177 // new since 1.2.6
01179 
01181     virtual QCString trRTFansicp()
01182     {
01183       return "1252";
01184     }
01185 
01187     virtual QCString trRTFCharSet()
01188     {
01189       return "0";
01190     }
01191 
01193     virtual QCString trRTFGeneralIndex()
01194     {
01195       return "Indice";
01196     }
01197 
01202     virtual QCString trClass(bool first_capital, bool singular)
01203     {
01204       QCString result((first_capital ? "Class" : "class"));
01205       result+=(singular ? "e" : "i");
01206       return result;
01207     }
01208 
01213     virtual QCString trFile(bool first_capital, bool)
01214     {
01215       QCString result((first_capital ? "File" : "file"));
01216       return result;
01217     }
01218 
01223     virtual QCString trNamespace(bool first_capital, bool)
01224     {
01225       QCString result((first_capital ? "Namespace" : "namespace"));
01226       return result;
01227     }
01228 
01233     virtual QCString trGroup(bool first_capital, bool singular)
01234     {
01235       QCString result((first_capital ? "Grupp" : "grupp"));
01236       result+=(singular ? "o" : "i");
01237       return result;
01238     }
01239 
01244     virtual QCString trPage(bool first_capital, bool singular)
01245     {
01246       QCString result((first_capital ? "Pagin" : "pagin"));
01247       result+=(singular ? "a" : "e");
01248       return result;
01249     }
01250 
01255     virtual QCString trMember(bool first_capital, bool singular)
01256     {
01257       QCString result((first_capital ? "Membr" : "membr"));
01258       result+=(singular ? "o" : "i");
01259       return result;
01260     }
01261 
01266     virtual QCString trGlobal(bool first_capital, bool singular)
01267     {
01268       QCString result((first_capital ? "Global" : "global"));
01269       result+=(singular ? "e" : "i");
01270       return result;
01271     }
01272 
01274 // new since 1.2.7
01276 
01279     virtual QCString trAuthor(bool first_capital, bool singular)
01280     {
01281       QCString result((first_capital ? "Autor" : "autor"));
01282       result+=(singular ? "e" : "i");
01283       return result;
01284     }
01285 
01287 // new since 1.2.11
01289 
01292     virtual QCString trReferences()
01293     {
01294       return "Riferimenti";
01295     }
01296 
01298 // new since 1.2.13
01300 
01304     virtual QCString trImplementedFromList(int numEntries)
01305     {
01306       return "Implementa "+trWriteList(numEntries)+".";
01307     }
01308 
01312     virtual QCString trImplementedInList(int numEntries)
01313     {
01314       return "Implementato in "+trWriteList(numEntries)+".";
01315     }
01316 
01318 // new since 1.2.16
01320 
01324     virtual QCString trRTFTableOfContents()
01325     {
01326       return "Sommario";
01327     }
01328 
01330 // new since 1.2.17
01332 
01336     virtual QCString trDeprecatedList()
01337     {
01338       return "Lista degli elementi deprecati";
01339     }
01340 
01342 // new since 1.2.18
01344 
01348     virtual QCString trEvents()
01349     {
01350       return "Eventi";
01351     }
01353     virtual QCString trEventDocumentation()
01354     {
01355       return "Documentazione degli eventi";
01356     }
01357 
01358 
01360 // new since 1.3
01362 
01365     virtual QCString trPackageTypes()
01366     {
01367       return "Tipi con visibilità di package";
01368     }
01372     virtual QCString trPackageMembers()
01373     {
01374       return "Funzioni con visibilità di package";
01375     }
01379     virtual QCString trStaticPackageMembers()
01380     {
01381       return "Funzioni statiche con visibilità di package";
01382     }
01386     virtual QCString trPackageAttribs()
01387     {
01388       return "Attributi con visibilità di package";
01389     }
01393     virtual QCString trStaticPackageAttribs()
01394     {
01395       return "Attributi statici con visibilità di package";
01396     }
01397 
01399 // new since 1.3.1
01401 
01405     virtual QCString trAll()
01406     {
01407       return "Tutto";
01408     }
01410     virtual QCString trCallGraph()
01411     {
01412       return "Questo è il grafo delle chiamate per questa funzione:";
01413     }
01414 
01416 // new since 1.3.3
01418 
01423     virtual QCString trSearchForIndex()
01424     {
01425       return "Cerca";
01426     }
01430     virtual QCString trSearchResultsTitle()
01431     {
01432       return "Risultati della ricerca";
01433     }
01442     virtual QCString trSearchResults(int numDocuments)
01443     {
01444       if (numDocuments==0)
01445       {
01446         return "Nessun documento soddisfa la tua richiesta.";
01447       }
01448       else if (numDocuments==1)
01449       {
01450         return "Trovato <b>1</b> documento che soddisfa la tua richiesta.";
01451       }
01452       else
01453       {
01454         return "Trovati <b>$num</b> documenti che soddisfano la tua richiesta. "
01455                "Le corrispondenze migliori sono in testa.";
01456       }
01457     }
01461     virtual QCString trSearchMatches()
01462     {
01463       return "Corrispondenze:";
01464     }
01465 
01467 // new since 1.3.8
01469 
01472     virtual QCString trSourceFile(QCString& filename)
01473     {
01474       return " File sorgente " + filename ;
01475     }
01476 
01478 // new since 1.3.9
01480 
01484     virtual QCString trDirIndex()
01485     { return "Gerarchia delle directory"; }
01486 
01490     virtual QCString trDirDocumentation()
01491     { return "Documentazione delle directory"; }
01492 
01496     virtual QCString trDirectories()
01497     { return "Directory"; }
01498 
01502     virtual QCString trDirDescription()
01503     { return "Questa gerarchia di directory è approssimativamente, "
01504         "ma non completamente, ordinata in ordine alfabetico:";
01505     }
01506 
01510     virtual QCString trDirReference(const char *dirName)
01511     { QCString result="Riferimenti per la directory "; result+=dirName; return result; }
01512 
01516     virtual QCString trDir(bool first_capital, bool)
01517     {
01518       QCString result((first_capital ? "Directory" : "directory"));
01519       return result;
01520     }
01521 
01523 // new since 1.4.1
01525 
01529     virtual QCString trOverloadText()
01530     {
01531        return "Questa è una funzione membro sovraccaricata (overloaded), "
01532               "fornita per comodità. Differisce dalla funzione di cui sopra"
01533               "unicamente per gli argomenti passati.";
01534     }
01535 
01537 // new since 1.4.6
01539 
01541     virtual QCString trCallerGraph()
01542     {
01543       return "Questo è il grafo dei chiamanti di questa funzione:";
01544     }
01545 
01549     virtual QCString trEnumerationValueDocumentation()
01550     { return "Documentazione dei tipi enumerati"; }
01551 
01553 // new since 1.5.4 (mainly for Fortran)
01555     
01557     virtual QCString trMemberFunctionDocumentationFortran()
01558     { return "Documentazione delle funzioni membro/subroutine"; }
01559 
01561     virtual QCString trCompoundListFortran()
01562     { return "Elenco dei tipi di dato"; }
01563 
01565     virtual QCString trCompoundMembersFortran()
01566     { return "Membri dei tipi di dato"; }
01567 
01569     virtual QCString trCompoundListDescriptionFortran()
01570     { return "Questi sono i tipi dato con una loro breve descrizione:"; }
01571 
01573     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
01574     {
01575       QCString result="Questa è una lista di tutti i membri ";
01576       if (!extractAll)
01577       {
01578         result+="documentati ";
01579       }
01580       result+="dei tipi di dato con collegamenti ";
01581       if (!extractAll) 
01582       {
01583          result+="alla documentazione della struttura dati per ciascun membro:";
01584       }
01585       else 
01586       {
01587          result+="ai tipi dato a cui appartengono:";
01588       }
01589       return result;
01590     }
01591 
01595     virtual QCString trCompoundIndexFortran()
01596     { return "Indice dei tipi dati"; }
01597 
01601     virtual QCString trTypeDocumentation()
01602     { return "Documentazione dei tipi dato"; }
01603 
01607     virtual QCString trSubprograms()
01608     { return "Funzioni/Subroutine"; }
01609 
01613     virtual QCString trSubprogramDocumentation()
01614     { return "Documentazione funzioni/subroutine"; }
01615 
01619      virtual QCString trDataTypes()
01620     { return "Tipi di dato"; }
01621     
01623     virtual QCString trModulesList()
01624     { return "Elenco dei moduli"; }
01625 
01627     virtual QCString trModulesListDescription(bool extractAll)
01628     {
01629       QCString result="Questa è una lista di tutti i moduli ";
01630       if (!extractAll) result+="documentati ";
01631       result+="con una loro breve descrizione:";
01632       return result;
01633     }
01634 
01636     virtual QCString trCompoundReferenceFortran(const char *clName,
01637                                     ClassDef::CompoundType compType,
01638                                     bool isTemplate)
01639     {
01640       QCString result="Riferimenti per ";
01641       if (isTemplate) result="Template per ";
01642       switch(compType)
01643       {
01644         case ClassDef::Class:      result+=" il modulo"; break;
01645         case ClassDef::Struct:     result+=" il tipo dato"; break;
01646         case ClassDef::Union:      result+=" l'union"; break;
01647         case ClassDef::Interface:  result+=" l'nterfaccia"; break;
01648         case ClassDef::Protocol:   result+=" il protocollo"; break;
01649         case ClassDef::Category:   result+=" la categoria"; break;
01650         case ClassDef::Exception:  result+=" l'eccezione"; break;
01651       }
01652       result+=(QCString)clName;
01653       return result;
01654     }
01655 
01657     virtual QCString trModuleReference(const char *namespaceName)
01658     {
01659       QCString result="Riferimenti per il modulo ";
01660       result+=namespaceName;        
01661       return result;
01662     }
01663     
01665     virtual QCString trModulesMembers()
01666     { return "Membri del modulo"; }
01667 
01669     virtual QCString trModulesMemberDescription(bool extractAll)
01670     { 
01671       QCString result="Questo è un elenco di tutti i membri dei moduli ";
01672       if (!extractAll) result+="documentati ";
01673       result+="con collegamenti ";
01674       if (extractAll) 
01675       {
01676         result+="alla documentazione del modulo per ciascun membro:";
01677       }
01678       else 
01679       {
01680         result+="al modulo a cui appartengono:";
01681       }
01682       return result;
01683     }
01684 
01688     virtual QCString trModulesIndex()
01689     { return "Indice dei moduli"; }
01690     
01695     virtual QCString trModule(bool first_capital, bool singular)
01696     {       
01697       QCString result((first_capital ? "Modul" : "modul"));
01698       if (singular) result+="o";
01699       else result+="i";
01700       return result; 
01701     }
01705     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
01706         bool single)
01707     { // here s is one of " Module", " Struct" or " Union"
01708       // single is true implies a single file
01709       QCString result=(QCString)"La documentazione per quest";
01710       switch(compType)
01711       {
01712         case ClassDef::Class:      result+="o modulo"; break;
01713         case ClassDef::Struct:     result+="o tipo"; break;
01714         case ClassDef::Union:      result+="a union"; break;
01715         case ClassDef::Interface:  result+="a interfaccia"; break;
01716         case ClassDef::Protocol:   result+="o protocollo"; break;
01717         case ClassDef::Category:   result+="a categoria"; break;
01718         case ClassDef::Exception:  result+="a eccezione"; break;
01719       }
01720       result+=" è stata generata a partire ";
01721       if (single) result+="dal seguente file:"; else result+="dai seguenti file:";
01722       return result;
01723     }
01728     virtual QCString trType(bool first_capital, bool singular)
01729     { 
01730       QCString result((first_capital ? "Tip" : "tip"));
01731       if (singular) result+="o";
01732       else result+="i";
01733       return result; 
01734     }
01739     virtual QCString trSubprogram(bool first_capital, bool singular)
01740     { 
01741       QCString result((first_capital ? "Sottoprogramm" : "sottoprogramm"));
01742       if (singular) result+="a";
01743       else result+="i";
01744       return result; 
01745     }
01746 
01748     virtual QCString trTypeConstraints()
01749     {
01750       return "Vincoli dei tipi";
01751     }
01752 
01753 };
01754 
01755 #endif



Generated on Mon Mar 31 10:58:46 2008 by  doxygen 1.5.1