summaryrefslogtreecommitdiffstats
path: root/src/translator_it.h
blob: 74f0b7581be8ecd383eca21cec671699ad260228 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
/******************************************************************************
 *
 * $Id$
 *
 * Copyright (C) 1997-1999 by Dimitri van Heesch.
 *
 * Initial Italian Translation by Ahmed Aldo Faisal
 * Revised and completed by Alessandro Falappa  (June 1999)
 * Updates:
 *		1999/09/10: corrected some small typos in the "new since 0.49-990425" section
 *					added the "new since 0.49-990728" section
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation under the terms of the GNU General Public License is hereby 
 * granted. No representations are made about the suitability of this software 
 * for any purpose. It is provided "as is" without express or implied warranty.
 * See the GNU General Public License for more details.
 *
 * All output generated with Doxygen is not covered by this license.
 *
 */

#ifndef TRANSLATOR_IT_H
#define TRANSLATOR_IT_H

#include "translator.h"

class TranslatorItalian : public Translator
{
  public:
    QCString latexBabelPackage()
    { return "italian"; }
    QCString trInherits()
    { return "eredita"; }
    QCString trAnd()
    { return "e"; }
    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"; }
    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"; }
    QCString trMemberDataDocumentation()
    { return "Documentazione dei dati membro"; }
    QCString trGeneratedFrom(const char *s,bool single)
    { 
      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;
    }
    QCString trMore()
    { return "Continua..."; }
	QCString trReference()
    { return "Riferimento"; }
    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;
    }
    QCString trEnumName()
    { return "nome di tipo enumerato"; }
    QCString trEnumValue()
    { return "valore di tipo enumerato"; }
    QCString trDefinedIn()
    { return "definito in"; }
    QCString trIncludeFile()
    { return "Include il file"; }
    QCString trVerbatimText(const char *f)
    { return (QCString)"Questo è il contenuto integrale dell file "+f+"."; }
    QCString trModules()
    { return "Moduli"; }
    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:";
    }
    QCString trFileListDescription(bool extractAll)
    {
      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;
    }
    QCString trCompoundListDescription()
    { return "Queste sono le classi, structs e "
             "unions con una loro breve descrizione:"; 
    }
    QCString trCompoundMembersDescription(bool extractAll)
    {
      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;
    }
    QCString trFileMembersDescription(bool extractAll)
    {
      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;
    }
    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"; }

    QCString trDocumentation()
    { return "Documentazione"; }
    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"; }

    QCString trDefines()
    { return "Definizioni"; }
    QCString trFuncProtos()
    { return "Prototipi delle funzioni"; }
    QCString trTypedefs()
    { return "Typedefs"; }
    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"; }
    QCString trGeneratedAt(const char *date,const char *projName)
    { 
      QCString result=(QCString)"Generato il "+date;
      if (projName) result+=(QCString)" per "+projName;
      result+=(QCString)" da";
      return result;
    }
    QCString trWrittenBy()
    {
      return "scritto da";
    }
    QCString trClassDiagram(const char *clName)
    {
      return (QCString)"Diagramma delle classi per "+clName;
    }
    QCString trForInternalUseOnly()
    { return "Solo per uso interno."; }
    QCString trReimplementedForInternalReasons()
    { return "Reimplementato per motivi interni; "
             "l'API non è stata modificata."; 
    }
    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 
//////////////////////////////////////////////////////////////////////////
    
    QCString trNamespaces()
    { return "Namespaces"; }
    QCString trNamespaceList()
    { return "Lista dei namespaces"; }
    QCString trNamespaceListDescription(bool extractAll)
    {
      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;
    }
    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 ";
      switch(compType)
      {
        case ClassDef::Class:  result+="la classe "; break;
        case ClassDef::Struct: result+="la struct "; break;
        case ClassDef::Union:  result+="la union "; break;
        case ClassDef::Interface:  result+="l'interfaccia "; 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"; }
	
//////////////////////////////////////////////////////////////////////////
// new since 0.49-990728
//////////////////////////////////////////////////////////////////////////

    /*! This is put at the bottom of a class documentation page and is
     *  followed by a list of files that were used to generate the page.
     */
    virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
        bool single)
    { // here s is one of " Class", " Struct" or " Union"
      // single is true implies a single file
      QCString result=(QCString)"La documentazione per questa ";
      switch(compType)
      {
        case ClassDef::Class:      result+="classe"; break;
        case ClassDef::Struct:     result+="struct"; break;
        case ClassDef::Union:      result+="union"; break;
        case ClassDef::Interface:  result+="interfaccia"; break;
      }
      result+=" è stata generata a partire ";
      if (single) result+="dal seguente file:";
	  else result+="dai seguenti files:";
      return result;
    }

    /*! This is in the (quick) index as a link to the alphabetical compound
     * list.
     */
    virtual QCString trAlphabeticalList()
    {
      return "Lista in ordine alfabetico";
    }

};

#endif