Chameleon

Chameleon Svn Source Tree

Root/branches/xZenu/src/util/doxygen/src/outputlist.h

Source at commit 1322 created 12 years 8 months ago.
By meklort, Add doxygen to utils folder
1/******************************************************************************␊
2 *␊
3 * $Id: outputlist.h,v 1.47 2001/03/19 19:27:41 root Exp $␊
4 *␊
5 * Copyright (C) 1997-2011 by Dimitri van Heesch.␊
6 *␊
7 * Permission to use, copy, modify, and distribute this software and its␊
8 * documentation under the terms of the GNU General Public License is hereby ␊
9 * granted. No representations are made about the suitability of this software ␊
10 * for any purpose. It is provided "as is" without express or implied warranty.␊
11 * See the GNU General Public License for more details.␊
12 *␊
13 * Documents produced by Doxygen are derivative works derived from the␊
14 * input used in their production; they are not affected by this license.␊
15 *␊
16 */␊
17␊
18#ifndef OUTPUTLIST_H␊
19#define OUTPUTLIST_H␊
20␊
21#include "qtbc.h"␊
22#include <qlist.h>␊
23#include "index.h" // for IndexSections␊
24#include "outputgen.h"␊
25␊
26#define FORALLPROTO1(arg1) \␊
27 void forall(void (OutputGenerator::*func)(arg1),arg1)␊
28#define FORALLPROTO2(arg1,arg2) \␊
29 void forall(void (OutputGenerator::*func)(arg1,arg2),arg1,arg2)␊
30#define FORALLPROTO3(arg1,arg2,arg3) \␊
31 void forall(void (OutputGenerator::*func)(arg1,arg2,arg3),arg1,arg2,arg3)␊
32#define FORALLPROTO4(arg1,arg2,arg3,arg4) \␊
33 void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4),arg1,arg2,arg3,arg4)␊
34#define FORALLPROTO5(arg1,arg2,arg3,arg4,arg5) \␊
35 void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4,arg5),arg1,arg2,arg3,arg4,arg5)␊
36 ␊
37class ClassDiagram;␊
38class DotClassGraph;␊
39class DotDirDeps;␊
40class DotInclDepGraph;␊
41class DotGfxHierarchyTable;␊
42class SectionDict;␊
43class DotGroupCollaboration;␊
44␊
45class OutputList : public OutputDocInterface␊
46{␊
47 public:␊
48 OutputList(bool);␊
49 virtual ~OutputList();␊
50␊
51 void add(const OutputGenerator *);␊
52 ␊
53 void disableAllBut(OutputGenerator::OutputType o);␊
54 void enableAll();␊
55 void disableAll();␊
56 void disable(OutputGenerator::OutputType o);␊
57 void enable(OutputGenerator::OutputType o);␊
58 bool isEnabled(OutputGenerator::OutputType o);␊
59 void pushGeneratorState();␊
60 void popGeneratorState();␊
61␊
62␊
63 //////////////////////////////////////////////////␊
64 // OutputDocInterface implementation␊
65 //////////////////////////////////////////////////␊
66␊
67 void parseDoc(const char *fileName,int startLine,␊
68 Definition *ctx,MemberDef *md,const QCString &docStr,␊
69 bool indexWords,bool isExample,const char *exampleName=0,␊
70 bool singleLine=FALSE,bool linkFromIndex=FALSE);␊
71 void parseText(const QCString &textStr);␊
72 ␊
73␊
74 void startIndexSection(IndexSections is)␊
75 { forall(&OutputGenerator::startIndexSection,is); }␊
76 void endIndexSection(IndexSections is)␊
77 { forall(&OutputGenerator::endIndexSection,is); }␊
78 void writePageLink(const char *name,bool first)␊
79 { forall(&OutputGenerator::writePageLink,name,first); }␊
80 void startProjectNumber()␊
81 { forall(&OutputGenerator::startProjectNumber); }␊
82 void endProjectNumber()␊
83 { forall(&OutputGenerator::endProjectNumber); }␊
84 void writeStyleInfo(int part) ␊
85 { forall(&OutputGenerator::writeStyleInfo,part); }␊
86 void startFile(const char *name,const char *manName,const char *title)␊
87 { forall(&OutputGenerator::startFile,name,manName,title); }␊
88 void writeFooter()␊
89 { forall(&OutputGenerator::writeFooter); }␊
90 void endFile() ␊
91 { forall(&OutputGenerator::endFile); }␊
92 void startTitleHead(const char *fileName) ␊
93 { forall(&OutputGenerator::startTitleHead,fileName); }␊
94 void endTitleHead(const char *fileName,const char *name)␊
95 { forall(&OutputGenerator::endTitleHead,fileName,name); }␊
96 void startTitle() ␊
97 { forall(&OutputGenerator::startTitle); }␊
98 void endTitle() ␊
99 { forall(&OutputGenerator::endTitle); }␊
100 //void newParagraph() ␊
101 //{ forall(&OutputGenerator::newParagraph); }␊
102 void startParagraph() ␊
103 { forall(&OutputGenerator::startParagraph); }␊
104 void endParagraph() ␊
105 { forall(&OutputGenerator::endParagraph); }␊
106 void writeString(const char *text) ␊
107 { forall(&OutputGenerator::writeString,text); }␊
108 void startIndexListItem() ␊
109 { forall(&OutputGenerator::startIndexListItem); }␊
110 void endIndexListItem() ␊
111 { forall(&OutputGenerator::endIndexListItem); }␊
112 void startIndexList() ␊
113 { forall(&OutputGenerator::startIndexList); }␊
114 void endIndexList() ␊
115 { forall(&OutputGenerator::endIndexList); }␊
116 void startIndexKey()␊
117 { forall(&OutputGenerator::startIndexKey); }␊
118 void endIndexKey()␊
119 { forall(&OutputGenerator::endIndexKey); }␊
120 void startIndexValue(bool b)␊
121 { forall(&OutputGenerator::startIndexValue,b); }␊
122 void endIndexValue(const char *name,bool b)␊
123 { forall(&OutputGenerator::endIndexValue,name,b); }␊
124 void startItemList() ␊
125 { forall(&OutputGenerator::startItemList); }␊
126 void endItemList() ␊
127 { forall(&OutputGenerator::endItemList); }␊
128 void startIndexItem(const char *ref,const char *file)␊
129 { forall(&OutputGenerator::startIndexItem,ref,file); }␊
130 void endIndexItem(const char *ref,const char *file)␊
131 { forall(&OutputGenerator::endIndexItem,ref,file); }␊
132 void docify(const char *s)␊
133 { forall(&OutputGenerator::docify,s); }␊
134 void codify(const char *s)␊
135 { forall(&OutputGenerator::codify,s); }␊
136 void writeObjectLink(const char *ref,const char *file,␊
137 const char *anchor, const char *name)␊
138 { forall(&OutputGenerator::writeObjectLink,ref,file,anchor,name); }␊
139 void writeCodeLink(const char *ref,const char *file,␊
140 const char *anchor,const char *name,␊
141 const char *tooltip)␊
142 { forall(&OutputGenerator::writeCodeLink,ref,file,anchor,name,tooltip); }␊
143 void startTextLink(const char *file,const char *anchor)␊
144 { forall(&OutputGenerator::startTextLink,file,anchor); }␊
145 void endTextLink()␊
146 { forall(&OutputGenerator::endTextLink); }␊
147 void startHtmlLink(const char *url)␊
148 { forall(&OutputGenerator::startHtmlLink,url); }␊
149 void endHtmlLink()␊
150 { forall(&OutputGenerator::endHtmlLink); }␊
151 void writeStartAnnoItem(const char *type,const char *file, ␊
152 const char *path,const char *name)␊
153 { forall(&OutputGenerator::writeStartAnnoItem,type,file,path,name); }␊
154 void writeEndAnnoItem(const char *name)␊
155 { forall(&OutputGenerator::writeEndAnnoItem,name); }␊
156 void startTypewriter() ␊
157 { forall(&OutputGenerator::startTypewriter); }␊
158 void endTypewriter() ␊
159 { forall(&OutputGenerator::endTypewriter); }␊
160 void startGroupHeader(int extraLevels=0)␊
161 { forall(&OutputGenerator::startGroupHeader,extraLevels); }␊
162 void endGroupHeader(int extraLevels=0)␊
163 { forall(&OutputGenerator::endGroupHeader,extraLevels); }␊
164 //void writeListItem() ␊
165 //{ forall(&OutputGenerator::writeListItem); }␊
166 void startItemListItem() ␊
167 { forall(&OutputGenerator::startItemListItem); }␊
168 void endItemListItem() ␊
169 { forall(&OutputGenerator::endItemListItem); }␊
170 void startMemberSections()␊
171 { forall(&OutputGenerator::startMemberSections); }␊
172 void endMemberSections()␊
173 { forall(&OutputGenerator::endMemberSections); }␊
174 void startHeaderSection()␊
175 { forall(&OutputGenerator::startHeaderSection); }␊
176 void endHeaderSection()␊
177 { forall(&OutputGenerator::endHeaderSection); }␊
178 void startMemberHeader(const char *anchor)␊
179 { forall(&OutputGenerator::startMemberHeader,anchor); }␊
180 void endMemberHeader()␊
181 { forall(&OutputGenerator::endMemberHeader); }␊
182 void startMemberSubtitle()␊
183 { forall(&OutputGenerator::startMemberSubtitle); }␊
184 void endMemberSubtitle()␊
185 { forall(&OutputGenerator::endMemberSubtitle); }␊
186 void startMemberDocList() ␊
187 { forall(&OutputGenerator::startMemberDocList); }␊
188 void endMemberDocList() ␊
189 { forall(&OutputGenerator::endMemberDocList); }␊
190 void startMemberList() ␊
191 { forall(&OutputGenerator::startMemberList); }␊
192 void endMemberList() ␊
193 { forall(&OutputGenerator::endMemberList); }␊
194 void startInlineDescription()␊
195 { forall(&OutputGenerator::startInlineDescription); }␊
196 void endInlineDescription()␊
197 { forall(&OutputGenerator::endInlineDescription); }␊
198 void startInlineHeader()␊
199 { forall(&OutputGenerator::startInlineHeader); }␊
200 void endInlineHeader()␊
201 { forall(&OutputGenerator::endInlineHeader); }␊
202 void startAnonTypeScope(int i1) ␊
203 { forall(&OutputGenerator::startAnonTypeScope,i1); }␊
204 void endAnonTypeScope(int i1) ␊
205 { forall(&OutputGenerator::endAnonTypeScope,i1); }␊
206 void startMemberItem(int i1) ␊
207 { forall(&OutputGenerator::startMemberItem,i1); }␊
208 void endMemberItem() ␊
209 { forall(&OutputGenerator::endMemberItem); }␊
210 void startMemberTemplateParams() ␊
211 { forall(&OutputGenerator::startMemberTemplateParams); }␊
212 void endMemberTemplateParams() ␊
213 { forall(&OutputGenerator::endMemberTemplateParams); }␊
214 void startMemberGroupHeader(bool b) ␊
215 { forall(&OutputGenerator::startMemberGroupHeader,b); }␊
216 void endMemberGroupHeader()␊
217 { forall(&OutputGenerator::endMemberGroupHeader); }␊
218 void startMemberGroupDocs()␊
219 { forall(&OutputGenerator::startMemberGroupDocs); }␊
220 void endMemberGroupDocs()␊
221 { forall(&OutputGenerator::endMemberGroupDocs); }␊
222 void startMemberGroup()␊
223 { forall(&OutputGenerator::startMemberGroup); }␊
224 void endMemberGroup(bool last)␊
225 { forall(&OutputGenerator::endMemberGroup,last); }␊
226 void insertMemberAlign(bool templ=FALSE) ␊
227 { forall(&OutputGenerator::insertMemberAlign,templ); }␊
228 void writeRuler() ␊
229 { forall(&OutputGenerator::writeRuler); }␊
230 void writeAnchor(const char *fileName,const char *name)␊
231 { forall(&OutputGenerator::writeAnchor,fileName,name); }␊
232 void startCodeFragment() ␊
233 { forall(&OutputGenerator::startCodeFragment); }␊
234 void endCodeFragment() ␊
235 { forall(&OutputGenerator::endCodeFragment); }␊
236 void startCodeLine() ␊
237 { forall(&OutputGenerator::startCodeLine); }␊
238 void endCodeLine() ␊
239 { forall(&OutputGenerator::endCodeLine); }␊
240 void writeLineNumber(const char *ref,const char *file,const char *anchor,␊
241 int lineNumber) ␊
242 { forall(&OutputGenerator::writeLineNumber,ref,file,anchor,lineNumber); }␊
243 void startEmphasis() ␊
244 { forall(&OutputGenerator::startEmphasis); }␊
245 void endEmphasis() ␊
246 { forall(&OutputGenerator::endEmphasis); }␊
247 void writeChar(char c)␊
248 { forall(&OutputGenerator::writeChar,c); }␊
249 void startMemberDoc(const char *clName,const char *memName,␊
250 const char *anchor,const char *title,bool showInline)␊
251 { forall(&OutputGenerator::startMemberDoc,clName,memName,anchor,title,showInline); }␊
252 void endMemberDoc(bool hasArgs) ␊
253 { forall(&OutputGenerator::endMemberDoc,hasArgs); }␊
254 void startDoxyAnchor(const char *fName,const char *manName,␊
255 const char *anchor, const char *name,␊
256 const char *args)␊
257 { forall(&OutputGenerator::startDoxyAnchor,fName,manName,anchor,name,args); }␊
258 void endDoxyAnchor(const char *fn,const char *anchor)␊
259 { forall(&OutputGenerator::endDoxyAnchor,fn,anchor); }␊
260 void startCodeAnchor(const char *label)␊
261 { forall(&OutputGenerator::startCodeAnchor,label); }␊
262 void endCodeAnchor()␊
263 { forall(&OutputGenerator::endCodeAnchor); }␊
264 void writeLatexSpacing() ␊
265 { forall(&OutputGenerator::writeLatexSpacing); }␊
266 void startDescription() ␊
267 { forall(&OutputGenerator::startDescription); }␊
268 void endDescription() ␊
269 { forall(&OutputGenerator::endDescription); }␊
270 void startDescItem() ␊
271 { forall(&OutputGenerator::startDescItem); }␊
272 void endDescItem() ␊
273 { forall(&OutputGenerator::endDescItem); }␊
274 void startDescForItem() ␊
275 { forall(&OutputGenerator::startDescForItem); }␊
276 void endDescForItem() ␊
277 { forall(&OutputGenerator::endDescForItem); }␊
278 void startSubsection() ␊
279 { forall(&OutputGenerator::startSubsection); }␊
280 void endSubsection() ␊
281 { forall(&OutputGenerator::endSubsection); }␊
282 void startSubsubsection() ␊
283 { forall(&OutputGenerator::startSubsubsection); }␊
284 void endSubsubsection() ␊
285 { forall(&OutputGenerator::endSubsubsection); }␊
286 void startCenter() ␊
287 { forall(&OutputGenerator::startCenter); }␊
288 void endCenter() ␊
289 { forall(&OutputGenerator::endCenter); }␊
290 void startSmall() ␊
291 { forall(&OutputGenerator::startSmall); }␊
292 void endSmall() ␊
293 { forall(&OutputGenerator::endSmall); }␊
294 void lineBreak(const char *style=0) ␊
295 { forall(&OutputGenerator::lineBreak,style); }␊
296 void startBold() ␊
297 { forall(&OutputGenerator::startBold); }␊
298 void endBold() ␊
299 { forall(&OutputGenerator::endBold); }␊
300 void startMemberDescription() ␊
301 { forall(&OutputGenerator::startMemberDescription); }␊
302 void endMemberDescription() ␊
303 { forall(&OutputGenerator::endMemberDescription); }␊
304 void startSimpleSect(SectionTypes t,const char *file,const char *anchor,␊
305 const char *title) ␊
306 { forall(&OutputGenerator::startSimpleSect,t,file,anchor,title); }␊
307 void endSimpleSect() ␊
308 { forall(&OutputGenerator::endSimpleSect); }␊
309 void startParamList(ParamListTypes t,const char *title) ␊
310 { forall(&OutputGenerator::startParamList,t,title); }␊
311 void endParamList() ␊
312 { forall(&OutputGenerator::endParamList); }␊
313 //void writeDescItem() ␊
314 //{ forall(&OutputGenerator::writeDescItem); }␊
315 void startIndent() ␊
316 { forall(&OutputGenerator::startIndent); }␊
317 void endIndent() ␊
318 { forall(&OutputGenerator::endIndent); }␊
319 void startSection(const char *lab,const char *title,SectionInfo::SectionType t)␊
320 { forall(&OutputGenerator::startSection,lab,title,t); }␊
321 void endSection(const char *lab,SectionInfo::SectionType t)␊
322 { forall(&OutputGenerator::endSection,lab,t); }␊
323 void addIndexItem(const char *s1,const char *s2)␊
324 { forall(&OutputGenerator::addIndexItem,s1,s2); }␊
325 void writeSynopsis() ␊
326 { forall(&OutputGenerator::writeSynopsis); }␊
327 void startClassDiagram()␊
328 { forall(&OutputGenerator::startClassDiagram); }␊
329 void endClassDiagram(const ClassDiagram &d,const char *f,const char *n)␊
330 { forall(&OutputGenerator::endClassDiagram,d,f,n); }␊
331 void startPageRef()␊
332 { forall(&OutputGenerator::startPageRef); }␊
333 void endPageRef(const char *c,const char *a)␊
334 { forall(&OutputGenerator::endPageRef,c,a); }␊
335 void startQuickIndices()␊
336 { forall(&OutputGenerator::startQuickIndices); }␊
337 void endQuickIndices()␊
338 { forall(&OutputGenerator::endQuickIndices); }␊
339 void writeSplitBar(const char *name)␊
340 { forall(&OutputGenerator::writeSplitBar,name); }␊
341 void writeLogo()␊
342 { forall(&OutputGenerator::writeLogo); }␊
343 void writeQuickLinks(bool compact,HighlightedItem hli)␊
344 { forall(&OutputGenerator::writeQuickLinks,compact,hli); }␊
345 void startContents()␊
346 { forall(&OutputGenerator::startContents); }␊
347 void endContents()␊
348 { forall(&OutputGenerator::endContents); }␊
349 void writeNonBreakableSpace(int num)␊
350 { forall(&OutputGenerator::writeNonBreakableSpace,num); }␊
351 void startDescTable()␊
352 { forall(&OutputGenerator::startDescTable); }␊
353 void endDescTable()␊
354 { forall(&OutputGenerator::endDescTable); }␊
355 void startDescTableTitle()␊
356 { forall(&OutputGenerator::startDescTableTitle); }␊
357 void endDescTableTitle()␊
358 { forall(&OutputGenerator::endDescTableTitle); }␊
359 void startDescTableData()␊
360 { forall(&OutputGenerator::startDescTableData); }␊
361 void endDescTableData()␊
362 { forall(&OutputGenerator::endDescTableData); }␊
363 void startDotGraph()␊
364 { forall(&OutputGenerator::startDotGraph); }␊
365 void endDotGraph(const DotClassGraph &g)␊
366 { forall(&OutputGenerator::endDotGraph,g); }␊
367 void startInclDepGraph()␊
368 { forall(&OutputGenerator::startInclDepGraph); }␊
369 void endInclDepGraph(const DotInclDepGraph &g)␊
370 { forall(&OutputGenerator::endInclDepGraph,g); }␊
371 void startCallGraph()␊
372 { forall(&OutputGenerator::startCallGraph); }␊
373 void endCallGraph(const DotCallGraph &g)␊
374 { forall(&OutputGenerator::endCallGraph,g); }␊
375 void startDirDepGraph()␊
376 { forall(&OutputGenerator::startDirDepGraph); }␊
377 void endDirDepGraph(const DotDirDeps &g)␊
378 { forall(&OutputGenerator::endDirDepGraph,g); }␊
379 void startGroupCollaboration()␊
380 { forall(&OutputGenerator::startGroupCollaboration); }␊
381 void endGroupCollaboration(const DotGroupCollaboration &g)␊
382 { forall(&OutputGenerator::endGroupCollaboration,g); }␊
383 void writeGraphicalHierarchy(const DotGfxHierarchyTable &g)␊
384 { forall(&OutputGenerator::writeGraphicalHierarchy,g); }␊
385 void startTextBlock(bool dense=FALSE)␊
386 { forall(&OutputGenerator::startTextBlock,dense); }␊
387 void endTextBlock(bool paraBreak=FALSE)␊
388 { forall(&OutputGenerator::endTextBlock,paraBreak); }␊
389 void lastIndexPage()␊
390 { forall(&OutputGenerator::lastIndexPage); }␊
391 void startMemberDocPrefixItem()␊
392 { forall(&OutputGenerator::startMemberDocPrefixItem); }␊
393 void endMemberDocPrefixItem()␊
394 { forall(&OutputGenerator::endMemberDocPrefixItem); }␊
395 void startMemberDocName(bool align)␊
396 { forall(&OutputGenerator::startMemberDocName,align); }␊
397 void endMemberDocName()␊
398 { forall(&OutputGenerator::endMemberDocName); }␊
399 void startParameterType(bool first,const char *key)␊
400 { forall(&OutputGenerator::startParameterType,first,key); }␊
401 void endParameterType()␊
402 { forall(&OutputGenerator::endParameterType); }␊
403 void startParameterName(bool one)␊
404 { forall(&OutputGenerator::startParameterName,one); }␊
405 void endParameterName(bool last,bool one,bool bracket)␊
406 { forall(&OutputGenerator::endParameterName,last,one,bracket); }␊
407 void startParameterList(bool openBracket)␊
408 { forall(&OutputGenerator::startParameterList,openBracket); }␊
409 void endParameterList()␊
410 { forall(&OutputGenerator::endParameterList); }␊
411␊
412 void startConstraintList(const char *header) ␊
413 { forall(&OutputGenerator::startConstraintList,header); }␊
414 void startConstraintParam() ␊
415 { forall(&OutputGenerator::startConstraintParam); }␊
416 void endConstraintParam() ␊
417 { forall(&OutputGenerator::endConstraintParam); }␊
418 void startConstraintType()␊
419 { forall(&OutputGenerator::startConstraintType); }␊
420 void endConstraintType()␊
421 { forall(&OutputGenerator::endConstraintType); }␊
422 void startConstraintDocs()␊
423 { forall(&OutputGenerator::startConstraintDocs); }␊
424 void endConstraintDocs()␊
425 { forall(&OutputGenerator::endConstraintDocs); }␊
426 void endConstraintList()␊
427 { forall(&OutputGenerator::endConstraintList); }␊
428 void startFontClass(const char *c)␊
429 { forall(&OutputGenerator::startFontClass,c); }␊
430 void endFontClass()␊
431 { forall(&OutputGenerator::endFontClass); }␊
432 void writeCodeAnchor(const char *name)␊
433 { forall(&OutputGenerator::writeCodeAnchor,name); }␊
434 void startPlainFile(const char *name)␊
435 { ␊
436 OutputGenerator *og=outputs->first();␊
437 while (og)␊
438 {␊
439 if (og->isEnabled()) (og->startPlainFile)(name);␊
440 og=outputs->next();␊
441 }␊
442 }␊
443 void endPlainFile() ␊
444 { ␊
445 OutputGenerator *og=outputs->first();␊
446 while (og)␊
447 {␊
448 if (og->isEnabled()) (og->endPlainFile)();␊
449 og=outputs->next();␊
450 }␊
451 }␊
452 void linkableSymbol(int,const char *,Definition *,Definition *) {}␊
453␊
454␊
455␊
456 private:␊
457 void debug();␊
458 void clear();␊
459 ␊
460 void forall(void (OutputGenerator::*func)());␊
461 FORALLPROTO1(const char *);␊
462 FORALLPROTO1(char);␊
463 FORALLPROTO1(IndexSections);␊
464 FORALLPROTO1(int);␊
465 FORALLPROTO1(const DotClassGraph &);␊
466 FORALLPROTO1(const DotInclDepGraph &);␊
467 FORALLPROTO1(const DotCallGraph &);␊
468 FORALLPROTO1(const DotGroupCollaboration &);␊
469 FORALLPROTO1(const DotDirDeps &);␊
470 FORALLPROTO1(const DotGfxHierarchyTable &);␊
471 FORALLPROTO1(SectionTypes);␊
472#if defined(HAS_BOOL_TYPE) || defined(Q_HAS_BOOL_TYPE)␊
473 FORALLPROTO1(bool);␊
474 FORALLPROTO2(bool,int);␊
475 FORALLPROTO2(bool,bool);␊
476 FORALLPROTO4(const char *,const char *,const char *,int);␊
477#endif␊
478 FORALLPROTO2(int,bool);␊
479 FORALLPROTO2(bool,HighlightedItem);␊
480 FORALLPROTO2(bool,const char *);␊
481 FORALLPROTO2(ParamListTypes,const char *);␊
482 FORALLPROTO2(const char *,const char *);␊
483 FORALLPROTO2(const char *,bool);␊
484 FORALLPROTO2(const char *,SectionInfo::SectionType);␊
485 FORALLPROTO3(bool,bool,bool);␊
486 FORALLPROTO3(const char *,const char *,bool);␊
487 FORALLPROTO3(const char *,const char *,SectionInfo::SectionType);␊
488 FORALLPROTO3(uchar,uchar,uchar);␊
489 FORALLPROTO3(const char *,const char *,const char *);␊
490 FORALLPROTO3(const ClassDiagram &,const char *,const char *);␊
491 FORALLPROTO4(SectionTypes,const char *,const char *,const char *);␊
492 FORALLPROTO4(const char *,const char *,const char *,const char *);␊
493 FORALLPROTO4(const char *,const char *,const char *,bool);␊
494 FORALLPROTO5(const char *,const char *,const char *,const char *,const char *);␊
495 FORALLPROTO5(const char *,const char *,const char *,const char *,bool);␊
496 ␊
497 OutputList(const OutputList &ol);␊
498 QList<OutputGenerator> *outputs;␊
499};␊
500␊
501#endif␊
502

Archive Download this file

Revision: 1322